phewsh 0.15.22 → 0.15.24

package/commands/session.js

@@ -21,6 +21,7 @@ const { HARNESSES, listHarnesses, runViaHarness, cancelActive } = require('../li
 const { recordDecision, labelOutcome, pendingDecisions, recentDecisions, outcomeStats, OUTCOMES } = require('../lib/outcomes');
 const { suggest, suggestAll } = require('../lib/suggest');
 const continuity = require('../lib/continuity');
+const learning = require('../lib/learning');
 const { closest } = require('../lib/closest');
 const cmdHistory = require('../lib/history');
 const { recordSessionEvent } = require('../lib/receipts-data');
@@ -770,7 +771,7 @@ async function main() {
     'clear', 'status', 'key', 'login', 'export', 'push', 'pull', 'serve',
     'sync', 'harnesses', 'fallback', 'outcomes', 'tour', 'update', 'upgrade',
     'agents', 'context', 'gate', 'reload', 'sequence', 'seq', 'setup', 'system', 'watch',
-    'next', 'recommend', 'guide', 'thread', 'continuity',
+    'next', 'recommend', 'guide', 'thread', 'continuity', 'learn', 'stats',
   ]);
   const installedIds = harnesses.filter(h => h.installed).map(h => h.id);
   let turnAbort = null;       // AbortController while an API turn streams
