phewsh 0.15.12 → 0.15.15

package/commands/hook.js

@@ -12,10 +12,27 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+const continuity = require('../lib/continuity');
+
 const PHEWSH_DIR = path.join(os.homedir(), '.phewsh');
 const AMBIENT_LOG = path.join(PHEWSH_DIR, 'ambient-sessions.jsonl');
+const DECISIONS_FILE = path.join(PHEWSH_DIR, 'outcomes', 'decisions.json');
 const INTENT_DIR = path.join(process.cwd(), '.intent');
 
+// "Where you left off, across every tool" — drawn from phewsh's own decision
+// record (not the host transcript). This is what makes opening Claude Code
+// standalone feel like resuming: it sees the thread Codex (or phewsh) left.
+function continuityBrief(project) {
+  try {
+    const decisions = JSON.parse(fs.readFileSync(DECISIONS_FILE, 'utf-8'));
+    const line = continuity.continuityLine(decisions, { project });
+    if (!line) return null;
+    const tools = continuity.toolsInThread(decisions, { project });
+    const span = tools >= 2 ? ` (${tools} tools, one thread)` : '';
+    return `Continuity${span}: you were ${line}. Nothing's lost — continue it.`;
+  } catch { return null; }
+}
+
 function readIfExists(p, maxBytes = 16384) {
   try { return fs.readFileSync(p, 'utf-8').slice(0, maxBytes); } catch { return null; }
 }
@@ -89,6 +106,11 @@ function sessionStart() {
   const status = readIfExists(path.join(INTENT_DIR, 'status.md'));
   if (status) parts.push(`\n## Status (excerpt)\n${firstLines(status, 5)}`);
 
+  // Decisions are tagged with the cwd basename (how recordDecision keys them),
+  // not the project.json display name — match on that so the thread connects.
+  const cont = continuityBrief(path.basename(process.cwd()));
+  if (cont) parts.push(`\n## Continuity (across your tools)\n${cont}`);
+
   parts.push(`\n(Brief injected by PHEWSH ambient from .intent/. Honor the constraints above. The human can run \`phewsh\` for mission control — council, outcomes, the decision record.)`);
 
   process.stdout.write(parts.join('\n') + '\n');

package/commands/session.js

@@ -18,8 +18,11 @@ const { select, refreshSession: refreshSess } = require('../lib/supabase');
 const { readPPS } = require('../lib/pps');
 const { push, pull, ensureValidToken } = require('./sync');
 const { HARNESSES, listHarnesses, runViaHarness, cancelActive } = require('../lib/harnesses');
-const { recordDecision, labelOutcome, pendingDecisions, outcomeStats, OUTCOMES } = require('../lib/outcomes');
+const { recordDecision, labelOutcome, pendingDecisions, recentDecisions, outcomeStats, OUTCOMES } = require('../lib/outcomes');
 const { suggest, suggestAll } = require('../lib/suggest');
+const continuity = require('../lib/continuity');
+const { closest } = require('../lib/closest');
+const cmdHistory = require('../lib/history');
 const { recordSessionEvent } = require('../lib/receipts-data');
 const configFile = require('../lib/config-file');
 const { createFailureTracker, createLineDispatcher } = require('../lib/session-input');
@@ -332,6 +335,7 @@ async function main() {
   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
+  let pendingDidYouMean = null;    // a suggested command; bare Enter accepts + runs it
   let decisionsThisSession = 0;
 
   // ── The Exhale: animated brand reveal ──────────────────
@@ -497,6 +501,19 @@ async function main() {
     };
   }
 
+  // "Nothing lost" — surface where you left off, across every tool, so opening
+  // phewsh feels like resuming a thread rather than starting cold.
+  function showContinuity() {
+    try {
+      const decisions = recentDecisions(50, { project: projectName });
+      const line = continuity.continuityLine(decisions, { project: projectName });
+      if (!line) return;
+      const tools = continuity.toolsInThread(decisions, { project: projectName });
+      const span = tools >= 2 ? slate(` · ${tools} tools, one thread`) : '';
+      console.log(`  ${teal('↻')} ${sage('Picking up — ' + line)}${span} ${slate('· /thread')}`);
+    } catch { /* continuity is a nicety, never a blocker */ }
+  }
+
   // One subtle line under the menu — the single highest-leverage nudge, if any.
   function showInlineTip() {
     let tip = null;
@@ -520,6 +537,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('');
+    showContinuity();
     showModeMenu();
     showInlineTip();
     console.log('');
@@ -553,6 +571,7 @@ async function main() {
   } else if (intentFiles.length === 0 && (atHome || recents.length > 0)) {
     showBootstrapMenu(recents);
   } else {
+    showContinuity();
     showModeMenu();
     showInlineTip();
   }
@@ -700,6 +719,7 @@ async function main() {
     output: process.stdout,
     prompt: `  ${teal('phewsh')} ${sage('>')} `,
     historySize: 100,
+    history: cmdHistory.loadForReadline(100),  // up-arrow remembers across sessions
   });
   const promptText = `  phewsh > `;
   let lastPaste = null;
@@ -750,7 +770,7 @@ async function main() {
     'clear', 'status', 'key', 'login', 'export', 'push', 'pull', 'serve',
     'sync', 'harnesses', 'fallback', 'outcomes', 'tour', 'update', 'upgrade',
     'agents', 'context', 'gate', 'reload', 'sequence', 'seq', 'setup', 'system', 'watch',
-    'next', 'recommend', 'guide',
+    'next', 'recommend', 'guide', 'thread', 'continuity',
   ]);
   const installedIds = harnesses.filter(h => h.installed).map(h => h.id);
   let turnAbort = null;       // AbortController while an API turn streams
