phewsh 0.13.1 → 0.14.0

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;130;142;138m${s}\x1b[0m`;  // slate (matches ui.js)
+const g  = (s) => `\x1b[38;2;152;164;158m${s}\x1b[0m`;  // slate (matches ui.js)
 const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 

package/commands/session.js

@@ -17,7 +17,7 @@ const { select, refreshSession: refreshSess } = require('../lib/supabase');
 const { readPPS } = require('../lib/pps');
 const { push, pull, ensureValidToken } = require('./sync');
 const { HARNESSES, listHarnesses, runViaHarness } = require('../lib/harnesses');
-const { recordDecision, labelOutcome, pendingDecisions, OUTCOMES } = require('../lib/outcomes');
+const { recordDecision, labelOutcome, pendingDecisions, outcomeStats, OUTCOMES } = require('../lib/outcomes');
 const { recordSessionEvent } = require('../lib/receipts-data');
 
 // Brand palette shortcuts
@@ -107,14 +107,16 @@ const DEFAULT_MODEL = 'claude-sonnet';
 // explicit config.defaultRoute → API key if set → first installed harness.
 
 function resolveRoute(config, harnesses) {
-  const installed = harnesses.filter(h => h.installed);
+  // Chat routing needs a headless-capable harness; interactive-only ones
+  // (Hermes, Pi) are still detected and reachable via /work.
+  const chatCapable = harnesses.filter(h => h.installed && h.headless);
   const preferred = config?.defaultRoute;
   if (preferred === 'api' && config?.apiKey) return { type: 'api' };
-  if (preferred && installed.some(h => h.id === preferred)) {
+  if (preferred && chatCapable.some(h => h.id === preferred)) {
     return { type: 'harness', id: preferred };
   }
   if (config?.apiKey) return { type: 'api' };
-  if (installed.length > 0) return { type: 'harness', id: installed[0].id };
+  if (chatCapable.length > 0) return { type: 'harness', id: chatCapable[0].id };
   return null;
 }
 
@@ -264,6 +266,7 @@ async function main() {
   let route = resolveRoute(config, harnesses);
   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 decisionsThisSession = 0;
 
   // ── The Exhale: animated brand reveal ──────────────────
@@ -276,45 +279,54 @@ async function main() {
     route = resolveRoute(config, harnesses);
   }
 
-  // ── Project status (compact) ────────────────────────────
-  const statusParts = [cream(projectName)];
-  if (intentFiles.length > 0) {
-    statusParts.push(teal('●') + sage(` .intent/ (${intentFiles.length} files)`));
-  } else {
-    statusParts.push(slate('no .intent/ — run /init'));
-  }
-  statusParts.push(sage('via ' + routeLabel(route, config)));
-  console.log(`  ${statusParts.join(slate('  ·  '))}`);
-
-  // Capabilities: what's installed on this machine, no setup required
-  if (installedHarnesses.length > 0) {
-    const caps = harnesses.map(h =>
-      h.installed ? `${teal('✓')} ${sage(h.label)}` : slate(`✗ ${h.label}`)
-    ).join(slate(' · '));
-    console.log(`  ${caps}`);
-  }
-
-  // Decisions from past sessions still waiting on an outcome
-  const pendingPast = pendingDecisions();
-  if (pendingPast.length > 0) {
-    console.log(`  ${peach('◌')} ${sage(`${pendingPast.length} decision${pendingPast.length !== 1 ? 's' : ''} awaiting outcome`)} ${slate('— /outcomes to label')}`);
-  }
-
-  // Sync status (one-line, non-blocking)
+  // ── Mission control: the whole state of your AI work, one screen ──────
+  // 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;
   if (config?.supabaseUserId && intentFiles.length > 0) {
-    const syncResult = await Promise.race([
+    syncState = await Promise.race([
       checkSyncStatus(config),
       new Promise(resolve => setTimeout(() => resolve(null), 3000)),
     ]);
-    if (syncResult) {
-      if (syncResult.status === 'cloud-newer') {
-        console.log(`  ${ember('↓')} ${sage('Cloud newer (' + syncResult.ago + ') — /pull')}`);
-      } else if (syncResult.status === 'local-newer') {
-        console.log(`  ${ember('↑')} ${sage('Local changes — /push')}`);
-      } else if (syncResult.status === 'synced') {
-        console.log(`  ${teal('↕')} ${slate('synced')}`);
-      }
-    }
+  }
+
+  const row = (label, value) => console.log(`  ${slate(label.padEnd(9))}${value}`);
+
+  row('PROJECT', cream(projectName) + (intentFiles.length > 0
+    ? slate(' · ') + teal('●') + sage(` .intent/ ${intentFiles.length} file${intentFiles.length !== 1 ? 's' : ''}`)
+    : slate(' · no memory yet — ') + sage('/init')));
+
+  row('ROUTE', route
+    ? cream(routeLabel(route, config)) + (route.type === 'harness' ? slate(' · no API key needed') : '')
+    : ember('none — /key or install an agent CLI'));
+
+  const backups = harnesses.filter(h => h.installed && h.headless && !(route?.type === 'harness' && route.id === h.id));
+  const workOnly = installedHarnesses.filter(h => !h.headless);
+  const backupParts = backups.map(h => `${teal('✓')} ${sage(h.label)}`);
+  if (config?.apiKey && route?.type !== 'api') backupParts.push(`${teal('✓')} ${sage('direct API')}`);
+  workOnly.forEach(h => backupParts.push(sage(h.label) + slate(' /work')));
+  row('BACKUP', backupParts.length > 0
+    ? backupParts.join(slate(' · ')) + slate('  — context travels if the route hits a wall')
+    : slate('none — install Codex or Gemini to cover usage limits'));
+
+  if (config?.supabaseUserId) {
+    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);
+  } else {
+    row('WEB', sage('local-only (works fine)') + slate(' · /login mirrors this at phewsh.com/intent'));
+  }
+
+  const oStats = outcomeStats();
+  const oLabeled = oStats.total - oStats.pending;
+  if (oStats.total > 0) {
+    const keptRate = oLabeled > 0 ? Math.round((oStats.kept / oLabeled) * 100) + '% kept' : 'unlabeled';
+    row('RECORD', cream(`${oStats.total} decision${oStats.total !== 1 ? 's' : ''}`) + slate(' · ') + sage(keptRate)
+      + (oStats.pending > 0 ? slate(' · ') + peach(`${oStats.pending} awaiting outcome`) + slate(' — /outcomes') : ''));
+  } else {
+    row('RECORD', slate('empty — decisions and outcomes accumulate as you work'));
   }
 
   console.log('');
@@ -331,10 +343,107 @@ async function main() {
   } 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 — both work')}`);
+    console.log(`  ${slate('pick a number, or just type — your context travels with every route')}`);
   }
   console.log('');
 
+  // ── Turn runners — every route records a decision, leaves a receipt ────
+  // Both return true on success so the fallback flow can chain them.
+
+  async function runHarnessTurn(input, harnessId, fullSystem) {
+    const decisionId = recordDecision({
+      project: projectName, route: harnessId, mode: sessionMode, summary: input,
+    });
+    decisionsThisSession++;
+    try {
+      const output = await runViaHarness(harnessId, fullSystem, buildHarnessPrompt(messages, input));
+      messages.push({ role: 'user', content: input });
+      messages.push({ role: 'assistant', content: (output || '').trim() });
+      recordSessionEvent(harnessId, projectName, 'task_complete', {
+        taskId: decisionId, success: true, summary: input.slice(0, 140),
+      });
+      awaitingOutcome = decisionId;
+      console.log(slate(`  via ${HARNESSES[harnessId].label} · outcome? 1 kept · 2 reverted · 3 superseded · 4 failed · or keep typing`));
+      return true;
+    } catch (err) {
+      try { labelOutcome(decisionId, 'failed'); } catch { /* keep going */ }
+      recordSessionEvent(harnessId, projectName, 'task_complete', {
+        taskId: decisionId, success: false, summary: input.slice(0, 140),
+      });
+      const limitHit = /limit|quota|rate|usage|exhaust/i.test(err.message);
+      console.error(`\n  ${ember('!')} ${cream(HARNESSES[harnessId].label)} ${sage(limitHit ? 'hit a usage wall' : 'failed')}${slate(' — ' + err.message.split('\n')[0])}`);
+      return false;
+    }
+  }
+
+  async function runApiTurn(input, fullSystem) {
+    const decisionId = recordDecision({
+      project: projectName, route: 'api', mode: sessionMode, summary: input,
+    });
+    decisionsThisSession++;
+    messages.push({ role: 'user', content: input });
+    console.log('');
+    try {
+      const result = await streamChat(config.apiKey, messages, fullSystem, MODELS[currentModel].id);
+      messages.push({ role: 'assistant', content: result.content });
+      if (result.promptTokens) totalPromptTokens += result.promptTokens;
+      if (result.completionTokens) totalCompletionTokens += result.completionTokens;
+      if (result.promptTokens || result.completionTokens) {
+        console.log(slate(`  ${result.promptTokens || '?'}→${result.completionTokens || '?'} tokens · ${MODELS[currentModel].name} · outcome? 1-4 or keep typing`));
+      }
+      awaitingOutcome = decisionId;
+      trackSap({
+        userId: config.supabaseUserId,
+        source: 'cli',
+        model: MODELS[currentModel].id,
+        promptTokens: result.promptTokens,
+        completionTokens: result.completionTokens,
+        accessToken: config.supabaseAccessToken,
+      });
+      return true;
+    } catch (err) {
+      try { labelOutcome(decisionId, 'failed'); } catch { /* keep going */ }
+      messages.pop();
+      console.error(`\n  ${ember('!')} ${sage('API route failed')}${slate(' — ' + err.message.split('\n')[0])}`);
+      return false;
+    }
+  }
+
+  // Fallbacks are a first-class flow: the route changes, the context and
+  // record do not. Ask by default; auto-switch only if setup said so.
+  async function offerFallbacks(input, fullSystem, failedId) {
+    const options = harnesses
+      .filter(h => h.installed && h.headless && h.id !== failedId)
+      .map(h => h.id);
+    if (config?.apiKey && failedId !== 'api') options.push('api');
+
+    if (options.length === 0) {
+      console.log(`  ${sage('No fallback ready.')} ${slate('Install Codex or Gemini, or add an API key with /key — context would travel automatically.')}`);
+      console.log('');
+      return;
+    }
+
+    if (config?.fallback === 'auto') {
+      const fb = options[0];
+      const fbLabel = fb === 'api' ? 'direct API' : HARNESSES[fb].label;
+      console.log(`  ${peach('↻')} ${sage('auto-fallback →')} ${cream(fbLabel)} ${slate('· same context, same record')}`);
+      const ok = fb === 'api'
+        ? await runApiTurn(input, fullSystem)
+        : await runHarnessTurn(input, fb, fullSystem);
+      if (!ok) console.log(`  ${ember('!')} ${sage('Fallback failed too — /provider to inspect routes.')}`);
+      console.log('');
+      return;
+    }
+
+    const list = options.map((id, i) =>
+      `${teal(String(i + 1))} ${sage(id === 'api' ? 'direct API (your key)' : HARNESSES[id].label)}`
+    ).join(slate(' · '));
+    console.log(`  ${sage('Retry with your context intact:')} ${list} ${slate('· enter = skip')}`);
+    console.log(`  ${slate('prefer auto-switching? phewsh setup sets it once')}`);
+    awaitingFallback = { input, fullSystem, options };
+    console.log('');
+  }
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -352,6 +461,24 @@ async function main() {
       return;
     }
 
+    // A bare number right after a route failure picks the fallback
+    if (awaitingFallback) {
+      const af = awaitingFallback;
+      awaitingFallback = null;
+      const n = parseInt(input, 10);
+      if (n >= 1 && n <= af.options.length) {
+        const fb = af.options[n - 1];
+        const ok = fb === 'api'
+          ? await runApiTurn(af.input, af.fullSystem)
+          : await runHarnessTurn(af.input, fb, af.fullSystem);
+        if (!ok) await offerFallbacks(af.input, af.fullSystem, fb);
+        console.log('');
+        rl.prompt();
+        return;
+      }
+      // anything else: drop the offer and treat it as fresh input
+    }
+
     // A bare 1-4 right after a routed action labels its outcome
     if (awaitingOutcome && /^[1-4]$/.test(input)) {
       const outcome = OUTCOMES[parseInt(input, 10) - 1];
@@ -832,6 +959,7 @@ async function main() {
           rows.push([h.label, h.installed ? `installed (${h.auth})` : 'not installed', h.installed ? 'green' : undefined]);
         }
         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']);
         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('|') + '>')}`);
@@ -858,6 +986,8 @@ async function main() {
         } else if (HARNESSES[target]) {
           if (!harnesses.find(h => h.id === target)?.installed) {
             console.log(`  ${ember('!')} ${sage(HARNESSES[target].label + ' is not installed on this machine.')}`);
+          } else if (!HARNESSES[target].args) {
+            console.log(`  ${sage(HARNESSES[target].label + ' is interactive-only — drop into it with')} ${cream('/work ' + target)} ${sage('(phewsh records the outcome when you return)')}`);
           } else {
             route = { type: 'harness', id: target };
             console.log(`  ${teal('●')} ${sage('Routing via')} ${cream(routeLabel(route, config))} ${slate('— no API key, your subscription')}`);
@@ -876,8 +1006,9 @@ async function main() {
         ui.divider('line');
         for (const h of harnesses) {
           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}${active}`);
