infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/switch.mjs

@@ -0,0 +1,310 @@
+/**
+ * infernoflow switch
+ *
+ * Generates a handoff summary when switching between AI agents
+ * (Copilot → Cursor → Claude → Windsurf → etc.).
+ *
+ * Captures the full session state — what was tried, what worked, what's
+ * in progress, the design system, and the capability context — into a
+ * single pasteable block so the next agent picks up exactly where you left off.
+ *
+ * Session boundary detection (same logic as `infernoflow recap`):
+ *   - All entries since the last `handoff` entry, or the last 24h — whichever is more recent
+ *   - Use --since to override (e.g. --since 48h, --since 2026-04-20)
+ *   - Use --all to include every entry ever logged
+ *
+ * Also writes inferno/HANDOFF.md (auto-loaded by some IDEs).
+ *
+ * Usage:
+ *   infernoflow switch                  Generate handoff + write HANDOFF.md
+ *   infernoflow switch --to cursor      Label the handoff for a specific agent
+ *   infernoflow switch --copy           Copy to clipboard
+ *   infernoflow switch --show           Print current HANDOFF.md
+ *   infernoflow switch --json           Output as JSON
+ *   infernoflow switch --since 48h      Include entries from the last 48 hours
+ *   infernoflow switch --all            Include all entries ever logged
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+const INFERNO_DIR    = "inferno";
+const HANDOFF_FILE   = path.join(INFERNO_DIR, "HANDOFF.md");
+const SESSIONS_FILE  = path.join(INFERNO_DIR, "sessions.jsonl");
+const STATE_FILE     = path.join(INFERNO_DIR, "context-state.json");
+const CONTRACT_FILE  = path.join(INFERNO_DIR, "contract.json");
+const THEME_FILE     = path.join(INFERNO_DIR, "theme.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 fmtDate(iso) {
+  if (!iso) return "unknown";
+  return new Date(iso).toLocaleString("en-GB", { day: "2-digit", month: "short", hour: "2-digit", minute: "2-digit" });
+}
+
+function getAllEntries() {
+  if (!fs.existsSync(SESSIONS_FILE)) return [];
+  return fs.readFileSync(SESSIONS_FILE, "utf8")
+    .split("\n").filter(Boolean)
+    .map(l => { try { return JSON.parse(l); } catch { return null; } })
+    .filter(Boolean);
+}
+
+/**
+ * Find the start of the "current session":
+ *   - The timestamp of the last `handoff` entry, OR 24h ago — whichever is more recent
+ *   - --since overrides both; --all returns epoch (everything)
+ */
+function findSessionStart(allEntries, sinceArg, allFlag) {
+  if (allFlag) return new Date(0);
+
+  if (sinceArg) {
+    const hoursMatch = sinceArg.match(/^(\d+)h$/i);
+    const daysMatch  = sinceArg.match(/^(\d+)d$/i);
+    if (hoursMatch) return new Date(Date.now() - parseInt(hoursMatch[1]) * 3600000);
+    if (daysMatch)  return new Date(Date.now() - parseInt(daysMatch[1]) * 86400000);
+    const parsed = new Date(sinceArg);
+    if (!isNaN(parsed)) return parsed;
+  }
+
+  // Find last handoff entry
+  for (let i = allEntries.length - 1; i >= 0; i--) {
+    if (allEntries[i].type === "handoff") {
+      const ts = new Date(allEntries[i].ts || 0);
+      const dayAgo = new Date(Date.now() - 86400000);
+      return ts > dayAgo ? ts : dayAgo;
+    }
+  }
+
+  return new Date(Date.now() - 86400000);
+}
+
+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; }
+}
+
+function buildHandoff(toAgent, sinceArg, allFlag) {
+  const state      = readJSON(STATE_FILE)    || {};
+  const contract   = readJSON(CONTRACT_FILE) || {};
+  const theme      = readJSON(THEME_FILE);
+  const allEntries = getAllEntries();
+  const sessionStart = findSessionStart(allEntries, sinceArg, allFlag);
+  // Session entries: everything since boundary; also keep last 5 for "recent log"
+  const sessions   = allEntries.filter(e => new Date(e.ts || 0) > sessionStart);
+  const recentFallback = allEntries.slice(-5); // fallback if session is empty
+  const now        = new Date().toLocaleString("en-GB", { day: "2-digit", month: "short", year: "numeric", hour: "2-digit", minute: "2-digit" });
+
+  const projectId = contract.policyId || path.basename(process.cwd());
+  const version   = contract.policyVersion || "?";
+  const caps      = (contract.capabilities || []).slice(0, 20);
+
+  // ── Session memory grouped by type ────────────────────────────────────────
+  const pool      = sessions.length > 0 ? sessions : recentFallback;
+  const gotchas   = pool.filter(e => e.type === "gotcha");
+  const decisions = pool.filter(e => e.type === "decision");
+  const attempts  = pool.filter(e => e.type === "attempt").filter(e => e.result === "failed" || e.result === "partial");
+  const prefs     = pool.filter(e => e.type === "preference");
+  const recent    = pool.slice(-8); // last 8 regardless of type
+
+  const sinceStr = sessionStart.getTime() === 0
+    ? "all time"
+    : sessionStart.toLocaleString("en-GB", { day: "2-digit", month: "short", hour: "2-digit", minute: "2-digit" });
+
+  const lines = [
+    `# 🔥 infernoflow Handoff — ${projectId}`,
+    `> Generated: ${now}${toAgent ? ` | Handing off to: **${toAgent}**` : ""}`,
+    `> Session memory: **${sessions.length} entries** since ${sinceStr}`,
+    "",
+    "---",
+    "",
+    "## Pick up here",
+    "",
+  ];
+
+  // Current working state
+  if (state.working || state.intent) {
+    if (state.working) lines.push(`**Working on:** ${state.working}  _(${fmtDate(state.workingUpdated)})_`);
+    if (state.intent)  lines.push(`**Intent:** ${state.intent}  _(${fmtDate(state.intentUpdated)})_`);
+    lines.push("");
+  } else {
+    lines.push("_No working state set. Run: `infernoflow context --working \"...\"` to set it._", "");
+  }
+
+  // ── Gotchas first — most critical for a new agent ─────────────────────────
+  if (gotchas.length) {
+    lines.push("## ⚠ Gotchas — read these first", "");
+    for (const e of gotchas) {
+      lines.push(`- ${e.summary}  _(${fmtDate(e.ts)})_`);
+    }
+    lines.push("");
+  }
+
+  // ── Decisions ──────────────────────────────────────────────────────────────
+  if (decisions.length) {
+    lines.push("## Decisions made", "");
+    for (const e of decisions) {
+      const result = e.result ? ` → **${e.result}**` : "";
+      lines.push(`- ${e.summary}${result}  _(${fmtDate(e.ts)})_`);
+    }
+    lines.push("");
+  }
+
+  // ── Failed attempts — don't repeat them ───────────────────────────────────
+  if (attempts.length) {
+    lines.push("## ✗ Already tried — don't repeat", "");
+    for (const e of attempts) {
+      lines.push(`- ${e.summary}  _(${fmtDate(e.ts)})_`);
+    }
+    lines.push("");
+  }
+
+  // ── Preferences ───────────────────────────────────────────────────────────
+  if (prefs.length) {
+    lines.push("## Developer preferences", "");
+    for (const e of prefs) {
+      lines.push(`- ${e.summary}`);
+    }
+    lines.push("");
+  }
+
+  // ── Design system ─────────────────────────────────────────────────────────
+  if (theme) {
+    lines.push("## Design system", "");
+    if (theme.fonts?.primary) lines.push(`- **Font:** ${theme.fonts.primary}${theme.fonts.mono ? ` · mono: ${theme.fonts.mono}` : ""}`);
+    if (theme.colors?.mode)   lines.push(`- **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 top = Object.entries(theme.cssVars).slice(0, 6).map(([k,v]) => `${k}: ${v}`).join("  |  ");
+      lines.push(`- **CSS vars:** ${top}`);
+    }
+    if (theme.framework) lines.push(`- **Framework:** ${theme.framework}`);
+    lines.push("", "> ⚠ Always match these exactly. Do not introduce new colors or fonts.", "");
+  }
+
+  // ── Capabilities ──────────────────────────────────────────────────────────
+  if (caps.length) {
+    lines.push("## Capability contract", "");
+    lines.push(`Project: **${projectId}** v${version}`);
+    lines.push(`Capabilities: ${caps.join(", ")}`);
+    lines.push("");
+  }
+
+  // ── Recent session log ────────────────────────────────────────────────────
+  if (recent.length) {
+    lines.push("## Recent session log", "");
+    for (const e of recent) {
+      const result = e.result ? ` [${e.result}]` : "";
+      lines.push(`- **${e.type}**${result}: ${e.summary}  _(${fmtDate(e.ts)})_`);
+    }
+    lines.push("");
+  }
+
+  lines.push("---");
+  lines.push("_Paste this at the start of your next AI session. Generated by infernoflow._");
+
+  return lines.join("\n");
+}
+
+export async function switchCommand(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 showOnly = has("--show") || has("-s");
+  const copyFlag = has("--copy") || has("-c");
+  const jsonFlag = has("--json");
+  const allFlag  = has("--all");
+  const sinceArg = flag("--since");
+  const toAgent  = flag("--to") || args.find(a => !a.startsWith("-") && !["switch"].includes(a)) || null;
+
+  console.log("\n  " + bold("🔥 infernoflow — switch"));
+  console.log("  " + "─".repeat(50) + "\n");
+
+  if (!fs.existsSync(INFERNO_DIR)) {
+    console.error(red("  ✘ inferno/ not found — run: infernoflow init\n"));
+    process.exit(1);
+  }
+
+  // ── Show existing handoff ─────────────────────────────────────────────────
+  if (showOnly) {
+    const existing = readFile(HANDOFF_FILE);
+    if (!existing) {
+      console.log(yellow("  ⚠ No HANDOFF.md yet — run: infernoflow switch\n"));
+      return;
+    }
+    console.log(existing);
+    return;
+  }
+
+  const handoff = buildHandoff(toAgent, sinceArg, allFlag);
+
+  if (jsonFlag) {
+    const state      = readJSON(STATE_FILE)    || {};
+    const contract   = readJSON(CONTRACT_FILE) || {};
+    const theme      = readJSON(THEME_FILE);
+    const allEntries = getAllEntries();
+    const sessionStart = findSessionStart(allEntries, sinceArg, allFlag);
+    const sessions   = allEntries.filter(e => new Date(e.ts || 0) > sessionStart);
+    console.log(JSON.stringify({ state, contract: { policyId: contract.policyId, policyVersion: contract.policyVersion, capabilities: contract.capabilities }, theme, sessions, sessionStart: sessionStart.toISOString(), generatedAt: new Date().toISOString() }, null, 2));
+    return;
+  }
+
+  // Write HANDOFF.md
+  fs.writeFileSync(HANDOFF_FILE, handoff, "utf8");
+  console.log(green("  ✔ Written → inferno/HANDOFF.md\n"));
+
+  // Also log the handoff itself to sessions.jsonl
+  if (fs.existsSync(SESSIONS_FILE)) {
+    const entry = {
+      ts:      new Date().toISOString(),
+      agent:   "infernoflow",
+      type:    "handoff",
+      summary: toAgent ? `Handed off to ${toAgent}` : "Handoff generated",
+    };
+    fs.appendFileSync(SESSIONS_FILE, JSON.stringify(entry) + "\n", "utf8");
+  }
+
+  // Print preview
+  const allEntriesForCount = getAllEntries();
+  const sessionStartForCount = findSessionStart(allEntriesForCount, sinceArg, allFlag);
+  const sessionEntries = allEntriesForCount.filter(e => new Date(e.ts || 0) > sessionStartForCount);
+  const state    = readJSON(STATE_FILE) || {};
+  const theme    = readJSON(THEME_FILE);
+  const contract = readJSON(CONTRACT_FILE) || {};
+
+  console.log("  " + bold("Handoff summary"));
+  console.log("  " + "─".repeat(50));
+  if (state.working) console.log("  Working on    " + cyan(state.working));
+  if (state.intent)  console.log("  Intent        " + cyan(state.intent));
+  console.log("  Session       " + sessionEntries.length + " entries (total: " + allEntriesForCount.length + ")");
+  console.log("  Capabilities  " + (contract.capabilities || []).length + " registered");
+  if (theme?.fonts?.primary) console.log("  Font          " + theme.fonts.primary);
+  if (theme?.colors?.mode)   console.log("  Color mode    " + theme.colors.mode);
+  if (toAgent) console.log("  Handing off → " + cyan(toAgent));
+  console.log();
+
+  if (copyFlag) {
+    const ok = copyToClipboard(handoff);
+    console.log(ok
+      ? green("  ✔ Copied to clipboard — paste at the start of your next AI session")
+      : yellow("  ⚠ Clipboard failed — open inferno/HANDOFF.md manually")
+    );
+  } else {
+    console.log("  " + bold("Ready to use:"));
+    console.log("  " + cyan("1.") + " Open    " + cyan("inferno/HANDOFF.md"));
+    console.log("  " + cyan("2.") + " Copy all");
+    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"));
+  }
+  console.log();
+}

package/dist/lib/commands/syncAuto.mjs

@@ -1 +1,96 @@
-import{execFileSync as w}from"node:child_process";import*as y from"node:path";import{fileURLToPath as P}from"node:url";import{header as h,section as d,ok as e,warn as f,yellow as g,gray as p}from"../ui/output.mjs";const S=P(import.meta.url),C=y.dirname(S),N=y.resolve(C,"..","..","bin","infernoflow.mjs");function D(o){const n=w(process.execPath,[N,...o],{encoding:"utf8",stdio:["ignore","pipe","pipe"]});return JSON.parse(n)}function _(o){try{return{ok:!0,data:D(o)}}catch(n){const s=n?.stdout?.toString?.()||"";try{return{ok:!1,data:JSON.parse(s)}}catch{return{ok:!1,data:{ok:!1,errors:["command_failed"]}}}}}async function E(o=[]){const n=o.includes("--auto"),s=o.includes("--json"),u=o.includes("--dry-run");n||(s&&(console.log(JSON.stringify({ok:!1,error:"missing_required_flag",hint:"Use: infernoflow sync --auto"},null,2)),process.exit(1)),h("sync"),f("missing --auto flag"),console.log(`  ${g("\u2192")} infernoflow sync --auto`),console.log(),process.exit(1));const c=_(["pr-impact","--json"]),i=!c.data?.ok,a=c.data?.confidence||"low",r=a==="high"?"auto":a==="medium"?"ask":"block",k=i?["Generate inferno update proposal (suggest)","Review changes","Validate with check --json"]:["No inferno drift detected","Validate with check --json"],t=_(["check","--json"]),l={ok:c.ok&&t.ok&&!!t.data?.ok,mode:"auto-skeleton",dryRun:u,needsSync:i,didApply:!1,confidence:a,policyDecision:r,actions:k,prImpact:c.data,postCheck:t.data,reasonCodes:[...i?["DRIFT_DETECTED"]:["NO_DRIFT"],`POLICY_${r.toUpperCase()}`,...r==="auto"?["AUTO_APPLY_DISABLED_IN_SKELETON"]:[]]};s&&(console.log(JSON.stringify(l,null,2)),process.exit(l.ok?0:1)),h("sync --auto"),d("State"),i?f("Inferno drift detected"):e("No inferno drift detected"),e(`Confidence: ${p(a)}`),e(`Policy decision: ${p(r)}`),e(`Apply mode: ${p("skeleton (no file writes)")}`),u&&e("Dry run enabled"),d("Plan"),k.forEach(m=>console.log(`  ${g("\u2192")} ${m}`)),d("Validation"),t.ok&&t.data?.ok?e("Post-check passed"):f("Post-check failed; see infernoflow check --json"),console.log(),process.exit(l.ok?0:1)}export{E as syncCommand};
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { header, section, ok, warn, yellow, gray } from "../ui/output.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const binPath = path.resolve(__dirname, "..", "..", "bin", "infernoflow.mjs");
+
+function runCliJson(args) {
+  const out = execFileSync(process.execPath, [binPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return JSON.parse(out);
+}
+
+function tryRunCliJson(args) {
+  try {
+    return { ok: true, data: runCliJson(args) };
+  } catch (err) {
+    const stdout = err?.stdout?.toString?.() || "";
+    try {
+      return { ok: false, data: JSON.parse(stdout) };
+    } catch {
+      return { ok: false, data: { ok: false, errors: ["command_failed"] } };
+    }
+  }
+}
+
+export async function syncCommand(args = []) {
+  const auto = args.includes("--auto");
+  const asJson = args.includes("--json");
+  const dryRun = args.includes("--dry-run");
+
+  if (!auto) {
+    const payload = { ok: false, error: "missing_required_flag", hint: "Use: infernoflow sync --auto" };
+    if (asJson) {
+      console.log(JSON.stringify(payload, null, 2));
+      process.exit(1);
+    }
+    header("sync");
+    warn("missing --auto flag");
+    console.log(`  ${yellow("→")} infernoflow sync --auto`);
+    console.log();
+    process.exit(1);
+  }
+
+  const impact = tryRunCliJson(["pr-impact", "--json"]);
+  const needsSync = !impact.data?.ok;
+  const confidence = impact.data?.confidence || "low";
+  const policyDecision = confidence === "high" ? "auto" : confidence === "medium" ? "ask" : "block";
+  const actions = needsSync
+    ? ["Generate inferno update proposal (suggest)", "Review changes", "Validate with check --json"]
+    : ["No inferno drift detected", "Validate with check --json"];
+
+  const check = tryRunCliJson(["check", "--json"]);
+  const payload = {
+    ok: impact.ok && check.ok && !!check.data?.ok,
+    mode: "auto-skeleton",
+    dryRun,
+    needsSync,
+    didApply: false,
+    confidence,
+    policyDecision,
+    actions,
+    prImpact: impact.data,
+    postCheck: check.data,
+    reasonCodes: [
+      ...(needsSync ? ["DRIFT_DETECTED"] : ["NO_DRIFT"]),
+      `POLICY_${policyDecision.toUpperCase()}`,
+      ...(policyDecision === "auto" ? ["AUTO_APPLY_DISABLED_IN_SKELETON"] : []),
+    ],
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(payload.ok ? 0 : 1);
+  }
+
+  header("sync --auto");
+  section("State");
+  if (needsSync) warn("Inferno drift detected");
+  else ok("No inferno drift detected");
+  ok(`Confidence: ${gray(confidence)}`);
+  ok(`Policy decision: ${gray(policyDecision)}`);
+  ok(`Apply mode: ${gray("skeleton (no file writes)")}`);
+  if (dryRun) ok("Dry run enabled");
+
+  section("Plan");
+  actions.forEach((a) => console.log(`  ${yellow("→")} ${a}`));
+
+  section("Validation");
+  if (check.ok && check.data?.ok) ok("Post-check passed");
+  else warn("Post-check failed; see infernoflow check --json");
+  console.log();
+  process.exit(payload.ok ? 0 : 1);
+}
+

package/dist/lib/commands/synthesize.mjs

@@ -1,10 +1,228 @@
-import*as j from"node:fs";import*as x from"node:path";import*as q from"node:readline";import{header as N,ok as C,warn as $,info as g,done as P,bold as f,cyan as w,yellow as z,green as h,gray as y}from"../ui/output.mjs";import{readProfile as I,writeProfile as k}from"../learning/profile.mjs";import{detectPatterns as O,mergeCandidates as D,pendingCandidates as b}from"../learning/patternDetector.mjs";import{synthesizeCandidate as A}from"../learning/skillSynthesizer.mjs";import{observeCommandStart as L}from"../learning/observe.mjs";function J(t){const i=x.join(t,"inferno");return j.existsSync(i)?i:null}function M(t,i){return new Promise(o=>t.question(i,s=>o(s.trim().toLowerCase())))}function R(t,i){const o=t.type==="agent"?w("agent"):h("skill"),s=Math.round(t.confidence*100),u=s>=80?h(`${s}%`):s>=60?z(`${s}%`):y(`${s}%`),a=y(`seen ${t.frequency}\xD7`);console.log(`
-  ${f(`[${i+1}]`)} ${o}  ${f(t.name)}  ${u} confidence  ${a}`),console.log(`      Pattern:  ${w(t.trigger)}`),t.steps&&console.log(`      Steps:    ${t.steps.join(" \u2192 ")}`),t.examples?.length&&console.log(`      Examples: ${t.examples.slice(0,2).map(n=>`"${n}"`).join(", ")}`)}async function W(t,i,o,s){if(s.length===0)return g("No new candidates to review."),{approved:0,rejected:0};const u=q.createInterface({input:process.stdin,output:process.stdout});let a=0,n=0;console.log(`
-  ${f("Candidates found:")} ${s.length}
-`),console.log(y(`  For each: [y] approve  [n] reject  [s] skip  [q] quit
-`));for(let p=0;p<s.length;p++){const e=s[p];R(e,p);const c=await M(u,`
-      Approve? [y/n/s/q]: `);if(c==="q")break;if(c==="s")continue;const l=[...o.agentCandidates||[],...o.skillCandidates||[]].find(r=>r.id===e.id);if(l)if(c==="y"){l.status="approved";try{const{filePaths:r}=A(t,i,e),d=e.type==="agent"?"approvedAgents":"approvedSkills";o[d]||(o[d]=[]),o[d].push({id:e.id,name:e.name,filePaths:r,approvedAt:new Date().toISOString()}),C(`  ${e.type==="agent"?"Agent":"Skill"} created:`);for(const v of r)console.log(`    ${h("\u2192")} ${v}`);a++}catch(r){$(`  Could not write files: ${r.message}`)}}else l.status="rejected",n++}return u.close(),{approved:a,rejected:n}}function E(t,i,o,s,u=.8){let a=0;for(const n of s){if(n.confidence<u)continue;const e=[...o.agentCandidates||[],...o.skillCandidates||[]].find(c=>c.id===n.id);if(e){e.status="approved";try{const{filePaths:c}=A(t,i,n),m=n.type==="agent"?"approvedAgents":"approvedSkills";o[m]||(o[m]=[]),o[m].push({id:n.id,name:n.name,filePaths:c,approvedAt:new Date().toISOString()}),C(`Auto-approved ${n.type}: ${f(n.name)} (${Math.round(n.confidence*100)}% confidence)`);for(const l of c)console.log(`  ${h("\u2192")} ${l}`);a++}catch(c){$(`Could not write ${n.name}: ${c.message}`)}}}return a}async function B(t){const i=process.cwd(),o=t.includes("--auto"),s=t.includes("--json"),u=t.includes("--watch"),a=(()=>{const e=t.indexOf("--threshold");return e!==-1&&Number(t[e+1])||3})(),n=J(i);n||(s?process.stdout.write(JSON.stringify({ok:!1,error:"inferno/ not found"})+`
-`):$("inferno/ not found \u2014 run infernoflow init first"),process.exit(1)),L(n,"synthesize");async function p(){const e=I(n),{agentCandidates:c,skillCandidates:m}=O(e,{minFreq:a});D(e,{agentCandidates:c,skillCandidates:m});const l=b(e);if(s){k(n,e),process.stdout.write(JSON.stringify({ok:!0,pendingCount:l.length,candidates:l,sessions:e.recentSessions?.length||0},null,2)+`
-`);return}if(N("infernoflow synthesize"),g(`Sessions analyzed: ${f(String(e.recentSessions?.length||0))}`),g(`Minimum frequency: ${f(String(a))}\xD7`),l.length===0){console.log(),(e.recentSessions?.length||0)<a?($(`Not enough session data yet \u2014 need at least ${a} sessions with similar commands.`),$("Keep using infernoflow and run synthesize again soon.")):C("No new patterns detected \u2014 your workflow is already well captured."),k(n,e);return}g(`New patterns detected: ${f(String(l.length))}`);let r;if(o)g("Auto-approving candidates with \u226580% confidence..."),r=E(i,n,e,l);else{const d=await W(i,n,e,l);r=d.approved,d.rejected>0&&g(`Rejected: ${d.rejected}`)}if(k(n,e),r>0){console.log(),P(`${r} skill${r!==1?"s/agents":"/agent"} synthesized`),console.log(`
-  ${f("What was created:")}`);for(const d of[...e.approvedSkills||[],...e.approvedAgents||[]].slice(-r)){const v=e.approvedAgents?.find(S=>S.id===d.id)?"agent":"skill";console.log(`    ${h("\u2714")} ${v}: ${f(d.name)}`);for(const S of d.filePaths||[])console.log(`       ${y(S)}`)}console.log(`
-  ${f("Next:")} Run ${w("infernoflow agent list")} to see your agents`),console.log(`         or ${w("infernoflow agent run <name>")} to execute one`)}}if(u){g("Watching for new patterns \u2014 press Ctrl+C to stop");const e=6e4;await p(),setInterval(p,e),await new Promise(()=>{})}else await p()}export{B as synthesizeCommand};
+/**
+ * infernoflow synthesize
+ *
+ * Analyzes your observed development sessions and auto-proposes reusable
+ * skills and agents based on repeated patterns.
+ *
+ * Usage:
+ *   infernoflow synthesize               — interactive review of candidates
+ *   infernoflow synthesize --auto        — auto-approve high-confidence (≥0.8)
+ *   infernoflow synthesize --json        — print candidates as JSON, exit
+ *   infernoflow synthesize --threshold 2 — surface patterns seen 2+ times
+ *   infernoflow synthesize --watch       — re-run every 60s, surface new candidates
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { header, ok, warn, info, done, bold, cyan, yellow, green, gray } from "../ui/output.mjs";
+import { readProfile, writeProfile } from "../learning/profile.mjs";
+import { detectPatterns, mergeCandidates, pendingCandidates } from "../learning/patternDetector.mjs";
+import { synthesizeCandidate } from "../learning/skillSynthesizer.mjs";
+import { observeCommandStart } from "../learning/observe.mjs";
+
+function findInfernoDir(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  if (!fs.existsSync(infernoDir)) return null;
+  return infernoDir;
+}
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, a => resolve(a.trim().toLowerCase())));
+}
+
+function renderCandidate(c, index) {
+  const type   = c.type === "agent" ? cyan("agent") : green("skill");
+  const conf   = Math.round(c.confidence * 100);
+  const confStr = conf >= 80 ? green(`${conf}%`) : conf >= 60 ? yellow(`${conf}%`) : gray(`${conf}%`);
+  const freq   = gray(`seen ${c.frequency}×`);
+
+  console.log(`\n  ${bold(`[${index + 1}]`)} ${type}  ${bold(c.name)}  ${confStr} confidence  ${freq}`);
+  console.log(`      Pattern:  ${cyan(c.trigger)}`);
+  if (c.steps) console.log(`      Steps:    ${c.steps.join(" → ")}`);
+  if (c.examples?.length) {
+    console.log(`      Examples: ${c.examples.slice(0, 2).map(e => `"${e}"`).join(", ")}`);
+  }
+}
+
+async function reviewInteractive(cwd, infernoDir, profile, candidates) {
+  if (candidates.length === 0) {
+    info("No new candidates to review.");
+    return { approved: 0, rejected: 0 };
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let approved = 0, rejected = 0;
+
+  console.log(`\n  ${bold("Candidates found:")} ${candidates.length}\n`);
+  console.log(gray("  For each: [y] approve  [n] reject  [s] skip  [q] quit\n"));
+
+  for (let i = 0; i < candidates.length; i++) {
+    const c = candidates[i];
+    renderCandidate(c, i);
+
+    const ans = await ask(rl, `\n      Approve? [y/n/s/q]: `);
+
+    if (ans === "q") break;
+    if (ans === "s") continue;
+
+    const all = [...(profile.agentCandidates || []), ...(profile.skillCandidates || [])];
+    const entry = all.find(x => x.id === c.id);
+    if (!entry) continue;
+
+    if (ans === "y") {
+      entry.status = "approved";
+      try {
+        const { filePaths } = synthesizeCandidate(cwd, infernoDir, c);
+        const approvedList = c.type === "agent" ? "approvedAgents" : "approvedSkills";
+        if (!profile[approvedList]) profile[approvedList] = [];
+        profile[approvedList].push({
+          id: c.id,
+          name: c.name,
+          filePaths,
+          approvedAt: new Date().toISOString(),
+        });
+        ok(`  ${c.type === "agent" ? "Agent" : "Skill"} created:`);
+        for (const fp of filePaths) console.log(`    ${green("→")} ${fp}`);
+        approved++;
+      } catch (err) {
+        warn(`  Could not write files: ${err.message}`);
+      }
+    } else {
+      entry.status = "rejected";
+      rejected++;
+    }
+  }
+
+  rl.close();
+  return { approved, rejected };
+}
+
+function autoApprove(cwd, infernoDir, profile, candidates, threshold = 0.8) {
+  let approved = 0;
+  for (const c of candidates) {
+    if (c.confidence < threshold) continue;
+
+    const all = [...(profile.agentCandidates || []), ...(profile.skillCandidates || [])];
+    const entry = all.find(x => x.id === c.id);
+    if (!entry) continue;
+
+    entry.status = "approved";
+    try {
+      const { filePaths } = synthesizeCandidate(cwd, infernoDir, c);
+      const approvedList = c.type === "agent" ? "approvedAgents" : "approvedSkills";
+      if (!profile[approvedList]) profile[approvedList] = [];
+      profile[approvedList].push({
+        id: c.id,
+        name: c.name,
+        filePaths,
+        approvedAt: new Date().toISOString(),
+      });
+      ok(`Auto-approved ${c.type}: ${bold(c.name)} (${Math.round(c.confidence * 100)}% confidence)`);
+      for (const fp of filePaths) console.log(`  ${green("→")} ${fp}`);
+      approved++;
+    } catch (err) {
+      warn(`Could not write ${c.name}: ${err.message}`);
+    }
+  }
+  return approved;
+}
+
+export async function synthesizeCommand(args) {
+  const cwd       = process.cwd();
+  const isAuto    = args.includes("--auto");
+  const isJson    = args.includes("--json");
+  const isWatch   = args.includes("--watch");
+  const threshold = (() => {
+    const idx = args.indexOf("--threshold");
+    return idx !== -1 ? Number(args[idx + 1]) || 3 : 3;
+  })();
+
+  const infernoDir = findInfernoDir(cwd);
+  if (!infernoDir) {
+    if (isJson) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "inferno/ not found" }) + "\n");
+    } else {
+      warn("inferno/ not found — run infernoflow init first");
+    }
+    process.exit(1);
+  }
+
+  observeCommandStart(infernoDir, "synthesize");
+
+  async function runOnce() {
+    const profile = readProfile(infernoDir);
+
+    // ── Detect patterns ──────────────────────────────────────────────────────
+    const { agentCandidates, skillCandidates } = detectPatterns(profile, { minFreq: threshold });
+    mergeCandidates(profile, { agentCandidates, skillCandidates });
+
+    const pending = pendingCandidates(profile);
+
+    // ── JSON mode ────────────────────────────────────────────────────────────
+    if (isJson) {
+      writeProfile(infernoDir, profile);
+      process.stdout.write(JSON.stringify({
+        ok: true,
+        pendingCount: pending.length,
+        candidates: pending,
+        sessions: profile.recentSessions?.length || 0,
+      }, null, 2) + "\n");
+      return;
+    }
+
+    header("infernoflow synthesize");
+    info(`Sessions analyzed: ${bold(String(profile.recentSessions?.length || 0))}`);
+    info(`Minimum frequency: ${bold(String(threshold))}×`);
+
+    if (pending.length === 0) {
+      console.log();
+      if ((profile.recentSessions?.length || 0) < threshold) {
+        warn(`Not enough session data yet — need at least ${threshold} sessions with similar commands.`);
+        warn(`Keep using infernoflow and run synthesize again soon.`);
+      } else {
+        ok("No new patterns detected — your workflow is already well captured.");
+      }
+      writeProfile(infernoDir, profile);
+      return;
+    }
+
+    info(`New patterns detected: ${bold(String(pending.length))}`);
+
+    // ── Auto mode ────────────────────────────────────────────────────────────
+    let approved;
+    if (isAuto) {
+      info(`Auto-approving candidates with ≥80% confidence...`);
+      approved = autoApprove(cwd, infernoDir, profile, pending);
+    } else {
+      const result = await reviewInteractive(cwd, infernoDir, profile, pending);
+      approved = result.approved;
+      if (result.rejected > 0) info(`Rejected: ${result.rejected}`);
+    }
+
+    writeProfile(infernoDir, profile);
+
+    if (approved > 0) {
+      console.log();
+      done(`${approved} skill${approved !== 1 ? "s/agents" : "/agent"} synthesized`);
+      console.log(`\n  ${bold("What was created:")}`);
+      for (const item of [...(profile.approvedSkills || []), ...(profile.approvedAgents || [])].slice(-approved)) {
+        const type = profile.approvedAgents?.find(a => a.id === item.id) ? "agent" : "skill";
+        console.log(`    ${green("✔")} ${type}: ${bold(item.name)}`);
+        for (const fp of item.filePaths || []) console.log(`       ${gray(fp)}`);
+      }
+      console.log(`\n  ${bold("Next:")} Run ${cyan("infernoflow agent list")} to see your agents`);
+      console.log(`         or ${cyan("infernoflow agent run <name>")} to execute one`);
+    }
+  }
+
+  if (isWatch) {
+    info("Watching for new patterns — press Ctrl+C to stop");
+    const INTERVAL = 60_000;
+    await runOnce();
+    setInterval(runOnce, INTERVAL);
+    await new Promise(() => {}); // keep alive
+  } else {
+    await runOnce();
+  }
+}