Upload folder using huggingface_hub

ctxstream/src/backend.cpp

@@ -0,0 +1,221 @@
+// Minimal HTTP/1.1 client + just enough JSON to talk to a local model server.
+// No libcurl, no JSON library: the request shape is fixed and only three fields
+// are read back, so a dependency would cost more than it saves.
+#include "ctxstream.hpp"
+
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <cstring>
+#include <sstream>
+#include <string>
+
+namespace ctxstream {
+
+static std::string json_escape(const std::string& s) {
+    std::string o;
+    o.reserve(s.size() + 32);
+    for (unsigned char c : s) {
+        switch (c) {
+            case '"':  o += "\\\""; break;
+            case '\\': o += "\\\\"; break;
+            case '\n': o += "\\n";  break;
+            case '\r': o += "\\r";  break;
+            case '\t': o += "\\t";  break;
+            case '\b': o += "\\b";  break;
+            case '\f': o += "\\f";  break;
+            default:
+                if (c < 0x20) {
+                    char buf[8];
+                    std::snprintf(buf, sizeof buf, "\\u%04x", c);
+                    o += buf;
+                } else {
+                    o += static_cast<char>(c);
+                }
+        }
+    }
+    return o;
+}
+
+// Unescape a JSON string body (the model's reply). Handles the escapes we emit
+// and the \uXXXX that servers produce; non-ASCII code points are passed through
+// as UTF-8.
+static std::string json_unescape(const std::string& s) {
+    std::string o;
+    o.reserve(s.size());
+    for (std::size_t i = 0; i < s.size(); ++i) {
+        if (s[i] != '\\' || i + 1 >= s.size()) { o += s[i]; continue; }
+        const char n = s[++i];
+        switch (n) {
+            case 'n': o += '\n'; break;
+            case 't': o += '\t'; break;
+            case 'r': o += '\r'; break;
+            case 'b': o += '\b'; break;
+            case 'f': o += '\f'; break;
+            case '"': o += '"';  break;
+            case '\\': o += '\\'; break;
+            case '/': o += '/';  break;
+            case 'u': {
+                if (i + 4 >= s.size()) break;
+                const unsigned cp =
+                    std::stoul(s.substr(i + 1, 4), nullptr, 16);
+                i += 4;
+                if (cp < 0x80) {
+                    o += static_cast<char>(cp);
+                } else if (cp < 0x800) {
+                    o += static_cast<char>(0xC0 | (cp >> 6));
+                    o += static_cast<char>(0x80 | (cp & 0x3F));
+                } else {
+                    o += static_cast<char>(0xE0 | (cp >> 12));
+                    o += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                    o += static_cast<char>(0x80 | (cp & 0x3F));
+                }
+                break;
+            }
+            default: o += n;
+        }
+    }
+    return o;
+}
+
+// Extract "key":"..." respecting backslash escapes.
+static bool json_string_field(const std::string& body, const std::string& key,
+                              std::string* out) {
+    const std::string needle = "\"" + key + "\"";
+    std::size_t p = body.find(needle);
+    if (p == std::string::npos) return false;
+    p = body.find(':', p + needle.size());
+    if (p == std::string::npos) return false;
+    while (p < body.size() && (body[++p] == ' ' || body[p] == '\t')) {}
+    if (p >= body.size() || body[p] != '"') return false;
+    const std::size_t start = ++p;
+    for (; p < body.size(); ++p) {
+        if (body[p] == '\\') { ++p; continue; }
+        if (body[p] == '"') break;
+    }
+    if (p >= body.size()) return false;
+    *out = json_unescape(body.substr(start, p - start));
+    return true;
+}
+
+static long json_number_field(const std::string& body, const std::string& key,
+                              long fallback = 0) {
+    const std::string needle = "\"" + key + "\"";
+    std::size_t p = body.find(needle);
+    if (p == std::string::npos) return fallback;
+    p = body.find(':', p + needle.size());
+    if (p == std::string::npos) return fallback;
+    ++p;
+    while (p < body.size() && (body[p] == ' ' || body[p] == '\t')) ++p;
+    const std::size_t start = p;
+    while (p < body.size() && (std::isdigit(static_cast<unsigned char>(body[p])) ||
+                               body[p] == '-' || body[p] == '.')) ++p;
+    if (p == start) return fallback;
+    try { return std::stol(body.substr(start, p - start)); }
+    catch (...) { return fallback; }
+}
+
+static bool http_post(const BackendOptions& opt, const std::string& payload,
+                      std::string* response, std::string* err) {
+    addrinfo hints{};
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    addrinfo* res = nullptr;
+    const std::string port = std::to_string(opt.port);
+    if (getaddrinfo(opt.host.c_str(), port.c_str(), &hints, &res) != 0 || !res) {
+        *err = "getaddrinfo failed for " + opt.host + ":" + port;
+        return false;
+    }
+
+    int fd = -1;
+    for (addrinfo* a = res; a; a = a->ai_next) {
+        fd = ::socket(a->ai_family, a->ai_socktype, a->ai_protocol);
+        if (fd < 0) continue;
+        timeval tv{opt.timeout_sec, 0};
+        setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
+        setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv);
+        if (::connect(fd, a->ai_addr, a->ai_addrlen) == 0) break;
+        ::close(fd);
+        fd = -1;
+    }
+    freeaddrinfo(res);
+    if (fd < 0) { *err = "connect failed to " + opt.host + ":" + port; return false; }
+
+    std::ostringstream req;
+    req << "POST " << opt.path << " HTTP/1.1\r\n"
+        << "Host: " << opt.host << ":" << opt.port << "\r\n"
+        << "Content-Type: application/json\r\n"
+        << "Content-Length: " << payload.size() << "\r\n"
+        << "Connection: close\r\n\r\n"
+        << payload;
+    const std::string raw = req.str();
+
+    for (std::size_t sent = 0; sent < raw.size();) {
+        const ssize_t n = ::send(fd, raw.data() + sent, raw.size() - sent, 0);
+        if (n <= 0) { ::close(fd); *err = "send failed"; return false; }
+        sent += static_cast<std::size_t>(n);
+    }
+
+    std::string all;
+    char buf[16384];
+    for (;;) {
+        const ssize_t n = ::recv(fd, buf, sizeof buf, 0);
+        if (n < 0) { ::close(fd); *err = "recv timeout/error"; return false; }
+        if (n == 0) break;
+        all.append(buf, static_cast<std::size_t>(n));
+    }
+    ::close(fd);
+
+    const std::size_t hdr = all.find("\r\n\r\n");
+    if (hdr == std::string::npos) { *err = "malformed HTTP response"; return false; }
+    *response = all.substr(hdr + 4);
+    return true;
+}
+
+Completion complete(const BackendOptions& opt, const std::string& system_prompt,
+                    const std::string& user_prompt) {
+    Completion c;
+    std::ostringstream body;
+    body << "{\"model\":\"" << json_escape(opt.model) << "\","
+         << "\"stream\":false,"
+         << "\"options\":{\"num_ctx\":" << opt.num_ctx
+         << ",\"num_predict\":" << opt.num_predict
+         << ",\"temperature\":0},"
+         << "\"messages\":[";
+    if (!system_prompt.empty()) {
+        body << "{\"role\":\"system\",\"content\":\"" << json_escape(system_prompt)
+             << "\"},";
+    }
+    body << "{\"role\":\"user\",\"content\":\"" << json_escape(user_prompt)
+         << "\"}]}";
+
+    std::string resp;
+    if (!http_post(opt, body.str(), &resp, &c.error)) return c;
+
+    std::string err;
+    if (json_string_field(resp, "error", &err) && !err.empty()) {
+        c.error = "server: " + err;
+        return c;
+    }
+    if (!json_string_field(resp, "content", &c.text)) {
+        c.error = "no content field in response: " + resp.substr(0, 200);
+        return c;
+    }
+    c.prompt_tokens = json_number_field(resp, "prompt_eval_count");
+    c.output_tokens = json_number_field(resp, "eval_count");
+    c.ok = true;
+    return c;
+}
+
+bool looks_truncated(std::size_t prompt_chars, long prompt_tokens) {
+    if (prompt_tokens <= 0) return false;  // server did not report; cannot judge
+    // Deliberately loose: no real tokenizer reaches 5 chars/token, so this fires
+    // only on gross clipping (measured: 50,000 tokens sent, 16,387 processed),
+    // never on tokenizer variance.
+    return static_cast<std::size_t>(prompt_tokens) < prompt_chars / 5;
+}
+
+}  // namespace ctxstream