+          console.log(`    ${cream(h.id.padEnd(12))} ${sage(h.label.padEnd(14))} ${status}${mode}${active}`);
         }
         console.log('');
         rl.prompt();
@@ -1078,68 +1209,12 @@ async function main() {
       : null;
     const fullSystem = modeHint ? `${systemPrompt}\n\n${modeHint}` : systemPrompt;
 
-    // Every routed action is a decision — recorded before it runs,
-    // labeled (1-4) when the outcome is known.
-    const decisionId = recordDecision({
-      project: projectName,
-      route: route.type === 'api' ? 'api' : route.id,
-      mode: sessionMode,
-      summary: input,
-    });
-    decisionsThisSession++;
-
-    if (route.type === 'harness') {
-      try {
-        const output = await runViaHarness(route.id, fullSystem, buildHarnessPrompt(messages, input));
-        messages.push({ role: 'user', content: input });
-        messages.push({ role: 'assistant', content: (output || '').trim() });
-        recordSessionEvent(route.id, projectName, 'task_complete', {
-          taskId: decisionId, success: true, summary: input.slice(0, 140),
-        });
-        awaitingOutcome = decisionId;
-        console.log(slate(`  via ${HARNESSES[route.id].label} · outcome? 1 kept · 2 reverted · 3 superseded · 4 failed · or keep typing`));
-      } catch (err) {
-        try { labelOutcome(decisionId, 'failed'); } catch { /* keep going */ }
-        recordSessionEvent(route.id, projectName, 'task_complete', {
-          taskId: decisionId, success: false, summary: input.slice(0, 140),
-        });
-        console.error(`\n  ${ember('!')} ${err.message}`);
-        if (installedHarnesses.length > 1 || config?.apiKey) {
-          console.log(`  ${slate('switch routes with /use — /provider shows what\'s available')}`);
-        }
-      }
-      console.log('');
-      rl.prompt();
-      return;
-    }
-
-    messages.push({ role: 'user', content: input });
-    console.log('');
+    const ok = route.type === 'harness'
+      ? await runHarnessTurn(input, route.id, fullSystem)
+      : await runApiTurn(input, fullSystem);
 
-    try {
-      const result = await streamChat(config.apiKey, messages, fullSystem, MODELS[currentModel].id);
-      messages.push({ role: 'assistant', content: result.content });
-
-      if (result.promptTokens) totalPromptTokens += result.promptTokens;
-      if (result.completionTokens) totalCompletionTokens += result.completionTokens;
-
-      if (result.promptTokens || result.completionTokens) {
-        console.log(slate(`  ${result.promptTokens || '?'}→${result.completionTokens || '?'} tokens · ${MODELS[currentModel].name} · outcome? 1-4 or keep typing`));
-      }
-      awaitingOutcome = decisionId;
-
-      trackSap({
-        userId: config.supabaseUserId,
-        source: 'cli',
-        model: MODELS[currentModel].id,
-        promptTokens: result.promptTokens,
-        completionTokens: result.completionTokens,
-        accessToken: config.supabaseAccessToken,
-      });
-    } catch (err) {
-      try { labelOutcome(decisionId, 'failed'); } catch { /* keep going */ }
-      console.error(`\n  ${err.message}\n`);
-      messages.pop();
+    if (!ok) {
+      await offerFallbacks(input, fullSystem, route.type === 'harness' ? route.id : 'api');
     }
 
     console.log('');

package/commands/setup.js

@@ -46,7 +46,8 @@ module.exports = async function setup() {
   console.log(`  ${b(cream('Detected on this machine'))}`);
   for (const h of harnesses) {
     const status = h.installed ? green('✓ installed') : slate('✗ not installed');
-    console.log(`    ${cream(h.label.padEnd(14))} ${status}  ${slate('(' + h.auth + ')')}`);
+    const mode = h.headless ? '' : slate(' · interactive — /work ' + h.id);
+    console.log(`    ${cream(h.label.padEnd(14))} ${status}  ${slate('(' + h.auth + ')')}${mode}`);
   }
   if (installed.length === 0) {
     console.log('');
@@ -58,11 +59,13 @@ module.exports = async function setup() {
 
   // Agent-run (no TTY): auto-configure instead of asking questions nobody
   // can answer. Pick the first installed harness; humans can change it later.
+  const chatCapable = installed.filter(h => h.headless);
   if (!process.stdin.isTTY) {
-    if (installed.length > 0) {
-      config.defaultRoute = installed[0].id;
+    if (chatCapable.length > 0) {
+      config.defaultRoute = chatCapable[0].id;
+      if (!config.fallback) config.fallback = 'ask';
       saveConfig(config);
-      console.log(`  ${teal('●')} ${sage('Auto-configured (non-interactive): default route =')} ${cream(installed[0].label)} ${slate('— no API key needed')}`);
+      console.log(`  ${teal('●')} ${sage('Auto-configured (non-interactive): default route =')} ${cream(chatCapable[0].label)} ${slate('— no API key needed')}`);
       console.log(`  ${slate('Change anytime: run `phewsh setup` in your own terminal, or /use inside a session.')}`);
     } else if (config.apiKey) {
       config.defaultRoute = 'api';
@@ -81,7 +84,9 @@ module.exports = async function setup() {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
   // ── 2. Pick the default route ─────────────────────────
-  const options = installed.map(h => ({ kind: 'harness', id: h.id, label: `${h.label} — your ${h.auth.split(' / ')[0].toLowerCase()}, no API key` }));
+  // Interactive-only harnesses (Hermes, Pi) can't take chat routing — they
+  // stay reachable via /work in a session, so they're not default options.
+  const options = chatCapable.map(h => ({ kind: 'harness', id: h.id, label: `${h.label} — your ${h.auth.split(' / ')[0].toLowerCase()}, no API key` }));
   options.push({ kind: 'api', id: 'api', label: 'Direct API — bring your own Anthropic/OpenRouter key' });
 
   console.log(`  ${b(cream('Where should phewsh route your work by default?'))}`);
@@ -124,9 +129,20 @@ module.exports = async function setup() {
     }
   }
 
+  // ── 4. Fallback behavior — first-class, not buried config ────────────
+  console.log('');
+  console.log(`  ${b(cream('If your route hits a usage limit or fails:'))}`);
+  console.log(`    ${teal('1')} ${sage('Ask me before switching')} ${slate('(default — shows what changes, context always travels)')}`);
+  console.log(`    ${teal('2')} ${sage('Auto-switch to the next available route')}`);
+  console.log('');
+  const fbAnswer = await ask(rl, `  ${teal('>')} ${slate('1-2, enter = 1: ')}`);
+  config.fallback = fbAnswer.trim() === '2' ? 'auto' : 'ask';
+  saveConfig(config);
+  console.log(`  ${teal('●')} ${sage('Fallback:')} ${cream(config.fallback === 'auto' ? 'auto-switch' : 'ask first')} ${slate('— either way, your project context and record stay intact')}`);
+
   rl.close();
 
-  // ── 4. Done ───────────────────────────────────────────
+  // ── 5. Done ───────────────────────────────────────────
   console.log('');
   ui.divider('line');
   console.log(`  ${teal('●')} ${b(cream('Setup complete.'))}`);

package/lib/harnesses.js

@@ -11,12 +11,21 @@
 
 const { execSync, spawn } = require('child_process');
 
+// args: how to run a one-shot prompt headlessly. args: null = we only know
+// 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] },
 };
 
 function isInstalled(id) {
@@ -25,16 +34,16 @@ function isInstalled(id) {
   try { execSync(`which ${h.bin}`, { stdio: 'pipe' }); return true; } catch { return false; }
 }
 
-/** First installed harness in preference order, or null. */
+/** First installed chat-capable harness in preference order, or null. */
 function detectInstalled() {
   for (const id of Object.keys(HARNESSES)) {
-    if (isInstalled(id)) return id;
+    if (HARNESSES[id].args && isInstalled(id)) return id;
   }
   return null;
 }
 
 function listHarnesses() {
-  return Object.entries(HARNESSES).map(([id, h]) => ({ id, ...h, installed: isInstalled(id) }));
+  return Object.entries(HARNESSES).map(([id, h]) => ({ id, ...h, headless: !!h.args, installed: isInstalled(id) }));
 }
 
 /**
@@ -45,6 +54,7 @@ function listHarnesses() {
 function runViaHarness(id, systemPrompt, userPrompt) {
   const h = HARNESSES[id];
   if (!h) return Promise.reject(new Error(`Unknown harness: ${id}`));
+  if (!h.args) return Promise.reject(new Error(`${h.label} is interactive-only here — launch it with /work ${id}`));
   const prompt = systemPrompt ? `${systemPrompt}\n\n---\n\n${userPrompt}` : userPrompt;
 
   return new Promise((resolve, reject) => {

package/lib/ui.js

@@ -11,8 +11,8 @@ 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(175, 195, 185);   // quiet — secondary text
-const slate   = rgb(130, 142, 138);   // whisper — dim text
+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
 

package/package.json

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