@holdpoint/cli 0.1.0-alpha.15 → 0.1.0-alpha.17

package/dist/index.js

@@ -4,20 +4,23 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, copyFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import chalk from "chalk";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk2 from "chalk";
 import ora from "ora";
 import { buildConfigJson, buildEngine } from "@holdpoint/engine-copilot";
 import { buildEngineJson as buildClaudeEngineJson } from "@holdpoint/engine-claude";
-import { buildEngine as buildCursorEngine } from "@holdpoint/engine-cursor";
+import {
+  buildCheckScript as buildCursorCheckScript,
+  buildEngine as buildCursorEngine,
+  buildHooksJson as buildCursorHooksJson
+} from "@holdpoint/engine-cursor";
 import {
   buildConfigToml as buildCodexConfigToml,
   buildHooksJson as buildCodexHooksJson,
-  buildCheckScript as buildCodexCheckScript,
-  spliceAgentsMd
+  buildCheckScript as buildCodexCheckScript
 } from "@holdpoint/engine-codex";
 import { parseHoldpointYaml } from "@holdpoint/yaml-core";
 
@@ -32,9 +35,17 @@ function detectInstalledAgents() {
   const agents = [];
   if (existsSync(".github/extensions/holdpoint/extension.mjs")) agents.push("copilot");
   if (existsSync(".claude/settings.json")) agents.push("claude");
+  if (existsSync(".cursor/hooks.json")) {
+    try {
+      if (readFileSync(".cursor/hooks.json", "utf8").includes("HOLDPOINT_MANAGED=cursor")) {
+        agents.push("cursor");
+      }
+    } catch {
+    }
+  }
   if (existsSync(".cursorrules")) {
     try {
-      if (readFileSync(".cursorrules", "utf8").includes("Holdpoint Rules")) {
+      if (!agents.includes("cursor") && readFileSync(".cursorrules", "utf8").includes("Holdpoint Rules")) {
         agents.push("cursor");
       }
     } catch {
@@ -43,49 +54,272 @@ function detectInstalledAgents() {
   if (existsSync(".codex/holdpoint-check.mjs")) agents.push("codex");
   return agents;
 }
-function detectStack() {
-  const hasNext = existsSync("next.config.ts") || existsSync("next.config.js") || existsSync("next.config.mjs");
-  const hasTsConfig = existsSync("tsconfig.json");
-  const hasPyproject = existsSync("pyproject.toml") || existsSync("requirements.txt") || existsSync("setup.py");
-  const hasPrisma = existsSync("prisma/schema.prisma");
-  const hasApi = existsSync("server") || existsSync("api") || existsSync("backend");
-  const hasGoMod = existsSync("go.mod");
-  if (hasNext && (hasPrisma || hasApi)) return "fullstack";
-  if (hasNext) return "nextjs";
-  if (hasTsConfig) return "typescript";
-  if (hasPyproject) return "python";
-  if (hasGoMod) return "go";
-  return "unknown";
-}
 
-// src/commands/init.ts
+// src/templates.ts
+import { copyFileSync, existsSync as existsSync2, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
-function getTemplatePath(stack) {
-  const name = stack === "unknown" ? "_base" : stack;
+function getBundledTemplatePath(filename) {
   const candidates = [
-    join(__dirname, "templates", `${name}.yaml`),
+    join(__dirname, "templates", filename),
     // dist/templates/ (published package)
-    join(__dirname, "../../../templates", `${name}.yaml`),
+    join(__dirname, "../../../templates", filename),
     // monorepo dev fallback
-    join(process.cwd(), "templates", `${name}.yaml`)
+    join(process.cwd(), "templates", filename)
     // cwd fallback
   ];
-  for (const p of candidates) {
-    if (existsSync2(p)) return p;
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
   }
   return "";
 }
-function getMasterPromptPath() {
+function ensureBundledFile(outputPath, templateFilename, fallbackContent) {
+  if (existsSync2(outputPath)) {
+    return false;
+  }
+  const templatePath = getBundledTemplatePath(templateFilename);
+  if (templatePath) {
+    copyFileSync(templatePath, outputPath);
+  } else {
+    writeFileSync(outputPath, fallbackContent, "utf8");
+  }
+  return true;
+}
+
+// src/lib/preflight.ts
+import { execSync } from "child_process";
+import chalk from "chalk";
+function silentExec(cmd) {
+  try {
+    const stdout = execSync(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString();
+    return { ok: true, stdout };
+  } catch {
+    return { ok: false, stdout: "" };
+  }
+}
+function checkCopilot() {
+  const gh = silentExec("gh --version");
+  if (!gh.ok) {
+    return {
+      agent: "copilot",
+      status: "action_required",
+      message: "GitHub CLI not found on PATH",
+      command: "brew install gh    # or: https://cli.github.com/"
+    };
+  }
+  const copilot = silentExec("gh copilot --version");
+  if (!copilot.ok) {
+    return {
+      agent: "copilot",
+      status: "action_required",
+      message: "Copilot CLI extension not installed",
+      command: "gh extension install github/gh-copilot"
+    };
+  }
+  return {
+    agent: "copilot",
+    status: "action_required",
+    message: "Copilot CLI detected \u2014 experimental mode required for EXTENSIONS",
+    command: "Inside Copilot CLI, run: /experimental on"
+  };
+}
+function checkClaude() {
+  const claude = silentExec("claude --version");
+  if (!claude.ok) {
+    return {
+      agent: "claude",
+      status: "unknown",
+      message: "Claude Code binary not on PATH (hooks still written for when it is)"
+    };
+  }
+  return {
+    agent: "claude",
+    status: "ok",
+    message: "Claude Code detected \u2014 hooks installed at .claude/settings.json"
+  };
+}
+function checkCursor() {
+  return {
+    agent: "cursor",
+    status: "ok",
+    message: "Cursor \u2014 .cursor/hooks.json gate + .cursor/rules breadcrumb installed",
+    docs: "https://holdpoint.dev/docs#cursor"
+  };
+}
+function checkCodex() {
+  const codex = silentExec("codex --version");
+  if (!codex.ok) {
+    return {
+      agent: "codex",
+      status: "action_required",
+      message: "Codex CLI not found on PATH",
+      command: "Install Codex: https://github.com/openai/codex"
+    };
+  }
+  return {
+    agent: "codex",
+    status: "action_required",
+    message: "Codex detected \u2014 project-level hooks require trust approval",
+    command: "In the Codex TUI: codex trust    (or /hooks to review)"
+  };
+}
+var CHECKS = {
+  copilot: checkCopilot,
+  claude: checkClaude,
+  cursor: checkCursor,
+  codex: checkCodex
+};
+function runPreflight(agents) {
+  return agents.flatMap((agent) => {
+    const check = CHECKS[agent];
+    return check ? [check()] : [];
+  });
+}
+function printPreflight(results) {
+  if (results.length === 0) return;
+  const ok = results.filter((r) => r.status === "ok");
+  const unknown = results.filter((r) => r.status === "unknown");
+  const action = results.filter((r) => r.status === "action_required");
+  console.log("");
+  console.log(chalk.bold("Agent preflight:"));
+  for (const r of ok) {
+    console.log(`  ${chalk.green("\u2713")} ${r.agent.padEnd(7)} ${chalk.dim(r.message)}`);
+  }
+  for (const r of unknown) {
+    console.log(`  ${chalk.dim("?")} ${r.agent.padEnd(7)} ${chalk.dim(r.message)}`);
+  }
+  for (const r of action) {
+    console.log(`  ${chalk.yellow("\u2192")} ${chalk.bold(r.agent.padEnd(7))} ${r.message}`);
+    if (r.command) console.log(`      ${chalk.cyan(r.command)}`);
+  }
+}
+
+// src/claude-settings.ts
+var HOLDPOINT_CLAUDE_HOOK_MARKER = "HOLDPOINT_MANAGED=claude";
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function asHookArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isManagedHookCommand(value) {
+  return isObject(value) && typeof value.command === "string" && value.command.includes(HOLDPOINT_CLAUDE_HOOK_MARKER);
+}
+function isLegacyManagedHookCommand(value) {
+  if (!isObject(value) || typeof value.command !== "string") return false;
+  return value.command === "node_modules/.bin/holdpoint event --engine claude --from-hook || true" || value.command === "node_modules/.bin/holdpoint check --staged";
+}
+function isManagedHookEntry(value) {
+  if (!isObject(value)) return false;
+  const hooks = asHookArray(value.hooks);
+  return hooks.length > 0 && (hooks.every(isManagedHookCommand) || hooks.every(isLegacyManagedHookCommand));
+}
+function mergeClaudeSettings(existing, generated) {
+  const existingHooks = isObject(existing.hooks) ? existing.hooks : {};
+  const generatedHooks = isObject(generated.hooks) ? generated.hooks : {};
+  const mergedHooks = {};
+  for (const eventName of /* @__PURE__ */ new Set([
+    ...Object.keys(existingHooks),
+    ...Object.keys(generatedHooks)
+  ])) {
+    const preserved = asHookArray(existingHooks[eventName]).filter(
+      (entry) => !isManagedHookEntry(entry)
+    );
+    const next = asHookArray(generatedHooks[eventName]);
+    if (preserved.length > 0 || next.length > 0) {
+      mergedHooks[eventName] = [...preserved, ...next];
+    }
+  }
+  return { ...existing, ...generated, hooks: mergedHooks };
+}
+
+// src/cursor-hooks.ts
+var HOLDPOINT_CURSOR_HOOK_MARKER = "HOLDPOINT_MANAGED=cursor";
+function isObject2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function asHookArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isManagedCursorHook(value) {
+  return isObject2(value) && typeof value.command === "string" && (value.command.includes(HOLDPOINT_CURSOR_HOOK_MARKER) || value.command.includes(".cursor/holdpoint-hook.mjs"));
+}
+function mergeCursorHooks(existing, generated) {
+  const existingHooks = isObject2(existing.hooks) ? existing.hooks : {};
+  const generatedHooks = isObject2(generated.hooks) ? generated.hooks : {};
+  const mergedHooks = {};
+  for (const eventName of /* @__PURE__ */ new Set([
+    ...Object.keys(existingHooks),
+    ...Object.keys(generatedHooks)
+  ])) {
+    const preserved = asHookArray2(existingHooks[eventName]).filter(
+      (entry) => !isManagedCursorHook(entry)
+    );
+    const next = asHookArray2(generatedHooks[eventName]);
+    if (preserved.length > 0 || next.length > 0) {
+      mergedHooks[eventName] = [...preserved, ...next];
+    }
+  }
+  return { ...existing, ...generated, hooks: mergedHooks };
+}
+
+// src/lib/instructions-breadcrumb.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+var START_MARKER = "<!-- HOLDPOINT_MANAGED \u2014 content between these markers is auto-generated by holdpoint init / holdpoint update -->";
+var END_MARKER = "<!-- /HOLDPOINT_MANAGED -->";
+var BREADCRUMB_BODY = `## Holdpoint workflow
+
+This repo uses [Holdpoint](https://holdpoint.dev) to gate task completion on deterministic checks.
+
+Before marking any task done:
+
+1. Run \`holdpoint check\` (or it will run automatically via Stop / TaskCompleted hooks).
+2. Fix any failures. Re-run until exit 0.
+3. Never bypass with \`--no-verify\` or by skipping the agent's stop hook.
+
+Full workflow reference: [\`MASTER_PROMPT.md\`](./MASTER_PROMPT.md) (always injected at session start).
+Deep reference: [\`HOLDPOINT_REFERENCE.md\`](./HOLDPOINT_REFERENCE.md) (read on demand).
+Active checks: [\`checks.yaml\`](./checks.yaml).`;
+function spliceBreadcrumb(filePath, body = BREADCRUMB_BODY, createIfMissing = true) {
+  const block = `${START_MARKER}
+
+${body}
+
+${END_MARKER}`;
+  if (!existsSync3(filePath)) {
+    if (!createIfMissing) return;
+    mkdirSync(dirname2(filePath), { recursive: true });
+    writeFileSync2(filePath, block + "\n", "utf8");
+    return;
+  }
+  const existing = readFileSync2(filePath, "utf8");
+  const startIdx = existing.indexOf(START_MARKER);
+  const endIdx = existing.indexOf(END_MARKER);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + END_MARKER.length);
+    writeFileSync2(filePath, before + block + after, "utf8");
+    return;
+  }
+  const sep2 = existing.endsWith("\n") ? "\n" : "\n\n";
+  writeFileSync2(filePath, existing + sep2 + block + "\n", "utf8");
+}
+
+// src/commands/init.ts
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+function getDefaultTemplatePath() {
   const candidates = [
-    join(__dirname, "templates/MASTER_PROMPT.md"),
+    join2(__dirname2, "templates", "default.yaml"),
     // dist/templates/ (published package)
-    join(__dirname, "../../../templates/MASTER_PROMPT.md"),
+    join2(__dirname2, "../../../templates", "default.yaml"),
     // monorepo dev fallback
-    join(process.cwd(), "templates/MASTER_PROMPT.md")
+    join2(process.cwd(), "templates", "default.yaml")
     // cwd fallback
   ];
   for (const p of candidates) {
-    if (existsSync2(p)) return p;
+    if (existsSync4(p)) return p;
   }
   return "";
 }
@@ -102,85 +336,122 @@ checks:
     label: "JSDoc on changed public functions"
     prompt: "Ensure all changed public functions and exports have JSDoc comments."
 `;
+var MINIMAL_MASTER_PROMPT = `# Holdpoint
+
+Run \`holdpoint check\` before marking any task complete.
+See \`checks.yaml\` for the full list of checks.
+`;
+var MINIMAL_HOLDPOINT_REFERENCE = `# Holdpoint reference
+
+Read \`MASTER_PROMPT.md\` first for the mandatory workflow, then use this file for deeper project-specific Holdpoint notes.
+`;
+var MINIMAL_PREREQUISITES = `# Holdpoint prerequisites
+
+Holdpoint installed repo-local engine integrations for one or more AI coding agents. Before relying on them locally, review these setup notes:
+
+- **GitHub Copilot CLI** \u2014 Holdpoint's \`.github/extensions/holdpoint/extension.mjs\` uses the Copilot CLI **EXTENSIONS** feature. Today that feature is gated behind experimental mode. In Copilot CLI, run \`/experimental on\` so **EXTENSIONS** appears in the enabled feature set before using Holdpoint locally.
+- **Cursor** \u2014 project-level hooks run in trusted workspaces. After opening the repo in Cursor, confirm the workspace is trusted and review Settings \u2192 Hooks if hooks do not fire.
+- **OpenAI Codex** \u2014 project-level hooks require trust approval. Run \`codex trust\` in the Codex TUI or review the hook with \`/hooks\`.
+- **General** \u2014 Holdpoint expects Node.js 18+ and a git repository so \`holdpoint init\`, \`holdpoint update\`, and \`holdpoint check\` can run normally.
+
+Docs: https://holdpoint.dev/docs
+`;
 async function initCommand(options) {
   const spinner = ora("Initialising Holdpoint\u2026").start();
-  const stack = options.stack ?? detectStack();
   const agentOpt = options.agent;
   const agents = !agentOpt || agentOpt === "all" ? ["copilot", "claude", "cursor", "codex"] : [agentOpt];
-  spinner.text = `Stack: ${chalk.cyan(stack)} \u2014 installing for: ${chalk.cyan(agents.join(", "))}`;
+  spinner.text = `Installing for: ${chalk2.cyan(agents.join(", "))}`;
   const pm = detectPackageManager();
   let yamlContent = MINIMAL_CHECKS_YAML;
-  if (!existsSync2("checks.yaml")) {
-    const templatePath = getTemplatePath(stack);
+  if (!existsSync4("checks.yaml")) {
+    const templatePath = getDefaultTemplatePath();
     if (templatePath) {
-      yamlContent = readFileSync2(templatePath, "utf8");
+      yamlContent = readFileSync3(templatePath, "utf8");
     }
     if (pm !== "pnpm") {
       yamlContent = yamlContent.replace(/\bpnpm\b/g, pm);
     }
-    writeFileSync("checks.yaml", yamlContent, "utf8");
+    writeFileSync3("checks.yaml", yamlContent, "utf8");
   } else {
-    yamlContent = readFileSync2("checks.yaml", "utf8");
+    yamlContent = readFileSync3("checks.yaml", "utf8");
   }
   const config = parseHoldpointYaml(yamlContent);
   const generatedDir = ".github/holdpoint/generated";
-  mkdirSync(generatedDir, { recursive: true });
-  writeFileSync(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
+  mkdirSync2(generatedDir, { recursive: true });
+  writeFileSync3(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
   if (agents.includes("copilot")) {
     const extDir = ".github/extensions/holdpoint";
-    mkdirSync(extDir, { recursive: true });
-    writeFileSync(join(extDir, "extension.mjs"), buildEngine(config), "utf8");
+    mkdirSync2(extDir, { recursive: true });
+    writeFileSync3(join2(extDir, "extension.mjs"), buildEngine(config), "utf8");
+    spliceBreadcrumb(".github/copilot-instructions.md");
   }
   if (agents.includes("claude")) {
-    mkdirSync(".claude", { recursive: true });
+    mkdirSync2(".claude", { recursive: true });
     const settingsPath = ".claude/settings.json";
     let existing = {};
-    if (existsSync2(settingsPath)) {
+    if (existsSync4(settingsPath)) {
       try {
-        existing = JSON.parse(readFileSync2(settingsPath, "utf8"));
+        existing = JSON.parse(readFileSync3(settingsPath, "utf8"));
       } catch {
       }
     }
     const holdpointHooks = JSON.parse(buildClaudeEngineJson(config));
-    writeFileSync(
+    writeFileSync3(
       settingsPath,
-      JSON.stringify({ ...existing, hooks: holdpointHooks.hooks }, null, 2),
+      JSON.stringify(mergeClaudeSettings(existing, holdpointHooks), null, 2),
       "utf8"
     );
+    spliceBreadcrumb("CLAUDE.md");
   }
   if (agents.includes("cursor")) {
+    mkdirSync2(".cursor", { recursive: true });
+    const cursorHooksPath = ".cursor/hooks.json";
+    let existingHooks = {};
+    if (existsSync4(cursorHooksPath)) {
+      try {
+        existingHooks = JSON.parse(readFileSync3(cursorHooksPath, "utf8"));
+      } catch {
+      }
+    }
+    const cursorHooks = JSON.parse(buildCursorHooksJson(config));
+    writeFileSync3(
+      cursorHooksPath,
+      JSON.stringify(mergeCursorHooks(existingHooks, cursorHooks), null, 2) + "\n",
+      "utf8"
+    );
+    writeFileSync3(".cursor/holdpoint-hook.mjs", buildCursorCheckScript(), "utf8");
     const cursorRules = buildCursorEngine(config);
     const cursorPath = ".cursorrules";
-    if (existsSync2(cursorPath)) {
-      const existing = readFileSync2(cursorPath, "utf8");
+    if (existsSync4(cursorPath)) {
+      const existing = readFileSync3(cursorPath, "utf8");
       if (!existing.includes("Holdpoint Rules")) {
-        writeFileSync(cursorPath, existing + "\n" + cursorRules, "utf8");
+        writeFileSync3(cursorPath, `${existing.trimEnd()}
+
+${cursorRules}`, "utf8");
       }
     } else {
-      writeFileSync(cursorPath, cursorRules, "utf8");
+      writeFileSync3(cursorPath, cursorRules, "utf8");
     }
+    spliceBreadcrumb(".cursor/rules/holdpoint.md");
   }
   if (agents.includes("codex")) {
-    mkdirSync(".codex", { recursive: true });
-    writeFileSync(".codex/hooks.json", buildCodexHooksJson(config), "utf8");
-    writeFileSync(".codex/holdpoint-check.mjs", buildCodexCheckScript(config), "utf8");
-    writeFileSync(".codex/config.toml", buildCodexConfigToml(), "utf8");
-    const agentsMdPath = "AGENTS.md";
-    const existing = existsSync2(agentsMdPath) ? readFileSync2(agentsMdPath, "utf8") : "";
-    writeFileSync(agentsMdPath, spliceAgentsMd(existing, config), "utf8");
-  }
-  if (!existsSync2("MASTER_PROMPT.md")) {
-    const guidePath = getMasterPromptPath();
-    if (guidePath) {
-      copyFileSync(guidePath, "MASTER_PROMPT.md");
-    } else {
-      writeFileSync(
-        "MASTER_PROMPT.md",
-        "# Holdpoint\n\nRun `holdpoint check` before marking any task complete.\nSee `checks.yaml` for the full list of checks.\n",
-        "utf8"
-      );
-    }
+    mkdirSync2(".codex", { recursive: true });
+    writeFileSync3(".codex/hooks.json", buildCodexHooksJson(config), "utf8");
+    writeFileSync3(".codex/holdpoint-check.mjs", buildCodexCheckScript(config), "utf8");
+    writeFileSync3(".codex/config.toml", buildCodexConfigToml(), "utf8");
+    spliceBreadcrumb("AGENTS.md");
   }
+  ensureBundledFile("MASTER_PROMPT.md", "MASTER_PROMPT.md", MINIMAL_MASTER_PROMPT);
+  ensureBundledFile(
+    "HOLDPOINT_REFERENCE.md",
+    "HOLDPOINT_REFERENCE.md",
+    MINIMAL_HOLDPOINT_REFERENCE
+  );
+  ensureBundledFile(
+    "HOLDPOINT_PREREQUISITES.md",
+    "HOLDPOINT_PREREQUISITES.md",
+    MINIMAL_PREREQUISITES
+  );
   spinner.text = "Installing holdpoint as a devDependency\u2026";
   const installCmds = {
     pnpm: "pnpm add -D holdpoint@alpha",
@@ -189,40 +460,46 @@ async function initCommand(options) {
   };
   const installCmd = installCmds[pm];
   try {
-    execSync(installCmd, { stdio: "pipe" });
-    spinner.succeed(chalk.bold.green("Holdpoint initialised!"));
+    execSync2(installCmd, { stdio: "pipe" });
+    spinner.succeed(chalk2.bold.green("Holdpoint initialised!"));
   } catch {
     spinner.warn(
-      chalk.yellow(`Holdpoint initialised, but could not install the package automatically.`) + `
-  Run manually: ${chalk.yellow(installCmd)}`
+      chalk2.yellow(`Holdpoint initialised, but could not install the package automatically.`) + `
+  Run manually: ${chalk2.yellow(installCmd)}`
     );
   }
+  const preflight = runPreflight(agents);
+  printPreflight(preflight);
   console.log(`
-${chalk.cyan("Next steps:")}
-  1. Edit ${chalk.yellow("checks.yaml")} to customise your eval checkpoints
-  2. Commit ${chalk.yellow("checks.yaml")} and the generated engine files
-  3. Run ${chalk.yellow("holdpoint check")} at any time to validate
+${chalk2.cyan("Next steps:")}
+  1. Edit ${chalk2.yellow("checks.yaml")} to customise your eval checkpoints
+  2. Address any ${chalk2.yellow("\u2192")} items above (full notes in ${chalk2.yellow("HOLDPOINT_PREREQUISITES.md")})
+  3. Commit ${chalk2.yellow("checks.yaml")}, ${chalk2.yellow("HOLDPOINT_PREREQUISITES.md")}, and the generated engine files
+  4. Run ${chalk2.yellow("holdpoint check")} at any time to validate
 
-  Visual builder: ${chalk.yellow("holdpoint builder")}  (opens localhost:4321)
-  Stack: ${chalk.cyan(stack)}  Agents: ${chalk.cyan(agents.join(", "))}
+  Visual builder: ${chalk2.yellow("holdpoint builder")}  (opens the daemon at /builder)
+  Agents: ${chalk2.cyan(agents.join(", "))}
 `);
 }
 
 // src/commands/check.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
-import chalk2 from "chalk";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+import chalk3 from "chalk";
 import ora2 from "ora";
 import { parseHoldpointYaml as parseHoldpointYaml2, matchesWhen } from "@holdpoint/yaml-core";
 import { runDeterministicChecks } from "@holdpoint/yaml-core/runner";
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
+import { randomUUID } from "crypto";
+import { identifyProject } from "@holdpoint/live-daemon";
+import { BridgeClient } from "@holdpoint/sdk";
 var COMMIT_CACHE_PATH = ".holdpoint/checked-commits.json";
 var COMMIT_CACHE_MAX = 100;
 var CHECK_REPORTS_PATH = ".holdpoint/check-reports.json";
 var CHECK_REPORTS_MAX = 50;
 function getStagedFiles() {
   try {
-    const out = execSync2("git diff --cached --name-only", {
+    const out = execSync3("git diff --cached --name-only", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -233,7 +510,7 @@ function getStagedFiles() {
 }
 function getAllChangedFiles() {
   try {
-    const out = execSync2("git diff --name-only HEAD", {
+    const out = execSync3("git diff --name-only HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -244,7 +521,7 @@ function getAllChangedFiles() {
 }
 function getLastCommitFiles() {
   try {
-    const out = execSync2("git diff --name-only HEAD~1 HEAD", {
+    const out = execSync3("git diff --name-only HEAD~1 HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -255,7 +532,7 @@ function getLastCommitFiles() {
 }
 function getHeadSha() {
   try {
-    return execSync2("git rev-parse HEAD", {
+    return execSync3("git rev-parse HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -265,7 +542,7 @@ function getHeadSha() {
 }
 function readCommitCache() {
   try {
-    const raw = readFileSync3(COMMIT_CACHE_PATH, "utf8");
+    const raw = readFileSync4(COMMIT_CACHE_PATH, "utf8");
     const parsed = JSON.parse(raw);
     return new Set(Array.isArray(parsed.verified) ? parsed.verified : []);
   } catch {
@@ -276,18 +553,18 @@ function recordCommitCache(sha) {
   try {
     const existing = readCommitCache();
     const updated = [sha, ...[...existing].filter((s) => s !== sha)].slice(0, COMMIT_CACHE_MAX);
-    mkdirSync2(join2(COMMIT_CACHE_PATH, ".."), { recursive: true });
-    writeFileSync2(COMMIT_CACHE_PATH, JSON.stringify({ verified: updated }, null, 2) + "\n", "utf8");
+    mkdirSync3(join3(COMMIT_CACHE_PATH, ".."), { recursive: true });
+    writeFileSync4(COMMIT_CACHE_PATH, JSON.stringify({ verified: updated }, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 function recordCheckReport(run) {
   try {
-    mkdirSync2(join2(CHECK_REPORTS_PATH, ".."), { recursive: true });
+    mkdirSync3(join3(CHECK_REPORTS_PATH, ".."), { recursive: true });
     let existing = { runs: [] };
-    if (existsSync3(CHECK_REPORTS_PATH)) {
+    if (existsSync5(CHECK_REPORTS_PATH)) {
       try {
-        existing = JSON.parse(readFileSync3(CHECK_REPORTS_PATH, "utf8"));
+        existing = JSON.parse(readFileSync4(CHECK_REPORTS_PATH, "utf8"));
         if (!Array.isArray(existing.runs)) existing.runs = [];
       } catch {
         existing = { runs: [] };
@@ -296,21 +573,21 @@ function recordCheckReport(run) {
     const updated = {
       runs: [run, ...existing.runs].slice(0, CHECK_REPORTS_MAX)
     };
-    writeFileSync2(CHECK_REPORTS_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    writeFileSync4(CHECK_REPORTS_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 async function checkCommand(options) {
-  if (!existsSync3("checks.yaml")) {
-    console.error(chalk2.red("No checks.yaml found. Run `holdpoint init` first."));
+  if (!existsSync5("checks.yaml")) {
+    console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
-  const yamlContent = readFileSync3("checks.yaml", "utf8");
+  const yamlContent = readFileSync4("checks.yaml", "utf8");
   let config;
   try {
     config = parseHoldpointYaml2(yamlContent);
   } catch (err) {
-    console.error(chalk2.red("Invalid checks.yaml:"), err.message);
+    console.error(chalk3.red("Invalid checks.yaml:"), err.message);
     process.exit(1);
   }
   const headSha = getHeadSha();
@@ -323,7 +600,7 @@ async function checkCommand(options) {
     } else {
       if (headSha && readCommitCache().has(headSha)) {
         console.log(
-          chalk2.green(`\u2713 Commit ${headSha.slice(0, 8)} already verified \u2014 nothing to re-check.`)
+          chalk3.green(`\u2713 Commit ${headSha.slice(0, 8)} already verified \u2014 nothing to re-check.`)
         );
         process.exit(0);
       }
@@ -332,10 +609,10 @@ async function checkCommand(options) {
         changedFiles = lastCommit;
         usedHeadShaForCache = true;
         console.log(
-          chalk2.yellow("No staged files. Running checks scoped to the most recent commit's files.")
+          chalk3.yellow("No staged files. Running checks scoped to the most recent commit's files.")
         );
       } else {
-        console.log(chalk2.green("\u2713 No staged changes and no recent commit \u2014 nothing to check."));
+        console.log(chalk3.green("\u2713 No staged changes and no recent commit \u2014 nothing to check."));
         process.exit(0);
       }
     }
@@ -343,10 +620,10 @@ async function checkCommand(options) {
     changedFiles = getAllChangedFiles();
     if (changedFiles.length === 0) {
       console.log(
-        chalk2.yellow("No changed files detected. Running all checks with no file filter.")
+        chalk3.yellow("No changed files detected. Running all checks with no file filter.")
       );
       console.log(
-        chalk2.dim(
+        chalk3.dim(
           "  Tip: if you just ran `holdpoint init`, commit the generated files to clear the git-commit check."
         )
       );
@@ -354,9 +631,9 @@ async function checkCommand(options) {
   }
   const guides = Object.entries(config.context?.guides ?? {});
   if (guides.length > 0) {
-    console.log(chalk2.cyan("\nProject guides:"));
+    console.log(chalk3.cyan("\nProject guides:"));
     for (const [key, text] of guides) {
-      console.log(chalk2.bold(`  ${key}:`), chalk2.dim(String(text).trim()));
+      console.log(chalk3.bold(`  ${key}:`), chalk3.dim(String(text).trim()));
     }
     console.log("");
   }
@@ -374,9 +651,9 @@ async function checkCommand(options) {
   console.log("");
   console.log(
     [
-      chalk2.green(`\u2713 ${passed.length} passed`),
-      failed.length > 0 ? chalk2.red(`\u2717 ${failed.length} failed`) : "",
-      skipped.length > 0 ? chalk2.gray(`\u25CC ${skipped.length} skipped`) : ""
+      chalk3.green(`\u2713 ${passed.length} passed`),
+      failed.length > 0 ? chalk3.red(`\u2717 ${failed.length} failed`) : "",
+      skipped.length > 0 ? chalk3.gray(`\u25CC ${skipped.length} skipped`) : ""
     ].filter(Boolean).join("  ")
   );
   const promptChecks = config.checks.filter(
@@ -384,9 +661,9 @@ async function checkCommand(options) {
   );
   if (promptChecks.length > 0) {
     console.log(`
-${chalk2.cyan("Agent prompts to act on:")}`);
+${chalk3.cyan("Agent prompts to act on:")}`);
     for (const c of promptChecks) {
-      console.log(`  ${chalk2.yellow("\u25A1")} [${c.label}] ${c.prompt ?? ""}`);
+      console.log(`  ${chalk3.yellow("\u25A1")} [${c.label}] ${c.prompt ?? ""}`);
     }
   }
   const reportResults = [
@@ -420,6 +697,30 @@ ${chalk2.cyan("Agent prompts to act on:")}`);
     }
   };
   recordCheckReport(run);
+  const project = identifyProject(process.cwd());
+  const bridge = new BridgeClient();
+  const liveEvents = reportResults.filter(
+    (result) => result.kind === "cmd"
+  ).map((result, index) => ({
+    v: 1,
+    id: randomUUID(),
+    ts: Date.now() + index,
+    engine: "holdpoint",
+    session_id: "check-runner",
+    project_hash: project.hash,
+    cwd: process.cwd(),
+    type: "check_run",
+    payload: {
+      check_id: result.id,
+      label: result.label,
+      status: result.status,
+      duration_ms: 0,
+      ...result.output ? { output: result.output } : {}
+    }
+  }));
+  if (liveEvents.length > 0) {
+    await bridge.sendEvents(liveEvents);
+  }
   if (failed.length > 0) {
     process.exit(1);
   }
@@ -428,258 +729,337 @@ ${chalk2.cyan("Agent prompts to act on:")}`);
   }
 }
 function printResult(result) {
-  const icon = result.status === "pass" ? chalk2.green("\u2713") : result.status === "fail" ? chalk2.red("\u2717") : result.status === "skip" ? chalk2.gray("\u25CC") : chalk2.yellow("\u2026");
+  const icon = result.status === "pass" ? chalk3.green("\u2713") : result.status === "fail" ? chalk3.red("\u2717") : result.status === "skip" ? chalk3.gray("\u25CC") : chalk3.yellow("\u2026");
   const label = result.check.label;
   console.log(`${icon} ${label}`);
   if (result.status === "fail" && result.output) {
     const trimmed = result.output.trim().split("\n").slice(0, 10).join("\n");
-    console.log(chalk2.dim(trimmed.replace(/^/gm, "    ")));
+    console.log(chalk3.dim(trimmed.replace(/^/gm, "    ")));
   }
   if (result.status === "skip" && result.skipReason) {
-    console.log(chalk2.dim(`    ${result.skipReason}`));
+    console.log(chalk3.dim(`    ${result.skipReason}`));
   }
 }
 
 // src/commands/validate.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import chalk3 from "chalk";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import chalk4 from "chalk";
 import { parseHoldpointYaml as parseHoldpointYaml3, validateConfig } from "@holdpoint/yaml-core";
 async function validateCommand() {
-  if (!existsSync4("checks.yaml")) {
-    console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
+  if (!existsSync6("checks.yaml")) {
+    console.error(chalk4.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
-  const text = readFileSync4("checks.yaml", "utf8");
+  const text = readFileSync5("checks.yaml", "utf8");
   let config;
   try {
     config = parseHoldpointYaml3(text);
   } catch (err) {
-    console.error(chalk3.red("Parse error:"), err.message);
+    console.error(chalk4.red("Parse error:"), err.message);
     process.exit(1);
   }
   const result = validateConfig(config);
   if (result.valid) {
-    console.log(chalk3.green("\u2713 checks.yaml is valid"));
+    console.log(chalk4.green("\u2713 checks.yaml is valid"));
     console.log(
-      chalk3.dim(
+      chalk4.dim(
         `  ${config.checks.filter((c) => c.cmd !== void 0).length} tasks, ${config.checks.filter((c) => c.prompt !== void 0).length} prompts, ${config.conditions.length} conditions`
       )
     );
   } else {
-    console.error(chalk3.red("\u2717 checks.yaml has errors:"));
+    console.error(chalk4.red("\u2717 checks.yaml has errors:"));
     for (const err of result.errors) {
-      console.error(`  ${chalk3.yellow(err.path)}: ${err.message}`);
+      console.error(`  ${chalk4.yellow(err.path)}: ${err.message}`);
     }
     process.exit(1);
   }
 }
 
 // src/commands/update.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import chalk4 from "chalk";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
+import chalk5 from "chalk";
 import ora3 from "ora";
 import { parseHoldpointYaml as parseHoldpointYaml4 } from "@holdpoint/yaml-core";
 import { buildConfigJson as buildConfigJson2, buildEngine as buildEngine2 } from "@holdpoint/engine-copilot";
 import { buildEngineJson as buildClaudeEngineJson2 } from "@holdpoint/engine-claude";
-import { buildEngine as buildCursorEngine2 } from "@holdpoint/engine-cursor";
+import {
+  buildCheckScript as buildCursorCheckScript2,
+  buildEngine as buildCursorEngine2,
+  buildHooksJson as buildCursorHooksJson2
+} from "@holdpoint/engine-cursor";
 import {
   buildConfigToml as buildCodexConfigToml2,
   buildHooksJson as buildCodexHooksJson2,
-  buildCheckScript as buildCodexCheckScript2,
-  spliceAgentsMd as spliceAgentsMd2
+  buildCheckScript as buildCodexCheckScript2
 } from "@holdpoint/engine-codex";
+var MINIMAL_PREREQUISITES2 = `# Holdpoint prerequisites
+
+Holdpoint installed repo-local engine integrations for one or more AI coding agents. Before relying on them locally, review these setup notes:
+
+- **GitHub Copilot CLI** \u2014 Holdpoint's \`.github/extensions/holdpoint/extension.mjs\` uses the Copilot CLI **EXTENSIONS** feature. Today that feature is gated behind experimental mode. In Copilot CLI, run \`/experimental on\` so **EXTENSIONS** appears in the enabled feature set before using Holdpoint locally.
+- **Cursor** \u2014 project-level hooks run in trusted workspaces. After opening the repo in Cursor, confirm the workspace is trusted and review Settings \u2192 Hooks if hooks do not fire.
+- **OpenAI Codex** \u2014 project-level hooks require trust approval. Run \`codex trust\` in the Codex TUI or review the hook with \`/hooks\`.
+- **General** \u2014 Holdpoint expects Node.js 18+ and a git repository so \`holdpoint init\`, \`holdpoint update\`, and \`holdpoint check\` can run normally.
+
+Docs: https://holdpoint.dev/docs
+`;
+var MINIMAL_HOLDPOINT_REFERENCE2 = `# Holdpoint reference
+
+Read \`MASTER_PROMPT.md\` first for the mandatory workflow, then use this file for deeper project-specific Holdpoint notes.
+`;
 async function updateCommand() {
-  if (!existsSync5("checks.yaml")) {
-    console.error(chalk4.red("No checks.yaml found. Run `holdpoint init` first."));
+  if (!existsSync7("checks.yaml")) {
+    console.error(chalk5.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
   const spinner = ora3("Updating Holdpoint engine files\u2026").start();
-  const config = parseHoldpointYaml4(readFileSync5("checks.yaml", "utf8"));
+  const config = parseHoldpointYaml4(readFileSync6("checks.yaml", "utf8"));
   const detected = detectInstalledAgents();
   const agents = detected.length > 0 ? detected : ["copilot", "claude", "cursor", "codex"];
   const generatedDir = ".github/holdpoint/generated";
-  mkdirSync3(generatedDir, { recursive: true });
-  writeFileSync3(`${generatedDir}/checks.immutable.json`, buildConfigJson2(config), "utf8");
+  mkdirSync4(generatedDir, { recursive: true });
+  writeFileSync5(`${generatedDir}/checks.immutable.json`, buildConfigJson2(config), "utf8");
   if (agents.includes("copilot")) {
     const extDir = ".github/extensions/holdpoint";
-    mkdirSync3(extDir, { recursive: true });
-    writeFileSync3(`${extDir}/extension.mjs`, buildEngine2(config), "utf8");
+    mkdirSync4(extDir, { recursive: true });
+    writeFileSync5(`${extDir}/extension.mjs`, buildEngine2(config), "utf8");
+    spliceBreadcrumb(".github/copilot-instructions.md");
   }
   if (agents.includes("claude")) {
-    mkdirSync3(".claude", { recursive: true });
+    mkdirSync4(".claude", { recursive: true });
     const settingsPath = ".claude/settings.json";
     let existing = {};
-    if (existsSync5(settingsPath)) {
+    if (existsSync7(settingsPath)) {
       try {
-        existing = JSON.parse(readFileSync5(settingsPath, "utf8"));
+        existing = JSON.parse(readFileSync6(settingsPath, "utf8"));
       } catch {
       }
     }
     const hooks = JSON.parse(buildClaudeEngineJson2(config));
-    writeFileSync3(
+    writeFileSync5(
       settingsPath,
-      JSON.stringify({ ...existing, hooks: hooks.hooks }, null, 2) + "\n"
+      JSON.stringify(mergeClaudeSettings(existing, hooks), null, 2) + "\n"
     );
+    spliceBreadcrumb("CLAUDE.md");
   }
   if (agents.includes("cursor")) {
+    mkdirSync4(".cursor", { recursive: true });
+    const cursorHooksPath = ".cursor/hooks.json";
+    let existingHooks = {};
+    if (existsSync7(cursorHooksPath)) {
+      try {
+        existingHooks = JSON.parse(readFileSync6(cursorHooksPath, "utf8"));
+      } catch {
+      }
+    }
+    const cursorHooks = JSON.parse(buildCursorHooksJson2(config));
+    writeFileSync5(
+      cursorHooksPath,
+      JSON.stringify(mergeCursorHooks(existingHooks, cursorHooks), null, 2) + "\n",
+      "utf8"
+    );
+    writeFileSync5(".cursor/holdpoint-hook.mjs", buildCursorCheckScript2(), "utf8");
     const cursorRules = buildCursorEngine2(config);
     const cursorPath = ".cursorrules";
-    if (existsSync5(cursorPath)) {
-      const content = readFileSync5(cursorPath, "utf8");
+    if (existsSync7(cursorPath)) {
+      const content = readFileSync6(cursorPath, "utf8");
       const start = content.indexOf("# \u2500\u2500\u2500 Holdpoint Rules");
       const end = content.indexOf("# \u2500\u2500\u2500 End Holdpoint Rules \u2500\u2500\u2500");
       if (start !== -1 && end !== -1) {
         const afterEnd = content.indexOf("\n", end);
-        const updated = content.slice(0, start) + cursorRules + content.slice(afterEnd === -1 ? end : afterEnd + 1);
-        writeFileSync3(cursorPath, updated);
+        const prefix = content.slice(0, start).trimEnd();
+        const suffix = content.slice(afterEnd === -1 ? end : afterEnd + 1).trimStart();
+        const updated = (prefix ? `${prefix}
+
+` : "") + cursorRules + (suffix ? `
+${suffix}` : "");
+        writeFileSync5(cursorPath, updated);
       } else {
-        writeFileSync3(cursorPath, content + "\n" + cursorRules);
+        writeFileSync5(cursorPath, `${content.trimEnd()}
+
+${cursorRules}`);
       }
+    } else {
+      writeFileSync5(cursorPath, cursorRules);
     }
+    spliceBreadcrumb(".cursor/rules/holdpoint.md");
   }
   if (agents.includes("codex")) {
-    mkdirSync3(".codex", { recursive: true });
-    writeFileSync3(".codex/hooks.json", buildCodexHooksJson2(config), "utf8");
-    writeFileSync3(".codex/holdpoint-check.mjs", buildCodexCheckScript2(config), "utf8");
+    mkdirSync4(".codex", { recursive: true });
+    writeFileSync5(".codex/hooks.json", buildCodexHooksJson2(config), "utf8");
+    writeFileSync5(".codex/holdpoint-check.mjs", buildCodexCheckScript2(config), "utf8");
     const configTomlPath = ".codex/config.toml";
-    if (!existsSync5(configTomlPath)) {
-      writeFileSync3(configTomlPath, buildCodexConfigToml2(), "utf8");
+    if (!existsSync7(configTomlPath)) {
+      writeFileSync5(configTomlPath, buildCodexConfigToml2(), "utf8");
     } else {
-      const existing2 = readFileSync5(configTomlPath, "utf8");
-      if (!existing2.includes("[features]")) {
-        writeFileSync3(configTomlPath, existing2.trimEnd() + "\n\n" + buildCodexConfigToml2(), "utf8");
+      const existing = readFileSync6(configTomlPath, "utf8");
+      if (!existing.includes("[features]")) {
+        writeFileSync5(configTomlPath, existing.trimEnd() + "\n\n" + buildCodexConfigToml2(), "utf8");
       }
     }
-    const agentsMdPath = "AGENTS.md";
-    const existing = existsSync5(agentsMdPath) ? readFileSync5(agentsMdPath, "utf8") : "";
-    writeFileSync3(agentsMdPath, spliceAgentsMd2(existing, config), "utf8");
+    spliceBreadcrumb("AGENTS.md");
+  }
+  const wroteReference = ensureBundledFile(
+    "HOLDPOINT_REFERENCE.md",
+    "HOLDPOINT_REFERENCE.md",
+    MINIMAL_HOLDPOINT_REFERENCE2
+  );
+  const wrotePrerequisites = ensureBundledFile(
+    "HOLDPOINT_PREREQUISITES.md",
+    "HOLDPOINT_PREREQUISITES.md",
+    MINIMAL_PREREQUISITES2
+  );
+  spinner.succeed(chalk5.green("Engine files updated from current checks.yaml"));
+  if (wroteReference) {
+    console.log(
+      chalk5.cyan("Created HOLDPOINT_REFERENCE.md with the full Holdpoint workflow reference.")
+    );
+  }
+  if (wrotePrerequisites) {
+    console.log(
+      chalk5.cyan(
+        "Created HOLDPOINT_PREREQUISITES.md with Copilot experimental-mode and other agent setup notes."
+      )
+    );
   }
-  spinner.succeed(chalk4.green("Engine files updated from current checks.yaml"));
 }
 
 // src/commands/build.ts
-import { createServer } from "http";
-import { createReadStream, existsSync as existsSync6 } from "fs";
-import { join as join3, extname, dirname as dirname2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync3 } from "child_process";
-import chalk5 from "chalk";
-var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript",
-  ".mjs": "text/javascript",
-  ".css": "text/css",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".json": "application/json"
-};
-function serveFile(res, filePath) {
-  const mime = MIME[extname(filePath)] ?? "application/octet-stream";
-  res.writeHead(200, { "Content-Type": mime });
-  createReadStream(filePath).pipe(res);
-}
-function handleRequest(req, res, uiDir) {
-  const url = (req.url ?? "/").split("?")[0] ?? "/";
-  if (url === "/__holdpoint/initial-yaml") {
-    const checksPath = join3(process.cwd(), "checks.yaml");
-    if (existsSync6(checksPath)) {
-      res.writeHead(200, { "Content-Type": "text/yaml; charset=utf-8" });
-      createReadStream(checksPath).pipe(res);
-    } else {
-      res.writeHead(404, { "Content-Type": "text/plain" });
-      res.end("checks.yaml not found in current directory");
+import chalk6 from "chalk";
+
+// src/lib/ensure-daemon.ts
+import { spawn } from "child_process";
+import { readHealthyDaemonLock } from "@holdpoint/live-daemon";
+function sleep(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+async function ensureDaemon(timeoutMs = 5e3) {
+  const existing = await readHealthyDaemonLock();
+  if (existing) {
+    return { info: existing, started: false };
+  }
+  const cliEntry = process.argv[1];
+  if (!cliEntry) {
+    throw new Error("Cannot determine the current holdpoint CLI entrypoint");
+  }
+  const child = spawn(process.execPath, [cliEntry, "daemon-serve"], {
+    stdio: "ignore",
+    env: process.env,
+    cwd: process.cwd()
+  });
+  child.unref();
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const lock = await readHealthyDaemonLock();
+    if (lock) {
+      return { info: lock, started: true };
     }
-    return;
+    await sleep(100);
   }
-  if (url === "/__holdpoint/initial-reports") {
-    const reportsPath = join3(process.cwd(), ".holdpoint", "check-reports.json");
-    if (existsSync6(reportsPath)) {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      createReadStream(reportsPath).pipe(res);
-    } else {
-      res.writeHead(404, { "Content-Type": "text/plain" });
-      res.end("No check reports found");
+  throw new Error("Daemon unavailable + cannot spawn");
+}
+
+// src/lib/open-browser.ts
+import { execSync as execSync4 } from "child_process";
+function openBrowser(url) {
+  const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    execSync4(`${openCmd} ${JSON.stringify(url)}`, { stdio: "ignore" });
+  } catch {
+  }
+}
+
+// src/lib/project.ts
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+import { identifyProject as identifyProject2 } from "@holdpoint/live-daemon";
+function findChecksYaml(startDir) {
+  let current = startDir;
+  for (; ; ) {
+    const candidate = join4(current, "checks.yaml");
+    if (existsSync8(candidate)) {
+      return candidate;
     }
+    const parent = dirname4(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function tryResolveCurrentProject() {
+  const checksYaml = findChecksYaml(process.cwd());
+  if (checksYaml) {
+    return identifyProject2(dirname4(checksYaml));
+  }
+  try {
+    return identifyProject2(process.cwd());
+  } catch {
+    return null;
+  }
+}
+function appendProjectAuthParams(url, project) {
+  if (!project) {
     return;
   }
-  const candidate = join3(uiDir, url === "/" ? "index.html" : url);
-  const filePath = existsSync6(candidate) ? candidate : join3(uiDir, "index.html");
-  serveFile(res, filePath);
+  url.searchParams.set("project", project.hash);
+  url.searchParams.set("name", project.name);
+  url.searchParams.set("root", project.root);
 }
+
+// src/commands/build.ts
 async function buildCommand() {
-  const port = 4321;
-  const uiDir = join3(__dirname2, "builder-ui");
-  if (!existsSync6(uiDir)) {
-    console.error(chalk5.red("\u2717 Builder UI not found.\n"));
-    console.log(chalk5.dim("  This is unexpected for a published build of @holdpoint/cli."));
-    console.log(chalk5.dim("  If you installed from source, rebuild with: pnpm turbo build\n"));
-    process.exit(1);
-  }
-  const server = createServer((req, res) => handleRequest(req, res, uiDir));
-  await new Promise((resolve, reject) => {
-    server.listen(port, () => {
-      console.log(
-        `
-${chalk5.green("\u2713")} Holdpoint builder running at ${chalk5.cyan(`http://localhost:${port}`)}`
-      );
-      console.log(chalk5.dim("  Edit checks.yaml, then reload the page to see updates"));
-      console.log(chalk5.dim("  Press Ctrl+C to stop\n"));
-      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-      try {
-        execSync3(`${openCmd} http://localhost:${port}`, { stdio: "ignore" });
-      } catch {
-      }
-    });
-    server.on("error", reject);
-    process.on("SIGINT", () => {
-      console.log(chalk5.dim("\n  Stopping builder\u2026"));
-      server.close(() => resolve());
-    });
-  });
+  const { info, started } = await ensureDaemon();
+  const url = new URL("/__holdpoint/live-auth", `http://127.0.0.1:${info.port}`);
+  url.searchParams.set("token", info.token);
+  url.searchParams.set("path", "/builder/");
+  appendProjectAuthParams(url, tryResolveCurrentProject());
+  openBrowser(url.toString());
+  console.log(
+    chalk6.green(
+      started ? "\u2713 Started Holdpoint Live and opened the builder" : "\u2713 Opened Holdpoint builder"
+    )
+  );
+  console.log(`  url: ${chalk6.cyan(url.toString())}`);
 }
 
 // src/commands/evolve.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { execSync as execSync6 } from "child_process";
-import chalk6 from "chalk";
+import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { execSync as execSync7 } from "child_process";
+import chalk7 from "chalk";
 import ora4 from "ora";
 import { parseHoldpointYaml as parseHoldpointYaml5, generateYaml } from "@holdpoint/yaml-core";
 
 // src/evolve/scanner.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync } from "fs";
-import { join as join4 } from "path";
-import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync } from "fs";
+import { join as join5 } from "path";
+import { execSync as execSync5 } from "child_process";
 function tryReadJson(path) {
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
 }
 function tryReadText(path) {
   try {
-    return readFileSync6(path, "utf8");
+    return readFileSync7(path, "utf8");
   } catch {
     return "";
   }
 }
 function scanProject(cwd = process.cwd()) {
-  const exists = (p) => existsSync7(join4(cwd, p));
+  const exists = (p) => existsSync9(join5(cwd, p));
   const packageManager = exists("pnpm-lock.yaml") ? "pnpm" : exists("yarn.lock") ? "yarn" : exists("bun.lockb") ? "bun" : "npm";
-  const pkg = tryReadJson(join4(cwd, "package.json"));
+  const pkg = tryReadJson(join5(cwd, "package.json"));
   const scripts = pkg?.scripts ?? {};
   const deps = /* @__PURE__ */ new Set([
     ...Object.keys(pkg?.dependencies ?? {}),
     ...Object.keys(pkg?.devDependencies ?? {})
   ]);
-  const pyprojectText = tryReadText(join4(cwd, "pyproject.toml"));
-  const requirementsText = tryReadText(join4(cwd, "requirements.txt"));
-  const pipfileText = tryReadText(join4(cwd, "Pipfile"));
+  const pyprojectText = tryReadText(join5(cwd, "pyproject.toml"));
+  const requirementsText = tryReadText(join5(cwd, "requirements.txt"));
+  const pipfileText = tryReadText(join5(cwd, "Pipfile"));
   const allPyText = pyprojectText + requirementsText + pipfileText;
   const hasPytest = exists("pytest.ini") || exists("setup.cfg") || allPyText.includes("pytest") || allPyText.includes("[tool.pytest");
   const hasRuff = allPyText.includes("ruff") || deps.has("ruff");
@@ -731,9 +1111,9 @@ function scanProject(cwd = process.cwd()) {
 }
 
 // src/evolve/dead-checker.ts
-import { execSync as execSync5 } from "child_process";
-import { readdirSync as readdirSync2, existsSync as existsSync8 } from "fs";
-import { join as join5 } from "path";
+import { execSync as execSync6 } from "child_process";
+import { readdirSync as readdirSync2, existsSync as existsSync10 } from "fs";
+import { join as join6 } from "path";
 var NAMED_SCOPES = /* @__PURE__ */ new Set([
   "frontend",
   "backend",
@@ -778,7 +1158,7 @@ function walkDir(dir, root, depth, maxDepth) {
   const results = [];
   for (const entry of entries) {
     if (WALK_IGNORED.has(entry) || entry.startsWith(".")) continue;
-    const full = join5(dir, entry);
+    const full = join6(dir, entry);
     const rel = full.slice(root.length + 1);
     results.push(rel);
     const children = walkDir(full, root, depth + 1, maxDepth);
@@ -788,7 +1168,7 @@ function walkDir(dir, root, depth, maxDepth) {
 }
 function getRepoFiles(cwd) {
   try {
-    const out = execSync5("git ls-files", {
+    const out = execSync6("git ls-files", {
       cwd,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
@@ -825,7 +1205,7 @@ function detectStaleChecks(config, repoFiles) {
     if (matches.length === 0) {
       const label = patternAlias ? `Pattern '${patternAlias}' (= '${regexStr}')` : `Regex '${regexStr}'`;
       const suggestedConditionPath = extractPathFromRegex(regexStr);
-      const pathGone = !suggestedConditionPath || !existsSync8(join5(process.cwd(), suggestedConditionPath));
+      const pathGone = !suggestedConditionPath || !existsSync10(join6(process.cwd(), suggestedConditionPath));
       if (pathGone) {
         stale.push({
           check,
@@ -844,6 +1224,9 @@ function pmScript(profile, script, fallback) {
   if (profile.packageManager === "npm") return `npm run ${script}`;
   return `${profile.packageManager} ${script}`;
 }
+var blockedMarkerTerms = ["TODO", "FIXME", "HACK", "XXX"];
+var blockedMarkerLabel = `No ${blockedMarkerTerms[0]}/${blockedMarkerTerms[1]} left in changed code`;
+var blockedMarkerPrompt = `Scan the files you changed for any ${blockedMarkerTerms.join(", ")} comments. Either resolve them before finishing or convert them to GitHub issues. Don't leave incomplete work silently behind.`;
 function getTemplates(profile) {
   return [
     // ── Universal checks (always proposed for any project) ──────────────────
@@ -867,8 +1250,8 @@ function getTemplates(profile) {
     },
     {
       id: "no-todos",
-      label: "No TODO/FIXME left in changed code",
-      prompt: "Scan the files you changed for any TODO, FIXME, HACK, or XXX comments. Either resolve them before finishing or convert them to GitHub issues. Don't leave incomplete work silently behind.",
+      label: blockedMarkerLabel,
+      prompt: blockedMarkerPrompt,
       trigger: () => true
     },
     // ── TypeScript / JavaScript ──────────────────────────────────────────────
@@ -1026,20 +1409,20 @@ function withHeader(header, newYaml) {
   return header + "\n\n" + newYaml;
 }
 async function evolveCommand(options) {
-  if (!existsSync9("checks.yaml")) {
-    console.error(chalk6.red("No checks.yaml found. Run `holdpoint init` first."));
+  if (!existsSync11("checks.yaml")) {
+    console.error(chalk7.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
   const spinner = ora4("Scanning project profile\u2026").start();
   const cwd = process.cwd();
   const profile = scanProject(cwd);
   const repoFiles = getRepoFiles(cwd);
-  const yamlContent = readFileSync7("checks.yaml", "utf8");
+  const yamlContent = readFileSync8("checks.yaml", "utf8");
   let config;
   try {
     config = parseHoldpointYaml5(yamlContent);
   } catch (err) {
-    spinner.fail(chalk6.red("Invalid checks.yaml:") + " " + err.message);
+    spinner.fail(chalk7.red("Invalid checks.yaml:") + " " + err.message);
     process.exit(1);
   }
   spinner.stop();
@@ -1048,7 +1431,7 @@ async function evolveCommand(options) {
   const allTemplates = getTemplates(profile);
   const proposals = allTemplates.filter((t) => t.trigger(profile) && !existingIds.has(t.id));
   const staleChecks = detectStaleChecks(config, repoFiles);
-  console.log(chalk6.bold("\n\u{1F4CB} Project profile:"));
+  console.log(chalk7.bold("\n\u{1F4CB} Project profile:"));
   const traits = [
     ["TypeScript", profile.hasTypeScript, "tsconfig.json"],
     ["ESLint", profile.hasEslint, "eslint.config.*"],
@@ -1074,40 +1457,40 @@ async function evolveCommand(options) {
   ];
   const detected = traits.filter(([, yes]) => yes);
   if (detected.length === 0) {
-    console.log(chalk6.dim("  (empty project \u2014 only universal checks apply)"));
+    console.log(chalk7.dim("  (empty project \u2014 only universal checks apply)"));
   } else {
     for (const [name, , hint] of detected) {
-      console.log(`  ${chalk6.green("\u2713")} ${name.padEnd(18)} ${chalk6.dim(hint)}`);
+      console.log(`  ${chalk7.green("\u2713")} ${name.padEnd(18)} ${chalk7.dim(hint)}`);
     }
   }
   if (staleChecks.length > 0) {
-    console.log(chalk6.bold(`
+    console.log(chalk7.bold(`
 \u26A0\uFE0F  Stale checks (${staleChecks.length}):`));
     for (const { check, reason, suggestedConditionPath } of staleChecks) {
-      const fix = suggestedConditionPath ? chalk6.dim(` \u2192 will wrap with conditionId: file_exists: ${suggestedConditionPath}`) : chalk6.dim(" \u2192 no path inferred; review manually");
-      console.log(`  ${chalk6.yellow("\u25CC")} ${chalk6.bold(check.id)}  ${chalk6.dim(reason)}${fix}`);
+      const fix = suggestedConditionPath ? chalk7.dim(` \u2192 will wrap with conditionId: file_exists: ${suggestedConditionPath}`) : chalk7.dim(" \u2192 no path inferred; review manually");
+      console.log(`  ${chalk7.yellow("\u25CC")} ${chalk7.bold(check.id)}  ${chalk7.dim(reason)}${fix}`);
     }
   }
   if (proposals.length === 0 && staleChecks.length === 0) {
-    console.log(chalk6.green("\n\u2713 checks.yaml is fully in sync with the project profile."));
+    console.log(chalk7.green("\n\u2713 checks.yaml is fully in sync with the project profile."));
     return;
   }
   if (proposals.length > 0) {
-    console.log(chalk6.bold(`
+    console.log(chalk7.bold(`
 \u{1F4A1} Proposed additions (${proposals.length}):`));
     for (const t of proposals) {
-      const scope = t.when ? chalk6.cyan(` when: ${t.when}`) : "";
-      const type = t.cmd ? chalk6.dim("cmd") : chalk6.dim("prompt");
-      const preview = t.cmd ? chalk6.dim(`  ${t.cmd.slice(0, 80)}${t.cmd.length > 80 ? "\u2026" : ""}`) : chalk6.dim(`  ${(t.prompt ?? "").slice(0, 80)}${(t.prompt?.length ?? 0) > 80 ? "\u2026" : ""}`);
-      console.log(`  ${chalk6.green("+")} ${chalk6.bold(t.id.padEnd(24))} [${type}]${scope}`);
+      const scope = t.when ? chalk7.cyan(` when: ${t.when}`) : "";
+      const type = t.cmd ? chalk7.dim("cmd") : chalk7.dim("prompt");
+      const preview = t.cmd ? chalk7.dim(`  ${t.cmd.slice(0, 80)}${t.cmd.length > 80 ? "\u2026" : ""}`) : chalk7.dim(`  ${(t.prompt ?? "").slice(0, 80)}${(t.prompt?.length ?? 0) > 80 ? "\u2026" : ""}`);
+      console.log(`  ${chalk7.green("+")} ${chalk7.bold(t.id.padEnd(24))} [${type}]${scope}`);
       console.log(`    ${preview}`);
     }
   }
   if (!options.apply) {
     console.log(
-      chalk6.red(`
+      chalk7.red(`
 \u2717 checks.yaml is out of sync with the project profile.`) + `
-  Run ${chalk6.bold("npx @holdpoint/cli@alpha evolve --apply")} to apply these changes.`
+  Run ${chalk7.bold("npx @holdpoint/cli@alpha suggest --apply")} to apply these changes.`
     );
     process.exit(1);
   }
@@ -1148,42 +1531,881 @@ async function evolveCommand(options) {
   };
   const header = extractHeader(yamlContent);
   const newYaml = withHeader(header, generateYaml(updatedConfig));
-  writeFileSync4("checks.yaml", newYaml, "utf8");
+  writeFileSync6("checks.yaml", newYaml, "utf8");
   applySpinner.text = "Running holdpoint update\u2026";
   try {
-    execSync6("npx @holdpoint/cli@alpha update", { stdio: "pipe" });
+    execSync7("npx @holdpoint/cli@alpha update", { stdio: "pipe" });
   } catch {
     applySpinner.warn(
-      chalk6.yellow("checks.yaml updated, but `holdpoint update` failed \u2014 run it manually.")
+      chalk7.yellow("checks.yaml updated, but `holdpoint update` failed \u2014 run it manually.")
     );
     printAppliedSummary(proposals.length, staleChecks.length);
     return;
   }
-  applySpinner.succeed(chalk6.green("checks.yaml updated and engine files regenerated."));
+  applySpinner.succeed(chalk7.green("checks.yaml updated and engine files regenerated."));
   printAppliedSummary(proposals.length, staleChecks.length);
 }
 function printAppliedSummary(added, wrapped) {
   const parts = [];
-  if (added > 0) parts.push(chalk6.green(`${added} check${added === 1 ? "" : "s"} added`));
+  if (added > 0) parts.push(chalk7.green(`${added} check${added === 1 ? "" : "s"} added`));
   if (wrapped > 0)
-    parts.push(chalk6.yellow(`${wrapped} stale check${wrapped === 1 ? "" : "s"} wrapped`));
+    parts.push(chalk7.yellow(`${wrapped} stale check${wrapped === 1 ? "" : "s"} wrapped`));
   if (parts.length > 0) console.log("  " + parts.join("  \xB7  "));
   console.log(
-    chalk6.dim("\n  Review checks.yaml, then commit: ") + chalk6.yellow("git add checks.yaml && git commit -m 'chore: evolve holdpoint checks'")
+    chalk7.dim("\n  Review checks.yaml, then commit: ") + chalk7.yellow("git add checks.yaml && git commit -m 'chore: update holdpoint checks'")
+  );
+}
+
+// src/commands/live.ts
+import chalk8 from "chalk";
+async function liveCommand(options = {}) {
+  const { info, started } = await ensureDaemon();
+  const baseUrl = new URL(`/__holdpoint/live-auth`, `http://127.0.0.1:${info.port}`);
+  baseUrl.searchParams.set("token", info.token);
+  baseUrl.searchParams.set("path", "/live/");
+  const currentProject = options.project ? null : tryResolveCurrentProject();
+  if (options.project) {
+    baseUrl.searchParams.set("project", options.project);
+  } else if (currentProject) {
+    appendProjectAuthParams(baseUrl, currentProject);
+  }
+  openBrowser(baseUrl.toString());
+  console.log(
+    chalk8.green(
+      started ? "\u2713 Started Holdpoint Live and opened the browser" : "\u2713 Opened Holdpoint Live"
+    )
+  );
+  console.log(`  url: ${chalk8.cyan(baseUrl.toString())}`);
+}
+
+// src/commands/daemon.ts
+import chalk9 from "chalk";
+import {
+  DaemonAlreadyRunningError,
+  isProcessAlive,
+  readDaemonLock,
+  readHealthyDaemonLock as readHealthyDaemonLock2,
+  removeDaemonLock,
+  startDaemonProcess
+} from "@holdpoint/live-daemon";
+
+// src/version.ts
+var CLI_VERSION = "0.1.0-alpha.15";
+
+// src/commands/daemon.ts
+function formatUptime(lock) {
+  const seconds = Math.max(0, Math.floor((Date.now() - lock.started_at) / 1e3));
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return minutes > 0 ? `${minutes}m ${remainingSeconds}s` : `${remainingSeconds}s`;
+}
+async function fetchSessionCount(lock) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${lock.port}/v1/sessions`, {
+      headers: {
+        authorization: `Bearer ${lock.token}`
+      }
+    });
+    if (!response.ok) return null;
+    const parsed = await response.json();
+    return Array.isArray(parsed.sessions) ? parsed.sessions.length : null;
+  } catch {
+    return null;
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+async function daemonStartCommand() {
+  const { info, started } = await ensureDaemon();
+  const sessionCount = await fetchSessionCount(info);
+  const headline = started ? "Started Holdpoint Live daemon" : "Reused existing Holdpoint Live daemon";
+  console.log(chalk9.green(`\u2713 ${headline}`));
+  console.log(`  pid: ${chalk9.cyan(String(info.pid))}`);
+  console.log(`  port: ${chalk9.cyan(String(info.port))}`);
+  console.log(`  uptime: ${chalk9.cyan(formatUptime(info))}`);
+  if (sessionCount !== null) {
+    console.log(`  sessions: ${chalk9.cyan(String(sessionCount))}`);
+  }
+}
+async function daemonStatusCommand() {
+  const lock = await readHealthyDaemonLock2();
+  if (!lock) {
+    console.log(chalk9.yellow("Holdpoint Live daemon is not running."));
+    return;
+  }
+  const sessionCount = await fetchSessionCount(lock);
+  console.log(chalk9.green("\u2713 Holdpoint Live daemon is running"));
+  console.log(`  pid: ${chalk9.cyan(String(lock.pid))}`);
+  console.log(`  port: ${chalk9.cyan(String(lock.port))}`);
+  console.log(`  uptime: ${chalk9.cyan(formatUptime(lock))}`);
+  if (sessionCount !== null) {
+    console.log(`  sessions: ${chalk9.cyan(String(sessionCount))}`);
+  }
+}
+async function daemonStopCommand() {
+  const lock = readDaemonLock();
+  if (!lock) {
+    console.log(chalk9.yellow("Holdpoint Live daemon is not running."));
+    return;
+  }
+  if (!isProcessAlive(lock.pid)) {
+    removeDaemonLock(void 0, lock.token);
+    console.log(chalk9.yellow("Removed stale Holdpoint Live lockfile."));
+    return;
+  }
+  process.kill(lock.pid, "SIGTERM");
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(lock.pid)) {
+      removeDaemonLock(void 0, lock.token);
+      console.log(chalk9.green(`\u2713 Stopped Holdpoint Live daemon (${lock.pid})`));
+      return;
+    }
+    await sleep2(100);
+  }
+  process.kill(lock.pid, "SIGKILL");
+  await sleep2(100);
+  removeDaemonLock(void 0, lock.token);
+  console.log(chalk9.green(`\u2713 Force-stopped Holdpoint Live daemon (${lock.pid})`));
+}
+async function daemonServeCommand(options) {
+  try {
+    const daemon2 = await startDaemonProcess({
+      version: CLI_VERSION,
+      ...options.port ? { port: Number(options.port) } : {}
+    });
+    await daemon2.closed;
+  } catch (error) {
+    if (error instanceof DaemonAlreadyRunningError) {
+      process.exit(0);
+    }
+    throw error;
+  }
+}
+
+// src/commands/engines.ts
+import chalk10 from "chalk";
+
+// src/engines.ts
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname5, join as join7, resolve, sep } from "path";
+import { createRequire } from "module";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
+import { parseEventV1 } from "@holdpoint/live-protocol";
+var require2 = createRequire(import.meta.url);
+var CLI_SRC_DIR = dirname5(fileURLToPath3(import.meta.url));
+var MONOREPO_ROOT = resolve(CLI_SRC_DIR, "../../..");
+var BUILTIN_LIVE_ENGINE_PACKAGES = [
+  "@holdpoint/engine-claude",
+  "@holdpoint/engine-codex",
+  "@holdpoint/engine-cursor"
+];
+var HOLDPOINT_ENGINE_KEYWORD = "holdpoint-engine";
+function isObject3(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function isExternalLiveEnginePackageName(packageName) {
+  return /^holdpoint-engine-[a-z0-9-]+$/.test(packageName) || /^@[a-z0-9_.-]+\/holdpoint-engine-[a-z0-9-]+$/.test(packageName);
+}
+function readJsonFile(path) {
+  if (!existsSync12(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    return isObject3(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function findNearestPackageRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (existsSync12(join7(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname5(current);
+    if (parent === current) {
+      return resolve(startDir);
+    }
+    current = parent;
+  }
+}
+function findPackageRootFromFile(path) {
+  let current = dirname5(path);
+  while (true) {
+    if (existsSync12(join7(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname5(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function getDependencyEnginePackageNames(projectRoot) {
+  const packageJson = readJsonFile(join7(projectRoot, "package.json"));
+  if (!packageJson) {
+    return [];
+  }
+  const packageNames = /* @__PURE__ */ new Set();
+  for (const field of ["dependencies", "devDependencies", "optionalDependencies"]) {
+    const deps = packageJson[field];
+    if (!isObject3(deps)) {
+      continue;
+    }
+    for (const packageName of Object.keys(deps)) {
+      if (isExternalLiveEnginePackageName(packageName)) {
+        packageNames.add(packageName);
+      }
+    }
+  }
+  return [...packageNames];
+}
+function resolvePackageRoot(packageName, projectRoot) {
+  try {
+    const entryPath = require2.resolve(packageName);
+    return findPackageRootFromFile(entryPath);
+  } catch {
+  }
+  try {
+    const entryPath = require2.resolve(packageName, {
+      paths: [projectRoot, process.cwd()]
+    });
+    return findPackageRootFromFile(entryPath);
+  } catch {
+  }
+  try {
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`, {
+      paths: [projectRoot, process.cwd()]
+    });
+    return dirname5(packageJsonPath);
+  } catch {
+    if (packageName.startsWith("@holdpoint/")) {
+      const scopedName = packageName.split("/")[1];
+      if (scopedName) {
+        const packageDir = resolve(MONOREPO_ROOT, "packages", scopedName);
+        if (existsSync12(join7(packageDir, "package.json"))) {
+          return packageDir;
+        }
+      }
+    }
+    return null;
+  }
+}
+function formatImportError(error) {
+  return error instanceof Error && error.message ? error.message : String(error);
+}
+function parseManifest(value) {
+  if (!isObject3(value)) {
+    return null;
+  }
+  if (value.manifestVersion !== 1) {
+    return null;
+  }
+  if (typeof value.id !== "string" || !/^[a-z0-9-]+$/.test(value.id)) {
+    return null;
+  }
+  if (typeof value.displayName !== "string" || !value.displayName.trim()) {
+    return null;
+  }
+  return {
+    manifestVersion: 1,
+    id: value.id,
+    displayName: value.displayName
+  };
+}
+function parseLiveCapabilities(value) {
+  if (!isObject3(value)) {
+    return null;
+  }
+  const capabilities = {};
+  for (const key of [
+    "can_stream",
+    "can_control",
+    "can_modify_context",
+    "can_register_tools",
+    "control_online"
+  ]) {
+    const entry = value[key];
+    if (entry === void 0) {
+      continue;
+    }
+    if (typeof entry !== "boolean") {
+      return null;
+    }
+    capabilities[key] = entry;
+  }
+  return capabilities;
+}
+function parseLiveAdapter(value, manifest) {
+  if (!isObject3(value)) {
+    return null;
+  }
+  if (typeof value.id !== "string" || typeof value.displayName !== "string") {
+    return null;
+  }
+  if (value.id !== manifest.id || value.displayName !== manifest.displayName) {
+    return null;
+  }
+  const capabilities = parseLiveCapabilities(value.capabilities);
+  if (!capabilities) {
+    return null;
+  }
+  const generateBridgeCommand = value.generateBridgeCommand;
+  if (typeof generateBridgeCommand !== "function") {
+    return null;
+  }
+  const translateHookInput = value.translateHookInput;
+  if (typeof translateHookInput !== "function") {
+    return null;
+  }
+  return {
+    id: value.id,
+    displayName: value.displayName,
+    capabilities,
+    generateBridgeCommand: () => {
+      const command = generateBridgeCommand();
+      if (typeof command !== "string") {
+        throw new Error("adapter.generateBridgeCommand() must return a string");
+      }
+      return command;
+    },
+    translateHookInput: (raw, options) => {
+      const event = translateHookInput(raw, options);
+      return event == null ? null : parseEventV1(event);
+    }
+  };
+}
+async function importModule(modulePath) {
+  const moduleUrl = pathToFileURL(modulePath).href;
+  return await import(moduleUrl);
+}
+function resolvePackageAssetPath(packageRoot, relativePath) {
+  const declaredPath = resolve(packageRoot, relativePath);
+  const sourceFallback = resolve(
+    packageRoot,
+    relativePath.replace(/^\.\/dist\//, "./src/").replace(/\.js$/, ".ts")
+  );
+  if (packageRoot.startsWith(resolve(MONOREPO_ROOT, "packages") + sep) && existsSync12(sourceFallback)) {
+    return sourceFallback;
+  }
+  if (existsSync12(declaredPath)) {
+    return declaredPath;
+  }
+  return sourceFallback;
+}
+async function resolveCandidate(packageName, source, projectRoot) {
+  const packageRoot = resolvePackageRoot(packageName, projectRoot);
+  if (!packageRoot) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "package could not be resolved from this project"
+    };
+  }
+  const packageJson = readJsonFile(join7(packageRoot, "package.json"));
+  if (!packageJson) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "package.json could not be read"
+    };
+  }
+  const keywords = Array.isArray(packageJson.keywords) ? packageJson.keywords : [];
+  if (!keywords.includes(HOLDPOINT_ENGINE_KEYWORD)) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: `missing \`${HOLDPOINT_ENGINE_KEYWORD}\` keyword`
+    };
+  }
+  const metadata = isObject3(packageJson.holdpoint) ? packageJson.holdpoint : void 0;
+  if (!metadata?.manifest) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "missing `holdpoint.manifest` package.json field"
+    };
+  }
+  if (!metadata.adapter) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "missing `holdpoint.adapter` package.json field"
+    };
+  }
+  const manifestPath = resolvePackageAssetPath(packageRoot, metadata.manifest);
+  const adapterPath = resolvePackageAssetPath(packageRoot, metadata.adapter);
+  if (!existsSync12(manifestPath)) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "manifest file does not exist"
+    };
+  }
+  if (!existsSync12(adapterPath)) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "adapter file does not exist"
+    };
+  }
+  try {
+    const manifestModule = await importModule(manifestPath);
+    const manifest = parseManifest(manifestModule.manifest);
+    if (!manifest) {
+      return {
+        packageName,
+        source,
+        status: "ignored",
+        reason: "manifest export is invalid"
+      };
+    }
+    return {
+      packageName,
+      source,
+      status: "loaded",
+      manifest,
+      packageRoot,
+      adapterPath
+    };
+  } catch (error) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: `manifest import failed: ${formatImportError(error)}`
+    };
+  }
+}
+async function discoverLiveEnginesDetailed(options) {
+  const projectRoot = findNearestPackageRoot(options?.cwd ?? process.cwd());
+  const dependencyPackages = getDependencyEnginePackageNames(projectRoot);
+  const seenPackages = /* @__PURE__ */ new Set();
+  const results = [];
+  const loadedIds = /* @__PURE__ */ new Set();
+  const candidates = [
+    ...BUILTIN_LIVE_ENGINE_PACKAGES.map((packageName) => ({
+      packageName,
+      source: "built-in"
+    })),
+    ...dependencyPackages.map((packageName) => ({ packageName, source: "dependency" }))
+  ];
+  for (const candidate of candidates) {
+    if (seenPackages.has(candidate.packageName)) {
+      continue;
+    }
+    seenPackages.add(candidate.packageName);
+    const result = await resolveCandidate(candidate.packageName, candidate.source, projectRoot);
+    if (result.status === "loaded" && result.manifest) {
+      if (loadedIds.has(result.manifest.id)) {
+        results.push({
+          packageName: result.packageName,
+          source: result.source,
+          status: "ignored",
+          reason: `engine id \`${result.manifest.id}\` collides with an already loaded adapter`,
+          manifest: result.manifest
+        });
+        continue;
+      }
+      loadedIds.add(result.manifest.id);
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function discoverLiveEngines(options) {
+  const results = await discoverLiveEnginesDetailed(options);
+  return results.map(({ packageName, source, status, reason, manifest }) => ({
+    packageName,
+    source,
+    status,
+    ...reason ? { reason } : {},
+    ...manifest ? { manifest } : {}
+  }));
+}
+async function loadLiveAdapter(engineId, options) {
+  const results = await discoverLiveEnginesDetailed(options);
+  const match = results.find(
+    (result) => result.status === "loaded" && result.manifest?.id === engineId
+  );
+  if (!match?.adapterPath || !match.manifest) {
+    return null;
+  }
+  try {
+    const adapterModule = await importModule(match.adapterPath);
+    return parseLiveAdapter(adapterModule.adapter, match.manifest);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/engines.ts
+async function enginesCommand(options = {}) {
+  const engines = await discoverLiveEngines();
+  if (options.json) {
+    console.log(JSON.stringify(engines, null, 2));
+    return;
+  }
+  if (engines.length === 0) {
+    console.log("No Holdpoint Live engines were discovered.");
+    return;
+  }
+  for (const engine of engines) {
+    if (engine.status === "loaded" && engine.manifest) {
+      console.log(
+        `${chalk10.green("loaded")} ${chalk10.cyan(engine.manifest.id)} (${engine.manifest.displayName}) from ${chalk10.yellow(engine.packageName)} [${engine.source}]`
+      );
+      continue;
+    }
+    console.log(
+      `${chalk10.yellow("ignored")} ${chalk10.yellow(engine.packageName)} [${engine.source}] \u2014 ${engine.reason ?? "unknown reason"}`
+    );
+  }
+}
+
+// src/commands/event.ts
+import { readFileSync as readFileSync10 } from "fs";
+import { parseEventV1 as parseEventV12, parseEventsBatch } from "@holdpoint/live-protocol";
+import { BridgeClient as BridgeClient2 } from "@holdpoint/sdk";
+function readStdin() {
+  return readFileSync10(0, "utf8");
+}
+async function eventCommand(options) {
+  const stdin = readStdin().trim();
+  if (!stdin) {
+    if (options.fromHook) {
+      process.exit(0);
+    }
+    console.error("No JSON input received on stdin.");
+    process.exit(3);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(stdin);
+  } catch {
+    if (options.fromHook) {
+      process.exit(0);
+    }
+    console.error("Invalid JSON input.");
+    process.exit(3);
+  }
+  const client = new BridgeClient2();
+  try {
+    if (options.fromHook) {
+      if (!options.engine) {
+        process.exit(0);
+      }
+      const adapter = await loadLiveAdapter(options.engine);
+      if (!adapter) {
+        process.exit(0);
+      }
+      const event = adapter.translateHookInput(raw, { cwd: process.cwd() });
+      if (!event) {
+        process.exit(0);
+      }
+      await client.sendEvent(event);
+      process.exit(0);
+    }
+    if (Array.isArray(raw)) {
+      await client.sendEvents(parseEventsBatch(raw));
+    } else {
+      await client.sendEvent(parseEventV12(raw));
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exit(3);
+  }
+}
+
+// src/commands/changeset.ts
+import { execSync as execSync8 } from "child_process";
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync11, statSync } from "fs";
+import { join as join8, relative } from "path";
+import chalk11 from "chalk";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage",
+  "dist",
+  "node_modules",
+  "test-results"
+]);
+function runGit(command) {
+  try {
+    const out = execSync8(command, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync11(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function getDefaultBranchRef() {
+  const [symbolic] = runGit("git symbolic-ref --quiet --short refs/remotes/origin/HEAD");
+  if (symbolic) return symbolic;
+  const candidates = ["origin/main", "origin/master"];
+  for (const candidate of candidates) {
+    if (runGit(`git rev-parse --verify ${candidate}`).length > 0) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function getBranchChangedFiles() {
+  const defaultBranch = getDefaultBranchRef();
+  if (!defaultBranch) return [];
+  const [base] = runGit(`git merge-base HEAD ${defaultBranch}`);
+  if (!base) return [];
+  return runGit(`git diff --name-only ${base}...HEAD`);
+}
+function uniqueFiles(files) {
+  return [...new Set(files.map(normalizePath))];
+}
+function getChangedFiles(options) {
+  const staged = runGit("git diff --cached --name-only");
+  if (options.staged && staged.length > 0) return staged;
+  const untracked = runGit("git ls-files --others --exclude-standard");
+  if (!options.staged) {
+    const unstaged = runGit("git diff --name-only HEAD");
+    const workingTree = uniqueFiles([...unstaged, ...untracked]);
+    if (workingTree.length > 0) return workingTree;
+  }
+  const branch = getBranchChangedFiles();
+  if (branch.length > 0 || untracked.length > 0) return uniqueFiles([...branch, ...untracked]);
+  return runGit("git diff --name-only HEAD~1 HEAD");
+}
+function parsePnpmWorkspacePatterns() {
+  if (!existsSync13("pnpm-workspace.yaml")) return [];
+  const lines = readFileSync11("pnpm-workspace.yaml", "utf8").split(/\r?\n/);
+  return lines.map((line) => line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/)?.[1]).filter((line) => Boolean(line)).filter((line) => !line.startsWith("!"));
+}
+function expandOneLevelWorkspacePattern(pattern) {
+  const normalized = normalizePath(pattern).replace(/\/package\.json$/, "");
+  if (!normalized.includes("*")) {
+    return existsSync13(join8(normalized, "package.json")) ? [normalized] : [];
+  }
+  const starIndex = normalized.indexOf("*");
+  const parent = normalized.slice(0, starIndex).replace(/\/$/, "");
+  const suffix = normalized.slice(starIndex + 1).replace(/^\//, "");
+  if (!parent || suffix.includes("*") || !existsSync13(parent)) {
+    return [];
+  }
+  return readdirSync3(parent).map((entry) => join8(parent, entry, suffix)).map(normalizePath).filter((candidate) => existsSync13(join8(candidate, "package.json")));
+}
+function walkPackageRoots(start, roots) {
+  let entries;
+  try {
+    entries = readdirSync3(start);
+  } catch {
+    return;
+  }
+  if (start !== "." && existsSync13(join8(start, "package.json"))) {
+    roots.push(normalizePath(start));
+    return;
+  }
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry)) continue;
+    const candidate = join8(start, entry);
+    let stats;
+    try {
+      stats = statSync(candidate);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      walkPackageRoots(candidate, roots);
+    }
+  }
+}
+function readPackageRoot(path) {
+  const pkg = readJson(join8(path, "package.json"));
+  if (!pkg) return null;
+  return {
+    path: normalizePath(path === "." ? "" : path),
+    name: typeof pkg.name === "string" ? pkg.name : path || "root",
+    private: pkg.private === true
+  };
+}
+function discoverPackageRoots(includePatterns = []) {
+  const explicitRoots = includePatterns.flatMap(expandOneLevelWorkspacePattern);
+  if (explicitRoots.length > 0) {
+    return uniquePackageRoots(
+      explicitRoots.map(readPackageRoot).filter((pkg) => Boolean(pkg))
+    );
+  }
+  const rootPackage = readJson("package.json");
+  const workspacePatterns = [
+    ...parsePnpmWorkspacePatterns(),
+    ...extractPackageJsonWorkspacePatterns(rootPackage)
+  ];
+  const workspaceRoots = workspacePatterns.flatMap(expandOneLevelWorkspacePattern);
+  if (workspaceRoots.length > 0) {
+    return uniquePackageRoots(
+      workspaceRoots.map(readPackageRoot).filter((pkg) => Boolean(pkg)).filter((pkg) => !pkg.private)
+    );
+  }
+  const discovered = [];
+  walkPackageRoots(".", discovered);
+  const roots = discovered.length > 0 ? discovered : existsSync13("package.json") ? ["."] : [];
+  return uniquePackageRoots(
+    roots.map(readPackageRoot).filter((pkg) => Boolean(pkg)).filter((pkg) => !pkg.private)
   );
 }
+function extractPackageJsonWorkspacePatterns(pkg) {
+  const workspaces = pkg?.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((entry) => typeof entry === "string");
+  }
+  if (workspaces && typeof workspaces === "object" && "packages" in workspaces && Array.isArray(workspaces.packages)) {
+    return workspaces.packages.filter(
+      (entry) => typeof entry === "string"
+    );
+  }
+  return [];
+}
+function uniquePackageRoots(packages) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    byPath.set(pkg.path, pkg);
+  }
+  return [...byPath.values()].sort((left, right) => right.path.length - left.path.length);
+}
+function isChangesetFile(file) {
+  return /^\.changeset\/(?!README\.md$)[^/]+\.md$/.test(file);
+}
+function isReleaseAffectingPackageFile(relativePath) {
+  if (/(^|\/)(__tests__|test|tests|spec|e2e)\//.test(relativePath) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(relativePath)) {
+    return false;
+  }
+  if (relativePath === "README.md" || relativePath === "CHANGELOG.md" || relativePath.startsWith("docs/") || relativePath.startsWith("dist/") || relativePath.startsWith("coverage/")) {
+    return false;
+  }
+  return /^(package\.json|src\/|lib\/|bin\/|templates\/|scripts\/|[^/]+\.config\.)/.test(
+    relativePath
+  );
+}
+function findPackageForFile(file, packageRoots) {
+  const normalized = normalizePath(file);
+  return packageRoots.find((pkg) => {
+    if (pkg.path === "") return true;
+    return normalized === pkg.path || normalized.startsWith(`${pkg.path}/`);
+  }) ?? null;
+}
+function analyzeChangesetRequirement(input) {
+  const changedFiles = input.changedFiles.map(normalizePath);
+  const hasChangeset = changedFiles.some(isChangesetFile);
+  const requiredFiles = changedFiles.flatMap((file) => {
+    if (file.startsWith(".changeset/")) return [];
+    const pkg = findPackageForFile(file, input.packageRoots);
+    if (!pkg) return [];
+    const relativePath = pkg.path === "" ? file : normalizePath(relative(pkg.path, file));
+    if (!isReleaseAffectingPackageFile(relativePath)) return [];
+    return [{ file, packageName: pkg.name }];
+  });
+  return { requiredFiles, hasChangeset };
+}
+async function requireChangesetCommand(options) {
+  const changedFiles = getChangedFiles(options);
+  if (changedFiles.length === 0) {
+    console.log(chalk11.green("\u2713 No changed files detected \u2014 no changeset required."));
+    return;
+  }
+  const packageRoots = discoverPackageRoots(options.include ?? []);
+  if (packageRoots.length === 0) {
+    console.log(chalk11.green("\u2713 No package roots detected \u2014 no changeset required."));
+    return;
+  }
+  const hasChangesetSetup = existsSync13(".changeset");
+  const { requiredFiles, hasChangeset } = analyzeChangesetRequirement({
+    changedFiles,
+    packageRoots
+  });
+  if (requiredFiles.length === 0) {
+    console.log(chalk11.green("\u2713 No release-affecting package files changed."));
+    return;
+  }
+  if (hasChangeset) {
+    console.log(chalk11.green("\u2713 Package changes include a changeset."));
+    return;
+  }
+  console.error(chalk11.red("\u2717 Package changes need a changeset."));
+  console.error("");
+  console.error(chalk11.bold("Changed package files:"));
+  for (const item of requiredFiles.slice(0, 12)) {
+    console.error(`  - ${item.file} (${item.packageName})`);
+  }
+  if (requiredFiles.length > 12) {
+    console.error(`  - \u2026and ${requiredFiles.length - 12} more`);
+  }
+  console.error("");
+  if (!hasChangesetSetup) {
+    console.error(
+      "No .changeset directory was found. Create one and add a changeset before finishing:"
+    );
+    console.error(chalk11.yellow("  mkdir -p .changeset"));
+  } else {
+    console.error("Add a changeset before finishing:");
+  }
+  console.error(chalk11.yellow("  pnpm changeset"));
+  console.error(chalk11.dim("  or add a .changeset/<name>.md file manually"));
+  process.exit(1);
+}
 
 // src/index.ts
 var program = new Command();
-program.name("holdpoint").description("Universal eval-guard for AI coding agents (alpha)").version("0.1.0-alpha.2");
-program.command("init").description("Initialise Holdpoint in the current project").option("--stack <stack>", "Stack type: typescript | python | nextjs | fullstack").option(
+program.name("holdpoint").description("Universal eval-guard for AI coding agents (alpha)").version(CLI_VERSION);
+program.action(() => {
+  program.outputHelp();
+});
+program.command("init").description("Initialise Holdpoint in the current project").option(
   "--agent <agent>",
   "Agent to install for: copilot | claude | cursor | codex (default: all four)"
 ).action(initCommand);
 program.command("check").description("Run task checks from checks.yaml").option("--staged", "Only check against git-staged files").action(checkCommand);
 program.command("validate").description("Validate checks.yaml schema and print any errors").action(validateCommand);
 program.command("update").description("Regenerate engine files from current checks.yaml (preserves checks.yaml)").action(updateCommand);
-program.command("builder").description("Open the visual builder UI on localhost:4321").action(buildCommand);
-program.command("evolve").description("Scan project and propose (or apply) new checks to keep checks.yaml in sync").option("--apply", "Write proposed changes to checks.yaml and regenerate engine files").action(evolveCommand);
+program.command("builder").description("Open the visual builder UI in the Holdpoint daemon").action(buildCommand);
+program.command("live").description("Open the Holdpoint Live UI").option("--project <project>", "Open the UI focused on a specific project hash").action(liveCommand);
+var daemon = program.command("daemon").description("Manage the Holdpoint Live daemon");
+daemon.command("start").description("Start or connect to the singleton Holdpoint Live daemon").action(daemonStartCommand);
+daemon.command("status").description("Show Holdpoint Live daemon status").action(daemonStatusCommand);
+daemon.command("stop").description("Stop the running Holdpoint Live daemon").action(daemonStopCommand);
+program.command("event").description("Internal: read event JSON from stdin and publish it to Holdpoint Live").option("--engine <engine>", "Engine name when converting native hook payloads").option("--from-hook", "Interpret stdin as an engine-native hook payload").action(eventCommand);
+program.command("engines").description("List discovered Holdpoint Live engine packages").option("--json", "Print machine-readable discovery output").action(enginesCommand);
+program.command("require-changeset").description("Ensure release-affecting package changes include a changeset").option("--staged", "Prefer git-staged files when deciding what changed").option(
+  "--include <pattern...>",
+  "Package directory glob(s) to enforce, e.g. packages/* apps/builder"
+).action(requireChangesetCommand);
+program.command("daemon-serve").description("Internal: run the Holdpoint Live daemon in the foreground").option("--port <port>", "Fixed port for the daemon process").action(daemonServeCommand);
+program.command("suggest").description("Scan project and propose (or apply) new checks to keep checks.yaml in sync").option("--apply", "Write proposed changes to checks.yaml and regenerate engine files").action(evolveCommand);
+program.command("evolve", { hidden: true }).description("Deprecated alias for `holdpoint suggest`").option("--apply", "Write proposed changes to checks.yaml and regenerate engine files").action(async (options) => {
+  process.stderr.write(
+    "warning: `holdpoint evolve` is deprecated; use `holdpoint suggest` instead.\n"
+  );
+  await evolveCommand(options);
+});
 program.parse();
 //# sourceMappingURL=index.js.map