@aliyunrds/ctxdb 1.0.1-beta.2 → 1.0.1

package/dist/chunk-IMYLU5C2.js

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+import {
+  isCircuitOpen,
+  isConnectionError,
+  resetCircuit,
+  tripCircuit
+} from "./chunk-TGVURF54.js";
+import {
+  CtxdbError,
+  debug,
+  isDebug
+} from "./chunk-6FZL67GH.js";
+
+// src/lib/capture-orchestrator.ts
+import {
+  filterMessagesForExtraction,
+  isKnowledgeBaseUploadTurn,
+  selectTurnMessages
+} from "@aliyunrds/ctxdb-shared";
+
+// src/lib/git-context.ts
+import { execSync } from "child_process";
+function getGitContext() {
+  try {
+    const raw = execSync("git rev-parse --show-toplevel --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const lines = raw.split("\n");
+    if (lines.length < 2) return null;
+    const project = lines[0].split(/[/\\]/).pop();
+    if (!project) return null;
+    const branch = lines[1];
+    return { project, branch };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/transcript.ts
+import { existsSync, readFileSync } from "fs";
+var ANTHROPIC_MESSAGE_TYPES = /* @__PURE__ */ new Set(["user", "assistant"]);
+var CODEX_RESPONSE_ITEM = "response_item";
+function readTranscript(path) {
+  if (!existsSync(path)) return [];
+  let text;
+  try {
+    text = readFileSync(path, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of text.split("\n")) {
+    const s = line.trim();
+    if (!s) continue;
+    let obj;
+    try {
+      obj = JSON.parse(s);
+    } catch {
+      continue;
+    }
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) continue;
+    const o = obj;
+    const rawType = typeof o.type === "string" ? o.type : "";
+    if (rawType === CODEX_RESPONSE_ITEM) {
+      const payload = o.payload;
+      if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+        out.push({ ...o, type: CODEX_RESPONSE_ITEM });
+      }
+      continue;
+    }
+    const message = o.message;
+    const role = message && typeof message === "object" ? message.role : void 0;
+    const inferred = ANTHROPIC_MESSAGE_TYPES.has(rawType) ? rawType : typeof role === "string" && ANTHROPIC_MESSAGE_TYPES.has(role) ? role : null;
+    if (!inferred) continue;
+    out.push({ ...o, type: inferred });
+  }
+  return out;
+}
+function toKbDetectionMessages(rows) {
+  const out = [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    if (row.type === CODEX_RESPONSE_ITEM) {
+      const p = row.payload;
+      if (!p || typeof p !== "object") continue;
+      const ptype = p.type;
+      if (ptype === "message") {
+        const role = p.role;
+        if (role !== "user" && role !== "assistant") continue;
+        out.push({ role, content: p.content });
+        continue;
+      }
+      if (ptype === "function_call") {
+        const name = typeof p.name === "string" ? p.name : "";
+        const args = parseArgs(p.arguments);
+        const command = typeof args.cmd === "string" ? args.cmd : typeof args.command === "string" ? args.command : "";
+        out.push({
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              // Map any codex tool name to "bash" so the shared
+              // SHELL_TOOL_NAMES set fires; the actual command text is
+              // preserved in input.command for the regex check.
+              name: "bash",
+              input: { command, codex_tool: name }
+            }
+          ]
+        });
+        continue;
+      }
+      continue;
+    }
+    const msg = row.message;
+    if (!msg || typeof msg !== "object") continue;
+    out.push({ role: msg.role, content: msg.content });
+  }
+  return out;
+}
+function selectTurnRows(rows) {
+  let turnStart = -1;
+  for (let ri = rows.length - 1; ri >= 0; ri--) {
+    if (hasExtractableUserText(rows[ri])) {
+      turnStart = ri;
+      while (turnStart > 0 && hasExtractableUserText(rows[turnStart - 1])) {
+        turnStart--;
+      }
+      break;
+    }
+  }
+  return turnStart >= 0 ? rows.slice(turnStart) : [];
+}
+function hasExtractableUserText(row) {
+  if (!row || typeof row !== "object") return false;
+  if (row.type === CODEX_RESPONSE_ITEM) {
+    const p = row.payload;
+    if (!p || typeof p !== "object") return false;
+    if (p.type !== "message" || p.role !== "user") return false;
+    const content2 = p.content;
+    if (!Array.isArray(content2)) return false;
+    return content2.some((block) => {
+      if (!block || typeof block !== "object") return false;
+      if (block.type !== "input_text") return false;
+      const text = block.text;
+      return typeof text === "string" && text.trim() && !isCodexScaffoldingText(text);
+    });
+  }
+  if (row.isMeta === true) return false;
+  const msg = row.message;
+  if (!msg || typeof msg !== "object") return false;
+  if (msg.role !== "user") return false;
+  const content = msg.content;
+  if (typeof content === "string") return Boolean(content.trim());
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => {
+    if (!block || typeof block !== "object") return false;
+    if (block.type !== "text") return false;
+    const text = block.text;
+    return typeof text === "string" && Boolean(text.trim());
+  });
+}
+function parseArgs(raw) {
+  if (typeof raw !== "string") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+var CODEX_USER_SCAFFOLDING_PREFIXES = [
+  "<environment_context>",
+  "<permissions instructions>",
+  "<collaboration_mode>",
+  "<apps_instructions>",
+  "<skills_instructions>",
+  "<plugins_instructions>",
+  "# AGENTS.md instructions for "
+];
+var CODEX_MEMORY_PREAMBLE_RE = /^## Memory\s+You have access to a memory folder/;
+function isCodexScaffoldingText(text) {
+  const t = text.trimStart();
+  if (!t) return false;
+  for (const prefix of CODEX_USER_SCAFFOLDING_PREFIXES) {
+    if (t.startsWith(prefix)) return true;
+  }
+  return CODEX_MEMORY_PREAMBLE_RE.test(t);
+}
+function toParsedMessages(rows) {
+  const parsed = [];
+  let idx = 0;
+  const push = (role, text) => {
+    if (text && text.trim()) {
+      parsed.push({ role, content: text, index: idx });
+      idx++;
+    }
+  };
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    if (row.type === CODEX_RESPONSE_ITEM) {
+      const p = row.payload;
+      if (!p || typeof p !== "object") continue;
+      const ptype = p.type;
+      if (ptype === "message") {
+        const role2 = p.role;
+        if (role2 !== "user" && role2 !== "assistant") continue;
+        const content2 = p.content;
+        if (!Array.isArray(content2)) continue;
+        for (const block of content2) {
+          if (!block || typeof block !== "object") continue;
+          const btype = block.type;
+          if (btype === "input_text" || btype === "output_text") {
+            const v = block.text;
+            if (typeof v !== "string") continue;
+            if (role2 === "user" && isCodexScaffoldingText(v)) continue;
+            push(role2, v);
+          }
+        }
+        continue;
+      }
+      if (ptype === "reasoning") continue;
+      continue;
+    }
+    if (row.isMeta === true) continue;
+    const msg = row.message;
+    if (!msg || typeof msg !== "object") continue;
+    const role = msg.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const content = msg.content;
+    if (typeof content === "string") {
+      push(role, content);
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (!block || typeof block !== "object") continue;
+        const btype = block.type;
+        let text = null;
+        if (btype === "text") {
+          const v = block.text;
+          if (typeof v === "string") text = v;
+        }
+        if (text) push(role, text);
+      }
+    }
+  }
+  return parsed;
+}
+var COMMAND_MESSAGE_RE = /<command-message>([\s\S]*?)<\/command-message>/;
+var COMMAND_ARGS_RE = /<command-args>([\s\S]*?)<\/command-args>/;
+function extractSkillSignals(rows) {
+  const signals = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (s) => {
+    const key = `${s.trigger}:${s.skill}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    signals.push(s);
+  };
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    if (row.type === "user") {
+      const msg = row.message;
+      if (!msg || typeof msg !== "object") continue;
+      const content = msg.content;
+      if (typeof content === "string") {
+        const m = COMMAND_MESSAGE_RE.exec(content);
+        if (m) {
+          const argsMatch = COMMAND_ARGS_RE.exec(content);
+          add({
+            skill: m[1].trim(),
+            args: argsMatch?.[1]?.trim() || void 0,
+            trigger: "command"
+          });
+        }
+      }
+    }
+    if (row.type === "assistant") {
+      const msg = row.message;
+      if (!msg || typeof msg !== "object") continue;
+      const content = msg.content;
+      if (!Array.isArray(content)) continue;
+      for (const block of content) {
+        if (block && typeof block === "object" && block.type === "tool_use" && block.name === "Skill") {
+          const input = block.input;
+          if (input && typeof input === "object") {
+            const skill = typeof input.skill === "string" ? input.skill : "";
+            const args = typeof input.args === "string" ? input.args : void 0;
+            if (skill) add({ skill, args, trigger: "agent" });
+          }
+        }
+      }
+    }
+  }
+  return signals;
+}
+
+// src/lib/capture-orchestrator.ts
+async function captureTurn(transcriptPath, cfg, client, agent = "default", sessionId) {
+  const preflight = capturePreflight(cfg, agent);
+  if (preflight) return preflight;
+  const rows = readTranscript(transcriptPath);
+  if (rows.length === 0) {
+    return { captured: false, reason: "empty_transcript", messageCount: 0 };
+  }
+  const dbg = isDebug();
+  if (dbg) debug("capture", "transcript rows", summarizeTranscriptRows(rows));
+  const parsed = toParsedMessages(rows);
+  if (parsed.length === 0) {
+    return {
+      captured: false,
+      reason: `transcript_schema_mismatch: rows=${rows.length} parsed=0`,
+      messageCount: 0
+    };
+  }
+  const turnRows = selectTurnRows(rows);
+  if (dbg) debug("capture", "current turn rows", summarizeTranscriptRows(turnRows));
+  return captureParsedMessages(parsed, cfg, client, agent, sessionId, {
+    kbDetectionMessages: toKbDetectionMessages(turnRows),
+    skills: extractSkillSignals(rows)
+  });
+}
+async function captureParsedMessages(parsed, cfg, client, agent = "default", sessionId, options = {}) {
+  const preflight = capturePreflight(cfg, agent);
+  if (preflight) return preflight;
+  if (parsed.length === 0) {
+    return { captured: false, reason: "empty_messages", messageCount: 0 };
+  }
+  const dbg = isDebug();
+  if (dbg) debug("capture", "parsed messages", summarizeTextMessages(parsed));
+  const turn = selectTurnMessages(parsed);
+  if (dbg) debug("capture", "selected turn", summarizeTextMessages(turn));
+  if (turn.length === 0) {
+    return { captured: false, reason: "empty_turn_slice", messageCount: 0 };
+  }
+  if (!turn.some((m) => m.role === "user")) {
+    return { captured: false, reason: "no_user_in_turn", messageCount: 0 };
+  }
+  const AUTOMATED_REVIEW_PREFIX = "[SYSTEM: This is an automated background review task. It is NOT a user message.";
+  const userMsgs = turn.filter((m) => m.role === "user");
+  if (userMsgs.every((m) => m.content.startsWith(AUTOMATED_REVIEW_PREFIX))) {
+    return { captured: false, reason: "automated_review_skip", messageCount: 0 };
+  }
+  const kb = isKnowledgeBaseUploadTurn(options.kbDetectionMessages);
+  if (kb.detected) {
+    return {
+      captured: false,
+      reason: `b3c_skip: ${kb.reason ?? "(no reason)"}`,
+      messageCount: 0
+    };
+  }
+  const rawMessages = turn.map((m) => ({ role: m.role, content: m.content }));
+  const filtered = filterMessagesForExtraction(rawMessages);
+  if (dbg) debug("capture", "filtered messages", summarizeTextMessages(filtered));
+  if (filtered.length === 0) {
+    return { captured: false, reason: "all_filtered", messageCount: 0 };
+  }
+  const git = getGitContext();
+  const skills = options.skills ?? [];
+  const bg = {};
+  if (git) bg.git = git;
+  if (skills.length > 0) bg.skills = skills.map(
+    ({ skill, trigger, args }) => args ? { skill, trigger, args } : { skill, trigger }
+  );
+  const hasBackground = Boolean(bg.git || bg.skills);
+  if (hasBackground) debug("capture", "background", bg);
+  const messages = hasBackground ? [{ role: "background", content: JSON.stringify(bg) }, ...filtered] : filtered;
+  const payload = {
+    messages,
+    user_id: cfg.userId,
+    async_mode: true
+  };
+  if (cfg.agentId) payload.agent_id = cfg.agentId;
+  if (cfg.appId) payload.app_id = cfg.appId;
+  if (sessionId) payload.run_id = sessionId;
+  let resp;
+  try {
+    resp = await client.postJson("/v3/memories/add/", payload);
+    resetCircuit(agent);
+  } catch (err) {
+    const msg = err instanceof CtxdbError ? err.message : String(err);
+    if (isConnectionError(err)) tripCircuit(agent, cfg.baseUrl, msg);
+    return {
+      captured: false,
+      reason: `http_error: ${msg}`,
+      messageCount: filtered.length
+    };
+  }
+  return {
+    captured: true,
+    reason: "ok",
+    serverResponse: resp,
+    messageCount: filtered.length
+  };
+}
+function capturePreflight(cfg, agent) {
+  if (!cfg.apiKey || !cfg.baseUrl) {
+    return { captured: false, reason: "config_incomplete", messageCount: 0 };
+  }
+  if (!cfg.autoCapture) {
+    return { captured: false, reason: "auto_capture_disabled", messageCount: 0 };
+  }
+  if (isCircuitOpen(agent, cfg.baseUrl)) {
+    return { captured: false, reason: `circuit_open: ${cfg.baseUrl}`, messageCount: 0 };
+  }
+  return null;
+}
+var DEBUG_TAIL_LIMIT = 25;
+var DEBUG_TEXT_LIMIT = 240;
+var DEBUG_BLOCK_LIMIT = 8;
+function summarizeTextMessages(messages) {
+  return {
+    count: messages.length,
+    roles: countRoles(messages),
+    tail: tailWithIndex(messages).map(({ index, item }) => ({
+      index,
+      parsedIndex: typeof item.index === "number" ? item.index : void 0,
+      role: item.role ?? "(unknown)",
+      content: summarizeText(item.content)
+    }))
+  };
+}
+function summarizeTranscriptRows(rows) {
+  return {
+    count: rows.length,
+    tail: tailWithIndex(rows).map(({ index, item: row }) => ({
+      index,
+      type: row.type,
+      role: rowRole(row),
+      isMeta: row.isMeta === true || void 0,
+      payloadType: row.payload?.type,
+      content: summarizeRowContent(row)
+    }))
+  };
+}
+function tailWithIndex(items) {
+  const start = Math.max(0, items.length - DEBUG_TAIL_LIMIT);
+  return items.slice(start).map((item, offset) => ({ index: start + offset, item }));
+}
+function countRoles(messages) {
+  const counts = {};
+  for (const msg of messages) {
+    const role = msg.role ?? "(unknown)";
+    counts[role] = (counts[role] ?? 0) + 1;
+  }
+  return counts;
+}
+function rowRole(row) {
+  const msgRole = row.message && typeof row.message === "object" ? row.message.role : void 0;
+  if (typeof msgRole === "string") return msgRole;
+  const payloadRole = row.payload && typeof row.payload === "object" ? row.payload.role : void 0;
+  return typeof payloadRole === "string" ? payloadRole : void 0;
+}
+function summarizeRowContent(row) {
+  if (row.type === "response_item") {
+    const p = row.payload;
+    if (!p || typeof p !== "object") return { kind: "missing" };
+    if (p.type === "function_call") {
+      return {
+        kind: "function_call",
+        name: p.name,
+        arguments: summarizeText(p.arguments)
+      };
+    }
+    return summarizeContent(p.content);
+  }
+  return summarizeContent(row.message?.content);
+}
+function summarizeContent(content) {
+  if (typeof content === "string") return summarizeText(content);
+  if (!Array.isArray(content)) {
+    return { kind: content === void 0 ? "missing" : typeof content };
+  }
+  return {
+    kind: "blocks",
+    count: content.length,
+    blocks: content.slice(0, DEBUG_BLOCK_LIMIT).map((block) => summarizeBlock(block)),
+    truncated: content.length > DEBUG_BLOCK_LIMIT || void 0
+  };
+}
+function summarizeBlock(block) {
+  if (!block || typeof block !== "object") return { kind: typeof block };
+  const b = block;
+  const summary = { type: b.type };
+  if (typeof b.name === "string") summary.name = b.name;
+  if (typeof b.text === "string") summary.text = summarizeText(b.text);
+  if (typeof b.thinking === "string") summary.thinking = summarizeText(b.thinking);
+  if (typeof b.content === "string") summary.content = summarizeText(b.content);
+  const input = b.input;
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    const i = input;
+    summary.inputKeys = Object.keys(i).sort();
+    if (typeof i.command === "string") summary.command = summarizeText(i.command);
+  }
+  return summary;
+}
+function summarizeText(text) {
+  if (typeof text !== "string") return { kind: text === void 0 ? "missing" : typeof text };
+  const normalized = text.replace(/\s+/g, " ").trim();
+  return {
+    kind: "text",
+    length: text.length,
+    snippet: normalized.length > DEBUG_TEXT_LIMIT ? `${normalized.slice(0, DEBUG_TEXT_LIMIT)}...` : normalized
+  };
+}
+
+export {
+  captureTurn,
+  captureParsedMessages
+};

package/dist/chunk-RZONPKY4.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import {
+  fetchKbCatalogBlock,
+  recallTurn
+} from "./chunk-EUQ3OFCQ.js";
+import {
+  isCircuitOpen
+} from "./chunk-TGVURF54.js";
+import {
+  HttpClient,
+  agentFromArgvWithFallback,
+  debug,
+  isComplete,
+  load,
+  setDebug
+} from "./chunk-6FZL67GH.js";
+import {
+  shouldSkipHooks
+} from "./chunk-UEKR2Z3S.js";
+
+// src/hooks/session-start.ts
+import { pathToFileURL } from "url";
+
+// src/lib/warmup-recall.ts
+import { execSync } from "child_process";
+import { basename } from "path";
+function collectGitSignals(cwd) {
+  const result = { branch: "", recentCommits: [] };
+  try {
+    result.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      timeout: 500,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+  }
+  try {
+    const log = execSync("git log --oneline -3 --no-decorate", {
+      cwd,
+      timeout: 500,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (log) {
+      result.recentCommits = log.split("\n").map((l) => {
+        const idx = l.indexOf(" ");
+        return idx > 0 ? l.slice(idx + 1) : l;
+      });
+    }
+  } catch {
+  }
+  return result;
+}
+function buildWarmupQuery(cwd, git) {
+  const project = basename(cwd) || "unknown";
+  const parts = [`project: ${project}`];
+  if (git.branch) {
+    parts.push(`branch: ${git.branch}`);
+  }
+  if (git.recentCommits.length > 0) {
+    parts.push(`recent work: ${git.recentCommits.join("; ")}`);
+  }
+  return parts.join(", ");
+}
+async function warmupRecall(cwd, cfg, client) {
+  if (!cfg.warmupRecall) {
+    return { ok: false, reason: "warmup_recall_disabled", additionalContext: "", memoryCount: 0, knowledgeChunkCount: 0 };
+  }
+  const git = collectGitSignals(cwd);
+  const query = buildWarmupQuery(cwd, git);
+  return recallTurn(query, cfg, client);
+}
+
+// src/hooks/session-start.ts
+var HOOK_TIMEOUT_MS = 5e3;
+function timeout(ms) {
+  return new Promise((resolve) => setTimeout(() => resolve(null), ms));
+}
+async function composeSessionStart(cfg, agent, client, cwd, timeoutMs = HOOK_TIMEOUT_MS) {
+  const kbInjectHere = cfg.kbCatalogInjection === "session_start";
+  const warmupPromise = cfg.warmupRecall ? Promise.race([warmupRecall(cwd, cfg, client), timeout(timeoutMs).then(() => null)]) : Promise.resolve(null);
+  const kbPromise = kbInjectHere ? Promise.race([fetchKbCatalogBlock(client, agent).catch(() => ""), timeout(timeoutMs).then(() => "")]) : Promise.resolve("");
+  const [result, kbBlock] = await Promise.all([warmupPromise, kbPromise]);
+  const warmupTimedOut = cfg.warmupRecall && result === null;
+  const warmupCtx = result && result.ok ? result.additionalContext || "" : "";
+  if (!warmupCtx && result && !result.ok) {
+    debug("warmup", `no result: ${result.reason}`);
+  }
+  let ctx = warmupCtx;
+  if (kbBlock) ctx = ctx ? `${ctx}
+
+${kbBlock}` : kbBlock;
+  return {
+    ctx,
+    memoryCount: result?.ok ? result.memoryCount : 0,
+    kbChunkCount: result?.ok ? result.knowledgeChunkCount : 0,
+    kbCatalogLines: kbBlock ? kbBlock.split("\n").length : 0,
+    warmupTimedOut
+  };
+}
+function formatSessionStartStdout(agent, ctx) {
+  if (agent === "codex") return ctx + "\n";
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: ctx
+    }
+  };
+  return JSON.stringify(out) + "\n";
+}
+async function readStdinJson() {
+  let raw = "";
+  for await (const chunk of process.stdin) raw += chunk;
+  if (!raw.trim()) return {};
+  try {
+    const obj = JSON.parse(raw);
+    return obj && typeof obj === "object" && !Array.isArray(obj) ? obj : {};
+  } catch {
+    return {};
+  }
+}
+async function main() {
+  try {
+    if (shouldSkipHooks()) return 0;
+    const event = await readStdinJson();
+    const { agent, fellBack } = agentFromArgvWithFallback();
+    if (fellBack) {
+      process.stderr.write(
+        `ctxdb warmup: agent unspecified, defaulting to ${agent}
+`
+      );
+    }
+    const cwd = typeof event.cwd === "string" ? event.cwd : "";
+    if (!cwd) return 0;
+    const cfg = load({ agent });
+    setDebug(cfg.debug);
+    debug("warmup", "start", { cwd, userId: cfg.userId });
+    const kbInjectHere = cfg.kbCatalogInjection === "session_start";
+    if (!isComplete(cfg) || !cfg.warmupRecall && !kbInjectHere) {
+      debug("warmup", "skip (config incomplete or both warmup+kb off)");
+      return 0;
+    }
+    if (isCircuitOpen(agent, cfg.baseUrl)) {
+      debug("warmup", "skip (circuit open)");
+      return 0;
+    }
+    const client = new HttpClient({
+      baseUrl: cfg.baseUrl,
+      apiKey: cfg.apiKey,
+      timeoutMs: HOOK_TIMEOUT_MS
+    });
+    const composed = await composeSessionStart(cfg, agent, client, cwd);
+    if (composed.warmupTimedOut) {
+      process.stderr.write("ctxdb warmup: timeout\n");
+    }
+    if (!composed.ctx) return 0;
+    const { memoryCount, kbChunkCount, kbCatalogLines, ctx } = composed;
+    debug(
+      "warmup",
+      `ok, memories=${memoryCount} kb=${kbChunkCount} kb_catalog=${kbCatalogLines}`
+    );
+    process.stderr.write(
+      `ctxdb warmup: ok (${memoryCount} memories, ${kbChunkCount} kb chunks, kb_catalog=${kbCatalogLines} lines)
+`
+    );
+    process.stdout.write(formatSessionStartStdout(agent, ctx));
+    return 0;
+  } catch (err) {
+    process.stderr.write(`ctxdb warmup: unexpected error: ${err?.message ?? err}
+`);
+    return 0;
+  }
+}
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  main().then((code) => {
+    process.exitCode = code;
+  });
+}
+
+export {
+  HOOK_TIMEOUT_MS,
+  composeSessionStart,
+  formatSessionStartStdout
+};

package/dist/{chunk-UULWJJT4.js → chunk-TGVURF54.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   configDir
-} from "./chunk-TKMIWM6Q.js";
+} from "./chunk-6FZL67GH.js";
 
 // src/lib/circuit.ts
 import { statSync, writeFileSync, unlinkSync, mkdirSync, readdirSync, readFileSync } from "fs";