@cstart/coldstart 2.2.14 → 2.2.16

package/hooks/capture-sentinel.mjs

@@ -0,0 +1,10 @@
+/**
+ * capture-sentinel.mjs — the marker `/capture-notes` command bodies carry so a
+ * host's own pre-prompt recall hook can recognize "this submitted prompt IS
+ * the capture command" and run `kb-elicit.mjs --manual` itself with the real
+ * session id it already has (Cursor/Codex have no way to pass a session id
+ * INTO the command the way Claude's `!`-expansion does). Wording in the
+ * command body can drift; this string must not — it is grepped verbatim
+ * against the raw submitted prompt.
+ */
+export const CAPTURE_SENTINEL = "<!-- coldstart:capture-notes -->";

package/hooks/codex-kb-elicit.mjs

@@ -105,7 +105,11 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
     const ignore = loadIgnore(root);
     // Session-cumulative v2 state: which files were already offered, and how
     // far into the rollout the last Stop read (a resumed thread appends).
-    const marker = join(tmpdir(), `coldstart-codex-kb-${sid}-${aid}.json`);
+    // Unified marker namespace (2026-08-06): manual /capture-notes always ran
+    // the SHARED kb-elicit.mjs --manual, which reads coldstart-kb-<sid>-<aid>.json
+    // — a per-host prefix here meant it could never see this host's own
+    // automatic evidence. One prefix for all three hosts fixes that outright.
+    const marker = join(tmpdir(), `coldstart-kb-${sid}-${aid}.json`);
     let state = null;
     try {
       const parsed = JSON.parse(readFileSync(marker, "utf8"));
@@ -140,7 +144,7 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
 
     const entries = worklistEntries(CLI, root, fresh, state.files, log);
     const payload = buildCapturePayload({
-      root, cli: CLI, sid, entries,
+      root, cli: CLI, sid, aid, entries,
       envelope: isSubagent ? "subagent" : "block",
     });
     logCaptureEvent(root, {

package/hooks/codex-kb-recall.mjs

@@ -18,6 +18,17 @@
  * arriving via PRs are a prompt-injection surface; the framing line is the
  * cheap mitigation.
  *
+ * MANUAL CAPTURE ON-DEMAND (2026-08-06): Codex's `/capture-notes` skill has no
+ * way to pass its own real session id into `kb-elicit.mjs --manual` the way
+ * Claude's `!`-expansion does — the skill body used to just ask the agent to
+ * run the command itself, blind to which session it's in. But THIS hook
+ * receives a real `input.session_id` on every prompt. So: when the submitted
+ * prompt IS the capture skill (its body carries a stable sentinel,
+ * CAPTURE_SENTINEL), run `--manual --session <real sid>` right here and inject
+ * its output — deterministic, no LLM has to type a correct `--session <id>`.
+ * The skill body keeps "run this in the terminal" as a fallback for when this
+ * hook is disabled or fails. See hooks/capture-sentinel.mjs.
+ *
  * Self-contained + fail-open: ANY error → exit 0 with no stdout → nothing
  * injected, the prompt proceeds untouched.
  */
@@ -29,6 +40,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 // Strip host telemetry wrappers before the query is built — see recall-query.mjs.
 import { recallQuery } from "./recall-query.mjs";
+import { CAPTURE_SENTINEL } from "./capture-sentinel.mjs";
 // Per-session dedup shared with the other recall hooks — see recall-seen.mjs.
 // Hosts with no transcript path never reset; dedup still holds for the session.
 import { readSeen, writeSeen, idsInPage, seenArgs } from "./recall-seen.mjs";
@@ -78,11 +90,43 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
 
     const sid = String(input.session_id || "").replace(/[^\w-]/g, "");
 
-    // No notebook → no tax, not even a child process.
-    if (!existsSync(join(root, ".coldstart", "notebook", ".raw"))) process.exit(0);
+    // The submitted prompt IS /capture-notes (its skill body carries this
+    // sentinel) → run the on-demand capture ourselves with the real session id
+    // this hook already has, instead of leaving the agent to guess one.
+    let manual = "";
+    if (sid && String(input.prompt || "").includes(CAPTURE_SENTINEL)) {
+      try {
+        const elicit = fileURLToPath(new URL("./kb-elicit.mjs", import.meta.url));
+        manual = execFileSync("node", [elicit, "--manual", "--session", sid, "--root", root], {
+          encoding: "utf8",
+          timeout: 8000,
+          stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (manual) log(`MANUAL-INJECT session=${sid} bytes=${manual.length}`);
+      } catch (e) {
+        log(`manual-capture-inject failed: ${String(e).split("\n")[0]}`);
+      }
+    }
+
+    // Below this point, every early exit falls back to delivering the manual
+    // capture alone (if we have one) instead of exiting silently — a recall
+    // miss must never swallow an explicit /capture-notes.
+    const deliverManualOnlyAndExit = (why) => {
+      if (!manual) process.exit(0);
+      log(`INJECT bytes=${manual.length} (manual only, ${why})`);
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: manual },
+      }));
+      process.exit(0);
+    };
+
+    // No notebook → no recall tax, not even a child process (the manual
+    // capture above is independent of the notebook existing — it's what
+    // creates the first note).
+    if (!existsSync(join(root, ".coldstart", "notebook", ".raw"))) deliverManualOnlyAndExit("no notebook yet");
 
     const prompt = recallQuery(input.prompt, MAX_QUERY_CHARS);
-    if (!prompt) process.exit(0);
+    if (!prompt) deliverManualOnlyAndExit("empty query");
 
     // Ephemeral Codex runs expose no rollout path; readSeen then never resets,
     // which is the safe direction — dedup simply holds for the whole session.
@@ -99,12 +143,12 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
       });
     } catch (e) {
       log(`search failed/timed out: ${String(e).split("\n")[0]}`);
-      process.exit(0);
+      deliverManualOnlyAndExit("search failed");
     }
 
     if (!page.trim() || page.startsWith("No notebook notes match") || page.startsWith("No notebook in")) {
       log(`no hits (promptChars=${prompt.length})`);
-      process.exit(0);
+      deliverManualOnlyAndExit("no recall hits");
     }
 
     // Record what this page hands over before the size guards can trim it — a