@@ -914,6 +934,9 @@ async function main() {
   async function handleInput(input) {
     input = expandPastes(input);
 
+    // Any typed input supersedes a pending "did you mean" offer.
+    if (pendingDidYouMean) pendingDidYouMean = null;
+
     // A bare number right after a route failure picks the fallback
     if (awaitingFallback) {
       const af = awaitingFallback;
@@ -1101,12 +1124,69 @@ async function main() {
         return;
       }
 
+      // ── /thread ────────────────────────────────────────
+      // The cross-tool thread: one continuous record of your work, whichever
+      // tool ran each step. The "nothing lost" proof, made visible.
+      if (cmd === 'thread' || cmd === 'continuity') {
+        const decisions = recentDecisions(50, { project: projectName });
+        const thread = continuity.threadFor(decisions, { project: projectName });
+        console.log('');
+        if (thread.length === 0) {
+          console.log(`  ${teal('●')} ${sage('No thread yet for')} ${cream(projectName)}${sage('.')} ${slate('Do something — every action joins the thread, whichever tool runs it.')}`);
+          console.log('');
+          rl.prompt();
+          return;
+        }
+        const tools = continuity.toolsInThread(decisions, { project: projectName });
+        console.log(`  ${b(cream('Your thread'))} ${slate('— ' + projectName + ' · phewsh remembers across every tool')}`);
+        ui.divider('line');
+        for (const d of thread.slice(0, 12)) {
+          const ago = continuity.agoText(d.ts).padEnd(9);
+          const via = continuity.labelFor(d.route).padEnd(13);
+          const oc = d.outcome
+            ? (d.outcome === 'kept' ? green('kept') : d.outcome === 'superseded' ? peach(d.outcome) : ember(d.outcome))
+            : slate('open');
+          let s = (d.summary || '').replace(/\s+/g, ' ');
+          if (s.length > 46) s = s.slice(0, 45).trimEnd() + '…';
+          console.log(`    ${slate(ago)} ${sage(via)} ${cream(s || '—')}  ${oc}`);
+        }
+        ui.divider('line');
+        const span = tools >= 2 ? `${tools} tools, one thread` : `${tools} tool`;
+        console.log(`  ${sage(thread.length + ' action' + (thread.length !== 1 ? 's' : '') + ' · ' + span + ' · nothing re-explained')}`);
+        console.log('');
+        rl.prompt();
+        return;
+      }
+
       if (cmd === 'help' || cmd === 'h') {
+        const wantsAll = /^(all|more|full|everything)$/i.test(cmdArg.trim());
+
+        // Bare /help → the short essentials a newcomer actually needs.
+        if (!wantsAll) {
+          console.log('');
+          console.log(`  ${sage('the loop: define .intent/ → sync → work → evolve → repeat')}`);
+          console.log('');
+          console.log(`  ${cream('the essentials')}`);
+          console.log(`    ${teal('just type')}      ${sage('chat — your .intent/ context travels with every route')}`);
+          console.log(`    ${teal('/next')}          ${sage('not sure? phewsh names the next step worth taking')}`);
+          console.log(`    ${teal('/use')} ${slate('<tool>')}   ${sage('route through Claude Code, Codex, Gemini… (their login, no key)')}`);
+          console.log(`    ${teal('@name')} ${slate('<msg>')}   ${sage('one message to one tool — @codex review this')}`);
+          console.log(`    ${teal('/work')} ${slate('[tool]')}  ${sage('hand off to the full interactive tool, outcome on return')}`);
+          console.log(`    ${teal('/clarify')}       ${sage('turn messy thoughts into .intent/ artifacts')}`);
+          console.log(`    ${teal('/outcomes')}      ${sage('label what you kept — the record that gets smarter')}`);
+          console.log('');
+          console.log(`  ${slate('/help all')} ${sage('everything')}  ${slate('·')}  ${slate('/tour')} ${sage('walkthrough')}  ${slate('·')}  ${slate('/quit')} ${sage('exit')}`);
+          console.log('');
+          rl.prompt();
+          return;
+        }
+
         console.log('');
         console.log(`  ${sage('the loop: define .intent/ → sync → work → evolve → repeat')}`);
         console.log('');
         console.log(`  ${cream('not sure what to do?')}`);
         console.log(`    ${teal('/next')}        ${sage("phewsh reads your state and hands back the next step worth taking")}`);
+        console.log(`    ${teal('/thread')}      ${sage('where you left off — your work across every tool, one record')}`);
         console.log('');
         console.log(`  ${cream('author .intent/')}`);
         console.log(`    ${teal('/init')}        ${sage('Create .intent/ for this project')}`);
@@ -1856,14 +1936,27 @@ async function main() {
 
       if (cmd === 'harnesses' || cmd === 'agents') {
         console.log('');
-        console.log(`  ${b(cream('Agent CLIs on this machine'))} ${slate('— each carries its own login, no API key')}`);
+        console.log(`  ${b(cream('Your AI tools'))} ${slate('— phewsh keeps them all, aligned. You never pick just one.')}`);
         ui.divider('line');
-        for (const h of harnesses) {
+        // Installed first, then the rest so the table also teaches what exists.
+        const sorted = [...harnesses].sort((a, b) => (b.installed - a.installed));
+        let lastGroup = null;
+        for (const h of sorted) {
+          const group = h.installed ? 'in' : 'out';
+          if (group !== lastGroup) {
+            console.log(`  ${slate(h.installed ? 'on this machine — context routes straight through their login:' : 'available — install any of these and phewsh picks it up:')}`);
+            lastGroup = group;
+          }
           const active = route?.type === 'harness' && route.id === h.id ? ` ${teal('● active')}` : '';
-          const mode = h.headless ? '' : slate(' · interactive (/work)');
-          const status = h.installed ? green('installed') : slate('not installed');
-          console.log(`    ${cream(h.id.padEnd(12))} ${sage(h.label.padEnd(14))} ${status}${mode}${active}`);
+          const dot = h.installed ? green('●') : slate('○');
+          const mode = h.headless ? '' : slate(' · /work only');
+          console.log(`    ${dot} ${cream(h.id.padEnd(11))} ${sage((h.role || h.label).padEnd(20))} ${slate(h.label)}${mode}${active}`);
         }
+        ui.divider('line');
+        console.log(`  ${sage('keep your tools, keep one record:')}`);
+        console.log(`    ${teal('/use')} ${slate('<id>')}     ${sage('route your typing through that tool')}`);
+        console.log(`    ${teal('@<id>')} ${slate('<msg>')}   ${sage('one message to one tool — context stays shared')}`);
+        console.log(`    ${teal('/council')} ${slate('<q>')}  ${sage('ask every installed tool at once, keep the best answer')}`);
         console.log('');
         rl.prompt();
         return;
@@ -2044,8 +2137,14 @@ async function main() {
         return;
       }
 
-      // Unknown slash command
-      console.log(`  ${sage('Unknown command:')} ${cream('/' + cmd)} ${slate('— type /help for available commands')}`);
+      // Unknown slash command — suggest the nearest real one instead of a dead end.
+      const guess = closest(cmd, [...KNOWN_COMMANDS]);
+      if (guess) {
+        console.log(`  ${sage('No command')} ${cream('/' + cmd)}${sage('. Did you mean')} ${teal('/' + guess)}${sage('?')} ${slate('· enter = run it · /help all for everything')}`);
+        pendingDidYouMean = '/' + guess + (cmdArg ? ' ' + cmdArg : '');
+      } else {
+        console.log(`  ${sage('No command')} ${cream('/' + cmd)}${sage('.')} ${slate('Type')} ${teal('/next')} ${slate('for what to do, or')} ${teal('/help')} ${slate('for everything.')}`);
+      }
       rl.prompt();
       return;
     }
@@ -2098,8 +2197,17 @@ async function main() {
   }
 
   const lineDispatcher = createLineDispatcher(handleInput, {
-    onBatch: ({ input, lines }) => collapsePastedEcho(lines, input),
-    onNoop: () => rl.prompt(),
+    onBatch: ({ input, lines }) => { collapsePastedEcho(lines, input); cmdHistory.append(input); },
+    onNoop: () => {
+      // Bare Enter accepts a pending "did you mean" suggestion.
+      if (pendingDidYouMean) {
+        const cmd = pendingDidYouMean;
+        pendingDidYouMean = null;
+        handleInput(cmd).catch(() => {});
+        return;
+      }
+      rl.prompt();
+    },
     onError: (err) => {
       console.error(`\n  ${ember('!')} ${sage('Input failed:')} ${err.message}`);
       rl.prompt();

package/lib/closest.js

@@ -0,0 +1,59 @@
+// Find the nearest known command to a typo — so an unknown slash command
+// becomes "did you mean /clarify?" instead of a dead end. Pure + deterministic.
+//
+// Strategy, in order of confidence:
+//   1. Exact prefix — user typed a real abbreviation (/cla → /clarify).
+//   2. Small edit distance — a genuine typo (/claify → /clarify).
+// Returns the single best candidate, or null when nothing is close enough.
+
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (!a.length) return b.length;
+  if (!b.length) return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  let curr = new Array(b.length + 1);
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[b.length];
+}
+
+/**
+ * @param {string} input — the unknown token (no leading slash)
+ * @param {string[]} candidates — known command names
+ * @param {object} [opts]
+ * @param {number} [opts.maxDistance=2] — max edit distance to still suggest
+ * @returns {string|null} best candidate or null
+ */
+function closest(input, candidates, opts = {}) {
+  const maxDistance = opts.maxDistance ?? 2;
+  if (!input || !candidates || candidates.length === 0) return null;
+  const q = input.toLowerCase();
+
+  // 1. Prefix match — shortest matching command wins (most specific abbrev).
+  //    Require at least 2 chars so a stray "/a" doesn't latch onto everything.
+  if (q.length >= 2) {
+    const prefixes = candidates
+      .filter(c => c.toLowerCase().startsWith(q))
+      .sort((a, b) => a.length - b.length);
+    if (prefixes.length) return prefixes[0];
+  }
+
+  // 2. Edit distance — nearest within threshold; scale threshold down for
+  //    very short inputs so "x" doesn't "match" every 1-2 char command.
+  const cap = Math.min(maxDistance, Math.max(1, Math.floor(q.length / 2) + 1));
+  let best = null;
+  let bestD = Infinity;
+  for (const c of candidates) {
+    const d = levenshtein(q, c.toLowerCase());
+    if (d < bestD) { bestD = d; best = c; }
+  }
+  return bestD <= cap ? best : null;
+}
+
+module.exports = { closest, levenshtein };

package/lib/continuity.js

@@ -0,0 +1,86 @@
+// Continuity — make "nothing lost across tools" visible.
+//
+// Every routed action phewsh records is tagged with the tool that ran it
+// (claude-code, codex, gemini…). Read newest-first, that list IS a thread of
+// your work across every tool. This module turns it into something a human
+// (front door, /thread) or a standalone harness (ambient brief) can feel:
+// "last you were doing X, via Codex, 3h ago — keep going."
+//
+// Pure + deterministic: feed it the decision records, get back strings.
+
+const ROUTE_LABELS = {
+  'claude-code': 'Claude Code',
+  codex: 'Codex',
+  gemini: 'Gemini',
+  cursor: 'Cursor',
+  opencode: 'OpenCode',
+  grok: 'Grok',
+  kiro: 'Kiro',
+  copilot: 'Copilot',
+  hermes: 'Hermes',
+  pi: 'Pi',
+  aider: 'Aider',
+  goose: 'Goose',
+  amp: 'Amp',
+  droid: 'Droid',
+  api: 'direct API',
+  council: 'council',
+};
+
+function labelFor(route, labeler) {
+  if (labeler) { const l = labeler(route); if (l) return l; }
+  return ROUTE_LABELS[route] || route || 'a tool';
+}
+
+function agoText(ts, now = Date.now()) {
+  const then = new Date(ts).getTime();
+  if (isNaN(then)) return '';
+  const s = Math.max(0, Math.floor((now - then) / 1000));
+  if (s < 45) return 'just now';
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  return `${d}d ago`;
+}
+
+/** Decisions for a project (or all), newest first. */
+function threadFor(decisions, { project = null } = {}) {
+  return (decisions || [])
+    .filter(d => d && d.ts && (!project || d.project === project))
+    .sort((a, b) => String(b.ts).localeCompare(String(a.ts)));
+}
+
+/** The single most recent action — "where you left off", or null. */
+function lastLeftOff(decisions, { project = null } = {}) {
+  const t = threadFor(decisions, { project });
+  if (!t.length) return null;
+  const d = t[0];
+  return {
+    summary: (d.summary || '').trim(),
+    route: d.route,
+    ts: d.ts,
+    outcome: d.outcome || null,
+  };
+}
+
+/** A one-line "picking up where you left off" string, or null. */
+function continuityLine(decisions, { project = null, now = Date.now(), labeler = null, maxLen = 52 } = {}) {
+  const last = lastLeftOff(decisions, { project });
+  if (!last) return null;
+  let s = last.summary.replace(/\s+/g, ' ');
+  if (s.length > maxLen) s = s.slice(0, maxLen - 1).trimEnd() + '…';
+  const via = labelFor(last.route, labeler);
+  const ago = agoText(last.ts, now);
+  const when = ago ? ` · ${ago}` : '';
+  return s ? `last: “${s}” · via ${via}${when}` : `last action via ${via}${when}`;
+}
+
+/** How many distinct tools appear in the thread (the "across tools" proof). */
+function toolsInThread(decisions, { project = null } = {}) {
+  const set = new Set(threadFor(decisions, { project }).map(d => d.route).filter(Boolean));
+  return set.size;
+}
+
+module.exports = { agoText, threadFor, lastLeftOff, continuityLine, toolsInThread, labelFor, ROUTE_LABELS };

package/lib/history.js

@@ -0,0 +1,40 @@
+// Persistent command history — so up-arrow remembers across sessions, like
+// every serious shell and harness. Stored at ~/.phewsh/history, newest last.
+//
+// Never persists anything secret: lines that set an API key are skipped, so a
+// key typed at the prompt can't linger on disk.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const FILE = path.join(os.homedir(), '.phewsh', 'history');
+
+const SECRET = /^\/key\b/i; // /key <token> — never write the token to disk
+
+/** Load up to `max` recent entries, oldest→newest (file order). */
+function load(max = 100, file = FILE) {
+  try {
+    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(l => l.trim().length);
+    return lines.slice(-max);
+  } catch {
+    return [];
+  }
+}
+
+/** Most-recent-first, the order Node's readline `history` option expects. */
+function loadForReadline(max = 100, file = FILE) {
+  return load(max, file).reverse();
+}
+
+/** Append one submitted line. No-ops on blank or secret-bearing input. */
+function append(line, file = FILE) {
+  if (!line || !line.trim()) return;
+  if (SECRET.test(line.trim())) return;
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, line.replace(/\r?\n/g, ' ') + '\n');
+  } catch { /* read-only home — in-session history still works */ }
+}
+
+module.exports = { load, loadForReadline, append, FILE };

package/package.json

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