@holdpoint/cli 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/index.js

@@ -4,20 +4,23 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+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 chalk from "chalk";
+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,20 +54,6 @@ 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/templates.ts
 import { copyFileSync, existsSync as existsSync2, writeFileSync } from "fs";
@@ -90,20 +87,239 @@ function ensureBundledFile(outputPath, templateFilename, fallbackContent) {
   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 = dirname2(fileURLToPath2(import.meta.url));
-function getTemplatePath(stack) {
-  const name = stack === "unknown" ? "_base" : stack;
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+function getDefaultTemplatePath() {
   const candidates = [
-    join2(__dirname2, "templates", `${name}.yaml`),
+    join2(__dirname2, "templates", "default.yaml"),
     // dist/templates/ (published package)
-    join2(__dirname2, "../../../templates", `${name}.yaml`),
+    join2(__dirname2, "../../../templates", "default.yaml"),
     // monorepo dev fallback
-    join2(process.cwd(), "templates", `${name}.yaml`)
+    join2(process.cwd(), "templates", "default.yaml")
     // cwd fallback
   ];
   for (const p of candidates) {
-    if (existsSync3(p)) return p;
+    if (existsSync4(p)) return p;
   }
   return "";
 }
@@ -125,11 +341,16 @@ 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 adapters for one or more AI coding agents. Before relying on them locally, review these setup notes:
+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.
 
@@ -137,72 +358,95 @@ 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 (!existsSync3("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);
     }
-    writeFileSync2("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 });
-  writeFileSync2(`${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 });
-    writeFileSync2(join2(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 (existsSync3(settingsPath)) {
+    if (existsSync4(settingsPath)) {
       try {
-        existing = JSON.parse(readFileSync2(settingsPath, "utf8"));
+        existing = JSON.parse(readFileSync3(settingsPath, "utf8"));
       } catch {
       }
     }
     const holdpointHooks = JSON.parse(buildClaudeEngineJson(config));
-    writeFileSync2(
+    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 (existsSync3(cursorPath)) {
-      const existing = readFileSync2(cursorPath, "utf8");
+    if (existsSync4(cursorPath)) {
+      const existing = readFileSync3(cursorPath, "utf8");
       if (!existing.includes("Holdpoint Rules")) {
-        writeFileSync2(cursorPath, existing + "\n" + cursorRules, "utf8");
+        writeFileSync3(cursorPath, `${existing.trimEnd()}
+
+${cursorRules}`, "utf8");
       }
     } else {
-      writeFileSync2(cursorPath, cursorRules, "utf8");
+      writeFileSync3(cursorPath, cursorRules, "utf8");
     }
+    spliceBreadcrumb(".cursor/rules/holdpoint.md");
   }
   if (agents.includes("codex")) {
-    mkdirSync(".codex", { recursive: true });
-    writeFileSync2(".codex/hooks.json", buildCodexHooksJson(config), "utf8");
-    writeFileSync2(".codex/holdpoint-check.mjs", buildCodexCheckScript(config), "utf8");
-    writeFileSync2(".codex/config.toml", buildCodexConfigToml(), "utf8");
-    const agentsMdPath = "AGENTS.md";
-    const existing = existsSync3(agentsMdPath) ? readFileSync2(agentsMdPath, "utf8") : "";
-    writeFileSync2(agentsMdPath, spliceAgentsMd(existing, config), "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",
@@ -210,44 +454,42 @@ async function initCommand(options) {
   );
   spinner.text = "Installing holdpoint as a devDependency\u2026";
   const installCmds = {
-    pnpm: "pnpm add -D holdpoint@alpha",
-    yarn: "yarn add --dev holdpoint@alpha",
-    npm: "npm install --save-dev holdpoint@alpha"
+    pnpm: "pnpm add -D holdpoint",
+    yarn: "yarn add --dev holdpoint",
+    npm: "npm install --save-dev holdpoint"
   };
   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. Review ${chalk.yellow("HOLDPOINT_PREREQUISITES.md")} for agent setup notes
-  3. Commit ${chalk.yellow("checks.yaml")}, ${chalk.yellow("HOLDPOINT_PREREQUISITES.md")}, and the generated engine files
-  4. 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
 
-${chalk.bgYellow.black(" Copilot local use ")} Run ${chalk.yellow("/experimental on")} in GitHub Copilot CLI so the
-${chalk.yellow("EXTENSIONS")} feature is enabled before using Holdpoint locally.
-See ${chalk.yellow("HOLDPOINT_PREREQUISITES.md")} for the full handoff notes.
-
-  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 existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
 import { join as join3 } from "path";
-import chalk2 from "chalk";
+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";
@@ -257,7 +499,7 @@ 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"]
     });
@@ -268,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"]
     });
@@ -279,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"]
     });
@@ -290,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();
@@ -300,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 {
@@ -311,18 +553,18 @@ function recordCommitCache(sha) {
   try {
     const existing = readCommitCache();
     const updated = [sha, ...[...existing].filter((s) => s !== sha)].slice(0, COMMIT_CACHE_MAX);
-    mkdirSync2(join3(COMMIT_CACHE_PATH, ".."), { recursive: true });
-    writeFileSync3(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(join3(CHECK_REPORTS_PATH, ".."), { recursive: true });
+    mkdirSync3(join3(CHECK_REPORTS_PATH, ".."), { recursive: true });
     let existing = { runs: [] };
-    if (existsSync4(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: [] };
@@ -331,21 +573,21 @@ function recordCheckReport(run) {
     const updated = {
       runs: [run, ...existing.runs].slice(0, CHECK_REPORTS_MAX)
     };
-    writeFileSync3(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 (!existsSync4("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();
@@ -358,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);
       }
@@ -367,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);
       }
     }
@@ -378,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."
         )
       );
@@ -389,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("");
   }
@@ -409,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(
@@ -419,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 = [
@@ -487,151 +729,195 @@ ${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 existsSync5, 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 (!existsSync5("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 existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, 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 adapters for one or more AI coding agents. Before relying on them locally, review these setup notes:
+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 (!existsSync6("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 });
-  writeFileSync4(`${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 });
-    writeFileSync4(`${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 (existsSync6(settingsPath)) {
+    if (existsSync7(settingsPath)) {
       try {
-        existing = JSON.parse(readFileSync5(settingsPath, "utf8"));
+        existing = JSON.parse(readFileSync6(settingsPath, "utf8"));
       } catch {
       }
     }
     const hooks = JSON.parse(buildClaudeEngineJson2(config));
-    writeFileSync4(
+    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 (existsSync6(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);
-        writeFileSync4(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 {
-        writeFileSync4(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 });
-    writeFileSync4(".codex/hooks.json", buildCodexHooksJson2(config), "utf8");
-    writeFileSync4(".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 (!existsSync6(configTomlPath)) {
-      writeFileSync4(configTomlPath, buildCodexConfigToml2(), "utf8");
+    if (!existsSync7(configTomlPath)) {
+      writeFileSync5(configTomlPath, buildCodexConfigToml2(), "utf8");
     } else {
-      const existing2 = readFileSync5(configTomlPath, "utf8");
-      if (!existing2.includes("[features]")) {
-        writeFileSync4(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 = existsSync6(agentsMdPath) ? readFileSync5(agentsMdPath, "utf8") : "";
-    writeFileSync4(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(chalk4.green("Engine files updated from current checks.yaml"));
+  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(
-      chalk4.cyan(
+      chalk5.cyan(
         "Created HOLDPOINT_PREREQUISITES.md with Copilot experimental-mode and other agent setup notes."
       )
     );
@@ -639,118 +925,131 @@ async function updateCommand() {
 }
 
 // src/commands/build.ts
-import { createServer } from "http";
-import { createReadStream, existsSync as existsSync7 } from "fs";
-import { join as join4, extname, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { execSync as execSync3 } from "child_process";
-import chalk5 from "chalk";
-var __dirname3 = dirname3(fileURLToPath3(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 = join4(process.cwd(), "checks.yaml");
-    if (existsSync7(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 = join4(process.cwd(), ".holdpoint", "check-reports.json");
-    if (existsSync7(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 = join4(uiDir, url === "/" ? "index.html" : url);
-  const filePath = existsSync7(candidate) ? candidate : join4(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 = join4(__dirname3, "builder-ui");
-  if (!existsSync7(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((resolve2, 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(() => resolve2());
-    });
-  });
+  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 existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } 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 existsSync8, readFileSync as readFileSync6, readdirSync } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync } from "fs";
 import { join as join5 } from "path";
-import { execSync as execSync4 } from "child_process";
+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) => existsSync8(join5(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(join5(cwd, "package.json"));
   const scripts = pkg?.scripts ?? {};
@@ -812,8 +1111,8 @@ function scanProject(cwd = process.cwd()) {
 }
 
 // src/evolve/dead-checker.ts
-import { execSync as execSync5 } from "child_process";
-import { readdirSync as readdirSync2, existsSync as existsSync9 } from "fs";
+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",
@@ -869,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"]
@@ -906,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 || !existsSync9(join6(process.cwd(), suggestedConditionPath));
+      const pathGone = !suggestedConditionPath || !existsSync10(join6(process.cwd(), suggestedConditionPath));
       if (pathGone) {
         stale.push({
           check,
@@ -925,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) ──────────────────
@@ -948,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 ──────────────────────────────────────────────
@@ -1107,20 +1409,20 @@ function withHeader(header, newYaml) {
   return header + "\n\n" + newYaml;
 }
 async function evolveCommand(options) {
-  if (!existsSync10("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();
@@ -1129,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.*"],
@@ -1155,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 suggest --apply")} to apply these changes.`
     );
     process.exit(1);
   }
@@ -1229,128 +1531,55 @@ async function evolveCommand(options) {
   };
   const header = extractHeader(yamlContent);
   const newYaml = withHeader(header, generateYaml(updatedConfig));
-  writeFileSync5("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 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 { existsSync as existsSync11 } from "fs";
-import { dirname as dirname4, join as join7 } from "path";
-import chalk7 from "chalk";
-import { identifyProject as identifyProject2 } from "@holdpoint/live-daemon";
-
-// 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 };
-    }
-    await sleep(100);
-  }
-  throw new Error("Daemon unavailable + cannot spawn");
-}
-
-// src/lib/open-browser.ts
-import { execSync as execSync7 } from "child_process";
-function openBrowser(url) {
-  const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  try {
-    execSync7(`${openCmd} ${JSON.stringify(url)}`, { stdio: "ignore" });
-  } catch {
-  }
-}
-
-// src/commands/live.ts
-function findChecksYaml(startDir) {
-  let current = startDir;
-  for (; ; ) {
-    const candidate = join7(current, "checks.yaml");
-    if (existsSync11(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;
-  }
-}
+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) {
-    baseUrl.searchParams.set("project", currentProject.hash);
-    baseUrl.searchParams.set("name", currentProject.name);
-    baseUrl.searchParams.set("root", currentProject.root);
+    appendProjectAuthParams(baseUrl, currentProject);
   }
   openBrowser(baseUrl.toString());
   console.log(
-    chalk7.green(
+    chalk8.green(
       started ? "\u2713 Started Holdpoint Live and opened the browser" : "\u2713 Opened Holdpoint Live"
     )
   );
-  console.log(`  url: ${chalk7.cyan(baseUrl.toString())}`);
+  console.log(`  url: ${chalk8.cyan(baseUrl.toString())}`);
 }
 
 // src/commands/daemon.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import {
   DaemonAlreadyRunningError,
   isProcessAlive,
@@ -1391,38 +1620,38 @@ 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(chalk8.green(`\u2713 ${headline}`));
-  console.log(`  pid: ${chalk8.cyan(String(info.pid))}`);
-  console.log(`  port: ${chalk8.cyan(String(info.port))}`);
-  console.log(`  uptime: ${chalk8.cyan(formatUptime(info))}`);
+  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: ${chalk8.cyan(String(sessionCount))}`);
+    console.log(`  sessions: ${chalk9.cyan(String(sessionCount))}`);
   }
 }
 async function daemonStatusCommand() {
   const lock = await readHealthyDaemonLock2();
   if (!lock) {
-    console.log(chalk8.yellow("Holdpoint Live daemon is not running."));
+    console.log(chalk9.yellow("Holdpoint Live daemon is not running."));
     return;
   }
   const sessionCount = await fetchSessionCount(lock);
-  console.log(chalk8.green("\u2713 Holdpoint Live daemon is running"));
-  console.log(`  pid: ${chalk8.cyan(String(lock.pid))}`);
-  console.log(`  port: ${chalk8.cyan(String(lock.port))}`);
-  console.log(`  uptime: ${chalk8.cyan(formatUptime(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: ${chalk8.cyan(String(sessionCount))}`);
+    console.log(`  sessions: ${chalk9.cyan(String(sessionCount))}`);
   }
 }
 async function daemonStopCommand() {
   const lock = readDaemonLock();
   if (!lock) {
-    console.log(chalk8.yellow("Holdpoint Live daemon is not running."));
+    console.log(chalk9.yellow("Holdpoint Live daemon is not running."));
     return;
   }
   if (!isProcessAlive(lock.pid)) {
     removeDaemonLock(void 0, lock.token);
-    console.log(chalk8.yellow("Removed stale Holdpoint Live lockfile."));
+    console.log(chalk9.yellow("Removed stale Holdpoint Live lockfile."));
     return;
   }
   process.kill(lock.pid, "SIGTERM");
@@ -1430,7 +1659,7 @@ async function daemonStopCommand() {
   while (Date.now() < deadline) {
     if (!isProcessAlive(lock.pid)) {
       removeDaemonLock(void 0, lock.token);
-      console.log(chalk8.green(`\u2713 Stopped Holdpoint Live daemon (${lock.pid})`));
+      console.log(chalk9.green(`\u2713 Stopped Holdpoint Live daemon (${lock.pid})`));
       return;
     }
     await sleep2(100);
@@ -1438,7 +1667,7 @@ async function daemonStopCommand() {
   process.kill(lock.pid, "SIGKILL");
   await sleep2(100);
   removeDaemonLock(void 0, lock.token);
-  console.log(chalk8.green(`\u2713 Force-stopped Holdpoint Live daemon (${lock.pid})`));
+  console.log(chalk9.green(`\u2713 Force-stopped Holdpoint Live daemon (${lock.pid})`));
 }
 async function daemonServeCommand(options) {
   try {
@@ -1456,20 +1685,24 @@ async function daemonServeCommand(options) {
 }
 
 // src/commands/engines.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 
 // src/engines.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname5, join as join8, resolve, sep } from "path";
+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 fileURLToPath4, pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import { parseEventV1 } from "@holdpoint/live-protocol";
 var require2 = createRequire(import.meta.url);
-var CLI_SRC_DIR = dirname5(fileURLToPath4(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"];
+var BUILTIN_LIVE_ENGINE_PACKAGES = [
+  "@holdpoint/engine-claude",
+  "@holdpoint/engine-codex",
+  "@holdpoint/engine-cursor"
+];
 var HOLDPOINT_ENGINE_KEYWORD = "holdpoint-engine";
-function isObject(value) {
+function isObject3(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function isExternalLiveEnginePackageName(packageName) {
@@ -1480,8 +1713,8 @@ function readJsonFile(path) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf8"));
-    return isObject(parsed) ? parsed : null;
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    return isObject3(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -1489,7 +1722,7 @@ function readJsonFile(path) {
 function findNearestPackageRoot(startDir) {
   let current = resolve(startDir);
   while (true) {
-    if (existsSync12(join8(current, "package.json"))) {
+    if (existsSync12(join7(current, "package.json"))) {
       return current;
     }
     const parent = dirname5(current);
@@ -1502,7 +1735,7 @@ function findNearestPackageRoot(startDir) {
 function findPackageRootFromFile(path) {
   let current = dirname5(path);
   while (true) {
-    if (existsSync12(join8(current, "package.json"))) {
+    if (existsSync12(join7(current, "package.json"))) {
       return current;
     }
     const parent = dirname5(current);
@@ -1513,14 +1746,14 @@ function findPackageRootFromFile(path) {
   }
 }
 function getDependencyEnginePackageNames(projectRoot) {
-  const packageJson = readJsonFile(join8(projectRoot, "package.json"));
+  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 (!isObject(deps)) {
+    if (!isObject3(deps)) {
       continue;
     }
     for (const packageName of Object.keys(deps)) {
@@ -1554,7 +1787,7 @@ function resolvePackageRoot(packageName, projectRoot) {
       const scopedName = packageName.split("/")[1];
       if (scopedName) {
         const packageDir = resolve(MONOREPO_ROOT, "packages", scopedName);
-        if (existsSync12(join8(packageDir, "package.json"))) {
+        if (existsSync12(join7(packageDir, "package.json"))) {
           return packageDir;
         }
       }
@@ -1566,7 +1799,7 @@ function formatImportError(error) {
   return error instanceof Error && error.message ? error.message : String(error);
 }
 function parseManifest(value) {
-  if (!isObject(value)) {
+  if (!isObject3(value)) {
     return null;
   }
   if (value.manifestVersion !== 1) {
@@ -1585,7 +1818,7 @@ function parseManifest(value) {
   };
 }
 function parseLiveCapabilities(value) {
-  if (!isObject(value)) {
+  if (!isObject3(value)) {
     return null;
   }
   const capabilities = {};
@@ -1608,7 +1841,7 @@ function parseLiveCapabilities(value) {
   return capabilities;
 }
 function parseLiveAdapter(value, manifest) {
-  if (!isObject(value)) {
+  if (!isObject3(value)) {
     return null;
   }
   if (typeof value.id !== "string" || typeof value.displayName !== "string") {
@@ -1674,7 +1907,7 @@ async function resolveCandidate(packageName, source, projectRoot) {
       reason: "package could not be resolved from this project"
     };
   }
-  const packageJson = readJsonFile(join8(packageRoot, "package.json"));
+  const packageJson = readJsonFile(join7(packageRoot, "package.json"));
   if (!packageJson) {
     return {
       packageName,
@@ -1692,7 +1925,7 @@ async function resolveCandidate(packageName, source, projectRoot) {
       reason: `missing \`${HOLDPOINT_ENGINE_KEYWORD}\` keyword`
     };
   }
-  const metadata = isObject(packageJson.holdpoint) ? packageJson.holdpoint : void 0;
+  const metadata = isObject3(packageJson.holdpoint) ? packageJson.holdpoint : void 0;
   if (!metadata?.manifest) {
     return {
       packageName,
@@ -1825,28 +2058,28 @@ async function enginesCommand(options = {}) {
     return;
   }
   if (engines.length === 0) {
-    console.log("No Holdpoint live adapters were discovered.");
+    console.log("No Holdpoint Live engines were discovered.");
     return;
   }
   for (const engine of engines) {
     if (engine.status === "loaded" && engine.manifest) {
       console.log(
-        `${chalk9.green("loaded")} ${chalk9.cyan(engine.manifest.id)} (${engine.manifest.displayName}) from ${chalk9.yellow(engine.packageName)} [${engine.source}]`
+        `${chalk10.green("loaded")} ${chalk10.cyan(engine.manifest.id)} (${engine.manifest.displayName}) from ${chalk10.yellow(engine.packageName)} [${engine.source}]`
       );
       continue;
     }
     console.log(
-      `${chalk9.yellow("ignored")} ${chalk9.yellow(engine.packageName)} [${engine.source}] \u2014 ${engine.reason ?? "unknown reason"}`
+      `${chalk10.yellow("ignored")} ${chalk10.yellow(engine.packageName)} [${engine.source}] \u2014 ${engine.reason ?? "unknown reason"}`
     );
   }
 }
 
 // src/commands/event.ts
-import { readFileSync as readFileSync9 } from "fs";
+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 readFileSync9(0, "utf8");
+  return readFileSync10(0, "utf8");
 }
 async function eventCommand(options) {
   const stdin = readStdin().trim();
@@ -1895,27 +2128,284 @@ async function eventCommand(options) {
   }
 }
 
+// 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(CLI_VERSION).action(() => {
-  void liveCommand();
+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("--stack <stack>", "Stack type: typescript | python | nextjs | fullstack").option(
+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("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 adapter packages").option("--json", "Print machine-readable discovery output").action(enginesCommand);
+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("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("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