ctxstream/src/codegraph.cpp

@@ -0,0 +1,321 @@
+// Code graph: scan a repo, find symbols and file-to-file edges, then segment
+// along that structure instead of along character offsets.
+//
+// Deliberately lexical, not a parser. A real parse (tree-sitter, clang) is a
+// dependency and a build burden, and the segmentation only needs to know where
+// a symbol starts and which files reference which. Heuristics that are right
+// most of the time produce better segments than exact offsets would, because
+// the consumer is a language model reading the text anyway.
+#include "ctxstream.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <filesystem>
+#include <fstream>
+#include <map>
+#include <regex>
+#include <set>
+#include <sstream>
+
+namespace fs = std::filesystem;
+
+namespace ctxstream {
+
+static std::string lang_of(const std::string& ext) {
+    static const std::map<std::string, std::string> m = {
+        {".c", "c"}, {".h", "c"}, {".cpp", "cpp"}, {".cc", "cpp"},
+        {".hpp", "cpp"}, {".hh", "cpp"}, {".cxx", "cpp"},
+        {".py", "python"}, {".pyi", "python"},
+        {".js", "js"}, {".mjs", "js"}, {".ts", "ts"}, {".tsx", "ts"},
+        {".go", "go"}, {".rs", "rust"}, {".java", "java"},
+        {".rb", "ruby"}, {".sh", "shell"}, {".bash", "shell"},
+        {".cs", "csharp"}, {".kt", "kotlin"}, {".swift", "swift"},
+        {".php", "php"}, {".lua", "lua"}, {".m", "objc"},
+    };
+    const auto it = m.find(ext);
+    return it == m.end() ? std::string() : it->second;
+}
+
+static bool looks_binary(const std::string& head) {
+    for (unsigned char c : head) {
+        if (c == 0) return true;
+    }
+    return false;
+}
+
+static std::string read_file(const fs::path& p, std::size_t cap, bool* too_big) {
+    std::error_code ec;
+    const auto sz = fs::file_size(p, ec);
+    if (!ec && sz > cap) { *too_big = true; return {}; }
+    std::ifstream in(p, std::ios::binary);
+    if (!in) return {};
+    std::ostringstream ss;
+    ss << in.rdbuf();
+    return ss.str();
+}
+
+// One pattern per language family. Captures the symbol name in group 1.
+static const std::vector<std::pair<std::regex, NodeKind>>& defs_for(
+    const std::string& lang) {
+    static const std::vector<std::pair<std::regex, NodeKind>> c_like = {
+        {std::regex(R"(^\s*(?:class)\s+([A-Za-z_][A-Za-z0-9_]*))"), NodeKind::Class},
+        {std::regex(R"(^\s*(?:struct)\s+([A-Za-z_][A-Za-z0-9_]*))"), NodeKind::Struct},
+        // return-type name(...) at line start, not a call or control keyword
+        {std::regex(R"(^[A-Za-z_][A-Za-z0-9_:<>,\s\*&]*\s[\*&]?([A-Za-z_][A-Za-z0-9_]*)\s*\([^;]*\)\s*(?:const)?\s*\{)"),
+         NodeKind::Function},
+    };
+    static const std::vector<std::pair<std::regex, NodeKind>> python = {
+        {std::regex(R"(^\s*class\s+([A-Za-z_][A-Za-z0-9_]*))"), NodeKind::Class},
+        {std::regex(R"(^\s*(?:async\s+)?def\s+([A-Za-z_][A-Za-z0-9_]*))"), NodeKind::Function},
+    };
+    static const std::vector<std::pair<std::regex, NodeKind>> js_like = {
+        {std::regex(R"(^\s*(?:export\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*))"), NodeKind::Class},
+        {std::regex(R"(^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*))"), NodeKind::Function},
+        {std::regex(R"(^\s*(?:export\s+)?const\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\()"), NodeKind::Function},
+    };
+    static const std::vector<std::pair<std::regex, NodeKind>> go_like = {
+        {std::regex(R"(^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_][A-Za-z0-9_]*))"), NodeKind::Function},
+        {std::regex(R"(^\s*type\s+([A-Za-z_][A-Za-z0-9_]*)\s+struct)"), NodeKind::Struct},
+    };
+    static const std::vector<std::pair<std::regex, NodeKind>> rust_like = {
+        {std::regex(R"(^\s*(?:pub\s+)?fn\s+([A-Za-z_][A-Za-z0-9_]*))"), NodeKind::Function},
+        {std::regex(R"(^\s*(?:pub\s+)?struct\s+([A-Za-z_][A-Za-z0-9_]*))"), NodeKind::Struct},
+    };
+    static const std::vector<std::pair<std::regex, NodeKind>> none;
+    if (lang == "c" || lang == "cpp" || lang == "java" || lang == "csharp") return c_like;
+    if (lang == "python") return python;
+    if (lang == "js" || lang == "ts") return js_like;
+    if (lang == "go") return go_like;
+    if (lang == "rust") return rust_like;
+    return none;
+}
+
+// #include "x.h" / import x / from x import / require('x')
+static std::vector<std::string> imports_of(const std::string& text,
+                                           const std::string& lang) {
+    static const std::regex inc_c(R"(^\s*#\s*include\s*[\"<]([^\">]+)[\">])");
+    static const std::regex imp_py(R"(^\s*(?:from\s+([A-Za-z0-9_.]+)\s+import|import\s+([A-Za-z0-9_.]+)))");
+    static const std::regex imp_js(R"((?:from\s*[\"']([^\"']+)[\"']|require\(\s*[\"']([^\"']+)[\"']\s*\)))");
+    std::vector<std::string> out;
+    std::istringstream in(text);
+    std::string line;
+    while (std::getline(in, line)) {
+        std::smatch m;
+        if ((lang == "c" || lang == "cpp") && std::regex_search(line, m, inc_c)) {
+            out.push_back(m[1].str());
+        } else if (lang == "python" && std::regex_search(line, m, imp_py)) {
+            out.push_back(m[1].matched ? m[1].str() : m[2].str());
+        } else if ((lang == "js" || lang == "ts") && std::regex_search(line, m, imp_js)) {
+            out.push_back(m[1].matched ? m[1].str() : m[2].str());
+        }
+    }
+    return out;
+}
+
+CodeGraph scan_repo(const std::string& root, const ScanOptions& opt) {
+    CodeGraph g;
+    g.root = root;
+    const std::set<std::string> excluded(opt.exclude_dirs.begin(),
+                                         opt.exclude_dirs.end());
+    // path (as written in imports) -> file id, for edge resolution
+    std::map<std::string, int> by_stem;
+    std::vector<std::string> texts;
+
+    std::error_code ec;
+    auto it = fs::recursive_directory_iterator(
+        root,
+        opt.follow_symlinks ? fs::directory_options::follow_directory_symlink
+                            : fs::directory_options::skip_permission_denied,
+        ec);
+    if (ec) return g;
+
+    for (fs::recursive_directory_iterator end; it != end; it.increment(ec)) {
+        if (ec) { ec.clear(); continue; }
+        const fs::path p = it->path();
+        if (it->is_directory(ec)) {
+            if (excluded.count(p.filename().string())) it.disable_recursion_pending();
+            continue;
+        }
+        if (!it->is_regular_file(ec)) continue;
+        const std::string lang = lang_of(p.extension().string());
+        if (lang.empty()) continue;
+
+        bool too_big = false;
+        const std::string text = read_file(p, opt.max_file_bytes, &too_big);
+        const std::string rel = fs::relative(p, root, ec).string();
+        if (too_big) { g.skipped.emplace_back(rel, "over max_file_bytes"); continue; }
+        if (text.empty()) { g.skipped.emplace_back(rel, "empty or unreadable"); continue; }
+        if (looks_binary(text.substr(0, 512))) {
+            g.skipped.emplace_back(rel, "binary");
+            continue;
+        }
+
+        FileNode f;
+        f.id = static_cast<int>(g.files.size());
+        f.path = rel;
+        f.language = lang;
+        f.bytes = text.size();
+        g.files.push_back(f);
+        texts.push_back(text);
+        by_stem[p.filename().string()] = f.id;
+        by_stem[p.stem().string()] = f.id;
+    }
+
+    // Symbols
+    for (std::size_t fi = 0; fi < g.files.size(); ++fi) {
+        const auto& pats = defs_for(g.files[fi].language);
+        if (pats.empty()) continue;
+        const std::string& text = texts[fi];
+        std::size_t off = 0;
+        int line_no = 0;
+        std::istringstream in(text);
+        std::string line;
+        while (std::getline(in, line)) {
+            ++line_no;
+            for (const auto& [re, kind] : pats) {
+                std::smatch m;
+                if (std::regex_search(line, m, re)) {
+                    SymbolNode s;
+                    s.id = static_cast<int>(g.symbols.size());
+                    s.kind = kind;
+                    s.name = m[1].str();
+                    s.file = static_cast<int>(fi);
+                    s.line = line_no;
+                    s.offset = off;
+                    g.symbols.push_back(s);
+                    g.files[fi].symbols++;
+                    break;
+                }
+            }
+            off += line.size() + 1;
+        }
+    }
+
+    // Edges from imports/includes, resolved by filename or stem.
+    std::set<std::pair<int, int>> seen;
+    for (std::size_t fi = 0; fi < g.files.size(); ++fi) {
+        for (const std::string& imp : imports_of(texts[fi], g.files[fi].language)) {
+            fs::path ip(imp);
+            for (const std::string& key : {ip.filename().string(), ip.stem().string()}) {
+                const auto hit = by_stem.find(key);
+                if (hit == by_stem.end() || hit->second == static_cast<int>(fi)) continue;
+                if (!seen.insert({static_cast<int>(fi), hit->second}).second) break;
+                g.edges.push_back({static_cast<int>(fi), hit->second, EdgeKind::Includes});
+                break;
+            }
+        }
+    }
+    return g;
+}
+
+std::string graph_summary(const CodeGraph& g) {
+    std::map<std::string, int> per_lang;
+    std::size_t bytes = 0;
+    for (const auto& f : g.files) { per_lang[f.language]++; bytes += f.bytes; }
+    std::ostringstream o;
+    o << "files=" << g.files.size() << " symbols=" << g.symbols.size()
+      << " edges=" << g.edges.size() << " bytes=" << bytes
+      << " skipped=" << g.skipped.size() << " langs=";
+    bool first = true;
+    for (const auto& [l, n] : per_lang) {
+        o << (first ? "" : ",") << l << ":" << n;
+        first = false;
+    }
+    return o.str();
+}
+
+// Dependency-first ordering: a file appears after the files it includes, so a
+// segment carrying a caller has a decent chance of following its callee. Cycles
+// are broken arbitrarily rather than dropped -- coverage matters more than order.
+static std::vector<int> topo_order(const CodeGraph& g) {
+    const int n = static_cast<int>(g.files.size());
+    std::vector<std::vector<int>> out(n);
+    std::vector<int> indeg(n, 0);
+    for (const auto& e : g.edges) {
+        if (e.from == e.to) continue;
+        out[e.to].push_back(e.from);   // dependency -> dependent
+        indeg[e.from]++;
+    }
+    std::vector<int> ready, order;
+    for (int i = 0; i < n; ++i) {
+        if (indeg[i] == 0) ready.push_back(i);
+    }
+    std::vector<bool> done(n, false);
+    while (!ready.empty()) {
+        const int v = ready.back();
+        ready.pop_back();
+        if (done[v]) continue;
+        done[v] = true;
+        order.push_back(v);
+        for (int w : out[v]) {
+            if (--indeg[w] == 0) ready.push_back(w);
+        }
+    }
+    for (int i = 0; i < n; ++i) {
+        if (!done[i]) order.push_back(i);  // cycle members
+    }
+    return order;
+}
+
+std::vector<Segment> plan_codebase(const CodeGraph& g, const ManifestOptions& opt,
+                                   std::string* packed_text) {
+    packed_text->clear();
+    std::vector<Segment> segs;
+    if (g.files.empty()) return segs;
+
+    // Pack files in dependency order into one buffer with explicit headers, so
+    // the model always knows which file a fragment came from, then cut segments
+    // on file boundaries.
+    struct Placed { std::size_t start, end; };
+    std::vector<Placed> placed;
+    placed.reserve(g.files.size());
+
+    for (int fi : topo_order(g)) {
+        const FileNode& f = g.files[fi];
+        std::error_code ec;
+        std::ifstream in(fs::path(g.root) / f.path, std::ios::binary);
+        std::ostringstream ss;
+        ss << in.rdbuf();
+        const std::size_t start = packed_text->size();
+        *packed_text += "\n===== FILE " + f.path + " (" + f.language + ") =====\n";
+        *packed_text += ss.str();
+        placed.push_back({start, packed_text->size()});
+    }
+
+    // Greedy: accumulate whole files until the next one would overflow.
+    int index = 0;
+    std::size_t seg_start = 0;
+    for (std::size_t i = 0; i < placed.size(); ++i) {
+        const std::size_t seg_end = placed[i].end;
+        const bool last = (i + 1 == placed.size());
+        const std::size_t next_end = last ? seg_end : placed[i + 1].end;
+
+        if (last || next_end - seg_start > opt.segment_chars) {
+            Segment s;
+            s.index = index++;
+            s.offset = seg_start;
+            s.length = seg_end - seg_start;
+            s.overlap_prefix = 0;
+            segs.push_back(s);
+            seg_start = seg_end;
+        }
+    }
+
+    // A single file larger than a segment still has to be split; fall back to
+    // line-boundary cutting inside it rather than dropping it.
+    std::vector<Segment> final_segs;
+    for (const Segment& s : segs) {
+        if (s.length <= opt.segment_chars) { final_segs.push_back(s); continue; }
+        const std::string sub = packed_text->substr(s.offset, s.length);
+        for (Segment inner : plan(sub, opt)) {
+            inner.offset += s.offset;
+            final_segs.push_back(inner);
+        }
+    }
+    for (std::size_t i = 0; i < final_segs.size(); ++i) {
+        final_segs[i].index = static_cast<int>(i);
+    }
+    return final_segs;
+}
+
+}  // namespace ctxstream

