phewsh 0.15.72 → 0.15.74

package/commands/ambient.js

@@ -262,6 +262,10 @@ async function turnOn(skipConfirm) {
 
 function turnOff() {
   const removed = removeClaudeHooks();
+  // Full reversibility: ambient off takes the lifecycle hooks with it too.
+  let gateRemoved = false;
+  try { gateRemoved = disablePreToolGate(); } catch { /* best-effort */ }
+  if (gateRemoved) removed.push('lifecycle hooks (PreToolUse gate + PostToolUse receipt)');
   const { removed: removedGlobal } = selfheal.removeGlobalBaseFiles();
   const { removed: removedProject } = selfheal.removeProjectContextFiles();
   const { removed: removedSlash } = slash.removeSlashCommands();
@@ -269,6 +273,7 @@ function turnOff() {
   delete ledger.applied['claude-code'];
   delete ledger.applied.globalBase;
   delete ledger.applied.slashCommands;
+  delete ledger.applied.lifecycle;
   delete ledger.autoEnabledAt;
   ledger.disabled = true; // sticky opt-out — first-run auto-enable must respect this
   saveLedger(ledger);
@@ -365,6 +370,11 @@ async function ensureAuto() {
 
   const hasClaude = installed.some(h => h.id === 'claude-code');
   const changes = hasClaude ? applyClaudeHooks() : [];
+  // Neal's ruling (Jul 5): the lifecycle hooks (PreToolUse gate + PostToolUse
+  // receipt) install with first-run auto-enable too — they're fail-open,
+  // redacted, and removed by the same `phewsh ambient off` / `gate enforce off`.
+  let gateApplied = false;
+  if (hasClaude) { try { gateApplied = enablePreToolGate(); } catch { /* best-effort */ } }
   const { written } = selfheal.syncGlobalBaseFiles();
   const slashWritten = slash.installSlashCommands().written;
   // Refresh existing project files only — first-run auto-enable must not dump
@@ -378,6 +388,13 @@ async function ensureAuto() {
       captures: '~/.phewsh/ambient-sessions.jsonl — timestamp, project, cwd only',
       undo: 'phewsh ambient off',
     };
+    if (gateApplied) {
+      ledger.applied.lifecycle = {
+        at: now, file: CLAUDE_SETTINGS,
+        what: 'PreToolUse gate (deny protected paths, ask on high blast radius) + PostToolUse redacted receipt',
+        undo: 'phewsh gate enforce off (or phewsh ambient off)',
+      };
+    }
   }
   if (written.length > 0) {
     ledger.applied.globalBase = { at: now, files: written, undo: 'phewsh ambient off' };
@@ -394,6 +411,7 @@ async function ensureAuto() {
     console.log('');
     console.log(`  ${b(cream('phewsh set itself up across your AI tools'))} ${sage('— so they stay in sync with your project intent.')}`);
     if (hasClaude) console.log(`    ${teal('+')} ${slate('Claude Code gets a brief from a project\'s .intent/ at session start')}`);
+    if (gateApplied) console.log(`    ${teal('+')} ${slate('guardrails: protected-path writes gated + a redacted receipt of what ran')}`);
     written.forEach(f => console.log(`    ${teal('+')} ${slate('environment note added to ' + f)}`));
     if (slashWritten.length) console.log(`    ${teal('+')} ${cream('/intent')} ${slate('command added to ' + slashWritten.join(', '))}`);
     console.log(`    ${sage('In any project with')} ${cream('.intent/')}${sage(', your tools now read its real intent. Reversible:')} ${cream('phewsh ambient off')}`);

package/commands/clarify.js

@@ -81,6 +81,26 @@ function assembleRaw(answers) {
   return answers.map((a) => `${a.title} (${a.directive}): ${a.answer}`).join('\n');
 }
 
+// No-AI spec from the user's own words: the first answer line becomes the
+// goal (node label stripped), the raw text survives verbatim in pps.intent.raw,
+// and the first task points back at the AI compile.
+function fallbackSpec(raw) {
+  const first = String(raw).split('\n').find(l => l.trim()) || "Capture this project's intent";
+  const goal = first.replace(/^[A-Za-z]+ \([^)]*\):\s*/, '').trim().slice(0, 200);
+  return {
+    goal,
+    success_criteria: [],
+    constraints: [],
+    inputs: [],
+    outputs: [],
+    tasks: [
+      { text: 'Re-run `phewsh clarify --update` to compile this spec with AI', type: 'copy' },
+      { text: 'Refine the vision — complete vision.md', type: 'do' },
+      { text: 'Define Phase 1 — what is the smallest thing to ship?', type: 'do' },
+    ],
+  };
+}
+
 function buildClarifySystemPrompt(existing) {
   const isRefine = !!(existing?.intent?.goal);
   return `You are a project compiler. Your job is to extract clean, structured intent from messy human input.
@@ -264,8 +284,12 @@ async function main() {
       ? await callClarifyViaHarness(harnessId, raw, existing)
       : await callClarifyAPI(config.apiKey, raw, existing);
   } catch (err) {
-    console.error('\n  Clarify failed:', err.message, '\n');
-    process.exit(1);
+    // A failed compile must NEVER eat the user's answers. They just walked
+    // the compass — write a plain no-AI spec from what they typed, and let
+    // `clarify --update` enrich it when a route works again.
+    console.log(`\n  AI compile unavailable (${err.message}).`);
+    console.log('  Saving your answers as a plain spec instead — nothing you typed is lost.');
+    extracted = fallbackSpec(raw);
   }
 
   const entity = getProjectName();
@@ -333,4 +357,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { run: main, GUIDE_NODES, INTENT_NODES, assembleRaw, askGuided, extractJson };
+module.exports = { run: main, GUIDE_NODES, INTENT_NODES, assembleRaw, askGuided, extractJson, fallbackSpec };

package/commands/hook.js

@@ -74,10 +74,39 @@ function firstLines(text, n) {
     .join('\n');
 }
 
+// The accountability invitation. A real project (it has .git) with no
+// .intent/ gets ONE gentle note injected — telling the agent to offer
+// grounding once, and to drop it if declined. Once per project, ever
+// (tracked in ~/.phewsh/intent-nudges.json); every later session is
+// silent again. Invite, never nag — the recorded stance (decisions.md).
+function maybeIntentInvitation() {
+  try {
+    if (!fs.existsSync(path.join(process.cwd(), '.git'))) return; // not a real project — cost nothing
+    const nudgeFile = path.join(PHEWSH_DIR, 'intent-nudges.json');
+    let seen = {};
+    try { seen = JSON.parse(fs.readFileSync(nudgeFile, 'utf-8')); } catch { /* first nudge ever */ }
+    if (seen && seen[process.cwd()]) return; // already invited here — never again
+    seen = (seen && typeof seen === 'object') ? seen : {};
+    seen[process.cwd()] = new Date().toISOString();
+    fs.mkdirSync(PHEWSH_DIR, { recursive: true });
+    fs.writeFileSync(nudgeFile, JSON.stringify(seen, null, 2));
+    process.stdout.write([
+      '# phewsh — one-time note for this project',
+      'This repo has no `.intent/` yet — no durable project truth that travels between AI tools.',
+      'If the user starts substantial (non-trivial) work here, offer ONCE, in plain language, to ground the project:',
+      '`phewsh clarify` (guided walk) or `phewsh init` (two questions) creates `.intent/` — vision, plan, and next steps that every AI tool reads, so the next session picks up where this one left off.',
+      'If they decline, or the work is trivial/exploratory, drop it and never raise it again. Do not create `.intent/` yourself uninvited.',
+    ].join('\n') + '\n');
+    appendBreadcrumb('intent-invite');
+  } catch { /* the invitation is a nicety — never break the host */ }
+}
+
 function sessionStart() {
   if (!fs.existsSync(path.join(INTENT_DIR, 'vision.md')) &&
       !fs.existsSync(path.join(INTENT_DIR, 'plan.md'))) {
-    // No .intent/ here — stay silent, cost the host nothing.
+    // No .intent/ here — one gentle invitation if this is a real project,
+    // then silence forever.
+    maybeIntentInvitation();
     process.exit(0);
   }
 

package/commands/intent.js

@@ -6,7 +6,12 @@ const { createPPS, writeGuardedViews } = require('../lib/pps');
 
 const os = require('os');
 const configFile = require('../lib/config-file');
-const args = process.argv.slice(3);
+// Flags may arrive as `phewsh intent --init` / `phewsh init --init` (flag at
+// argv[3]) or as a direct `node intent.js --init` (flag at argv[2]) — the
+// session used the direct form and every flag was silently missed, so /init
+// printed help instead of initializing. Accept both shapes.
+const rawArgs = process.argv.slice(2);
+const args = (rawArgs[0] === 'intent' || rawArgs[0] === 'init') ? rawArgs.slice(1) : rawArgs;
 const INTENT_DIR = path.join(process.cwd(), '.intent');
 const CONFIG_PATH = path.join(os.homedir(), '.phewsh', 'config.json');
 const WEB_URL = 'https://phewsh.com/intent';

package/commands/pack.js

@@ -36,7 +36,39 @@ function list() {
     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(`  ${sage('Install:')} ${cream('phewsh pack install <name>')}   ${sage('All official packs at once:')} ${cream('phewsh pack install all')}`);
+  console.log(`  ${sage('Remove:')}  ${cream('phewsh pack remove <name>')}    ${sage('Read about every pack:')} ${cream('phewsh.com/cli#packs')}`);
+  console.log('');
+}
+
+// `phewsh pack install all` — every official (vendored) pack in one confirmed
+// pass. Linked packs stay pointers to their upstream source; we list them so
+// nothing external ever installs silently.
+async function installAll() {
+  const vendored = Object.entries(packs.PACKS).filter(([, p]) => p.kind !== 'linked');
+  const linked = Object.entries(packs.PACKS).filter(([, p]) => p.kind === 'linked');
+  const pending = vendored.filter(([name]) => !packs.isInstalled(name));
+
+  console.log('');
+  if (pending.length === 0) {
+    console.log(`  ${sage('All official packs are already installed here.')}`);
+  } else {
+    console.log(`  ${b(cream('Official phewsh packs'))} ${sage('— ' + pending.length + ' to install:')}`);
+    pending.forEach(([name, p]) => console.log(`    ${cream(name.padEnd(16))} ${slate(p.desc)}`));
+    console.log('');
+    const ok = await confirm(`  ${b('Install ' + (pending.length === 1 ? 'it' : 'all ' + pending.length) + ' here?')} ${slate('[y/N] ')}`);
+    if (!ok) { console.log(`  ${sage('Nothing changed.')}\n`); return; }
+    for (const [name] of pending) {
+      const { written } = packs.install(name);
+      console.log(`  ${green('●')} ${cream(name)} ${slate('→ ' + written.join(', '))}`);
+    }
+    console.log(`  ${sage('Remove any:')} ${cream('phewsh pack remove <name>')}`);
+  }
+  if (linked.length > 0) {
+    console.log('');
+    console.log(`  ${sage(linked.length + ' more are linked packs — separate tools phewsh points at but never auto-installs:')}`);
+    console.log(`    ${cream('phewsh pack')} ${sage('lists them ·')} ${cream('phewsh.com/cli#packs')} ${sage('tells their stories')}`);
+  }
   console.log('');
 }
 
@@ -89,6 +121,7 @@ function remove(name) {
 async function main() {
   const sub = process.argv[3];
   const name = process.argv[4];
+  if (sub === 'install' && name === 'all') return installAll();
   if (sub === 'install' && name) return install(name);
   if (sub === 'remove' && name) return remove(name);
   return list();

package/commands/session.js

@@ -733,6 +733,39 @@ async function main() {
     console.log('');
   }
 
+  // The project scanner — bootstrap option AND /scan slash command. Lists
+  // .intent/ projects plus likely candidates (git, no .intent yet, reason
+  // shown) from the usual folders, numbered so a bare digit opens one.
+  function runScanMenu() {
+    const spin = ui.spinner('scanning your usual folders');
+    const found = scanForProjects();
+    let candidates = [];
+    try { candidates = scanForCandidates(); } catch { /* advisory — scan still useful without it */ }
+    spin.stop();
+    if (found.length === 0 && candidates.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.')}`);
+      return;
+    }
+    bootstrapChoices = [];
+    if (found.length > 0) {
+      console.log(`  ${teal('●')} ${sage(`Found ${found.length} project${found.length !== 1 ? 's' : ''} with .intent/:`)}`);
+      for (const p of found) {
+        bootstrapChoices.push({ kind: 'open', path: p.path });
+        console.log(`  ${teal(String(bootstrapChoices.length))} ${cream(p.name)} ${slate('· ' + tildify(p.path))}`);
+      }
+    }
+    if (candidates.length > 0) {
+      console.log(`  ${teal('●')} ${sage(`${candidates.length} likely candidate${candidates.length !== 1 ? 's' : ''} — no shared memory yet:`)}`);
+      for (const p of candidates) {
+        bootstrapChoices.push({ kind: 'open', path: p.path });
+        console.log(`  ${teal(String(bootstrapChoices.length))} ${cream(p.name)} ${slate('· ' + tildify(p.path) + ' · ' + p.reason)}`);
+      }
+    }
+    console.log(`  ${slate('pick a number to open it')}`);
+  }
+
   function showBootstrapMenu(projects) {
     console.log(`  ${b(cream('Where do you want to work?'))}`);
     bootstrapChoices = [];
@@ -976,7 +1009,7 @@ async function main() {
   // RECOGNIZED leading /command (or @harness) token turns teal (peach for @)
   // so you know it registered. Arguments stay plain. TTY-only, fail-soft.
   const KNOWN_COMMANDS = new Set([
-    'quit', 'exit', 'q', 'help', 'h', 'init', 'intent', 'clarify', 'model',
+    'quit', 'exit', 'q', 'help', 'h', 'init', 'intent', 'clarify', 'scan', 'model',
     'models', 'council', 'all', 'provider', 'route', 'use', 'work', 'switch', 'run',
     'clear', 'status', 'key', 'login', 'export', 'push', 'pull', 'serve',
     'sync', 'harnesses', 'fallback', 'outcomes', 'tour', 'update', 'upgrade',
@@ -1277,8 +1310,11 @@ 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)) {
+    // Scan/bootstrap menu: a bare number opens a project, inits, or scans.
+    // Any other input means the user moved on — drop the menu so it never
+    // shadows a later digit (mirrors the nextChoices rule above).
+    if (bootstrapChoices && !/^[0-9]{1,2}$/.test(input)) bootstrapChoices = null;
+    if (bootstrapChoices && /^[0-9]{1,2}$/.test(input)) {
       const choice = bootstrapChoices[parseInt(input, 10) - 1];
       if (!choice) {
         console.log(`  ${sage('Pick 1-' + bootstrapChoices.length)}`);
@@ -1293,8 +1329,8 @@ async function main() {
       if (choice.kind === 'init') {
         bootstrapChoices = null;
         try {
-          const { execSync } = require('child_process');
-          execSync('node ' + path.join(__dirname, 'intent.js') + ' --init', { stdio: 'inherit' });
+          const { execFileSync } = require('child_process');
+          execFileSync(process.execPath, [path.join(__dirname, '..', 'bin', 'phewsh.js'), 'intent', '--init'], { stdio: 'inherit' });
           intentFiles = loadIntentContext();
           systemPrompt = buildSystemPrompt(intentFiles);
           if (intentFiles.length > 0) {
@@ -1309,35 +1345,7 @@ async function main() {
         return;
       }
       if (choice.kind === 'scan') {
-        const spin = ui.spinner('scanning your usual folders');
-        const found = scanForProjects();
-        // Likely candidates: real repos with no .intent/ yet — the projects
-        // most worth grounding. Same shallow scan; shown with their reason.
-        let candidates = [];
-        try { candidates = scanForCandidates(); } catch { /* advisory — scan still useful without it */ }
-        spin.stop();
-        if (found.length === 0 && candidates.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 {
-          bootstrapChoices = [];
-          if (found.length > 0) {
-            console.log(`  ${teal('●')} ${sage(`Found ${found.length} project${found.length !== 1 ? 's' : ''} with .intent/:`)}`);
-            for (const p of found) {
-              bootstrapChoices.push({ kind: 'open', path: p.path });
-              console.log(`  ${teal(String(bootstrapChoices.length))} ${cream(p.name)} ${slate('· ' + tildify(p.path))}`);
-            }
-          }
-          if (candidates.length > 0) {
-            console.log(`  ${teal('●')} ${sage(`${candidates.length} likely candidate${candidates.length !== 1 ? 's' : ''} — no shared memory yet:`)}`);
-            for (const p of candidates) {
-              bootstrapChoices.push({ kind: 'open', path: p.path });
-              console.log(`  ${teal(String(bootstrapChoices.length))} ${cream(p.name)} ${slate('· ' + tildify(p.path) + ' · ' + p.reason)}`);
-            }
-          }
-          console.log(`  ${slate('pick a number to open it')}`);
-        }
+        runScanMenu();
         console.log('');
         rl.prompt();
         return;
@@ -1671,6 +1679,7 @@ async function main() {
           console.log(`    ${teal('@name')} ${slate('<msg>')}   ${sage('one message to one tool — @codex review this')}`);
           console.log(`    ${teal('/work')} ${slate('[tool]')}  ${sage('hand off to the full interactive tool, outcome on return')}`);
           console.log(`    ${teal('/clarify')}       ${sage('turn messy thoughts into .intent/ artifacts')}`);
+          console.log(`    ${teal('/scan')}          ${sage('find your projects — and repos that need shared memory')}`);
           console.log(`    ${teal('/outcomes')}      ${sage('label what you kept — the record that gets smarter')}`);
           console.log('');
           console.log(`  ${slate('/help all')} ${sage('everything')}  ${slate('·')}  ${slate('/tour')} ${sage('walkthrough')}  ${slate('·')}  ${slate('/quit')} ${sage('exit')}`);
@@ -1688,6 +1697,7 @@ async function main() {
         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('/scan')}        ${sage('Find your projects — and likely candidates with no .intent/ yet')}`);
         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')}`);
@@ -1906,8 +1916,8 @@ async function main() {
           console.log(`  ${sage('Use /reload to refresh context')}\n`);
         } else {
           try {
-            const { execSync } = require('child_process');
-            execSync('node ' + path.join(__dirname, 'intent.js') + ' --init', { stdio: 'inherit' });
+            const { execFileSync } = require('child_process');
+            execFileSync(process.execPath, [path.join(__dirname, '..', 'bin', 'phewsh.js'), 'intent', '--init'], { stdio: 'inherit' });
             intentFiles = loadIntentContext();
             systemPrompt = buildSystemPrompt(intentFiles);
             if (intentFiles.length > 0) {
@@ -1922,6 +1932,13 @@ async function main() {
         return;
       }
 
+      if (cmd === 'scan') {
+        runScanMenu();
+        console.log('');
+        rl.prompt();
+        return;
+      }
+
       if (cmd === 'clarify') {
         try {
           const { spawnSync } = require('child_process');

package/lib/cors.js

@@ -37,6 +37,12 @@ function corsHeaders(req) {
     'Access-Control-Allow-Origin': origin,
     'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
     'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Phewsh-Runtime',
+    // Chrome Local/Private Network Access: an HTTPS page (phewsh.com) fetching
+    // plain-http loopback gets a preflight carrying Access-Control-Request-
+    // Private-Network; without this answer Chrome kills the request before it
+    // is ever sent — the cockpit shows "bridge offline" while serve is
+    // demonstrably up. Loopback-only server, allowlisted origins only.
+    'Access-Control-Allow-Private-Network': 'true',
     'Access-Control-Max-Age': '600',
     Vary: 'Origin',
   };

package/lib/packs.js

@@ -54,11 +54,11 @@ const PACKS = {
   },
   'loop-library': {
     kind: 'linked',
-    title: 'Loop Library',
-    desc: 'Copy-ready agent loops with checks and stopping conditions. Good Work-layer inspiration; phewsh links to it without becoming a scheduler or runner.',
-    source: 'github.com/Forward-Future/loop-library · signals.forwardfuture.ai/loop-library',
+    title: 'Loop Library / Loopy',
+    desc: 'Forward Future\'s practical agent-loop library and Loopy skill, with checks and stopping conditions. Good Work-layer inspiration; phewsh links to it without becoming a scheduler or runner.',
+    source: 'signals.forwardfuture.com/loop-library · github.com/Forward-Future/loop-library',
     license: 'MIT',
-    install: 'npx skills add Forward-Future/loop-library --skill loop-library -g   # install through upstream skills tooling',
+    install: 'npx skills add Forward-Future/loop-library --skill loopy -g   # install Loopy through upstream skills tooling',
   },
   'matt-skills': {
     kind: 'linked',

package/package.json

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