petbox-wire 0.1.0-ci.543

package/src/import-sessions.ts

@@ -0,0 +1,256 @@
+// History importer (spec: wiring-history-import) — backfill the PetBox session archive
+// from the agents' LOCAL history, so a freshly connected project starts with a warm
+// memory instead of an empty one:
+//
+//   node --experimental-strip-types import-sessions.ts [--agent claude|opencode|all]
+//        [--project <key>] [--dry-run] [--since YYYY-MM-DD] [--limit N] [--force]
+//
+// Two invariants protect the archive:
+//   native ids   — a session is pushed under the SAME id its agent's live hook/plugin
+//                  uses (Claude: transcript uuid; opencode: ses_…), so an import lands
+//                  in the same latest-snapshot row — duplicates are impossible;
+//   upgrade-only — latest-snapshot is last-write-wins, so before pushing we compare the
+//                  local message count against the server version (GET /api/sessions)
+//                  and skip unless local is strictly larger (--force overrides) — a
+//                  stale file read can never roll back a fresher snapshot.
+//
+// Only dialogue turns are sent (shared transcript.ts parsing — the same code the Stop
+// hook runs); raw tool outputs never leave the machine. Server-side, the cursor-driven
+// pipelines (digest, facts, patterns) backfill on their own after the push.
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+import { readRegistry, resolveProject, type ResolvedProject } from "./registry.ts";
+import { buildMessages, readTranscriptCwd, type Msg } from "./transcript.ts";
+
+const FETCH_TIMEOUT_MS = 30000;
+
+type Args = {
+  agent: "claude" | "opencode" | "all";
+  project?: string;
+  dryRun: boolean;
+  since?: Date;
+  limit?: number;
+  force: boolean;
+};
+
+type Candidate = {
+  agent: string;
+  sessionId: string;
+  updated: Date;
+  load: () => Promise<Msg[]>;
+};
+
+function parseArgs(argv: string[]): Args {
+  const a: Args = { agent: "all", dryRun: false, force: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--agent") a.agent = (argv[++i] as Args["agent"]) ?? "all";
+    else if (arg === "--project") a.project = argv[++i];
+    else if (arg === "--dry-run") a.dryRun = true;
+    else if (arg === "--force") a.force = true;
+    else if (arg === "--since") a.since = new Date(argv[++i] ?? "");
+    else if (arg === "--limit") a.limit = parseInt(argv[++i] ?? "0", 10) || undefined;
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+  if (!["claude", "opencode", "all"].includes(a.agent)) throw new Error(`invalid --agent: ${a.agent}`);
+  if (a.since && isNaN(a.since.getTime())) throw new Error("invalid --since (use YYYY-MM-DD)");
+  return a;
+}
+
+// The target: --project finds the registry entry by project key; otherwise the cwd
+// resolves like the hooks do.
+function resolveTarget(projectKey?: string): ResolvedProject {
+  if (projectKey) {
+    const entry = readRegistry().find((e) => e.project === projectKey);
+    if (!entry) throw new Error(`project '${projectKey}' not found in ~/.petbox/projects.json`);
+    const apiKey = process.env[entry.envVar];
+    if (!apiKey) throw new Error(`env var ${entry.envVar} is empty`);
+    return {
+      project: entry.project,
+      apiKey,
+      baseUrl: (entry.baseUrl ?? "https://petbox.3po.su").replace(/\/+$/, ""),
+      envVar: entry.envVar,
+    };
+  }
+  const resolved = resolveProject(process.cwd());
+  if (!resolved) throw new Error("cwd is not a registered project (or its env var is empty); use --project");
+  return resolved;
+}
+
+function listDirs(path: string): string[] {
+  try {
+    return readdirSync(path, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+
+function listFiles(path: string, ext: string): string[] {
+  try {
+    return readdirSync(path).filter((f) => f.endsWith(ext));
+  } catch {
+    return [];
+  }
+}
+
+function readJson(path: string): any | null {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// Claude Code: ~/.claude/projects/<encoded-cwd>/*.jsonl. The encoding is lossy, so a
+// transcript is attributed by the cwd recorded INSIDE it, resolved through the same
+// registry matching the hooks use (worktrees and subfolders included).
+async function claudeCandidates(target: ResolvedProject): Promise<Candidate[]> {
+  const root = join(homedir(), ".claude", "projects");
+  const out: Candidate[] = [];
+  for (const dir of listDirs(root)) {
+    for (const file of listFiles(join(root, dir), ".jsonl")) {
+      const path = join(root, dir, file);
+      const cwd = await readTranscriptCwd(path);
+      if (!cwd) continue;
+      const resolved = resolveProject(cwd);
+      if (!resolved || resolved.project !== target.project) continue;
+      out.push({
+        agent: "claude-code",
+        sessionId: basename(file, ".jsonl"),
+        updated: statSync(path).mtime,
+        load: () => buildMessages(path),
+      });
+    }
+  }
+  return out;
+}
+
+// opencode: ~/.local/share/opencode/storage —
+//   session/<projectHash>/<ses>.json  {id, directory, time.updated}
+//   message/<ses>/<msg>.json          {id, role, time.created}
+//   part/<msg>/<prt>.json             {type:"text", text}
+// A session is attributed by its recorded `directory`; content = the text parts of each
+// message, in message-time order — the same dialogue-only shape the live plugin pushes.
+function opencodeCandidates(target: ResolvedProject): Candidate[] {
+  const storage = join(homedir(), ".local", "share", "opencode", "storage");
+  const out: Candidate[] = [];
+  for (const hash of listDirs(join(storage, "session"))) {
+    for (const file of listFiles(join(storage, "session", hash), ".json")) {
+      const info = readJson(join(storage, "session", hash, file));
+      if (!info || typeof info.id !== "string" || typeof info.directory !== "string") continue;
+      const resolved = resolveProject(info.directory);
+      if (!resolved || resolved.project !== target.project) continue;
+      const sessionId = info.id;
+      out.push({
+        agent: "opencode",
+        sessionId,
+        updated: new Date(info.time?.updated ?? info.time?.created ?? 0),
+        load: async () => {
+          const msgDir = join(storage, "message", sessionId);
+          const metas = listFiles(msgDir, ".json")
+            .map((f) => readJson(join(msgDir, f)))
+            .filter((m) => m && typeof m.role === "string")
+            .sort((a, b) => (a.time?.created ?? 0) - (b.time?.created ?? 0) || String(a.id).localeCompare(String(b.id)));
+          const msgs: Msg[] = [];
+          for (const meta of metas) {
+            const partDir = join(storage, "part", meta.id);
+            const text = listFiles(partDir, ".json")
+              .sort()
+              .map((f) => readJson(join(partDir, f)))
+              .filter((p) => p && p.type === "text" && typeof p.text === "string")
+              .map((p) => p.text)
+              .join("\n")
+              .trim();
+            if (text.length === 0) continue;
+            msgs.push({ role: meta.role, content: text });
+          }
+          return msgs;
+        },
+      });
+    }
+  }
+  return out;
+}
+
+async function serverVersions(target: ResolvedProject): Promise<Map<string, number>> {
+  const res = await fetch(`${target.baseUrl}/api/sessions/${target.project}`, {
+    headers: { "X-Api-Key": target.apiKey },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  });
+  if (!res.ok) throw new Error(`GET /api/sessions/${target.project} → ${res.status}`);
+  const body = (await res.json()) as { sessions?: { sessionId: string; version: number }[] };
+  return new Map((body.sessions ?? []).map((s) => [s.sessionId, s.version]));
+}
+
+async function push(target: ResolvedProject, c: Candidate, msgs: Msg[]): Promise<void> {
+  const body = msgs.map((m) => JSON.stringify(m)).join("\n");
+  const uri = `${target.baseUrl}/api/sessions/${target.project}/${encodeURIComponent(c.sessionId)}?agent=${encodeURIComponent(c.agent)}`;
+  const res = await fetch(uri, {
+    method: "POST",
+    headers: { "X-Api-Key": target.apiKey, "Content-Type": "application/x-ndjson; charset=utf-8" },
+    body,
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  });
+  if (!res.ok) throw new Error(`POST ${c.sessionId} → ${res.status}`);
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const target = resolveTarget(args.project);
+  console.log(`importing into '${target.project}' @ ${target.baseUrl} (agent: ${args.agent}${args.dryRun ? ", DRY-RUN" : ""})`);
+
+  let candidates: Candidate[] = [];
+  if (args.agent === "claude" || args.agent === "all") candidates.push(...(await claudeCandidates(target)));
+  if (args.agent === "opencode" || args.agent === "all") candidates.push(...opencodeCandidates(target));
+  candidates.sort((a, b) => a.updated.getTime() - b.updated.getTime());
+
+  const filtered = args.since ? candidates.filter((c) => c.updated >= args.since!) : candidates;
+  const skippedFiltered = candidates.length - filtered.length;
+  const capped = args.limit ? filtered.slice(0, args.limit) : filtered;
+  const skippedLimit = filtered.length - capped.length;
+
+  const versions = await serverVersions(target);
+  let pushed = 0, upToDate = 0, empty = 0, failed = 0, totalMsgs = 0;
+  for (const c of capped) {
+    try {
+      const msgs = await c.load();
+      if (msgs.length === 0) {
+        empty++;
+        continue;
+      }
+      const server = versions.get(c.sessionId) ?? 0;
+      if (!args.force && msgs.length <= server) {
+        upToDate++; // upgrade-only: never roll a fresher snapshot back
+        continue;
+      }
+      if (args.dryRun) {
+        console.log(`  would push ${c.agent} ${c.sessionId}: ${msgs.length} msgs (server: ${server})`);
+        pushed++;
+        totalMsgs += msgs.length;
+        continue;
+      }
+      await push(target, c, msgs);
+      pushed++;
+      totalMsgs += msgs.length;
+      console.log(`  pushed ${c.agent} ${c.sessionId}: ${msgs.length} msgs (server was ${server})`);
+    } catch (e) {
+      failed++;
+      console.error(`  FAILED ${c.sessionId}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+
+  console.log(
+    `done: ${pushed} pushed (${totalMsgs} msgs), ${upToDate} up-to-date, ${empty} empty, ` +
+      `${skippedFiltered} before --since, ${skippedLimit} over --limit, ${failed} failed`,
+  );
+  if (pushed > 0 && !args.dryRun)
+    console.log("note: server pipelines (digest/facts/patterns) will backfill in the background over the next minutes.");
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch((e) => {
+  console.error(e instanceof Error ? e.message : e);
+  process.exit(1);
+});

package/src/opencode-plugin.ts

@@ -0,0 +1,106 @@
+/**
+ * PetBox plugin for opencode (GLOBAL) — the opencode port of the two Claude Code hooks:
+ *
+ *   1. pull-memory  (SessionStart) → inject the PetBox memory protocol so the agent recalls
+ *      relevant memory and captures learnings via the connected `petbox` MCP. Appended to the
+ *      system prompt via `experimental.chat.system.transform`.
+ *
+ *   2. push-session (Stop) → mirror the session conversation into PetBox's Session module so it
+ *      auto-populates. Fires on `session.idle` (opencode's "the turn finished") and pushes the
+ *      INCREMENT via the server-authoritative append cursor (see append.ts) — the plugin is
+ *      long-lived, so it remembers each session's lastOrdinal from the previous response in
+ *      process memory (no durable state); a restart self-heals off the structured 409 gap
+ *      reject, and old servers without the append route fall back to the full-snapshot push.
+ *
+ * Unlike the per-project copy this is installed once at user scope. The active project + API
+ * key + base URL are resolved from `directory` (PluginInput) via the shared registry. If the
+ * cwd is not a registered project (or the key is missing) BOTH hooks are no-ops — but the
+ * plugin still loads cleanly in every project.
+ *
+ * Both hooks are best-effort and must never break a turn (every failure is swallowed).
+ *
+ * MCP note: opencode exposes MCP tools as `<server>_<tool>`, so the petbox memory verbs are
+ * `petbox_memory_search` / `petbox_memory_remember` / `petbox_memory_get` /
+ * `petbox_memory_upsert` (the Claude `mcp__petbox__*` names do not apply here).
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+import { pushTranscript } from "./append.ts";
+import { fetchCanonBlock } from "./canon.ts";
+import { buildProtocol, opencodePetboxTool } from "./protocol.ts";
+import { resolveProject } from "./registry.ts";
+
+export const PetboxPlugin: Plugin = async ({ client, directory }) => {
+  // Resolve the active project once at load. null → both hooks no-op.
+  const resolved = resolveProject(directory ?? "");
+
+  // Avoid re-POSTing the same state when session.idle fires repeatedly.
+  const lastPushed = new Map<string, string>();
+  // Per-session server cursor (lastOrdinal from the previous response). Process memory only —
+  // a plugin restart just means the first push self-heals via the structured gap reject.
+  const cursors = new Map<string, number>();
+
+  async function pushSession(sessionID: string): Promise<void> {
+    if (!resolved || !sessionID) return;
+
+    const res = await client.session.messages({ path: { id: sessionID } });
+    const messages = res.data;
+    if (!Array.isArray(messages) || messages.length === 0) return;
+
+    // The whole conversation (user + assistant text turns), ordered — pushTranscript sends
+    // only the tail past the remembered server cursor (the increment), not the full history.
+    const msgs = messages
+      .map((m: any) => {
+        const text = m.parts
+          .filter((p: any) => p.type === "text" && typeof p.text === "string")
+          .map((p: any) => p.text)
+          .join("\n")
+          .trim();
+        return text ? { role: m.info.role, content: text } : null;
+      })
+      .filter(Boolean) as { role: string; content: string }[];
+    if (msgs.length === 0) return;
+    const lastID = messages[messages.length - 1]?.info?.id ?? "";
+    if (lastPushed.get(sessionID) === lastID) return;
+
+    const lastOrdinal = await pushTranscript(
+      {
+        baseUrl: resolved.baseUrl,
+        project: resolved.project,
+        sessionId: sessionID,
+        apiKey: resolved.apiKey,
+        agent: "opencode",
+        timeoutMs: 8000,
+      },
+      msgs,
+      cursors.get(sessionID) ?? null,
+    );
+    if (lastOrdinal !== null) {
+      cursors.set(sessionID, lastOrdinal);
+      lastPushed.set(sessionID, lastID);
+    }
+  }
+
+  return {
+    // Port of pull-memory — make the memory protocol part of the system prompt.
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (!resolved) return;
+      output.system.push(buildProtocol(resolved.project, opencodePetboxTool));
+      // Append the curated memory canon when available (best-effort; degrades to nothing).
+      const canon = await fetchCanonBlock(resolved);
+      if (canon) output.system.push(canon);
+    },
+
+    // Port of push-session — mirror the finished turn into PetBox's Session module.
+    event: async ({ event }) => {
+      if (event.type !== "session.idle") return;
+      const sessionID = (event as any).properties?.sessionID;
+      try {
+        await pushSession(sessionID);
+      } catch {
+        /* best-effort: never break the turn */
+      }
+    },
+  };
+};
+
+export default PetboxPlugin;

package/src/protocol.ts

@@ -0,0 +1,72 @@
+// Shared PetBox memory-protocol builder — the ONE implementation every SessionStart injector
+// renders from (pull-memory.ts for Claude Code, opencode-plugin.ts for opencode,
+// droid-pull-memory.ts for Factory Droid), so the protocol text can no longer drift between
+// agents as hand-synced copies (spec: agent-wiring, wiring-single-source).
+//
+// The ONLY thing that varies per agent is how an MCP tool is named: pass a `tool` mapper that
+// turns a bare verb (e.g. "memory_search") into that agent's fully-qualified tool name. Claude
+// Code and Droid both expose petbox tools as `mcp__petbox__<verb>`; opencode as `petbox_<verb>`.
+//
+// The CC-only "resume/compact" suffix is opt-in via `opts.source` (Droid's SessionStart payload
+// also carries a `source`, so it shares the same behavior). Any other source = no suffix.
+//
+// Plain TS for native node type-stripping: no enum/namespace/parameter-properties, zero deps.
+
+export type ToolNamer = (verb: string) => string;
+
+export type ProtocolOpts = {
+  // The SessionStart `source` (Claude Code / Droid). "resume" | "compact" append a recall nudge;
+  // anything else (or omitted) renders the base protocol only.
+  source?: string;
+};
+
+// Build the memory-protocol block for a project. `tool` maps a bare verb to the agent's
+// fully-qualified MCP tool name so the SAME text renders correct tool names everywhere.
+export function buildProtocol(project: string, tool: ToolNamer, opts?: ProtocolOpts): string {
+  const memorySearch = tool("memory_search");
+  const memoryGet = tool("memory_get");
+  const sessionSearch = tool("session_search");
+  const sessionGet = tool("session_get");
+  const memoryRemember = tool("memory_remember");
+  const memoryUpsert = tool("memory_upsert");
+  const tasksUpsert = tool("tasks_upsert");
+
+  let out = `## PetBox memory
+
+This project is wired to PetBox (project \`${project}\`) over the connected \`petbox\` MCP.
+
+In your FIRST response this session, open with exactly this line (so it's visible the protocol is active):
+\`🧠 PetBox memory active\`
+
+PetBox remembers a LOT about this project — the curated facts AND the full session history (imported + auto-pushed). Start reasoning about anything past from a SEARCH, not from assumption.
+
+**Rule — search before you (re)work:** before re-deriving, re-investigating, or re-deciding ANYTHING about this project's past, run \`${memorySearch}\` FIRST — redoing work the project already remembers is the failure mode this protocol exists to prevent. And before you store a new fact, \`${memorySearch}\` for an existing one and edit that instead (duplicates poison recall).
+
+The entry point has two legs:
+
+- **Facts — \`${memorySearch}\`**: a \`q\` of a few words you are confident appear (tokens are ANDed, prefix-matched; wordforms stem), pass \`bodyLen\` (e.g. 240) for cheap snippets. With no \`scope\` it cascades project ⊕ workspace and EVERY store — curated notes and the machine-distilled \`autocaptured\` quarantine alike (the store label in each hit tells you which). Without \`q\` it's a plain listing (freshest first). Pull a full body with \`${memoryGet}\`.
+- **Past conversations — \`${sessionSearch}\`**: when you need HOW something was decided, an error text, or any detail a fact wouldn't carry — two-stage search over the whole session archive; every hit carries the message ordinal, so \`${sessionGet}\` jumps to the verbatim source.
+
+As you work, **capture** incrementally (don't wait for session end): after a decision, a fixed bug, a discovered pattern, or a stated preference, store a concise fact via \`${memoryRemember}\` (\`text\` = the learning; \`type\` = User|Feedback|Project|Reference; \`scope\` = workspace for facts that span projects or are about the user, else omit for this project). Curated/temporal edits go through \`${memoryUpsert}\`.
+
+**Background autocapture is LIVE:** after a session settles (~minutes), the server distills durable facts and recurring behavior patterns from it into the \`autocaptured\` store on its own. So: (1) don't re-store what memory_search already shows as autocaptured — promote-worthy entries are the owner's call; (2) the **end-of-session sweep** is now an INSURANCE pass, not the only capture: before you stop, store the 1-3 learnings that must not wait for background distillation (a key decision + why, a root cause, a gotcha) — and also record 0-2 process-friction observations (what got in the way, what you had to work around, what looked stale) — skip narration and anything derivable from code/git.
+
+**Process defects are findings, not obstacles:** never silently work around a process/doc defect or a contradiction between a document and reality — file an intake issue on the project's \`intake\` board (\`${tasksUpsert}\` type:"issue" status:"reported") instead of swallowing it. Criticism of the process is explicitly welcome and is never scope creep.`;
+
+  const source = opts?.source;
+  if (source === "resume" || source === "compact") {
+    out += `\n\nSession ${source} — also recall recent session/decision memories to pick up where you left off.`;
+  }
+  return out;
+}
+
+// The Claude-Code / Droid tool namer: petbox tools are exposed as `mcp__petbox__<verb>`.
+export const mcpPetboxTool: ToolNamer = (verb) => `mcp__petbox__${verb}`;
+
+// The opencode tool namer: petbox tools are exposed as `petbox_<verb>`.
+export const opencodePetboxTool: ToolNamer = (verb) => `petbox_${verb}`;
+
+// Factory Droid exposes MCP tools as `<server>___<tool>` (triple underscore) — observed
+// live in exec mode (session 7be9f6c2: `mcp__petbox__*` answers "not permitted in exec
+// mode"); the docs' `mcp__<server>__<tool>` form did not match the shipped CLI.
+export const droidPetboxTool: ToolNamer = (verb) => `petbox___${verb}`;

package/src/pull-memory.ts

@@ -0,0 +1,51 @@
+// Claude Code SessionStart hook (global) — port of pull-memory.ps1.
+//
+// Injects the PetBox memory protocol so the agent recalls relevant memory at session start
+// and captures learnings as it works, via the already-connected petbox MCP (native memory.*
+// tools). Stdout is added to the session context by Claude Code.
+//
+// The project is resolved from cwd via the shared registry; if the cwd is not a registered
+// project this prints nothing and exits 0. Best-effort, never blocks — always exit 0.
+
+import { fetchCanonBlock } from "./canon.ts";
+import { buildProtocol, mcpPetboxTool } from "./protocol.ts";
+import { resolveProject } from "./registry.ts";
+
+type HookInput = { cwd?: string; source?: string };
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let buf = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (buf += c));
+    process.stdin.on("end", () => resolve(buf));
+    process.stdin.on("error", () => resolve(buf));
+  });
+}
+
+async function main(): Promise<void> {
+  let source = "startup";
+  let cwd = "";
+  try {
+    const raw = await readStdin();
+    const j: HookInput = JSON.parse(raw);
+    if (typeof j.source === "string" && j.source.trim()) source = j.source.trim();
+    if (typeof j.cwd === "string") cwd = j.cwd;
+  } catch {
+    // fall through with defaults; cwd stays empty → resolves to null below
+  }
+
+  try {
+    const resolved = resolveProject(cwd);
+    if (!resolved) return; // not a registered project → no output
+    let out = buildProtocol(resolved.project, mcpPetboxTool, { source });
+    // Append the curated memory canon when available (best-effort; degrades to nothing).
+    const canon = await fetchCanonBlock(resolved);
+    if (canon) out += `\n\n${canon}`;
+    process.stdout.write(out);
+  } catch {
+    // best-effort
+  }
+}
+
+main().finally(() => process.exit(0));

package/src/push-session.ts

@@ -0,0 +1,84 @@
+// Claude Code Stop hook (global) — port of push-session.ps1.
+//
+// Mirrors the session conversation into PetBox's Session module so the board auto-populates.
+// The project + API key are resolved from cwd via the shared registry; if the cwd is not a
+// registered project this exits immediately (first guard, before any work).
+//
+// Reads the full transcript JSONL, extracts the user/assistant text turns (tool dumps and
+// system reminders excluded), and pushes only the INCREMENT via the server-authoritative
+// append cursor (see append.ts): this process is fresh each turn, so it optimistically
+// resends a small idempotent overlap window; a contiguity gap comes back as a structured
+// 409 with the server's lastOrdinal and the tail is resent from there. Old servers without
+// the append route fall back to the legacy full-snapshot push. Best-effort: every failure
+// is swallowed and we ALWAYS exit 0 — never break the user's session.
+
+import { pushTranscript } from "./append.ts";
+import { resolveProject } from "./registry.ts";
+import { buildMessages, type Msg } from "./transcript.ts";
+
+const FETCH_TIMEOUT_MS = 12000;
+
+type HookInput = {
+  session_id?: string;
+  transcript_path?: string;
+  cwd?: string;
+  stop_hook_active?: boolean;
+};
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let buf = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (buf += c));
+    process.stdin.on("end", () => resolve(buf));
+    process.stdin.on("error", () => resolve(buf));
+  });
+}
+
+async function main(): Promise<void> {
+  try {
+    const raw = await readStdin();
+    let j: HookInput;
+    try {
+      j = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (j.stop_hook_active) return;
+
+    // FIRST guard: not a registered project → silent no-op.
+    const resolved = resolveProject(j.cwd ?? "");
+    if (!resolved) return;
+
+    const sid = (j.session_id ?? "").trim();
+    const tp = (j.transcript_path ?? "").trim();
+    if (!sid || !tp) return;
+
+    let msgs: Msg[];
+    try {
+      msgs = await buildMessages(tp);
+    } catch {
+      return; // transcript missing/unreadable
+    }
+    if (msgs.length === 0) return; // empty body → server returns 400, don't push
+
+    // Fresh process each turn → no remembered cursor (null): pushTranscript guesses an
+    // idempotent overlap window and self-heals off the server's structured gap reject.
+    await pushTranscript(
+      {
+        baseUrl: resolved.baseUrl,
+        project: resolved.project,
+        sessionId: sid,
+        apiKey: resolved.apiKey,
+        agent: "claude-code",
+        timeoutMs: FETCH_TIMEOUT_MS,
+      },
+      msgs,
+      null,
+    );
+  } catch {
+    // best-effort: never break the user's session
+  }
+}
+
+main().finally(() => process.exit(0));