infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/context.mjs

@@ -1,34 +1,346 @@
-import c from"node:fs";import y from"node:path";import{execSync as C}from"node:child_process";import{bold as I,gray as g,cyan as p,red as Z,green as d,yellow as _}from"../ui/output.mjs";import{buildCursorImplementPrompt as Ct,buildGenericImplementPrompt as $t}from"../ui/prompts.mjs";import{detectDrift as bt}from"../git/detect-drift.mjs";function jt(n){try{const i=process.platform;if(i==="win32")C("clip",{input:n});else if(i==="darwin")C("pbcopy",{input:n});else try{C("xclip -selection clipboard",{input:n})}catch{C("xsel --clipboard --input",{input:n})}return!0}catch{return!1}}const h="inferno",D=y.join(h,"CONTEXT.md"),tt=y.join(h,"context-state.json");function et(n){try{return JSON.parse(c.readFileSync(n,"utf8"))}catch{return null}}function E(n){try{return c.readFileSync(n,"utf8")}catch{return null}}function nt(){const n=E(tt);if(!n)return{};try{return JSON.parse(n)}catch{return{}}}function ot(n){c.writeFileSync(tt,JSON.stringify(n,null,2),"utf8")}function A(n){return n?new Date(n).toLocaleDateString("en-GB",{day:"2-digit",month:"short",year:"numeric"}):"unknown"}function Ft(n,i){if(!n)return[];const s=[];let l=null;for(const a of n.split(`
-`))if(a.startsWith("## ")){if(l&&s.length<i&&s.push(l),s.length>=i)break;l={title:a.replace("## ","").trim(),items:[]}}else l&&a.startsWith("- ")&&l.items.push(a.replace("- ","").trim());return l&&s.length<i&&s.push(l),s.filter(a=>a.items.length>0)}async function It(n){const i=t=>n.includes(t),s=t=>{const o=n.indexOf(t);return o!==-1&&n[o+1]?n[o+1]:null},l=s("--intent")||s("-i"),a=s("--working")||s("-w"),x=s("--decision")||s("-d"),it=i("--show")||i("-s"),B=i("--copy")||i("-c"),st=i("--cursor"),rt=i("--copilot"),ct=i("--reset"),lt=i("--watch"),P=i("--auto-commit")||i("--auto-push"),L=i("--auto-push"),R=parseInt(s("--interval")||"30",10)*1e3;console.log(`
-  `+I("\uFFFD\uFFFD\uFFFD infernoflow \u2014 context")),console.log("  "+"\u2500".repeat(50)+`
-`),c.existsSync(h)||(console.error(Z("  \u2718 inferno/ not found")),console.error(g(`  \u2192 Run: infernoflow init
-`)),process.exit(1));const S=et(y.join(h,"contract.json")),T=et(y.join(h,"capabilities.json")),at=E(y.join(h,"CHANGELOG.md"));(!S||!T)&&(console.error(Z(`  \u2718 Missing contract.json or capabilities.json
-`)),process.exit(1));let e=nt();ct&&(e={},console.log(_(`  \u26A0 State reset
-`))),l&&(e.intent=l,e.intentUpdated=new Date().toISOString(),console.log(d('  \u2714 Intent saved: "'+l+'"'))),a&&(e.working=a,e.workingUpdated=new Date().toISOString(),console.log(d('  \u2714 Working on: "'+a+'"'))),x&&(e.decisions||(e.decisions=[]),e.decisions.push({text:x,date:new Date().toISOString()}),console.log(d('  \u2714 Decision recorded: "'+x+'"'))),(l||a||x)&&ot(e);const O=T.capabilities||[],V=O.length===(S.capabilities||[]).length,J=Ft(at,3),W=String(S.policyVersion).replace(/^v/i,""),pt=new Date().toLocaleDateString("en-GB",{day:"2-digit",month:"short",year:"numeric"}),U=V?"\u2713 validated":"\u26A0 out of sync",G=e.intent||"describe the exact task to implement",X={task:G,contract:S,caps:T,scenarios:[],state:e},dt=Ct(X),ut=$t(X),gt=O.map(t=>"- **"+t.id+"** \u2014 "+t.title).join(`
-`),mt=J.length>0?J.map(t=>"### "+t.title+`
-`+t.items.map(o=>"  - "+o).join(`
-`)).join(`
-
-`):"_No recent changes_",ft=e.intent?e.intent+"  _("+A(e.intentUpdated)+")_":'_Not set \u2014 run: infernoflow context --intent "..."_',ht=e.working?e.working+"  _("+A(e.workingUpdated)+")_":'_Not set \u2014 run: infernoflow context --working "..."_',wt=e.decisions&&e.decisions.length>0?e.decisions.slice(-5).map(t=>"- "+t.text+"  _("+A(t.date)+")_").join(`
-`):"_No decisions recorded_",M=y.join(h,"sessions.jsonl");let H='_No session history yet \u2014 use: infernoflow log "<what happened>"_';if(c.existsSync(M)){const t=c.readFileSync(M,"utf8").split(`
-`).filter(Boolean).map(o=>{try{return JSON.parse(o)}catch{return null}}).filter(Boolean).slice(-10);t.length&&(H=t.map(o=>{const f=new Date(o.ts).toLocaleString("en-GB",{day:"2-digit",month:"short",hour:"2-digit",minute:"2-digit"}),u=o.result?` [${o.result}]`:"";return`- **${o.type||"note"}**${u}  ${o.summary}  _(${f})_`}).join(`
-`))}const K=y.join(h,"theme.json");let q="_Not scanned yet \u2014 run: infernoflow theme_";if(c.existsSync(K))try{const t=JSON.parse(c.readFileSync(K,"utf8")),o=[];if(t.fonts?.primary&&o.push(`- **Font (primary):** ${t.fonts.primary}`),t.fonts?.mono&&o.push(`- **Font (mono):** ${t.fonts.mono}`),t.colors?.mode&&o.push(`- **Color mode:** ${t.colors.mode}`),t.colors?.palette){const f=Object.entries(t.colors.palette).map(([u,k])=>`${u}=${k}`).join("  ");o.push(`- **Palette:** ${f}`)}if(t.cssVars&&Object.keys(t.cssVars).length){const f=Object.entries(t.cssVars).slice(0,8).map(([u,k])=>`${u}: ${k}`).join("  |  ");o.push(`- **CSS vars:** ${f}`)}t.framework&&o.push(`- **Framework:** ${t.framework}`),o.push("","> \u26A0 Always use these exact values. Do not introduce new colors or fonts."),q=o.join(`
-`)}catch{}const N=["# Project Context \u2014 "+S.policyId+" v"+W,"> Generated by infernoflow | "+pt+" | "+U,"","---","","## Session Memory \u2014 what AI can't infer from code","_Decisions made, failed attempts, gotchas, preferences_","",H,"","---","","## Design System","_Fonts, colors, CSS vars \u2014 always match these exactly_","",q,"","---","","## What this system does","",gt,"","---","","## Recent changes","",mt,"","---","","## Current state","","- **Capabilities:** "+O.length,"- **Version:** v"+W,"- **Sync:** "+U,"","---","","## What I am working on right now","",ht,"","---","","## Intent \u2014 what I want to build next","",ft,"","---","","## Decisions & notes","",wt,"","---","","## Implementation Prompt Seed","","Use this to start coding immediately with an agent:","","```bash",`infernoflow implement "${G}" --mode both`,"```","","### Cursor Agent Prompt","","```text",dt,"```","","### Generic Agent Prompt","","```text",ut,"```","","---","_Paste this block at the start of any new AI session._"].join(`
-`);if(it||(c.writeFileSync(D,N,"utf8"),console.log(d(`
-  \u2714 Context written \u2192 `+D))),B){const t=jt(N);console.log(t?d("  \u2714 Copied to clipboard \u2014 paste with Ctrl+V"):_("  \u26A0 Clipboard copy failed \u2014 open inferno/CONTEXT.md manually"))}if(st&&(c.writeFileSync(".cursorrules",N,"utf8"),console.log(d("  \u2714 Written to .cursorrules \u2014 Cursor loads this automatically"))),rt&&(c.existsSync(".github")||c.mkdirSync(".github"),c.writeFileSync(".github/copilot-instructions.md",N,"utf8"),console.log(d("  \u2714 Written to .github/copilot-instructions.md \u2014 Copilot loads this automatically"))),console.log(`
-  `+I("Context Summary")),console.log("  "+"\u2500".repeat(50)),console.log("  Project      "+S.policyId+" \u2014 v"+W),console.log("  Capabilities "+O.length+" registered"),console.log("  Sync         "+(V?d("\u2713 in sync"):_("\u26A0 check needed"))),console.log("  Working on   "+(e.working?p(e.working):g("not set"))),console.log("  Intent       "+(e.intent?p(e.intent):g("not set"))),console.log("  Decisions    "+(e.decisions?e.decisions.length:0)+` recorded
-`),console.log("  "+I("Implementation Prompt")),console.log("  "+p("\u2192")+" Run "+p(`infernoflow implement "${G}" --mode both`)+`
-`),B?(console.log("  "+I("Ready to use:")),console.log("  "+p("\u2192")+" Paste into Claude / Cursor / Copilot with "+p("Ctrl+V")+`
-`)):(console.log("  "+I("Ready to use:")),console.log("  "+p("1.")+" Open "+p("inferno/CONTEXT.md")),console.log("  "+p("2.")+" Copy everything"),console.log("  "+p("3.")+" Paste at the start of your next AI session"),console.log("  "+g("  tip: use --copy to skip steps 1-2 automatically")+`
-`)),lt){let u=function(m){try{return C(m,{cwd:process.cwd(),encoding:"utf8",stdio:["ignore","pipe","pipe"]}),!0}catch{return!1}},k=function(m){try{return C(`git status --porcelain "${m}"`,{cwd:process.cwd(),encoding:"utf8",stdio:["ignore","pipe","pipe"]}).trim()===""}catch{return!0}},z=function(m,r,v){const b=`chore: update context [${r.length>0?r.slice(0,3).join(", "):`${v} files`}]`;return u(`git add "${m}"`)?k(m)?{ok:!1,reason:"nothing to commit"}:u(`git commit -m "${b}"`)?{ok:!0,msg:b}:{ok:!1,reason:"git commit failed (lock?)"}:{ok:!1,reason:"git add failed"}},Q=function(){return u("git push")};var _t=u,xt=k,Ot=z,Nt=Q;const t=L?"auto-push":P?"auto-commit":"watch";console.log("  "+p("\u{1F441}  Watch mode active")+g(` \u2014 polling every ${R/1e3}s`+(L?" \xB7 will commit + push on change":P?" \xB7 will commit on change":""))),console.log("  "+g(`Press Ctrl+C to stop
-`));let o="",f=null;const Y=async()=>{try{const m=process.cwd(),r=bt(m,{sinceCommits:1}),v=r.changedFiles.sort().join("|");if(v===o||(o=v,r.changedFiles.length===0))return;const $=r.affectedCapabilities.map(F=>F.id),b=$.length>0?`Working on: ${$.join(", ")} (${r.changedFiles.length} files changed)`:`${r.changedFiles.length} files changed \u2014 no capability match yet`,j=nt();if(j.working!==b){j.working=b,j.workingUpdated=new Date().toISOString(),ot(j),await It(n.filter(w=>w!=="--watch"&&w!=="--auto-commit"&&w!=="--auto-push"));const F=E(D),St=new Date().toLocaleTimeString("en-GB",{hour:"2-digit",minute:"2-digit",second:"2-digit"});if(process.stderr.write(`
-  ${d("\u2714")} [${St}] Context updated \u2014 ${$.length} capabilities affected
-  ${g(r.changedFiles.slice(0,3).join(", ")+(r.changedFiles.length>3?` +${r.changedFiles.length-3} more`:""))}
-`),P&&F!==f){f=F;const w=z(D,$,r.changedFiles.length);if(w.ok){if(process.stderr.write(`  ${d("\u2714")} Committed: ${g(w.msg)}
-`),L){const kt=Q();process.stderr.write(kt?`  ${d("\u2714")} Pushed to origin
-`:`  ${_("\u26A0")} Push failed \u2014 will retry next change
-`)}}else process.stderr.write(`  ${_("\u26A0")} Commit skipped: ${g(w.reason)}
-`)}}}catch{}};await Y();const yt=setInterval(Y,R);process.on("SIGINT",()=>{clearInterval(yt),process.stderr.write(`
-  `+g(`Watch stopped.
-
-`)),process.exit(0)}),await new Promise(()=>{})}}export{It as contextCommand};
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { bold, gray, cyan, red, green, yellow } from "../ui/output.mjs";
+import { buildCursorImplementPrompt, buildGenericImplementPrompt } from "../ui/prompts.mjs";
+import { detectDrift } from "../git/detect-drift.mjs";
+
+function copyToClipboard(text) {
+  try {
+    const p = process.platform;
+    if (p === "win32") execSync("clip", { input: text });
+    else if (p === "darwin") execSync("pbcopy", { input: text });
+    else { try { execSync("xclip -selection clipboard", { input: text }); } catch { execSync("xsel --clipboard --input", { input: text }); } }
+    return true;
+  } catch { return false; }
+}
+
+const INFERNO_DIR = "inferno";
+const CONTEXT_FILE = path.join(INFERNO_DIR, "CONTEXT.md");
+const STATE_FILE  = path.join(INFERNO_DIR, "context-state.json");
+
+function readJSON(f) { try { return JSON.parse(fs.readFileSync(f,"utf8")); } catch { return null; } }
+function readFile(f) { try { return fs.readFileSync(f,"utf8"); } catch { return null; } }
+function loadState() { const r=readFile(STATE_FILE); if(!r) return {}; try { return JSON.parse(r); } catch { return {}; } }
+function saveState(s) { fs.writeFileSync(STATE_FILE,JSON.stringify(s,null,2),"utf8"); }
+function fmtDate(iso) { if(!iso) return "unknown"; return new Date(iso).toLocaleDateString("en-GB",{day:"2-digit",month:"short",year:"numeric"}); }
+function parseChangelog(txt,max) {
+  if(!txt) return [];
+  const entries=[]; let cur=null;
+  for(const line of txt.split("\n")) {
+    if(line.startsWith("## ")) { if(cur&&entries.length<max) entries.push(cur); if(entries.length>=max) break; cur={title:line.replace("## ","").trim(),items:[]}; }
+    else if(cur&&line.startsWith("- ")) cur.items.push(line.replace("- ","").trim());
+  }
+  if(cur&&entries.length<max) entries.push(cur);
+  return entries.filter(e=>e.items.length>0);
+}
+
+export async function contextCommand(args) {
+  const has  = (f) => args.includes(f);
+  const flag = (f) => { const i=args.indexOf(f); return i!==-1&&args[i+1]?args[i+1]:null; };
+
+  const intent   = flag("--intent")   || flag("-i");
+  const working  = flag("--working")  || flag("-w");
+  const decision = flag("--decision") || flag("-d");
+  const showOnly = has("--show")  || has("-s");
+  const copyFlag = has("--copy")  || has("-c");
+  const cursorFlag  = has("--cursor");
+  const copilotFlag = has("--copilot");
+  const resetFlag= has("--reset");
+  const watchFlag      = has("--watch");
+  const autoCommit     = has("--auto-commit") || has("--auto-push");
+  const autoPush       = has("--auto-push");
+  const statsFlag      = has("--stats");
+  const watchInterval  = parseInt(flag("--interval") || "30", 10) * 1000;
+
+  console.log("\n  "+bold("��� infernoflow — context"));
+  console.log("  "+"─".repeat(50)+"\n");
+
+  if(!fs.existsSync(INFERNO_DIR)){
+    console.error(red("  ✘ inferno/ not found"));
+    console.error(gray("  → Run: infernoflow init\n"));
+    process.exit(1);
+  }
+
+  const contract     = readJSON(path.join(INFERNO_DIR,"contract.json"));
+  const capabilities = readJSON(path.join(INFERNO_DIR,"capabilities.json"));
+  const changelog    = readFile(path.join(INFERNO_DIR,"CHANGELOG.md"));
+
+  if(!contract||!capabilities){
+    console.error(red("  ✘ Missing contract.json or capabilities.json\n"));
+    process.exit(1);
+  }
+
+  let state = loadState();
+  if(resetFlag){ state={}; console.log(yellow("  ⚠ State reset\n")); }
+  if(intent)   { state.intent=intent; state.intentUpdated=new Date().toISOString(); console.log(green('  ✔ Intent saved: "'+intent+'"')); }
+  if(working)  { state.working=working; state.workingUpdated=new Date().toISOString(); console.log(green('  ✔ Working on: "'+working+'"')); }
+  if(decision) { if(!state.decisions) state.decisions=[]; state.decisions.push({text:decision,date:new Date().toISOString()}); console.log(green('  ✔ Decision recorded: "'+decision+'"')); }
+  if(intent||working||decision) saveState(state);
+
+  const capList   = capabilities.capabilities||[];
+  const allInSync = capList.length===(contract.capabilities||[]).length;
+  const recent    = parseChangelog(changelog,3);
+  const version   = String(contract.policyVersion).replace(/^v/i,"");
+  const now       = new Date().toLocaleDateString("en-GB",{day:"2-digit",month:"short",year:"numeric"});
+  const syncBadge = allInSync?"✓ validated":"⚠ out of sync";
+  const implementTask = state.intent || "describe the exact task to implement";
+  const implementInput = { task: implementTask, contract, caps: capabilities, scenarios: [], state };
+  const cursorPrompt = buildCursorImplementPrompt(implementInput);
+  const genericPrompt = buildGenericImplementPrompt(implementInput);
+
+  const capLines  = capList.map(c=>"- **"+c.id+"** — "+c.title).join("\n");
+  const chgLines  = recent.length>0 ? recent.map(e=>"### "+e.title+"\n"+e.items.map(i=>"  - "+i).join("\n")).join("\n\n") : "_No recent changes_";
+  const intentLine  = state.intent   ? state.intent+"  _("+fmtDate(state.intentUpdated)+")_"  : "_Not set — run: infernoflow context --intent \"...\"_";
+  const workingLine = state.working  ? state.working+"  _("+fmtDate(state.workingUpdated)+")_" : "_Not set — run: infernoflow context --working \"...\"_";
+  const decLines    = state.decisions&&state.decisions.length>0 ? state.decisions.slice(-5).map(d=>"- "+d.text+"  _("+fmtDate(d.date)+")_").join("\n") : "_No decisions recorded_";
+
+  // ── Session memory (what AI can't infer from code) ────────────────────────
+  const sessionsFile = path.join(INFERNO_DIR, "sessions.jsonl");
+  let sessionLines = "_No session history yet — use: infernoflow log \"<what happened>\"_";
+  if (fs.existsSync(sessionsFile)) {
+    const entries = fs.readFileSync(sessionsFile, "utf8")
+      .split("\n").filter(Boolean)
+      .map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(Boolean)
+      .slice(-10); // last 10 entries
+    if (entries.length) {
+      sessionLines = entries.map(e => {
+        const ts = new Date(e.ts).toLocaleString("en-GB",{day:"2-digit",month:"short",hour:"2-digit",minute:"2-digit"});
+        const result = e.result ? ` [${e.result}]` : "";
+        return `- **${e.type||"note"}**${result}  ${e.summary}  _(${ts})_`;
+      }).join("\n");
+    }
+  }
+
+  // ── Design system (theme.json) ────────────────────────────────────────────
+  const themeFile = path.join(INFERNO_DIR, "theme.json");
+  let themeLines = "_Not scanned yet — run: infernoflow theme_";
+  if (fs.existsSync(themeFile)) {
+    try {
+      const theme = JSON.parse(fs.readFileSync(themeFile, "utf8"));
+      const lines = [];
+      if (theme.fonts?.primary)  lines.push(`- **Font (primary):** ${theme.fonts.primary}`);
+      if (theme.fonts?.mono)     lines.push(`- **Font (mono):** ${theme.fonts.mono}`);
+      if (theme.colors?.mode)    lines.push(`- **Color mode:** ${theme.colors.mode}`);
+      if (theme.colors?.palette) {
+        const pal = Object.entries(theme.colors.palette).map(([k,v])=>`${k}=${v}`).join("  ");
+        lines.push(`- **Palette:** ${pal}`);
+      }
+      if (theme.cssVars && Object.keys(theme.cssVars).length) {
+        const vars = Object.entries(theme.cssVars).slice(0,8).map(([k,v])=>`${k}: ${v}`).join("  |  ");
+        lines.push(`- **CSS vars:** ${vars}`);
+      }
+      if (theme.framework) lines.push(`- **Framework:** ${theme.framework}`);
+      lines.push("", "> ⚠ Always use these exact values. Do not introduce new colors or fonts.");
+      themeLines = lines.join("\n");
+    } catch {}
+  }
+
+  const md = [
+    "# Project Context — "+contract.policyId+" v"+version,
+    "> Generated by infernoflow | "+now+" | "+syncBadge,
+    "","---","",
+    "## Session Memory — what AI can't infer from code",
+    "_Decisions made, failed attempts, gotchas, preferences_","",
+    sessionLines,"","---","",
+    "## Design System",
+    "_Fonts, colors, CSS vars — always match these exactly_","",
+    themeLines,"","---","",
+    "## What this system does","",capLines,"","---","",
+    "## Recent changes","",chgLines,"","---","",
+    "## Current state","",
+    "- **Capabilities:** "+capList.length,
+    "- **Version:** v"+version,
+    "- **Sync:** "+syncBadge,
+    "","---","",
+    "## What I am working on right now","",workingLine,"","---","",
+    "## Intent — what I want to build next","",intentLine,"","---","",
+    "## Decisions & notes","",decLines,"","---",
+    "",
+    "## Implementation Prompt Seed","",
+    "Use this to start coding immediately with an agent:","",
+    "```bash",
+    `infernoflow implement "${implementTask}" --mode both`,
+    "```",
+    "",
+    "### Cursor Agent Prompt","",
+    "```text",
+    cursorPrompt,
+    "```",
+    "",
+    "### Generic Agent Prompt","",
+    "```text",
+    genericPrompt,
+    "```",
+    "",
+    "---",
+    "_Paste this block at the start of any new AI session._"
+  ].join("\n");
+
+  if(!showOnly){ fs.writeFileSync(CONTEXT_FILE,md,"utf8"); console.log(green("\n  ✔ Context written → "+CONTEXT_FILE)); }
+
+  if(copyFlag){
+    const ok=copyToClipboard(md);
+    console.log(ok ? green("  ✔ Copied to clipboard — paste with Ctrl+V") : yellow("  ⚠ Clipboard copy failed — open inferno/CONTEXT.md manually"));
+  }
+
+  if (cursorFlag) {
+    fs.writeFileSync(".cursorrules", md, "utf8");
+    console.log(green("  ✔ Written to .cursorrules — Cursor loads this automatically"));
+  }
+  if (copilotFlag) {
+    if (!fs.existsSync(".github")) fs.mkdirSync(".github");
+    fs.writeFileSync(".github/copilot-instructions.md", md, "utf8");
+    console.log(green("  ✔ Written to .github/copilot-instructions.md — Copilot loads this automatically"));
+  }
+  console.log("\n  "+bold("Context Summary"));
+  console.log("  "+"─".repeat(50));
+  console.log("  Project      "+contract.policyId+" — v"+version);
+  console.log("  Capabilities "+capList.length+" registered");
+  console.log("  Sync         "+(allInSync?green("✓ in sync"):yellow("⚠ check needed")));
+  console.log("  Working on   "+(state.working?cyan(state.working):gray("not set")));
+  console.log("  Intent       "+(state.intent ?cyan(state.intent) :gray("not set")));
+  console.log("  Decisions    "+(state.decisions?state.decisions.length:0)+" recorded");
+
+  // Brief stats line when --stats flag is set
+  if (statsFlag) {
+    try {
+      const { statsCommand } = await import("./stats.mjs");
+      process.stdout.write("\n");
+      await statsCommand(["--brief"]);
+    } catch {}
+  }
+  console.log();
+  console.log("  "+bold("Implementation Prompt"));
+  console.log("  "+cyan("→")+" Run "+cyan(`infernoflow implement "${implementTask}" --mode both`)+"\n");
+
+  if(copyFlag){
+    console.log("  "+bold("Ready to use:"));
+    console.log("  "+cyan("→")+" Paste into Claude / Cursor / Copilot with "+cyan("Ctrl+V")+"\n");
+  } else {
+    console.log("  "+bold("Ready to use:"));
+    console.log("  "+cyan("1.")+" Open "+cyan("inferno/CONTEXT.md"));
+    console.log("  "+cyan("2.")+" Copy everything");
+    console.log("  "+cyan("3.")+" Paste at the start of your next AI session");
+    console.log("  "+gray("  tip: use --copy to skip steps 1-2 automatically")+"\n");
+  }
+
+  // ── Watch mode ────────────────────────────────────────────────────────────
+  if (watchFlag) {
+    const modeLabel = autoPush ? "auto-push" : autoCommit ? "auto-commit" : "watch";
+    console.log("  " + cyan("👁  Watch mode active") + gray(
+      ` — polling every ${watchInterval / 1000}s` +
+      (autoPush ? " · will commit + push on change" : autoCommit ? " · will commit on change" : "")
+    ));
+    console.log("  " + gray("Press Ctrl+C to stop\n"));
+
+    let lastChangedFiles = "";
+    let lastCommittedContent = null;
+
+    // ── git helpers ──────────────────────────────────────────────────────
+    function gitRun(cmd) {
+      try {
+        execSync(cmd, { cwd: process.cwd(), encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        return true;
+      } catch { return false; }
+    }
+
+    function gitIsCleanFor(filePath) {
+      // Returns true if the file has no staged/unstaged changes (nothing to commit)
+      try {
+        const out = execSync(`git status --porcelain "${filePath}"`, {
+          cwd: process.cwd(), encoding: "utf8", stdio: ["ignore", "pipe", "pipe"]
+        }).trim();
+        return out === "";
+      } catch { return true; }
+    }
+
+    function commitContext(contextPath, affectedCaps, changedCount) {
+      const caps  = affectedCaps.length > 0 ? affectedCaps.slice(0, 3).join(", ") : `${changedCount} files`;
+      const msg   = `chore: update context [${caps}]`;
+      const staged = gitRun(`git add "${contextPath}"`);
+      if (!staged) return { ok: false, reason: "git add failed" };
+      if (gitIsCleanFor(contextPath)) return { ok: false, reason: "nothing to commit" };
+      const committed = gitRun(`git commit -m "${msg}"`);
+      if (!committed) return { ok: false, reason: "git commit failed (lock?)" };
+      return { ok: true, msg };
+    }
+
+    function pushContext() {
+      const ok = gitRun("git push");
+      return ok;
+    }
+
+    // ── poll loop ────────────────────────────────────────────────────────
+    const poll = async () => {
+      try {
+        const cwd = process.cwd();
+        const drift = detectDrift(cwd, { sinceCommits: 1 });
+        const changedKey = drift.changedFiles.sort().join("|");
+
+        if (changedKey === lastChangedFiles) return;
+        lastChangedFiles = changedKey;
+        if (drift.changedFiles.length === 0) return;
+
+        // Update "working" field
+        const affected = drift.affectedCapabilities.map(c => c.id);
+        const newWorking = affected.length > 0
+          ? `Working on: ${affected.join(", ")} (${drift.changedFiles.length} files changed)`
+          : `${drift.changedFiles.length} files changed — no capability match yet`;
+
+        const currentState = loadState();
+        if (currentState.working !== newWorking) {
+          currentState.working = newWorking;
+          currentState.workingUpdated = new Date().toISOString();
+          saveState(currentState);
+
+          // Regenerate CONTEXT.md silently
+          await contextCommand(args.filter(a => a !== "--watch" && a !== "--auto-commit" && a !== "--auto-push"));
+
+          const newContent = readFile(CONTEXT_FILE);
+          const ts = new Date().toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+
+          process.stderr.write(
+            `\n  ${green("✔")} [${ts}] Context updated — ${affected.length} capabilities affected\n` +
+            `  ${gray(drift.changedFiles.slice(0, 3).join(", ") + (drift.changedFiles.length > 3 ? ` +${drift.changedFiles.length - 3} more` : ""))}\n`
+          );
+
+          // Auto-commit if enabled and content actually changed
+          if (autoCommit && newContent !== lastCommittedContent) {
+            lastCommittedContent = newContent;
+            const result = commitContext(CONTEXT_FILE, affected, drift.changedFiles.length);
+            if (result.ok) {
+              process.stderr.write(`  ${green("✔")} Committed: ${gray(result.msg)}\n`);
+              if (autoPush) {
+                const pushed = pushContext();
+                process.stderr.write(
+                  pushed
+                    ? `  ${green("✔")} Pushed to origin\n`
+                    : `  ${yellow("⚠")} Push failed — will retry next change\n`
+                );
+              }
+            } else {
+              process.stderr.write(`  ${yellow("⚠")} Commit skipped: ${gray(result.reason)}\n`);
+            }
+          }
+        }
+      } catch {
+        // Silent — watch mode never crashes
+      }
+    };
+
+    // Poll immediately then on interval
+    await poll();
+    const timer = setInterval(poll, watchInterval);
+
+    process.on("SIGINT", () => {
+      clearInterval(timer);
+      process.stderr.write("\n  " + gray("Watch stopped.\n\n"));
+      process.exit(0);
+    });
+
+    // Prevent Node from exiting
+    await new Promise(() => {});
+  }
+}