skalpel 4.0.11 → 4.0.13

package/autopsy.mjs

@@ -192,8 +192,14 @@ function extractAnchors(text) {
   const fileRe =
     /\b[\w-]+(?:\/[\w.-]+)*\.(?:rs|ts|tsx|jsx|mjs|cjs|go|py|sql|toml|yaml|yml|sh|astro|vue|svelte)\b/g;
   while ((m = fileRe.exec(text))) {
-    const base = m[0].split("/").pop();
-    if (!GENERIC.has(base.split(".")[0])) push("sym:file", base, m.index);
+    const raw = m[0]; // the mentioned path token, e.g. "src/components/Hero.astro" or "Users/ryan/…/Hero.astro"
+    const base = raw.split("/").pop();
+    if (!GENERIC.has(base.split(".")[0])) {
+      // fileRe cannot start on the leading "/", so an absolute path shows up as raw="Users/…" with a
+      // "/" immediately before it. Detect that so the path can be resolved to a real file IDENTITY.
+      const abs = m.index > 0 && text[m.index - 1] === "/";
+      out.push({ kind: "sym:file", anchor: base, at: m.index, rawPath: raw, abs });
+    }
   }
   const rustRe = /\b[a-z_][a-z0-9_]{2,}::[a-z_][a-z0-9_:]{2,}/g;
   while ((m = rustRe.exec(text))) push("sym:path", m[0], m.index);
@@ -631,7 +637,10 @@ function reproduceCount(anchor, witnesses) {
   const total = witnesses.length;
   for (const w of witnesses) {
     const txt = reopenTurnText(w);
-    if (txt && norm(txt).includes(norm(anchor))) confirmed++;
+    // For files, w.reAnchor is the FULL mentioned path (e.g. "src/components/Hero.astro" or the
+    // absolute) — re-confirming it, not the bare basename, is what proves the same actual file.
+    const need = w.reAnchor || anchor;
+    if (txt && norm(txt).includes(norm(need))) confirmed++;
   }
   return { confirmed, total };
 }
@@ -683,6 +692,23 @@ function projTail(root) {
   const tail = parts.slice(-2).join("/");
   return tail ? `~/${tail}` : null;
 }
+// Resolve a mentioned file token to a stable, absolute IDENTITY so cross-vendor "same file" means the
+// SAME ACTUAL FILE — not a shared basename. Returns a normalized absolute path, or null when the
+// mention cannot be pinned to a real file:
+//   • absolute path in the text        → that path IS the identity (works across every vendor).
+//   • relative path WITH a directory    → resolved against the session's project root (cwd), but ONLY
+//                                         when that root is a real project (never the home catch-all,
+//                                         and never Cursor's rootless bubbles) — otherwise unknowable.
+//   • bare basename (no directory)      → null. A basename alone can never prove same-file.
+function resolveFileIdentity(rawPath, abs, root) {
+  if (!rawPath) return null;
+  if (abs) return path.posix.normalize("/" + rawPath.replace(/^\/+/, ""));
+  if (!rawPath.includes("/")) return null; // bare basename — not a same-file proof
+  if (/^\.\.?\//.test(rawPath)) return null; // "./x" or "../x": ambiguous relative to an unknown subdir
+  const base = decodeRoot(root); // "" when root is null (Cursor) or unknown
+  if (!base || base === HOME) return null; // no real project root to anchor a relative path against
+  return path.posix.normalize(base.replace(/\/+$/, "") + "/" + rawPath);
+}
 // Detect any email (incl. TLDs truncated by the 200-char span slice, e.g. "name@host.c" or "name@host").
 const EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9][A-Za-z0-9.-]*/g;
 
@@ -726,13 +752,30 @@ const AUTOPSY_ECHO = [
   "cross-vendor",
   "appears in both",
   "connect a 2nd agent",
+  "basename collision",
+  "basename-only",
+  "same actual file",
+  "same actual path",
+  "same absolute path",
+  "same project-root",
+  "followed you across",
+  "honest-absence",
+  "honest absence",
+  "single-vendor",
+  "cross-vendor autopsy",
+  "the same file followed you",
+  "distinctive symbol",
+  "distinctive-error",
 ];
+// Case-insensitive: a receipt/meta-discussion turn can quote the vocabulary in any case (BASENAME,
+// Cross-Vendor, …). Two distinct markers in the first 800 chars ⇒ it is talking ABOUT the autopsy,
+// so it is excluded from anchor mining — the tool must never report on its own machinery.
 const isAutopsyEcho = (s) => {
   if (!s) return false;
-  const l = s.slice(0, 800);
+  const l = s.slice(0, 800).toLowerCase();
   let hits = 0;
   for (const m of AUTOPSY_ECHO) {
-    if (l.includes(m)) {
+    if (l.includes(m.toLowerCase())) {
       hits++;
       if (hits >= 2) return true;
     }
@@ -845,15 +888,112 @@ const CROSS_COMMON_CORES = new Set([
   "components",
   "handler",
 ]);
-const fileCore = (anchor) => anchor.replace(/\.[^.]+$/, "").toLowerCase();
-// A cross-vendor anchor must be SPECIFIC: an identifier-carrying error, or a DISTINCTIVE (non-generic)
-// filename that is a strong proxy for the same actual file across tools.
-function anchorEligible(kind, anchor) {
+// Common library / runtime / build tokens: identical across everyone's projects, so they are NOT a
+// distinctive "your work followed you" anchor. A symbol must clear this list (and a frequency ceiling)
+// to be a genuine cross-vendor signal. Not exhaustive — the frequency ceiling is the real backstop.
+const SCAFFOLD_SYMBOLS = new Set([
+  "addeventlistener",
+  "removeeventlistener",
+  "getelementbyid",
+  "queryselector",
+  "queryselectorall",
+  "createelement",
+  "appendchild",
+  "setattribute",
+  "getattribute",
+  "classlist",
+  "innerhtml",
+  "textcontent",
+  "usestate",
+  "useeffect",
+  "usecallback",
+  "usememo",
+  "usecontext",
+  "useref",
+  "usereducer",
+  "foreach",
+  "tostring",
+  "valueof",
+  "constructor",
+  "prototype",
+  "stringify",
+  "parseint",
+  "parsefloat",
+  "tolowercase",
+  "touppercase",
+  "trimstart",
+  "trimend",
+  "startswith",
+  "endswith",
+  "indexof",
+  "lastindexof",
+  "includes",
+  "createinterface",
+  "readfilesync",
+  "writefilesync",
+  "readdirsync",
+  "existssync",
+  "createreadstream",
+  "spawnsync",
+  "execsync",
+  "setinterval",
+  "setttimeout",
+  "settimeout",
+  "clearinterval",
+  "cleartimeout",
+  "unwrap",
+  "to_string",
+  "into_iter",
+  "as_str",
+  "as_ref",
+  "clone",
+  "collect",
+  "serialize",
+  "deserialize",
+  "async_trait",
+  "tokio",
+  "serde",
+  "sqlx",
+  "anyhow",
+  "thiserror",
+  "node_modules",
+  "package_json",
+  "tsconfig_json",
+  "sourcemappingurl",
+  "getserversideprops",
+  "getstaticprops",
+  "getstaticpaths",
+]);
+
+// A distinctive symbol/function name is genuinely PORTABLE across vendors: the identical token string
+// in two agents is the same code entity (unlike a basename). Eligibility: not generic/template/
+// scaffolding, long enough to be specific, and NOT so ubiquitous it is obviously a library token
+// (appearing in more than a handful of distinct sessions ⇒ shared vocabulary, not a personal anchor).
+function symbolDistinctive(kind, anchor, sessionCount) {
+  if (kind !== "sym:path" && kind !== "sym:ident") return false;
+  const a = anchor.toLowerCase();
+  if (isTemplateTok(anchor)) return false;
+  if (GENERIC.has(a) || CROSS_COMMON_CORES.has(a) || SCAFFOLD_SYMBOLS.has(a)) return false;
+  // any path/ident segment being a scaffold token drags the whole anchor toward library noise
+  for (const seg of a.split(/[^a-z0-9]+/).filter(Boolean))
+    if (SCAFFOLD_SYMBOLS.has(seg)) return false;
+  if (kind === "sym:path") {
+    if (anchor.length < 10) return false; // namespaced `a::b` — needs real length to be specific
+  } else {
+    if (anchor.length < 12) return false; // multi-segment ident — long enough to be non-accidental
+  }
+  if (sessionCount > 6) return false; // ubiquitous ⇒ library / harness vocabulary, not a personal anchor
+  return true;
+}
+
+// A cross-vendor NON-FILE anchor (files are matched by absolute-path identity elsewhere): an
+// identifier-carrying error, or a distinctive symbol. Bare / generic tokens never qualify.
+function crossAnchorEligible(kind, anchor, sessionCount) {
   if (isTemplateTok(anchor)) return false;
   if (kind.startsWith("err")) return ERR_SPECIFIC.has(kind);
-  if (kind === "sym:file")
-    return !BARE_FILES.has(anchor) && !CROSS_COMMON_CORES.has(fileCore(anchor));
-  return false; // sym:path / sym:ident are harness/runtime token noise — never headline-eligible
+  if (kind === "sym:path" || kind === "sym:ident")
+    return symbolDistinctive(kind, anchor, sessionCount);
+  return false; // sym:file is handled by path identity, never by basename here
 }
 
 // ---------- main ----------
@@ -918,15 +1058,43 @@ async function main() {
   const presentVendors = Object.keys(inv).filter((v) => inv[v].sessions > 0);
 
   // ============ CELL A: cross-session recurrence on deterministic anchors (across the UNION) ============
+  // filePathMap indexes file mentions by RESOLVED ABSOLUTE IDENTITY (not basename) so a cross-vendor
+  // "same file" claim can require the SAME ACTUAL FILE. identity → Map(source_tool → Map(sessionId,witness)).
   const anchorMap = new Map();
+  const filePathMap = new Map();
   for (const s of sessions) {
     for (const turn of s.turns) {
       const mineText = turn.boiler ? "" : turn.text || turn.toolErrText || "";
       if (!mineText || isAutopsyEcho(mineText)) continue;
       const errOnly = turn.mineErrOnly;
       const seenThisTurn = new Set();
-      for (const { kind, anchor, at } of extractAnchors(mineText)) {
+      for (const ex of extractAnchors(mineText)) {
+        const { kind, anchor, at } = ex;
         if (errOnly && !kind.startsWith("err")) continue;
+        // ---- same-file identity index (message text only; tool output is skipped above) ----
+        if (kind === "sym:file") {
+          const identity = resolveFileIdentity(ex.rawPath, ex.abs, turn.root);
+          if (identity) {
+            if (!filePathMap.has(identity))
+              filePathMap.set(identity, { basename: anchor, byTool: new Map() });
+            const fe = filePathMap.get(identity);
+            if (!fe.byTool.has(turn.source_tool)) fe.byTool.set(turn.source_tool, new Map());
+            const perSess = fe.byTool.get(turn.source_tool);
+            if (!perSess.has(s.sessionId))
+              perSess.set(s.sessionId, {
+                session_id: s.sessionId,
+                turn_idx: turn.turn_idx,
+                ts: turn.ts,
+                role: turn.role,
+                root: turn.root,
+                from: "message",
+                source_tool: turn.source_tool,
+                bubbleKey: turn.bubbleKey,
+                verbatim: span(mineText, at, ex.rawPath.length),
+                reAnchor: ex.rawPath, // re-confirm the FULL mentioned path on a fresh re-read, not the basename
+              });
+          }
+        }
         const key = kind.startsWith("sym") ? anchor : kind + "|" + anchor.toLowerCase();
         if (seenThisTurn.has(key)) continue;
         seenThisTurn.add(key);
@@ -987,13 +1155,17 @@ async function main() {
   }
   cellA.sort((a, b) => b.relatedN - a.relatedN || b.spec - a.spec);
 
-  // ============ CELL X: CROSS-VENDOR recurrence — same specific anchor across >=2 agents ============
-  // Built from the same anchorMap (one witness per session). An anchor qualifies when its witnessing
-  // sessions span >=2 distinct source tools AND it clears the specificity gate. Each vendor's count and
-  // witnesses are kept separate so the receipt reproduces EACH side from its own raw store.
+  // ============ CELL X: CROSS-VENDOR recurrence — the SAME specific anchor across >=2 agents ============
+  // Two disjoint, both-genuine sources:
+  //   (1) errors-with-identifiers + distinctive symbols — from anchorMap. The identical token in two
+  //       agents IS the same entity (portable by construction), so >=2 distinct source tools qualifies.
+  //   (2) files — from filePathMap, keyed by RESOLVED ABSOLUTE IDENTITY. A shared basename is NOT a
+  //       match; only the same actual path across >=2 tools qualifies. proofPath carries that identity
+  //       so the receipt (and the pre-push self-verify) can print the exact shared file.
+  // Each vendor's witnesses stay separate so the receipt reproduces EACH side from its own raw store.
   const cellX = [];
   for (const [, rec] of anchorMap) {
-    if (!anchorEligible(rec.kind, rec.anchor)) continue;
+    if (!crossAnchorEligible(rec.kind, rec.anchor, rec.sessions.size)) continue;
     const byVendor = new Map();
     for (const w of rec.sessions.values()) {
       const st = w.source_tool || SRC.claude;
@@ -1009,12 +1181,31 @@ async function main() {
     cellX.push({
       kind: rec.kind,
       anchor: rec.anchor,
+      proofPath: null,
       vendorCount: byVendor.size,
       totalSessions: rec.sessions.size,
       perVendor,
       spec,
     });
   }
+  for (const [identity, fe] of filePathMap) {
+    if (fe.byTool.size < 2) continue; // same actual file must appear in >=2 different agents
+    let totalSessions = 0;
+    const perVendor = [...fe.byTool.entries()].map(([src, perSess]) => {
+      const ws = [...perSess.values()].sort((a, b) => (a.turn_idx || 0) - (b.turn_idx || 0));
+      totalSessions += ws.length;
+      return { src, witnesses: ws };
+    });
+    cellX.push({
+      kind: "sym:file",
+      anchor: fe.basename,
+      proofPath: identity, // the exact shared absolute path — the same-file proof
+      vendorCount: fe.byTool.size,
+      totalSessions,
+      perVendor,
+      spec: identity.length + 6,
+    });
+  }
   cellX.sort(
     (a, b) => b.vendorCount - a.vendorCount || b.totalSessions - a.totalSessions || b.spec - a.spec,
   );
@@ -1131,7 +1322,7 @@ async function main() {
     }
     if (legs.length < 2) continue; // must still be genuinely cross-vendor after a fresh re-read
     legs.sort((a, b) => b.rep.confirmed - a.rep.confirmed);
-    renderedX.push({ kind: r.kind, anchor: r.anchor, legs });
+    renderedX.push({ kind: r.kind, anchor: r.anchor, proofPath: r.proofPath, legs });
     usedAnchors.add(anchorKey(r.kind, r.anchor));
   }
 
@@ -1210,6 +1401,7 @@ async function main() {
     }
     P();
     P("  " + RULE);
+    renderNoCrossVendor(P, presentVendors, renderedX.length > 0);
     renderConnectInvite(P, presentVendors);
     renderFooter(P, presentVendors);
     process.stdout.write(out.join("\n") + "\n");
@@ -1229,11 +1421,15 @@ async function main() {
         : names.slice(0, -1).join(", ") + ", and " + names.slice(-1);
     const counts = rx.legs.map((l) => `${l.rep.total} in ${srcLabel(l.src)}`).join(", ");
     if (rx.kind === "sym:file") {
-      P(`  ${plainAnchor(rx.kind, rx.anchor)} shows up in BOTH ${nameList} — the same file`);
-      P(`  followed you across different agents (${counts}).`);
-    } else {
+      P(`  The SAME FILE followed you across ${nameList} (${counts}):`);
+      P(`    ${redact(rx.proofPath)}`);
+      P(`  — same absolute path in every agent, not just a shared filename.`);
+    } else if (rx.kind.startsWith("err")) {
       P(`  ${plainAnchor(rx.kind, rx.anchor)} appears in BOTH ${nameList} — the same specific`);
       P(`  error surfaced in more than one agent (${counts}).`);
+    } else {
+      P(`  ${plainAnchor(rx.kind, rx.anchor)} appears in BOTH ${nameList} — the same distinctive`);
+      P(`  symbol carried across more than one agent (${counts}).`);
     }
     P(`  No single model vendor can see this; it needs all your logs at once.`);
     P();
@@ -1335,12 +1531,32 @@ async function main() {
     P("  " + RULE);
   }
 
-  // --- honest connect-a-2nd-agent invite (only when a single vendor is present)
+  // --- honest cross-vendor status: strict miss when >=2 agents present, or a connect invite for one.
+  renderNoCrossVendor(P, presentVendors, renderedX.length > 0);
   renderConnectInvite(P, presentVendors);
   renderFooter(P, presentVendors);
   process.stdout.write(out.join("\n") + "\n");
 }
 
+// When >=2 agents ARE connected but nothing genuinely crosses between them, say so plainly instead of
+// manufacturing a basename-collision "match". This is the honest counterpart to a real CELL X finding.
+function renderNoCrossVendor(P, presentVendors, hasCrossVendor) {
+  if (presentVendors.length < 2 || hasCrossVendor) return;
+  const names = presentVendors.map(srcLabel);
+  const list =
+    names.length === 2
+      ? names.join(" and ")
+      : names.slice(0, -1).join(", ") + ", and " + names.slice(-1);
+  P();
+  P(`  No same-file or same-error crossed your tools yet (read: ${list}).`);
+  P(`  Cross-vendor is deliberately strict: it fires only when the SAME actual file`);
+  P(`  path — or the SAME specific error/symbol — shows up in two different agents.`);
+  P(`  A shared filename across different projects is NOT a match and is suppressed.`);
+  P(`  Keep working across your tools; the first genuine crossing renders itself here.`);
+  P();
+  P("  " + RULE);
+}
+
 // When only ONE agent has usable history, the cross-vendor verdict cannot exist yet. Say so honestly
 // and invite a second connection — the multi-vendor connect is the whole point of this cell.
 function renderConnectInvite(P, presentVendors) {

package/bootstrap.mjs

@@ -368,7 +368,9 @@ function recordProfile(profile, sessions) {
   if (headline) {
     recordInsight({
       kind: "profile",
-      display: `learned ${headline.hours ?? 0}h across ${headline.sessions ?? sessions} sessions; ${headline.rework_pct ?? 0}% was rework`,
+      // RED LINE 1: hours/rework_pct are the server's LLM-derived ESTIMATES, not a stopwatch and not
+      // locally reproducible — label them as estimates and point to the `skalpel autopsy` receipt.
+      display: `estimated ~${headline.hours ?? 0}h active with AI across ${headline.sessions ?? sessions} sessions; est. ~${headline.rework_pct ?? 0}% rework (run 'skalpel autopsy' for the exact receipt)`,
     });
   } else {
     recordInsight({ kind: "profile", display: `standing profile built from ${sessions} sessions` });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skalpel",
-  "version": "4.0.11",
+  "version": "4.0.13",
   "description": "Behavioral graph for AI-assisted coding — learns how you work and steers Claude Code + Codex in real time.",
   "type": "module",
   "bin": {

package/reveal.mjs

@@ -31,13 +31,25 @@ export function graphReadyNote() {
   const trap = m.report && (m.report.discriminative || [])[0] && m.report.discriminative[0].seq;
   const n = m.n_sessions || h.sessions || 0;
 
+  // PROVENANCE / HONESTY (RED LINE 1): both `hours` and `rework_pct` come from the hosted graph
+  // server's profile, which is built from an LLM judge's per-intent classification (intent_class +
+  // resolution) over the ingested transcripts. `hours` = summed, banded human read/dwell time on
+  // non-`other` intents (NOT raw session wall-clock); `rework_pct` = share of that time whose
+  // LLM-judged resolution is a "waste" class. Neither is a stopwatch measurement and neither
+  // re-derives locally the way `skalpel autopsy` does — so they must be surfaced as ESTIMATES, never
+  // as measured fact. The reproducible receipt is `skalpel autopsy`.
   const facts = [];
   if (h.hours)
-    facts.push(`they've spent about ${h.hours} hours working with AI across these sessions`);
+    facts.push(
+      `skalpel ESTIMATES they've spent about ${h.hours} hours of active time working with AI across ` +
+        `these sessions (inferred from their history — an estimate, not an exact clock)`,
+    );
   if (h.rework_pct)
     facts.push(
-      `roughly ${h.rework_pct}% of that time went into REWORK — going back to redo, re-explain, or ` +
-        `re-fix things they'd already worked on (that's the time skalpel is built to give back)`,
+      `and it estimates roughly ${h.rework_pct}% of that went into REWORK-type patterns — going back ` +
+        `to redo, re-explain, or re-fix things they'd already worked on (this % is skalpel's ESTIMATE ` +
+        `from reading their sessions, NOT a stopwatch figure — it's the kind of loop skalpel is built ` +
+        `to help with)`,
     );
   if (trap)
     facts.push(
@@ -54,8 +66,12 @@ export function graphReadyNote() {
     `"🔬 skalpel · your graph's ready — here's what I noticed about how you work:" — then, in 2-3 ` +
     `friendly plain-English sentences, tell them what it found` +
     (facts.length ? `: ${facts.join("; ")}` : "") +
-    `. Close by reassuring them this is exactly the loop skalpel now quietly watches for and steers them ` +
-    `out of, live, while they code — they don't have to track it themselves. Then continue with whatever ` +
-    `they actually asked. Keep the whole thing short and human.]`
+    `. HONESTY RULE: present every number as skalpel's ESTIMATE inferred from their history — hedge ` +
+    `naturally ("about", "roughly", "skalpel estimates") and NEVER state a figure as an exact ` +
+    `measurement. If they want the exact, locally-verified receipt that re-derives from the coding ` +
+    `logs already on their own machine, tell them they can run \`skalpel autopsy\` anytime. Close by ` +
+    `reassuring them this is exactly the loop skalpel now quietly watches for and steers them out of, ` +
+    `live, while they code — they don't have to track it themselves. Then continue with whatever they ` +
+    `actually asked. Keep the whole thing short and human.]`
   );
 }

package/skalpel-setup.mjs

@@ -698,12 +698,15 @@ async function revealInsights(report) {
   console.log("");
   await line(`   ${B}Here's what I learned about how you work:${X}\n`, 480);
 
+  // RED LINE 1: h.hours / h.rework_pct are the hosted graph server's ESTIMATES, built from an LLM
+  // judge's per-intent classification — not a stopwatch, and not locally reproducible. Surface them
+  // as estimates and point to `skalpel autopsy` (the zero-network receipt that re-derives from disk).
   const rw = h.rework_pct || 0;
   await line(
-    `   ${R}▸${X} You've spent ${B}${h.hours}h${X} with AI across ${h.sessions} sessions — and about ${B}${R}${rw}%${X} of it went to ${B}rework${X}:`,
+    `   ${R}▸${X} skalpel estimates about ${B}${h.hours}h${X} of active time with AI across ${h.sessions} sessions — and that about ${B}${R}${rw}%${X} of it went to ${B}rework${X}:`,
   );
   await line(
-    `     ${D}circling back, re-explaining, re-fixing the same thing. That's the time skalpel goes after.${X}\n`,
+    `     ${D}circling back, re-explaining, re-fixing the same thing — the loop skalpel goes after.${X}\n`,
     520,
   );
 
@@ -738,6 +741,13 @@ async function revealInsights(report) {
   }
 
   console.log("");
+  // RED LINE 1: everything above (hours, rework %, archetype waste-hours, time-sink %, escape %) is
+  // the hosted graph's ESTIMATE from an LLM read of your sessions — not a stopwatch. State that once,
+  // plainly, and point to the zero-network receipt that re-derives from the logs on THIS machine.
+  await line(
+    `   ${D}These are skalpel's estimates from your recent sessions — run ${X}${B}skalpel autopsy${X}${D} for the exact receipt that re-derives from the logs on this machine.${X}`,
+    260,
+  );
   await line(
     `   ${G}skalpel now watches for these every session and steers you off them in real time.${X}`,
     260,