phewsh 0.15.27 → 0.15.29

package/commands/hook.js

@@ -124,7 +124,16 @@ function sessionEnd() {
   process.stdin.on('end', () => {
     let reason = null;
     try { reason = JSON.parse(stdin).reason || null; } catch { /* metadata only; fine */ }
-    appendBreadcrumb('session-end', reason ? { reason } : {});
+    // Self-heal: if this project's .intent/ drifted ahead of CLAUDE.md during
+    // the session, bring it current now — so the next tool to open here (phewsh
+    // or any agent) reads today's intent without anyone running `seq -w`. Silent
+    // and deterministic; failures never touch the host tool.
+    let healed = false;
+    try {
+      const selfheal = require('../lib/selfheal');
+      if (selfheal.isStale()) healed = selfheal.heal().healed;
+    } catch { /* a hook must never error the host */ }
+    appendBreadcrumb('session-end', { ...(reason ? { reason } : {}), ...(healed ? { healed: true } : {}) });
     process.exit(0);
   });
   // If the host never closes stdin, don't hang it.

package/commands/outcomes.js

@@ -10,6 +10,8 @@ const {
   OUTCOMES, recordDecision, labelOutcome,
   pendingDecisions, recentDecisions, outcomeStats, bypassStats,
 } = require('../lib/outcomes');
+const learning = require('../lib/learning');
+const continuity = require('../lib/continuity');
 
 const { b, teal, peach, sage, slate, cream, ember, green } = ui;
 
@@ -42,76 +44,108 @@ function showBypasses() {
   }
 }
 
