@cstart/coldstart 2.2.15 → 2.2.17

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.15",
+  "version": "2.2.17",
   "mcpName": "io.github.AkashGoenka/coldstart",
   "publishConfig": {
     "access": "public"
@@ -40,7 +40,7 @@
   ],
   "license": "MIT",
   "author": "Akash Goenka (https://github.com/AkashGoenka)",
-  "homepage": "https://akashgoenka.github.io/coldstart/",
+  "homepage": "https://coldstartmcp.dev/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AkashGoenka/coldstart.git"