phewsh 0.15.34 → 0.15.36

package/commands/hook.js

@@ -111,6 +111,28 @@ function sessionStart() {
   const cont = continuityBrief(path.basename(process.cwd()));
   if (cont) parts.push(`\n## Continuity (across your tools)\n${cont}`);
 
+  // Drift nudge (read-only): if code moved ahead of .intent/, say so — right
+  // here, where the agent will see it — so the human knows *when* to reconcile.
+  // We never auto-rewrite their source of truth; we just make the gap visible.
+  try {
+    const { statusDrift } = require('../lib/truth');
+    const drift = statusDrift(process.cwd());
+    if (drift && drift.tracked && drift.commitsSince > 0) {
+      parts.push(`\n## ⚠ phewsh drift\n.intent/ is ${drift.commitsSince} commit(s) behind the code (since ${drift.lastCommit}) — its current-state claims may be stale. Good moment to reconcile so every tool inherits today's reality.`);
+    }
+  } catch { /* drift is a nicety; never break the host */ }
+
+  // Ambient operating guidance: make phewsh *felt*, not invoked. The human may
+  // not know a single slash command — translate intent into phewsh actions for
+  // them, nudge gently, and leave a quiet signature so they feel the layer.
+  parts.push(`\n## Working with phewsh installed (ambient guidance)
+phewsh keeps this project's intent, decisions, and outcomes aligned across every AI tool — so nothing is lost when the human switches tools. Help it work *for* them without making them learn it:
+- Do their actual request first, and well.
+- When you make a real decision, ship something, or change direction, offer in plain language to keep the shared record current — e.g. "want me to reconcile this into phewsh so your other tools inherit it?" Never make them memorize slash commands; map their intent to phewsh actions yourself.
+- If the drift note above is present, mention it once, gently.
+- Keep nudges subtle and occasional — never nag, never block the work.
+- When phewsh context shaped your reply, sign off quietly with 😮‍💨🤫 (e.g. "— 😮‍💨🤫") so the human feels the continuity layer working in the background.`);
+
   parts.push(`\n(Brief injected by PHEWSH ambient from .intent/. Honor the constraints above. The human can run \`phewsh\` for mission control — council, outcomes, the decision record.)`);
 
   process.stdout.write(parts.join('\n') + '\n');
@@ -129,11 +151,17 @@ function sessionEnd() {
     // or any agent) reads today's intent without anyone running `seq -w`. Silent
     // and deterministic; failures never touch the host tool.
     let healed = false;
+    let synced = [];
     try {
       const selfheal = require('../lib/selfheal');
-      if (selfheal.isStale()) healed = selfheal.heal().healed;
+      // Keep EVERY tool's native context file current from .intent/, not just
+      // CLAUDE.md — so the next tool to open here (Codex, Gemini, Cursor, …)
+      // reads today's truth without anyone running a command. Idempotent:
+      // only writes files whose substantive content actually changed.
+      synced = selfheal.syncContextFiles().synced || [];
+      healed = synced.length > 0;
     } catch { /* a hook must never error the host */ }
-    appendBreadcrumb('session-end', { ...(reason ? { reason } : {}), ...(healed ? { healed: true } : {}) });
+    appendBreadcrumb('session-end', { ...(reason ? { reason } : {}), ...(synced.length ? { synced } : {}) });
     process.exit(0);
   });
   // If the host never closes stdin, don't hang it.

package/commands/session.js