+// Plain-language explanation of the contract — shown every time, because the
+// #1 complaint was "I have no idea what this is for or how to use it."
+function explainDeal() {
+  console.log(`  ${b(cream('Outcomes'))} ${slate('— phewsh\'s memory of what actually worked')}`);
+  ui.divider('line');
+  console.log(`  ${sage('Every call you route, phewsh logs. Tell it what you')} ${green('kept')} ${sage('vs')} ${ember('threw out')}${sage(',')}`);
+  console.log(`  ${sage('and it learns which tool to trust for which job — and warns you before')}`);
+  console.log(`  ${sage('you repeat something that flopped.')} ${slate('That labeled record is the one thing')}`);
+  console.log(`  ${slate('your chat history doesn\'t have. Two taps now = smarter routing later.')}`);
+}
+
+// The payoff, in their own data — so labeling feels like it buys something.
+function showPayoff(stats) {
+  const lines = [];
+  try {
+    const best = learning.bestRoute(stats, { minSample: 2 });
+    if (best && best.keptRate >= 0.5) {
+      const label = continuity.labelFor(best.route) || best.route;
+      lines.push(`${green('●')} ${sage(label + ' keeps best for you — ')}${cream(Math.round(best.keptRate * 100) + '%')} ${sage(`(${best.kept}/${best.total}). phewsh leans there when it routes.`)}`);
+    }
+  } catch { /* best-effort */ }
+  const regrets = stats.reverted + stats.failed;
+  if (regrets > 0) {
+    lines.push(`${ember('●')} ${sage((regrets === 1 ? '1 call you marked a miss is' : regrets + ' calls you marked misses are') + ' remembered — ')}${cream('/recall')} ${sage('warns you before a repeat.')}`);
+  }
+  if (lines.length === 0) return;
+  console.log('');
+  console.log(`  ${b(cream('What it already knows'))} ${slate('← this is the payoff')}`);
+  for (const l of lines) console.log(`    ${l}`);
+  if (stats.judged < 4) console.log(`    ${slate('judge a few more and clearer patterns surface here.')}`);
+}
+
 function showStats() {
   const stats = outcomeStats();
-  const labeled = stats.total - stats.pending;
 
   console.log('');
-  console.log(`  ${b(cream('Outcomes'))} ${slate('— what your decisions became')}`);
-  ui.divider('line');
+  explainDeal();
 
   if (stats.total === 0) {
-    console.log(`  ${sage('Nothing recorded yet.')}`);
-    console.log(`  ${slate('Work through a phewsh session — every routed action records a decision.')}`);
-    console.log(`  ${slate('Label them 1-4 as you learn what held up.')}`);
+    console.log('');
+    console.log(`  ${sage('Nothing logged yet — start routing work and it fills in.')}`);
+    console.log(`  ${slate('In a session: just type, or use /use <tool>. Then tap 1-4 to judge it.')}`);
     showBypasses();
     console.log('');
     return;
   }
 
-  console.log(`  ${cream(String(stats.total))} ${sage('decisions')} ${slate('·')} ${cream(String(labeled))} ${sage('labeled')} ${slate('·')} ${cream(String(stats.pending))} ${sage('pending')}`);
-  if (labeled > 0) {
-    console.log(`  ${green(stats.kept + ' kept')} ${slate('·')} ${ember(stats.reverted + ' reverted')} ${slate('·')} ${peach(stats.superseded + ' superseded')} ${slate('·')} ${ember(stats.failed + ' failed')}`);
+  // The state of the record, in plain numbers that don't lie.
+  console.log('');
+  console.log(`  ${b(cream('Your record'))}`);
+  console.log(`    ${cream(String(stats.total))} ${sage('routed')} ${slate('·')} ${cream(String(stats.judged))} ${sage('you\'ve judged')} ${slate('·')} ${cream(String(stats.pending))} ${sage('not yet judged')}`);
+  if (stats.judged > 0) {
+    const bits = [green(`✓ ${stats.kept} kept`)];
+    if (stats.reverted) bits.push(ember(`↩ ${stats.reverted} reverted`));
+    if (stats.superseded) bits.push(peach(`⟳ ${stats.superseded} redone`));
+    if (stats.failed) bits.push(ember(`✗ ${stats.failed} flopped`));
+    console.log(`    ${bits.join(slate(' · '))}`);
   }
-
-  const routes = Object.entries(stats.byRoute);
-  if (routes.length > 0) {
-    console.log('');
-    console.log(`  ${b(cream('By route'))}`);
-    for (const [route, r] of routes.sort((a, b) => b[1].total - a[1].total)) {
-      const rate = r.total > 0 ? Math.round((r.kept / r.total) * 100) : 0;
-      console.log(`    ${cream(route.padEnd(14))} ${sage(`${r.total} labeled`)} ${slate('·')} ${green(`${rate}% kept`)}`);
-    }
+  if (stats.autoFailed > 0) {
+    console.log(`    ${slate(`(${stats.autoFailed} didn't complete — route errors phewsh logged for you, not your call)`)}`);
   }
 
-  const modes = Object.entries(stats.byMode);
-  if (modes.length > 0) {
-    console.log('');
-    console.log(`  ${b(cream('By mode'))}`);
-    for (const [mode, m] of modes.sort((a, b) => b[1].total - a[1].total)) {
-      const rate = m.total > 0 ? Math.round((m.kept / m.total) * 100) : 0;
-      console.log(`    ${cream(mode.padEnd(14))} ${sage(`${m.total} labeled`)} ${slate('·')} ${green(`${rate}% kept`)}`);
-    }
-  }
+  showPayoff(stats);
 
-  const recent = recentDecisions(8);
-  if (recent.length > 0) {
+  // The ask — focused on recent, real calls, with a dead-simple next step.
+  const pending = pendingDecisions({ substantive: true }).slice(-6).reverse();
+  if (pending.length > 0) {
     console.log('');
-    console.log(`  ${b(cream('Recent'))}`);
-    for (const d of recent) {
-      console.log(`    ${slate(d.id.padEnd(10))} ${outcomeBadge(d)} ${slate(fmtAgo(d.ts).padStart(3))} ${sage(d.summary.slice(0, 56))}`);
-    }
+    console.log(`  ${b(cream('Give a verdict'))} ${slate('— your recent calls (skip the trivial ones)')}`);
+    pending.forEach((d, i) => {
+      let s = (d.summary || '').replace(/\s+/g, ' ');
+      if (s.length > 44) s = s.slice(0, 43).trimEnd() + '…';
+      const via = (continuity.labelFor(d.route) || d.route).padEnd(12);
+      console.log(`    ${teal(String(i + 1))} ${cream(s.padEnd(45))} ${slate(via)} ${slate(fmtAgo(d.ts))}`);
+    });
+    console.log('');
+    console.log(`  ${teal('→')} ${sage('Walk through them:')} ${cream('phewsh outcomes label')} ${slate('· 20 seconds, Enter skips')}`);
+    console.log(`    ${slate('or in a session, just tap')} ${cream('1-4')} ${slate('right after any answer.')}`);
   }
 
   showBypasses();
-
-  if (stats.pending > 0) {
-    console.log('');
-    console.log(`  ${sage('Label pending decisions:')} ${cream('phewsh outcomes label')}`);
-  }
   console.log('');
 }
 
 function labelInteractive() {
-  const pending = pendingDecisions();
+  // Newest first, and capped — you judge best while the work is fresh, and a
+  // 76-item slog through last week's test prompts is exactly the chore that
+  // made this feel pointless. The recent calls carry the signal.
+  const CAP = 12;
+  const all = pendingDecisions({ substantive: true }).reverse(); // newest first
+  const pending = all.slice(0, CAP);
   if (pending.length === 0) {
-    console.log(`\n  ${teal('●')} ${sage('No pending decisions — everything is labeled.')}\n`);
+    console.log(`\n  ${teal('●')} ${sage('Nothing substantive to judge — your real calls are all labeled.')}\n`);
     return;
   }
 
   console.log('');
-  console.log(`  ${b(cream(`${pending.length} pending decision${pending.length !== 1 ? 's' : ''}`))}`);
-  console.log(`  ${slate('1 kept · 2 reverted · 3 superseded · 4 failed · enter = skip · q = quit')}`);
+  const more = all.length > CAP ? slate(` (most recent ${CAP}; ${all.length - CAP} older left alone)`) : '';
+  console.log(`  ${b(cream(`Judging your recent call${pending.length !== 1 ? 's' : ''}`))}${more}`);
+  console.log(`  ${slate('For each: what happened to it?')}`);
+  console.log(`  ${green('1')} ${sage('kept it')}   ${ember('2')} ${sage('undid it')}   ${peach('3')} ${sage('redid it differently')}   ${ember('4')} ${sage('it flopped')}`);
+  console.log(`  ${slate('Enter = skip (judge later) · q = stop. This is what teaches phewsh.')}`);
   ui.divider('line');
 
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

package/commands/session.js

@@ -21,6 +21,7 @@ const { HARNESSES, listHarnesses, runViaHarness, cancelActive } = require('../li
 const { recordDecision, labelOutcome, pendingDecisions, recentDecisions, outcomeStats, OUTCOMES } = require('../lib/outcomes');
 const { suggest, suggestAll } = require('../lib/suggest');
 const continuity = require('../lib/continuity');
+const selfheal = require('../lib/selfheal');
 const learning = require('../lib/learning');
 const recall = require('../lib/recall');
 const { closest } = require('../lib/closest');
@@ -335,6 +336,7 @@ async function main() {
   let sessionMode = null;          // INTENT_MODES id once picked
   let awaitingOutcome = null;      // decision id eligible for 1-4 labeling
   let awaitingWhy = null;          // { id, outcome } — next line is the reason
+  let awaitingWrap = null;         // { block } — y/N to fold shipped work into next.md
   let awaitingFallback = null;     // { input, fullSystem, options } after a route failure
   let bootstrapChoices = null;     // root-bootstrap menu entries when no project here
   let nextChoices = null;          // ranked /next suggestions awaiting a numeric pick
@@ -436,13 +438,16 @@ async function main() {
   }
 
   const oStats = outcomeStats();
-  const oLabeled = oStats.total - oStats.pending;
   if (oStats.total > 0) {
-    const keptRate = oLabeled > 0 ? Math.round((oStats.kept / oLabeled) * 100) + '% kept' : 'unlabeled';
-    row('RECORD', cream(`${oStats.total} decision${oStats.total !== 1 ? 's' : ''}`) + slate(' · ') + sage(keptRate)
-      + (oStats.pending > 0 ? slate(' · ') + peach(`${oStats.pending} awaiting outcome`) + slate(' — /outcomes') : ''));
+    // Plain language: what phewsh has logged vs what you've taught it. The
+    // kept-rate counts only the calls you actually judged (auto route-errors
+    // don't drag it down) — see /outcomes for the full picture + payoff.
+    const tail = oStats.judged > 0
+      ? slate(' · ') + sage(`${Math.round((oStats.kept / oStats.judged) * 100)}% of what you judged, you kept`)
+      : slate(' · ') + peach('none judged yet — tell it what you kept');
+    row('RECORD', cream(`${oStats.total} routed`) + tail + slate(' — /outcomes'));
   } else {
-    row('RECORD', slate('empty — decisions and outcomes accumulate as you work'));
+    row('RECORD', slate('empty — phewsh starts logging what you route as you work'));
   }
   } catch (cockpitErr) {
     console.log(`  ${slate('(cockpit row unavailable — ' + cockpitErr.message + ' · PHEWSH_DEBUG=1 phewsh for details)')}`);
@@ -487,7 +492,8 @@ async function main() {
     } catch { /* no settings = ambient off */ }
 
     let pending = 0;
-    try { pending = pendingDecisions({ project: projectName }).length; } catch { /* best-effort */ }
+    // Only substantive calls — never nag the user to "judge" a greeting.
+    try { pending = pendingDecisions({ project: projectName, substantive: true }).length; } catch { /* best-effort */ }
 
     let installed = [];
     try { installed = listHarnesses().filter(h => h.installed).map(h => h.id); } catch { /* best-effort */ }
@@ -507,10 +513,22 @@ async function main() {
       turnsThisSession: Math.floor(messages.length / 2),
       seqStale,
       ambientOn,
+      commitsSinceIntent: (() => { try { return selfheal.commitsSinceIntent(); } catch { return 0; } })(),
       bestKeeper,
     };
   }
 
+  // Self-healing continuity on entry: if .intent/ drifted ahead of CLAUDE.md
+  // since last time, quietly bring it current so every tool reading CLAUDE.md
+  // (this session included) sees today — the user never runs `seq -w` by hand.
+  function maybeHealOnEntry() {
+    try {
+      if (!selfheal.isStale()) return;
+      const h = selfheal.heal();
+      if (h.healed) console.log(`  ${teal('↻')} ${sage('Synced your .intent/ into CLAUDE.md — kept current automatically')}`);
+    } catch { /* self-heal is a nicety, never a blocker */ }
+  }
+
   // "Nothing lost" — surface where you left off, across every tool, so opening
   // phewsh feels like resuming a thread rather than starting cold.
   function showContinuity() {
@@ -547,6 +565,7 @@ async function main() {
     console.log('');
     console.log(`  ${teal('●')} ${cream(projectName)} ${slate('·')} ${sage(`.intent/ ${intentFiles.length} file${intentFiles.length !== 1 ? 's' : ''} loaded`)} ${slate('· via ' + routeLabel(route, config))}`);
     console.log('');
+    maybeHealOnEntry();
     showContinuity();
     showModeMenu();
     showInlineTip();
@@ -581,6 +600,7 @@ async function main() {
   } else if (intentFiles.length === 0 && (atHome || recents.length > 0)) {
     showBootstrapMenu(recents);
   } else {
+    maybeHealOnEntry();
     showContinuity();
     showModeMenu();
     showInlineTip();
@@ -628,7 +648,7 @@ async function main() {
       });
       lastTurnFailure = null;
       awaitingOutcome = decisionId;
-      console.log(slate(`  via ${HARNESSES[harnessId].label} · outcome? 1 kept · 2 reverted · 3 superseded · 4 failed · or keep typing`));
+      console.log(slate(`  via ${HARNESSES[harnessId].label} · how'd it go? 1 kept · 2 undid · 3 redid · 4 flopped · or keep typing`));
       return true;
     } catch (err) {
       turnInFlight = false;
@@ -637,7 +657,7 @@ async function main() {
         console.log(`\n  ${slate('cancelled — esc')}`);
         return true; // user's call, not a failure: no fallback offer
       }
-      try { labelOutcome(decisionId, 'failed'); } catch { /* keep going */ }
+      try { labelOutcome(decisionId, 'failed', null, { auto: true }); } catch { /* keep going */ }
       recordSessionEvent(harnessId, projectName, 'task_complete', {
         taskId: decisionId, success: false, summary: input.slice(0, 140),
       });
@@ -668,7 +688,7 @@ async function main() {
       if (result.promptTokens) totalPromptTokens += result.promptTokens;
       if (result.completionTokens) totalCompletionTokens += result.completionTokens;
       if (result.promptTokens || result.completionTokens) {
-        console.log(slate(`  ${result.promptTokens || '?'}→${result.completionTokens || '?'} tokens · ${modelName(currentModel)} · outcome? 1-4 or keep typing`));
+        console.log(slate(`  ${result.promptTokens || '?'}→${result.completionTokens || '?'} tokens · ${modelName(currentModel)} · how'd it go? 1-4 or keep typing`));
       }
       awaitingOutcome = decisionId;
       trackSap({
@@ -689,7 +709,7 @@ async function main() {
         console.log(`\n  ${slate('cancelled — esc')}`);
         return true; // user's call, not a failure: no fallback offer
       }
-      try { labelOutcome(decisionId, 'failed'); } catch { /* keep going */ }
+      try { labelOutcome(decisionId, 'failed', null, { auto: true }); } catch { /* keep going */ }
       messages.pop();
       console.error(`\n  ${ember('!')} ${sage('API route failed')}${slate(' — ' + err.message.split('\n')[0])}`);
       return false;
@@ -974,6 +994,25 @@ async function main() {
       return;
     }
 
+    // /wrap confirmation: y folds the shipped-work block into next.md + heals.
+    if (awaitingWrap) {
+      const { block } = awaitingWrap;
+      awaitingWrap = null;
+      if (/^(y|yes)$/i.test(input.trim())) {
+        const r = selfheal.appendToNext(block);
+        if (r.written) {
+          console.log(`  ${green('✓')} ${sage('Folded into .intent/' + r.file + ' — CLAUDE.md synced too. The record matches the work now.')}`);
+        } else {
+          console.log(`  ${ember('!')} ${sage('Could not write .intent/next.md — left it untouched.')}`);
+        }
+      } else {
+        console.log(`  ${slate('Left .intent/ as-is.')}`);
+      }
+      console.log('');
+      rl.prompt();
+      return;
+    }
+
     // Any typed input supersedes a pending "did you mean" offer.
     if (pendingDidYouMean) pendingDidYouMean = null;
 
@@ -1149,6 +1188,13 @@ async function main() {
         if (global._phewshChildren) {
           global._phewshChildren.forEach(c => { try { c.kill(); } catch {} });
         }
+        // Self-healing continuity: leave the next tool a current CLAUDE.md so
+        // opening Claude Code / Codex here next reads today's intent — without
+        // anyone remembering to run `seq -w`.
+        try {
+          const h = selfheal.heal();
+          if (h.healed) console.log(`  ${teal('↻')} ${sage("CLAUDE.md refreshed from .intent/ — you didn't have to")}`);
+        } catch { /* self-heal must never block exit */ }
         try { require('../lib/intro').farewell(); } catch { /* sign-off is a nicety */ }
         console.log(`  ${sage('session ended · ' + turns + ' exchanges · ' + (totalPromptTokens + totalCompletionTokens) + ' tokens')}`);
         if (decisionsThisSession > 0) {
@@ -1221,6 +1267,37 @@ async function main() {
         return;
       }
 
+      // ── /wrap ──────────────────────────────────────────
+      // Fold what you've shipped (git commits since .intent/ was last updated)
+      // back into next.md, then re-sync CLAUDE.md — so the record reflects the
+      // work, not last week. Deterministic from commit subjects; no LLM needed,
+      // so it works even with nothing connected. This is the cure for the drift
+      // that ate phewsh's own dogfood.
+      if (cmd === 'wrap') {
+        const draft = selfheal.wrapDraft();
+        console.log('');
+        if (!draft) {
+          console.log(`  ${teal('●')} ${sage('Nothing to fold in — your .intent/ is already current with git (or this isn\'t a repo).')}`);
+          console.log('');
+          rl.prompt();
+          return;
+        }
+        const n = draft.commits.length;
+        console.log(`  ${b(cream('Wrap'))} ${slate('— ' + n + ' commit' + (n !== 1 ? 's' : '') + ' shipped since .intent/ was last updated')}`);
+        ui.divider('line');
+        for (const s of draft.commits.slice(0, 12)) {
+          let line = s.replace(/\s+/g, ' ');
+          if (line.length > 70) line = line.slice(0, 69).trimEnd() + '…';
+          console.log(`    ${sage('+')} ${cream(line)}`);
+        }
+        if (n > 12) console.log(`    ${slate('… and ' + (n - 12) + ' more')}`);
+        ui.divider('line');
+        console.log(`  ${sage('Fold this into')} ${cream('.intent/next.md')} ${sage('and re-sync CLAUDE.md?')} ${slate('y/N')}`);
+        awaitingWrap = { block: draft.block };
+        rl.prompt();
+        return;
+      }
+
       // ── /learn ─────────────────────────────────────────
       // What the record has learned — kept-rates by tool and by mode, so the
       // 100th decision is better-informed than the 1st. Honest: stays quiet
@@ -1295,6 +1372,7 @@ async function main() {
         console.log(`  ${cream('author .intent/')}`);
         console.log(`    ${teal('/init')}        ${sage('Create .intent/ for this project')}`);
         console.log(`    ${teal('/intent')}      ${sage('Pause and reflect — view or update .intent/ before moving on')}`);
+        console.log(`    ${teal('/wrap')}        ${sage('Fold what you shipped (git) into .intent/ — keeps the record current')}`);
         console.log(`    ${teal('/clarify')}     ${sage('Turn ideas into .intent/ artifacts')}`);
         console.log(`    ${teal('/gate')}        ${sage('Set constraints (budget, time, skill)')}`);
         console.log(`    ${teal('/context')}     ${sage('Show loaded .intent/ files')}`);
@@ -1317,7 +1395,7 @@ async function main() {
         console.log(`    ${teal('/harnesses')}   ${sage('Agent CLIs detected on this machine')}`);
         console.log(`    ${teal('/provider')}    ${sage('Current route + what\'s available')}`);
         console.log(`    ${teal('/fallback')}    ${sage('What happens at a usage wall: ask or auto-switch')}`);
-        console.log(`    ${teal('/outcomes')}    ${sage('Decision record — kept/reverted/superseded/failed')}`);
+        console.log(`    ${teal('/outcomes')}    ${sage('What worked — tell phewsh, and it learns which tool to trust')}`);
         console.log('');
         console.log(`  ${cream('session')}`);
         console.log(`    ${teal('/work')} ${slate('[harness]')} ${sage('Hand off to interactive Claude Code/Codex — outcome on return')}`);
@@ -1946,9 +2024,9 @@ async function main() {
           messages.push({ role: 'user', content: cmdArg });
           messages.push({ role: 'assistant', content: `[council of ${answers.length}]\n\n${answers.join('\n\n')}` });
           awaitingOutcome = decisionId;
-          console.log(slate(`  council of ${answers.length} · outcome? 1 kept · 2 reverted · 3 superseded · 4 failed · or keep typing`));
+          console.log(slate(`  council of ${answers.length} · how'd it go? 1 kept · 2 undid · 3 redid · 4 flopped · or keep typing`));
         } else {
-          try { labelOutcome(decisionId, 'failed'); } catch { /* keep going */ }
+          try { labelOutcome(decisionId, 'failed', null, { auto: true }); } catch { /* keep going */ }
           console.log(`  ${sage('Every council member failed — check')} ${cream('/provider')}`);
         }
         console.log('');
@@ -2193,7 +2271,7 @@ async function main() {
         });
         awaitingOutcome = decisionId;
         console.log('');
-        console.log(`  ${teal('●')} ${sage('Back in phewsh.')} ${slate('outcome? 1 kept · 2 reverted · 3 superseded · 4 failed · or keep typing')}`);
+        console.log(`  ${teal('●')} ${sage('Back in phewsh.')} ${slate("how'd it go? 1 kept · 2 undid · 3 redid · 4 flopped · or keep typing")}`);
         console.log('');
         rl.prompt();
         return;

package/lib/outcomes.js

@@ -50,8 +50,18 @@ function recordDecision({ project, route, mode, summary }) {
   return id;
 }
 
-/** Label a decision by id (or unambiguous id prefix). Returns the decision or null. */
-function labelOutcome(idOrPrefix, outcome, why = null) {
+/**
+ * Label a decision by id (or unambiguous id prefix). Returns the decision or null.
+ * @param {string} idOrPrefix
+ * @param {string} outcome  one of OUTCOMES
+ * @param {string|null} why one-line reason (gold for reverted/failed)
+ * @param {object} [opts]
+ * @param {boolean} [opts.auto]  the SYSTEM set this (e.g. a route errored), not
+ *   the user's judgment. Kept separate so auto-failures never masquerade as
+ *   "you tried it and reverted it" — that distinction is what made the old
+ *   `/outcomes` read like phewsh was broken.
+ */
+function labelOutcome(idOrPrefix, outcome, why = null, opts = {}) {
   if (!OUTCOMES.includes(outcome)) {
     throw new Error(`Outcome must be one of: ${OUTCOMES.join(', ')}`);
   }
@@ -60,6 +70,8 @@ function labelOutcome(idOrPrefix, outcome, why = null) {
   if (matches.length !== 1) return null;
   matches[0].outcome = outcome;
   matches[0].labeledAt = new Date().toISOString();
+  if (opts.auto) matches[0].auto = true;
+  else delete matches[0].auto; // a human judgment overrides a prior auto-label
   // One-line reason — the most valuable thing about a reverted/failed call.
   // Feeds /recall ("you reverted this before — because …") and /learn.
   if (why && String(why).trim()) matches[0].why = String(why).trim().slice(0, 200);
@@ -67,10 +79,24 @@ function labelOutcome(idOrPrefix, outcome, why = null) {
   return matches[0];
 }
 
-/** Unlabeled decisions, oldest first. */
-function pendingDecisions({ project = null } = {}) {
+// A routed line that isn't really a decision worth judging — greetings, one
+// word fillers, or a command echo. Used to keep the "judge these" ask (and the
+// nudge to label) focused on real work, not "hi". Conservative on purpose: only
+// obvious noise, so genuine short prompts ("fix the bug") still count.
+const TRIVIAL_RE = /^(hi|hey|hello|yo|sup|ok|okay|k|thanks|thx|ty|test|testing|cool|nice|great|good|yes|no|y|n|hi there)\b[!.\s]*$/i;
+function looksTrivial(summary) {
+  const s = (summary || '').trim();
+  if (s.length < 3) return true;
+  if (TRIVIAL_RE.test(s)) return true;
+  if (/^(phewsh|\/)/.test(s) && s.split(/\s+/).length <= 3) return true; // command echo
+  return false;
+}
+
+/** Unlabeled decisions, oldest first. `substantive` drops greetings/filler. */
+function pendingDecisions({ project = null, substantive = false } = {}) {
   return load()
     .filter(d => !d.outcome && (!project || d.project === project))
+    .filter(d => !substantive || !looksTrivial(d.summary))
     .sort((a, b) => a.ts.localeCompare(b.ts));
 }
 
@@ -82,31 +108,73 @@ function recentDecisions(limit = 10, { project = null } = {}) {
     .slice(0, limit);
 }
 
+const MIGRATE_MARKER = path.join(OUTCOMES_DIR, '.auto-migrated-v1');
+
+/**
+ * One-time cleanup of records created before the `auto` flag existed. The only
+ * code path that ever wrote 'failed' with no reason was the turn runner
+ * reacting to a route error — a genuine human "this failed" verdict is always
+ * offered a one-line why. So legacy failed-without-why = a route error; tag it
+ * so it stops masquerading as the user's judgment. Idempotent (marker-guarded).
+ */
+function migrateLegacyAutoFailures() {
+  try {
+    if (fs.existsSync(MIGRATE_MARKER)) return;
+    const decisions = load();
+    let changed = false;
+    for (const d of decisions) {
+      if (d.outcome === 'failed' && !d.auto && !d.why) { d.auto = true; changed = true; }
+    }
+    if (changed) save(decisions);
+    fs.mkdirSync(OUTCOMES_DIR, { recursive: true });
+    fs.writeFileSync(MIGRATE_MARKER, new Date().toISOString());
+  } catch { /* migration is best-effort — never block the record */ }
+}
+
+/** Was this outcome set by the SYSTEM (a route errored) rather than the human? */
+function isAutoLabel(d) {
+  return d.auto === true;
+}
+
 /**
  * The Day-14 view: totals, per-route reliability, per-mode patterns.
  * Only labeled decisions count toward outcome rates — pending is honest noise.
  */
 function outcomeStats({ project = null } = {}) {
+  migrateLegacyAutoFailures();
   const all = load().filter(d => !project || d.project === project);
   const labeled = all.filter(d => d.outcome);
+  // A route that errored is auto-labeled 'failed' — that's a system event, not
+  // the user judging the work. Split it out so the headline reflects the user's
+  // actual calls (kept/reverted/superseded + failures they themselves marked).
+  const judged = labeled.filter(d => !isAutoLabel(d));
+  const autoFailed = labeled.filter(isAutoLabel).length;
 
   const stats = {
     total: all.length,
     pending: all.length - labeled.length,
+    judged: judged.length,        // decisions the human actually labeled
+    autoFailed,                   // route errors phewsh recorded for you
     kept: 0, reverted: 0, superseded: 0, failed: 0,
     byRoute: {},
     byMode: {},
   };
 
-  for (const d of labeled) {
+  // Outcome rates count the human's judgments only — auto route-errors don't
+  // tank a tool's kept-rate (they're tracked separately in byRoute.errored).
+  for (const d of judged) {
     stats[d.outcome]++;
-    const r = (stats.byRoute[d.route] ||= { total: 0, kept: 0, reverted: 0, superseded: 0, failed: 0 });
+    const r = (stats.byRoute[d.route] ||= { total: 0, kept: 0, reverted: 0, superseded: 0, failed: 0, errored: 0 });
     r.total++; r[d.outcome]++;
     if (d.mode) {
-      const m = (stats.byMode[d.mode] ||= { total: 0, kept: 0, reverted: 0, superseded: 0, failed: 0 });
+      const m = (stats.byMode[d.mode] ||= { total: 0, kept: 0, reverted: 0, superseded: 0, failed: 0, errored: 0 });
       m.total++; m[d.outcome]++;
     }
   }
+  for (const d of labeled.filter(isAutoLabel)) {
+    const r = (stats.byRoute[d.route] ||= { total: 0, kept: 0, reverted: 0, superseded: 0, failed: 0, errored: 0 });
+    r.errored = (r.errored || 0) + 1;
+  }
 
   return stats;
 }
@@ -165,5 +233,5 @@ function bypassStats() {
 module.exports = {
   OUTCOMES, DECISIONS_FILE, BYPASS_REASONS, BYPASSES_FILE,
   recordDecision, labelOutcome, pendingDecisions, recentDecisions, outcomeStats,
-  recordBypass, bypassStats,
+  isAutoLabel, looksTrivial, recordBypass, bypassStats,
 };

package/lib/selfheal.js

@@ -0,0 +1,152 @@
+// Self-healing continuity — phewsh keeps CLAUDE.md current from .intent/ so the
+// user never has to run `seq -w` by hand. This is the deterministic half of the
+// trust promise: every time phewsh runs (and when an ambient session ends), if
+// .intent/ has drifted ahead of CLAUDE.md, we re-sequence it silently.
+//
+// Pure-ish and safe: never throws, never blocks the host. Returns a small
+// result the caller can render ("✓ kept your CLAUDE.md current — you didn't
+// have to"). The LLM-assisted half (drafting next.md/status.md from a session)
+// lives elsewhere; this layer needs no model and works fully offline.
+
+const fs = require('fs');
+const path = require('path');
+
+const INTENT_FILES_RE = /\.(md|json)$/;
+
+// Newest mtime among .intent/ artifacts, or 0 if none / unreadable.
+function newestIntentMs(intentDir) {
+  try {
+    return fs.readdirSync(intentDir)
+      .filter(f => INTENT_FILES_RE.test(f))
+      .reduce((m, f) => {
+        try { return Math.max(m, fs.statSync(path.join(intentDir, f)).mtimeMs); }
+        catch { return m; }
+      }, 0);
+  } catch { return 0; }
+}
+
+/**
+ * Has .intent/ drifted ahead of CLAUDE.md's synced block?
+ * Returns false when there's no .intent/ or no CLAUDE.md (nothing to heal).
+ * @param {string} [cwd]
+ */
+function isStale(cwd = process.cwd()) {
+  try {
+    const claudePath = path.join(cwd, 'CLAUDE.md');
+    const intentDir = path.join(cwd, '.intent');
+    if (!fs.existsSync(claudePath) || !fs.existsSync(intentDir)) return false;
+    const claudeT = fs.statSync(claudePath).mtimeMs;
+    const newest = newestIntentMs(intentDir);
+    return newest > claudeT + 1000; // >1s newer = real drift, not a co-write race
+  } catch { return false; }
+}
+
+/**
+ * Re-sequence .intent/ → CLAUDE.md if (and only if) it has drifted. Uses the
+ * exact same path as `phewsh seq claude -w`, so the auto-heal and the manual
+ * command can never diverge.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]
+ * @param {boolean} [opts.force]  resync even if not detected stale
+ * @returns {{ healed: boolean, writeResult?: string, chunks?: number, sources?: number, reason?: string }}
+ */
+function heal({ cwd = process.cwd(), force = false } = {}) {
+  try {
+    if (!force && !isStale(cwd)) return { healed: false, reason: 'fresh' };
+    // Require lazily — the sequencer pulls in parsers/emitters we don't want to
+    // load on every bare command.
+    const { sequence } = require('./sequencer');
+    const prev = process.cwd();
+    let result;
+    try {
+      if (cwd !== prev) process.chdir(cwd);
+      result = sequence({ target: 'claude-md', write: true });
+    } finally {
+      if (cwd !== prev) { try { process.chdir(prev); } catch { /* best-effort */ } }
+    }
+    return {
+      healed: result.writeResult === 'updated' || result.writeResult === 'created',
+      writeResult: result.writeResult,
+      chunks: Array.isArray(result.chunks) ? result.chunks.length : undefined,
+      sources: Array.isArray(result.sources) ? result.sources.length : undefined,
+    };
+  } catch (err) {
+    return { healed: false, reason: err && err.message ? err.message : 'error' };
+  }
+}
+
+// The deeper drift: code ships but .intent/ content never gets updated (the
+// exact failure that ate phewsh's own dogfood — 16 versions shipped while
+// next.md stayed days stale). Count git commits authored AFTER the newest
+// .intent/ narrative file, so phewsh can notice "you've shipped but your intent
+// is behind" and offer to fold it in. Best-effort: 0 if not a git repo / no git.
+const NARRATIVE_FILES = ['vision.md', 'plan.md', 'status.md', 'next.md', 'narrative.md'];
+
+function newestNarrativeMs(intentDir) {
+  return NARRATIVE_FILES.reduce((m, f) => {
+    try { return Math.max(m, fs.statSync(path.join(intentDir, f)).mtimeMs); }
+    catch { return m; }
+  }, 0);
+}
+
+function commitsSinceIntent(cwd = process.cwd()) {
+  try {
+    const intentDir = path.join(cwd, '.intent');
+    if (!fs.existsSync(intentDir)) return 0;
+    const since = newestNarrativeMs(intentDir);
+    if (!since) return 0;
+    const { execFileSync } = require('child_process');
+    const iso = new Date(since).toISOString();
+    // execFile (no shell) with args as an array — the date is machine-generated,
+    // and array args mean there's no shell to inject into regardless.
+    const out = execFileSync('git', ['log', `--since=${iso}`, '--oneline'], {
+      cwd, encoding: 'utf-8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out.split('\n').filter(l => l.trim()).length;
+  } catch { return 0; }
+}
+
+// Build a "what shipped since .intent/ was last updated" draft block straight
+// from git commit subjects — deterministic, no LLM. This is the offline floor
+// of `/wrap`: even with nothing connected, phewsh can fold real work into the
+// record. (An LLM pass can later prose-ify this; the commits are the truth.)
+function wrapDraft(cwd = process.cwd()) {
+  try {
+    const intentDir = path.join(cwd, '.intent');
+    if (!fs.existsSync(intentDir)) return null;
+    const since = newestNarrativeMs(intentDir);
+    if (!since) return null;
+    const { execFileSync } = require('child_process');
+    const iso = new Date(since).toISOString();
+    const raw = execFileSync('git', ['log', `--since=${iso}`, '--pretty=format:%s'], {
+      cwd, encoding: 'utf-8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const commits = raw.split('\n')
+      .map(l => l.trim())
+      .filter(Boolean)
+      .filter(s => !/^Merge (branch|pull|remote)/i.test(s)); // drop merge noise
+    if (commits.length === 0) return null;
+    const date = new Date().toISOString().slice(0, 10);
+    const block = `\n## ✅ Shipped since last update (folded in ${date})\n`
+      + commits.map(s => `- ${s}`).join('\n') + '\n';
+    return { commits, block, date };
+  } catch { return null; }
+}
+
+// Append a block to a .intent/ narrative file (default next.md), then heal so
+// CLAUDE.md reflects it immediately. Returns { written: boolean, file }.
+function appendToNext(block, { cwd = process.cwd(), file = 'next.md' } = {}) {
+  try {
+    const target = path.join(cwd, '.intent', file);
+    if (!fs.existsSync(target)) return { written: false, file };
+    fs.appendFileSync(target, block.endsWith('\n') ? block : block + '\n');
+    heal({ cwd, force: true });
+    return { written: true, file };
+  } catch { return { written: false, file }; }
+}
+
+module.exports = {
+  isStale, heal, newestIntentMs, newestNarrativeMs,
+  commitsSinceIntent, wrapDraft, appendToNext,
+};

package/lib/suggest.js

@@ -38,6 +38,7 @@ function suggestAll(s = {}) {
     turnsThisSession = 0,
     seqStale = false,
     ambientOn = false,
+    commitsSinceIntent = 0,
     bestKeeper = null,   // { route, label, keptRate, total } from the record, or null
   } = s;
 
@@ -55,12 +56,14 @@ function suggestAll(s = {}) {
     });
   }
 
-  // 2. Decisions piling up unlabeled — the record only gets smarter if labeled.
+  // 2. Some real calls judged, others not — a verdict or two is what teaches
+  //    phewsh which tool to trust. Payoff-framed, no scary backlog number (the
+  //    big count read as a chore, not a payoff).
   if (pendingOutcomes >= 3) {
     out.push({
       id: 'label-outcomes',
       priority: 90,
-      message: `${pendingOutcomes} decisions unlabeled — phewsh can't learn what you keep until you say.`,
+      message: `Tell phewsh what worked — a quick verdict teaches it which tool to trust for you.`,
       command: '/outcomes',
       why: 'Labeling kept/reverted is the dataset; it weights future routing and recall.',
     });
@@ -77,6 +80,19 @@ function suggestAll(s = {}) {
     });
   }
 
+  // 3b. Code shipped but .intent/ never caught up — the deeper drift that ate
+  //     phewsh's own dogfood (versions shipped while next.md stayed stale).
+  //     CLAUDE.md self-heals, but the *intent* itself is behind the work.
+  if (hasIntentDir && commitsSinceIntent >= 3) {
+    out.push({
+      id: 'intent-behind-code',
+      priority: 85,
+      message: `${commitsSinceIntent} commits since your .intent/ was updated — the record is behind the work.`,
+      command: '/wrap',
+      why: 'Folds what you shipped into next.md/status.md so continuity reflects reality, not last week.',
+    });
+  }
+
   // 4. Multiple harnesses installed, only leaning on one — council is free leverage.
   const others = installedHarnesses.filter(h => h !== route);
   if (installedHarnesses.length >= 2 && turnsThisSession >= 3 && others.length >= 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phewsh",
-  "version": "0.15.27",
+  "version": "0.15.29",
   "description": "Turn intent into action. Structure your thinking, execute your next step.",
   "bin": {
     "phewsh": "bin/phewsh.js"