phewsh 0.15.47 → 0.15.49

package/bin/phewsh.js

@@ -88,6 +88,10 @@ const COMMANDS = {
   ambient: () => require('../commands/ambient')(),
   shim:    () => require('../commands/shim')(),
   status:  () => require('../commands/status')(),
+  next:    () => require('../commands/next')(),
+  work:    () => require('../commands/work')(),
+  remember: () => require('../commands/remember')(),
+  pack:    () => require('../commands/pack')(),
   hook:    () => require('../commands/hook')(),
   welcome: () => require('../commands/welcome')(),
   intro:   () => require('../commands/welcome')(),
@@ -103,7 +107,14 @@ function showHelp() {
   const pkg = require('../package.json');
   showBrand();
   console.log(`  ${g('v' + pkg.version)}  ·  ${g('phewsh.com/cli')}\n`);
-  console.log(`  ${g('The loop: define .intent/ → sync → every AI tool reads → work → repeat')}`);
+  console.log(`  ${g('Phewsh keeps work from getting lost — for you, and every AI tool you use.')}`);
+  console.log('');
+  console.log(`  ${b(w('the whole idea — four plain words'))}`);
+  console.log(`    ${cyan('intent')}     ${g('PROJECT   what you\'re building & why')}`);
+  console.log(`    ${cyan('next')}       ${g('NEXT      what should happen next — a zero-AI list')}`);
+  console.log(`    ${cyan('work')}       ${g('WORK      what\'s happening now — at a glance')}`);
+  console.log(`    ${cyan('remember')}   ${g('RECORD    jot a decision so it sticks & travels')}`);
+  console.log(`    ${cyan('status')}     ${g('see all four at a glance')}`);
   console.log('');
   console.log(`  ${b(w('get started'))}`);
   console.log(`    ${cyan('phewsh')}           ${g('Open a session — routes through your installed agents')}`);
@@ -115,6 +126,7 @@ function showHelp() {
   console.log(`    ${cyan('gate')}       ${g('Set constraints (budget, time, skill, urgency)')}`);
   console.log(`    ${cyan('context')}    ${g('Export .intent/ for any AI tool')}`);
   console.log(`    ${cyan('status')}     ${g('git status for AI continuity — truth, record, drift, what\'s wired')}`);
+  console.log(`    ${cyan('next')}       ${g('What should happen next — a zero-AI list every tool reads')}`);
   console.log(`    ${cyan('truth')}      ${g('Read-only audit: versions, Git, intent, projections, conflicts')}`);
   console.log(`    ${cyan('brief')}      ${g('Provider-ready briefing built from verified project truth')}`);
   console.log(`    ${cyan('ai')}         ${g('One-shot prompt with .intent/ context')}
@@ -128,7 +140,9 @@ function showHelp() {
   console.log(`    ${cyan('mcp')}        ${g('Connect AI agents via MCP protocol')}`);
   console.log(`    ${cyan('ambient')}    ${g('Continuity without launching phewsh — enhance your other tools')}`);
   console.log(`    ${cyan('shim')}       ${g('Guaranteed launch banner — phewsh prints status before each tool')}`);
+  console.log(`    ${cyan('pack')}       ${g('Opt-in workflow packs (Karpathy guidelines, GSD…) — attributed, reversible')}`);
   console.log(`    ${cyan('receipts')}   ${g('Proof trail — what agents actually did, with evidence')}`);
+  console.log(`    ${cyan('remember')}   ${g('Jot a decision to .intent/decisions.md — every tool inherits it')}`);
   console.log(`    ${cyan('outcomes')}   ${g('Decision record — what was kept, reverted, or failed')}`);
   console.log(`    ${cyan('bypass')}     ${g('Went around phewsh? Record why — 10 seconds, no guilt')}`);
   console.log('');

package/commands/next.js

@@ -0,0 +1,131 @@
+// phewsh next — one of the four plain words (Project · Next · Work · Record).
+// A zero-AI "what should happen next?" list that lives in `.intent/next.json`,
+// so it travels with the repo and every AI tool reads the same list. Works
+// for a human alone with no model in the loop — a thinking tool first.
+//
+//   phewsh next                 show NOW / NEXT / DONE + phewsh's suggestion
+//   phewsh next add "<title>"   queue something
+//   phewsh next start <n|id>    mark it in progress (NOW)
+//   phewsh next done <n|id>     mark it shipped (DONE)
+//   phewsh next drop <n|id>     remove it
+//   phewsh next clear           clear the DONE pile
+
+const next = require('../lib/next');
+
+const b = (s) => `\x1b[1m${s}\x1b[0m`;
+const teal = (s) => `\x1b[38;5;79m${s}\x1b[0m`;
+const sage = (s) => `\x1b[38;5;151m${s}\x1b[0m`;
+const slate = (s) => `\x1b[38;5;247m${s}\x1b[0m`;
+const cream = (s) => `\x1b[38;5;230m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+
+const MARK = { now: green('◐'), next: slate('○'), done: slate('✓') };
+const LABEL = { now: cream('NOW '), next: teal('NEXT'), done: slate('DONE') };
+
+function render(cwd = process.cwd()) {
+  const data = next.load(cwd);
+  const list = next.ordered(data);
+  console.log('');
+  console.log(`  ${b(cream('NEXT'))} ${slate('— what should happen next ·')} ${slate('.intent/next.json')}`);
+  console.log('');
+  if (list.length === 0) {
+    console.log(`  ${slate('Nothing queued yet.')}`);
+    console.log(`  ${slate('Add one:')} ${cream('phewsh next add "the thing you want done"')}`);
+  } else {
+    list.forEach((it, i) => {
+      const n = slate(String(i + 1).padStart(2));
+      const title = it.state === 'done' ? slate(it.title) : cream(it.title);
+      console.log(`  ${n} ${MARK[it.state]} ${LABEL[it.state]}  ${title}`);
+    });
+    console.log('');
+    console.log(`  ${slate('start # · done # · drop # · add "…" · clear')}`);
+  }
+
+  // Unify with phewsh's own recommendation: the user's list is what THEY want
+  // next; this one line is what phewsh notices is worth doing. Best-effort.
+  try {
+    const { suggest } = require('../lib/suggest');
+    const tip = suggest(buildState(cwd));
+    if (tip) {
+      console.log('');
+      console.log(`  ${teal('⤷ phewsh suggests')}  ${cream(tip.command.trim())}  ${sage(tip.message)}`);
+    }
+  } catch { /* suggestion is a nicety, never required */ }
+  console.log('');
+}
+
+// Minimal state for the suggestion engine — mirrors session.buildSuggestState
+// but standalone (no live session). Everything fail-soft.
+function buildState(cwd) {
+  const fs = require('fs');
+  const path = require('path');
+  const hasIntentDir = fs.existsSync(path.join(cwd, '.intent'));
+  let intentFileCount = 0;
+  try {
+    intentFileCount = fs.readdirSync(path.join(cwd, '.intent')).filter(f => f.endsWith('.md')).length;
+  } catch { /* none */ }
+  let packsInstalled = false;
+  try {
+    const { PACKS, isInstalled } = require('../lib/packs');
+    packsInstalled = Object.keys(PACKS).some(name => isInstalled(name, cwd));
+  } catch { /* ignore */ }
+  let installedHarnesses = [];
+  try { installedHarnesses = require('../lib/harnesses').listHarnesses().filter(h => h.installed).map(h => h.id); } catch { /* ignore */ }
+  return { hasIntentDir, intentFileCount, installedHarnesses, packsInstalled, turnsThisSession: 1 };
+}
+
+function notFound(ref) {
+  console.log('');
+  console.log(`  ${slate('No item')} ${cream(ref)}${slate('. Run')} ${cream('phewsh next')} ${slate('to see the numbered list.')}`);
+  console.log('');
+}
+
+function main() {
+  const sub = (process.argv[3] || '').toLowerCase();
+  const rest = process.argv.slice(4).join(' ').replace(/^["']|["']$/g, '');
+
+  if (!sub || sub === 'list' || sub === 'ls') {
+    render();
+    return;
+  }
+
+  if (sub === 'add' || sub === 'a') {
+    const item = next.add(rest);
+    if (!item) {
+      console.log(`\n  ${slate('Add what? e.g.')} ${cream('phewsh next add "wire up the MCP read connector"')}\n`);
+      return;
+    }
+    render();
+    return;
+  }
+
+  if (sub === 'start' || sub === 'now' || sub === 'done' || sub === 'drop' || sub === 'rm') {
+    const ref = process.argv[4];
+    if (!ref) { console.log(`\n  ${slate('Which one? e.g.')} ${cream('phewsh next ' + sub + ' 1')}\n`); return; }
+    if (sub === 'drop' || sub === 'rm') {
+      const removed = next.remove(ref);
+      if (!removed) return notFound(ref);
+    } else {
+      const state = sub === 'start' || sub === 'now' ? 'now' : 'done';
+      const item = next.setState(ref, state);
+      if (!item) return notFound(ref);
+    }
+    render();
+    return;
+  }
+
+  if (sub === 'clear') {
+    const data = next.load();
+    data.items = data.items.filter(it => it.state !== 'done');
+    next.save(data);
+    render();
+    return;
+  }
+
+  // Unknown sub → treat the whole thing as a quick add ("phewsh next fix the bug")
+  const item = next.add([sub, rest].filter(Boolean).join(' '));
+  if (item) { render(); return; }
+  render();
+}
+
+module.exports = main;

package/commands/pack.js

@@ -0,0 +1,97 @@
+// phewsh pack — opt-in gateway to AI-workflow enhancements (Karpathy-style
+// guidelines, GSD, …). Attributed, previewed, confirmed, reversible. phewsh's
+// core stays continuity; packs are an optional layer you choose.
+//
+//   phewsh pack                  list packs (available + installed)
+//   phewsh pack install <name>   show source/license + diff, confirm, install
+//   phewsh pack remove <name>    remove a vendored pack's marked block
+
+const readline = require('readline');
+const packs = require('../lib/packs');
+
+const b = (s) => `\x1b[1m${s}\x1b[0m`;
+const teal = (s) => `\x1b[38;5;79m${s}\x1b[0m`;
+const sage = (s) => `\x1b[38;5;151m${s}\x1b[0m`;
+const slate = (s) => `\x1b[38;5;247m${s}\x1b[0m`;
+const cream = (s) => `\x1b[38;5;230m${s}\x1b[0m`;
+const peach = (s) => `\x1b[38;5;216m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+
+async function confirm(q) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(res => rl.question(q, a => { rl.close(); res(/^y(es)?$/i.test(a.trim())); }));
+}
+
+function list() {
+  console.log('');
+  console.log(`  ${b(cream('phewsh packs'))} ${sage('— optional, attributed, reversible enhancements')}`);
+  console.log(`  ${slate('phewsh\'s core is continuity; these are extras you opt into.')}`);
+  console.log('');
+  for (const [name, p] of Object.entries(packs.PACKS)) {
+    const on = packs.isInstalled(name);
+    const tag = p.kind === 'linked' ? slate('[linked]') : (on ? green('[installed]') : slate('[available]'));
+    console.log(`  ${cream(name.padEnd(16))} ${tag}`);
+    console.log(`    ${slate(p.desc)}`);
+    console.log(`    ${slate('source: ' + p.source)}`);
+  }
+  console.log('');
+  console.log(`  ${sage('Install:')} ${cream('phewsh pack install <name>')}   ${sage('Remove:')} ${cream('phewsh pack remove <name>')}`);
+  console.log('');
+}
+
+async function install(name) {
+  const p = packs.PACKS[name];
+  if (!p) { console.log(`\n  ${yellow('Unknown pack:')} ${name}. See ${cream('phewsh pack')}.\n`); return; }
+
+  console.log('');
+  console.log(`  ${b(cream(p.title))} ${slate('(pack: ' + name + ')')}`);
+  console.log(`  ${slate(p.desc)}`);
+  console.log(`  ${peach('source:')}  ${slate(p.source)}`);
+  console.log(`  ${peach('license:')} ${slate(p.license)}`);
+  console.log('');
+
+  if (p.kind === 'linked') {
+    console.log(`  ${sage('This is a separate tool — phewsh doesn\'t vendor it. Install it with:')}`);
+    console.log(`    ${cream(p.install)}`);
+    console.log('');
+    return;
+  }
+
+  const preview = packs.previewInstall(name);
+  console.log(`  ${sage('Writes a clearly-marked, removable block into:')} ${cream(preview.files.join(', '))}`);
+  console.log(`  ${slate('Preview:')}`);
+  preview.block.split('\n').slice(0, 8).forEach(l => console.log(`    ${slate('│ ' + l)}`));
+  console.log(`    ${slate('│ … (' + preview.block.split('\n').length + ' lines total)')}`);
+  console.log('');
+
+  const ok = await confirm(`  ${b('Install this pack here?')} ${slate('[y/N] ')}`);
+  if (!ok) { console.log(`  ${sage('Nothing changed.')}\n`); return; }
+
+  const { written } = packs.install(name);
+  console.log('');
+  console.log(`  ${green('●')} ${b('Installed.')} ${slate('→ ' + written.join(', '))}`);
+  console.log(`  ${sage('Remove anytime:')} ${cream('phewsh pack remove ' + name)}`);
+  console.log('');
+}
+
+function remove(name) {
+  const p = packs.PACKS[name];
+  if (!p) { console.log(`\n  ${yellow('Unknown pack:')} ${name}.\n`); return; }
+  if (p.kind === 'linked') { console.log(`\n  ${sage(p.title + ' is a separate tool — uninstall it the way you installed it.')}\n`); return; }
+  const { removed } = packs.remove(name);
+  console.log('');
+  if (removed.length) console.log(`  ${green('●')} ${b('Removed.')} ${slate('← ' + removed.join(', '))}`);
+  else console.log(`  ${sage('Not installed here — nothing to remove.')}`);
+  console.log('');
+}
+
+async function main() {
+  const sub = process.argv[3];
+  const name = process.argv[4];
+  if (sub === 'install' && name) return install(name);
+  if (sub === 'remove' && name) return remove(name);
+  return list();
+}
+
+module.exports = main;

package/commands/remember.js

@@ -0,0 +1,45 @@
+// phewsh remember — Record's zero-AI verb (Project · Next · Work · Record).
+// Jot a decision or lesson so it sticks and every AI tool inherits it.
+//
+//   phewsh remember "we're deferring the MCP connector to phase 3"
+//   phewsh remember            show what you've remembered
+
+const record = require('../lib/record');
+
+const b = (s) => `\x1b[1m${s}\x1b[0m`;
+const teal = (s) => `\x1b[38;5;79m${s}\x1b[0m`;
+const sage = (s) => `\x1b[38;5;151m${s}\x1b[0m`;
+const slate = (s) => `\x1b[38;5;247m${s}\x1b[0m`;
+const cream = (s) => `\x1b[38;5;230m${s}\x1b[0m`;
+
+function main() {
+  const text = process.argv.slice(3).join(' ').replace(/^["']|["']$/g, '');
+
+  if (!text) {
+    const ns = record.notes();
+    console.log('');
+    if (ns.length === 0) {
+      console.log(`  ${slate('Nothing remembered yet.')}`);
+      console.log(`  ${slate('Jot a decision so every tool inherits it:')}`);
+      console.log(`  ${cream('phewsh remember "we decided to keep packs opt-in"')}`);
+    } else {
+      console.log(`  ${b(cream('RECORD'))} ${slate('— what you decided · .intent/decisions.md')}`);
+      console.log('');
+      ns.slice(-12).forEach(l => console.log(`  ${slate(l)}`));
+    }
+    console.log('');
+    return;
+  }
+
+  const r = record.remember(text);
+  console.log('');
+  if (r) {
+    console.log(`  ${teal('✓')} ${sage('Remembered.')} ${slate('Every tool reading .intent/ now sees it.')}`);
+    console.log(`  ${slate('.intent/decisions.md · ' + r.date)}`);
+  } else {
+    console.log(`  ${slate('Could not write .intent/decisions.md here.')}`);
+  }
+  console.log('');
+}
+
+module.exports = main;

package/commands/session.js

@@ -582,6 +582,12 @@ async function main() {
     let shimOn = false;
     try { shimOn = require('../lib/shims').shimStatus().installed.length > 0; } catch { /* shims off */ }
 
+    let packsInstalled = false;
+    try {
+      const { PACKS, isInstalled } = require('../lib/packs');
+      packsInstalled = Object.keys(PACKS).some(name => isInstalled(name));
+    } catch { /* packs nudge is optional */ }
+
     let pending = 0;
     // Only substantive calls — never nag the user to "judge" a greeting.
     try { pending = pendingDecisions({ project: projectName, substantive: true }).length; } catch { /* best-effort */ }
@@ -605,6 +611,7 @@ async function main() {
       seqStale,
       ambientOn,
       shimOn,
+      packsInstalled,
       commitsSinceIntent: (() => { try { return selfheal.commitsSinceIntent(); } catch { return 0; } })(),
       bestKeeper,
     };
@@ -932,6 +939,7 @@ async function main() {
     'sync', 'harnesses', 'fallback', 'outcomes', 'tour', 'update', 'upgrade',
     'agents', 'context', 'truth', 'brief', 'wrap', 'reconcile', 'gate', 'reload', 'sequence', 'seq', 'setup', 'system', 'watch',
     'next', 'recommend', 'guide', 'thread', 'continuity', 'learn', 'stats',
+    'pack', 'packs', 'remember',
   ]);
   const installedIds = harnesses.filter(h => h.installed).map(h => h.id);
   let turnAbort = null;       // AbortController while an API turn streams
@@ -1354,11 +1362,52 @@ async function main() {
       // The self-aware "what should I do?" button: phewsh reads the session's
       // state and hands back ranked, pickable next steps — no command to recall.
       if (cmd === 'next' || cmd === 'recommend' || cmd === 'guide') {
+        // "Next" is one of the four words: your list (.intent/next.json) +
+        // phewsh's own recommendation, unified under one verb.
+        const nx = require('../lib/next');
+        const nparts = cmdArg.split(/\s+/);
+        const nsub = (nparts[0] || '').toLowerCase();
+        const TASK_SUBS = ['add', 'a', 'start', 'now', 'done', 'drop', 'rm', 'list', 'ls', 'clear'];
+        const renderTasks = () => {
+          const items = nx.ordered(nx.load());
+          console.log('');
+          console.log(`  ${b(cream('NEXT'))} ${slate('— what should happen next · .intent/next.json')}`);
+          if (items.length === 0) {
+            console.log(`  ${slate('Empty.')} ${cream('/next add "the thing you want done"')}`);
+          } else {
+            items.forEach((it, i) => {
+              const mark = it.state === 'now' ? green('◐') : it.state === 'done' ? slate('✓') : slate('○');
+              const title = it.state === 'done' ? slate(it.title) : cream(it.title);
+              console.log(`  ${slate(String(i + 1).padStart(2))} ${mark} ${title}`);
+            });
+            console.log(`  ${slate('/next start # · /next done # · /next drop # · /next add "…"')}`);
+          }
+          console.log('');
+        };
+        if (TASK_SUBS.includes(nsub)) {
+          if (nsub === 'add' || nsub === 'a') nx.add(cmdArg.replace(/^\S+\s*/, '').replace(/^["']|["']$/g, ''));
+          else if (nsub === 'clear') { const dd = nx.load(); dd.items = dd.items.filter(i => i.state !== 'done'); nx.save(dd); }
+          else if (nsub === 'list' || nsub === 'ls') { /* render only */ }
+          else { const ref = nparts[1]; if (nsub === 'drop' || nsub === 'rm') nx.remove(ref); else nx.setState(ref, (nsub === 'start' || nsub === 'now') ? 'now' : 'done'); }
+          renderTasks();
+          rl.prompt();
+          return;
+        }
+        const c = nx.counts();
         let ranked = [];
         try { ranked = suggestAll(buildSuggestState()); } catch { /* best-effort */ }
         console.log('');
+        if (c.total > 0) {
+          const bits = [];
+          if (c.now) bits.push(green(c.now + ' in progress'));
+          if (c.next) bits.push(teal(c.next + ' queued'));
+          if (c.done) bits.push(slate(c.done + ' done'));
+          console.log(`  ${cream('your NEXT list:')} ${bits.join(slate(' · '))}  ${slate('— /next list')}`);
+          console.log('');
+        }
         if (ranked.length === 0) {
-          console.log(`  ${teal('●')} ${sage("You're aligned — nothing pressing. Keep working, or /help for everything.")}`);
+          if (c.total === 0) console.log(`  ${teal('●')} ${sage("You're aligned — nothing pressing. Note what's next with /next add, or keep working.")}`);
+          else console.log(`  ${teal('●')} ${sage("That's your list. Nothing else pressing from phewsh.")}`);
           console.log('');
           nextChoices = null;
           rl.prompt();
@@ -1518,6 +1567,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('/remember')}    ${sage('Jot a decision to .intent/decisions.md — every tool inherits it')}`);
         console.log(`    ${teal('/truth')}       ${sage('Read-only audit of versions, Git, intent, projections, and conflicts')}`);
         console.log(`    ${teal('/brief')}       ${sage('Generate the current provider-ready verified briefing')}`);
         console.log(`    ${teal('/wrap')}        ${sage('Observe changes, contradictions, unknowns, and reconciliation needs')}`);
@@ -1536,6 +1586,7 @@ async function main() {
         console.log(`    ${teal('/pull')}        ${sage('Pull from cloud (reloads context)')}`);
         console.log(`    ${teal('/serve')}       ${sage('Execution bridge for phewsh.com/intent')}`);
         console.log(`    ${teal('/sync')}        ${sage('Check sync status')}`);
+        console.log(`    ${teal('/pack')}        ${sage('Opt-in workflow packs (Karpathy, GSD…) — attributed, reversible')}`);
         console.log('');
         console.log(`  ${cream('route — where your typing goes')}`);
         console.log(`    ${teal('/use')} ${slate('<route>')}  ${sage('Switch: claude-code, codex, gemini, cursor, opencode, api')}`);
@@ -2554,6 +2605,45 @@ async function main() {
         return;
       }
 
+      if (cmd === 'remember') {
+        // Record's zero-AI verb: jot a decision/lesson to .intent/decisions.md
+        // so it sticks and every tool inherits it. No model needed.
+        const rec = require('../lib/record');
+        const text = cmdArg.replace(/^["']|["']$/g, '').trim();
+        console.log('');
+        if (!text) {
+          const ns = rec.notes();
+          if (ns.length === 0) {
+            console.log(`  ${slate('Nothing remembered yet. Jot a decision:')} ${cream('/remember we decided to keep packs opt-in')}`);
+          } else {
+            console.log(`  ${b(cream('RECORD'))} ${slate('— what you decided · .intent/decisions.md')}`);
+            ns.slice(-12).forEach(l => console.log(`  ${slate(l)}`));
+          }
+        } else {
+          const r = rec.remember(text);
+          if (r) console.log(`  ${green('✓')} ${sage('Remembered.')} ${slate('Every tool reading .intent/ now sees it. · .intent/decisions.md')}`);
+          else console.log(`  ${slate('Could not write .intent/decisions.md here.')}`);
+        }
+        console.log('');
+        rl.prompt();
+        return;
+      }
+
+      if (cmd === 'pack' || cmd === 'packs') {
+        // Opt-in workflow packs (Karpathy, GSD…) — attributed, reversible,
+        // project-scoped. Delegate to the real `phewsh pack` command so the
+        // preview + [y/N] confirm get the live stdin (same handoff as /intent).
+        pasteMode(false);
+        rl.pause();
+        const { spawnSync } = require('child_process');
+        const passArgs = cmdArg ? cmdArg.split(/\s+/).filter(Boolean) : [];
+        spawnSync(process.execPath, [path.join(__dirname, '..', 'bin', 'phewsh.js'), 'pack', ...passArgs], { stdio: 'inherit' });
+        rl.resume();
+        pasteMode(true);
+        rl.prompt();
+        return;
+      }
+
       // Unknown slash command — suggest the nearest real one instead of a dead end.
       const guess = closest(cmd, [...KNOWN_COMMANDS]);
       if (guess) {

package/commands/status.js

@@ -21,7 +21,6 @@ const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 
 const ok = green('✓');
 const off = slate('○');
-const warn = peach('⚠');
 
 function row(label, value) {
   return `  ${slate(label.padEnd(13))} ${value}`;
@@ -53,44 +52,69 @@ function main() {
 
   console.log('');
   console.log(`  ${b('😮‍💨 PHEWSH STATUS')} ${slate('· ' + projectName(cwd))}`);
+  console.log(`  ${slate('Project · Next · Work · Record — the four answers every tool inherits')}`);
   console.log('');
 
-  // ── Continuity asset (the product) ─────────────────────────────────
+  // ── PROJECT — what you're building & why ───────────────────────────
   if (!hasIntent) {
-    console.log(row('Truth', `${off} ${sage('no shared project truth here yet')}`));
-    console.log(row('', slate('create it so the next AI inherits this one\'s context:')));
+    console.log(row('PROJECT', `${off} ${sage('no shared project truth here yet')}`));
+    console.log(row('', slate('create it so you — and the next AI — inherit context:')));
     console.log(row('', cream('phewsh intent --init')));
   } else {
     const files = fs.readdirSync(intentDir).filter(f => /\.(md|json)$/.test(f));
     const has = (f) => files.includes(f);
-    console.log(row('Truth', `${ok} ${sage('.intent present')} ${slate('(' + files.length + ' files)')}`));
-    console.log(row('Vision', has('vision.md') ? `${ok} ${slate('loaded')}` : `${off} ${slate('missing')}`));
-    console.log(row('Next step', (has('next.md') || has('status.md')) ? `${ok} ${slate('loaded')}` : `${off} ${slate('missing')}`));
-
-    // Decision record
-    let stats = { total: 0, pending: 0 };
-    try { stats = require('../lib/outcomes').outcomeStats({ project: key }); } catch { /* none */ }
-    const pend = stats.pending ? `  ${warn} ${peach(stats.pending + ' pending')}` : `  ${ok} ${slate('all labeled')}`;
-    console.log(row('Record', `${cream(stats.total + ' decisions')}${stats.total ? pend : slate(' — none yet')}`));
+    const visionBit = has('vision.md') ? sage('vision loaded') : slate('vision missing');
+    console.log(row('PROJECT', `${ok} ${sage('.intent present')} ${slate('(' + files.length + ' files)')} ${slate('·')} ${visionBit}`));
+  }
 
-    // Cross-tool continuity
+  // ── NEXT — what should happen next (works with zero AI) ────────────
+  try {
+    const nx = require('../lib/next');
+    const items = nx.ordered(nx.load(cwd));
+    if (items.length === 0) {
+      console.log(row('NEXT', `${off} ${slate('nothing queued — ')}${cream('phewsh next add "…"')}`));
+    } else {
+      const c = { now: 0, next: 0, done: 0 };
+      items.forEach(i => { c[i.state]++; });
+      const bits = [];
+      if (c.now) bits.push(green('◐ ' + c.now + ' in progress'));
+      if (c.next) bits.push(teal('○ ' + c.next + ' queued'));
+      if (c.done) bits.push(slate('✓ ' + c.done + ' done'));
+      console.log(row('NEXT', bits.join(slate(' · '))));
+      const focus = items.find(i => i.state === 'now') || items.find(i => i.state === 'next');
+      if (focus) console.log(row('', cream(focus.title)));
+    }
+  } catch { /* best-effort */ }
+
+  // ── WORK — what's being done right now (loops/runs land here later) ─
+  if (hasIntent) {
     try {
       const continuity = require('../lib/continuity');
       const decisions = loadDecisions();
       const tools = continuity.toolsInThread(decisions, { project: key });
       const line = continuity.lastLeftOff(decisions, { project: key });
-      if (tools >= 2) console.log(row('Continuity', `${ok} ${sage(tools + ' tools, one thread')}${line && line.ts ? slate(' · last ' + continuity.agoText(line.ts)) : ''}`));
-      else if (tools === 1) console.log(row('Continuity', `${slate('1 tool so far — continuity builds as you switch tools')}`));
-      else console.log(row('Continuity', slate('no activity recorded yet')));
+      const last = line && line.ts ? slate(' · last ' + continuity.agoText(line.ts)) : '';
+      if (tools >= 2) console.log(row('WORK', `${ok} ${sage(tools + ' tools, one thread')}${last}`));
+      else if (tools === 1) console.log(row('WORK', `${slate('1 tool so far — continuity builds as you switch tools')}${last}`));
+      else console.log(row('WORK', slate('no runs active yet')));
     } catch { /* best-effort */ }
+  }
 
-    // Drift
+  // ── RECORD — what happened & what we learned ───────────────────────
+  if (hasIntent) {
+    let stats = { total: 0, pending: 0 };
+    try { stats = require('../lib/outcomes').outcomeStats({ project: key }); } catch { /* none */ }
+    const pend = stats.pending ? ` ${slate('·')} ${peach(stats.pending + ' pending')}` : (stats.total ? ` ${slate('·')} ${slate('all labeled')}` : '');
+    let noteBit = '';
+    try { const n = require('../lib/record').notes(cwd).length; if (n) noteBit = ` ${slate('·')} ${sage(n + ' remembered')}`; } catch { /* none */ }
+    let driftBit = '';
     try {
       const drift = require('../lib/selfheal').commitsSinceIntent(cwd);
-      console.log(row('Drift', drift > 0
-        ? `${warn} ${peach(drift + ' commit(s) since .intent updated')} ${slate('— reconcile to refresh')}`
-        : `${ok} ${slate('0 — record matches the code')}`));
+      driftBit = drift > 0
+        ? ` ${slate('·')} ${peach('drift ' + drift + ' commit(s)')} ${slate('— reconcile')}`
+        : ` ${slate('·')} ${slate('no drift')}`;
     } catch { /* best-effort */ }
+    console.log(row('RECORD', `${cream(stats.total + ' decisions')}${stats.total ? pend : slate(' — none yet')}${noteBit}${driftBit}`));
   }
 
   // ── Delivery (implementation — how phewsh reaches your tools) ───────

package/commands/work.js

@@ -0,0 +1,75 @@
+// phewsh work — the read-only view of the fourth word
+// (Project · Next · Work · Record). One glance: what are we building, what's
+// next, what's happening now, what did we last decide, does anything need you?
+//
+// Read-only on purpose. It makes Work *visible*, not powerful — the loop/queue
+// machinery is deliberately NOT here (see .intent/work-layer.md).
+
+const work = require('../lib/work');
+
+const b = (s) => `\x1b[1m${s}\x1b[0m`;
+const teal = (s) => `\x1b[38;5;79m${s}\x1b[0m`;
+const sage = (s) => `\x1b[38;5;151m${s}\x1b[0m`;
+const slate = (s) => `\x1b[38;5;247m${s}\x1b[0m`;
+const cream = (s) => `\x1b[38;5;230m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const peach = (s) => `\x1b[38;5;216m${s}\x1b[0m`;
+
+function trunc(s, n = 88) {
+  s = String(s).replace(/\s+/g, ' ').trim();
+  return s.length > n ? s.slice(0, n - 1) + '…' : s;
+}
+
+function main() {
+  const v = work.workView();
+  console.log('');
+  console.log(`  ${b('😮‍💨 PHEWSH WORK')} ${slate('· ' + v.project.name)}`);
+  console.log('');
+
+  // Project — what we're building
+  console.log(`  ${cream('Project')}`);
+  if (v.project.present) {
+    console.log(`    ${sage(v.project.name)}${v.project.tagline ? slate(' — ' + trunc(v.project.tagline, 70)) : ''}`);
+  } else {
+    console.log(`    ${slate('no .intent/ here yet — ')}${cream('phewsh intent --init')}`);
+  }
+
+  // Next — what should happen next
+  console.log(`  ${cream('Next')}`);
+  if (v.next.now) {
+    console.log(`    ${green('Now:')} ${sage(trunc(v.next.now))}`);
+  } else if (v.next.topQueued) {
+    console.log(`    ${slate('Up next (not started):')} ${sage(trunc(v.next.topQueued))}  ${slate('· phewsh next start 1')}`);
+  } else {
+    console.log(`    ${slate('nothing queued — ')}${cream('phewsh next add "…"')}`);
+  }
+
+  // Work — what's being done now
+  console.log(`  ${cream('Work')}`);
+  if (v.work.tool) {
+    console.log(`    ${slate('Tool:')} ${sage(v.work.tool)}`);
+    console.log(`    ${slate('Status:')} ${v.work.active ? green('active session') : slate('last ' + v.work.lastAgo)}`);
+  } else {
+    console.log(`    ${slate('no active run detected')}`);
+  }
+
+  // Record — what we last decided / learned
+  console.log(`  ${cream('Record')}`);
+  if (v.record.latest) {
+    console.log(`    ${slate('Latest:')} ${sage(trunc(v.record.latest))}`);
+  } else {
+    console.log(`    ${slate('nothing recorded yet — ')}${cream('phewsh remember "…"')}`);
+  }
+
+  // Review — does anything need a human?
+  console.log(`  ${cream('Review')}`);
+  if (v.review.clear) {
+    console.log(`    ${green('✓')} ${sage('Nothing needs human review right now')}`);
+  } else {
+    v.review.needs.forEach(n => console.log(`    ${peach('⚠')} ${sage(n)}`));
+  }
+
+  console.log('');
+}
+
+module.exports = main;

package/lib/next.js

@@ -0,0 +1,111 @@
+// "Next" — the structured backing for one of phewsh's four plain words
+// (Project · Next · Work · Record). A dead-simple, zero-AI task list that
+// answers "what should happen next?" for a human alone OR for any AI tool
+// reading the project. Lives in `.intent/next.json` so it travels with the
+// repo and every tool inherits the same list — no account, no model needed.
+//
+// Three states only, on purpose: NOW (doing it), NEXT (queued), DONE (shipped).
+// CG called this a "queue"; we call it Next because everyone understands it.
+// Pure + fail-soft: a corrupt/odd-shaped file degrades to empty, never throws.
+
+const fs = require('fs');
+const path = require('path');
+
+const STATES = ['now', 'next', 'done'];
+// Display order — what you act on first, what's queued, what's already done.
+const ORDER = { now: 0, next: 1, done: 2 };
+
+function intentDir(cwd = process.cwd()) {
+  return path.join(cwd, '.intent');
+}
+
+function nextFile(cwd = process.cwd()) {
+  return path.join(intentDir(cwd), 'next.json');
+}
+
+function load(cwd = process.cwd()) {
+  try {
+    const data = JSON.parse(fs.readFileSync(nextFile(cwd), 'utf-8'));
+    const items = Array.isArray(data?.items) ? data.items.filter(it => it && it.id && it.title) : [];
+    return { version: 1, items };
+  } catch {
+    return { version: 1, items: [] };
+  }
+}
+
+function save(data, cwd = process.cwd()) {
+  try {
+    fs.mkdirSync(intentDir(cwd), { recursive: true });
+    fs.writeFileSync(nextFile(cwd), JSON.stringify({ version: 1, items: data.items }, null, 2) + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Items in display order: NOW, then NEXT, then DONE; stable within a state. */
+function ordered(data) {
+  return data.items
+    .map((it, i) => ({ it, i }))
+    .sort((a, b) => (ORDER[a.it.state] ?? 1) - (ORDER[b.it.state] ?? 1) || a.i - b.i)
+    .map(x => x.it);
+}
+
+/** Resolve a user reference (exact id, or 1-based number in display order). */
+function resolve(data, ref) {
+  if (ref == null) return null;
+  const byId = data.items.find(it => it.id === ref);
+  if (byId) return byId;
+  const n = parseInt(ref, 10);
+  if (Number.isInteger(n) && n >= 1) {
+    const list = ordered(data);
+    if (n <= list.length) return list[n - 1];
+  }
+  return null;
+}
+
+function add(title, cwd = process.cwd()) {
+  const t = (title || '').trim();
+  if (!t) return null;
+  const data = load(cwd);
+  const id = 'n' + Date.now().toString(36).slice(-4) + Math.random().toString(36).slice(2, 4);
+  const now = new Date().toISOString();
+  const item = { id, title: t.slice(0, 200), state: 'next', created: now, updated: now };
+  data.items.push(item);
+  save(data, cwd);
+  return item;
+}
+
+function setState(ref, state, cwd = process.cwd()) {
+  if (!STATES.includes(state)) return null;
+  const data = load(cwd);
+  const item = resolve(data, ref);
+  if (!item) return null;
+  item.state = state;
+  item.updated = new Date().toISOString();
+  if (state === 'done') item.done = item.updated;
+  save(data, cwd);
+  return item;
+}
+
+function remove(ref, cwd = process.cwd()) {
+  const data = load(cwd);
+  const item = resolve(data, ref);
+  if (!item) return null;
+  data.items = data.items.filter(it => it.id !== item.id);
+  save(data, cwd);
+  return item;
+}
+
+/** Counts by state — for status/banner summaries. */
+function counts(cwd = process.cwd()) {
+  const { items } = load(cwd);
+  return {
+    now: items.filter(i => i.state === 'now').length,
+    next: items.filter(i => i.state === 'next').length,
+    done: items.filter(i => i.state === 'done').length,
+    total: items.length,
+  };
+}
+
+module.exports = { STATES, load, save, ordered, resolve, add, setState, remove, counts, nextFile };

package/lib/packs.js

@@ -0,0 +1,127 @@
+// phewsh packs — an opt-in gateway to proven AI-workflow enhancements.
+//
+// phewsh's core is project truth + continuity + record. It is NOT a grab-bag of
+// every viral CLAUDE.md. But good ideas exist out there, and phewsh is a natural
+// front door to them — IF they stay optional, attributed, and reversible. So:
+//   • Nothing is vendored or injected by default (never in ambient/first-run).
+//   • `phewsh pack install <name>` shows the source + license + a diff preview
+//     and asks before writing.
+//   • `phewsh pack remove <name>` cleanly reverses it (marked block only).
+//
+// Two kinds of pack:
+//   • vendored — phewsh writes a clearly-marked block into the project's agent
+//     files (e.g. Karpathy's coding guidelines into CLAUDE.md/AGENTS.md).
+//   • linked   — phewsh doesn't vendor it; it points you at the upstream
+//     installer (e.g. GSD is its own tool — we hand you its command).
+
+const fs = require('fs');
+const path = require('path');
+
+const KARPATHY_GUIDELINES = `## Coding guidelines
+**Tradeoff:** these bias toward caution over speed. For trivial tasks, use judgment.
+
+### 1. Think before coding
+State assumptions explicitly; if uncertain, ask. If multiple interpretations exist, present them — don't pick silently. If a simpler approach exists, say so. If something's unclear, stop and name it.
+
+### 2. Simplicity first
+Minimum code that solves the problem, nothing speculative. No features beyond what was asked, no abstractions for single-use code, no error handling for impossible cases. If 200 lines could be 50, rewrite. Ask: "would a senior engineer call this overcomplicated?"
+
+### 3. Surgical changes
+Touch only what you must. Don't "improve" adjacent code, don't refactor what isn't broken, match existing style. Remove only the orphans YOUR change created; mention pre-existing dead code, don't delete it. Every changed line should trace to the request.
+
+### 4. Goal-driven execution
+Turn tasks into verifiable goals ("add validation" → "write tests for invalid inputs, then make them pass"). For multi-step work, state a brief plan with a verify step each. Strong success criteria let you loop independently.
+
+**Working if:** fewer unnecessary diffs, fewer rewrites from overcomplication, and clarifying questions come before mistakes, not after.`;
+
+const PACKS = {
+  'karpathy-style': {
+    kind: 'vendored',
+    title: 'Karpathy-style coding guidelines',
+    desc: 'Behavioral guidelines that reduce common LLM coding mistakes (think-before-coding, simplicity, surgical changes, goal-driven loops).',
+    source: "Andrej Karpathy's CLAUDE.md · github.com/multica-ai/andrej-karpathy-skills",
+    license: 'review the source repo for license before redistributing',
+    targets: ['CLAUDE.md', 'AGENTS.md'],
+    content: KARPATHY_GUIDELINES,
+  },
+  gsd: {
+    kind: 'linked',
+    title: 'GSD — Get Shit Done',
+    desc: 'A Claude-centric workflow augmentation (hooks, commands, planning). Its own tool — phewsh just points you at it; it is not vendored.',
+    source: 'github.com/gsd-build/get-shit-done',
+    license: 'see the GSD repo',
+    install: 'npx @gsd-build/get-shit-done init   # follow the GSD repo for current instructions',
+  },
+};
+
+function markers(name) {
+  return { start: `<!-- phewsh-pack:${name} START -->`, end: `<!-- phewsh-pack:${name} END -->` };
+}
+
+function blockFor(name, pack) {
+  const m = markers(name);
+  const header = `# ${pack.title} (phewsh pack: ${name})\n`
+    + `> Source: ${pack.source}\n`
+    + `> Opt-in via \`phewsh pack install ${name}\` · remove: \`phewsh pack remove ${name}\`\n\n`;
+  return `${m.start}\n${header}${pack.content}\n${m.end}`;
+}
+
+function isInstalled(name, cwd = process.cwd()) {
+  const pack = PACKS[name];
+  if (!pack || pack.kind !== 'vendored') return false;
+  return pack.targets.some(f => {
+    try { return fs.readFileSync(path.join(cwd, f), 'utf-8').includes(markers(name).start); }
+    catch { return false; }
+  });
+}
+
+// Returns the files it WOULD write to + the block, without writing — for preview.
+function previewInstall(name, cwd = process.cwd()) {
+  const pack = PACKS[name];
+  if (!pack || pack.kind !== 'vendored') return null;
+  return { files: pack.targets, block: blockFor(name, pack) };
+}
+
+function install(name, cwd = process.cwd()) {
+  const pack = PACKS[name];
+  if (!pack || pack.kind !== 'vendored') return { written: [] };
+  const block = blockFor(name, pack);
+  const m = markers(name);
+  const written = [];
+  for (const f of pack.targets) {
+    const fp = path.join(cwd, f);
+    let existing = '';
+    try { existing = fs.readFileSync(fp, 'utf-8'); } catch { /* new file */ }
+    if (existing.includes(m.start)) {
+      // refresh in place
+      const re = new RegExp(escapeRe(m.start) + '[\\s\\S]*?' + escapeRe(m.end));
+      fs.writeFileSync(fp, existing.replace(re, block));
+    } else {
+      fs.writeFileSync(fp, (existing ? existing.replace(/\s*$/, '') + '\n\n' : '') + block + '\n');
+    }
+    written.push(f);
+  }
+  return { written };
+}
+
+function remove(name, cwd = process.cwd()) {
+  const pack = PACKS[name];
+  if (!pack || pack.kind !== 'vendored') return { removed: [] };
+  const m = markers(name);
+  const removed = [];
+  for (const f of pack.targets) {
+    const fp = path.join(cwd, f);
+    try {
+      const existing = fs.readFileSync(fp, 'utf-8');
+      if (!existing.includes(m.start)) continue;
+      const re = new RegExp('\\n*' + escapeRe(m.start) + '[\\s\\S]*?' + escapeRe(m.end) + '\\n*', 'g');
+      fs.writeFileSync(fp, existing.replace(re, '\n').replace(/\n{3,}/g, '\n\n').replace(/^\n+/, ''));
+      removed.push(f);
+    } catch { /* not there */ }
+  }
+  return { removed };
+}
+
+function escapeRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+module.exports = { PACKS, install, remove, isInstalled, previewInstall, blockFor };

package/lib/record.js

@@ -0,0 +1,47 @@
+// "Record" — the human-authored side of one of the four words
+// (Project · Next · Work · Record). `phewsh remember "<x>"` appends a dated
+// line to `.intent/decisions.md` so a decision or lesson sticks and travels
+// with the repo — every AI tool reads it as project truth. Zero-AI: a person
+// alone can jot WHY they did something, and the next session (human or model)
+// inherits it. The auto-captured ledger (~/.phewsh/outcomes) is separate: that
+// is routed actions labeled kept/reverted; this is what you chose to remember.
+
+const fs = require('fs');
+const path = require('path');
+
+const LINE_RE = /^- \d{4}-\d{2}-\d{2} — /;
+
+function recordFile(cwd = process.cwd()) {
+  return path.join(cwd, '.intent', 'decisions.md');
+}
+
+function remember(text, cwd = process.cwd()) {
+  const t = (text || '').trim();
+  if (!t) return null;
+  const fp = recordFile(cwd);
+  const date = new Date().toISOString().slice(0, 10);
+  const line = `- ${date} — ${t.replace(/\s+/g, ' ')}\n`;
+  try {
+    fs.mkdirSync(path.dirname(fp), { recursive: true });
+    if (!fs.existsSync(fp)) {
+      fs.writeFileSync(fp, '# Decisions\n\n> What we decided and why — append-only. Captured with `phewsh remember "…"`.\n\n' + line);
+    } else {
+      const existing = fs.readFileSync(fp, 'utf-8');
+      fs.writeFileSync(fp, existing.replace(/\n*$/, '\n') + line);
+    }
+    return { date, text: t };
+  } catch {
+    return null;
+  }
+}
+
+/** The remembered lines, oldest first. */
+function notes(cwd = process.cwd()) {
+  try {
+    return fs.readFileSync(recordFile(cwd), 'utf-8').split('\n').filter(l => LINE_RE.test(l));
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { remember, notes, recordFile };

package/lib/shims.js

@@ -127,8 +127,10 @@ function preflightBanner(bin, cwd = process.cwd()) {
       const d = statusDrift(cwd);
       if (d && d.tracked && d.commitsSince > 0) record = `${d.commitsSince} behind`;
     } catch { /* nicety */ }
-    const continuity = decisionCount(cwd) >= 1 ? 'healthy' : 'building';
-    return `${C.sage('😮‍💨 phewsh')} ${C.teal('✓')}  ${C.slate('intent: ' + files + ' files · record: ' + record + ' · continuity: ' + continuity)}  ${C.slate('· phewsh status → ' + bin)}`;
+    let nextBit = '';
+    try { const c = require('./next').counts(cwd); if (c.now + c.next > 0) nextBit = ' · next: ' + (c.now + c.next) + ' open'; } catch { /* nicety */ }
+    // The four words, compact: Project · Next · Record (Work = this launch).
+    return `${C.sage('😮‍💨 phewsh')} ${C.teal('✓')}  ${C.slate('project: ' + files + ' files' + nextBit + ' · record: ' + record)}  ${C.slate('· phewsh status → ' + bin)}`;
   } catch {
     return `😮‍💨🤫 phewsh active · → ${bin}`; // never break the launch
   }

package/lib/suggest.js

@@ -40,6 +40,7 @@ function suggestAll(s = {}) {
     ambientOn = false,
     shimOn = false,
     commitsSinceIntent = 0,
+    packsInstalled = false,  // any opt-in workflow pack present in cwd
     bestKeeper = null,   // { route, label, keptRate, total } from the record, or null
   } = s;
 
@@ -145,6 +146,19 @@ function suggestAll(s = {}) {
     });
   }
 
+  // 7. Workflow packs — lowest-leverage convenience, surfaced only once the
+  // moat work (intent, outcomes, ambient, shim) is handled. phewsh core stays
+  // continuity; packs are opt-in, attributed schools of thought you can add.
+  if (hasIntentDir && !packsInstalled && turnsThisSession >= 2) {
+    out.push({
+      id: 'try-packs',
+      priority: 22,
+      message: `One continuity layer, many schools of thought — add an opt-in workflow pack (Karpathy, GSD…).`,
+      command: '/pack',
+      why: 'Attributed, reversible, project-scoped. Browse with /pack; nothing is injected without your y/N.',
+    });
+  }
+
   return out.sort((a, b) => b.priority - a.priority);
 }
 

package/lib/work.js

@@ -0,0 +1,105 @@
+// "Work" — the read-only view for the fourth plain word
+// (Project · Next · Work · Record). This is a DERIVED aggregator, not a new
+// store: it reads state that already exists and answers, in one glance, "what's
+// happening right now?" No automation, no loop runner, no persistence. Work is
+// made *visible* here; bounding and running it is a later, separate phase
+// (see .intent/work-layer.md — the design fence).
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function projectSummary(cwd) {
+  const intentDir = path.join(cwd, '.intent');
+  const present = fs.existsSync(intentDir);
+  let name = path.basename(cwd);
+  try {
+    const m = JSON.parse(fs.readFileSync(path.join(intentDir, 'project.json'), 'utf-8'));
+    if (m && m.name) name = m.name;
+  } catch { /* fall back to dir name */ }
+  let tagline = null;
+  try {
+    const v = fs.readFileSync(path.join(intentDir, 'vision.md'), 'utf-8');
+    const m = v.match(/##\s*North Star\s*\n+([^\n]+)/);
+    if (m) tagline = m[1].trim().replace(/\.+$/, '').slice(0, 120);
+  } catch { /* no tagline */ }
+  return { present, name, tagline };
+}
+
+function nextSummary(cwd) {
+  try {
+    const nx = require('./next');
+    const items = nx.ordered(nx.load(cwd));
+    const now = items.find(i => i.state === 'now') || null;
+    const queued = items.filter(i => i.state === 'next');
+    return { now: now ? now.title : null, queuedCount: queued.length, topQueued: queued[0] ? queued[0].title : null };
+  } catch { return { now: null, queuedCount: 0, topQueued: null }; }
+}
+
+function loadDecisions() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(os.homedir(), '.phewsh', 'outcomes', 'decisions.json'), 'utf-8'));
+  } catch { return []; }
+}
+
+function workSummary(cwd) {
+  // No reliable standalone "current tool" detection exists, so derive from the
+  // continuity thread: who acted last for this project, and how recently.
+  // "active" = recent enough to look like a live session.
+  try {
+    const continuity = require('./continuity');
+    const project = path.basename(cwd);
+    const last = continuity.lastLeftOff(loadDecisions(), { project });
+    if (!last || !last.ts) return { tool: null, active: false, lastAgo: null };
+    let tool = null;
+    try { tool = continuity.labelFor(last.route); } catch { tool = last.route || null; }
+    const ageMs = Date.now() - new Date(last.ts).getTime();
+    const active = Number.isFinite(ageMs) && ageMs >= 0 && ageMs < 15 * 60 * 1000;
+    return { tool, active, lastAgo: continuity.agoText(last.ts) };
+  } catch { return { tool: null, active: false, lastAgo: null }; }
+}
+
+function recordSummary(cwd) {
+  // Prefer a human-remembered decision; fall back to the latest routed decision.
+  try {
+    const ns = require('./record').notes(cwd);
+    if (ns.length) {
+      const latest = ns[ns.length - 1].replace(/^- \d{4}-\d{2}-\d{2} — /, '');
+      return { latest, source: 'remembered' };
+    }
+  } catch { /* none */ }
+  try {
+    const { recentDecisions } = require('./outcomes');
+    const r = recentDecisions(1, { project: path.basename(cwd) });
+    if (r.length && r[0].summary) return { latest: r[0].summary, source: 'decision' };
+  } catch { /* none */ }
+  return { latest: null, source: null };
+}
+
+function reviewSummary(cwd) {
+  // "Does anything appear to need a human?" — derived from existing signals only.
+  const needs = [];
+  try {
+    const { outcomeStats } = require('./outcomes');
+    const s = outcomeStats({ project: path.basename(cwd) });
+    if (s.pending > 0) needs.push(`${s.pending} decision${s.pending === 1 ? '' : 's'} to label — phewsh outcomes`);
+  } catch { /* none */ }
+  try {
+    const drift = require('./selfheal').commitsSinceIntent(cwd);
+    if (drift > 0) needs.push(`intent is ${drift} commit${drift === 1 ? '' : 's'} behind the code — reconcile`);
+  } catch { /* none */ }
+  return { needs, clear: needs.length === 0 };
+}
+
+/** The whole read-only view. Pure aggregation over existing state. */
+function workView(cwd = process.cwd()) {
+  return {
+    project: projectSummary(cwd),
+    next: nextSummary(cwd),
+    work: workSummary(cwd),
+    record: recordSummary(cwd),
+    review: reviewSummary(cwd),
+  };
+}
+
+module.exports = { workView };

package/package.json

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