phewsh 0.15.35 → 0.15.36

package/commands/hook.js

@@ -151,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)}`);
         }

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.35",
+  "version": "0.15.36",
   "description": "Turn intent into action. Structure your thinking, execute your next step.",
   "bin": {
     "phewsh": "bin/phewsh.js"