ctxstream/src/ctxstream.hpp

@@ -0,0 +1,208 @@
+// ctxstream -- treat an oversized context like a video stream.
+//
+// The failure this exists to fix, measured on a 4B model over a 261,226-token
+// corpus on a 6GB card: the model swept every segment correctly and then, asked
+// which label was least common, replied "Status: beta, Status: delta, Status:
+// gamma, Status: alpha". It listed the candidates instead of selecting. Earlier
+// runs with more segments combined 65 partial counts wrongly.
+//
+// Both failures are the same mistake in the harness, not the model: a language
+// model was asked to plan a traversal and to aggregate arithmetic. Streaming
+// splits those out.
+//
+//   manifest   segments planned in code, up front, deterministic
+//   buffer     N segments in flight, latency hidden behind compute
+//   decode     model sees ONE segment, emits STRUCTURED records, never prose
+//   reduce     aggregation in code, over parsed records
+//
+// The model's only job is extraction from a window it comfortably fits.
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace ctxstream {
+
+// ---------------------------------------------------------------- manifest
+
+struct Segment {
+    int index = 0;
+    std::size_t offset = 0;
+    std::size_t length = 0;
+    // Segments may overlap so a record straddling a boundary is seen whole by at
+    // least one segment. The reducer dedupes on record identity.
+    std::size_t overlap_prefix = 0;
+};
+
+struct ManifestOptions {
+    // Sized to what the serving model actually fits, not what it advertises.
+    // Measured: gemma4:e4b holds 32,768 tokens in 3.3GB on a 6GB card.
+    std::size_t segment_chars = 60000;
+    std::size_t overlap_chars = 400;
+    // Prefer splitting on a record boundary within this slack of the target, so
+    // segments do not cut a row in half.
+    std::size_t boundary_slack = 4000;
+    std::string record_delim = "\n";
+};
+
+// Deterministic. No model call. Runs before anything is dispatched, which is
+// the point: the plan cannot be wrong in a way the model has to recover from.
+std::vector<Segment> plan(const std::string& text, const ManifestOptions& opt);
+
+std::string segment_text(const std::string& text, const Segment& s);
+
+// ---------------------------------------------------------------- codegraph
+//
+// A codebase is not a character stream. Cutting it every N chars splits
+// functions, separates a call from its definition, and hands the model
+// fragments no human would review. When the input is a directory, the default
+// path is: scan -> graph -> segment along graph structure -> stream.
+
+enum class NodeKind { File, Function, Class, Struct, Other };
+
+struct SymbolNode {
+    int id = 0;
+    NodeKind kind = NodeKind::Other;
+    std::string name;
+    int file = 0;          // index into CodeGraph::files
+    int line = 0;
+    std::size_t offset = 0;
+    std::size_t length = 0;
+};
+
+enum class EdgeKind { Includes, References };
+
+struct GraphEdge {
+    int from = 0;          // file index
+    int to = 0;            // file index
+    EdgeKind kind = EdgeKind::Includes;
+};
+
+struct FileNode {
+    int id = 0;
+    std::string path;      // relative to the scanned root
+    std::string language;
+    std::size_t bytes = 0;
+    int symbols = 0;
+};
+
+struct CodeGraph {
+    std::string root;
+    std::vector<FileNode> files;
+    std::vector<SymbolNode> symbols;
+    std::vector<GraphEdge> edges;
+    // Files skipped and why, so a sweep can never silently miss part of the
+    // repo and still report a confident answer.
+    std::vector<std::pair<std::string, std::string>> skipped;
+};
+
+struct ScanOptions {
+    std::size_t max_file_bytes = 2u * 1024 * 1024;
+    std::vector<std::string> exclude_dirs = {
+        ".git", "node_modules", "build", "dist", "__pycache__", ".venv",
+        "venv", "target", ".mypy_cache", ".pytest_cache", "vendor"};
+    bool follow_symlinks = false;
+};
+
+CodeGraph scan_repo(const std::string& root, const ScanOptions& opt);
+
+// Segments that respect the graph: a file is never split mid-symbol, and files
+// are ordered so that a file follows the ones it includes wherever the include
+// graph is acyclic. Large files fall back to symbol-boundary splitting.
+std::vector<Segment> plan_codebase(const CodeGraph& g,
+                                   const ManifestOptions& opt,
+                                   std::string* packed_text);
+
+std::string graph_summary(const CodeGraph& g);
+
+// ---------------------------------------------------------------- backend
+
+struct Completion {
+    std::string text;
+    long prompt_tokens = 0;   // 0 when the server does not report it
+    long output_tokens = 0;
+    bool ok = false;
+    std::string error;
+};
+
+struct BackendOptions {
+    std::string host = "127.0.0.1";
+    int port = 11434;
+    std::string model = "gemma4:e4b";
+    std::string path = "/api/chat";  // native route: honours num_ctx AND reports
+                                     // prompt_eval_count. The OpenAI-compatible
+                                     // route silently ignores num_ctx.
+    int num_ctx = 32768;
+    int num_predict = 1024;
+    int timeout_sec = 900;
+};
+
+Completion complete(const BackendOptions& opt,
+                    const std::string& system_prompt,
+                    const std::string& user_prompt);
+
+// Guard against the failure that produced a confident answer from a fragment:
+// a server that quietly clips the prompt and never says so. Returns true when
+// the reported prompt token count is implausibly small for what was sent.
+bool looks_truncated(std::size_t prompt_chars, long prompt_tokens);
+
+// ---------------------------------------------------------------- pipeline
+
+struct SegmentResult {
+    int index = 0;
+    std::string raw;          // exactly what the model returned
+    bool ok = false;
+    bool truncated = false;
+    std::string error;
+    long prompt_tokens = 0;
+    long output_tokens = 0;
+    double seconds = 0.0;
+};
+
+struct PipelineOptions {
+    // Segments in flight. Buffering, in the video sense: keeps the model busy
+    // while the next prompt is being assembled.
+    int concurrency = 2;
+    int max_retries = 2;
+    bool verbose = true;
+};
+
+// Streams every segment through the model. Returns results in segment order.
+// Never aggregates, never interprets -- that is the reducer's job.
+std::vector<SegmentResult> stream(const std::string& text,
+                                  const std::vector<Segment>& segments,
+                                  const std::string& extract_prompt,
+                                  const BackendOptions& backend,
+                                  const PipelineOptions& pipe);
+
+// ---------------------------------------------------------------- reduce
+
+// One parsed record from a segment. The extraction prompt asks for
+// "<key>\t<count>" lines, which is cheap for a small model to emit correctly
+// and unambiguous to parse -- unlike prose summaries.
+struct Record {
+    std::string key;
+    double value = 0.0;
+};
+
+std::vector<Record> parse_records(const std::string& raw);
+
+struct Tally {
+    std::vector<std::pair<std::string, double>> sorted;  // ascending by value
+    double total = 0.0;
+    int parsed_records = 0;
+    int unparsed_lines = 0;
+};
+
+// Sums per key across every segment. This is the step the model kept getting
+// wrong; here it is a loop.
+Tally tally(const std::vector<SegmentResult>& results);
+
+// Answer construction is chosen explicitly, after the sweep -- not improvised
+// by the model mid-traversal.
+enum class Answer { Least, Most, Total, List };
+
+std::string construct(const Tally& t, Answer how, const std::string& label = "Answer");
+
+}  // namespace ctxstream

