phewsh 0.15.26 → 0.15.28

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/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
@@ -492,18 +494,37 @@ async function main() {
     let installed = [];
     try { installed = listHarnesses().filter(h => h.installed).map(h => h.id); } catch { /* best-effort */ }
 
+    let bestKeeper = null;
+    try {
+      const br = learning.bestRoute(outcomeStats({ project: projectName }), { minSample: 4 });
+      if (br) bestKeeper = { route: br.route, label: continuity.labelFor(br.route), keptRate: br.keptRate, total: br.total };
+    } catch { /* best-effort */ }
+
     return {
       hasIntentDir: fs.existsSync(path.join(process.cwd(), '.intent')),
       intentFileCount: intentFiles.length,
       pendingOutcomes: pending,
       installedHarnesses: installed,
-      route,
+      route: route?.id || route,
       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() {
@@ -540,6 +561,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();
@@ -574,6 +596,7 @@ async function main() {
   } else if (intentFiles.length === 0 && (atHome || recents.length > 0)) {
     showBootstrapMenu(recents);
   } else {
+    maybeHealOnEntry();
     showContinuity();
     showModeMenu();
     showInlineTip();
@@ -967,6 +990,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;
 
@@ -1094,10 +1136,23 @@ async function main() {
       if (n === 5) {
         console.log('');
         console.log(`  ${b(cream('Ask another model — switch the route'))}`);
+        let mStats = null, best = null;
+        try {
+          mStats = outcomeStats({ project: projectName });
+          best = learning.bestRoute(mStats, { minSample: 3 });
+        } catch { /* best-effort */ }
+        // Only celebrate a route that actually holds up (≥50% kept) — a star on
+        // a poor rate would be dishonest. The badge shows regardless.
+        const starRoute = best && best.keptRate >= 0.5 ? best.route : null;
         for (const h of harnesses) {
-          if (h.installed) console.log(`    ${teal('/use ' + h.id.padEnd(12))} ${sage(h.label)} ${slate('(' + h.auth + ')')}`);
+          if (!h.installed) continue;
+          const badge = mStats ? learning.keptBadge(mStats, h.id) : '';
+          const star = starRoute === h.id ? ` ${green('★ keeps best')}` : '';
+          const rec = badge ? ` ${slate('· ' + badge)}` : '';
+          console.log(`    ${teal('/use ' + h.id.padEnd(12))} ${sage(h.label)} ${slate('(' + h.auth + ')')}${rec}${star}`);
         }
         if (config?.apiKey) console.log(`    ${teal('/use api'.padEnd(17))} ${sage('Direct API')} ${slate('(your key)')}`);
+        if (starRoute) console.log(`  ${slate('★ = highest kept-rate in your record so far')}`);
         console.log('');
         rl.prompt();
         return;
@@ -1129,6 +1184,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) {
@@ -1201,6 +1263,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
@@ -1275,6 +1368,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')}`);

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,8 @@ function suggestAll(s = {}) {
     turnsThisSession = 0,
     seqStale = false,
     ambientOn = false,
+    commitsSinceIntent = 0,
+    bestKeeper = null,   // { route, label, keptRate, total } from the record, or null
   } = s;
 
   const out = [];
@@ -76,6 +78,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) {
@@ -88,6 +103,18 @@ function suggestAll(s = {}) {
     });
   }
 
+  // 4b. The record has a clear favorite that isn't your current route —
+  //     auto-weighting: lean on what actually holds for you.
+  if (bestKeeper && bestKeeper.route !== route && bestKeeper.total >= 4 && bestKeeper.keptRate >= 0.6) {
+    out.push({
+      id: 'prefer-best-route',
+      priority: 55,
+      message: `${bestKeeper.label || bestKeeper.route} keeps best in your record (${Math.round(bestKeeper.keptRate * 100)}%, ${bestKeeper.total} labeled).`,
+      command: `/use ${bestKeeper.route}`,
+      why: 'The record weights routing — lean on the tool whose work you actually keep.',
+    });
+  }
+
   // 5. Ambient off — continuity that costs nothing once turned on.
   if (hasIntentDir && !ambientOn && installedHarnesses.includes('claude-code')) {
     out.push({

package/package.json

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