@@ -1108,11 +1108,11 @@ async function main() {
       if (/^(y|yes)$/i.test(input.trim())) {
         const r = applyReconciliation(proposal);
         if (r.written) {
-          const healed = selfheal.heal({ force: true });
+          const synced = (selfheal.syncContextFiles().synced) || [];
           intentFiles = loadIntentContext();
           systemPrompt = buildSystemPrompt(intentFiles);
           console.log(`  ${green('✓')} ${sage('Applied the approved diff to ' + r.target + '.')}`);
-          console.log(`  ${slate(healed.healed ? 'Generated Claude context refreshed from the approved intent change.' : 'Intent updated; generated context did not require a write.')}`);
+          console.log(`  ${slate(synced.length ? 'Synced every tool from the approved change: ' + synced.join(', ') + '.' : 'Intent updated; tool context already current.')}`);
         } else {
           console.log(`  ${ember('!')} ${sage('Reconciliation was not applied: ' + r.reason)}`);
         }
@@ -2422,7 +2422,7 @@ async function main() {
         const preflightTruth = await auditTruth();
         const before = captureSnapshot(preflightTruth);
         const generatedBrief = await generateBrief({ report: preflightTruth });
-        const launchBrief = `${generatedBrief.content}\n\nYou are receiving a PHEWSH handoff brief — acknowledge in one short line that you've loaded it, then proceed. Use it as project context, preserve native tool behavior, and verify claims against the repository before acting. When you finish, exit this tool — PHEWSH resumes, runs an automatic postflight comparing what changed against this brief, and offers reconciliation.`;
+        const launchBrief = `${generatedBrief.content}\n\nYou are receiving a PHEWSH handoff brief — acknowledge in one short line that you've loaded it, then proceed. Use it as project context, preserve native tool behavior, and verify claims against the repository before acting. When you finish, exit this tool — PHEWSH resumes, runs an automatic postflight comparing what changed against this brief, and offers reconciliation.\n\nAmbient guidance: the human may not know any phewsh commands — make the layer felt, not invoked. Do their request first; when you make a real decision, ship something, or change direction, offer in plain language to keep the shared record current ("want me to reconcile this into phewsh so your other tools inherit it?"). Keep it subtle, never nag. When phewsh context shaped your reply, sign off quietly with 😮‍💨🤫 so they feel the continuity layer working.`;
         const savedBrief = persistBrief(generatedBrief.content, { project: projectName, route: target });
         const launch = interactiveLaunchArgs(target, launchBrief, { model: harnessModel });
         // Foolproof fallback: the brief on the clipboard survives the native

package/lib/selfheal.js

@@ -76,6 +76,79 @@ function heal({ cwd = process.cwd(), force = false } = {}) {
   }
 }
 
+// ── Multi-tool context sync ──────────────────────────────────────────────
+// phewsh keeps EVERY harness's native context file current from .intent/, not
+// just CLAUDE.md — so opening Codex (AGENTS.md), Gemini (GEMINI.md), or Cursor
+// (.cursorrules) in a phewsh project reads the same truth Claude Code does.
+// Same proven marker pattern (block between PHEWSH:START/END, rest preserved),
+// plus a verifiable signed footer so "is it current?" is `cat`-able, not vibes.
+const TARGET_FILES = ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md', '.cursorrules'];
+const START_MARKER = '<!-- PHEWSH:START -->';
+const END_MARKER = '<!-- PHEWSH:END -->';
+
+function escapeRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+// Strip the volatile signed footer so timestamp-only changes don't cause churn.
+function coreOf(text) {
+  return text.replace(/\n?>\s*—\s*synced by phewsh[\s\S]*$/m, '').trim();
+}
+
+// Insert/replace the phewsh block between markers; create the file (with a
+// short header) if absent; preserve everything outside the markers. Writes
+// only when the substantive content changed (footer timestamp is ignored), so
+// re-running every session doesn't churn files. Returns true if written.
+function upsertBlock(filePath, core, footer, fileLabel) {
+  try {
+    const block = core.replace(/\s*$/, '') + '\n' + footer;
+    const wrapped = `${START_MARKER}\n${block}\n${END_MARKER}`;
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : null;
+    if (existing && existing.includes(START_MARKER) && existing.includes(END_MARKER)) {
+      const re = new RegExp(escapeRe(START_MARKER) + '([\\s\\S]*?)' + escapeRe(END_MARKER));
+      const m = existing.match(re);
+      if (m && coreOf(m[1]) === coreOf(core)) return false; // unchanged but for the timestamp
+      const next = existing.replace(re, wrapped);
+      fs.writeFileSync(filePath, next);
+    } else if (existing) {
+      fs.writeFileSync(filePath, existing.replace(/\s*$/, '') + '\n\n' + wrapped + '\n');
+    } else {
+      const header = `# ${fileLabel} — kept current by phewsh\n> Project context compiled from .intent/. The block below is auto-managed; edit outside the markers.\n\n`;
+      fs.writeFileSync(filePath, header + wrapped + '\n');
+    }
+    return true;
+  } catch { return false; }
+}
+
+// Build the phewsh block once (from .intent/ via the sequencer) and write it
+// into every target tool's context file with a signed, timestamped footer.
+function syncContextFiles({ cwd = process.cwd(), targets = TARGET_FILES } = {}) {
+  try {
+    const intentDir = path.join(cwd, '.intent');
+    if (!fs.existsSync(intentDir)) return { synced: [], reason: 'no-intent' };
+    const { sequence } = require('./sequencer');
+    const prev = process.cwd();
+    let output;
+    try {
+      if (cwd !== prev) process.chdir(cwd);
+      output = sequence({ target: 'claude-md', write: false }).output;
+    } finally {
+      if (cwd !== prev) { try { process.chdir(prev); } catch { /* best-effort */ } }
+    }
+    if (!output) return { synced: [], reason: 'no-output' };
+    let head = '';
+    try {
+      head = require('child_process').execFileSync('git', ['rev-parse', '--short', 'HEAD'],
+        { cwd, encoding: 'utf-8', timeout: 1500, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    } catch { /* not a git repo — fine */ }
+    const stamp = new Date().toISOString().slice(0, 16).replace('T', ' ');
+    const footer = `> — synced by phewsh 😮‍💨🤫 · ${stamp}${head ? ' · ' + head : ''}`;
+    const synced = [];
+    for (const file of targets) {
+      if (upsertBlock(path.join(cwd, file), output, footer, file)) synced.push(file);
+    }
+    return { synced };
+  } catch (err) { return { synced: [], reason: err && err.message ? err.message : 'error' }; }
+}
+
 // The deeper drift: code ships but .intent/ content never gets updated (the
 // exact failure that ate phewsh's own dogfood — 16 versions shipped while
 // next.md stayed days stale). Count git commits authored AFTER the newest
@@ -166,4 +239,5 @@ function appendToNext(block, { cwd = process.cwd(), file = 'next.md' } = {}) {
 module.exports = {
   isStale, heal, newestIntentMs, newestNarrativeMs,
   commitsSinceIntent, worktreeChanges, wrapDraft, appendToNext,
+  syncContextFiles, TARGET_FILES,
 };

package/lib/sequencer/parsers/generic.js

@@ -11,8 +11,15 @@ const TYPE_TO_KIND = {
   readme: 'context',      // README is broad project context
 };
 
+// Strip phewsh's own auto-managed block so the sequencer never re-ingests its
+// own output (AGENTS.md / GEMINI.md / .cursorrules are both written by phewsh
+// AND read as sources — without this, each sync perturbs the next = churn loop).
+function stripPhewshBlock(text) {
+  return text.replace(/<!--\s*PHEWSH:START\s*-->[\s\S]*?<!--\s*PHEWSH:END\s*-->/g, '').trim();
+}
+
 function parse(source) {
-  const content = fs.readFileSync(source.path, 'utf-8');
+  const content = stripPhewshBlock(fs.readFileSync(source.path, 'utf-8'));
   if (!content.trim()) return [];
 
   const mtime = fs.statSync(source.path).mtime.toISOString();

package/package.json

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