phewsh 0.14.1 → 0.14.3

package/bin/phewsh.js

@@ -7,7 +7,7 @@ const command = args[0];
 const b  = (s) => `\x1b[1m${s}\x1b[0m`;   // bold
 const d  = (s) => `\x1b[2m${s}\x1b[0m`;   // dim
 const w  = (s) => `\x1b[97m${s}\x1b[0m`;  // bright white
-const g  = (s) => `\x1b[38;2;152;164;158m${s}\x1b[0m`;  // slate (matches ui.js)
+const g  = (s) => `\x1b[38;5;247m${s}\x1b[0m`;  // slate, 256-color (matches ui.js — 24-bit breaks Apple Terminal)
 const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 

package/commands/receipts.js

@@ -21,7 +21,7 @@ const { gatherReceipts } = require('../lib/receipts-data');
 const b = (s) => `\x1b[1m${s}\x1b[0m`;
 const d = (s) => `\x1b[2m${s}\x1b[0m`;
 const w = (s) => `\x1b[97m${s}\x1b[0m`;
-const g = (s) => `\x1b[38;2;130;142;138m${s}\x1b[0m`;
+const g = (s) => `\x1b[38;5;247m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 const red = (s) => `\x1b[31m${s}\x1b[0m`;

package/commands/session.js

@@ -11,7 +11,8 @@ const ui = require('../lib/ui');
 
 const CONFIG_DIR = path.join(os.homedir(), '.phewsh');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
-const INTENT_DIR = path.join(process.cwd(), '.intent');
+// Dynamic — the session can chdir into a project from the root bootstrap
+const intentDir = () => path.join(process.cwd(), '.intent');
 
 const { select, refreshSession: refreshSess } = require('../lib/supabase');
 const { readPPS } = require('../lib/pps');
@@ -19,6 +20,7 @@ const { push, pull, ensureValidToken } = require('./sync');
 const { HARNESSES, listHarnesses, runViaHarness } = require('../lib/harnesses');
 const { recordDecision, labelOutcome, pendingDecisions, outcomeStats, OUTCOMES } = require('../lib/outcomes');
 const { recordSessionEvent } = require('../lib/receipts-data');
+const { recordProject, listProjects, scanForProjects, fmtAgo } = require('../lib/projects-index');
 
 // Brand palette shortcuts
 const { b, d, w, g, green, cyan, yellow,
@@ -27,13 +29,13 @@ const { b, d, w, g, green, cyan, yellow,
 // Sync awareness: compare local .intent/ timestamps with cloud updated_at
 async function checkSyncStatus(config) {
   if (!config?.supabaseUserId || !config?.supabaseAccessToken) return null;
-  if (!fs.existsSync(INTENT_DIR)) return null;
+  if (!fs.existsSync(intentDir())) return null;
 
   try {
     const token = await ensureValidToken(config);
     if (!token) return null;
 
-    const pps = readPPS(INTENT_DIR);
+    const pps = readPPS(intentDir());
     const cloudId = pps?.adapters?.phewsh?.cloud_id;
     const projectName = path.basename(process.cwd());
 
@@ -59,7 +61,7 @@ async function checkSyncStatus(config) {
     const localFiles = ['vision.md', 'plan.md', 'next.md'];
     let latestLocal = 0;
     for (const file of localFiles) {
-      const filePath = path.join(INTENT_DIR, file);
+      const filePath = path.join(intentDir(), file);
       if (fs.existsSync(filePath)) {
         const mtime = fs.statSync(filePath).mtimeMs;
         if (mtime > latestLocal) latestLocal = mtime;
@@ -154,7 +156,7 @@ function loadIntentContext() {
   const files = ['vision.md', 'plan.md', 'next.md'];
   const loaded = [];
   for (const file of files) {
-    const p = path.join(INTENT_DIR, file);
+    const p = path.join(intentDir(), file);
     if (fs.existsSync(p)) {
       loaded.push({ file, content: fs.readFileSync(p, 'utf-8') });
     }
@@ -255,7 +257,12 @@ async function main() {
   let intentFiles = loadIntentContext();
   let systemPrompt = buildSystemPrompt(intentFiles);
   const messages = [];
-  const projectName = path.basename(process.cwd());
+  let projectName = path.basename(process.cwd());
+
+  // Index this project so `phewsh` from anywhere can offer it as a recent
+  if (intentFiles.length > 0) {
+    try { recordProject(process.cwd()); } catch { /* index is best-effort */ }
+  }
   let currentModel = DEFAULT_MODEL;
   let totalPromptTokens = 0;
   let totalCompletionTokens = 0;
@@ -267,6 +274,7 @@ async function main() {
   let sessionMode = null;          // INTENT_MODES id once picked
   let awaitingOutcome = null;      // decision id eligible for 1-4 labeling
   let awaitingFallback = null;     // { input, fullSystem, options } after a route failure
+  let bootstrapChoices = null;     // root-bootstrap menu entries when no project here
   let decisionsThisSession = 0;
 
   // ── The Exhale: animated brand reveal ──────────────────
@@ -283,6 +291,21 @@ async function main() {
   // PROJECT what am I in · ROUTE where typing goes · BACKUP what's ready if
   // the route hits a wall · WEB am I mirrored · RECORD what's accumulated
   let syncState = null;
+  const row = (label, value) => console.log(`  ${slate(label.padEnd(9))}${value}`);
+
+  // realpath both sides — macOS /tmp and /var are symlinks into /private
+  const realPath = (p) => { try { return fs.realpathSync(p); } catch { return path.resolve(p); } };
+  const tildify = (p) => {
+    const home = realPath(os.homedir());
+    const rp = realPath(p);
+    return rp.startsWith(home) ? '~' + rp.slice(home.length) : p;
+  };
+  let atHome = false;
+  let recents = [];
+
+  // Fail-soft render: corrupt data or a network hiccup may cost a row —
+  // it must never kill the session.
+  try {
   if (config?.supabaseUserId && intentFiles.length > 0) {
     syncState = await Promise.race([
       checkSyncStatus(config),
@@ -290,11 +313,19 @@ async function main() {
     ]);
   }
 
-  const row = (label, value) => console.log(`  ${slate(label.padEnd(9))}${value}`);
+  atHome = realPath(process.cwd()) === realPath(os.homedir());
+  recents = intentFiles.length === 0
+    ? listProjects().filter(p => realPath(p.path) !== realPath(process.cwd())).slice(0, 3)
+    : [];
 
-  row('PROJECT', cream(projectName) + (intentFiles.length > 0
-    ? slate(' · ') + teal('●') + sage(` .intent/ ${intentFiles.length} file${intentFiles.length !== 1 ? 's' : ''}`)
-    : slate(' · no memory yet — ') + sage('/init')));
+  if (intentFiles.length > 0) {
+    row('PROJECT', cream(projectName) + slate(' · ') + teal('●')
+      + sage(` .intent/ ${intentFiles.length} file${intentFiles.length !== 1 ? 's' : ''}`));
+  } else if (atHome || recents.length > 0) {
+    row('PROJECT', slate('none here — your projects are listed below'));
+  } else {
+    row('PROJECT', cream(projectName) + slate(' · no memory yet — ') + sage('/init'));
+  }
 
   row('ROUTE', route
     ? cream(routeLabel(route, config)) + (route.type === 'harness' ? slate(' · no API key needed') : '')
@@ -310,11 +341,29 @@ async function main() {
     : slate('none — install Codex or Gemini to cover usage limits'));
 
   if (config?.supabaseUserId) {
+    // Cloud project count, best-effort with a hard 2s budget — the cockpit
+    // never blocks on the network.
+    let cloudCount = null;
+    try {
+      const token = await Promise.race([
+        ensureValidToken(config),
+        new Promise(r => setTimeout(() => r(null), 2000)),
+      ]);
+      if (token) {
+        const rows = await Promise.race([
+          select('projects', `user_id=eq.${config.supabaseUserId}&select=id`, token),
+          new Promise(r => setTimeout(() => r(null), 2000)),
+        ]);
+        if (Array.isArray(rows)) cloudCount = rows.length;
+      }
+    } catch { /* offline — cockpit still renders */ }
+
     const syncLabel = syncState?.status === 'synced' ? teal('↕ ') + sage('mirrored')
       : syncState?.status === 'cloud-newer' ? ember('↓ ') + sage(`cloud newer (${syncState.ago}) — /pull`)
       : syncState?.status === 'local-newer' ? ember('↑ ') + sage('local ahead — /push')
       : sage('linked');
-    row('WEB', cream(config.email || 'logged in') + slate(' · ') + syncLabel);
+    row('WEB', cream(config.email || 'logged in') + slate(' · ') + syncLabel
+      + (cloudCount !== null ? slate(' · ') + sage(`${cloudCount} cloud project${cloudCount !== 1 ? 's' : ''}`) : ''));
   } else {
     row('WEB', sage('local-only (works fine)') + slate(' · /login mirrors this at phewsh.com/intent'));
   }
@@ -328,6 +377,57 @@ async function main() {
   } else {
     row('RECORD', slate('empty — decisions and outcomes accumulate as you work'));
   }
+  } catch (cockpitErr) {
+    console.log(`  ${slate('(cockpit row unavailable — ' + cockpitErr.message + ' · PHEWSH_DEBUG=1 phewsh for details)')}`);
+    if (process.env.PHEWSH_DEBUG) console.error(cockpitErr.stack);
+  }
+
+  // Chat-routable options as they exist on THIS machine — every usage hint
+  // derives from this so /use, /provider, and reality never disagree.
+  function useOptions() {
+    const opts = harnesses.filter(h => h.installed && h.headless).map(h => h.id);
+    if (config?.apiKey) opts.push('api');
+    return opts;
+  }
+
+  function showModeMenu() {
+    console.log(`  ${b(cream('What are you trying to do?'))}`);
+    console.log(`  ${teal('1')} ${sage('Build')}  ${slate('·')}  ${teal('2')} ${sage('Research')}  ${slate('·')}  ${teal('3')} ${sage('Decide')}  ${slate('·')}  ${teal('4')} ${sage('Review')}  ${slate('·')}  ${teal('5')} ${sage('Ask another model')}`);
+    console.log(`  ${slate('pick a number, or just type — your context travels with every route')}`);
+  }
+
+  // Open a known project from the bootstrap menu: chdir, reload memory,
+  // back to the normal flow. The session is the cockpit; projects swap in.
+  function openProjectAt(dir) {
+    try { process.chdir(dir); } catch (err) {
+      console.log(`  ${ember('!')} ${sage('Could not open ' + dir + ': ' + err.message)}`);
+      return;
+    }
+    projectName = path.basename(dir);
+    intentFiles = loadIntentContext();
+    systemPrompt = buildSystemPrompt(intentFiles);
+    try { recordProject(dir); } catch { /* best-effort */ }
+    bootstrapChoices = null;
+    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('');
+    showModeMenu();
+    console.log('');
+  }
+
+  function showBootstrapMenu(projects) {
+    console.log(`  ${b(cream('Where do you want to work?'))}`);
+    bootstrapChoices = [];
+    for (const p of projects) {
+      bootstrapChoices.push({ kind: 'open', path: p.path });
+      console.log(`  ${teal(String(bootstrapChoices.length))} ${cream(p.name)} ${slate('— ' + fmtAgo(p.lastOpened) + ' · ' + tildify(p.path))}`);
+    }
+    bootstrapChoices.push({ kind: 'init' });
+    const initN = bootstrapChoices.length;
+    bootstrapChoices.push({ kind: 'scan' });
+    console.log(`  ${teal(String(initN))} ${sage('Start a project here')} ${slate('(/init)')}  ${slate('·')}  ${teal(String(initN + 1))} ${sage('Scan my folders for projects')}`);
+    console.log(`  ${slate('pick a number, or just type to chat — no project required')}`);
+  }
 
   console.log('');
   if (!route) {
@@ -340,10 +440,10 @@ async function main() {
     console.log(`    ${teal('/key')}    ${sage('Set an API key (10 seconds)')}`);
     console.log(`    ${teal('/tour')}   ${sage('See what this does (nothing needed)')}`);
     console.log(`  ${slate('Or install Claude Code / Codex — phewsh uses their login automatically.')}`);
+  } else if (intentFiles.length === 0 && (atHome || recents.length > 0)) {
+    showBootstrapMenu(recents);
   } else {
-    console.log(`  ${b(cream('What are you trying to do?'))}`);
-    console.log(`  ${teal('1')} ${sage('Build')}  ${slate('·')}  ${teal('2')} ${sage('Research')}  ${slate('·')}  ${teal('3')} ${sage('Decide')}  ${slate('·')}  ${teal('4')} ${sage('Review')}  ${slate('·')}  ${teal('5')} ${sage('Ask another model')}`);
-    console.log(`  ${slate('pick a number, or just type — your context travels with every route')}`);
+    showModeMenu();
   }
   console.log('');
 
@@ -493,6 +593,59 @@ async function main() {
       return;
     }
 
+    // Root bootstrap: a bare number opens a project, inits, or scans
+    if (bootstrapChoices && messages.length === 0 && /^[0-9]{1,2}$/.test(input)) {
+      const choice = bootstrapChoices[parseInt(input, 10) - 1];
+      if (!choice) {
+        console.log(`  ${sage('Pick 1-' + bootstrapChoices.length)}`);
+        rl.prompt();
+        return;
+      }
+      if (choice.kind === 'open') {
+        openProjectAt(choice.path);
+        rl.prompt();
+        return;
+      }
+      if (choice.kind === 'init') {
+        bootstrapChoices = null;
+        try {
+          const { execSync } = require('child_process');
+          execSync('node ' + path.join(__dirname, 'intent.js') + ' --init', { stdio: 'inherit' });
+          intentFiles = loadIntentContext();
+          systemPrompt = buildSystemPrompt(intentFiles);
+          if (intentFiles.length > 0) {
+            try { recordProject(process.cwd()); } catch { /* best-effort */ }
+            console.log(`  ${teal('●')} ${sage('Project started — context loaded:')} ${cream(intentFiles.map(f => f.file).join(', '))}`);
+          }
+        } catch (err) {
+          console.error(`  ${ember('!')} ${sage('Init failed:')} ${err.message}`);
+        }
+        console.log('');
+        rl.prompt();
+        return;
+      }
+      if (choice.kind === 'scan') {
+        const spin = ui.spinner('scanning your usual folders');
+        const found = scanForProjects();
+        spin.stop();
+        if (found.length === 0) {
+          bootstrapChoices = null;
+          console.log(`  ${sage('No .intent/ projects found in the usual folders.')}`);
+          console.log(`  ${slate('cd into a project and run phewsh, or /init to start one here.')}`);
+        } else {
+          console.log(`  ${teal('●')} ${sage(`Found ${found.length} project${found.length !== 1 ? 's' : ''}:`)}`);
+          bootstrapChoices = found.map(p => ({ kind: 'open', path: p.path }));
+          found.forEach((p, i) => {
+            console.log(`  ${teal(String(i + 1))} ${cream(p.name)} ${slate('· ' + tildify(p.path))}`);
+          });
+          console.log(`  ${slate('pick a number to open it')}`);
+        }
+        console.log('');
+        rl.prompt();
+        return;
+      }
+    }
+
     // A bare 1-5 on an empty conversation picks an intent mode
     if (messages.length === 0 && !awaitingOutcome && /^[1-5]$/.test(input)) {
       const n = parseInt(input, 10);
@@ -569,6 +722,7 @@ async function main() {
         console.log(`    ${teal('/use')} ${slate('<route>')}  ${sage('Switch: claude-code, codex, gemini, cursor, opencode, api')}`);
         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('');
         console.log(`  ${cream('session')}`);
@@ -669,7 +823,7 @@ async function main() {
       }
 
       if (cmd === 'init') {
-        if (fs.existsSync(path.join(INTENT_DIR, 'vision.md'))) {
+        if (fs.existsSync(path.join(intentDir(), 'vision.md'))) {
           console.log(`\n  ${sage('.intent/ already exists in')} ${slate(process.cwd())}`);
           console.log(`  ${sage('Use /reload to refresh context')}\n`);
         } else {
@@ -956,22 +1110,49 @@ async function main() {
           ['Route', routeLabel(route, config), 'green'],
         ];
         for (const h of harnesses) {
-          rows.push([h.label, h.installed ? `installed (${h.auth})` : 'not installed', h.installed ? 'green' : undefined]);
+          if (!h.installed && !['aider', 'goose', 'amp', 'droid'].includes(h.id)) {
+            rows.push([h.label, 'not installed']);
+            continue;
+          }
+          if (!h.installed) continue; // hide the long tail of uninstalled extras
+          const via = h.headless ? '' : ' · /work only';
+          rows.push([h.label, `ready — ${h.role}${via}`, 'green']);
         }
         rows.push(['API key', config?.apiKey ? config.apiKey.slice(0, 8) + '... (' + (config.provider || 'anthropic') + ')' : 'not set — optional', config?.apiKey ? 'green' : 'yellow']);
-        rows.push(['Fallback', config?.fallback === 'auto' ? 'auto-switch on failure' : 'ask before switching', 'peach']);
+        rows.push(['Fallback', (config?.fallback === 'auto' ? 'auto-switch on failure' : 'ask before switching') + ' — /fallback to change', 'peach']);
         if (route?.type === 'api') rows.push(['Model', MODELS[currentModel].name, 'cyan']);
         ui.statusPanel('Provider', rows);
-        console.log(`  ${slate('switch:')} ${cream('/use <' + harnesses.filter(h => h.installed).map(h => h.id).concat(config?.apiKey ? ['api'] : []).join('|') + '>')}`);
+        console.log(`  ${sage('One terminal. Every AI worker. Shared project memory.')}`);
+        console.log(`  ${slate('switch:')} ${cream('/use <' + useOptions().join('|') + '>')} ${slate('· interactive tools: /work <hermes|pi>')}`);
         console.log('');
         rl.prompt();
         return;
       }
 
+      if (cmd === 'fallback') {
+        const arg = cmdArg?.trim().toLowerCase();
+        if (arg === 'ask' || arg === 'auto') {
+          config = loadConfig() || {};
+          config.fallback = arg;
+          saveConfig(config);
+          console.log(`  ${teal('●')} ${sage('Fallback:')} ${cream(arg === 'auto' ? 'auto-switch to the next route on failure' : 'ask before switching')}`);
+          console.log(`  ${slate('either way your project context and record stay intact')}`);
+        } else {
+          console.log(`  ${sage('Fallback is')} ${cream(config?.fallback === 'auto' ? 'auto-switch' : 'ask first')} ${slate('— when your route hits a usage wall, context travels to the next one.')}`);
+          console.log(`  ${sage('Usage:')} ${cream('/fallback ask')} ${slate('·')} ${cream('/fallback auto')}`);
+        }
+        rl.prompt();
+        return;
+      }
+
       if (cmd === 'use') {
         if (!cmdArg) {
           console.log(`  ${sage('Current route:')} ${cream(routeLabel(route, config))}`);
-          console.log(`  ${sage('Usage:')} ${cream('/use <claude-code|codex|gemini|cursor|opencode|api>')}`);
+          console.log(`  ${sage('Usage:')} ${cream('/use <' + useOptions().join('|') + '>')}`);
+          const workOnlyInstalled = harnesses.filter(h => h.installed && !h.headless);
+          if (workOnlyInstalled.length > 0) {
+            console.log(`  ${slate('interactive tools: /work <' + workOnlyInstalled.map(h => h.id).join('|') + '>')}`);
+          }
           rl.prompt();
           return;
         }
@@ -1053,7 +1234,7 @@ async function main() {
       }
 
       if (cmd === 'watch') {
-        if (!fs.existsSync(INTENT_DIR)) {
+        if (!fs.existsSync(intentDir())) {
           console.log(`\n  ${ember('!')} ${sage('No .intent/ found. Run /init first.')}\n`);
           rl.prompt();
           return;
@@ -1229,5 +1410,7 @@ async function main() {
 
 main().catch(err => {
   console.error('\n  Error:', err.message);
+  if (process.env.PHEWSH_DEBUG) console.error('\n' + err.stack);
+  else console.error('  (run PHEWSH_DEBUG=1 phewsh for the full trace)');
   process.exit(1);
 });

package/commands/update.js

@@ -8,7 +8,7 @@ const { spawn } = require('child_process');
 
 const b = (s) => `\x1b[1m${s}\x1b[0m`;
 const w = (s) => `\x1b[97m${s}\x1b[0m`;
-const g = (s) => `\x1b[38;2;130;142;138m${s}\x1b[0m`;
+const g = (s) => `\x1b[38;5;247m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 

package/lib/harnesses.js

@@ -15,17 +15,17 @@ const { execSync, spawn } = require('child_process');
 // how to launch it interactively (detection + /work still fully supported —
 // never guess flags; a wrong invocation looks like phewsh being broken).
 const HARNESSES = {
-  'claude-code': { bin: 'claude',       label: 'Claude Code',  auth: 'Claude subscription / Console', args: (p) => ['-p', p, '--output-format', 'text'] },
-  'codex':       { bin: 'codex',        label: 'Codex CLI',    auth: 'ChatGPT plan',                  args: (p) => ['exec', p] },
-  'gemini':      { bin: 'gemini',       label: 'Gemini CLI',   auth: 'Google login',                  args: (p) => ['-p', p] },
-  'cursor':      { bin: 'cursor-agent', label: 'Cursor Agent', auth: 'Cursor account',                args: (p) => ['-p', p, '--output-format', 'text'] },
-  'opencode':    { bin: 'opencode',     label: 'OpenCode',     auth: 'OpenCode Zen / configured',     args: (p) => ['run', p] },
-  'hermes':      { bin: 'hermes',       label: 'Hermes',       auth: 'Nous account',                  args: null },
-  'pi':          { bin: 'pi',           label: 'Pi',           auth: 'Pi login',                      args: null },
-  'aider':       { bin: 'aider',        label: 'Aider',        auth: 'configured keys',               args: (p) => ['--message', p] },
-  'goose':       { bin: 'goose',        label: 'Goose',        auth: 'Block / configured',            args: (p) => ['run', '-t', p] },
-  'amp':         { bin: 'amp',          label: 'Amp',          auth: 'Sourcegraph account',           args: (p) => ['-x', p] },
-  'droid':       { bin: 'droid',        label: 'Droid',        auth: 'Factory account',               args: (p) => ['exec', p] },
+  'claude-code': { bin: 'claude',       label: 'Claude Code',  role: 'writes code',          auth: 'Claude subscription / Console', args: (p) => ['-p', p, '--output-format', 'text'] },
+  'codex':       { bin: 'codex',        label: 'Codex CLI',    role: 'reasons & reviews',    auth: 'ChatGPT plan',                  args: (p) => ['exec', p] },
+  'gemini':      { bin: 'gemini',       label: 'Gemini CLI',   role: "another model's take", auth: 'Google login',                  args: (p) => ['-p', p] },
+  'cursor':      { bin: 'cursor-agent', label: 'Cursor Agent', role: 'edits files',          auth: 'Cursor account',                args: (p) => ['-p', p, '--output-format', 'text'] },
+  'opencode':    { bin: 'opencode',     label: 'OpenCode',     role: 'general agent',        auth: 'OpenCode Zen / configured',     args: (p) => ['run', p] },
+  'hermes':      { bin: 'hermes',       label: 'Hermes',       role: 'runs loops',           auth: 'Nous account',                  args: null },
+  'pi':          { bin: 'pi',           label: 'Pi',           role: 'conversation',         auth: 'Pi login',                      args: null },
+  'aider':       { bin: 'aider',        label: 'Aider',        role: 'pair-codes',           auth: 'configured keys',               args: (p) => ['--message', p] },
+  'goose':       { bin: 'goose',        label: 'Goose',        role: 'automates tasks',      auth: 'Block / configured',            args: (p) => ['run', '-t', p] },
+  'amp':         { bin: 'amp',          label: 'Amp',          role: 'agentic coding',       auth: 'Sourcegraph account',           args: (p) => ['-x', p] },
+  'droid':       { bin: 'droid',        label: 'Droid',        role: 'agentic coding',       auth: 'Factory account',               args: (p) => ['exec', p] },
 };
 
 function isInstalled(id) {

package/lib/outcomes.js

@@ -19,7 +19,11 @@ const DECISIONS_FILE = path.join(OUTCOMES_DIR, 'decisions.json');
 const OUTCOMES = ['kept', 'reverted', 'superseded', 'failed'];
 
 function load() {
-  try { return JSON.parse(fs.readFileSync(DECISIONS_FILE, 'utf-8')); } catch { return []; }
+  // Array-or-nothing: a corrupt/odd-shaped file must degrade, never throw
+  try {
+    const d = JSON.parse(fs.readFileSync(DECISIONS_FILE, 'utf-8'));
+    return Array.isArray(d) ? d : [];
+  } catch { return []; }
 }
 
 function save(decisions) {
@@ -122,7 +126,10 @@ const BYPASS_REASONS = [
 ];
 
 function loadBypasses() {
-  try { return JSON.parse(fs.readFileSync(BYPASSES_FILE, 'utf-8')); } catch { return []; }
+  try {
+    const d = JSON.parse(fs.readFileSync(BYPASSES_FILE, 'utf-8'));
+    return Array.isArray(d) ? d : [];
+  } catch { return []; }
 }
 
 function recordBypass(reason, note = '') {

package/lib/projects-index.js

@@ -0,0 +1,95 @@
+// Local project index — how phewsh knows your projects from anywhere.
+//
+// Every session opened in a project (or created via /init) records it here,
+// so running `phewsh` at machine root becomes mission-control bootstrap
+// ("where do you want to work?") instead of "no project found, goodbye."
+//
+// Storage: ~/.phewsh/projects.json. Local-first; web sync layers on top.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const INDEX_FILE = path.join(os.homedir(), '.phewsh', 'projects.json');
+
+// Shallow-scanned roots when the user asks to find projects. One level deep,
+// opt-in only — deep-scanning someone's machine uninvited is invasive.
+const SCAN_ROOTS = [
+  path.join(os.homedir(), 'Documents', 'GitHub'),
+  path.join(os.homedir(), 'Projects'),
+  path.join(os.homedir(), 'projects'),
+  path.join(os.homedir(), 'repos'),
+  path.join(os.homedir(), 'Developer'),
+  path.join(os.homedir(), 'code'),
+];
+
+function load() {
+  // Shape-or-nothing: corrupt index degrades to empty, never throws
+  try {
+    const i = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf-8'));
+    if (i && typeof i === 'object' && i.projects && typeof i.projects === 'object') return i;
+    return { projects: {} };
+  } catch { return { projects: {} }; }
+}
+
+function save(index) {
+  fs.mkdirSync(path.dirname(INDEX_FILE), { recursive: true });
+  fs.writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2));
+}
+
+/** Upsert the project at `dir` (called whenever a session opens one). */
+function recordProject(dir, extra = {}) {
+  const index = load();
+  const key = path.resolve(dir);
+  index.projects[key] = {
+    ...(index.projects[key] || {}),
+    name: path.basename(key),
+    path: key,
+    lastOpened: new Date().toISOString(),
+    ...extra,
+  };
+  save(index);
+}
+
+/** Known projects, most recently opened first. Prunes paths that vanished. */
+function listProjects() {
+  const index = load();
+  const alive = Object.values(index.projects).filter(p => {
+    try { return fs.existsSync(path.join(p.path, '.intent')); } catch { return false; }
+  });
+  return alive.sort((a, b) => String(b.lastOpened).localeCompare(String(a.lastOpened)));
+}
+
+/** Shallow scan: direct children of common roots that contain .intent/. */
+function scanForProjects() {
+  const found = [];
+  const seen = new Set(); // realpath-dedupe — case-insensitive FS makes ~/Projects and ~/projects one dir
+  for (const root of SCAN_ROOTS) {
+    let entries;
+    try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.name.startsWith('.')) continue;
+      const dir = path.join(root, e.name);
+      try {
+        if (fs.existsSync(path.join(dir, '.intent', 'vision.md'))) {
+          const real = fs.realpathSync(dir);
+          if (seen.has(real)) continue;
+          seen.add(real);
+          found.push({ name: e.name, path: real });
+        }
+      } catch { /* unreadable dir — skip */ }
+    }
+  }
+  return found;
+}
+
+function fmtAgo(ts) {
+  if (!ts) return '';
+  const mins = Math.floor((Date.now() - new Date(ts).getTime()) / 60000);
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  return `${Math.floor(hrs / 24)}d ago`;
+}
+
+module.exports = { INDEX_FILE, SCAN_ROOTS, recordProject, listProjects, scanForProjects, fmtAgo };

package/lib/ui.js

@@ -3,18 +3,22 @@
 // Zero dependencies. Pure ANSI. The terminal breathes.
 
 // ── PHEWSH palette ───────────────────────────────────────
-// 24-bit color for terminals that support it (most modern ones do).
-// Fallback-safe: if 24-bit fails, the text still renders.
-const rgb = (r, g, b) => (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m`;
+// 256-color (38;5;n), NOT 24-bit (38;2;r;g;b). Terminals without truecolor
+// (Apple Terminal et al.) misparse 24-bit params as separate SGR codes —
+// e.g. teal's red channel "100" became "bright black BACKGROUND" = grey
+// boxes behind text. 256-color is a single param: renders the same
+// everywhere. Comfy in every terminal beats precise in some.
+const c256 = (n) => (s) => `\x1b[38;5;${n}m${s}\x1b[0m`;
+const rgb = (r, g, b) => (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m`; // kept for callers; avoid for new UI
 const rgbBg = (r, g, b) => (s) => `\x1b[48;2;${r};${g};${b}m${s}\x1b[0m`;
 
 // Brand colors — relief, quiet, future
-const teal    = rgb(100, 215, 195);   // cool calm — primary
-const peach   = rgb(255, 195, 145);   // warm exhale — accent
-const sage    = rgb(190, 208, 198);   // quiet — secondary text
-const slate   = rgb(152, 164, 158);   // whisper — dim text (bright enough for dark terminals)
-const cream   = rgb(240, 235, 225);   // clarity — bright text
-const ember   = rgb(220, 140, 90);    // glow — warnings/energy
+const teal    = c256(79);    // #5fd7af  cool calm — primary
+const peach   = c256(216);   // #ffaf87  warm exhale — accent
+const sage    = c256(151);   // #afd7af  quiet — secondary text
+const slate   = c256(247);   // #9e9e9e  whisper — dim but legible
+const cream   = c256(230);   // #ffffd7  clarity — bright text
+const ember   = c256(173);   // #d7875f  glow — warnings/energy
 
 // Standard ANSI fallbacks (used where 24-bit might not render)
 const b  = (s) => `\x1b[1m${s}\x1b[0m`;

package/package.json

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