ctxstream/src/main.cpp

@@ -0,0 +1,162 @@
+#include "ctxstream.hpp"
+
+#include <chrono>
+#include <cstdio>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace fs = std::filesystem;
+using namespace ctxstream;
+
+static void usage() {
+    std::fprintf(stderr,
+        "ctxstream -- stream an oversized context past a small model, reduce in code.\n\n"
+        "Usage:\n"
+        "  ctxstream --input <file|dir> --extract <prompt> [options]\n\n"
+        "A directory input builds a code graph first and segments along it.\n\n"
+        "Options:\n"
+        "  --input PATH        file, or directory for codebase mode\n"
+        "  --extract PROMPT    what each fragment should emit as <key>\\t<number>\n"
+        "  --answer MODE       least | most | total | list   (default: list)\n"
+        "  --label TEXT        answer label                  (default: Answer)\n"
+        "  --model NAME        ollama model                  (default: gemma4:e4b)\n"
+        "  --host H --port P   model server        (default: 127.0.0.1:11434)\n"
+        "  --num-ctx N         per-call window                (default: 32768)\n"
+        "  --segment-chars N   fragment size                  (default: 60000)\n"
+        "  --concurrency N     fragments in flight            (default: 2)\n"
+        "  --plan-only         print the plan and exit, no model calls\n"
+        "  --graph-only        print the code graph and exit\n"
+        "  --quiet             suppress progress\n");
+}
+
+static std::string slurp(const fs::path& p) {
+    std::ifstream in(p, std::ios::binary);
+    std::ostringstream ss;
+    ss << in.rdbuf();
+    return ss.str();
+}
+
+int main(int argc, char** argv) {
+    std::string input, extract, answer_mode = "list", label = "Answer";
+    BackendOptions backend;
+    ManifestOptions manifest;
+    PipelineOptions pipe;
+    bool plan_only = false, graph_only = false;
+
+    for (int i = 1; i < argc; ++i) {
+        const std::string a = argv[i];
+        auto next = [&]() -> std::string {
+            return (i + 1 < argc) ? argv[++i] : std::string();
+        };
+        if (a == "--input") input = next();
+        else if (a == "--extract") extract = next();
+        else if (a == "--answer") answer_mode = next();
+        else if (a == "--label") label = next();
+        else if (a == "--model") backend.model = next();
+        else if (a == "--host") backend.host = next();
+        else if (a == "--port") backend.port = std::stoi(next());
+        else if (a == "--num-ctx") backend.num_ctx = std::stoi(next());
+        else if (a == "--segment-chars") manifest.segment_chars = std::stoul(next());
+        else if (a == "--concurrency") pipe.concurrency = std::stoi(next());
+        else if (a == "--plan-only") plan_only = true;
+        else if (a == "--graph-only") graph_only = true;
+        else if (a == "--quiet") pipe.verbose = false;
+        else if (a == "-h" || a == "--help") { usage(); return 0; }
+        else { std::fprintf(stderr, "unknown option: %s\n", a.c_str()); usage(); return 2; }
+    }
+    if (input.empty()) { usage(); return 2; }
+
+    std::error_code ec;
+    if (!fs::exists(input, ec)) {
+        std::fprintf(stderr, "no such input: %s\n", input.c_str());
+        return 2;
+    }
+
+    std::string text;
+    std::vector<Segment> segments;
+    const bool codebase = fs::is_directory(input, ec);
+
+    if (codebase) {
+        // Default path for a repo: graph first, then segment along it.
+        const CodeGraph g = scan_repo(input, ScanOptions{});
+        std::fprintf(stderr, "[ctxstream] graph %s\n", graph_summary(g).c_str());
+        for (const auto& [p, why] : g.skipped) {
+            std::fprintf(stderr, "[ctxstream] skipped %s (%s)\n", p.c_str(), why.c_str());
+        }
+        if (graph_only) {
+            for (const auto& f : g.files) {
+                std::printf("FILE\t%s\t%s\t%zu\t%d\n", f.path.c_str(),
+                            f.language.c_str(), f.bytes, f.symbols);
+            }
+            for (const auto& s : g.symbols) {
+                std::printf("SYM\t%s\t%s:%d\n", s.name.c_str(),
+                            g.files[s.file].path.c_str(), s.line);
+            }
+            for (const auto& e : g.edges) {
+                std::printf("EDGE\t%s\t->\t%s\n", g.files[e.from].path.c_str(),
+                            g.files[e.to].path.c_str());
+            }
+            return 0;
+        }
+        if (g.files.empty()) {
+            std::fprintf(stderr, "no source files found under %s\n", input.c_str());
+            return 1;
+        }
+        segments = plan_codebase(g, manifest, &text);
+    } else {
+        text = slurp(input);
+        if (text.empty()) { std::fprintf(stderr, "empty input\n"); return 1; }
+        segments = plan(text, manifest);
+    }
+
+    std::fprintf(stderr, "[ctxstream] %zu chars -> %zu segments (<=%zu chars each)\n",
+                 text.size(), segments.size(), manifest.segment_chars);
+    if (plan_only) {
+        for (const auto& s : segments) {
+            std::printf("SEG\t%d\t%zu\t%zu\n", s.index, s.offset, s.length);
+        }
+        return 0;
+    }
+    if (extract.empty()) {
+        std::fprintf(stderr, "--extract is required unless --plan-only/--graph-only\n");
+        return 2;
+    }
+
+    const auto t0 = std::chrono::steady_clock::now();
+    const std::vector<SegmentResult> results =
+        stream(text, segments, extract, backend, pipe);
+
+    int failed = 0;
+    for (const auto& r : results) {
+        if (!r.ok) ++failed;
+    }
+    const Tally t = tally(results);
+
+    Answer how = Answer::List;
+    if (answer_mode == "least") how = Answer::Least;
+    else if (answer_mode == "most") how = Answer::Most;
+    else if (answer_mode == "total") how = Answer::Total;
+
+    const double secs = std::chrono::duration<double>(
+        std::chrono::steady_clock::now() - t0).count();
+    std::fprintf(stderr,
+                 "[ctxstream] failed=%d/%zu records=%d unparsed_lines=%d keys=%zu %.1fs\n",
+                 failed, results.size(), t.parsed_records, t.unparsed_lines,
+                 t.sorted.size(), secs);
+
+    // A partial sweep must never be reported as a clean answer.
+    if (failed) {
+        std::fprintf(stderr,
+                     "[ctxstream] REFUSING a headline answer: %d segment(s) failed, "
+                     "so every key is undercounted. Fix and rerun, or use --answer list.\n",
+                     failed);
+        if (how != Answer::List) return 1;
+    }
+
+    std::cout << construct(t, how, label) << std::endl;
+    return 0;
+}