@@ -1086,7 +1087,7 @@ async function main() {
         if (global._phewshChildren) {
           global._phewshChildren.forEach(c => { try { c.kill(); } catch {} });
         }
-        console.log('');
+        try { require('../lib/intro').farewell(); } catch { /* sign-off is a nicety */ }
         console.log(`  ${sage('session ended · ' + turns + ' exchanges · ' + (totalPromptTokens + totalCompletionTokens) + ' tokens')}`);
         if (decisionsThisSession > 0) {
           const stillPending = pendingDecisions().length;
@@ -1158,6 +1159,46 @@ async function main() {
         return;
       }
 
+      // ── /learn ─────────────────────────────────────────
+      // What the record has learned — kept-rates by tool and by mode, so the
+      // 100th decision is better-informed than the 1st. Honest: stays quiet
+      // until there's real labeled signal.
+      if (cmd === 'learn' || cmd === 'stats') {
+        let stats = null;
+        try { stats = outcomeStats({ project: projectName }); } catch { /* best-effort */ }
+        const labeled = stats ? learning.totalLabeled(stats) : 0;
+        console.log('');
+        if (labeled < 5) {
+          console.log(`  ${teal('●')} ${sage(`Not enough labeled decisions yet (${labeled}).`)} ${slate('Label outcomes with /outcomes — the record gets smarter as you do.')}`);
+          console.log('');
+          rl.prompt();
+          return;
+        }
+        console.log(`  ${b(cream('What your record has learned'))} ${slate(`— ${labeled} labeled decisions, ${projectName}`)}`);
+        ui.divider('line');
+        console.log(`  ${sage('by tool')} ${slate('(kept-rate, best first)')}`);
+        for (const r of learning.routeRates(stats, { minSample: 2 })) {
+          const pct = Math.round(r.keptRate * 100);
+          const bar = '█'.repeat(Math.round(r.keptRate * 10)).padEnd(10, '░');
+          console.log(`    ${continuity.labelFor(r.route).padEnd(14)} ${teal(bar)} ${cream(pct + '%')} ${slate(`(${r.kept}/${r.total} kept)`)}`);
+        }
+        const modes = learning.modeRates(stats, { minSample: 2 });
+        if (modes.length) {
+          console.log('');
+          console.log(`  ${sage('by kind of work')}`);
+          for (const m of modes) {
+            const pct = Math.round(m.keptRate * 100);
+            console.log(`    ${String(m.mode).padEnd(14)} ${cream(pct + '%')} ${slate(`(${m.kept}/${m.total} kept)`)}`);
+          }
+        }
+        const best = learning.bestRoute(stats, { minSample: 3 });
+        ui.divider('line');
+        if (best) console.log(`  ${teal('↪')} ${sage(`${continuity.labelFor(best.route)} keeps best for you (${Math.round(best.keptRate * 100)}%).`)} ${slate('/use ' + best.route + ' to lean on it.')}`);
+        console.log('');
+        rl.prompt();
+        return;
+      }
+
       if (cmd === 'help' || cmd === 'h') {
         const wantsAll = /^(all|more|full|everything)$/i.test(cmdArg.trim());
 
@@ -1187,6 +1228,7 @@ async function main() {
         console.log(`  ${cream('not sure what to do?')}`);
         console.log(`    ${teal('/next')}        ${sage("phewsh reads your state and hands back the next step worth taking")}`);
         console.log(`    ${teal('/thread')}      ${sage('where you left off — your work across every tool, one record')}`);
+        console.log(`    ${teal('/learn')}       ${sage('what your record taught — which tool keeps best, by kind of work')}`);
         console.log('');
         console.log(`  ${cream('author .intent/')}`);
         console.log(`    ${teal('/init')}        ${sage('Create .intent/ for this project')}`);
@@ -1938,6 +1980,9 @@ async function main() {
         console.log('');
         console.log(`  ${b(cream('Your AI tools'))} ${slate('— phewsh keeps them all, aligned. You never pick just one.')}`);
         ui.divider('line');
+        // The record feeding back: kept-rate per route, where it's earned.
+        let hStats = null;
+        try { hStats = outcomeStats({ project: projectName }); } catch { /* best-effort */ }
         // Installed first, then the rest so the table also teaches what exists.
         const sorted = [...harnesses].sort((a, b) => (b.installed - a.installed));
         let lastGroup = null;
@@ -1950,9 +1995,13 @@ async function main() {
           const active = route?.type === 'harness' && route.id === h.id ? ` ${teal('● active')}` : '';
           const dot = h.installed ? green('●') : slate('○');
           const mode = h.headless ? '' : slate(' · /work only');
-          console.log(`    ${dot} ${cream(h.id.padEnd(11))} ${sage((h.role || h.label).padEnd(20))} ${slate(h.label)}${mode}${active}`);
+          const badge = hStats ? learning.keptBadge(hStats, h.id) : '';
+          const rec = badge ? ` ${slate('· ' + badge)}` : '';
+          console.log(`    ${dot} ${cream(h.id.padEnd(11))} ${sage((h.role || h.label).padEnd(20))} ${slate(h.label)}${mode}${rec}${active}`);
         }
         ui.divider('line');
+        const learned = hStats ? learning.learningLine(hStats) : null;
+        if (learned) console.log(`  ${teal('↪')} ${sage(learned)} ${slate('— route accordingly')}`);
         console.log(`  ${sage('keep your tools, keep one record:')}`);
         console.log(`    ${teal('/use')} ${slate('<id>')}     ${sage('route your typing through that tool')}`);
         console.log(`    ${teal('@<id>')} ${slate('<msg>')}   ${sage('one message to one tool — context stays shared')}`);

package/lib/intro.js

@@ -28,6 +28,25 @@ const FACE = [
   '          ███    ███',
 ];
 
+// The shush mark (🤫) — rasterized from assets/shh.svg, same 30×14 grid.
+// Bookends the session: phew opens it, shh signs off.
+const SHH = [
+  '         ██       ███',
+  '     ██                █',
+  '   █                      █',
+  '  █      ███      ███      █',
+  ' █                          █',
+  '█             ██             █',
+  '█            █  █            █',
+  '█               █            █',
+  '           █     █',
+  ' █      █ █                 █',
+  '   █     █ ██  █   █      █',
+  '     █    █         █   █',
+  '        ██  █       ██',
+  '              ██   █',
+];
+
 const LOGO = ['█▀█ █░█ █▀▀ █░█ █▀ █░█', '█▀▀ █▀█ ██▄ ▀▄▀ ▄█ █▀█'];
 
 function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
@@ -80,4 +99,13 @@ async function playIntro(opts = {}) {
   return { toolsFound: harnesses.length };
 }
 
-module.exports = { playIntro, LOGO, FACE };
+// Quiet sign-off — the shush mark, printed static (no animation; exit is instant).
+function farewell(opts = {}) {
+  const { out = console.log } = opts;
+  const { slate } = ui;
+  out('');
+  for (const line of SHH) out(`  ${slate(line)}`);
+  out('');
+}
+
+module.exports = { playIntro, farewell, LOGO, FACE, SHH };

package/lib/learning.js

@@ -0,0 +1,62 @@
+// Learning loops — what gets smarter after the 100th decision.
+//
+// The decision record is already labeled (kept / reverted / superseded /
+// failed) per route and per mode. This turns that into insight that feeds
+// BACK into the next decision: which tool actually keeps best for you, and
+// for which kind of work. Honest by construction — nothing surfaces until
+// there's enough labeled signal, so there are no fake gauges.
+//
+// Pure: feed it outcomeStats(), get back rankings + one-line readouts.
+
+const { labelFor } = require('./continuity');
+
+function rate(r) { return r.total ? r.kept / r.total : 0; }
+
+/** Per-route kept-rates, best first. Filters out thin samples. */
+function routeRates(stats, { minSample = 1 } = {}) {
+  return Object.entries((stats && stats.byRoute) || {})
+    .map(([route, r]) => ({ route, total: r.total, kept: r.kept, keptRate: rate(r) }))
+    .filter((r) => r.total >= minSample)
+    .sort((a, b) => b.keptRate - a.keptRate || b.total - a.total);
+}
+
+/** Per-mode kept-rates, best first. */
+function modeRates(stats, { minSample = 1 } = {}) {
+  return Object.entries((stats && stats.byMode) || {})
+    .map(([mode, m]) => ({ mode, total: m.total, kept: m.kept, keptRate: rate(m) }))
+    .filter((m) => m.total >= minSample)
+    .sort((a, b) => b.keptRate - a.keptRate || b.total - a.total);
+}
+
+function totalLabeled(stats) {
+  if (!stats) return 0;
+  return (stats.kept || 0) + (stats.reverted || 0) + (stats.superseded || 0) + (stats.failed || 0);
+}
+
+/** The route with the best kept-rate, given enough data, or null. */
+function bestRoute(stats, { minSample = 3 } = {}) {
+  const rates = routeRates(stats, { minSample });
+  return rates.length ? rates[0] : null;
+}
+
+/**
+ * One honest line of what the record has learned, or null if too thin.
+ * "After 23 labeled: Codex 8/10 · Claude Code 5/9 kept"
+ */
+function learningLine(stats, { labeler = null, minLabeled = 5, top = 3 } = {}) {
+  const labeled = totalLabeled(stats);
+  if (labeled < minLabeled) return null;
+  const rates = routeRates(stats, { minSample: 2 }).slice(0, top);
+  if (!rates.length) return null;
+  const parts = rates.map((r) => `${labelFor(r.route, labeler)} ${r.kept}/${r.total}`);
+  return `After ${labeled} labeled: ${parts.join(' · ')} kept`;
+}
+
+/** A short percentage badge for one route, or '' if too thin to be honest. */
+function keptBadge(stats, route, { minSample = 2 } = {}) {
+  const r = stats && stats.byRoute && stats.byRoute[route];
+  if (!r || r.total < minSample) return '';
+  return `${r.kept}/${r.total} kept`;
+}
+
+module.exports = { routeRates, modeRates, bestRoute, learningLine, keptBadge, totalLabeled };

package/package.json

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