phewsh 0.15.79 → 0.15.81

package/bin/phewsh.js

@@ -103,6 +103,8 @@ const COMMANDS = {
   setup:   () => require('../commands/setup')(),
   update:  () => require('../commands/update')(),
   serve:   () => require('../commands/serve')(),
+  project: () => require('../commands/project')(),
+  projects: () => require('../commands/project')(),
   sequence: () => require('../commands/sequence')(),
   seq:     () => require('../commands/sequence')(),
   ambient: () => require('../commands/ambient')(),
@@ -161,6 +163,7 @@ function showHelp() {
   console.log(`    ${cyan('watch')}      ${g('Auto-sync .intent/ → native harness files + cloud')}`);
   console.log(`    ${cyan('push/pull')}  ${g('Manual sync to/from phewsh.com/intent')}`);
   console.log(`    ${cyan('serve')}      ${g('Execution bridge — run from phewsh.com/ion or /intent')}`);
+  console.log(`    ${cyan('project')}    ${g('Choose which projects this machine\'s worker shows on /ion')}`);
   console.log(`    ${cyan('ion')}        ${g('Shared visual room for humans + local agents')}`);
   console.log(`    ${cyan('mcp')}        ${g('Connect AI agents via MCP protocol')}`);
   console.log(`    ${cyan('ambient')}    ${g('Continuity without launching phewsh — enhance your other tools')}`);

package/commands/ion.js

@@ -35,8 +35,9 @@ function showHelp() {
     ${cyan('phewsh ion')}              ${sage('open phewsh.com/ion')}
     ${cyan('phewsh ion open')}         ${sage('same')}
 
-  ${sage('Make this machine available')}
-    ${cyan('phewsh ion serve')}        ${sage('start the local worker bridge')}
+  ${sage('Make this machine available — the two-step')}
+    ${cyan('phewsh project add')}      ${sage('1. register this repo (once per repo)')}
+    ${cyan('phewsh serve')}            ${sage('2. one worker serves the whole machine')}
     ${cyan('phewsh ion status')}       ${sage('show bridge/project/task status')}
 
   ${sage('Use the existing task loop')}
@@ -92,7 +93,7 @@ module.exports = async function run() {
     if (sub === 'serve' || sub === 'worker') return runServe(rest);
     if (sub === 'status') {
       console.log(`\n  ${cream('Ion room:')} ${cyan(WEB_URL)}`);
-      console.log(`  ${sage('Local worker:')} ${cream('phewsh ion serve')}`);
+      console.log(`  ${sage('Local worker:')} ${cream('phewsh project add')} ${sage('(once per repo), then')} ${cream('phewsh serve')}`);
       return runTask(['list']);
     }
     if (sub === 'task' || sub === 'tasks') return runTask(rest.length ? rest : ['list']);

package/commands/project.js

@@ -0,0 +1,121 @@
+// phewsh project — the serve registry: which projects may this machine's
+// worker expose to phewsh.com/ion and /cockpit?
+//
+// Jul 8 2026 Option C ruling: one worker per machine, explicit registry,
+// identity = normalized git remote (never the folder name). Adding a project
+// here does NOT execute anything and does NOT let anyone run work remotely —
+// it only makes the project visible as "online" when `phewsh serve` runs.
+// Manual claim remains the execution boundary.
+//
+// Usage:
+//   phewsh project              Show the registry + what to do next
+//   phewsh project add [path]   Register a project (default: this directory)
+//   phewsh project list         Same as bare `phewsh project`
+//   phewsh project remove <name|path>   Stop exposing a project
+
+const path = require('path');
+const { addServeProject, removeServeProject, serveProjects } = require('../lib/projects-index');
+
+const b = (s) => `\x1b[1m${s}\x1b[0m`;
+const g = (s) => `\x1b[38;5;247m${s}\x1b[0m`;
+const w = (s) => `\x1b[97m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+
+function showList() {
+  const projects = serveProjects();
+  console.log('');
+  console.log(`  ${b(w('Served projects'))} ${g('— what this machine\'s worker shows on phewsh.com/ion')}`);
+  console.log('');
+  if (projects.length === 0) {
+    console.log(`  ${g('None yet. Registering a project is one command, run inside its repo:')}`);
+    console.log('');
+    console.log(`    ${cyan('cd <your-project> && phewsh project add')}`);
+    console.log('');
+    console.log(`  ${g('Then start the worker once for the whole machine:')}  ${cyan('phewsh serve')}`);
+  } else {
+    for (const p of projects) {
+      console.log(`  ${green('●')} ${w(p.name)}`);
+      console.log(`     ${g('repo:')} ${g(p.remote || 'no remote')}`);
+      console.log(`     ${g('path:')} ${g(p.path)}`);
+    }
+    console.log('');
+    console.log(`  ${g('These appear as this machine\'s projects when')} ${cyan('phewsh serve')} ${g('is running.')}`);
+    console.log(`  ${g('Add another:')} ${cyan('phewsh project add [path]')}   ${g('Stop exposing one:')} ${cyan('phewsh project remove <name>')}`);
+  }
+  console.log('');
+  console.log(`  ${g('Registering never executes anything — work still starts only when a')}`);
+  console.log(`  ${g('human claims it. See phewsh.com/ion for the team room.')}`);
+  console.log('');
+}
+
+function main() {
+  const args = process.argv.slice(3);
+  const sub = args[0];
+
+  if (sub === 'add') {
+    const dir = args[1] ? path.resolve(args[1]) : process.cwd();
+    try {
+      const p = addServeProject(dir);
+      console.log('');
+      console.log(`  ${green('✓')} ${w(p.name)} ${g('registered for this machine\'s worker.')}`);
+      console.log(`     ${g('identity:')} ${g(p.remote)}`);
+      console.log('');
+      console.log(`  ${g('Next:')} ${cyan('phewsh serve')} ${g('— one worker serves every registered project;')}`);
+      console.log(`  ${g('phewsh.com/ion will show it as online on this machine.')}`);
+      console.log('');
+    } catch (err) {
+      console.log('');
+      console.log(`  ${yellow('●')} ${err.message.split('\n').join(`\n  ${g('')}`)}`);
+      console.log('');
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (sub === 'remove' || sub === 'rm') {
+    if (!args[1]) {
+      console.log('');
+      console.log(`  ${g('Which one? ')} ${cyan('phewsh project remove <name|path>')}`);
+      console.log('');
+      showList();
+      process.exit(1);
+    }
+    const hit = removeServeProject(args[1]);
+    console.log('');
+    if (hit) {
+      console.log(`  ${green('✓')} ${w(hit.name)} ${g('is no longer exposed by this machine\'s worker.')}`);
+      console.log(`  ${g('(The project itself is untouched — this only changes what the worker shows.)')}`);
+    } else {
+      console.log(`  ${yellow('●')} ${g('No served project matches')} ${w(args[1])}${g('. Here\'s what\'s registered:')}`);
+      showList();
+      process.exit(1);
+    }
+    console.log('');
+    return;
+  }
+
+  if (sub && sub !== 'list' && sub !== 'ls' && sub !== 'help' && sub !== '--help' && sub !== '-h') {
+    console.log('');
+    console.log(`  ${yellow('●')} ${g('Unknown subcommand:')} ${w(sub)}`);
+  }
+
+  if (sub === 'help' || sub === '--help' || sub === '-h') {
+    console.log('');
+    console.log(`  ${b(w('phewsh project'))} ${g('— choose which projects this machine\'s worker exposes')}`);
+    console.log('');
+    console.log(`    ${cyan('phewsh project')}                    ${g('show the registry + guidance')}`);
+    console.log(`    ${cyan('phewsh project add [path]')}         ${g('register a project (default: here)')}`);
+    console.log(`    ${cyan('phewsh project remove <name|path>')} ${g('stop exposing a project')}`);
+    console.log('');
+    console.log(`  ${g('Safety: registering only affects visibility. Execution always requires')}`);
+    console.log(`  ${g('a human claim — nothing runs remotely because it was registered.')}`);
+    console.log('');
+    return;
+  }
+
+  showList();
+}
+
+module.exports = main;

package/commands/serve.js

@@ -71,6 +71,7 @@ function detectRuntimes() {
 // ─── Job Queue ─────────────────────────────────────────────────────────────
 
 const { gatherReceipts, recordSessionEvent, recordResultFile } = require('../lib/receipts-data');
+const { serveProjects } = require('../lib/projects-index');
 
 const jobs = new Map();
 
@@ -259,10 +260,13 @@ function main() {
 
     // Health check — includes which project this worker is serving, so the
     // web can say "worker online — <project>" instead of an anonymous dot.
+    // `projects` = the explicit serve registry (`phewsh project add`); only
+    // deliberately registered projects are exposed, never the session index.
     if (url.pathname === '/health' && req.method === 'GET') {
       return json(req, res, {
         status: 'ok',
         project: currentProject(),
+        projects: serveProjects().map(p => ({ name: p.name, remote: p.remote })),
         runtimes: detectRuntimes(),
         version: require('../package.json').version,
         uptime: process.uptime(),
@@ -328,6 +332,7 @@ function main() {
           pending: pendingDecisions().length,
           bypasses: bypassStats(),
           recentProjects: listProjects().slice(0, 5).map(p => ({ name: p.name, path: p.path, lastOpened: p.lastOpened })),
+          servedProjects: serveProjects().map(p => ({ name: p.name, remote: p.remote })),
           version: require('../package.json').version,
         });
       } catch (err) {
@@ -408,6 +413,20 @@ function main() {
       console.log(`  ${g('https://docs.anthropic.com/en/docs/claude-code')}`);
     }
     console.log('');
+    const registered = serveProjects();
+    const here = currentProject();
+    console.log(`  ${b('Projects this worker shows on phewsh.com/ion:')}`);
+    if (registered.length === 0) {
+      console.log(`    ${g('only the current directory:')} ${w(here.name)}${here.remote ? g(` (${here.remote})`) : ''}`);
+      console.log(`    ${g('Register projects by name so the web knows them:')} ${cyan('phewsh project add')} ${g('(run inside each repo)')}`);
+    } else {
+      for (const p of registered) {
+        const isHere = p.path === process.cwd();
+        console.log(`    ${green('●')} ${w(p.name)}${g(` (${p.remote})`)}${isHere ? g(' ← current directory') : ''}`);
+      }
+      console.log(`    ${g('Manage the list:')} ${cyan('phewsh project')}`);
+    }
+    console.log('');
     console.log(`  ${g('Open phewsh.com/ion to see the worker online, or phewsh.com/intent → Work')}`);
     console.log(`  ${g('Press Ctrl+C to stop')}`);
     console.log('');

package/lib/packs.js

@@ -44,6 +44,14 @@ const PACKS = {
     targets: ['CLAUDE.md', 'AGENTS.md'],
     content: KARPATHY_GUIDELINES,
   },
+  'boat-to-shore': {
+    kind: 'linked',
+    title: 'Boat to Shore — completion-loop skill',
+    desc: 'A tested Claude skill for recurring autonomous improvement sessions (run it via /loop): one verified slice per session, state-file continuity across resets, branch discipline, honest handoffs. Moves a repo from unfinished (Water) to shippable (Shore) to excellent (Mountain). Pairs with a plan made at phewsh.com/intent.',
+    source: 'github.com/cleverIdeaz/phewsh-cli (skills/boat-to-shore)',
+    license: 'MIT',
+    install: 'mkdir -p ~/.claude/skills/boat-to-shore && curl -fsSL https://raw.githubusercontent.com/cleverIdeaz/phewsh-cli/main/skills/boat-to-shore/SKILL.md -o ~/.claude/skills/boat-to-shore/SKILL.md',
+  },
   gsd: {
     kind: 'linked',
     title: 'GSD — Get Shit Done',

package/lib/projects-index.js

@@ -13,7 +13,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const INDEX_FILE = path.join(os.homedir(), '.phewsh', 'project-index.json');
+// PHEWSH_PROJECT_INDEX override exists for tests only — never point real use away from home.
+const INDEX_FILE = process.env.PHEWSH_PROJECT_INDEX || path.join(os.homedir(), '.phewsh', 'project-index.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.
@@ -114,6 +115,75 @@ function scanForCandidates(roots = SCAN_ROOTS) {
   return found;
 }
 
+// ─── Serve registry (Jul 8 2026 Option C ruling) ────────────────────────────
+// Auto-recorded session entries are NOT auto-exposed to the worker. Only
+// projects the human deliberately registers with `phewsh project add` carry
+// serve:true, and only those appear on the bridge/web. Identity is the
+// normalized git remote — the same convention the task-claim path enforces —
+// never the folder name.
+
+const { execFileSync } = require('child_process');
+const { normalizeRemote } = require('./team-tasks');
+
+function originRemote(dir) {
+  try {
+    return execFileSync('git', ['remote', 'get-url', 'origin'], {
+      cwd: dir, stdio: ['ignore', 'pipe', 'ignore'],
+    }).toString().trim() || null;
+  } catch { return null; }
+}
+
+/**
+ * Register a project so the local worker may expose it. Validates before
+ * writing; throws with a plain-language message when something is missing.
+ */
+function addServeProject(dir) {
+  if (!fs.existsSync(path.resolve(dir))) throw new Error(`That folder doesn't exist: ${path.resolve(dir)}`);
+  const key = fs.realpathSync(path.resolve(dir)); // one entry per real directory, symlinks collapse
+
+  if (!fs.existsSync(path.join(key, '.git'))) {
+    throw new Error(`Not a git repository: ${key}\nA served project needs a repo so work stays traceable. Run this inside a git repo (or git init first).`);
+  }
+  const remote = originRemote(key);
+  if (!remote) {
+    throw new Error(`This repo has no 'origin' remote yet.\nThe remote is the project's identity — it's how phewsh guarantees work lands in the right repo.\nAdd one first:  git remote add origin <url>`);
+  }
+  const index = load();
+  index.projects[key] = {
+    ...(index.projects[key] || {}),
+    name: path.basename(key),
+    path: key,
+    remote: normalizeRemote(remote),
+    serve: true,
+    serveAddedAt: new Date().toISOString(),
+    lastOpened: index.projects[key]?.lastOpened || new Date().toISOString(),
+  };
+  save(index);
+  return index.projects[key];
+}
+
+/** Stop exposing a project (by name or path). The session-index entry stays. */
+function removeServeProject(nameOrPath) {
+  const index = load();
+  let wantPath = path.resolve(nameOrPath);
+  try { wantPath = fs.realpathSync(wantPath); } catch { /* not a live path — name match still works */ }
+  const hit = Object.values(index.projects).find(p =>
+    p.serve && (p.path === wantPath || p.name === nameOrPath));
+  if (!hit) return null;
+  delete index.projects[hit.path].serve;
+  delete index.projects[hit.path].serveAddedAt;
+  save(index);
+  return hit;
+}
+
+/** Projects the worker is allowed to expose, pruned to paths that still exist. */
+function serveProjects() {
+  const index = load();
+  return Object.values(index.projects)
+    .filter(p => p.serve === true && fs.existsSync(p.path))
+    .sort((a, b) => String(a.name).localeCompare(String(b.name)));
+}
+
 function fmtAgo(ts) {
   if (!ts) return '';
   const mins = Math.floor((Date.now() - new Date(ts).getTime()) / 60000);
@@ -123,4 +193,4 @@ function fmtAgo(ts) {
   return `${Math.floor(hrs / 24)}d ago`;
 }
 
-module.exports = { INDEX_FILE, SCAN_ROOTS, recordProject, listProjects, scanForProjects, scanForCandidates, fmtAgo };
+module.exports = { INDEX_FILE, SCAN_ROOTS, recordProject, listProjects, scanForProjects, scanForCandidates, fmtAgo, addServeProject, removeServeProject, serveProjects };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "phewsh",
-  "version": "0.15.79",
-  "description": "One mission. Many AI tools. No lost context. PHEWSH keeps your project's intent, decisions, and working context aligned across Claude Code, Codex, Cursor, Gemini and your team — so the next AI knows what the last one learned.",
+  "version": "0.15.81",
+  "description": "One mission. Many AI tools. No lost context. PHEWSH keeps your project's intent, decisions, and working context aligned across Claude Code, Codex, Cursor, Gemini and your team \u2014 so the next AI knows what the last one learned.",
   "bin": {
     "phewsh": "bin/phewsh.js"
   },
@@ -10,6 +10,7 @@
     "commands/",
     "lib/",
     "mcp/",
+    "skills/",
     "README.md",
     "SECURITY.md",
     "LICENSE"
@@ -54,4 +55,4 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0"
   }
-}
+}

package/skills/boat-to-shore/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: boat-to-shore
+description: Use when running recurring autonomous improvement sessions on a repository (e.g. via /loop or a scheduled continuation), when resuming work after a session reset or context loss, or when moving a repo from unfinished/TODO-riddled toward shippable without a human available to answer questions.
+---
+
+# Boat to Shore
+
+## Overview
+
+Move the repo from **Water** (broken, unclear, unfinished) to **Shore** (runs, builds, core flow works, verified) to **Mountain** (polished, tested, documented, launch-ready). One verified slice per session. The state file is the anchor: every session starts by reading it and ends by updating it. The loop's output is not just code — it's a repo the next session can pick up cold.
+
+**Violating the letter of these rules is violating the spirit of the loop.** A high-quality sprawl is still a sprawl.
+
+## Session sequence
+
+1. **Rehydrate.** Read `./.agent/boat-loop.md`, `git status`/recent log, and README. If the repo has a `.intent/` directory (phewsh), treat it as the project plan and read it first. If the state file is missing, create it: run a first-pass diagnostic (stack, how to run/build/test, TODO/FIXME/placeholder sweep, run the checks) plus a blind-spot pass (unknown unknowns, risky assumptions, map-vs-territory disagreements — the plan is the map, the repo is the territory; when they disagree, trust the territory and log the disagreement).
+2. **Choose ONE slice.** If the state file already names a Current Session Goal or Next best loop, that is your slice — do not renegotiate it. Otherwise pick the single highest-leverage goal completable and verifiable this session. A slice is one *goal*, not everything that happens to live in the same files. Priority order: runs → builds → core flow works → user understands it → verified → survives real use → feels excellent → next agent moves faster.
+3. **Branch.** `git checkout -b boat/<slug>-<date>` (or reuse the existing boat branch). Never work directly on main/master.
+4. **Implement small.** Smallest coherent change that completes the slice. Check `git diff` as you go. No unrelated refactors, no rewrites without proving the current architecture can't support the goal.
+5. **Verify.** Strongest feasible ladder: typecheck/lint → tests → build → local smoke → browser/Playwright when UI behavior matters. A claim without a run check is not a result.
+6. **Push harder — inside the slice's blast radius.** After it works: is there an error/empty/loading state, a locking test, or a doc line attached to *this* slice? Do the best one. Adjacent backlog items are the next loop's slices, not this one's dessert.
+7. **Update state.** Append to `.agent/boat-loop.md` (never overwrite the log): what changed, what was verified, current status (Water/Shore/Mountain), and **Next best loop**. Log non-obvious decisions and deviations from the plan in `.agent/implementation-notes.md` (discovery → decision → why → risk → verification).
+8. **Report** using the template below.
+
+## Hard rules
+
+- **One slice per session.** Even if the backlog looks small enough to finish. Finishing the backlog in one sitting produces an unreviewable diff and an untestable session.
+- **Never commit to main/master.** Branch, always, even in tiny repos.
+- **"Done" is not a state.** There are only Water, Shore, Mountain — and Mountain still gets a "Next best loop" (a strategic push, or an explicit recommendation to the human to stop the loop). If you wrote "Done", replace it.
+- **Verify before claiming.** If a check fails and is out of scope, document it precisely — don't hide it.
+- **Blocked?** Make the safest reversible assumption, log it, keep moving. Ask a question only if it would change architecture, data model, auth, pricing, or ownership — never "should I continue?"
+- **Bounded research.** Competitor/reference scan at most once per repo, only after Shore, output = implementation moves (not a report), stored in `.agent/competitors.md`.
+
+| Rationalization | Reality |
+|---|---|
+| "The remaining items are small — I'll just do them all" | That's three sessions' worth of review risk in one diff. One slice. |
+| "It's all in the same two tiny files — one coherent slice" | File adjacency doesn't merge goals. The state file's scope instruction wins. |
+| "This repo is tiny, master is fine" | The loop runs unattended. Branches are the undo button. |
+| "Everything on the list is fixed — mark it Done" | The list was the map. Re-inspect the territory: embarrassment test, then write the next loop. |
+| "It seems finished" | Prove it: run the checks, load the UI, read it as a stranger. |
+| "Pushing harder means doing more items" | Pushing harder means making *this* slice excellent. |
+
+## Red flags — stop and re-read Hard rules
+
+Working on main · second backlog item in one session · "Done" anywhere · claiming results with no check run · state file unchanged at session end · asking the human what to do next.
+
+## Session report template
+
+```
+## Session Result — <repo> — <date>
+Status: Water | Shore | Mountain
+### Slice completed
+### Verified (commands run + results)
+### Deviations & assumptions (map vs territory)
+### Remaining risks
+### Next best loop
+### Quiz for the human (3 Qs: main improvement? riskiest assumption? what should the next loop do?)
+```
+
+## The mountain question
+
+Before ending any Shore/Mountain session: *if a real user, a buyer, and a future maintainer saw this tomorrow, what would embarrass us?* The highest-impact answer is the next loop's slice.