@aiviatic/kindling 0.1.0

package/dist/chunk-MW7UAGER.js

@@ -0,0 +1,890 @@
+import {
+  ErrorCode,
+  Phase,
+  Status,
+  StepId,
+  exec,
+  expandTilde
+} from "./chunk-OU3WSB6B.js";
+
+// engine/emitter.ts
+var EngineEmitter = class {
+  log = [];
+  listeners = /* @__PURE__ */ new Set();
+  /** Subscribe to events. Returns an unsubscribe function. */
+  on(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Emit an event: freeze it, append to the log, then notify listeners in subscription order. */
+  emit(event) {
+    const frozen = Object.freeze({ ...event });
+    this.log.push(frozen);
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(frozen);
+      } catch {
+      }
+    }
+  }
+  /** A snapshot of the append-only event log, in emission order. */
+  events() {
+    return [...this.log];
+  }
+};
+
+// engine/pins.ts
+var pins = Object.freeze({
+  node: "24.16.0",
+  bmad: "6.9.0",
+  // frozen for the Cohort #1 cycle (matches this repo's BMad install; tools + install flags verified vs the real 6.9.0 CLI 2026-07-02); bump between cohorts
+  kindling: "0.1.0"
+});
+
+// engine/messages.ts
+var stepMessages = {
+  [StepId.ProvisionNode]: "Setting up Node \u2014 the engine your project runs on.",
+  [StepId.ProvisionGit]: "Setting up Git \u2014 it keeps the history of your project safe.",
+  [StepId.ProvisionXcodeClt]: "macOS is installing some developer tools. A system dialog popped up \u2014 click Install. This is completely normal and usually takes about 5 minutes. You can grab a coffee.",
+  [StepId.ScaffoldGitInit]: "Creating your project folder and starting its history.",
+  [StepId.InstallBmad]: "Installing BMad \u2014 the toolkit that powers your project. This is a sizeable download, so it can take a couple of minutes. Nothing is stuck; hang tight.",
+  [StepId.InstallAgentCli]: "Installing your AI coding assistant so it\u2019s ready to run right after setup.",
+  [StepId.FinalizeSelfCheck]: "Double-checking everything is in place."
+};
+var agentCliMessages = {
+  working: (name) => `Installing ${name} so you can start right away.`,
+  done: (name) => `${name} is installed and ready to run.`,
+  skipped: (name) => `${name} is already installed \u2014 reusing it.`,
+  failed: (name) => `${name} didn\u2019t finish installing \u2014 your project is still set up and ready. You can press Retry, or install it yourself later.`,
+  manualInstall: (pkg) => `To install it yourself later, run: npm install -g ${pkg}`
+};
+var scaffoldMessages = {
+  done: "Your project folder is ready.",
+  skipped: "Project already set up \u2014 nothing to do.",
+  blocked: "This folder already has files in it. Kindling won\u2019t change anything without your OK \u2014 pick an empty folder, or confirm before continuing.",
+  failed: "Setting up your project folder ran into a problem. Check the details, then press Retry."
+};
+var provisionMessages = {
+  nodePresent: "Node is already installed \u2014 reusing it.",
+  nodeQueued: "Node needs setting up \u2014 the engine your project runs on.",
+  gitPresent: "Git is already installed \u2014 reusing it.",
+  gitQueued: "Git needs setting up \u2014 it keeps the history of your project.",
+  gitInstalled: "Git is set up.",
+  xcodeWaiting: "Still installing developer tools\u2026 the macOS dialog is doing its thing. This can take a few minutes \u2014 hang tight, nothing is stuck.",
+  xcodeDone: "Developer tools are ready \u2014 Git is set up.",
+  xcodeTimeout: "The developer-tools install is taking longer than expected. If the macOS dialog is still open, let it finish, then press Retry.",
+  xcodeInstallFailed: "We couldn\u2019t start the developer-tools install. Make sure you\u2019re connected, then press Retry.",
+  gitInstallFailed: "Setting up Git ran into a problem \u2014 it may need permission to install. Check the details, then press Retry."
+};
+var selfCheckMessages = {
+  done: "Everything checks out \u2014 you\u2019re ready.",
+  failed: "Some checks didn\u2019t pass \u2014 see the readiness details."
+};
+var installMessages = {
+  notPinned: "BMad isn\u2019t pinned to a version yet \u2014 set the cohort version before installing.",
+  done: (version) => `BMad ${version} installed.`
+};
+var errorMessages = {
+  [ErrorCode.ExecFailed]: "Something needs a quick fix \u2014 a step did not finish. Check the next step below, then press Retry.",
+  [ErrorCode.NetworkLost]: "We lost the connection. Reconnect to the internet, then press Retry.",
+  [ErrorCode.BmadInstallFailed]: "BMad didn\u2019t finish installing. The details are below \u2014 press Retry.",
+  [ErrorCode.AgentCliInstallFailed]: "Your AI coding assistant didn\u2019t finish installing \u2014 your project is still ready. Press Retry, or install it yourself later.",
+  [ErrorCode.ExecPolicyBlocked]: "Windows blocked the script because it\u2019s unsigned \u2014 that\u2019s expected, safe, and reversible.",
+  [ErrorCode.SmartScreenBlocked]: "Windows SmartScreen (or your antivirus) paused the script \u2014 that\u2019s expected, safe, and reversible.",
+  [ErrorCode.ProjectConflict]: "That folder already has files in it that Kindling didn\u2019t create."
+};
+var recoveryGuidance = {
+  [ErrorCode.ExecFailed]: {
+    title: "Something needs a quick fix.",
+    detail: "A step didn\u2019t finish. This usually clears up on a second try \u2014 press Retry.",
+    recovery: "retry"
+  },
+  [ErrorCode.NetworkLost]: {
+    title: "We lost the connection.",
+    detail: "A download was interrupted. Reconnect to the internet, then press Retry \u2014 Kindling resumes where it left off.",
+    recovery: "retry"
+  },
+  [ErrorCode.BmadInstallFailed]: {
+    title: "BMad didn\u2019t install.",
+    detail: "The install step didn\u2019t finish. This is usually temporary \u2014 press Retry. The step details below show what happened.",
+    recovery: "retry"
+  },
+  [ErrorCode.AgentCliInstallFailed]: {
+    // No `fixCommand` here: the exact package differs per CLI (claude-code vs codex), so the
+    // concrete, copy-pasteable `npm install -g <package>` line ships in the failed step's own
+    // message (agentCliMessages.manualInstall) rather than in this static, error-code-keyed entry.
+    title: "Your AI assistant didn\u2019t install.",
+    detail: "Your project is set up and ready either way \u2014 this step is optional. Press Retry to try again, or install it yourself later using the command shown in the step details below.",
+    recovery: "retry"
+  },
+  [ErrorCode.ExecPolicyBlocked]: {
+    title: "Something needs a quick fix.",
+    detail: "Windows blocked the script because it\u2019s unsigned \u2014 that\u2019s expected, and it\u2019s safe and reversible. Run this one line in PowerShell, then come back and press Retry:",
+    fixCommand: "Set-ExecutionPolicy -Scope Process Bypass",
+    recovery: "retry"
+  },
+  [ErrorCode.SmartScreenBlocked]: {
+    title: "Windows asked you to confirm.",
+    detail: "SmartScreen or your antivirus paused the script \u2014 this is expected and safe. Choose \u201CMore info\u201D, then \u201CRun anyway\u201D, and press Retry. Nothing was changed on your computer.",
+    recovery: "retry"
+  },
+  [ErrorCode.ProjectConflict]: {
+    title: "That folder isn\u2019t empty.",
+    detail: "It already contains files Kindling didn\u2019t create, so we won\u2019t touch them. Pick a different (empty or new) folder and we\u2019ll set up there.",
+    recovery: "choose-folder"
+  }
+};
+
+// engine/orchestrate/scaffold.ts
+import { mkdir, readdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { randomUUID } from "crypto";
+var MARKER = ".kindling.json";
+var OS_CRUFT = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db"]);
+function isTrivial(entry) {
+  return entry === MARKER || entry === ".git" || OS_CRUFT.has(entry);
+}
+async function scaffold(opts) {
+  const git = opts.git ?? "git";
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const emit = (status, humanMessage, level = "info", errorCode) => {
+    opts.emitter.emit({
+      id: randomUUID(),
+      phase: Phase.Scaffold,
+      step: StepId.ScaffoldGitInit,
+      status,
+      humanMessage,
+      level,
+      timestamp: now(),
+      errorCode
+    });
+  };
+  const doInit = async () => {
+    emit(Status.Working, stepMessages[StepId.ScaffoldGitInit]);
+    try {
+      await mkdir(opts.projectDir, { recursive: true });
+      await initRepo(git, opts);
+    } catch (err) {
+      emit(Status.Failed, scaffoldMessages.failed, "error", ErrorCode.ExecFailed);
+      throw err;
+    }
+    emit(Status.Done, scaffoldMessages.done);
+  };
+  const entries = await readDirSafe(opts.projectDir);
+  if (entries !== null) {
+    const hasMarker = entries.includes(MARKER);
+    const foreign = entries.filter((e) => !isTrivial(e));
+    if (!hasMarker && foreign.length > 0) {
+      emit(Status.Failed, scaffoldMessages.blocked, "error", ErrorCode.ProjectConflict);
+      return "blocked";
+    }
+    if (hasMarker && await hasCommit(git, opts.projectDir)) {
+      emit(Status.Skipped, scaffoldMessages.skipped);
+      return "skipped";
+    }
+    await doInit();
+    return hasMarker ? "resumed" : "created";
+  }
+  await doInit();
+  return "created";
+}
+async function initRepo(git, opts) {
+  await run(git, ["-C", opts.projectDir, "init", "-b", "main"]);
+  await writeFile(
+    join(opts.projectDir, MARKER),
+    JSON.stringify({ scaffoldedBy: "kindling", project: opts.projectName }, null, 2) + "\n"
+  );
+  await run(git, ["-C", opts.projectDir, "add", "-A"]);
+  await run(git, [
+    "-C",
+    opts.projectDir,
+    "-c",
+    "user.name=Kindling",
+    "-c",
+    "user.email=kindling@local",
+    "-c",
+    "commit.gpgsign=false",
+    "-c",
+    "core.hooksPath=",
+    "commit",
+    "-m",
+    "Initial commit"
+  ]);
+}
+async function hasCommit(git, dir) {
+  try {
+    const r = await exec(git, ["-C", dir, "rev-parse", "--verify", "HEAD"]);
+    return r.code === 0;
+  } catch {
+    return false;
+  }
+}
+async function run(git, args) {
+  const r = await exec(git, args);
+  if (r.code !== 0) {
+    throw new Error(`git ${args.join(" ")} failed (code ${r.code}): ${r.stderr.trim()}`);
+  }
+}
+async function readDirSafe(dir) {
+  try {
+    return await readdir(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+// engine/orchestrate/flags.ts
+function composeInstallArgs(config, action = "install") {
+  for (const value of [...config.modules, ...config.ides]) {
+    if (value.includes(",")) {
+      throw new Error(`module/IDE value may not contain a comma: "${value}"`);
+    }
+  }
+  const args = ["install", "--yes", "--directory", config.projectDir];
+  if (action === "update") {
+    args.push("--action", "update");
+  }
+  if (config.modules.length > 0) {
+    args.push("--modules", config.modules.join(","));
+  }
+  if (config.ides.length > 0) {
+    args.push("--tools", config.ides.join(","));
+  }
+  if (config.set) {
+    for (const [key, value] of Object.entries(config.set)) {
+      args.push("--set", `${key}=${value}`);
+    }
+  }
+  return args;
+}
+
+// engine/orchestrate/bmad-install.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { stat } from "fs/promises";
+import { join as join2 } from "path";
+async function defaultBmadInstalled(projectDir) {
+  try {
+    return (await stat(join2(projectDir, "_bmad"))).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function runBmadInstall(opts) {
+  const exec2 = opts.exec ?? exec;
+  const npx = opts.npxCommand ?? "npx";
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const bmadTarget = opts.config.bmadTarget ?? "pinned";
+  const versionTag = bmadTarget === "latest" ? "latest" : opts.config.pins.bmad;
+  const emit = (status, humanMessage, level = "info", errorCode) => {
+    opts.emitter.emit({
+      id: randomUUID2(),
+      phase: Phase.Install,
+      step: StepId.InstallBmad,
+      status,
+      humanMessage,
+      level,
+      timestamp: now(),
+      errorCode
+    });
+  };
+  emit(Status.Working, stepMessages[StepId.InstallBmad]);
+  if (bmadTarget === "pinned" && versionTag.includes("TODO")) {
+    emit(Status.Failed, installMessages.notPinned, "error", ErrorCode.BmadInstallFailed);
+    return { ok: false, bmadVersion: versionTag };
+  }
+  let result;
+  try {
+    let action;
+    if (bmadTarget === "latest") {
+      action = "update";
+    } else {
+      const alreadyInstalled = opts.bmadAlreadyInstalled ?? defaultBmadInstalled;
+      action = await alreadyInstalled(opts.config.projectDir) ? "update" : "install";
+    }
+    const args = [`bmad-method@${versionTag}`, ...composeInstallArgs(opts.config, action)];
+    result = await exec2(npx, args);
+  } catch (err) {
+    emit(Status.Failed, errorMessages[ErrorCode.BmadInstallFailed], "error", ErrorCode.BmadInstallFailed);
+    throw err;
+  }
+  if (result.code !== 0) {
+    emit(Status.Failed, errorMessages[ErrorCode.BmadInstallFailed], "error", ErrorCode.BmadInstallFailed);
+    return { ok: false, bmadVersion: versionTag };
+  }
+  emit(Status.Done, installMessages.done(versionTag));
+  return { ok: true, bmadVersion: versionTag };
+}
+
+// engine/orchestrate/agent-cli.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// engine/probe.ts
+async function probeVersion(exec2, cmd) {
+  try {
+    const r = await exec2(cmd, ["--version"]);
+    const out = r.stdout.trim() || r.stderr.trim();
+    return r.code === 0 && out ? out : null;
+  } catch {
+    return null;
+  }
+}
+
+// engine/orchestrate/agent-cli.ts
+var AGENT_CLI_TABLE = {
+  "claude-code": { pkg: "@anthropic-ai/claude-code", bin: "claude", name: "Claude Code" },
+  codex: { pkg: "@openai/codex", bin: "codex", name: "Codex" }
+};
+function eligibleAgentClis(installCli) {
+  return [...new Set((installCli ?? []).filter((id) => id in AGENT_CLI_TABLE))].map((id) => ({
+    id,
+    ...AGENT_CLI_TABLE[id]
+  }));
+}
+async function installAgentCli(opts) {
+  const exec2 = opts.exec ?? exec;
+  const npm = opts.npmCommand ?? "npm";
+  const resolveBin = opts.resolveBin ?? ((bin) => bin);
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const emit = (status, humanMessage, level = "info", errorCode) => {
+    opts.emitter.emit({
+      id: randomUUID3(),
+      phase: Phase.Install,
+      step: StepId.InstallAgentCli,
+      status,
+      humanMessage,
+      level,
+      timestamp: now(),
+      errorCode
+    });
+  };
+  const installed = [];
+  const skipped = [];
+  const failed = [];
+  const eligible = eligibleAgentClis(opts.config.installCli);
+  for (const { id, pkg, bin, name } of eligible) {
+    if (await probeVersion(exec2, resolveBin(bin)) !== null) {
+      emit(Status.Skipped, agentCliMessages.skipped(name));
+      skipped.push(id);
+      continue;
+    }
+    emit(Status.Working, agentCliMessages.working(name));
+    const failMessage = `${agentCliMessages.failed(name)} ${agentCliMessages.manualInstall(pkg)}`;
+    try {
+      const result = await exec2(npm, ["install", "-g", pkg]);
+      if (result.code === 0) {
+        emit(Status.Done, agentCliMessages.done(name));
+        installed.push(id);
+      } else {
+        emit(Status.Failed, failMessage, "error", ErrorCode.AgentCliInstallFailed);
+        failed.push(id);
+      }
+    } catch {
+      emit(Status.Failed, failMessage, "error", ErrorCode.AgentCliInstallFailed);
+      failed.push(id);
+    }
+  }
+  return { ok: true, installed, skipped, failed };
+}
+
+// engine/bmad-manifest.ts
+import { readFile } from "fs/promises";
+import { join as join3 } from "path";
+import { load } from "js-yaml";
+async function readInstalledBmadVersion(projectDir) {
+  try {
+    const raw = await readFile(join3(projectDir, "_bmad", "_config", "manifest.yaml"), "utf8");
+    const doc = load(raw);
+    if (typeof doc !== "object" || doc === null) return null;
+    const installation = doc.installation;
+    if (typeof installation !== "object" || installation === null) return null;
+    const version = installation.version;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+// engine/validation-summary.ts
+var SCHEMA_VERSION = 3;
+var NODE_FLOOR_MAJOR = 20;
+function buildValidationSummary(facts) {
+  const success = facts.node.present && facts.node.satisfiesFloor && facts.git.present && facts.bmad.installed && facts.scaffold.created;
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    kindlingVersion: facts.kindlingVersion,
+    os: facts.os,
+    arch: facts.arch,
+    osVersion: facts.osVersion,
+    node: facts.node,
+    git: facts.git,
+    bmad: facts.bmad,
+    scaffold: facts.scaffold,
+    cli: facts.cli,
+    success,
+    generatedAt: facts.generatedAt
+  };
+}
+function isCliPresence(c) {
+  return typeof c === "object" && c !== null && typeof c.name === "string" && typeof c.bin === "string" && typeof c.pkg === "string" && typeof c.present === "boolean";
+}
+function cliLoginGuidance(summary) {
+  return (summary.cli ?? []).filter(isCliPresence).filter((c) => c.present);
+}
+function cliMissing(summary) {
+  return (summary.cli ?? []).filter(isCliPresence).filter((c) => !c.present);
+}
+function bmadVersionLabel(summary, pinnedFallback) {
+  const installed = summary?.bmad?.installedVersion;
+  if (typeof installed === "string" && installed.length > 0 && installed !== pinnedFallback) {
+    return { version: installed, note: "updated to latest" };
+  }
+  return { version: pinnedFallback, note: "a stable, tested version" };
+}
+function parseMajor(version) {
+  if (!version) return null;
+  const m = /(\d+)(?:\.\d+){0,2}/.exec(version);
+  return m ? Number(m[1]) : null;
+}
+
+// engine/self-check.ts
+import { release } from "os";
+import { randomUUID as randomUUID4 } from "crypto";
+async function runSelfCheck(opts) {
+  const exec2 = opts.exec ?? exec;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const resolveBin = opts.resolveBin ?? ((bin) => bin);
+  const readInstalledBmadVersion2 = opts.readInstalledBmadVersion ?? readInstalledBmadVersion;
+  const platform = opts.platform ?? {
+    os: process.platform,
+    arch: process.arch,
+    osVersion: release()
+  };
+  const emit = (status, humanMessage, level = "info", errorCode, summaryJson) => {
+    opts.emitter.emit({
+      id: randomUUID4(),
+      phase: Phase.Finalize,
+      step: StepId.FinalizeSelfCheck,
+      status,
+      humanMessage,
+      level,
+      timestamp: now(),
+      errorCode,
+      summaryJson
+    });
+  };
+  const generatedAt = now();
+  emit(Status.Working, stepMessages[StepId.FinalizeSelfCheck]);
+  const nodeVersion = await probeVersion(exec2, opts.node ?? "node");
+  const gitVersion = await probeVersion(exec2, opts.git ?? "git");
+  const nodeMajor = parseMajor(nodeVersion);
+  const cli = [];
+  for (const c of opts.agentClis ?? []) {
+    const present = await probeVersion(exec2, resolveBin(c.bin)) !== null;
+    cli.push({ id: c.id, name: c.name, bin: c.bin, pkg: c.pkg, present });
+  }
+  const installedVersion = await readInstalledBmadVersion2(opts.projectDir);
+  const summary = buildValidationSummary({
+    kindlingVersion: pins.kindling,
+    os: platform.os,
+    arch: platform.arch,
+    osVersion: platform.osVersion,
+    node: {
+      present: nodeVersion !== null,
+      version: nodeVersion,
+      satisfiesFloor: nodeMajor !== null && nodeMajor >= NODE_FLOOR_MAJOR
+    },
+    git: { present: gitVersion !== null, version: gitVersion },
+    bmad: { pinnedVersion: pins.bmad, installed: opts.bmadInstalled, installedVersion },
+    scaffold: { created: opts.scaffoldCreated },
+    cli,
+    generatedAt
+  });
+  if (summary.success) {
+    emit(Status.Done, selfCheckMessages.done, "info", void 0, JSON.stringify(summary));
+  } else {
+    emit(Status.Failed, selfCheckMessages.failed, "error", ErrorCode.ExecFailed);
+  }
+  return summary;
+}
+
+// engine/provision/detect.ts
+import { randomUUID as randomUUID5 } from "crypto";
+async function detectDependencies(opts = {}) {
+  const exec2 = opts.exec ?? exec;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const nodeVersion = await probeVersion(exec2, opts.node ?? "node");
+  const nodeMajor = parseMajor(nodeVersion);
+  const node = {
+    present: nodeVersion !== null,
+    version: nodeVersion,
+    satisfiesFloor: nodeMajor !== null && nodeMajor >= NODE_FLOOR_MAJOR
+  };
+  const gitVersion = await probeVersion(exec2, opts.git ?? "git");
+  const git = { present: gitVersion !== null, version: gitVersion };
+  const emitter = opts.emitter;
+  if (emitter) {
+    const emit = (step, status, humanMessage, level = "info") => {
+      emitter.emit({
+        id: randomUUID5(),
+        phase: Phase.Provision,
+        step,
+        status,
+        humanMessage,
+        level,
+        timestamp: now()
+      });
+    };
+    if (node.present && node.satisfiesFloor) {
+      emit(StepId.ProvisionNode, Status.Skipped, provisionMessages.nodePresent);
+    } else {
+      emit(StepId.ProvisionNode, Status.Queued, provisionMessages.nodeQueued);
+    }
+    if (git.present) {
+      emit(StepId.ProvisionGit, Status.Skipped, provisionMessages.gitPresent);
+    } else {
+      emit(StepId.ProvisionGit, Status.Queued, provisionMessages.gitQueued);
+    }
+  }
+  return { node, git };
+}
+
+// engine/provision/git-unix.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function makeDefaults(exec2) {
+  return {
+    triggerXcodeInstall: async () => {
+      await exec2("xcode-select", ["--install"]);
+    },
+    checkXcode: async () => (await exec2("xcode-select", ["-p"])).code === 0,
+    installLinuxGit: async () => {
+      const r = await exec2("sudo", ["-n", "apt-get", "install", "-y", "git"]);
+      if (r.code !== 0) throw new Error(`apt-get install git failed (code ${r.code}): ${r.stderr.trim()}`);
+    }
+  };
+}
+async function provisionGitUnix(opts) {
+  const exec2 = opts.exec ?? exec;
+  const d = makeDefaults(exec2);
+  const triggerXcodeInstall = opts.triggerXcodeInstall ?? d.triggerXcodeInstall;
+  const checkXcode = opts.checkXcode ?? d.checkXcode;
+  const installLinuxGit = opts.installLinuxGit ?? d.installLinuxGit;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const pollIntervalMs = opts.pollIntervalMs ?? 3e3;
+  const maxPolls = opts.maxPolls ?? 200;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const isMac = opts.platform === "darwin";
+  const step = isMac ? StepId.ProvisionXcodeClt : StepId.ProvisionGit;
+  const emit = (status, humanMessage, level = "info", errorCode) => {
+    opts.emitter.emit({
+      id: randomUUID6(),
+      phase: Phase.Provision,
+      step,
+      status,
+      humanMessage,
+      level,
+      timestamp: now(),
+      errorCode
+    });
+  };
+  if (opts.alreadyOk) {
+    emit(Status.Skipped, isMac ? provisionMessages.xcodeDone : provisionMessages.gitPresent);
+    return { ok: true };
+  }
+  if (isMac) {
+    emit(Status.Working, stepMessages[StepId.ProvisionXcodeClt]);
+    try {
+      await triggerXcodeInstall();
+    } catch (err) {
+      emit(Status.Failed, provisionMessages.xcodeInstallFailed, "error", ErrorCode.ExecFailed);
+      throw err;
+    }
+    for (let i = 0; i < maxPolls; i++) {
+      if (await checkXcode()) {
+        emit(Status.Done, provisionMessages.xcodeDone);
+        return { ok: true };
+      }
+      emit(Status.Working, provisionMessages.xcodeWaiting);
+      if (i < maxPolls - 1) await sleep(pollIntervalMs);
+    }
+    emit(Status.Failed, provisionMessages.xcodeTimeout, "error", ErrorCode.ExecFailed);
+    return { ok: false };
+  }
+  emit(Status.Working, stepMessages[StepId.ProvisionGit]);
+  try {
+    await installLinuxGit();
+  } catch (err) {
+    emit(Status.Failed, provisionMessages.gitInstallFailed, "error", ErrorCode.ExecFailed);
+    throw err;
+  }
+  emit(Status.Done, provisionMessages.gitInstalled);
+  return { ok: true };
+}
+
+// engine/log.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir } from "os";
+import { randomUUID as randomUUID7 } from "crypto";
+function defaultLogDir() {
+  if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+    return join4(process.env.LOCALAPPDATA, "kindling", "logs");
+  }
+  return join4(homedir(), ".kindling", "logs");
+}
+function render(entry, timestamp) {
+  const lines = [
+    `Kindling failure report`,
+    `Generated: ${timestamp}`,
+    `Failed step: ${entry.step}`,
+    ``,
+    `Error:`,
+    entry.error,
+    ``,
+    `Event log:`,
+    ...entry.events.map((e) => `  [${e.status}] ${e.step} \u2014 ${e.humanMessage}`),
+    ``
+  ];
+  return lines.join("\n");
+}
+async function writeFailureLog(entry, opts = {}) {
+  const dir = opts.dir ?? defaultLogDir();
+  const timestamp = (opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
+  const safeStamp = timestamp.replace(/[:.]/g, "-");
+  const suffix = randomUUID7().slice(0, 8);
+  await mkdir2(dir, { recursive: true });
+  const path = join4(dir, `kindling-report-${safeStamp}-${suffix}.log`);
+  await writeFile2(path, render(entry, timestamp));
+  return path;
+}
+
+// engine/engine.ts
+import { randomUUID as randomUUID8 } from "crypto";
+var defaultDeps = {
+  detect: detectDependencies,
+  provisionGit: provisionGitUnix,
+  scaffold,
+  runBmadInstall,
+  installAgentCli,
+  runSelfCheck,
+  writeFailureLog: (entry) => writeFailureLog(entry),
+  platform: process.platform
+};
+var Engine = class {
+  constructor(config, emitter, deps = {}) {
+    this.emitter = emitter;
+    this.config = { ...config, projectDir: expandTilde(config.projectDir) };
+    this.deps = { ...defaultDeps, ...deps };
+    const gitStepId = this.deps.platform === "darwin" ? StepId.ProvisionXcodeClt : StepId.ProvisionGit;
+    this.steps = [
+      {
+        // Node was provisioned by the bootstrap (kindling is running on it). Verify it actually
+        // meets the floor before showing a green row — a sub-floor Node shows honestly (Failed)
+        // instead of a false Skipped that would only surface as a confusing self-check failure.
+        id: StepId.ProvisionNode,
+        run: async () => {
+          const state = await this.deps.detect({});
+          if (state.node.present && state.node.satisfiesFloor) {
+            this.emit(StepId.ProvisionNode, Status.Skipped, provisionMessages.nodePresent);
+            return true;
+          }
+          this.emit(StepId.ProvisionNode, Status.Failed, provisionMessages.nodeQueued, "error", ErrorCode.ExecFailed);
+          return false;
+        }
+      },
+      {
+        // Git/Xcode CLT runs IN the engine so the browser shows the never-frozen progress (the
+        // ~5-min macOS dialog). On Windows, Git is provisioned by the bootstrap (PortableGit) —
+        // probe + reflect it (Failed if the bootstrap didn't lay it down, rather than a cryptic
+        // scaffold crash later).
+        id: gitStepId,
+        run: async () => {
+          const state = await this.deps.detect({});
+          if (this.deps.platform === "win32") {
+            if (state.git.present) {
+              this.emit(gitStepId, Status.Skipped, provisionMessages.gitPresent);
+              return true;
+            }
+            this.emit(gitStepId, Status.Failed, provisionMessages.gitInstallFailed, "error", ErrorCode.ExecFailed);
+            return false;
+          }
+          const result = await this.deps.provisionGit({
+            platform: this.deps.platform,
+            emitter: this.emitter,
+            alreadyOk: state.git.present
+          });
+          return result.ok;
+        }
+      },
+      {
+        id: StepId.ScaffoldGitInit,
+        run: async () => {
+          const outcome = await this.deps.scaffold({
+            projectDir: this.config.projectDir,
+            projectName: this.config.projectName,
+            emitter: this.emitter
+          });
+          this.scaffoldCreated = outcome !== "blocked";
+          return outcome !== "blocked";
+        }
+      },
+      {
+        id: StepId.InstallBmad,
+        run: async () => {
+          const result = await this.deps.runBmadInstall({ config: this.config, emitter: this.emitter });
+          this.bmadInstalled = result.ok;
+          return result.ok;
+        }
+      },
+      {
+        // Optional agent-CLI install (Story 6.1). NON-fatal by design: it awaits the step but
+        // returns `true` UNCONDITIONALLY, so an individual CLI-install failure never invalidates
+        // the successful BMad install — the run still reaches self-check / Welcome. The failure is
+        // surfaced only as a Failed event (ErrorCode.AgentCliInstallFailed) for the error surface /
+        // Story 6.2 UI. The row is retryable via engine.retry(StepId.InstallAgentCli) — but note a
+        // future "Retry install" affordance must ALSO re-run self-check to refresh the Welcome's
+        // CLI-presence guidance (retry() skips the already-completed self-check). See deferred-work.md.
+        id: StepId.InstallAgentCli,
+        run: async () => {
+          await this.deps.installAgentCli({ config: this.config, emitter: this.emitter });
+          return true;
+        }
+      },
+      {
+        id: StepId.FinalizeSelfCheck,
+        run: async () => {
+          const summary = await this.deps.runSelfCheck({
+            scaffoldCreated: this.scaffoldCreated,
+            bmadInstalled: this.bmadInstalled,
+            // Where the BMad manifest lives — self-check reads the ACTUAL installed version (FR26).
+            projectDir: this.config.projectDir,
+            // Thread the requested eligible CLI descriptors (SSOT accessor over config.installCli)
+            // the same way scaffold/bmad outcomes are threaded — self-check probes each for presence.
+            agentClis: eligibleAgentClis(this.config.installCli),
+            emitter: this.emitter
+          });
+          this.lastSummary = summary;
+          return summary.success;
+        }
+      }
+    ];
+  }
+  emitter;
+  config;
+  deps;
+  completed = /* @__PURE__ */ new Set();
+  cancelled = false;
+  running = false;
+  // Outputs threaded between steps.
+  scaffoldCreated = false;
+  bmadInstalled = false;
+  lastSummary = null;
+  steps;
+  start(config) {
+    void config;
+    return this.runFrom(0);
+  }
+  // Re-runs from `step` forward, skipping other completed steps. The named step is always
+  // re-executed (cleared from `completed`). Returns a structured result for an unknown step
+  // rather than throwing, so callers handle one shape.
+  retry(step) {
+    const idx = this.steps.findIndex((s) => s.id === step);
+    if (idx < 0) {
+      return Promise.resolve({ ok: false, failedStep: step, summary: this.lastSummary, logPath: null });
+    }
+    this.cancelled = false;
+    this.completed.delete(step);
+    return this.runFrom(idx);
+  }
+  cancel() {
+    this.cancelled = true;
+  }
+  // Emit a provision-phase event the engine authors directly (the Node row; the Windows
+  // git-present row). Step orchestrators emit their own events.
+  emit(step, status, humanMessage, level = "info", errorCode) {
+    this.emitter.emit({
+      id: randomUUID8(),
+      phase: Phase.Provision,
+      step,
+      status,
+      humanMessage,
+      level,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      errorCode
+    });
+  }
+  async runFrom(startIdx) {
+    if (this.running) throw new Error("Engine is already running");
+    this.running = true;
+    try {
+      for (let i = startIdx; i < this.steps.length; i++) {
+        const step = this.steps[i];
+        if (this.completed.has(step.id)) continue;
+        if (this.cancelled) {
+          return { ok: false, failedStep: null, summary: this.lastSummary, logPath: null };
+        }
+        let ok;
+        try {
+          ok = await step.run();
+        } catch (err) {
+          const logPath = await this.fail(step.id, err);
+          return { ok: false, failedStep: step.id, summary: this.lastSummary, logPath };
+        }
+        if (this.cancelled) {
+          return { ok: false, failedStep: null, summary: this.lastSummary, logPath: null };
+        }
+        if (!ok) {
+          const logPath = await this.fail(step.id, new Error(`Step ${step.id} did not succeed`));
+          return { ok: false, failedStep: step.id, summary: this.lastSummary, logPath };
+        }
+        this.completed.add(step.id);
+      }
+      return { ok: true, failedStep: null, summary: this.lastSummary, logPath: null };
+    } finally {
+      this.running = false;
+    }
+  }
+  // Writes the failure report; a log-write error must not mask the underlying step failure,
+  // so it degrades to logPath: null rather than rejecting the run.
+  async fail(step, err) {
+    const error = err instanceof Error ? err.stack ?? err.message : err !== null && typeof err === "object" ? JSON.stringify(err) : String(err);
+    try {
+      return await this.deps.writeFailureLog({ step, error, events: this.emitter.events() });
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  EngineEmitter,
+  pins,
+  stepMessages,
+  provisionMessages,
+  errorMessages,
+  recoveryGuidance,
+  scaffold,
+  composeInstallArgs,
+  defaultBmadInstalled,
+  runBmadInstall,
+  AGENT_CLI_TABLE,
+  eligibleAgentClis,
+  installAgentCli,
+  readInstalledBmadVersion,
+  SCHEMA_VERSION,
+  NODE_FLOOR_MAJOR,
+  buildValidationSummary,
+  cliLoginGuidance,
+  cliMissing,
+  bmadVersionLabel,
+  parseMajor,
+  runSelfCheck,
+  detectDependencies,
+  provisionGitUnix,
+  defaultLogDir,
+  writeFailureLog,
+  Engine
+};
+//# sourceMappingURL=chunk-MW7UAGER.js.map