ctxstream/src/manifest.cpp

@@ -0,0 +1,54 @@
+#include "ctxstream.hpp"
+
+#include <algorithm>
+
+namespace ctxstream {
+
+// Walk back from the target cut to the nearest record delimiter, so a segment
+// never ends mid-row. A row split across two segments is counted twice or not
+// at all, and both are silent corruption of the tally.
+static std::size_t snap_to_boundary(const std::string& text, std::size_t target,
+                                    const ManifestOptions& opt) {
+    if (target >= text.size()) return text.size();
+    const std::size_t floor =
+        target > opt.boundary_slack ? target - opt.boundary_slack : 0;
+    const std::size_t hit = text.rfind(opt.record_delim, target);
+    if (hit != std::string::npos && hit >= floor) {
+        return hit + opt.record_delim.size();
+    }
+    // No delimiter within slack: the data is not row-shaped, cut where asked.
+    return target;
+}
+
+std::vector<Segment> plan(const std::string& text, const ManifestOptions& opt) {
+    std::vector<Segment> out;
+    if (text.empty() || opt.segment_chars == 0) return out;
+
+    std::size_t pos = 0;
+    int index = 0;
+    while (pos < text.size()) {
+        const std::size_t want = std::min(pos + opt.segment_chars, text.size());
+        const std::size_t end = snap_to_boundary(text, want, opt);
+        // snap_to_boundary can land at or before pos on pathological input
+        // (a single row longer than the segment); force progress.
+        const std::size_t stop = end > pos ? end : want;
+
+        Segment s;
+        s.index = index++;
+        s.overlap_prefix = std::min(pos, opt.overlap_chars);
+        s.offset = pos - s.overlap_prefix;
+        s.length = stop - s.offset;
+        out.push_back(s);
+
+        if (stop >= text.size()) break;
+        pos = stop;
+    }
+    return out;
+}
+
+std::string segment_text(const std::string& text, const Segment& s) {
+    if (s.offset >= text.size()) return {};
+    return text.substr(s.offset, std::min(s.length, text.size() - s.offset));
+}
+
+}  // namespace ctxstream

