skalpel 4.0.9 → 4.0.10

package/incremental-ingest.mjs

@@ -6,6 +6,7 @@
 // process kill, or accepted-response loss cannot lose the completed session or duplicate paid work.
 import { createHash } from "node:crypto";
 import {
+  appendFileSync,
   closeSync,
   existsSync,
   mkdirSync,
@@ -23,7 +24,6 @@ import { basename, extname, isAbsolute, join, relative, resolve, sep } from "nod
 import { gzipSync } from "node:zlib";
 
 import { identity } from "./auth.mjs";
-import { recordInsight } from "./insights.mjs";
 
 const OUTBOX_DIR = "ingest-outbox";
 const LEDGER_FILE = "delivered.json";
@@ -159,11 +159,31 @@ function saveItem(home, item) {
   writeAtomic(itemPath(home, item.key), item);
 }
 
-function notifyOnce(home, item, state, display, insightFn) {
+// INFRA STATUS is NOT product output. Background context-graph maintenance (retry-queued, waiting on
+// provider quota, snapshot-missing, membership-required) is an operational condition, not an insight the
+// user asked for — so it goes to a DOCTOR channel (~/.skalpel/doctor.log + stderr), never to the
+// user-facing insights feed. `skalpel doctor`/stderr is where an operator looks; the insights feed stays
+// exclusively product signal. Fail-open: a doctor write must never break the fail-safe SessionEnd hook.
+function doctorLog(home, message) {
+  const line = `${new Date().toISOString()} [ingest] ${message}`;
+  try {
+    process.stderr.write(line + "\n");
+  } catch {
+    /* stderr may be closed under the async hook — never throw */
+  }
+  try {
+    mkdirSync(skalpelDir(home), { recursive: true });
+    appendFileSync(join(skalpelDir(home), "doctor.log"), line + "\n");
+  } catch {
+    /* the doctor trail is best-effort; never block ingest on it */
+  }
+}
+
+function notifyOnce(home, item, state, message, doctorFn) {
   if (item.notified_state === state) return;
   item.notified_state = state;
   saveItem(home, item);
-  insightFn({ kind: "profile", display });
+  doctorFn(home, message);
 }
 
 function listItems(home, preferredKey) {
@@ -200,7 +220,7 @@ function retryDelayMs(generation) {
   return Math.min(60 * 60 * 1000, 5 * 60 * 1000 * 2 ** Math.max(0, generation - 1));
 }
 
-function scheduleTerminalRetry(home, item, status, now, insightFn) {
+function scheduleTerminalRetry(home, item, status, now, doctorFn) {
   const nextGeneration = (item.generation || 0) + 1;
   item.last_job_id = item.job_id || null;
   item.job_id = null;
@@ -218,7 +238,7 @@ function scheduleTerminalRetry(home, item, status, now, insightFn) {
       item,
       `retry-${nextGeneration}`,
       "context graph update hit an error; a safe retry is queued",
-      insightFn,
+      doctorFn,
     );
     return;
   }
@@ -230,12 +250,12 @@ function scheduleTerminalRetry(home, item, status, now, insightFn) {
     item,
     "fallback-required",
     "context graph update needs a retry; reopen Skalpel to run the history catch-up",
-    insightFn,
+    doctorFn,
   );
 }
 
 async function pollAcceptedJob(home, item, auth, options, deadline) {
-  const { api, fetchFn, insightFn, now, pollIntervalMs, requestTimeoutMs, sleepFn } = options;
+  const { api, fetchFn, doctorFn, now, pollIntervalMs, requestTimeoutMs, sleepFn } = options;
   const statusURL = `${api}/ingest/status?job_id=${encodeURIComponent(item.job_id)}`;
   for (;;) {
     let response;
@@ -258,7 +278,7 @@ async function pollAcceptedJob(home, item, auth, options, deadline) {
       return "pending";
     }
     if (response.status === 404) {
-      scheduleTerminalRetry(home, item, { state: "error", error: "job not found" }, now, insightFn);
+      scheduleTerminalRetry(home, item, { state: "error", error: "job not found" }, now, doctorFn);
       return "retry";
     }
     if (!response.ok) {
@@ -295,7 +315,7 @@ async function pollAcceptedJob(home, item, auth, options, deadline) {
       // carries retry_at, and resumes the SAME job. Pin both contracts; never infer one from the
       // state string alone.
       if (item.terminal && item.requires_replay) {
-        scheduleTerminalRetry(home, item, status, now, insightFn);
+        scheduleTerminalRetry(home, item, status, now, doctorFn);
         return "retry";
       }
       notifyOnce(
@@ -303,16 +323,16 @@ async function pollAcceptedJob(home, item, auth, options, deadline) {
         item,
         "waiting-quota",
         "context graph update is safely queued while provider capacity recovers",
-        insightFn,
+        doctorFn,
       );
       return "pending";
     }
     if (item.terminal && item.requires_replay) {
-      scheduleTerminalRetry(home, item, status, now, insightFn);
+      scheduleTerminalRetry(home, item, status, now, doctorFn);
       return "retry";
     }
     if (item.state === "error" || item.state === "failed") {
-      scheduleTerminalRetry(home, item, status, now, insightFn);
+      scheduleTerminalRetry(home, item, status, now, doctorFn);
       return "retry";
     }
     if (now() + pollIntervalMs >= deadline) return "pending";
@@ -321,7 +341,7 @@ async function pollAcceptedJob(home, item, auth, options, deadline) {
 }
 
 async function submitItem(home, item, auth, options, deadline) {
-  const { api, fetchFn, insightFn, now, requestTimeoutMs } = options;
+  const { api, fetchFn, doctorFn, now, requestTimeoutMs } = options;
   if (!item.job_id) {
     let transcript;
     try {
@@ -334,7 +354,7 @@ async function submitItem(home, item, auth, options, deadline) {
         item,
         "snapshot-missing",
         "context graph update needs a retry; reopen Skalpel to run the history catch-up",
-        insightFn,
+        doctorFn,
       );
       return "pending";
     }
@@ -378,7 +398,7 @@ async function submitItem(home, item, auth, options, deadline) {
         item,
         "membership-required",
         "context graph update is queued until membership access is available",
-        insightFn,
+        doctorFn,
       );
       return "pending";
     }
@@ -469,7 +489,7 @@ export function enqueueCompletedSession(payload, options = {}) {
 export async function drainIncrementalOutbox(options = {}) {
   const home = options.home || homedir();
   const now = options.now || Date.now;
-  const insightFn = options.insightFn || recordInsight;
+  const doctorFn = options.doctorFn || doctorLog;
   ensureOutbox(home);
   const lockPath = join(outboxDir(home), DRAIN_LOCK);
   if (!acquireLock(lockPath, now)) return { locked: true, pending: listItems(home).length };
@@ -490,7 +510,7 @@ export async function drainIncrementalOutbox(options = {}) {
     const common = {
       api: options.api || clientAPI(home),
       fetchFn: options.fetchFn || fetch,
-      insightFn,
+      doctorFn,
       now,
       pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
       requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,

package/package.json

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

package/skalpel-hook-session.mjs

@@ -6,7 +6,7 @@
 //
 // Wire it (Claude ~/.claude/settings.json):
 //   {"hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"node …/skalpel-hook-session.mjs"}]}]}}
-import { readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { identity } from "./auth.mjs";
@@ -14,43 +14,44 @@ import { record } from "./metrics.mjs";
 import { recordInsight } from "./insights.mjs";
 import { graphReadyNote } from "./reveal.mjs";
 
-// The statusline counter is PER-SESSION: it shows the estimated rework skalpel flagged during THIS
-// session, not a forever-accumulating lifetime total (which reads as a bragging trophy and is
-// unprovable). SessionStart zeroes it so each new session starts the count fresh. Fail-open — a
-// stats reset must never block the profile injection.
-// RECAP — the felt wins, surfaced at a break point (peak-end rule). Two break points:
+// RECAP — surfaced at a break point (peak-end rule). It reports a COUNT of the steers skalpel actually
+// showed (a reproducible number from session.json's steers array) and the recurring work-type — NEVER a
+// "saved ~Xmin" figure (that was a server estimate rendered as measured time; it is gone). Two break
+// points:
 //   • "compact"  → mid-session, right AFTER compaction (a natural chapter break, user present). The
 //                  recap is CUMULATIVE ("so far this session") and the tally is NOT reset — work goes on.
 //   • else       → a fresh session start; recap the PREVIOUS session's tally (re-engagement), then reset.
 // PreCompact/SessionEnd stdout are silent in Claude Code; the post-compact SessionStart CAN inject, so
 // that's where the compaction recap rides. Read BEFORE resetStats wipes it.
 const SESSION_PATH = join(homedir(), ".skalpel", "session.json");
-// Returns { note, mins } — the injected directive AND the minutes it cites, so the local insight
-// record (below) can reuse the exact same number instead of re-deriving it.
+// Returns { note, n } — the injected directive AND the steer count it cites, so the local insight record
+// (below) can reuse the exact same number instead of re-deriving it.
 function buildRecap(source) {
   try {
     const s = JSON.parse(readFileSync(SESSION_PATH, "utf8"));
-    const mins = Math.round(s.mins || 0);
     const steers = Array.isArray(s.steers) ? s.steers : [];
-    // Recap only when there's real saved time to report — the honest, felt number. No "caught" count.
-    if (mins < 1) return { note: null, mins: 0 };
+    const n = steers.length;
+    // Recap only when skalpel actually showed steers this session — a real, reproducible count.
+    if (n < 1) return { note: null, n: 0 };
     const byWt = {};
     for (const st of steers) if (st.wt) byWt[st.wt] = (byWt[st.wt] || 0) + 1;
     const top = Object.entries(byWt).sort((a, b) => b[1] - a[1])[0];
-    const trapTail = top ? ` — ${top[0]} kept coming up` : "";
+    const trapTail = top ? ` — ${top[0]} kept coming up (${top[1]}×)` : "";
     const compact = source === "compact";
     const when = compact ? "in the stretch before this compaction" : "last session";
+    const count = `${n} recurring-pattern moment${n === 1 ? "" : "s"}`;
     const line = compact
-      ? `“🔬 skalpel · in that last stretch I saved you ~${mins}min${trapTail} — fresh context now.”`
-      : `“🔬 skalpel · last session I saved you ~${mins}min${trapTail}.”`;
+      ? `“🔬 skalpel · flagged ${count} in that last stretch${trapTail} — fresh context now. Run \`skalpel autopsy\` for the receipts.”`
+      : `“🔬 skalpel · last session I flagged ${count}${trapTail}. Run \`skalpel autopsy\` for the receipts.”`;
     const note =
-      `[skalpel — RECAP (${when}): saved ~${mins}min` +
+      `[skalpel — RECAP (${when}): skalpel flagged ${count}` +
       (top ? `; the recurring trap was ${top[0]} (${top[1]}×)` : "") +
-      `. Open THIS message with ONE natural line so they see it landed — ${line} ` +
-      "Then continue normally. Skip it only if it doesn't fit.]";
-    return { note, mins };
+      `. Open THIS message with ONE natural line so they see it — ${line} ` +
+      "Then continue normally. Do NOT invent any time-saved number — the only honest figures live in " +
+      "`skalpel autopsy`. Skip the recap if it doesn't fit.]";
+    return { note, n };
   } catch {
-    return { note: null, mins: 0 }; // no prior session / fresh install
+    return { note: null, n: 0 }; // no prior session / fresh install
   }
 }
 
@@ -58,34 +59,14 @@ function resetStats() {
   try {
     const dir = join(homedir(), ".skalpel");
     mkdirSync(dir, { recursive: true });
-    const p = join(dir, "stats.json");
-    // Reset the SESSION counters to zero but PRESERVE the lifetime total across sessions — so the
-    // statusline can show both "saved this session" and "total saved". Read current first.
-    let s = {
-      session_hours: 0,
-      session_cost: 0,
-      session_events: 0,
-      total_hours: 0,
-      total_cost: 0,
-      total_events: 0,
-    };
-    try {
-      s = { ...s, ...JSON.parse(readFileSync(p, "utf8")) };
-    } catch {
-      /* fresh */
-    }
-    s.session_hours = 0;
-    s.session_cost = 0;
-    s.session_events = 0;
-    const tmp = `${p}.tmp`;
-    writeFileSync(tmp, JSON.stringify(s));
-    renameSync(tmp, p);
-    // also clear any pending n+1 prediction from the prior session — a stale prediction must never
-    // false-credit an avoided detour across a session boundary.
+    // The old stats.json "time saved" accumulator is GONE — nothing writes or reads it anymore, so there
+    // is nothing to zero here. This just clears the per-session working state so each session starts fresh.
+    // Clear any pending n+1 prediction from the prior session — a stale prediction must never
+    // false-attribute a break-out across a session boundary.
     writeFileSync(join(dir, "pending.json"), "{}");
     writeFileSync(join(dir, "steer.json"), "{}"); // no live steer until the first prompt this session
     writeFileSync(join(dir, "traj.json"), "[]"); // fresh work-type trajectory each session
-    writeFileSync(join(dir, "session.json"), JSON.stringify({ steers: [], caught: 0, mins: 0 })); // recap tally
+    writeFileSync(join(dir, "session.json"), JSON.stringify({ steers: [] })); // recap tally (steer count)
     // clear the SESSION-scoped mute (a shush lasts one session), but PRESERVE persistent prefs
     // (per-trap "fewer"/"more", usefulness scores) — those are the learned personalization.
     try {
@@ -131,7 +112,7 @@ async function main() {
   }
   // source distinguishes a real new session (startup/resume/clear) from a mid-session compaction.
   const source = payload.source || payload.hookSpecificOutput?.source || "startup";
-  const { note: recapNote, mins: recapMins } = buildRecap(source); // read the tally BEFORE resetStats wipes it
+  const { note: recapNote, n: recapN } = buildRecap(source); // read the tally BEFORE resetStats wipes it
   // Compaction CONTINUES the session — keep the counter + tally running; only a real start zeroes them.
   if (source !== "compact") resetStats();
   // identity from the Google sign-in (refreshed if near expiry); the token authenticates the read so
@@ -180,8 +161,7 @@ async function main() {
   if (recapNote)
     recordInsight({
       kind: "recap",
-      display: `last session skalpel saved you ~${recapMins}min`,
-      mins: recapMins,
+      display: `last session skalpel flagged ${recapN} recurring-pattern moment${recapN === 1 ? "" : "s"}`,
     });
   if (context)
     recordInsight({

package/skalpel-hook.mjs

@@ -108,46 +108,10 @@ function detectCascade(payload) {
   }
 }
 
-// The running "rework flagged" counter — one JSON file, incremented every time a real recurring
-// pattern fires (server already gated it on recurs>=3, so this only counts real trends). The number
-// is the ESTIMATED downstream waste on the path we flagged — rework that USUALLY happens from here,
-// not time already saved (we can't prove the nudge changed anything). Per-session: SessionStart
-// zeroes it (see skalpel-hook-session.mjs). Read by the statusline, Brave-ad-block-counter style.
-const STATS_PATH = join(homedir(), ".skalpel", "stats.json");
-const EMPTY_STATS = {
-  session_hours: 0,
-  session_cost: 0,
-  session_events: 0,
-  total_hours: 0,
-  total_cost: 0,
-  total_events: 0,
-};
-function bumpStats(hours, cost) {
-  try {
-    let s = { ...EMPTY_STATS };
-    try {
-      s = { ...s, ...JSON.parse(readFileSync(STATS_PATH, "utf8")) };
-    } catch {
-      /* missing or corrupt -> start fresh, never block on it */
-    }
-    const r2 = (n) => Math.round(n * 100) / 100;
-    const h = hours || 0;
-    const c = cost || 0;
-    // increment BOTH: session (resets each session) and total (lifetime, never resets)
-    s.session_hours = r2(s.session_hours + h);
-    s.session_cost = r2(s.session_cost + c);
-    s.session_events += 1;
-    s.total_hours = r2(s.total_hours + h);
-    s.total_cost = r2(s.total_cost + c);
-    s.total_events += 1;
-    mkdirSync(join(homedir(), ".skalpel"), { recursive: true });
-    const tmp = `${STATS_PATH}.tmp`;
-    writeFileSync(tmp, JSON.stringify(s));
-    renameSync(tmp, STATS_PATH); // atomic swap — a concurrent read never sees a half-written file
-  } catch {
-    /* stats are a bonus, never block emitting the injection */
-  }
-}
+// NOTE: the old stats.json "time saved" accumulator (session_hours/total_hours/…/total_events) is GONE.
+// It summed a SERVER estimate of expected-waste-ahead and the statusline rendered it as "~Xh saved" — an
+// estimate shown as a measurement. Nothing writes or reads stats.json anymore; the only honest local
+// receipts are what `skalpel autopsy` re-derives from the raw transcripts on disk.
 
 // n+1 CONFIRMATION store — the honest, Brave-style counter. At turn N we PREDICT a rework path but
 // credit NOTHING yet; we stash the prediction here. At turn N+1 we check whether you actually broke
@@ -182,13 +146,12 @@ function readSteer() {
     return {};
   }
 }
-function writeSteer(label, creditMins, type, wt, id) {
-  // label = server's plain-English "what skalpel's doing" (or null on a silent turn). credit = the
-  // +Xmin the n+1 check just credited THIS turn (or null) -> the statusline flashes "+Xmin ✓", the
-  // felt "just delivered" tick, on the exact turn a break-out lands. type/wt = the raw steer identity
-  // (e.g. "TELL"/"refine") so the NEXT turn's feedback phrase ("fewer like this") can target it.
-  // id = the steer's join key (minted once per steer turn, also on that steer's insight row) so the
-  // NEXT turn's adherence record can reference exactly this steer; null on a silent turn.
+function writeSteer(label, type, wt, id) {
+  // label = server's plain-English "what skalpel's doing" (or null on a silent turn) — a DESCRIPTION the
+  // statusline can show, never a number. The old `credit` field (a +Xmin estimate rendered as a measured
+  // tick) is REMOVED. type/wt = the raw steer identity (e.g. "TELL"/"refine") so the NEXT turn's feedback
+  // phrase ("fewer like this") can target it. id = the steer's join key (minted once per steer turn, also
+  // on that steer's insight row) so the NEXT turn's adherence record can reference exactly this steer.
   try {
     mkdirSync(join(homedir(), ".skalpel"), { recursive: true });
     const tmp = `${STEER_PATH}.tmp`;
@@ -196,7 +159,6 @@ function writeSteer(label, creditMins, type, wt, id) {
       tmp,
       JSON.stringify({
         label: label || null,
-        credit: creditMins || null,
         type: type || null,
         wt: wt || null,
         id: id || null,
@@ -228,8 +190,9 @@ function readPrefs() {
 
 // ADHERENCE — the implicit workhorse (Grammarly's accept/reject, not thumbs). Per steer TYPE we track,
 // from BEHAVIOR alone: shown (fired), acted (you moved off the work-type it pushed you off next turn),
-// paid (acting also produced an n+1 time-saved credit). This is revealed preference — which of your
-// patterns you actually act on — and it accretes across sessions into your personal steer model.
+// paid (acting also coincided with an n+1 BREAK-OUT — expected-waste-ahead dropped). All categorical
+// revealed preference — which of your patterns you actually act on — never a number shown to the user;
+// it accretes across sessions into your personal steer model.
 function recordAdherence(prefs, prev, thisWt, paid) {
   if (!prev || !prev.type || !thisWt) return null;
   prefs.stats = prefs.stats || {};
@@ -298,22 +261,21 @@ function parseControl(q) {
   return null;
 }
 
-// SESSION EVENT LOG — the raw material for the end-of-session recap (peak-end rule). One row per turn
-// where a steer fired or a break-out was credited. SessionStart resets it; SessionEnd renders it.
+// SESSION EVENT LOG — the raw material for the end-of-session recap (peak-end rule). One row per turn a
+// steer actually fired: a COUNT of real steers shown, plus their work-types (for "refine kept coming up").
+// No minutes, no "caught" tally — those were estimate-derived. SessionStart resets it; SessionEnd renders
+// it as a count. (`ev.caughtMins` is intentionally ignored; the estimate path that fed it is gone.)
 const SESSION_PATH = join(homedir(), ".skalpel", "session.json");
 function logSessionEvent(ev) {
   try {
-    let s = { steers: [], caught: 0, mins: 0 };
+    let s = { steers: [] };
     try {
-      s = { ...s, ...JSON.parse(readFileSync(SESSION_PATH, "utf8")) };
+      const prev = JSON.parse(readFileSync(SESSION_PATH, "utf8"));
+      if (Array.isArray(prev?.steers)) s.steers = prev.steers;
     } catch {
       /* fresh session */
     }
     if (ev.type) s.steers.push({ type: ev.type, wt: ev.wt || null, ts: Date.now() });
-    if (ev.caughtMins) {
-      s.caught += 1;
-      s.mins += ev.caughtMins;
-    }
     mkdirSync(join(homedir(), ".skalpel"), { recursive: true });
     const tmp = `${SESSION_PATH}.tmp`;
     writeFileSync(tmp, JSON.stringify(s));
@@ -494,12 +456,10 @@ async function main() {
   const timer = setTimeout(() => ctrl.abort(), remaining);
   const t0 = Date.now();
   let injection = null;
-  let winNote = null; // positive reinforcement: set when THIS turn confirms you broke out of a rut
-  let winMins = null; // the ~minutes the win note cites — reused verbatim by the insight record
-  let steerLabel = null; // "what skalpel's doing" for the statusline
+  let steerLabel = null; // "what skalpel's doing" for the statusline — a DESCRIPTION, never a number
   let steerType = null; // raw top-steer type (TELL/SINK/…) — for the feedback loop + session log
   let steerWt = null; // the work-type the steer is about (refine/debug/…)
-  let creditMins = null; // the +Xmin the n+1 check credited THIS turn -> statusline tick
+  let brokeOut = false; // behavioral-only: did expected-waste-ahead drop after last turn's steer (adherence)
   let outcome = "fetch_error";
   try {
     const r = await fetch(`${API}/retrieve`, {
@@ -546,59 +506,35 @@ async function main() {
           "\n\n[skalpel — the user asked for MORE on this trap; expand: name the shape, the count, and the way out in 2-3 sentences.]";
       }
 
-      // --- n+1 CONFIRMATION: credit the DROP in expected waste-ahead (diff-from-worst) ---
-      // Turn N (a flagged high-waste moment) armed pending with V(N) = the DAG's expected waste ahead
-      // from where you were. THIS turn's waste-ahead is V(N+1) = j.state_hours. If it DROPPED, you
-      // moved toward resolved -> credit the drop (the real magnitude of time saved, now that the DAG
-      // state values discriminate stuck-vs-resolved; before they were flat so the drop was always 0).
+      // --- n+1 CONFIRMATION: did the user BREAK OUT of last turn's flagged pattern? (behavioral only) ---
+      // Turn N (a flagged high-waste moment) armed pending with V(N) = the DAG's expected waste-ahead from
+      // where you were. THIS turn's waste-ahead is V(N+1) = j.state_hours. A meaningful DROP means you
+      // moved toward "resolved" — a BEHAVIORAL signal that feeds adherence (did acting on the steer pay
+      // off). It is NEVER converted into a user-facing "time saved" number: the DAG state values are a
+      // server estimate, not a measured clock, so surfacing them as minutes would be fabrication.
       const vNow = typeof j?.state_hours === "number" ? j.state_hours : null;
-      const vcNow = typeof j?.state_cost === "number" ? j.state_cost : 0;
       const pending = readPending();
       if (pending && typeof pending.v === "number" && vNow !== null) {
-        const savedH = Math.max(0, pending.v - vNow); // waste-ahead you shed since last turn
-        const savedC = Math.max(0, (pending.vc || 0) - vcNow);
-        // COHERENCE: a "catch" must be a REAL, visible >=1min drop. Everything downstream — the counter,
-        // the "+Xmin this turn" tick, the "N caught" tally, the recap minutes — is driven by the SAME
-        // number (cm), so caught can NEVER increment without the time moving by the same amount. (The old
-        // code credited sub-minute drops and forced caughtMins to 1 via Math.max, so caught ticked up
-        // while creditMins rounded to 0 and the visible time didn't budge — the incoherence.)
-        const cm = Math.round(savedH * 60);
-        if (cm >= 1) {
-          bumpStats(savedH, savedC);
-          creditMins = cm; // the felt "+Xmin ✓" tick — same value as the catch
-          logSessionEvent({ caughtMins: cm }); // caught++ and recap minutes, same number
-          dbg(`  -> n+1 CREDIT: waste-ahead ${pending.v}h -> ${vNow}h, +${cm}min saved`);
-          // REINFORCE GOOD MOVES (the carrot): on a MEANINGFUL break-out (not a trivial drop),
-          // hand the model a brief positive-acknowledgment note. Sparse by threshold so praise stays
-          // a signal, not noise — a coach that celebrates every micro-step becomes wallpaper too.
-          if (savedH >= 0.08) {
-            const mins = Math.max(1, Math.round(savedH * 60));
-            winMins = mins;
-            winNote =
-              `[skalpel — the user just broke OUT of a pattern that usually costs them ~${mins}min of rework. ` +
-              `If it feels natural (don't force it), briefly acknowledge the good move in one line — ` +
-              `e.g. "🔬 skalpel · nice — you skipped the loop you usually get stuck in there" — then continue. ` +
-              `Reinforce the behavior, don't lecture. Skip it if the moment doesn't fit.]`;
-          }
-        } else {
-          dbg(
-            `  -> n+1 no-credit: waste-ahead ${pending.v}h -> ${vNow}h (drop < 1min, not counted)`,
-          );
-        }
+        // >=0.08 in the estimate's units = a real move toward resolved (not estimate jitter). Boolean only.
+        brokeOut = pending.v - vNow >= 0.08;
+        dbg(
+          `  -> n+1 ${brokeOut ? "BREAK-OUT" : "no-breakout"}: waste-ahead ${pending.v} -> ${vNow}`,
+        );
         writePending({}); // this turn's confirmation is consumed
       }
       // Arm NEXT turn: when the injection fires (a flagged high-waste moment) AND we have a V for this
-      // turn, remember it so N+1 can measure how far your waste-ahead dropped.
+      // turn, remember it so N+1 can tell whether you broke out.
       if (injection && vNow !== null) {
-        writePending({ v: vNow, vc: vcNow });
+        writePending({ v: vNow });
       } else if (!pending || vNow !== null) {
         writePending({}); // clear only when we actually had data this turn (don't drop a stale carry)
       }
 
-      // IMPLICIT ADHERENCE (the real Grammarly loop): now that the n+1 credit has resolved, record
-      // whether LAST turn's steer landed — did you act on it (moved off its work-type) and did acting
-      // pay off (a credit this turn). Accretes per steer-type; the gate above reads it next time.
-      const paid = creditMins != null && creditMins > 0;
+      // IMPLICIT ADHERENCE (the real Grammarly loop): now that the break-out check has resolved, record
+      // whether LAST turn's steer landed — did you act on it (moved off its work-type) and did acting pay
+      // off (a break-out this turn). Accretes per steer-type; the gate above reads it next time. This is
+      // categorical revealed-preference data, not a number shown to the user.
+      const paid = brokeOut;
       const adh = recordAdherence(prefs, prevSteer, steerWt, paid);
       writePrefs(prefs);
       // ADHERENCE INSIGHT ROW (data, not display — no `display` field): the same judgment, exported
@@ -626,11 +562,10 @@ async function main() {
     record("prompt", outcome, Date.now() - t0);
   }
 
-  // MUTE is absolute — a shushed session surfaces NOTHING (steer, reset, or win). The ack note (a
-  // one-time "muted" confirmation) still goes through, since that IS the mute turn's response.
+  // MUTE is absolute — a shushed session surfaces NOTHING (steer or reset). The ack note (a one-time
+  // "muted" confirmation) still goes through, since that IS the mute turn's response.
   if (prefs.muted_session) {
     resetNote = null;
-    winNote = null;
     injection = null;
     steerLabel = null;
   }
@@ -638,13 +573,13 @@ async function main() {
   // A live cascade reset outranks the server steer for the statusline label (it's the acute one).
   if (resetNote) steerLabel = "resetting a spiral";
 
-  // Statusline state, written ONCE per turn: what skalpel is doing now + the +Xmin the n+1 check just
-  // credited (the felt "just delivered" tick), plus the raw steer identity so NEXT turn's feedback
-  // phrase can target it. All null on a silent/no-credit turn -> bar shows just the running total.
-  // steerId = the join key minted once per STEER turn (a string), written to BOTH steer.json and the
-  // steer's insight row below, so next turn's adherence record can reference exactly this steer.
+  // Statusline state, written ONCE per turn: the plain-English label of what skalpel is doing now (a
+  // description, never a number), plus the raw steer identity so NEXT turn's feedback phrase can target
+  // it. label is null on a silent turn. steerId = the join key minted once per STEER turn (a string),
+  // written to BOTH steer.json and the steer's insight row below, so next turn's adherence record can
+  // reference exactly this steer.
   const steerId = injection ? String(Date.now()) : null;
-  writeSteer(steerLabel, creditMins, steerType, steerWt, steerId);
+  writeSteer(steerLabel, steerType, steerWt, steerId);
   if (injection) logSessionEvent({ type: steerType, wt: steerWt }); // feed the end-of-session recap
 
   // LOCAL INSIGHT RECORDS (~/.skalpel/insights.ndjson) — one plain-English row per note kind that
@@ -656,15 +591,6 @@ async function main() {
       id: steerId,
       display: steerLabel || "a steer for this spot",
       label: steerLabel,
-      mins: creditMins > 0 ? creditMins : null,
-      harness,
-      session_id: sessionId,
-    });
-  if (winNote)
-    recordInsight({
-      kind: "win",
-      display: `nice — you broke out of a pattern that usually costs ~${winMins}min`,
-      mins: winMins,
       harness,
       session_id: sessionId,
     });
@@ -685,11 +611,9 @@ async function main() {
 
   // A just-finished background build leads (one-shot: surface "your graph's ready" the instant the next
   // prompt fires, so the user doesn't have to restart a session to see it), then ackNote (feedback
-  // confirmation), the reset interrupt (most acute), the server steer, and the win note. Any can fire alone.
+  // confirmation), the reset interrupt (most acute), and the server steer. Any can fire alone.
   const readyNote = graphReadyNote();
-  const additionalContext = [readyNote, ackNote, resetNote, winNote, injection]
-    .filter(Boolean)
-    .join("\n\n");
+  const additionalContext = [readyNote, ackNote, resetNote, injection].filter(Boolean).join("\n\n");
   if (additionalContext) {
     process.stdout.write(
       JSON.stringify({

package/skalpel-statusline.mjs

@@ -1,65 +1,137 @@
 #!/usr/bin/env node
-// skalpel statusline — reads the running "time saved" counter (bumped by skalpel-hook.mjs every time
-// a real recurring pattern fires) and prints one line for Claude Code's status bar. Brave's
-// ads-blocked-counter, but for AI-coding thrash. The zero state stays visible so a fresh install
-// advertises that skalpel is present before the first confirmed save lands.
-import { readFileSync } from "node:fs";
+// skalpel statusline — COUNT-OR-NOTHING. Prints ONLY facts that reproduce from local state, never an
+// estimate dressed up as a measurement. There is no "~Xh saved" and no "+min this turn": those were a
+// SERVER estimate of expected-waste (never a measured clock), so they are gone. What can honestly show:
+//   • the live re-ask/interrupt COUNT for THIS session, read straight from the transcript Claude Code
+//     hands us on stdin — the exact material `skalpel autopsy` re-derives from disk, a count of things
+//     that verifiably happened, or
+//   • the current steer's plain-English label (what skalpel is doing now) — a description, not a number.
+// A clean session prints NOTHING. Fail-open: any error → print nothing, exit 0. Never blocks the bar.
+import { closeSync, fstatSync, openSync, readFileSync, readSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-const STATS_PATH = join(homedir(), ".skalpel", "stats.json");
-const STEER_PATH = join(homedir(), ".skalpel", "steer.json");
-
-// ANSI — the status bar renders color. Emphasize the WIN (time saved) in green; show the live steer
-// in accent; recede the secondary numbers so the eye lands on saved-time + what skalpel's doing now.
-const GREEN = "\x1b[32m";
 const CYAN = "\x1b[36m";
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
 const RESET = "\x1b[0m";
 
-function main() {
-  let s = {};
+// Claude Code pipes a JSON status payload on stdin (transcript_path, session_id, …). Read it ONLY when
+// stdin is actually piped — never block on a TTY (manual invocation) where reading fd 0 would hang.
+function readPayload() {
   try {
-    const parsed = JSON.parse(readFileSync(STATS_PATH, "utf8"));
-    if (parsed && typeof parsed === "object") s = parsed;
+    if (process.stdin.isTTY) return {};
+    const raw = readFileSync(0, "utf8");
+    if (!raw.trim()) return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
-    // Missing/corrupt first-run state is an honest zero, not a reason to hide the status line.
+    return {};
   }
-  const finiteOrZero = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
-  const sess = finiteOrZero(s.session_hours).toFixed(1);
-  const total = finiteOrZero(s.total_hours).toFixed(1);
-  const steers = finiteOrZero(s.total_events);
+}
 
-  // The LIVE steer (written by skalpel-hook.mjs each turn) — the deterministic awareness channel: the
-  // user SEES skalpel steering right now, even when the model doesn't surface a 🔬 line in the answer.
-  let steerLabel = null;
-  let creditMins = null;
+// Read only the TAIL of a (possibly large) transcript — the status bar re-renders often, so we never
+// slurp a multi-MB file. Drop the partial first line so JSON.parse only ever sees whole records.
+function tailLines(path, maxBytes) {
+  let fd;
   try {
-    const st = JSON.parse(readFileSync(STEER_PATH, "utf8"));
-    steerLabel = st?.label || null;
-    creditMins = st?.credit || null;
+    fd = openSync(path, "r");
+    const size = fstatSync(fd).size;
+    const start = Math.max(0, size - maxBytes);
+    const len = size - start;
+    if (len <= 0) return [];
+    const buf = Buffer.allocUnsafe(len);
+    readSync(fd, buf, 0, len, start);
+    let text = buf.toString("utf8");
+    if (start > 0) {
+      const nl = text.indexOf("\n");
+      if (nl >= 0) text = text.slice(nl + 1);
+    }
+    return text.split("\n").filter(Boolean);
   } catch {
-    /* no steer/credit this turn — just show the counter */
+    return [];
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch {
+        /* already closed */
+      }
+    }
   }
-  // The felt "just delivered" tick — the +Xmin the n+1 check credited THIS turn. Hero position, bold
-  // green, right after the wordmark: you SEE it land, then it folds into the growing total.
-  // the per-turn tick sits to the RIGHT of the running total: total = the accumulation, tick = what
-  // THIS turn just added. Both green (the win).
-  const tick = creditMins ? ` · ${BOLD}${GREEN}+${creditMins} min saved this turn${RESET}` : "";
-  // Animate the steering label so it reads as LIVE — Claude Code re-invokes the statusline periodically,
-  // so a time-derived frame cycles a small spinner. (A single-line status bar can't move text vertically;
-  // this is the alive-feeling equivalent.) Only spins while a steer is on the board.
-  const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-  const frame = FRAMES[Math.floor(Date.now() / 120) % FRAMES.length];
-  const steering = steerLabel ? ` · ${CYAN}${frame} steering: ${steerLabel}${RESET}` : "";
+}
 
-  // LIVE session tally — how many loops skalpel has caught THIS session (peak-end: the "end" number
-  // stays visible so the user sees it before they quit, even though the recap itself lands next start).
-  void sess;
-  process.stdout.write(
-    `${BOLD}skalpel${RESET}${steering} · ${GREEN}~${total}h saved${RESET}${tick} · ${DIM}${steers} steers${RESET}`,
-  );
+// The re-ask signal, counted from disk: over the last few user turns of THIS session's transcript, how
+// many times did the user INTERRUPT ("[Request interrupted by user]") or fire a short CORRECTION ("no",
+// "still wrong", "that's not it"). Mirrors the per-turn hook's own cascade detector so the number the
+// bar shows is the same one the hook acts on — and it is a COUNT of real events, not a time estimate.
+const CORRECTION =
+  /^(no\b|nope|that'?s not|not what|still\b|again\b|wrong\b|i said|i meant|wtf|tf\b|why (is|are|does|isn|do)|ugh|c'?mon|cmon|bruh)/i;
+function reaskCount(transcriptPath) {
+  if (!transcriptPath) return 0;
+  const lines = tailLines(transcriptPath, 256 * 1024);
+  if (!lines.length) return 0;
+  let signals = 0;
+  let userTurns = 0;
+  for (let i = lines.length - 1; i >= 0 && userTurns < 6; i--) {
+    let e;
+    try {
+      e = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    const raw = e.content ?? e.message?.content;
+    const text =
+      typeof raw === "string"
+        ? raw
+        : Array.isArray(raw)
+          ? raw
+              .filter((b) => b?.type === "text")
+              .map((b) => b.text)
+              .join(" ")
+          : "";
+    if (/\[Request interrupted by user\]/i.test(text)) signals++;
+    if (e.type === "user" || e.role === "user") {
+      userTurns++;
+      if (CORRECTION.test(text.trim())) signals++;
+    }
+  }
+  return signals;
+}
+
+// The current steer's label — the plain-English "what skalpel is doing" for the latest turn (null on a
+// silent turn, since the hook overwrites it to null when nothing fired). A DESCRIPTION, not a number. We
+// read ONLY `label`; the old `credit` minutes field is not read here and is no longer written at all.
+function steerLabel() {
+  try {
+    const st = JSON.parse(readFileSync(join(homedir(), ".skalpel", "steer.json"), "utf8"));
+    const label = st && typeof st === "object" ? st.label : null;
+    return typeof label === "string" && label.trim() ? label.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  const payload = readPayload();
+
+  // Acute + reproducible: the user has re-asked / interrupted repeatedly this stretch. Surface the count
+  // and point at the receipts — every figure in `skalpel autopsy` re-derives from these same local logs.
+  const n = reaskCount(payload.transcript_path);
+  if (n >= 2) {
+    process.stdout.write(
+      `${BOLD}skalpel${RESET} · ${CYAN}${n} re-asks/interrupts this stretch${RESET} · ${DIM}run: skalpel autopsy${RESET}`,
+    );
+    return;
+  }
+
+  // Otherwise, if a steer is live, name what it's doing — a description, no number. Else: print NOTHING.
+  const label = steerLabel();
+  if (label) {
+    process.stdout.write(`${BOLD}skalpel${RESET} · ${CYAN}${label}${RESET}`);
+    return;
+  }
+  // Clean session → COUNT-OR-NOTHING resolves to nothing. Emit no bytes.
 }
 
 main();