infernoflow 0.10.23 → 0.10.26

package/dist/lib/commands/publish.mjs

@@ -1,21 +1,299 @@
-import*as c from"node:fs";import*as f from"node:path";import{execSync as b}from"node:child_process";import{fileURLToPath as F}from"node:url";import{header as L,ok as o,fail as k,warn as l,info as u,done as O,bold as S,cyan as C,gray as n,green as T}from"../ui/output.mjs";const U=f.dirname(F(import.meta.url)),g=f.resolve(U,"../..");function a(r,i={}){return b(r,{cwd:g,encoding:"utf8",stdio:i.silent?["ignore","pipe","pipe"]:["inherit","inherit","inherit"],...i})}function x(r){return b(r,{cwd:g,encoding:"utf8",stdio:["ignore","pipe","pipe"]}).trim()}function E(r,i){const e=r.split(".").map(Number);return i==="major"?(e[0]++,e[1]=0,e[2]=0):i==="minor"?(e[1]++,e[2]=0):e[2]++,e.join(".")}function h(){return new Date().toISOString().slice(0,10)}function H(r,i){if(!c.existsSync(r))return c.writeFileSync(r,`# Changelog \u2014 infernoflow
+/**
+ * infernoflow publish
+ *
+ * One command to release:
+ *   1. Bump version in package.json  (--bump patch|minor|major, default: patch)
+ *   2. Move CHANGELOG ## Unreleased → ## <new-version> — <date>
+ *   3. Run build  (node build.mjs)
+ *   4. Run smoke tests  (skippable with --skip-tests)
+ *   5. npm publish
+ *   6. git add + commit + push
+ *
+ * Flags:
+ *   --bump patch|minor|major   Version bump type (default: patch)
+ *   --skip-build               Skip build step
+ *   --skip-tests               Skip smoke-test step
+ *   --skip-push                Publish + commit but don't git push
+ *   --dry-run                  Print every step without executing
+ *   --yes, -y                  Non-interactive (skip confirmation prompt)
+ *   --tag                      Also create a git tag vX.Y.Z
+ */
 
-## ${i} \u2014 ${h()}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { header, ok, fail, warn, info, done, bold, cyan, gray, yellow, green } from "../ui/output.mjs";
 
-### Added
-- Release ${i}
-`),!0;let e=c.readFileSync(r,"utf8");if(/^## Unreleased/im.test(e))return e=e.replace(/^## Unreleased.*$/im,`## ${i} \u2014 ${h()}`),c.writeFileSync(r,e),!0;const p=/^# .+$/im;return p.test(e)?(e=e.replace(p,y=>`${y}
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT  = path.resolve(__dirname, "../..");
 
-## ${i} \u2014 ${h()}
+// ── helpers ──────────────────────────────────────────────────────────────────
 
-### Added
-- Release ${i}
-`),c.writeFileSync(r,e),!0):(c.writeFileSync(r,`## ${i} \u2014 ${h()}
+function run(cmd, opts = {}) {
+  return execSync(cmd, {
+    cwd: PKG_ROOT,
+    encoding: "utf8",
+    stdio: opts.silent ? ["ignore", "pipe", "pipe"] : ["inherit", "inherit", "inherit"],
+    ...opts,
+  });
+}
 
-### Added
-- Release ${i}
+function runCapture(cmd) {
+  return execSync(cmd, { cwd: PKG_ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
 
-${e}`),!0)}function _(){try{return x("git status --porcelain").length>0}catch{return!1}}function J(){try{return x("git config user.email"),!0}catch{return!1}}async function M(r){const i=r.slice(1),e=i.includes("--dry-run"),p=i.includes("--skip-build"),y=i.includes("--skip-tests"),A=i.includes("--skip-push"),j=i.includes("--tag"),N=i.includes("--yes")||i.includes("-y"),G=i.indexOf("--bump"),m=G!==-1&&i[G+1]||"patch";["patch","minor","major"].includes(m)||(console.error(`  Invalid --bump value: ${m}. Must be patch, minor, or major.`),process.exit(1)),L("infernoflow publish"),e&&l("DRY RUN \u2014 no files will be written, no commands executed");const v=f.join(g,"package.json"),$=JSON.parse(c.readFileSync(v,"utf8")),w=$.version,t=E(w,m);if(console.log(),console.log(`  ${n("current")}  ${S(w)}`),console.log(`  ${n("new     ")}  ${S(T(t))}  ${n("("+m+" bump)")}`),console.log(),!N&&!e){process.stdout.write(`  Publish ${S(C("infernoflow@"+t))} to npm? [y/N] `);let s=!1;try{const d=b("bash -c 'read -r ans </dev/tty; echo $ans'",{encoding:"utf8",stdio:["inherit","pipe","inherit"]}).trim().toLowerCase();s=d==="y"||d==="yes"}catch{s=!1}console.log(),s||(console.log(n(`  Aborted.
-`)),process.exit(0))}u(`Bumping package.json  ${n(w+" \u2192 "+t)}`),e?o(n("[dry] would write package.json")):($.version=t,c.writeFileSync(v,JSON.stringify($,null,4)+`
-`),o("package.json updated"));const R=f.join(g,"CHANGELOG.md");if(u("Updating CHANGELOG.md"),e?o(n("[dry] would update CHANGELOG.md")):(H(R,t),o("CHANGELOG.md updated")),p)l("Skipping build  (--skip-build)");else if(u("Running build  "+n("node build.mjs")),e)o(n("[dry] would run: node build.mjs"));else try{a("node build.mjs",{silent:!1}),o("Build succeeded")}catch(s){k("Build failed",s.message),process.exit(1)}if(y)l("Skipping tests  (--skip-tests)");else if(u("Running smoke tests"),e)o(n("[dry] would run: npm test"));else try{a("npm test",{silent:!1}),o("All smoke tests passed")}catch{k("Smoke tests failed","Fix tests or re-run with --skip-tests"),process.exit(1)}if(u(`Publishing to npm  ${n("infernoflow@"+t)}`),e)o(n("[dry] would run: npm publish"));else try{a("npm publish",{silent:!1}),o(`Published infernoflow@${t}`)}catch(s){k("npm publish failed",s.message||"Check npm credentials"),l("Continuing to git commit despite publish failure")}if(u("Committing version bump"),e)o(n(`[dry] would commit: chore: release ${t}`));else try{a(`git add ${["package.json","CHANGELOG.md"].join(" ")}`,{silent:!1});const d=`chore: release ${t}`;a(`git commit -m "${d}"`,{silent:!1}),o(`Committed: ${n(d)}`)}catch(s){l(`Git commit failed: ${s.message}`),l('You can commit manually: git add package.json CHANGELOG.md && git commit -m "chore: release '+t+'"')}if(j)if(u(`Creating git tag  ${n("v"+t)}`),e)o(n(`[dry] would tag: v${t}`));else try{a(`git tag v${t}`,{silent:!1}),o(`Tagged v${t}`)}catch(s){l(`Git tag failed: ${s.message}`)}if(A)l("Skipping push  (--skip-push)");else if(u("Pushing to origin"),e)o(n("[dry] would run: git push"));else try{const s=j?`git push && git push origin v${t}`:"git push";a(s,{silent:!1}),o("Pushed to origin")}catch(s){l(`Git push failed: ${s.message}`),l("Push manually: git push")}console.log(),e?O(`Dry run complete \u2014 would have published infernoflow@${t}`):(O(`infernoflow@${t} published, committed, and pushed`),console.log(`  ${C("npm:")}  https://www.npmjs.com/package/infernoflow`),console.log(`  ${C("git:")}  ${n("chore: release "+t)}
-`))}export{M as publishCommand};
+function bumpVersion(current, type) {
+  const parts = current.split(".").map(Number);
+  if (type === "major") { parts[0]++; parts[1] = 0; parts[2] = 0; }
+  else if (type === "minor") { parts[1]++; parts[2] = 0; }
+  else { parts[2]++; }
+  return parts.join(".");
+}
+
+function todayISO() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function updateChangelog(changelogPath, newVersion) {
+  if (!fs.existsSync(changelogPath)) {
+    // create a minimal changelog if none exists
+    fs.writeFileSync(changelogPath,
+      `# Changelog — infernoflow\n\n## ${newVersion} — ${todayISO()}\n\n### Added\n- Release ${newVersion}\n`);
+    return true;
+  }
+
+  let text = fs.readFileSync(changelogPath, "utf8");
+
+  // If there's an ## Unreleased section, rename it
+  if (/^## Unreleased/im.test(text)) {
+    text = text.replace(
+      /^## Unreleased.*$/im,
+      `## ${newVersion} — ${todayISO()}`
+    );
+    fs.writeFileSync(changelogPath, text);
+    return true;
+  }
+
+  // No Unreleased section — insert a new version heading after the first heading
+  const insertAfter = /^# .+$/im;
+  if (insertAfter.test(text)) {
+    text = text.replace(
+      insertAfter,
+      (m) => `${m}\n\n## ${newVersion} — ${todayISO()}\n\n### Added\n- Release ${newVersion}\n`
+    );
+    fs.writeFileSync(changelogPath, text);
+    return true;
+  }
+
+  // Fallback: prepend
+  fs.writeFileSync(changelogPath, `## ${newVersion} — ${todayISO()}\n\n### Added\n- Release ${newVersion}\n\n${text}`);
+  return true;
+}
+
+function hasUncommittedChanges() {
+  try {
+    const out = runCapture("git status --porcelain");
+    return out.length > 0;
+  } catch { return false; }
+}
+
+function gitUserConfigured() {
+  try {
+    runCapture("git config user.email");
+    return true;
+  } catch { return false; }
+}
+
+
+// ── main ─────────────────────────────────────────────────────────────────────
+
+export async function publishCommand(rawArgs) {
+  const args = rawArgs.slice(1); // drop command name
+
+  const dryRun     = args.includes("--dry-run");
+  const skipBuild  = args.includes("--skip-build");
+  const skipTests  = args.includes("--skip-tests");
+  const skipPush   = args.includes("--skip-push");
+  const createTag  = args.includes("--tag");
+  const yes        = args.includes("--yes") || args.includes("-y");
+
+  const bumpIdx = args.indexOf("--bump");
+  const bumpType = bumpIdx !== -1 ? (args[bumpIdx + 1] || "patch") : "patch";
+
+  if (!["patch", "minor", "major"].includes(bumpType)) {
+    console.error(`  Invalid --bump value: ${bumpType}. Must be patch, minor, or major.`);
+    process.exit(1);
+  }
+
+  header("infernoflow publish");
+
+  if (dryRun) {
+    warn("DRY RUN — no files will be written, no commands executed");
+  }
+
+  // ── 1. Read current version ───────────────────────────────────────────────
+  const pkgPath = path.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const oldVersion = pkg.version;
+  const newVersion = bumpVersion(oldVersion, bumpType);
+
+  console.log();
+  console.log(`  ${gray("current")}  ${bold(oldVersion)}`);
+  console.log(`  ${gray("new     ")}  ${bold(green(newVersion))}  ${gray("(" + bumpType + " bump)")}`);
+  console.log();
+
+  // ── 2. Confirm ────────────────────────────────────────────────────────────
+  if (!yes && !dryRun) {
+    process.stdout.write(`  Publish ${bold(cyan("infernoflow@" + newVersion))} to npm? [y/N] `);
+    let confirmed = false;
+    try {
+      const answer = execSync("bash -c 'read -r ans </dev/tty; echo $ans'", {
+        encoding: "utf8",
+        stdio: ["inherit", "pipe", "inherit"],
+      }).trim().toLowerCase();
+      confirmed = answer === "y" || answer === "yes";
+    } catch {
+      confirmed = false;
+    }
+    console.log();
+    if (!confirmed) {
+      console.log(gray("  Aborted.\n"));
+      process.exit(0);
+    }
+  }
+
+  // ── 3. Bump package.json ──────────────────────────────────────────────────
+  info(`Bumping package.json  ${gray(oldVersion + " → " + newVersion)}`);
+  if (!dryRun) {
+    pkg.version = newVersion;
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 4) + "\n");
+    ok("package.json updated");
+  } else {
+    ok(gray("[dry] would write package.json"));
+  }
+
+  // ── 4. Update CHANGELOG ───────────────────────────────────────────────────
+  const changelogPath = path.join(PKG_ROOT, "CHANGELOG.md");
+  info("Updating CHANGELOG.md");
+  if (!dryRun) {
+    updateChangelog(changelogPath, newVersion);
+    ok("CHANGELOG.md updated");
+  } else {
+    ok(gray("[dry] would update CHANGELOG.md"));
+  }
+
+  // ── 5. Build ──────────────────────────────────────────────────────────────
+  if (!skipBuild) {
+    info("Running build  " + gray("node build.mjs"));
+    if (!dryRun) {
+      try {
+        run("node build.mjs", { silent: false });
+        ok("Build succeeded");
+      } catch (err) {
+        fail("Build failed", err.message);
+        process.exit(1);
+      }
+    } else {
+      ok(gray("[dry] would run: node build.mjs"));
+    }
+  } else {
+    warn("Skipping build  (--skip-build)");
+  }
+
+  // ── 6. Smoke tests ────────────────────────────────────────────────────────
+  if (!skipTests) {
+    info("Running smoke tests");
+    if (!dryRun) {
+      try {
+        run("npm test", { silent: false });
+        ok("All smoke tests passed");
+      } catch (err) {
+        fail("Smoke tests failed", "Fix tests or re-run with --skip-tests");
+        process.exit(1);
+      }
+    } else {
+      ok(gray("[dry] would run: npm test"));
+    }
+  } else {
+    warn("Skipping tests  (--skip-tests)");
+  }
+
+  // ── 7. npm publish ────────────────────────────────────────────────────────
+  info(`Publishing to npm  ${gray("infernoflow@" + newVersion)}`);
+  if (!dryRun) {
+    try {
+      run("npm publish", { silent: false });
+      ok(`Published infernoflow@${newVersion}`);
+    } catch (err) {
+      fail("npm publish failed", err.message || "Check npm credentials");
+      // Don't exit — still commit the version bump even if publish fails
+      warn("Continuing to git commit despite publish failure");
+    }
+  } else {
+    ok(gray("[dry] would run: npm publish"));
+  }
+
+  // ── 8. Git commit ─────────────────────────────────────────────────────────
+  info("Committing version bump");
+  if (!dryRun) {
+    try {
+      // Stage changed files
+      const filesToStage = ["package.json", "CHANGELOG.md"];
+      run(`git add ${filesToStage.join(" ")}`, { silent: false });
+
+      const commitMsg = `chore: release ${newVersion}`;
+      run(`git commit -m "${commitMsg}"`, { silent: false });
+      ok(`Committed: ${gray(commitMsg)}`);
+    } catch (err) {
+      warn(`Git commit failed: ${err.message}`);
+      warn("You can commit manually: git add package.json CHANGELOG.md && git commit -m \"chore: release " + newVersion + "\"");
+    }
+  } else {
+    ok(gray(`[dry] would commit: chore: release ${newVersion}`));
+  }
+
+  // ── 9. Git tag ────────────────────────────────────────────────────────────
+  if (createTag) {
+    info(`Creating git tag  ${gray("v" + newVersion)}`);
+    if (!dryRun) {
+      try {
+        run(`git tag v${newVersion}`, { silent: false });
+        ok(`Tagged v${newVersion}`);
+      } catch (err) {
+        warn(`Git tag failed: ${err.message}`);
+      }
+    } else {
+      ok(gray(`[dry] would tag: v${newVersion}`));
+    }
+  }
+
+  // ── 10. Git push ──────────────────────────────────────────────────────────
+  if (!skipPush) {
+    info("Pushing to origin");
+    if (!dryRun) {
+      try {
+        const pushCmd = createTag ? `git push && git push origin v${newVersion}` : "git push";
+        run(pushCmd, { silent: false });
+        ok("Pushed to origin");
+      } catch (err) {
+        warn(`Git push failed: ${err.message}`);
+        warn("Push manually: git push");
+      }
+    } else {
+      ok(gray("[dry] would run: git push"));
+    }
+  } else {
+    warn("Skipping push  (--skip-push)");
+  }
+
+  // ── Done ──────────────────────────────────────────────────────────────────
+  console.log();
+  if (dryRun) {
+    done(`Dry run complete — would have published infernoflow@${newVersion}`);
+  } else {
+    done(`infernoflow@${newVersion} published, committed, and pushed`);
+    console.log(`  ${cyan("npm:")}  https://www.npmjs.com/package/infernoflow`);
+    console.log(`  ${cyan("git:")}  ${gray("chore: release " + newVersion)}\n`);
+  }
+}

package/dist/lib/commands/run.mjs

@@ -1,10 +1,338 @@
-import*as a from"node:fs";import*as p from"node:path";import{execFileSync as T}from"node:child_process";import{fileURLToPath as L}from"node:url";import{generateWithLocalModel as $}from"../ai/localProvider.mjs";import{resolveProvider as q}from"../ai/providerRouter.mjs";import{buildPrompt as W,loadSuggestContext as G,parseSuggestionJson as O,validateSuggestion as M,detectSuggestionConflicts as V,applyChanges as K}from"./suggest.mjs";import{header as U,section as B,ok as x,warn as F,fail as v,info as h,gray as j}from"../ui/output.mjs";const z=L(import.meta.url),H=p.dirname(z),Q=p.resolve(H,"..","..","bin","infernoflow.mjs");function D(t){try{const e=T(process.execPath,[Q,...t],{encoding:"utf8",stdio:["ignore","pipe","pipe"]});return{ok:!0,data:JSON.parse(e)}}catch(e){const n=e?.stdout?.toString?.()||"";try{return{ok:!1,data:JSON.parse(n)}}catch{return{ok:!1,data:{ok:!1,errors:["command_failed"]}}}}}function m(t,e,n,o,s={}){const r={ts:new Date().toISOString(),stage:n,status:o,...s};if(e.push(r),t)return;const c=`${n}: ${o}`;o==="ok"?x(c):o==="warn"?F(c):o==="fail"?v(c):h(c)}function X(t){const e=p.join(t,"inferno"),n=[],o=r=>{for(const c of a.readdirSync(r,{withFileTypes:!0})){const f=p.join(r,c.name);c.isDirectory()?o(f):n.push(f)}};a.existsSync(e)&&o(e);const s=new Map;return n.forEach(r=>s.set(r,a.readFileSync(r,"utf8"))),s}function Y(t,e){const n=p.join(t,"inferno");if(a.existsSync(n)){const o=[],s=r=>{for(const c of a.readdirSync(r,{withFileTypes:!0})){const f=p.join(r,c.name);c.isDirectory()?s(f):o.push(f)}};s(n),o.forEach(r=>{e.has(r)||a.unlinkSync(r)})}for(const[o,s]of e.entries())a.mkdirSync(p.dirname(o),{recursive:!0}),a.writeFileSync(o,s,"utf8")}function Z(t,e){const n=p.join(t,"inferno","runs");a.mkdirSync(n,{recursive:!0});const o=p.join(n,`${Date.now()}.json`);return a.writeFileSync(o,JSON.stringify(e,null,2)+`
-`,"utf8"),p.relative(t,o)}function A(t,e,n=null){const o=t.indexOf(e);return o!==-1&&t[o+1]&&!t[o+1].startsWith("-")?t[o+1]:n}function ee(t){const e=new Set(["--provider","--ide"]),n=[];for(let o=1;o<t.length;o++){const s=t[o];if(s.startsWith("-")){e.has(s)&&(o+=1);continue}n.push(s)}return n.join(" ").trim()}function oe(t,e){return{summary:`Prompt fallback only: ${t}`,newCapabilities:[],removedCapabilities:[],updatedScenarios:[],changelogEntry:`- Prompt fallback mode for task: ${t} (no automatic contract mutation).`,_meta:{actionRequired:!0,nextStep:"Run infernoflow suggest or provide an agent bridge for automatic apply.",capabilitiesCount:(e?.capabilities||[]).length}}}async function te(t){if(process.env.INFERNO_AGENT_MOCK_RESPONSE)return process.env.INFERNO_AGENT_MOCK_RESPONSE;const e=process.env.INFERNO_AGENT_RESPONSE_FILE?process.env.INFERNO_AGENT_RESPONSE_FILE:p.join(process.cwd(),"inferno","agent-response.json");if(a.existsSync(e)){const r=a.readFileSync(e,"utf8");return a.unlinkSync(e),r}const n=p.join(process.cwd(),"inferno"),o=p.join(n,"agent-prompt.md");a.existsSync(o)&&a.unlinkSync(o),a.writeFileSync(o,t,"utf8"),process.stderr.write(`
-  \u2139 Prompt written to inferno/agent-prompt.md
-`),process.stderr.write(`  \u2192 Open it, paste into Cursor or Claude
-`),process.stderr.write(`  \u2192 Save the JSON reply to: inferno/agent-response.json
-`),process.stderr.write(`  Waiting up to 5 minutes...
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { generateWithLocalModel } from "../ai/localProvider.mjs";
+import { resolveProvider } from "../ai/providerRouter.mjs";
+import {
+  buildPrompt,
+  loadSuggestContext,
+  parseSuggestionJson,
+  validateSuggestion,
+  detectSuggestionConflicts,
+  applyChanges,
+} from "./suggest.mjs";
+import { header, section, ok, warn, fail, info, gray } from "../ui/output.mjs";
 
-`);const s=Date.now()+3e5;for(;Date.now()<s;)if(await new Promise(r=>setTimeout(r,1e3)),a.existsSync(e)){const r=a.readFileSync(e,"utf8");return a.unlinkSync(e),process.stderr.write(`  \u2714 Response received
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const binPath = path.resolve(__dirname, "..", "..", "bin", "infernoflow.mjs");
+
+function runCliJson(args) {
+  try {
+    const out = execFileSync(process.execPath, [binPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return { ok: true, data: JSON.parse(out) };
+  } 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"] } };
+    }
+  }
+}
+
+function stageEvent(asJson, events, stage, status, details = {}) {
+  const ev = { ts: new Date().toISOString(), stage, status, ...details };
+  events.push(ev);
+  if (asJson) return;
+  const text = `${stage}: ${status}`;
+  if (status === "ok") ok(text);
+  else if (status === "warn") warn(text);
+  else if (status === "fail") fail(text);
+  else info(text);
+}
+
+function snapshotInferno(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  const targets = [];
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else targets.push(p);
+    }
+  };
+  if (fs.existsSync(infernoDir)) walk(infernoDir);
+  const snapshot = new Map();
+  targets.forEach((filePath) => snapshot.set(filePath, fs.readFileSync(filePath, "utf8")));
+  return snapshot;
+}
+
+function restoreSnapshot(cwd, snapshot) {
+  const infernoDir = path.join(cwd, "inferno");
+  if (fs.existsSync(infernoDir)) {
+    const existing = [];
+    const walk = (dir) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, entry.name);
+        if (entry.isDirectory()) walk(p);
+        else existing.push(p);
+      }
+    };
+    walk(infernoDir);
+    existing.forEach((filePath) => {
+      if (!snapshot.has(filePath)) fs.unlinkSync(filePath);
+    });
+  }
+  for (const [filePath, content] of snapshot.entries()) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+}
+
+function writeRunArtifact(cwd, artifact) {
+  const runsDir = path.join(cwd, "inferno", "runs");
+  fs.mkdirSync(runsDir, { recursive: true });
+  const filePath = path.join(runsDir, `${Date.now()}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  return path.relative(cwd, filePath);
+}
+
+function getOptionValue(args, flag, fallback = null) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith("-")) return args[idx + 1];
+  return fallback;
+}
+
+function extractTask(args) {
+  const takesValue = new Set(["--provider", "--ide"]);
+  const out = [];
+  for (let i = 1; i < args.length; i++) {
+    const token = args[i];
+    if (token.startsWith("-")) {
+      if (takesValue.has(token)) i += 1;
+      continue;
+    }
+    out.push(token);
+  }
+  return out.join(" ").trim();
+}
+
+function buildPromptFallbackSuggestion(task, contract) {
+  return {
+    summary: `Prompt fallback only: ${task}`,
+    newCapabilities: [],
+    removedCapabilities: [],
+    updatedScenarios: [],
+    changelogEntry: `- Prompt fallback mode for task: ${task} (no automatic contract mutation).`,
+    _meta: {
+      actionRequired: true,
+      nextStep: "Run infernoflow suggest or provide an agent bridge for automatic apply.",
+      capabilitiesCount: (contract?.capabilities || []).length,
+    },
+  };
+}
+
+async function generateWithIdeAgent(prompt) {
+  if (process.env.INFERNO_AGENT_MOCK_RESPONSE) return process.env.INFERNO_AGENT_MOCK_RESPONSE;
+  const responseFile = process.env.INFERNO_AGENT_RESPONSE_FILE
+    ? process.env.INFERNO_AGENT_RESPONSE_FILE
+    : path.join(process.cwd(), "inferno", "agent-response.json");
+  if (fs.existsSync(responseFile)) {
+    const data = fs.readFileSync(responseFile, "utf8");
+    fs.unlinkSync(responseFile);
+    return data;
+  }
+  const infernoDir = path.join(process.cwd(), "inferno");
+  const promptFile = path.join(infernoDir, "agent-prompt.md");
+  if (fs.existsSync(promptFile)) fs.unlinkSync(promptFile);
+  fs.writeFileSync(promptFile, prompt, "utf8");
+  process.stderr.write("\n  \u2139 Prompt written to inferno/agent-prompt.md\n");
+  process.stderr.write("  \u2192 Open it, paste into Cursor or Claude\n");
+  process.stderr.write("  \u2192 Save the JSON reply to: inferno/agent-response.json\n");
+  process.stderr.write("  Waiting up to 5 minutes...\n\n");
+  const deadline = Date.now() + 300_000;
+  while (Date.now() < deadline) {
+    await new Promise(r => setTimeout(r, 1000));
+    if (fs.existsSync(responseFile)) {
+      const data = fs.readFileSync(responseFile, "utf8");
+      fs.unlinkSync(responseFile);
+      process.stderr.write("  \u2714 Response received\n\n");
+      return data;
+    }
+  }
+  throw new Error("ide_agent_bridge_timeout");
+}
+
+export async function runCommand(args = []) {
+  const asJson = args.includes("--json");
+  const dryRun = args.includes("--dry-run");
+  const noRollback = args.includes("--no-rollback");
+  const providerRequested = (getOptionValue(args, "--provider", "auto") || "auto").toLowerCase();
+  const ideRequested = (getOptionValue(args, "--ide", "auto") || "auto").toLowerCase();
+  const task = extractTask(args) || "sync check";
+  const cwd = process.cwd();
+  const events = [];
+  const reasonCodes = [];
+
+  if (!asJson) header("run");
+  stageEvent(asJson, events, "init", "info", { task, dryRun, noRollback });
+
+  // detect
+  const impact = runCliJson(["pr-impact", "--json"]);
+  stageEvent(asJson, events, "detect", impact.data?.ok ? "ok" : "warn", { confidence: impact.data?.confidence || "low" });
+
+  const routed = await resolveProvider(providerRequested, ideRequested);
+  reasonCodes.push(...(routed.reasonCodes || []));
+  if (routed.error === "agent_unavailable") {
+    const payload = {
+      ok: false,
+      error: "agent_unavailable",
+      providerRequested,
+      providerResolved: routed.providerResolved,
+      ideDetected: routed.ideDetected,
+      agentAvailable: routed.agentAvailable,
+      reasonCodes,
+      events,
+    };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("provider agent unavailable", "Use --provider auto|local|prompt");
+    process.exit(1);
+  }
+  stageEvent(asJson, events, "route", "ok", {
+    providerRequested,
+    providerResolved: routed.providerResolved,
+    ideDetected: routed.ideDetected,
+    agentAvailable: routed.agentAvailable,
+  });
+
+  const ctx = loadSuggestContext(cwd);
+  if (!ctx?.contract) {
+    const payload = { ok: false, error: "inferno_missing", events };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("inferno/ missing or invalid");
+    process.exit(1);
+  }
+
+  // propose
+  const prompt = buildPrompt({
+    description: task,
+    contract: ctx.contract,
+    capabilities: ctx.capabilities,
+    scenarios: ctx.scenarios,
+  });
+  let suggestion;
+  try {
+    if (routed.providerResolved === "local") {
+      const raw = await generateWithLocalModel(prompt);
+      suggestion = parseSuggestionJson(raw);
+    } else if (routed.providerResolved === "agent") {
+      const raw = await generateWithIdeAgent(prompt);
+      suggestion = parseSuggestionJson(raw);
+    } else {
+      suggestion = buildPromptFallbackSuggestion(task, ctx.contract);
+    }
+  } catch (err) {
+    const payload = { ok: false, error: "proposal_failed", reason: String(err.message || err), reasonCodes, events };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("proposal generation failed", err.message);
+    process.exit(1);
+  }
+  stageEvent(asJson, events, "propose", "ok", {
+    newCapabilities: (suggestion.newCapabilities || []).length,
+    removedCapabilities: (suggestion.removedCapabilities || []).length,
+  });
+
+  const schemaErrors = routed.providerResolved === "prompt" ? [] : validateSuggestion(suggestion);
+  const conflictErrors = routed.providerResolved === "prompt" ? [] : detectSuggestionConflicts(ctx.contract, suggestion);
+  if (schemaErrors.length || conflictErrors.length) {
+    const payload = {
+      ok: false,
+      error: "invalid_suggestion",
+      issues: [...schemaErrors, ...conflictErrors],
+      events,
+    };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("suggestion invalid", payload.issues[0]);
+    process.exit(1);
+  }
+
+  const snapshot = snapshotInferno(cwd);
+  let rolledBack = false;
+  let applyChanged = false;
+  let validationPassed = false;
+
+  try {
+    if (dryRun) {
+      stageEvent(asJson, events, "apply", "info", { dryRun: true });
+    } else if (routed.providerResolved === "prompt") {
+      stageEvent(asJson, events, "apply", "warn", {
+        skipped: true,
+        reason: "prompt_fallback_requires_manual_step",
+      });
+    } else {
+      applyChanged = applyChanges({
+        cwd,
+        contract: ctx.contract,
+        capabilities: ctx.capabilities,
+        suggestion,
+        version: ctx.version,
+        quiet: asJson,
+      });
+      stageEvent(asJson, events, "apply", "ok", { changed: applyChanged });
+    }
+
+    let check = runCliJson(["check", "--json"]);
+    if (process.env.INFERNO_TEST_FORCE_VALIDATE_FAIL === "1") {
+      check = { ok: false, data: { ok: false, errors: ["forced_validation_failure"] } };
+    }
+    if (!check.ok || !check.data?.ok) {
+      throw new Error(`validation_failed:${(check.data?.errors || []).join(",")}`);
+    }
+    validationPassed = true;
+    stageEvent(asJson, events, "validate", "ok");
+  } catch (err) {
+    stageEvent(asJson, events, "validate", "fail", { reason: String(err.message || err) });
+    if (!dryRun && !noRollback) {
+      restoreSnapshot(cwd, snapshot);
+      rolledBack = true;
+      stageEvent(asJson, events, "rollback", "ok");
+    }
+  }
+
+  const artifact = {
+    task,
+    dryRun,
+    noRollback,
+    rolledBack,
+    applyChanged,
+    suggestionSummary: suggestion.summary || "",
+    touchedCapabilities: [
+      ...(suggestion.newCapabilities || []).map((c) => c.id),
+      ...(suggestion.removedCapabilities || []),
+    ],
+    events,
+  };
+  const artifactPath = writeRunArtifact(cwd, artifact);
+
+  const payload = {
+    ok: validationPassed,
+    mode: "run",
+    task,
+    dryRun,
+    providerRequested,
+    providerResolved: routed.providerResolved,
+    ideDetected: routed.ideDetected,
+    agentAvailable: routed.agentAvailable,
+    reasonCodes: Array.from(new Set(reasonCodes)),
+    rolledBack,
+    applyChanged,
+    artifactPath,
+    events,
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(payload.ok ? 0 : 1);
+  }
+
+  section("Result");
+  info(`task: ${gray(task)}`);
+  info(`artifact: ${gray(artifactPath)}`);
+  if (payload.ok) ok("run completed");
+  else warn("run rolled back after failed validation");
+  console.log();
+  process.exit(payload.ok ? 0 : 1);
+}
 
-`),r}throw new Error("ide_agent_bridge_timeout")}async function le(t=[]){const e=t.includes("--json"),n=t.includes("--dry-run"),o=t.includes("--no-rollback"),s=(A(t,"--provider","auto")||"auto").toLowerCase(),r=(A(t,"--ide","auto")||"auto").toLowerCase(),c=ee(t)||"sync check",f=process.cwd(),l=[],y=[];e||U("run"),m(e,l,"init","info",{task:c,dryRun:n,noRollback:o});const b=D(["pr-impact","--json"]);m(e,l,"detect",b.data?.ok?"ok":"warn",{confidence:b.data?.confidence||"low"});const d=await q(s,r);if(y.push(...d.reasonCodes||[]),d.error==="agent_unavailable"){const i={ok:!1,error:"agent_unavailable",providerRequested:s,providerResolved:d.providerResolved,ideDetected:d.ideDetected,agentAvailable:d.agentAvailable,reasonCodes:y,events:l};e?console.log(JSON.stringify(i,null,2)):v("provider agent unavailable","Use --provider auto|local|prompt"),process.exit(1)}m(e,l,"route","ok",{providerRequested:s,providerResolved:d.providerResolved,ideDetected:d.ideDetected,agentAvailable:d.agentAvailable});const g=G(f);g?.contract||(e?console.log(JSON.stringify({ok:!1,error:"inferno_missing",events:l},null,2)):v("inferno/ missing or invalid"),process.exit(1));const _=W({description:c,contract:g.contract,capabilities:g.capabilities,scenarios:g.scenarios});let u;try{if(d.providerResolved==="local"){const i=await $(_);u=O(i)}else if(d.providerResolved==="agent"){const i=await te(_);u=O(i)}else u=oe(c,g.contract)}catch(i){const J={ok:!1,error:"proposal_failed",reason:String(i.message||i),reasonCodes:y,events:l};e?console.log(JSON.stringify(J,null,2)):v("proposal generation failed",i.message),process.exit(1)}m(e,l,"propose","ok",{newCapabilities:(u.newCapabilities||[]).length,removedCapabilities:(u.removedCapabilities||[]).length});const R=d.providerResolved==="prompt"?[]:M(u),E=d.providerResolved==="prompt"?[]:V(g.contract,u);if(R.length||E.length){const i={ok:!1,error:"invalid_suggestion",issues:[...R,...E],events:l};e?console.log(JSON.stringify(i,null,2)):v("suggestion invalid",i.issues[0]),process.exit(1)}const P=X(f);let w=!1,S=!1,N=!1;try{n?m(e,l,"apply","info",{dryRun:!0}):d.providerResolved==="prompt"?m(e,l,"apply","warn",{skipped:!0,reason:"prompt_fallback_requires_manual_step"}):(S=K({cwd:f,contract:g.contract,capabilities:g.capabilities,suggestion:u,version:g.version,quiet:e}),m(e,l,"apply","ok",{changed:S}));let i=D(["check","--json"]);if(process.env.INFERNO_TEST_FORCE_VALIDATE_FAIL==="1"&&(i={ok:!1,data:{ok:!1,errors:["forced_validation_failure"]}}),!i.ok||!i.data?.ok)throw new Error(`validation_failed:${(i.data?.errors||[]).join(",")}`);N=!0,m(e,l,"validate","ok")}catch(i){m(e,l,"validate","fail",{reason:String(i.message||i)}),!n&&!o&&(Y(f,P),w=!0,m(e,l,"rollback","ok"))}const I={task:c,dryRun:n,noRollback:o,rolledBack:w,applyChanged:S,suggestionSummary:u.summary||"",touchedCapabilities:[...(u.newCapabilities||[]).map(i=>i.id),...u.removedCapabilities||[]],events:l},C=Z(f,I),k={ok:N,mode:"run",task:c,dryRun:n,providerRequested:s,providerResolved:d.providerResolved,ideDetected:d.ideDetected,agentAvailable:d.agentAvailable,reasonCodes:Array.from(new Set(y)),rolledBack:w,applyChanged:S,artifactPath:C,events:l};e&&(console.log(JSON.stringify(k,null,2)),process.exit(k.ok?0:1)),B("Result"),h(`task: ${j(c)}`),h(`artifact: ${j(C)}`),k.ok?x("run completed"):F("run rolled back after failed validation"),console.log(),process.exit(k.ok?0:1)}export{le as runCommand};