@senticor/hive 1.49.1 → 1.50.0

package/chive.cjs

@@ -0,0 +1,1472 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.43_@swc+helpers@0.5.23__jiti@2.7.0_postcss@8.5.28_supports-co_ebdccb821406f648b54993c6aadaa9c1/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/chive.mts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// ../hive-kernel-code-context/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BUILDER_VERSION: () => BUILDER_VERSION2,
+  EXT_LANG: () => EXT_LANG2,
+  buildContextPacket: () => buildContextPacket2,
+  buildDelta: () => buildDelta2,
+  buildGraph: () => buildGraph2,
+  parseFile: () => parseFile2,
+  projectContextPacket: () => projectContextPacket2,
+  projectDelta: () => projectDelta2,
+  projectGraph: () => projectGraph2,
+  scanRepository: () => scanRepository2
+});
+
+// ../hive-kernel-code-context/src/scanner.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  DEFAULT_IGNORES: () => DEFAULT_IGNORES,
+  EXT_LANG: () => EXT_LANG,
+  scanRepository: () => scanRepository
+});
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var DEFAULT_IGNORES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".pnpm-store",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".terraform"
+]);
+var EXT_LANG = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".tf": "terraform",
+  ".yaml": "yaml",
+  ".yml": "yaml"
+};
+function readGitignore(repoRoot) {
+  const file = path.join(repoRoot, ".gitignore");
+  if (!fs.existsSync(file)) return [];
+  const text = fs.readFileSync(file, "utf8");
+  return text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => l.replace(/^\//, "").replace(/\/$/, ""));
+}
+function matchesIgnore(name, ignorePatterns) {
+  if (DEFAULT_IGNORES.has(name)) return true;
+  for (const pat of ignorePatterns) {
+    if (!pat.includes("*") && pat === name) return true;
+    if (pat.includes("*")) {
+      const re = new RegExp("^" + pat.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
+      if (re.test(name)) return true;
+    }
+  }
+  return false;
+}
+function scanRepository({ repositoryRoot, maxFiles = 5e3, extensions = null } = {}) {
+  if (!repositoryRoot || !fs.existsSync(repositoryRoot)) {
+    throw new Error(`repositoryRoot does not exist: ${repositoryRoot}`);
+  }
+  const absRoot = path.resolve(repositoryRoot);
+  const ignorePatterns = readGitignore(absRoot);
+  const wantExt = extensions ? new Set(extensions.map((e) => e.startsWith(".") ? e : "." + e)) : null;
+  const files = [];
+  let truncated = false;
+  const walk = (dir) => {
+    if (truncated) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (_) {
+      return;
+    }
+    for (const entry of entries) {
+      if (truncated) return;
+      const name = entry.name;
+      if (matchesIgnore(name, ignorePatterns)) continue;
+      const full = path.join(dir, name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        const ext = path.extname(name).toLowerCase();
+        const lang = EXT_LANG[ext];
+        if (!lang) continue;
+        if (wantExt && !wantExt.has(ext)) continue;
+        if (files.length >= maxFiles) {
+          truncated = true;
+          return;
+        }
+        files.push({
+          filePath: path.relative(absRoot, full),
+          absPath: full,
+          language: lang,
+          ext
+        });
+      }
+    }
+  };
+  walk(absRoot);
+  return { files, truncated, repositoryRoot: absRoot };
+}
+
+// ../hive-kernel-code-context/src/ts-parser.ts
+var ts_parser_exports = {};
+__export(ts_parser_exports, {
+  isTsLang: () => isTsLang,
+  moduleIdFor: () => moduleIdFor,
+  parseFile: () => parseFile
+});
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_node_module = require("module");
+var _require = (0, import_node_module.createRequire)(importMetaUrl);
+var _ts = null;
+function ts() {
+  if (_ts) return _ts;
+  const mod = _require("typescript");
+  _ts = mod;
+  return mod;
+}
+function isTsLang(lang) {
+  return lang === "typescript" || lang === "javascript";
+}
+function scriptKindForExt(ext) {
+  const T = ts();
+  switch (ext) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return T.ScriptKind.TS;
+    case ".tsx":
+      return T.ScriptKind.TSX;
+    case ".jsx":
+      return T.ScriptKind.JSX;
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+    default:
+      return T.ScriptKind.JS;
+  }
+}
+function nodeIdFor(filePath, kind, name, pos2) {
+  return `${kind}:${filePath}#${name || "_"}@${pos2}`;
+}
+function moduleIdFor(filePath) {
+  return `module:${filePath}`;
+}
+function parseFile({ filePath, absPath, ext = path2.extname(absPath).toLowerCase(), repositoryRoot }) {
+  const T = ts();
+  const source = fs2.readFileSync(absPath, "utf8");
+  const sf = T.createSourceFile(
+    absPath,
+    source,
+    T.ScriptTarget.Latest,
+    /*setParentNodes*/
+    true,
+    scriptKindForExt(ext)
+  );
+  const nodes = [];
+  const edges = [];
+  const moduleNodeId = moduleIdFor(filePath);
+  const language = EXT_LANG[ext] || (ext === ".ts" || ext === ".tsx" ? "typescript" : "javascript");
+  nodes.push({
+    nodeId: moduleNodeId,
+    kind: "module",
+    label: filePath,
+    filePath,
+    spanStart: 0,
+    spanEnd: source.length,
+    language
+  });
+  const definedSymbols = /* @__PURE__ */ new Map();
+  function recordDecl(kind, name, node) {
+    if (!name) return null;
+    const id = nodeIdFor(filePath, kind, name, node.pos);
+    nodes.push({
+      nodeId: id,
+      kind,
+      label: name,
+      filePath,
+      spanStart: node.getStart(sf),
+      spanEnd: node.getEnd(),
+      language
+    });
+    edges.push({
+      edgeId: `${moduleNodeId}|defines|${id}`,
+      from: moduleNodeId,
+      to: id,
+      predicate: "defines"
+    });
+    definedSymbols.set(name, id);
+    return id;
+  }
+  function resolveImportPath(specifier) {
+    if (!specifier) return null;
+    if (specifier.startsWith(".")) {
+      const baseDir = path2.dirname(filePath);
+      let resolved = path2.normalize(path2.join(baseDir, specifier));
+      if (resolved.startsWith("./")) resolved = resolved.slice(2);
+      return resolved;
+    }
+    return specifier;
+  }
+  function recordImport(specifier, importedNames, node) {
+    if (!specifier) return;
+    const resolved = resolveImportPath(specifier);
+    const isLocal = specifier.startsWith(".");
+    const targetId = isLocal ? `module:${resolved}` : `extmodule:${specifier}`;
+    edges.push({
+      edgeId: `${moduleNodeId}|imports|${targetId}@${node.pos}`,
+      from: moduleNodeId,
+      to: targetId,
+      predicate: "imports",
+      meta: {
+        specifier,
+        importedNames: importedNames || [],
+        external: !isLocal
+      }
+    });
+    if (!isLocal) {
+      nodes.push({
+        nodeId: targetId,
+        kind: "external_module",
+        label: specifier,
+        meta: { external: true }
+      });
+    }
+  }
+  function recordTopLevelCall(callee, node) {
+    if (!callee) return;
+    const targetSymbol = definedSymbols.get(callee);
+    const targetId = targetSymbol || `symbol:${callee}@external`;
+    edges.push({
+      edgeId: `${moduleNodeId}|calls|${targetId}@${node.pos}`,
+      from: moduleNodeId,
+      to: targetId,
+      predicate: "calls",
+      meta: { callee, external: !targetSymbol }
+    });
+  }
+  function visit(node) {
+    if (T.isFunctionDeclaration(node)) {
+      const name = node.name ? node.name.text : null;
+      recordDecl("function", name, node);
+      return;
+    }
+    if (T.isClassDeclaration(node)) {
+      const name = node.name ? node.name.text : null;
+      recordDecl("class", name, node);
+      return;
+    }
+    if (T.isInterfaceDeclaration(node)) {
+      recordDecl("interface", node.name.text, node);
+      return;
+    }
+    if (T.isTypeAliasDeclaration(node)) {
+      recordDecl("type", node.name.text, node);
+      return;
+    }
+    if (T.isEnumDeclaration(node)) {
+      recordDecl("enum", node.name.text, node);
+      return;
+    }
+    if (T.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (T.isIdentifier(decl.name)) {
+          recordDecl("const", decl.name.text, decl);
+        }
+      }
+      return;
+    }
+    if (T.isImportDeclaration(node)) {
+      const moduleSpec = node.moduleSpecifier && T.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
+      const names = [];
+      if (node.importClause) {
+        if (node.importClause.name) names.push(node.importClause.name.text);
+        const nb = node.importClause.namedBindings;
+        if (nb) {
+          if (T.isNamedImports(nb)) {
+            for (const e of nb.elements) names.push(e.name.text);
+          } else if (T.isNamespaceImport(nb)) {
+            names.push("* as " + nb.name.text);
+          }
+        }
+      }
+      recordImport(moduleSpec, names, node);
+      return;
+    }
+    if (T.isExpressionStatement(node) && T.isCallExpression(node.expression)) {
+      const call = node.expression;
+      let callee = null;
+      if (T.isIdentifier(call.expression)) callee = call.expression.text;
+      else if (T.isPropertyAccessExpression(call.expression)) callee = call.expression.name.text;
+      recordTopLevelCall(callee, node);
+      return;
+    }
+  }
+  sf.forEachChild(visit);
+  return { nodes, edges };
+}
+
+// ../hive-kernel-code-context/src/graph-builder.ts
+var graph_builder_exports = {};
+__export(graph_builder_exports, {
+  BUILDER_VERSION: () => BUILDER_VERSION,
+  buildGraph: () => buildGraph
+});
+var path4 = __toESM(require("path"), 1);
+
+// ../hive-utils/dist/index.js
+var import_node_crypto2 = require("crypto");
+
+// ../hive-utils/dist/pagination.js
+var import_node_crypto = require("crypto");
+
+// ../hive-utils/dist/schema-org-records.js
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// ../hive-utils/dist/ssrf.js
+var import_node_net = __toESM(require("net"), 1);
+var import_node_dns = __toESM(require("dns"), 1);
+
+// ../hive-utils/dist/file-sniff.js
+var PDF_SIG = Buffer.from("%PDF-", "latin1");
+
+// ../hive-utils/dist/limits.js
+var INGEST_LIMIT_SPEC = {
+  /**
+   * Max ids in a daily reconciliation manifest's job_application_ids[].
+   * `ceiling` is the hard wire-contract cap from the JSON schema's `maxItems`;
+   * an env override is clamped to it so the env-driven handler guard and the
+   * `/api/me/limits` advertisement can never exceed what the ajv validator
+   * accepts (otherwise a client following discovery would send a manifest the
+   * Kafka inline validator rejects as schema_mismatch — split behaviour).
+   */
+  manifestMaxApplicationIds: { env: "HIVE_MANIFEST_MAX_APPLICATION_IDS", default: 1e5, ceiling: 1e5 },
+  /** Max attached documents per application. */
+  maxDocsPerApplication: { env: "HIVE_MAX_DOCS_PER_APPLICATION", default: 50 },
+  // NOTE: a per-jobposting application ceiling is intentionally NOT advertised
+  // here yet — enforcing it needs a durable per-jobposting counter at ingest,
+  // deferred to a follow-up. Advertising an unenforced limit would mislead
+  // clients (#1218 review), so it stays out of the discovery surface until wired.
+  /** Max bytes for a single ingested file (file-drop / upload). */
+  maxIngestFileBytes: { env: "HIVE_MAX_INGEST_FILE_BYTES", default: 25 * 1024 * 1024 },
+  /** Max pages rendered from a single PDF. */
+  maxPdfPages: { env: "HIVE_PDF_MARKDOWN_MAX_PAGES", default: 50 },
+  /** Max request body bytes accepted by ingest routes. */
+  maxBodyBytes: { env: "HIVE_MAX_BODY_BYTES", default: 10 * 1024 * 1024 },
+  // PDF semantic-enrichment caps (#1379) — folded into the SoT so they are
+  // advertised at /api/me/limits and read from one place instead of being
+  // hardcoded in the enrichment service. Breaching any of these flags the
+  // parent application (APPLICATION_PROCESSING_INCOMPLETE) instead of silently
+  // truncating. The `ceiling` is the hard cap above which an env override is
+  // clamped (a single oversized ingest must not OOM the worker — the #1326 root cause).
+  /** Max input bytes admitted into PDF semantic enrichment (skip+flag above). */
+  maxPdfEnrichmentInputBytes: { env: "HIVE_PDF_MAX_ENRICH_BYTES", default: 50 * 1024 * 1024, ceiling: 256 * 1024 * 1024 },
+  /** Max extracted-text chars fed to PDF semantic enrichment (abort+flag above). */
+  maxPdfEnrichmentTextChars: { env: "HIVE_PDF_MAX_ENRICH_TEXT_CHARS", default: 5e5, ceiling: 8e6 },
+  /** Max per-stream decompressed bytes when extracting PDF text (zip-bomb guard). */
+  maxPdfStreamDecompressionBytes: { env: "HIVE_PDF_MAX_DECOMPRESSION_BYTES", default: 64 * 1024 * 1024, ceiling: 256 * 1024 * 1024 },
+  /**
+   * Max UTF-8 bytes of a Kafka binding's broker CA bundle (`tls.caPem`, #83).
+   * The ceiling mirrors the wire-contract cap the api-contracts validator
+   * enforces (MISSION_KAFKA_TLS_CA_MAX_BYTES) — an env override can only
+   * LOWER the effective limit, so `/api/me/limits` never advertises more
+   * than the validator accepts (same split-behaviour guard as
+   * manifestMaxApplicationIds).
+   */
+  maxKafkaTlsCaPemBytes: { env: "HIVE_MAX_KAFKA_TLS_CA_PEM_BYTES", default: 64 * 1024, ceiling: 64 * 1024 }
+};
+
+// ../hive-utils/dist/index.js
+function sha256Hex(input) {
+  const h = (0, import_node_crypto2.createHash)("sha256");
+  h.update(input);
+  return h.digest("hex");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// ../hive-kernel-code-context/src/graph-builder.ts
+var BUILDER_VERSION = "0.1.0";
+function buildGraph(params) {
+  const p = params || {};
+  const {
+    repositoryRoot,
+    repositoryRev = null,
+    graphId,
+    graphType = "source",
+    maxFiles = 5e3,
+    extensions = null
+  } = p;
+  if (!repositoryRoot) {
+    throw new Error("repositoryRoot is required");
+  }
+  const scan = scanRepository({ repositoryRoot, maxFiles, extensions });
+  const nodes = [];
+  const edges = [];
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const file of scan.files) {
+    if (!isTsLang(file.language)) continue;
+    let result;
+    try {
+      result = parseFile({
+        filePath: file.filePath,
+        absPath: file.absPath,
+        ext: file.ext,
+        repositoryRoot: scan.repositoryRoot
+      });
+    } catch {
+      continue;
+    }
+    for (const n of result.nodes) {
+      if (seenNodes.has(n.nodeId)) continue;
+      seenNodes.add(n.nodeId);
+      nodes.push(n);
+    }
+    for (const e of result.edges) {
+      if (seenEdges.has(e.edgeId)) continue;
+      seenEdges.add(e.edgeId);
+      edges.push(e);
+    }
+  }
+  const LOCAL_IMPORT_VARIANTS = [
+    "",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    "/index.ts",
+    "/index.tsx",
+    "/index.mts",
+    "/index.cts",
+    "/index.js",
+    "/index.jsx",
+    "/index.mjs",
+    "/index.cjs"
+  ];
+  for (const edge of edges) {
+    if (edge.predicate !== "imports") continue;
+    if (edge.meta && edge.meta.external) continue;
+    if (seenNodes.has(edge.to)) continue;
+    const base = edge.to.startsWith("module:") ? edge.to.slice("module:".length) : edge.to;
+    for (const variant of LOCAL_IMPORT_VARIANTS) {
+      const candidate = `module:${base}${variant}`;
+      if (seenNodes.has(candidate)) {
+        edge.to = candidate;
+        if (edge.meta) edge.meta.resolvedExtension = variant || null;
+        break;
+      }
+    }
+  }
+  const repoName = path4.basename(scan.repositoryRoot).toLowerCase().replace(/[^a-z0-9._-]/g, "-");
+  const finalGraphId = graphId || `cg.${repoName || "repo"}.v1`;
+  return {
+    schema: "hive.codeGraph.v1",
+    graphId: finalGraphId,
+    repositoryRoot: scan.repositoryRoot,
+    repositoryRev,
+    graphType,
+    builtAt: nowIso(),
+    builderVersion: BUILDER_VERSION,
+    nodes,
+    edges,
+    stats: {
+      nodeCount: nodes.length,
+      edgeCount: edges.length,
+      fileCount: scan.files.length,
+      truncated: scan.truncated
+    },
+    meta: {
+      builderLangs: ["typescript", "javascript"]
+    }
+  };
+}
+
+// ../hive-kernel-code-context/src/context-builder.ts
+var context_builder_exports = {};
+__export(context_builder_exports, {
+  APPROX_CHARS_PER_TOKEN: () => APPROX_CHARS_PER_TOKEN,
+  buildContextPacket: () => buildContextPacket
+});
+var fs4 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var APPROX_CHARS_PER_TOKEN = 4;
+function _matchScope(node, scope) {
+  if (!scope) return false;
+  if (Array.isArray(scope.paths) && node.filePath) {
+    for (const p of scope.paths) {
+      if (node.filePath === p || node.filePath.startsWith(p + path5.sep) || node.filePath.startsWith(p + "/")) {
+        return true;
+      }
+    }
+  }
+  if (Array.isArray(scope.symbols) && node.label) {
+    if (scope.symbols.includes(node.label)) return true;
+  }
+  return false;
+}
+function _readSnippet(absRoot, node) {
+  if (!node.filePath) return null;
+  const abs = path5.isAbsolute(node.filePath) ? node.filePath : path5.join(absRoot || "", node.filePath);
+  let source;
+  try {
+    source = fs4.readFileSync(abs, "utf8");
+  } catch (_) {
+    return null;
+  }
+  const start = Math.max(0, node.spanStart || 0);
+  const end = Math.min(source.length, node.spanEnd || source.length);
+  return {
+    filePath: node.filePath,
+    spanStart: start,
+    spanEnd: end,
+    content: source.slice(start, end),
+    language: node.language || null,
+    reason: node.kind,
+    graphPath: [node.nodeId]
+  };
+}
+function buildContextPacket(params) {
+  const p = params || {};
+  const { graph, task, packetId, tokenBudgetHint = 4e3, repositoryRoot } = p;
+  if (!graph || graph.schema !== "hive.codeGraph.v1") {
+    throw new Error("graph must be a hive.codeGraph.v1 object");
+  }
+  if (!task || !task.objective) {
+    throw new Error("task.objective is required");
+  }
+  const absRoot = repositoryRoot || graph.repositoryRoot;
+  const nodesById = new Map(graph.nodes.map((n) => [n.nodeId, n]));
+  const seedIds = /* @__PURE__ */ new Set();
+  for (const n of graph.nodes) {
+    if (_matchScope(n, task.scope)) seedIds.add(n.nodeId);
+  }
+  const visited = new Set(seedIds);
+  for (const edge of graph.edges) {
+    if (seedIds.has(edge.from) || seedIds.has(edge.to)) {
+      visited.add(edge.from);
+      visited.add(edge.to);
+    }
+  }
+  const charBudget = Math.max(0, tokenBudgetHint * APPROX_CHARS_PER_TOKEN);
+  let usedChars = 0;
+  const snippets = [];
+  const ordered = [
+    ...[...seedIds].map((id) => nodesById.get(id)).filter((n) => Boolean(n)),
+    ...[...visited].filter((id) => !seedIds.has(id)).map((id) => nodesById.get(id)).filter((n) => Boolean(n))
+  ];
+  for (const node of ordered) {
+    if (node.kind === "external_module") continue;
+    const snip = _readSnippet(absRoot, node);
+    if (!snip) continue;
+    if (charBudget > 0 && usedChars + snip.content.length > charBudget && snippets.length > 0) {
+      break;
+    }
+    snippets.push(snip);
+    usedChars += snip.content.length;
+  }
+  const slug = (graph.graphId || "graph").replace(/^cg\./, "").replace(/\.v\d+$/, "");
+  const finalPacketId = packetId || `ccp.${slug || "task"}.v1`;
+  return {
+    schema: "hive.codeContextPacket.v1",
+    packetId: finalPacketId,
+    task: {
+      objective: task.objective,
+      kind: task.kind || "other",
+      scope: task.scope || {}
+    },
+    graphRefs: [
+      {
+        graphId: graph.graphId,
+        graphType: graph.graphType,
+        repositoryRev: graph.repositoryRev
+      }
+    ],
+    snippets,
+    findings: [],
+    tokenBudgetHint,
+    builtAt: nowIso(),
+    meta: {
+      seedCount: seedIds.size,
+      expandedCount: visited.size,
+      usedChars,
+      truncated: snippets.length < ordered.length
+    }
+  };
+}
+
+// ../hive-kernel-code-context/src/delta.ts
+var delta_exports = {};
+__export(delta_exports, {
+  buildDelta: () => buildDelta
+});
+function buildDelta({ baseGraph, headGraph, deltaId } = {}) {
+  if (!baseGraph || baseGraph.schema !== "hive.codeGraph.v1") {
+    throw new Error("baseGraph must be a hive.codeGraph.v1 object");
+  }
+  if (!headGraph || headGraph.schema !== "hive.codeGraph.v1") {
+    throw new Error("headGraph must be a hive.codeGraph.v1 object");
+  }
+  if (baseGraph.graphId !== headGraph.graphId) {
+    throw new Error(`graphId mismatch: ${baseGraph.graphId} vs ${headGraph.graphId}`);
+  }
+  const baseNodes = new Map(baseGraph.nodes.map((n) => [n.nodeId, n]));
+  const headNodes = new Map(headGraph.nodes.map((n) => [n.nodeId, n]));
+  const baseEdges = new Map(baseGraph.edges.map((e) => [e.edgeId, e]));
+  const headEdges = new Map(headGraph.edges.map((e) => [e.edgeId, e]));
+  const addedNodes = [];
+  const removedNodes = [];
+  for (const [id, n] of headNodes.entries()) {
+    if (!baseNodes.has(id)) addedNodes.push(n);
+  }
+  for (const id of baseNodes.keys()) {
+    if (!headNodes.has(id)) removedNodes.push(id);
+  }
+  const addedEdges = [];
+  const removedEdges = [];
+  for (const [id, e] of headEdges.entries()) {
+    if (!baseEdges.has(id)) addedEdges.push(e);
+  }
+  for (const id of baseEdges.keys()) {
+    if (!headEdges.has(id)) removedEdges.push(id);
+  }
+  const slug = (headGraph.graphId || "graph").replace(/^cg\./, "").replace(/\.v\d+$/, "");
+  const finalDeltaId = deltaId || `cgd.${slug || "graph"}.v1`;
+  return {
+    schema: "hive.codeGraphDelta.v1",
+    deltaId: finalDeltaId,
+    graphId: headGraph.graphId,
+    baseRev: baseGraph.repositoryRev || "unknown",
+    headRev: headGraph.repositoryRev || "unknown",
+    addedNodes,
+    removedNodes,
+    addedEdges,
+    removedEdges,
+    stats: {
+      addedNodes: addedNodes.length,
+      removedNodes: removedNodes.length,
+      addedEdges: addedEdges.length,
+      removedEdges: removedEdges.length
+    },
+    computedAt: nowIso()
+  };
+}
+
+// ../hive-kernel-code-context/src/projection.ts
+var projection_exports = {};
+__export(projection_exports, {
+  projectContextPacket: () => projectContextPacket,
+  projectDelta: () => projectDelta,
+  projectGraph: () => projectGraph
+});
+function _missionSlug(missionId) {
+  return String(missionId || "default").replace(/[^a-z0-9._-]/gi, "-");
+}
+function projectGraph({ graph, missionId, tenantId = "default" } = {}) {
+  if (!graph || graph.schema !== "hive.codeGraph.v1") {
+    throw new Error("graph must be a hive.codeGraph.v1 object");
+  }
+  if (!missionId) throw new Error("missionId is required");
+  const slug = _missionSlug(missionId);
+  const nodes = graph.nodes.map((n) => ({
+    nodeId: n.nodeId,
+    kind: n.kind,
+    label: n.label || n.nodeId,
+    layer: "code",
+    missionId,
+    tenantId,
+    meta: {
+      filePath: n.filePath || null,
+      spanStart: n.spanStart || null,
+      spanEnd: n.spanEnd || null,
+      language: n.language || null,
+      graphId: graph.graphId,
+      ...n.meta || {}
+    }
+  }));
+  const edges = graph.edges.map((e) => ({
+    edgeId: e.edgeId,
+    from: e.from,
+    predicate: e.predicate,
+    to: e.to,
+    layer: "code",
+    missionId,
+    weight: e.weight || null,
+    meta: {
+      graphId: graph.graphId,
+      ...e.meta || {}
+    }
+  }));
+  const cellWrites = [
+    {
+      cellId: `kc.code.${slug}.graph`,
+      records: [
+        {
+          recordType: "CodeGraphSnapshot",
+          recordId: `${graph.graphId}@${graph.repositoryRev || "unknown"}`,
+          payload: {
+            graphId: graph.graphId,
+            graphType: graph.graphType,
+            repositoryRoot: graph.repositoryRoot,
+            repositoryRev: graph.repositoryRev,
+            stats: graph.stats,
+            builtAt: graph.builtAt
+          }
+        }
+      ]
+    }
+  ];
+  return { graphMutations: { nodes, edges }, cellWrites };
+}
+function projectContextPacket({ packet, missionId, tenantId = "default" } = {}) {
+  if (!packet || packet.schema !== "hive.codeContextPacket.v1") {
+    throw new Error("packet must be a hive.codeContextPacket.v1 object");
+  }
+  if (!missionId) throw new Error("missionId is required");
+  const slug = _missionSlug(missionId);
+  const packetHash = sha256Hex(JSON.stringify({ task: packet.task, snippets: packet.snippets }));
+  const cellWrites = [
+    {
+      cellId: `kc.code.${slug}.context-packets`,
+      records: [
+        {
+          recordType: "CodeContextPacket",
+          recordId: packet.packetId,
+          payload: {
+            packetId: packet.packetId,
+            task: packet.task,
+            graphRefs: packet.graphRefs,
+            snippetCount: (packet.snippets || []).length,
+            findingCount: (packet.findings || []).length,
+            tokenBudgetHint: packet.tokenBudgetHint,
+            builtAt: packet.builtAt,
+            packetHash
+          }
+        }
+      ]
+    }
+  ];
+  if (Array.isArray(packet.findings) && packet.findings.length > 0) {
+    cellWrites.push({
+      cellId: `kc.code.${slug}.findings`,
+      records: packet.findings.map((f) => ({
+        recordType: "CodeFinding",
+        recordId: f.findingId,
+        payload: { ...f, packetId: packet.packetId }
+      }))
+    });
+  }
+  const evidence = (packet.snippets || []).map((s, i) => ({
+    evidenceId: `${packet.packetId}#snippet-${i}`,
+    type: "code_snippet",
+    payload: {
+      filePath: s.filePath,
+      spanStart: s.spanStart,
+      spanEnd: s.spanEnd,
+      language: s.language,
+      reason: s.reason,
+      graphPath: s.graphPath || [],
+      contentHash: sha256Hex(s.content || "")
+    }
+  }));
+  return { cellWrites, evidence };
+}
+function projectDelta({ delta, missionId } = {}) {
+  if (!delta || delta.schema !== "hive.codeGraphDelta.v1") {
+    throw new Error("delta must be a hive.codeGraphDelta.v1 object");
+  }
+  if (!missionId) throw new Error("missionId is required");
+  const slug = _missionSlug(missionId);
+  return {
+    eventType: "CodeGraphDeltaComputed",
+    eventBody: {
+      missionId,
+      deltaId: delta.deltaId,
+      graphId: delta.graphId,
+      baseRev: delta.baseRev,
+      headRev: delta.headRev,
+      stats: delta.stats
+    },
+    cellWrite: {
+      cellId: `kc.code.${slug}.deltas`,
+      records: [
+        {
+          recordType: "CodeGraphDelta",
+          recordId: delta.deltaId,
+          payload: delta
+        }
+      ]
+    }
+  };
+}
+
+// ../hive-kernel-code-context/src/index.ts
+var { scanRepository: scanRepository2, EXT_LANG: EXT_LANG2 } = scanner_exports;
+var { buildGraph: buildGraph2, BUILDER_VERSION: BUILDER_VERSION2 } = graph_builder_exports;
+var { buildContextPacket: buildContextPacket2 } = context_builder_exports;
+var { buildDelta: buildDelta2 } = delta_exports;
+var { projectGraph: projectGraph2, projectContextPacket: projectContextPacket2, projectDelta: projectDelta2 } = projection_exports;
+var { parseFile: parseFile2 } = ts_parser_exports;
+
+// src/chive-http.mts
+var ChiveHttpError = class extends Error {
+  code;
+  status;
+  body;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "ChiveHttpError";
+    this.code = opts.code || "http_error";
+    this.status = opts.status || null;
+    this.body = opts.body || null;
+  }
+};
+function assertFlagRecord(flags2) {
+  if (flags2 == null) return void 0;
+  if (typeof flags2 !== "object" || Array.isArray(flags2)) {
+    throw new ChiveHttpError("CLI flags must be an object", { code: "invalid_flags" });
+  }
+  return flags2;
+}
+function optionalStringFlag(flags2, name) {
+  if (!flags2) return void 0;
+  const value = flags2[name];
+  if (value == null || value === false || value === "") return void 0;
+  if (typeof value !== "string") {
+    throw new ChiveHttpError(`--${name} requires a value`, { code: `invalid_${name.replace(/[^a-z0-9]/gi, "_")}_flag` });
+  }
+  return value;
+}
+function optionalEnvString(name) {
+  const value = process.env[name];
+  return value && value.length > 0 ? value : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function extractResponseMessage(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const obj = parsed;
+  if (typeof obj.error === "string" && obj.error) return obj.error;
+  if (typeof obj.message === "string" && obj.message) return obj.message;
+  return null;
+}
+function normalizeHeaders(headers) {
+  if (headers === void 0) return {};
+  if (!headers || typeof headers !== "object" || Array.isArray(headers)) {
+    throw new ChiveHttpError("headers must be an object", { code: "invalid_headers" });
+  }
+  return Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => {
+      if (typeof value !== "string") {
+        throw new ChiveHttpError(`header ${name} must be a string`, { code: "invalid_headers" });
+      }
+      return [name, value];
+    })
+  );
+}
+function normalizeHttpOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new ChiveHttpError("httpJson options must be an object", { code: "invalid_http_options" });
+  }
+  const method = options.method ?? "GET";
+  if (typeof method !== "string" || method.length === 0) {
+    throw new ChiveHttpError("HTTP method must be a non-empty string", { code: "invalid_method" });
+  }
+  if (typeof options.url !== "string" || options.url.length === 0) {
+    throw new ChiveHttpError("HTTP URL must be a non-empty string", { code: "invalid_url" });
+  }
+  if (options.token != null && typeof options.token !== "string") {
+    throw new ChiveHttpError("token must be a string", { code: "invalid_token" });
+  }
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new ChiveHttpError("timeoutMs must be a positive number", { code: "invalid_timeout" });
+  }
+  return {
+    method,
+    url: options.url,
+    body: options.body,
+    token: options.token || null,
+    headers: normalizeHeaders(options.headers),
+    timeoutMs
+  };
+}
+function resolveApiBase(flags2) {
+  const flagRecord = assertFlagRecord(flags2);
+  const fromFlag = optionalStringFlag(flagRecord, "api") || optionalStringFlag(flagRecord, "api-base");
+  const fromEnv = optionalEnvString("HIVE_API_URL");
+  const base = (fromFlag || fromEnv || "").replace(/\/+$/, "");
+  if (!base) {
+    throw new ChiveHttpError(
+      "no API base URL \u2014 set HIVE_API_URL or pass --api <url>",
+      { code: "no_api_url" }
+    );
+  }
+  return base;
+}
+function resolveToken(flags2) {
+  const flagRecord = assertFlagRecord(flags2);
+  return optionalStringFlag(flagRecord, "token") || optionalEnvString("HIVE_API_TOKEN") || null;
+}
+async function httpJson(options) {
+  const { method, url, body, token, headers, timeoutMs } = normalizeHttpOptions(options);
+  const requestInit = {
+    method,
+    headers: {
+      accept: "application/json",
+      ...body !== void 0 ? { "content-type": "application/json" } : {},
+      ...token ? { authorization: `Bearer ${token}` } : {},
+      ...headers
+    }
+  };
+  if (body !== void 0) requestInit.body = JSON.stringify(body);
+  const controller = new AbortController();
+  const t = setTimeout(() => controller.abort(), timeoutMs);
+  requestInit.signal = controller.signal;
+  let res;
+  try {
+    res = await fetch(url, requestInit);
+  } catch (error) {
+    throw new ChiveHttpError(`network: ${errorMessage(error)}`, { code: "network" });
+  } finally {
+    clearTimeout(t);
+  }
+  const text = await res.text();
+  let parsed;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch {
+    parsed = { raw: text };
+  }
+  if (!res.ok) {
+    const message = extractResponseMessage(parsed) || `HTTP ${res.status}`;
+    throw new ChiveHttpError(`${method} ${url} \u2192 ${res.status}: ${message}`, {
+      code: `http_${res.status}`,
+      status: res.status,
+      body: parsed
+    });
+  }
+  return parsed;
+}
+function mkRecordId(prefix) {
+  if (typeof prefix !== "string" || prefix.length === 0) {
+    throw new ChiveHttpError("record ID prefix must be a non-empty string", { code: "invalid_record_prefix" });
+  }
+  const ts2 = Date.now().toString(36);
+  const rnd = Math.random().toString(36).slice(2, 8);
+  return `${prefix}.${ts2}.${rnd}`;
+}
+
+// src/chive.mts
+var VERSION = "0.2.0";
+var KNOWLEDGE_TOPICS = ["notes", "procedures", "examples", "post-mortems"];
+var KNOWLEDGE_RECORD_TYPES = {
+  notes: "KnowledgeNote",
+  procedures: "KnowledgeProcedure",
+  examples: "KnowledgeExample",
+  "post-mortems": "KnowledgePostMortem"
+};
+var KNOWLEDGE_TEMPLATE_ID = "mt.knowledge.base.v1";
+var codeContextKernel = src_exports;
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const positional = [];
+  const flags2 = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      const eqIdx = a.indexOf("=");
+      if (eqIdx > 0) {
+        flags2[a.slice(2, eqIdx)] = a.slice(eqIdx + 1);
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        flags2[a.slice(2)] = args[++i];
+      } else {
+        flags2[a.slice(2)] = true;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { positional, flags: flags2 };
+}
+var { positional: pos, flags } = parseArgs(process.argv);
+function printHelp() {
+  console.log(`chive v${VERSION} \u2014 Cognitive Hive OS code-context CLI
+
+OFFLINE (kernel-only):
+  chive graph build   --repo <path> [--rev <rev>] [--graph-id <id>] [--max-files N] [--out <file>]
+  chive graph update  --repo <path> --base <graph.json> [--rev <rev>] [--graph-id <id>] [--out <file>]
+  chive context build --graph <graph.json> --task "..." [--paths a,b] [--symbols x,y]
+                      [--budget <tokens>] [--repo <path>] [--out <file>]
+
+ONLINE (talks to HIVE_API_URL or --api <url>; bearer via HIVE_API_TOKEN or --token):
+  chive memory remember     --task "..." --kind bugfix [--outcome success|failure]
+                            [--packet <packet.json>] [--summary "..."] [--domain code]
+  chive memory recall       [--task "..."] [--kind ...] [--domain code] [--limit N]
+  chive arch decide         --mission <missionId> --title "..." --because "..."
+                            [--files a,b] [--packet <packet.json>]
+  chive arch list           --mission <missionId>
+  chive todo add            "<title>" --mission <missionId> [--file path:line]
+                            [--priority high|med|low]
+  chive todo list           --mission <missionId> [--status open|done]
+  chive todo done <todoId>  --mission <missionId>
+  chive knowledge mission create --intent "..." [--title "..."]
+  chive knowledge mission list
+  chive knowledge note add  --mission <missionId> --topic notes|procedures|examples|post-mortems
+                            --title "..." [--body "..."] [--body-file <file>]
+                            [--tags a,b,c]
+  chive knowledge note list --mission <missionId> [--topic ...]
+
+  chive version | help
+
+Offline JSON shapes follow specs/schemas/hive.codeGraph.v1, hive.codeContextPacket.v1,
+and hive.codeGraphDelta.v1. Online commands write JSON to stdout (or --out).
+
+Examples:
+  chive graph build   --repo . --rev "$(git rev-parse HEAD)" --out graph.json
+  chive context build --graph graph.json --task "Fix auth bug" --symbols login --out packet.json
+  chive memory remember --task "Fix auth race" --kind bugfix --packet packet.json --outcome success
+  chive arch decide --mission m-1 --title "Redis sessions" --because "1h TTL fits..."
+  chive todo add "Validate JWT exp claim" --mission m-1 --file src/auth.ts:42 --priority high
+  chive knowledge mission create --intent "Security knowledge base" --title "Security"
+  chive knowledge note add --mission m-2 --topic procedures --title "Rotate keys" --body "..."
+`);
+}
+if (hasFlag("version") || pos[0] === "version") {
+  console.log(`chive v${VERSION}`);
+  process.exit(0);
+}
+if (hasFlag("help") || hasFlag("h") || !pos[0] || pos[0] === "help") {
+  printHelp();
+  process.exit(0);
+}
+function dieUsage(msg) {
+  console.error(`chive: ${msg}
+Run \`chive help\` for usage.`);
+  process.exit(2);
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function dieRuntime(error) {
+  console.error(`chive: ${errorMessage2(error)}`);
+  if (hasFlag("verbose") && error instanceof Error && error.stack) console.error(error.stack);
+  process.exit(3);
+}
+function hasFlag(name) {
+  return flags[name] !== void 0 && flags[name] !== false;
+}
+function stringFlag(name) {
+  const value = flags[name];
+  if (value === void 0 || value === false || value === "") return void 0;
+  if (typeof value !== "string") dieUsage(`--${name} requires a value`);
+  return value;
+}
+function requiredStringFlag(name, command) {
+  const value = stringFlag(name);
+  if (!value) dieUsage(`--${name} is required for \`${command}\``);
+  return value;
+}
+function splitList(value) {
+  if (!value) return [];
+  return value.split(",").map((x) => x.trim()).filter(Boolean);
+}
+function stringListFlag(name) {
+  return splitList(stringFlag(name));
+}
+function readJsonFile(p, label) {
+  if (!import_node_fs.default.existsSync(p)) dieUsage(`${label} not found at ${p}`);
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(p, "utf8"));
+  } catch (error) {
+    dieRuntime(new Error(`${label} is not valid JSON: ${errorMessage2(error)}`));
+  }
+}
+function writeResult(obj) {
+  const json = JSON.stringify(obj, null, 2);
+  const out = stringFlag("out");
+  if (out) {
+    import_node_fs.default.writeFileSync(out, json + "\n");
+    console.error(`chive: wrote ${import_node_path.default.resolve(out)}`);
+  } else {
+    process.stdout.write(json + "\n");
+  }
+}
+function parseIntFlag(name, value, { min = 1 } = {}) {
+  if (value === void 0 || value === false || value === "") return void 0;
+  if (typeof value !== "string") dieUsage(`--${name} requires a value`);
+  const n = Number.parseInt(value, 10);
+  if (!Number.isFinite(n)) dieUsage(`--${name} must be an integer`);
+  if (n < min) dieUsage(`--${name} must be at least ${min}`);
+  return n;
+}
+function isKnowledgeTopic(value) {
+  return KNOWLEDGE_TOPICS.includes(value);
+}
+function includesString(value, needle) {
+  return Array.isArray(value) && value.some((item) => item === needle);
+}
+async function apiCall(method, urlPath, body) {
+  const base = resolveApiBase(flags);
+  const token = resolveToken(flags);
+  return await httpJson({ method, url: `${base}${urlPath}`, body, token });
+}
+async function createRecord({ recordType, missionId, cellId, data }) {
+  const recordId = mkRecordId(recordType.toLowerCase().replace(/[^a-z0-9]/g, "-"));
+  return await apiCall("POST", "/api/records", {
+    recordId,
+    recordType,
+    missionId,
+    cellId: cellId || null,
+    data
+  });
+}
+async function listRecords({ recordType, missionId, extra = {} }) {
+  const qs = new URLSearchParams({ recordType, ...missionId ? { missionId } : {}, ...extra });
+  return await apiCall("GET", `/api/records?${qs.toString()}`, void 0);
+}
+async function patchRecord(recordId, patch) {
+  return await apiCall("PATCH", `/api/records/${encodeURIComponent(recordId)}`, patch);
+}
+function readPacketIfSet() {
+  const packetPath = stringFlag("packet");
+  if (!packetPath) return null;
+  if (!import_node_fs.default.existsSync(packetPath)) dieUsage(`packet file not found at ${packetPath}`);
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(packetPath, "utf8"));
+  } catch (error) {
+    dieRuntime(new Error(`packet is not valid JSON: ${errorMessage2(error)}`));
+  }
+}
+function readBodyIfSet() {
+  const body = stringFlag("body");
+  if (body) return body;
+  const bodyFile = stringFlag("body-file");
+  if (bodyFile) {
+    if (!import_node_fs.default.existsSync(bodyFile)) dieUsage(`body-file not found at ${bodyFile}`);
+    return import_node_fs.default.readFileSync(bodyFile, "utf8");
+  }
+  return null;
+}
+var group = pos[0];
+var sub = pos[1];
+(function dispatch() {
+  try {
+    if (group === "graph" && sub === "build") {
+      const repo = requiredStringFlag("repo", "graph build");
+      const graph = codeContextKernel.buildGraph({
+        repositoryRoot: repo,
+        repositoryRev: stringFlag("rev") || null,
+        graphId: stringFlag("graph-id") || null,
+        maxFiles: parseIntFlag("max-files", flags["max-files"])
+      });
+      writeResult(graph);
+      process.exit(0);
+    }
+    if (group === "graph" && sub === "update") {
+      const repo = requiredStringFlag("repo", "graph update");
+      const basePath = requiredStringFlag("base", "graph update");
+      const base = readJsonFile(basePath, "base graph");
+      const head = codeContextKernel.buildGraph({
+        repositoryRoot: repo,
+        repositoryRev: stringFlag("rev") || null,
+        graphId: stringFlag("graph-id") || base.graphId || null
+      });
+      const delta = codeContextKernel.buildDelta({ baseGraph: base, headGraph: head });
+      writeResult(delta);
+      process.exit(0);
+    }
+    if (group === "context" && sub === "build") {
+      const graphPath = requiredStringFlag("graph", "context build");
+      const taskObjective = requiredStringFlag("task", "context build");
+      const graph = readJsonFile(graphPath, "graph");
+      const packet = codeContextKernel.buildContextPacket({
+        graph,
+        task: {
+          objective: taskObjective,
+          kind: stringFlag("kind") || "other",
+          scope: {
+            paths: stringListFlag("paths"),
+            symbols: stringListFlag("symbols")
+          }
+        },
+        tokenBudgetHint: parseIntFlag("budget", flags.budget, { min: 0 }) ?? 4e3,
+        repositoryRoot: stringFlag("repo")
+      });
+      writeResult(packet);
+      process.exit(0);
+    }
+    if (group === "memory") {
+      handleMemory().catch(dieRuntime);
+      return;
+    }
+    if (group === "arch") {
+      handleArch().catch(dieRuntime);
+      return;
+    }
+    if (group === "todo") {
+      handleTodo().catch(dieRuntime);
+      return;
+    }
+    if (group === "knowledge") {
+      handleKnowledge().catch(dieRuntime);
+      return;
+    }
+    dieUsage(`unknown command: ${group}${sub ? " " + sub : ""}`);
+  } catch (e) {
+    dieRuntime(e);
+  }
+})();
+async function handleMemory() {
+  if (sub === "remember") {
+    const task = requiredStringFlag("task", "memory remember");
+    const kind = requiredStringFlag("kind", "memory remember");
+    const outcome = stringFlag("outcome");
+    const summary = stringFlag("summary");
+    const packet = readPacketIfSet();
+    const content = summary ? summary : `task: ${task}${outcome ? ` \u2014 outcome: ${outcome}` : ""}`;
+    const meta = {
+      taskKind: kind,
+      outcome: outcome || null,
+      packetId: packet ? packet.packetId : null,
+      graphRefs: packet ? packet.graphRefs || [] : [],
+      taskObjective: task
+    };
+    const tags = ["code", kind];
+    if (packet && Array.isArray(packet.graphRefs)) {
+      for (const ref of packet.graphRefs) if (ref.graphId) tags.push(`graph:${ref.graphId}`);
+    }
+    const r = await apiCall("POST", "/api/cortex/promote", {
+      domain: stringFlag("domain") || "code",
+      entries: [{ entryType: "outcome", content, tags, meta, confidence: 0.7 }],
+      source: "chive"
+    });
+    writeResult(r);
+    return;
+  }
+  if (sub === "recall") {
+    const limit = parseIntFlag("limit", flags.limit) ?? 20;
+    const kind = stringFlag("kind");
+    const fetchLimit = kind ? Math.max(limit * 5, 100) : limit;
+    const body = {
+      domain: stringFlag("domain") || "code",
+      query: stringFlag("task") || null,
+      entryType: stringFlag("entryType") || "outcome",
+      limit: fetchLimit
+    };
+    const r = await apiCall("POST", "/api/cortex/query", body);
+    if (kind && r && Array.isArray(r.entries)) {
+      r.entries = r.entries.filter((e) => e.meta?.taskKind === kind);
+      r.entries = r.entries.slice(0, limit);
+      r.count = r.entries.length;
+    }
+    writeResult(r);
+    return;
+  }
+  dieUsage(`unknown memory subcommand: ${sub || ""}`);
+}
+async function handleArch() {
+  if (sub === "decide") {
+    const mission = requiredStringFlag("mission", "arch decide");
+    const title = requiredStringFlag("title", "arch decide");
+    const because = requiredStringFlag("because", "arch decide");
+    const packet = readPacketIfSet();
+    const data = {
+      kind: "adr",
+      title,
+      because,
+      files: stringListFlag("files"),
+      packetId: packet ? packet.packetId : null,
+      graphRefs: packet ? packet.graphRefs || [] : [],
+      decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "accepted"
+    };
+    const r = await createRecord({
+      recordType: "CodeArchitectureDecision",
+      missionId: mission,
+      data
+    });
+    writeResult(r);
+    return;
+  }
+  if (sub === "list") {
+    const mission = requiredStringFlag("mission", "arch list");
+    const r = await listRecords({
+      recordType: "CodeArchitectureDecision",
+      missionId: mission
+    });
+    writeResult(r);
+    return;
+  }
+  dieUsage(`unknown arch subcommand: ${sub || ""}`);
+}
+async function handleTodo() {
+  if (sub === "add") {
+    const title = pos[2];
+    if (!title) dieUsage('title is required: `chive todo add "<title>"`');
+    const mission = requiredStringFlag("mission", "todo add");
+    const data = {
+      kind: "todo",
+      title,
+      file: stringFlag("file") || null,
+      priority: stringFlag("priority") || "med",
+      status: "open",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const r = await createRecord({
+      recordType: "CodeTodo",
+      missionId: mission,
+      data
+    });
+    writeResult(r);
+    return;
+  }
+  if (sub === "list") {
+    const mission = requiredStringFlag("mission", "todo list");
+    const r = await listRecords({
+      recordType: "CodeTodo",
+      missionId: mission
+    });
+    const status = stringFlag("status");
+    if (status && r && Array.isArray(r.records)) {
+      r.records = r.records.filter((rec) => rec.data?.status === status);
+    }
+    writeResult(r);
+    return;
+  }
+  if (sub === "done") {
+    const todoId = pos[2];
+    if (!todoId) dieUsage("todoId is required: `chive todo done <todoId>`");
+    const mission = requiredStringFlag("mission", "todo done");
+    const r = await patchRecord(todoId, {
+      missionId: mission,
+      data: { status: "done", closedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    writeResult(r);
+    return;
+  }
+  dieUsage(`unknown todo subcommand: ${sub || ""}`);
+}
+async function handleKnowledge() {
+  if (sub === "mission" && pos[2] === "create") {
+    const intent = stringFlag("intent") || stringFlag("title");
+    if (!intent) dieUsage("--intent (or --title) is required for `knowledge mission create`");
+    const r = await apiCall("POST", `/api/mission-templates/${encodeURIComponent(KNOWLEDGE_TEMPLATE_ID)}/instantiate`, {
+      userIntent: intent,
+      instantiationConfig: {
+        title: stringFlag("title") || intent
+      }
+    });
+    writeResult(r);
+    return;
+  }
+  if (sub === "mission" && pos[2] === "list") {
+    const r = await apiCall("GET", "/api/missions", void 0);
+    if (r && Array.isArray(r.missions)) {
+      r.missions = r.missions.filter(
+        (m) => (m.templateId || m.template_id) === KNOWLEDGE_TEMPLATE_ID || includesString(m.tags, "knowledge-base")
+      );
+    }
+    writeResult(r);
+    return;
+  }
+  if (sub === "note" && pos[2] === "add") {
+    const mission = requiredStringFlag("mission", "knowledge note add");
+    const topic = requiredStringFlag("topic", "knowledge note add");
+    if (!isKnowledgeTopic(topic)) {
+      dieUsage(`unknown topic "${topic}". Must be one of: ${KNOWLEDGE_TOPICS.join(", ")}`);
+    }
+    const title = requiredStringFlag("title", "knowledge note add");
+    const recordType = KNOWLEDGE_RECORD_TYPES[topic];
+    const body = readBodyIfSet();
+    const data = {
+      topic,
+      title,
+      body: body || "",
+      tags: stringListFlag("tags"),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const r = await createRecord({
+      recordType,
+      missionId: mission,
+      data
+    });
+    writeResult(r);
+    return;
+  }
+  if (sub === "note" && pos[2] === "list") {
+    const mission = requiredStringFlag("mission", "knowledge note list");
+    const topic = stringFlag("topic");
+    let topics = KNOWLEDGE_TOPICS;
+    if (topic) {
+      if (!isKnowledgeTopic(topic)) {
+        dieUsage(`unknown topic "${topic}". Must be one of: ${KNOWLEDGE_TOPICS.join(", ")}`);
+      }
+      topics = [topic];
+    }
+    const combined = { ok: true, records: [] };
+    for (const t of topics) {
+      const recordType = KNOWLEDGE_RECORD_TYPES[t];
+      const r = await listRecords({ recordType, missionId: mission });
+      if (r && Array.isArray(r.records)) combined.records?.push(...r.records);
+    }
+    combined.count = combined.records?.length ?? 0;
+    writeResult(combined);
+    return;
+  }
+  dieUsage(`unknown knowledge subcommand: ${sub || ""}${pos[2] ? " " + pos[2] : ""}`);
+}