@@ -140,6 +184,11 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
     // never exceed 8.5KB.
     if (block.length > 8500) block = block.slice(0, 8500) + "\n…(truncated)";
 
+    // An explicit /capture-notes rides FIRST — it's what the user asked for
+    // this turn. If the combination would spill past the host's payload cap,
+    // recall yields — the capture checklist must arrive whole.
+    if (manual) block = manual.length + block.length > 9500 ? manual : `${manual}\n\n---\n\n${block}`;
+
     // Arm the PostToolUse nudge detectors (nudge-handler.mjs gates its spiral
     // detectors on seen_find so it never nags sessions that don't use coldstart).
     // An injected session IS coldstart-aware even if it never runs `find` — the

package/hooks/cursor-kb-elicit.mjs

@@ -121,7 +121,11 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
     if (!transcriptPath || !existsSync(transcriptPath)) { log("SKIP no-transcript"); process.exit(0); }
 
     const ignore = loadIgnore(root);
-    const marker = join(tmpdir(), `coldstart-cursor-kb-${sid}-${aid}.json`);
+    // Unified marker namespace (2026-08-06): manual /capture-notes always ran
+    // the SHARED kb-elicit.mjs --manual, which reads coldstart-kb-<sid>-<aid>.json
+    // — a per-host prefix here meant it could never see this host's own
+    // automatic evidence. One prefix for all three hosts fixes that outright.
+    const marker = join(tmpdir(), `coldstart-kb-${sid}-${aid}.json`);
     let state = null;
     try {
       const parsed = JSON.parse(readFileSync(marker, "utf8"));
@@ -152,7 +156,7 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
       writeFileSync(marker, JSON.stringify(state));
       if (!fresh.length) { log(`FAST-EXIT subagent no-new-files session=${sid} agent=${aid}`); process.exit(0); }
       const entries = worklistEntries(CLI, root, fresh, Object.fromEntries(fresh.map((rel) => [rel, delta.get(rel)])), log);
-      const payload = buildCapturePayload({ root, cli: CLI, sid, entries, envelope: "subagent" });
+      const payload = buildCapturePayload({ root, cli: CLI, sid, aid, entries, envelope: "subagent" });
       logCaptureEvent(root, { event: "fire", reason: "subagent", session: sid, agent: aid, files: fresh.length, host: "cursor" });
       log(`FIRE subagent session=${sid} agent=${aid} files=${fresh.length}`);
       process.stdout.write(JSON.stringify({ followup_message: payload }));
@@ -188,11 +192,11 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
     log(`FIRE ${decision.fire} mode=${decision.mode} session=${sid} score=${decision.score} files=${decision.files.length}`);
 
     if (decision.mode === "block") {
-      const payload = buildCapturePayload({ root, cli: CLI, sid, entries, envelope: "block" });
+      const payload = buildCapturePayload({ root, cli: CLI, sid, aid, entries, envelope: "block" });
       process.stdout.write(JSON.stringify({ followup_message: payload }));
     } else {
       // Non-blocking: cursor-kb-recall delivers this with the user's next prompt.
-      const payload = buildCapturePayload({ root, cli: CLI, sid, entries, envelope: "inject" });
+      const payload = buildCapturePayload({ root, cli: CLI, sid, aid, entries, envelope: "inject" });
       writePendingCapture(sid, decision.fire, payload);
     }
   } catch (e) {

package/hooks/cursor-kb-recall.mjs

@@ -16,6 +16,17 @@
  *     injection channel used here. If a future Cursor build stops honoring it,
  *     recall silently no-ops (fail-open) — nav + capture are unaffected.
  *
+ * MANUAL CAPTURE ON-DEMAND (2026-08-06): Cursor's `/capture-notes` command has
+ * no `!`-expansion (unlike Claude), so it can't pass its own real session id to
+ * `kb-elicit.mjs --manual` the way Claude does — the command body used to just
+ * ask the agent to run the command itself, blind to which session it's in. But
+ * THIS hook receives a real `input.session_id` on every prompt. So: when the
+ * submitted prompt IS the capture command (its body carries a stable sentinel,
+ * CAPTURE_SENTINEL), run `--manual --session <real sid>` right here and inject
+ * its output the same way a pending automatic fire is injected — deterministic,
+ * no LLM has to type a correct `--session <id>`. The command body keeps "run
+ * this in the terminal" as a fallback for when this hook is disabled/fails.
+ *
  * Self-contained + fail-open: ANY error → exit 0, no stdout → nothing injected.
  */
 
@@ -31,6 +42,7 @@ import { cursorRoot } from "./cursor-input.mjs";
 import { takePendingCapture } from "./elicit-core.mjs";
 // Strip host telemetry wrappers before the query is built — see recall-query.mjs.
 import { recallQuery } from "./recall-query.mjs";
+import { CAPTURE_SENTINEL } from "./capture-sentinel.mjs";
 // Per-session dedup shared with the other recall hooks — see recall-seen.mjs.
 // Hosts with no transcript path never reset; dedup still holds for the session.
 import { readSeen, writeSeen, idsInPage, seenArgs } from "./recall-seen.mjs";
@@ -83,7 +95,28 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
     // A pending capture (non-blocking fire at a previous stop) is delivered
     // regardless of recall hits — it must not depend on the notebook existing
     // (the first capture is what creates it).
-    const pending = takePendingCapture(sid);
+    let pending = takePendingCapture(sid);
+
+    // The submitted prompt IS /capture-notes (its command body carries this
+    // sentinel) → run the on-demand capture ourselves with the real session id
+    // this hook already has, instead of leaving the agent to guess one. See
+    // the file header and hooks/capture-sentinel.mjs.
+    if (sid && String(input.prompt || "").includes(CAPTURE_SENTINEL)) {
+      try {
+        const elicit = fileURLToPath(new URL("./kb-elicit.mjs", import.meta.url));
+        const manual = execFileSync("node", [elicit, "--manual", "--session", sid, "--root", root], {
+          encoding: "utf8",
+          timeout: 8000,
+          stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (manual.trim()) {
+          pending = pending ? `${manual.trim()}\n\n---\n\n${pending}` : manual.trim();
+          log(`MANUAL-INJECT session=${sid} bytes=${manual.length}`);
+        }
+      } catch (e) {
+        log(`manual-capture-inject failed: ${String(e).split("\n")[0]}`);
+      }
+    }
 
     const prompt = recallQuery(input.prompt, MAX_QUERY_CHARS);
 

package/hooks/kb-elicit.mjs

@@ -36,7 +36,7 @@ import { existsSync, writeFileSync, appendFileSync, readFileSync, readdirSync, s
 import { extractEvidence, segmentStats } from "./evidence.mjs";
 import { initialState, step } from "./trigger.mjs";
 import { loadIgnore } from "./ignore.mjs";
-import { buildCapturePayload } from "./capture-payload.mjs";
+import { buildCapturePayload, worklistJsonPath } from "./capture-payload.mjs";
 import {
   worklistEntries, freshNotedSet, gitHead, logCaptureEvent, writePendingCapture, MAX_WORKLIST,
 } from "./elicit-core.mjs";
@@ -129,10 +129,12 @@ process.on("unhandledRejection", (e) => { log(`unhandled ${e?.stack || e}`); pro
 
 // --- Manual capture (`--manual --root <dir>`) --------------------------------
 // The `/capture-notes` command runs this to fire capture ON DEMAND, bypassing
-// the trigger score gate. There is no hook stdin, so we self-discover the
-// session: the freshest marker in tmpdir whose recorded (relative) files still
-// resolve under <root> is this repo's active session. We then emit the SAME
-// capture payload an automatic fire would, built from accumulated evidence.
+// the trigger score gate. There is no hook stdin, so there is no session id to
+// trust by default. When the host names it (Claude passes `--session
+// ${CLAUDE_SESSION_ID}`), that session's marker is resolved exactly, never
+// guessed among several. Hosts with no session-id variable on their command
+// surface (Cursor, Codex) pass none; soleMarkerUnderRoot below covers the
+// common single-session case for them without ever guessing wrong.
 //
 // It marks the files it LISTED as captured (and nothing else). Without that, a
 // manual capture left every file uncaptured, so the next automatic fire re-asked
@@ -144,41 +146,77 @@ function argValue(name) {
   const i = process.argv.indexOf(name);
   return i >= 0 ? process.argv[i + 1] : undefined;
 }
-function markerMtime(p) { try { return statSync(p).mtimeMs; } catch { return 0; } }
-function freshestMarkerUnderRoot(root) {
-  let names;
-  try { names = readdirSync(tmpdir()); } catch { return null; }
-  const markers = names
-    .filter((n) => /^coldstart-kb-.+-main\.json$/.test(n))
-    .map((n) => ({ n, p: join(tmpdir(), n), mtime: 0 }))
-    .map((m) => ({ ...m, mtime: markerMtime(m.p) }))
-    .sort((a, b) => b.mtime - a.mtime);
-  for (const m of markers) {
-    let state;
-    try { state = JSON.parse(readFileSync(m.p, "utf8")); } catch { continue; }
-    const files = state && state.files ? Object.keys(state.files) : [];
-    if (!files.length) continue;
-    // Belongs to THIS repo iff a recorded file still resolves under root.
-    if (files.some((rel) => existsSync(join(root, rel)))) {
-      return { sid: m.n.slice("coldstart-kb-".length, -"-main.json".length), state, path: m.p };
-    }
+// The main-agent evidence marker for a KNOWN session id. Returns null when the
+// sid is empty or its marker is absent/foreign (files don't resolve under root).
+function markerForSession(root, sid) {
+  if (!sid) return null;
+  const p = join(tmpdir(), `coldstart-kb-${sid}-main.json`);
+  let state;
+  try { state = JSON.parse(readFileSync(p, "utf8")); } catch { return null; }
+  const files = state && state.files ? Object.keys(state.files) : [];
+  if (!files.length || !files.some((rel) => existsSync(join(root, rel)))) return null;
+  return { sid, state, path: p };
+}
+// Hosts with no verified session-id variable on their command surface (Cursor,
+// Codex — their commands are plain prompt templates the agent itself runs, with
+// no `!`-style substitution to carry a session id into the invocation) can't name
+// a session at all. Guessing among several is the wrong-session risk `--session`
+// exists to avoid, but when exactly ONE main-agent marker under this root exists
+// there is nothing to disambiguate — restore that single-session case instead of
+// refusing outright. `-main.json` only: subagent markers never own a worklist.
+function soleMarkerUnderRoot(root) {
+  const re = /^coldstart-kb-(.+)-main\.json$/;
+  let entries;
+  try { entries = readdirSync(tmpdir()); } catch { return { marker: null, ambiguous: false }; }
+  const candidates = [];
+  for (const name of entries) {
+    const m = re.exec(name);
+    if (!m) continue;
+    const found = markerForSession(root, m[1]);
+    if (found) candidates.push(found);
   }
-  return null;
+  if (candidates.length === 1) return { marker: candidates[0], ambiguous: false };
+  if (candidates.length > 1) return { marker: null, ambiguous: true };
+  return { marker: null, ambiguous: false };
 }
 if (process.argv.includes("--manual")) {
   try {
     const rootArg = argValue("--root");
     const root = rootArg ? resolve(rootArg) : process.cwd();
     setLogRoot(root);
-    const found = freshestMarkerUnderRoot(root);
-    if (!found) {
+    const sidArg = String(argValue("--session") || "").replace(/[^A-Za-z0-9_-]/g, "");
+    let found = sidArg ? markerForSession(root, sidArg) : null;
+    if (!sidArg) {
+      const sole = soleMarkerUnderRoot(root);
+      if (sole.ambiguous) {
+        process.stdout.write(
+          "Multiple sessions have notebook-capture evidence in this repo, and this host can't tell\n" +
+          "/capture-notes which one you mean — pass --session <id> if your host exposes one, or close\n" +
+          "the other sessions working here so only one remains.\n",
+        );
+        log(`MANUAL ambiguous-no-session root=${root}`);
+        process.exit(0);
+      }
+      found = sole.marker;
+      if (found) log(`MANUAL sole-marker-fallback sid=${found.sid} root=${root}`);
+    }
+    if (!sidArg && !found) {
       process.stdout.write(
         "No notebook-capture evidence for this repo yet — it accrues as you read and edit files.\n" +
         "Do a turn or two of real work here, then run /capture-notes again.\n",
       );
-      log(`MANUAL no-marker root=${root}`);
+      log(`MANUAL no-session root=${root}`);
+      process.exit(0);
+    }
+    if (!found) {
+      process.stdout.write(
+        "No notebook-capture evidence for THIS session in this repo yet — it accrues as you read\n" +
+        "and edit files. Do a turn or two of real work here, then run /capture-notes again.\n",
+      );
+      log(`MANUAL no-marker-for-session sid=${sidArg} root=${root}`);
       process.exit(0);
     }
+    log(`MANUAL session sid=${found.sid} root=${root}`);
     const { sid, state, path: markerPath } = found;
     // A manual /capture-notes is an EXPLICIT request to write up THIS session's
     // work, so its scope is everything worked on — not merely what an automatic
@@ -189,10 +227,17 @@ if (process.argv.includes("--manual")) {
     // note unwritten and a now-stale note unfixed (the Bug-1 report). So:
     // include every edited file regardless of the flag, and drop only READ-ONLY
     // files that were already offered (re-listing those on demand is just
-    // noise). Rank most-worked first (edits → retouches → reads) so new/edited
-    // files lead; the per-file annotations flag when a fresh note needs nothing.
+    // noise) AND whose worklist is still live. A captured read-only file whose
+    // durable worklist pair is gone (write failure, or hand-deleted since) has
+    // no live checklist anywhere naming it — re-including it here is the only
+    // way it is ever offered again, and it can't double-nag since there is
+    // nothing else currently showing it. Rank most-worked first (edits →
+    // retouches → reads) so new/edited files lead; the per-file annotations
+    // flag when a fresh note needs nothing.
+    const worklistLost = !existsSync(worklistJsonPath(root, sid, "main"));
+    if (worklistLost) log(`MANUAL worklist-artifact-missing session=${sid} — recovering captured read-only files too`);
     const files = Object.entries(state.files)
-      .filter(([, f]) => (f.reads + f.edits + f.gs) > 0 && (f.edits > 0 || !f.captured))
+      .filter(([, f]) => (f.reads + f.edits + f.gs) > 0 && (f.edits > 0 || !f.captured || worklistLost))
       .sort((a, b) => (b[1].edits - a[1].edits)
         || ((b[1].retouches || 0) - (a[1].retouches || 0))
         || (b[1].reads - a[1].reads))
@@ -203,7 +248,9 @@ if (process.argv.includes("--manual")) {
       process.exit(0);
     }
     const entries = worklistEntries(CLI, root, files, state.files, log);
-    const payload = buildCapturePayload({ root, cli: CLI, sid, entries, envelope: "manual" });
+    // Manual capture resolves the invoking session's MAIN marker (markerForSession
+    // targets `-main.json`), so its worklist is the main agent's.
+    const payload = buildCapturePayload({ root, cli: CLI, sid, aid: "main", entries, envelope: "manual" });
     // Mark ONLY the files actually LISTED (the worklist caps its display to
     // MAX_WORKLIST) captured — any overflow stays uncaptured so it rolls into
     // the next capture rather than being marked done but never shown. Re-read
@@ -345,7 +392,7 @@ if (process.argv.includes("--manual")) {
       writeFileSync(marker, JSON.stringify(state));
       if (!fresh.length) { log(`FAST-EXIT subagent no-new-files session=${sid} agent=${aid}`); process.exit(0); }
       const entries = worklistEntries(CLI, root, fresh, Object.fromEntries(fresh.map((rel) => [rel, delta.get(rel)])), log);
-      const payload = buildCapturePayload({ root, cli: CLI, sid, entries, envelope: "subagent" });
+      const payload = buildCapturePayload({ root, cli: CLI, sid, aid, entries, envelope: "subagent" });
       logCaptureEvent(root, { event: "fire", reason: "subagent", session: sid, agent: aid, files: fresh.length });
       log(`FIRE subagent session=${sid} agent=${aid} files=${fresh.length}`);
       process.stdout.write(JSON.stringify({ decision: "block", reason: payload }));
@@ -381,11 +428,11 @@ if (process.argv.includes("--manual")) {
     log(`FIRE ${decision.fire} mode=${decision.mode} session=${sid} score=${decision.score} files=${decision.files.length}`);
 
     if (decision.mode === "block") {
-      const payload = buildCapturePayload({ root, cli: CLI, sid, entries, envelope: "block" });
+      const payload = buildCapturePayload({ root, cli: CLI, sid, aid, entries, envelope: "block" });
       process.stdout.write(JSON.stringify({ decision: "block", reason: payload }));
     } else {
       // Non-blocking: kb-recall delivers this with the user's next prompt.
-      const payload = buildCapturePayload({ root, cli: CLI, sid, entries, envelope: "inject" });
+      const payload = buildCapturePayload({ root, cli: CLI, sid, aid, entries, envelope: "inject" });
       writePendingCapture(sid, decision.fire, payload);
     }
   } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cstart/coldstart",
-  "version": "2.2.14",
+  "version": "2.2.16",
   "mcpName": "io.github.AkashGoenka/coldstart",
   "publishConfig": {
     "access": "public"

package/dist/kb/session-worklist.d.ts

@@ -1,10 +0,0 @@
-/** Paths this spec puts a note on. Flow steps do NOT count: a flow verifies
- *  files, it does not give any of them the file note rule 5 asks for. */
-export declare function specPaths(spec: unknown): string[];
-/**
- * Record this write against the session worklist and return the coverage line
- * to print, or null when there is no manifest to compare against (no --session,
- * a manual `kb write` outside capture, a session that never armed).
- */
-export declare function noteCoverage(sid: string | undefined, spec: unknown): string | null;
-//# sourceMappingURL=session-worklist.d.ts.map

package/dist/kb/session-worklist.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-worklist.d.ts","sourceRoot":"","sources":["../../src/kb/session-worklist.ts"],"names":[],"mappings":"AA8CA;yEACyE;AACzE,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,CAIjD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CA8BlF"}

package/dist/kb/session-worklist.js

@@ -1,92 +0,0 @@
-/**
- * Capture coverage — telling the writing agent how much of its worklist it noted.
- *
- * The gap this closes: the capture checklist hands the agent a worklist of every
- * file it worked on, but `kb write` only ever sees ONE spec, so nothing could
- * report "you wrote 8 notes for 30 worked files". The agent's own count is the
- * one thing it cannot check — it is mid-heredoc, and under-capture is silent by
- * construction. So the hook drops the worklist in tmpdir when it builds the
- * capture prompt, and every `kb write --session <sid>` prints the running ratio.
- *
- * CONTRACT TWIN: hooks/capture-payload.mjs (worklistManifestPath) writes this
- * file; keep the name and shape in step. Everything here is best-effort — a
- * missing, stale or malformed manifest prints nothing and never fails a write.
- *
- * Local only. The manifest lives in tmpdir, never in the repo: it is scratch
- * state for one session, not a record, and nothing about it is transmitted.
- */
-import { readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-/** Manifests older than this are a resumed/unrelated session — ignore them. */
-const MAX_AGE_MS = 24 * 60 * 60 * 1000;
-/** Below this share of outstanding files, name the skips. */
-const LOW_COVERAGE = 0.5;
-const LIST_MAX = 6;
-function manifestPath(sid) {
-    return join(tmpdir(), `coldstart-kb-worklist-${sid}.json`);
-}
-function load(sid) {
-    try {
-        const m = JSON.parse(readFileSync(manifestPath(sid), 'utf8'));
-        if (!Array.isArray(m?.files) || !m.files.length)
-            return null;
-        if (typeof m.ts === 'number' && Date.now() - m.ts > MAX_AGE_MS)
-            return null;
-        m.wrote = Array.isArray(m.wrote) ? m.wrote : [];
-        return m;
-    }
-    catch {
-        return null;
-    }
-}
-/** Paths this spec puts a note on. Flow steps do NOT count: a flow verifies
- *  files, it does not give any of them the file note rule 5 asks for. */
-export function specPaths(spec) {
-    const s = spec;
-    if (!s || typeof s.path !== 'string')
-        return [];
-    return s.type === 'file-single' || s.type === 'file-hub' ? [s.path] : [];
-}
-/**
- * Record this write against the session worklist and return the coverage line
- * to print, or null when there is no manifest to compare against (no --session,
- * a manual `kb write` outside capture, a session that never armed).
- */
-export function noteCoverage(sid, spec) {
-    if (!sid)
-        return null;
-    const m = load(sid);
-    if (!m)
-        return null;
-    for (const p of specPaths(spec))
-        if (!m.wrote.includes(p))
-            m.wrote.push(p);
-    try {
-        writeFileSync(manifestPath(sid), JSON.stringify(m));
-    }
-    catch { /* best-effort */ }
-    const outstanding = m.files.filter((f) => f.needsNote);
-    if (!outstanding.length)
-        return null;
-    const wrote = new Set(m.wrote);
-    const done = outstanding.filter((f) => wrote.has(f.path));
-    const left = outstanding.filter((f) => !wrote.has(f.path));
-    const already = m.files.length - outstanding.length;
-    const lines = [
-        `capture coverage: ${done.length} of ${outstanding.length} worklist files noted` +
-            (already ? ` (${already} more already had a fresh note)` : ''),
-    ];
-    if (left.length) {
-        const shown = left.slice(0, LIST_MAX).map((f) => `${f.path} [${f.tier}]`).join(', ');
-        lines.push(`  not noted yet: ${shown}${left.length > LIST_MAX ? `, +${left.length - LIST_MAX} more` : ''}`);
-    }
-    // The nudge fires only on the low end, and asks for a REASON rather than more
-    // notes: a deliberate skip is a fine answer, an invisible one is not. Chained
-    // writes each print this, so the last line of the block carries the real tally.
-    if (left.length && done.length / outstanding.length < LOW_COVERAGE) {
-        lines.push('  if those need no note, say which and why in your reply — an unexplained skip reads as a forgotten one.');
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=session-worklist.js.map

package/dist/kb/session-worklist.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-worklist.js","sourceRoot":"","sources":["../../src/kb/session-worklist.ts"],"names":[],"mappings":"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"}