ctxstream/src/pipeline.cpp

@@ -0,0 +1,108 @@
+#include "ctxstream.hpp"
+
+#include <atomic>
+#include <chrono>
+#include <cstdio>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace ctxstream {
+
+// The extraction contract. Kept short and mechanical on purpose: a small model
+// asked for prose produces prose that no parser can trust, and prose is exactly
+// what broke the aggregation in the Python harness this replaces.
+static const char* kExtractSystem =
+    "You extract structured data from one fragment of a larger corpus.\n"
+    "Rules:\n"
+    "1. Output ONLY lines of the form <key><TAB><number>. Nothing else.\n"
+    "2. No preamble, no explanation, no markdown, no totals.\n"
+    "3. Count only what is present in THIS fragment. Do not guess about the rest.\n"
+    "4. If nothing matches, output exactly: NONE";
+
+std::vector<SegmentResult> stream(const std::string& text,
+                                  const std::vector<Segment>& segments,
+                                  const std::string& extract_prompt,
+                                  const BackendOptions& backend,
+                                  const PipelineOptions& pipe) {
+    std::vector<SegmentResult> results(segments.size());
+    if (segments.empty()) return results;
+
+    std::atomic<std::size_t> next{0};
+    std::atomic<int> done{0}, failed{0};
+    std::mutex log_mu;
+    const auto t0 = std::chrono::steady_clock::now();
+
+    // "Buffer depth" in the video sense: this many segments decoding at once.
+    const int workers =
+        std::max(1, std::min<int>(pipe.concurrency, static_cast<int>(segments.size())));
+
+    auto worker = [&] {
+        for (;;) {
+            const std::size_t i = next.fetch_add(1);
+            if (i >= segments.size()) return;
+
+            const Segment& seg = segments[i];
+            const std::string body = segment_text(text, seg);
+            const std::string prompt =
+                extract_prompt + "\n\n--- FRAGMENT " + std::to_string(seg.index + 1) +
+                " of " + std::to_string(segments.size()) + " ---\n" + body;
+
+            SegmentResult r;
+            r.index = seg.index;
+            const auto s0 = std::chrono::steady_clock::now();
+
+            for (int attempt = 0; attempt <= pipe.max_retries; ++attempt) {
+                const Completion c = complete(backend, kExtractSystem, prompt);
+                if (!c.ok) { r.error = c.error; continue; }
+                r.prompt_tokens = c.prompt_tokens;
+                r.output_tokens = c.output_tokens;
+                // A server that clipped the prompt will answer confidently from
+                // the part it kept. Never accept that as a segment result.
+                if (looks_truncated(prompt.size(), c.prompt_tokens)) {
+                    r.truncated = true;
+                    r.error = "server processed " + std::to_string(c.prompt_tokens) +
+                              " tokens of a " + std::to_string(prompt.size()) +
+                              "-char prompt";
+                    break;
+                }
+                r.raw = c.text;
+                r.ok = true;
+                r.error.clear();
+                break;
+            }
+
+            r.seconds = std::chrono::duration<double>(
+                            std::chrono::steady_clock::now() - s0).count();
+            results[i] = r;
+
+            const int d = ++done;
+            if (!r.ok) ++failed;
+            if (pipe.verbose) {
+                std::lock_guard<std::mutex> lk(log_mu);
+                const double elapsed = std::chrono::duration<double>(
+                    std::chrono::steady_clock::now() - t0).count();
+                const double eta = d ? elapsed / d * (segments.size() - d) : 0.0;
+                // Failures first: a climbing error count must be visible within
+                // seconds, not discovered after the run.
+                std::fprintf(stderr,
+                             "[ctxstream] failed=%d %d/%zu seg=%d %.1fs eta=%.1fm\n",
+                             failed.load(), d, segments.size(), r.index, r.seconds,
+                             eta / 60.0);
+            }
+        }
+    };
+
+    std::vector<std::thread> pool;
+    pool.reserve(workers);
+    for (int i = 0; i < workers; ++i) pool.emplace_back(worker);
+    for (auto& t : pool) t.join();
+
+    if (pipe.verbose && failed) {
+        std::fprintf(stderr, "[ctxstream] WARNING: %d/%zu segments failed\n",
+                     failed.load(), segments.size());
+    }
+    return results;
+}
+
+}  // namespace ctxstream

ctxstream/src/reduce.cpp

@@ -0,0 +1,118 @@
+#include "ctxstream.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <map>
+#include <sstream>
+
+namespace ctxstream {
+
+static std::string trim(const std::string& s) {
+    std::size_t a = 0, b = s.size();
+    while (a < b && std::isspace(static_cast<unsigned char>(s[a]))) ++a;
+    while (b > a && std::isspace(static_cast<unsigned char>(s[b - 1]))) --b;
+    return s.substr(a, b - a);
+}
+
+static bool to_number(const std::string& s, double* out) {
+    if (s.empty()) return false;
+    std::string clean;
+    for (char c : s) {
+        if (c != ',' && c != '_') clean += c;   // 1,234 and 1_234
+    }
+    try {
+        std::size_t used = 0;
+        const double v = std::stod(clean, &used);
+        if (used != clean.size()) return false;
+        *out = v;
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::vector<Record> parse_records(const std::string& raw) {
+    std::vector<Record> out;
+    std::istringstream in(raw);
+    std::string line;
+    while (std::getline(in, line)) {
+        const std::string t = trim(line);
+        if (t.empty() || t == "NONE") continue;
+
+        // Split on the last tab, else the last run of whitespace, else a colon.
+        // Keys legitimately contain spaces ("Spatial Relationship"), which is
+        // exactly the case a naive \S+ split truncated in the previous harness.
+        std::size_t cut = t.rfind('\t');
+        if (cut == std::string::npos) {
+            const std::size_t colon = t.rfind(':');
+            const std::size_t space = t.find_last_of(" ");
+            cut = (colon != std::string::npos && colon > space) ? colon : space;
+        }
+        if (cut == std::string::npos || cut == 0) continue;
+
+        double v = 0.0;
+        if (!to_number(trim(t.substr(cut + 1)), &v)) continue;
+        const std::string key = trim(t.substr(0, cut));
+        if (key.empty()) continue;
+        out.push_back({key, v});
+    }
+    return out;
+}
+
+Tally tally(const std::vector<SegmentResult>& results) {
+    Tally out;
+    std::map<std::string, double> sums;
+    for (const SegmentResult& r : results) {
+        if (!r.ok) continue;  // a failed segment contributes nothing, silently
+                              // dropping it would understate every key
+        const std::vector<Record> recs = parse_records(r.raw);
+        out.parsed_records += static_cast<int>(recs.size());
+        // Count lines the model produced that no parser could use, so a model
+        // ignoring the output contract is visible rather than just quiet.
+        int lines = 0;
+        std::istringstream in(r.raw);
+        std::string l;
+        while (std::getline(in, l)) {
+            if (!trim(l).empty() && trim(l) != "NONE") ++lines;
+        }
+        out.unparsed_lines += std::max(0, lines - static_cast<int>(recs.size()));
+        for (const Record& rec : recs) {
+            sums[rec.key] += rec.value;
+            out.total += rec.value;
+        }
+    }
+    out.sorted.assign(sums.begin(), sums.end());
+    std::sort(out.sorted.begin(), out.sorted.end(),
+              [](const auto& a, const auto& b) {
+                  if (a.second != b.second) return a.second < b.second;
+                  return a.first < b.first;   // stable, reproducible ties
+              });
+    return out;
+}
+
+static std::string fmt(double v) {
+    std::ostringstream o;
+    if (v == static_cast<long long>(v)) o << static_cast<long long>(v);
+    else o << v;
+    return o.str();
+}
+
+std::string construct(const Tally& t, Answer how, const std::string& label) {
+    if (t.sorted.empty()) return label + ": NONE";
+    switch (how) {
+        case Answer::Least:
+            return label + ": " + t.sorted.front().first;
+        case Answer::Most:
+            return label + ": " + t.sorted.back().first;
+        case Answer::Total:
+            return label + ": " + fmt(t.total);
+        case Answer::List: {
+            std::ostringstream o;
+            for (const auto& [k, v] : t.sorted) o << k << "\t" << fmt(v) << "\n";
+            return o.str();
+        }
+    }
+    return label + ": NONE";
+}
+
+}  // namespace ctxstream