@holdpoint/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/index.js

@@ -1,202 +1,626 @@
 #!/usr/bin/env node
+import {
+  detectInstalledAgents,
+  ensureBundledFile,
+  initCommand,
+  mergeClaudeSettings,
+  mergeCursorHooks,
+  spliceBreadcrumb
+} from "./chunk-COPLLMYJ.js";
 
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/init.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+// src/commands/check.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
 import chalk from "chalk";
 import ora from "ora";
-import { buildHookJson, buildCheckScript, buildConfigJson } from "@holdpoint/engine-copilot";
-import { buildEngineJson as buildClaudeEngineJson } from "@holdpoint/engine-claude";
-import { buildEngine as buildCursorEngine } from "@holdpoint/engine-cursor";
-import { parseHoldpointYaml } from "@holdpoint/yaml-core";
-
-// src/detect.ts
-import { existsSync } from "fs";
-function detectAgent() {
-  if (existsSync(".github/extensions")) return "copilot";
-  if (existsSync(".claude")) return "claude";
-  if (existsSync(".cursorrules")) return "cursor";
-  return "unknown";
-}
-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";
+import { parseHoldpointYaml, matchesWhen } from "@holdpoint/yaml-core";
+import { runDeterministicChecks } from "@holdpoint/yaml-core/runner";
+import { HOOK_EVENTS, checkHook } from "@holdpoint/types";
+import { execSync } 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 = execSync("git diff --cached --name-only", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
 }
-
-// src/commands/init.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function getTemplatePath(stack) {
-  const name = stack === "unknown" ? "_base" : stack;
-  const candidates = [
-    join(__dirname, "templates", `${name}.yaml`),
-    // dist/templates/ (published package)
-    join(__dirname, "../../../templates", `${name}.yaml`),
-    // monorepo dev fallback
-    join(process.cwd(), "templates", `${name}.yaml`)
-    // cwd fallback
-  ];
-  for (const p of candidates) {
-    if (existsSync2(p)) return p;
+function getAllChangedFiles() {
+  try {
+    const out = execSync("git diff --name-only HEAD", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
   }
-  return "";
 }
-function getMasterPromptPath() {
-  const candidates = [
-    join(__dirname, "templates/MASTER_PROMPT.md"),
-    // dist/templates/ (published package)
-    join(__dirname, "../../../templates/MASTER_PROMPT.md"),
-    // monorepo dev fallback
-    join(process.cwd(), "templates/MASTER_PROMPT.md")
-    // cwd fallback
+function getLastCommitFiles() {
+  try {
+    const out = execSync("git diff --name-only HEAD~1 HEAD", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getHeadSha() {
+  try {
+    return execSync("git rev-parse HEAD", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function readCommitCache() {
+  try {
+    const raw = readFileSync(COMMIT_CACHE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    return new Set(Array.isArray(parsed.verified) ? parsed.verified : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function recordCommitCache(sha) {
+  try {
+    const existing = readCommitCache();
+    const updated = [sha, ...[...existing].filter((s) => s !== sha)].slice(0, COMMIT_CACHE_MAX);
+    mkdirSync(join(COMMIT_CACHE_PATH, ".."), { recursive: true });
+    writeFileSync(COMMIT_CACHE_PATH, JSON.stringify({ verified: updated }, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+function recordCheckReport(run) {
+  try {
+    mkdirSync(join(CHECK_REPORTS_PATH, ".."), { recursive: true });
+    let existing = { runs: [] };
+    if (existsSync(CHECK_REPORTS_PATH)) {
+      try {
+        existing = JSON.parse(readFileSync(CHECK_REPORTS_PATH, "utf8"));
+        if (!Array.isArray(existing.runs)) existing.runs = [];
+      } catch {
+        existing = { runs: [] };
+      }
+    }
+    const updated = {
+      runs: [run, ...existing.runs].slice(0, CHECK_REPORTS_MAX)
+    };
+    writeFileSync(CHECK_REPORTS_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+async function checkCommand(options) {
+  const hook = options.hook && HOOK_EVENTS.includes(options.hook) ? options.hook : "before_done";
+  if (!existsSync("checks.yaml")) {
+    if (options.staged || !process.stdout.isTTY || !process.stdin.isTTY) {
+      console.error(chalk.red("No checks.yaml found. Run `holdpoint init` first."));
+      process.exit(1);
+    }
+    const { promptYesNo } = await import("./prompt-EQ5IFADN.js");
+    console.log(
+      chalk.yellow("No checks.yaml in this directory.") + chalk.dim(" (") + process.cwd() + chalk.dim(")")
+    );
+    const shouldInit = await promptYesNo(chalk.bold("Initialise Holdpoint here?"), true);
+    if (!shouldInit) {
+      console.error(chalk.dim("Skipped. Run `holdpoint init` when you're ready."));
+      process.exit(1);
+    }
+    const { initCommand: initCommand2 } = await import("./init-FNQ5GQBD.js");
+    await initCommand2({});
+    console.log(
+      chalk.dim("\nReview ") + chalk.yellow("checks.yaml") + chalk.dim(" and run ") + chalk.yellow("holdpoint check") + chalk.dim(" again when you're ready.")
+    );
+    return;
+  }
+  const yamlContent = readFileSync("checks.yaml", "utf8");
+  let config;
+  try {
+    config = parseHoldpointYaml(yamlContent);
+  } catch (err) {
+    console.error(chalk.red("Invalid checks.yaml:"), err.message);
+    process.exit(1);
+  }
+  const headSha = getHeadSha();
+  let changedFiles;
+  let usedHeadShaForCache = false;
+  if (options.staged) {
+    const staged = getStagedFiles();
+    if (staged.length > 0) {
+      changedFiles = staged;
+    } else {
+      if (headSha && readCommitCache().has(headSha)) {
+        console.log(
+          chalk.green(`\u2713 Commit ${headSha.slice(0, 8)} already verified \u2014 nothing to re-check.`)
+        );
+        process.exit(0);
+      }
+      const lastCommit = getLastCommitFiles();
+      if (lastCommit.length > 0) {
+        changedFiles = lastCommit;
+        usedHeadShaForCache = true;
+        console.log(
+          chalk.yellow("No staged files. Running checks scoped to the most recent commit's files.")
+        );
+      } else {
+        console.log(chalk.green("\u2713 No staged changes and no recent commit \u2014 nothing to check."));
+        process.exit(0);
+      }
+    }
+  } else {
+    changedFiles = getAllChangedFiles();
+    if (changedFiles.length === 0) {
+      console.log(
+        chalk.yellow("No changed files detected. Running all checks with no file filter.")
+      );
+      console.log(
+        chalk.dim(
+          "  Tip: if you just ran `holdpoint init`, commit the generated files to clear the git-commit check."
+        )
+      );
+    }
+  }
+  const guides = Object.entries(config.context?.guides ?? {});
+  if (guides.length > 0) {
+    console.log(chalk.cyan("\nProject guides:"));
+    for (const [key, text] of guides) {
+      console.log(chalk.bold(`  ${key}:`), chalk.dim(String(text).trim()));
+    }
+    console.log("");
+  }
+  const taskCount = config.checks.filter(
+    (c) => c.cmd !== void 0 && checkHook(c) === hook
+  ).length;
+  const spinner = ora(`Running ${taskCount} task(s)\u2026`).start();
+  const effectiveFiles = changedFiles.length > 0 ? changedFiles : ["__all__"];
+  const results = runDeterministicChecks(config, effectiveFiles, hook);
+  const passed = results.filter((r) => r.status === "pass");
+  const failed = results.filter((r) => r.status === "fail");
+  const skipped = results.filter((r) => r.status === "skip");
+  spinner.stop();
+  for (const result of results) {
+    printResult(result);
+  }
+  console.log("");
+  console.log(
+    [
+      chalk.green(`\u2713 ${passed.length} passed`),
+      failed.length > 0 ? chalk.red(`\u2717 ${failed.length} failed`) : "",
+      skipped.length > 0 ? chalk.gray(`\u25CC ${skipped.length} skipped`) : ""
+    ].filter(Boolean).join("  ")
+  );
+  const promptChecks = changedFiles.length > 0 ? config.checks.filter(
+    (c) => c.prompt !== void 0 && checkHook(c) === hook && matchesWhen(c.when, changedFiles, config.patterns)
+  ) : [];
+  if (promptChecks.length > 0) {
+    console.log(`
+${chalk.cyan("Agent prompts to act on:")}`);
+    for (const c of promptChecks) {
+      console.log(`  ${chalk.yellow("\u25A1")} [${c.label}] ${c.prompt ?? ""}`);
+    }
+  } else if (changedFiles.length === 0) {
+    const totalPromptChecks = config.checks.filter((c) => c.prompt !== void 0).length;
+    if (totalPromptChecks > 0) {
+      console.log(
+        chalk.dim(
+          `
+  (${totalPromptChecks} prompt-style checks defined; they fire relative to changed files \u2014 none surfaced with no diff context)`
+        )
+      );
+    }
+  }
+  const reportResults = [
+    ...results.map((r) => ({
+      id: r.check.id,
+      label: r.check.label,
+      kind: "cmd",
+      status: r.status,
+      ...r.output !== void 0 ? { output: r.output } : {},
+      ...r.exitCode !== void 0 ? { exitCode: r.exitCode } : {},
+      ...r.skipReason !== void 0 ? { skipReason: r.skipReason } : {}
+    })),
+    ...promptChecks.map((c) => ({
+      id: c.id,
+      label: c.label,
+      kind: "prompt",
+      status: "shown"
+    }))
   ];
-  for (const p of candidates) {
-    if (existsSync2(p)) return p;
-  }
-  return "";
-}
-var MINIMAL_CHECKS_YAML = `version: 1
-context:
-  guides: {}
-conditions: []
-checks:
-  - id: lint
-    label: "Lint codebase"
-    cmd: "echo 'Add your lint command here'"
+  const run = {
+    sha: headSha,
+    shortSha: headSha ? headSha.slice(0, 8) : null,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    files: changedFiles.length > 0 ? changedFiles : [],
+    results: reportResults,
+    summary: {
+      passed: passed.length,
+      failed: failed.length,
+      skipped: skipped.length,
+      shown: promptChecks.length
+    }
+  };
+  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);
+  }
+  if (usedHeadShaForCache && headSha) {
+    recordCommitCache(headSha);
+  }
+}
+function printResult(result) {
+  const icon = result.status === "pass" ? chalk.green("\u2713") : result.status === "fail" ? chalk.red("\u2717") : result.status === "skip" ? chalk.gray("\u25CC") : chalk.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(chalk.dim(trimmed.replace(/^/gm, "    ")));
+  }
+  if (result.status === "skip" && result.skipReason) {
+    console.log(chalk.dim(`    ${result.skipReason}`));
+  }
+}
 
-  - id: jsdoc
-    label: "JSDoc on changed public functions"
-    prompt: "Ensure all changed public functions and exports have JSDoc comments."
-`;
-async function initCommand(options) {
-  const spinner = ora("Initialising Holdpoint\u2026").start();
-  const stack = options.stack ?? detectStack();
-  const agent = options.agent ?? detectAgent();
-  spinner.text = `Detected stack: ${chalk.cyan(stack)}, agent: ${chalk.cyan(agent)}`;
-  let yamlContent = MINIMAL_CHECKS_YAML;
+// src/commands/validate.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import chalk2 from "chalk";
+import { parseHoldpointYaml as parseHoldpointYaml2, validateConfig } from "@holdpoint/yaml-core";
+async function validateCommand() {
   if (!existsSync2("checks.yaml")) {
-    const templatePath = getTemplatePath(stack);
-    if (templatePath) {
-      yamlContent = readFileSync(templatePath, "utf8");
-    }
-    writeFileSync("checks.yaml", yamlContent, "utf8");
+    console.error(chalk2.red("No checks.yaml found. Run `holdpoint init` first."));
+    process.exit(1);
+  }
+  const text = readFileSync2("checks.yaml", "utf8");
+  let config;
+  try {
+    config = parseHoldpointYaml2(text);
+  } catch (err) {
+    console.error(chalk2.red("Parse error:"), err.message);
+    process.exit(1);
+  }
+  const result = validateConfig(config);
+  if (result.valid) {
+    console.log(chalk2.green("\u2713 checks.yaml is valid"));
+    console.log(
+      chalk2.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 {
-    yamlContent = readFileSync("checks.yaml", "utf8");
+    console.error(chalk2.red("\u2717 checks.yaml has errors:"));
+    for (const err of result.errors) {
+      console.error(`  ${chalk2.yellow(err.path)}: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/update.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import { parseHoldpointYaml as parseHoldpointYaml3 } from "@holdpoint/yaml-core";
+import { buildConfigJson, buildEngine } from "@holdpoint/engine-copilot";
+import { buildEngineJson as buildClaudeEngineJson } from "@holdpoint/engine-claude";
+import {
+  buildCheckScript as buildCursorCheckScript,
+  buildEngine as buildCursorEngine,
+  buildHooksJson as buildCursorHooksJson
+} from "@holdpoint/engine-cursor";
+import {
+  buildConfigToml as buildCodexConfigToml,
+  buildHooksJson as buildCodexHooksJson,
+  buildCheckScript as buildCodexCheckScript
+} from "@holdpoint/engine-codex";
+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
+`;
+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.
+`;
+async function updateCommand() {
+  if (!existsSync3("checks.yaml")) {
+    console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
+    process.exit(1);
   }
-  const config = parseHoldpointYaml(yamlContent);
+  const spinner = ora2("Updating Holdpoint engine files\u2026").start();
+  const config = parseHoldpointYaml3(readFileSync3("checks.yaml", "utf8"));
+  const detected = detectInstalledAgents();
+  const agents = detected.length > 0 ? detected : ["copilot", "claude", "cursor", "codex"];
   const generatedDir = ".github/holdpoint/generated";
-  mkdirSync(generatedDir, { recursive: true });
-  writeFileSync(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
-  if (agent === "copilot" || agent === "unknown") {
-    const hooksDir = ".github/hooks";
-    mkdirSync(hooksDir, { recursive: true });
-    writeFileSync(join(hooksDir, "holdpoint.json"), buildHookJson(config), "utf8");
-    writeFileSync(join(hooksDir, "holdpoint-check.mjs"), buildCheckScript(config), "utf8");
-  }
-  if (agent === "claude") {
-    mkdirSync(".claude", { recursive: true });
+  mkdirSync2(generatedDir, { recursive: true });
+  writeFileSync2(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
+  if (agents.includes("copilot")) {
+    const extDir = ".github/extensions/holdpoint";
+    mkdirSync2(extDir, { recursive: true });
+    writeFileSync2(`${extDir}/extension.mjs`, buildEngine(config), "utf8");
+    spliceBreadcrumb(".github/copilot-instructions.md");
+  }
+  if (agents.includes("claude")) {
+    mkdirSync2(".claude", { recursive: true });
     const settingsPath = ".claude/settings.json";
     let existing = {};
-    if (existsSync2(settingsPath)) {
+    if (existsSync3(settingsPath)) {
       try {
-        existing = JSON.parse(readFileSync(settingsPath, "utf8"));
+        existing = JSON.parse(readFileSync3(settingsPath, "utf8"));
       } catch {
       }
     }
-    const holdpointHooks = JSON.parse(buildClaudeEngineJson(config));
-    writeFileSync(
+    const hooks = JSON.parse(buildClaudeEngineJson(config));
+    writeFileSync2(
       settingsPath,
-      JSON.stringify({ ...existing, hooks: holdpointHooks.hooks }, null, 2),
-      "utf8"
+      JSON.stringify(mergeClaudeSettings(existing, hooks), null, 2) + "\n"
     );
+    spliceBreadcrumb("CLAUDE.md");
   }
-  if (agent === "cursor") {
+  if (agents.includes("cursor")) {
+    mkdirSync2(".cursor", { recursive: true });
+    const cursorHooksPath = ".cursor/hooks.json";
+    let existingHooks = {};
+    if (existsSync3(cursorHooksPath)) {
+      try {
+        existingHooks = JSON.parse(readFileSync3(cursorHooksPath, "utf8"));
+      } catch {
+      }
+    }
+    const cursorHooks = JSON.parse(buildCursorHooksJson(config));
+    writeFileSync2(
+      cursorHooksPath,
+      JSON.stringify(mergeCursorHooks(existingHooks, cursorHooks), null, 2) + "\n",
+      "utf8"
+    );
+    writeFileSync2(".cursor/holdpoint-hook.mjs", buildCursorCheckScript(), "utf8");
     const cursorRules = buildCursorEngine(config);
     const cursorPath = ".cursorrules";
-    if (existsSync2(cursorPath)) {
-      const existing = readFileSync(cursorPath, "utf8");
-      if (!existing.includes("Holdpoint Rules")) {
-        writeFileSync(cursorPath, existing + "\n" + cursorRules, "utf8");
+    if (existsSync3(cursorPath)) {
+      const content = readFileSync3(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 prefix = content.slice(0, start).trimEnd();
+        const suffix = content.slice(afterEnd === -1 ? end : afterEnd + 1).trimStart();
+        const updated = (prefix ? `${prefix}
+
+` : "") + cursorRules + (suffix ? `
+${suffix}` : "");
+        writeFileSync2(cursorPath, updated);
+      } else {
+        writeFileSync2(cursorPath, `${content.trimEnd()}
+
+${cursorRules}`);
       }
     } else {
-      writeFileSync(cursorPath, cursorRules, "utf8");
+      writeFileSync2(cursorPath, cursorRules);
     }
+    spliceBreadcrumb(".cursor/rules/holdpoint.md");
   }
-  if (!existsSync2("MASTER_PROMPT.md")) {
-    const guidePath = getMasterPromptPath();
-    if (guidePath) {
-      copyFileSync(guidePath, "MASTER_PROMPT.md");
+  if (agents.includes("codex")) {
+    mkdirSync2(".codex", { recursive: true });
+    writeFileSync2(".codex/hooks.json", buildCodexHooksJson(config), "utf8");
+    writeFileSync2(".codex/holdpoint-check.mjs", buildCodexCheckScript(config), "utf8");
+    const configTomlPath = ".codex/config.toml";
+    if (!existsSync3(configTomlPath)) {
+      writeFileSync2(configTomlPath, buildCodexConfigToml(), "utf8");
     } else {
-      writeFileSync(
-        "MASTER_PROMPT.md",
-        "# Holdpoint\n\nRun `npx @holdpoint/cli@alpha check` before marking any task complete.\nSee `checks.yaml` for the full list of checks.\n",
-        "utf8"
-      );
+      const existing = readFileSync3(configTomlPath, "utf8");
+      if (!existing.includes("[features]")) {
+        writeFileSync2(configTomlPath, existing.trimEnd() + "\n\n" + buildCodexConfigToml(), "utf8");
+      }
+    }
+    spliceBreadcrumb("AGENTS.md");
+  }
+  const wroteReference = ensureBundledFile(
+    "HOLDPOINT_REFERENCE.md",
+    "HOLDPOINT_REFERENCE.md",
+    MINIMAL_HOLDPOINT_REFERENCE
+  );
+  const wrotePrerequisites = ensureBundledFile(
+    "HOLDPOINT_PREREQUISITES.md",
+    "HOLDPOINT_PREREQUISITES.md",
+    MINIMAL_PREREQUISITES
+  );
+  spinner.succeed(chalk3.green("Engine files updated from current checks.yaml"));
+  if (wroteReference) {
+    console.log(
+      chalk3.cyan("Created HOLDPOINT_REFERENCE.md with the full Holdpoint workflow reference.")
+    );
+  }
+  if (wrotePrerequisites) {
+    console.log(
+      chalk3.cyan(
+        "Created HOLDPOINT_PREREQUISITES.md with Copilot experimental-mode and other agent setup notes."
+      )
+    );
+  }
+}
+
+// src/commands/build.ts
+import chalk4 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 };
     }
+    await sleep(100);
   }
-  spinner.succeed(chalk.bold.green("Holdpoint initialised!"));
-  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("npx @holdpoint/cli@alpha check")} at any time to validate
+  throw new Error("Daemon unavailable + cannot spawn");
+}
 
-  Visual builder: ${chalk.yellow("npx @holdpoint/cli@alpha builder")}  (opens localhost:4321)
-  Stack: ${chalk.cyan(stack)}  Agent: ${chalk.cyan(agent)}
-`);
+// src/lib/open-browser.ts
+import { execSync as execSync2 } from "child_process";
+function openBrowser(url) {
+  const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    execSync2(`${openCmd} ${JSON.stringify(url)}`, { stdio: "ignore" });
+  } catch {
+  }
 }
 
-// src/commands/check.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import chalk2 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 execSync3 } from "child_process";
+// src/lib/project.ts
+import { existsSync as existsSync4 } from "fs";
+import { dirname, join as join2 } from "path";
+import { identifyProject as identifyProject2 } from "@holdpoint/live-daemon";
+function findChecksYaml(startDir) {
+  let current = startDir;
+  for (; ; ) {
+    const candidate = join2(current, "checks.yaml");
+    if (existsSync4(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function tryResolveCurrentProject() {
+  const checksYaml = findChecksYaml(process.cwd());
+  if (checksYaml) {
+    return identifyProject2(dirname(checksYaml));
+  }
+  try {
+    return identifyProject2(process.cwd());
+  } catch {
+    return null;
+  }
+}
+function appendProjectAuthParams(url, project) {
+  if (!project) {
+    return;
+  }
+  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 { 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", "/live/");
+  url.searchParams.set("tab", "checks");
+  appendProjectAuthParams(url, tryResolveCurrentProject());
+  openBrowser(url.toString());
+  console.log(
+    chalk4.green(
+      started ? "\u2713 Started Holdpoint Live and opened the builder" : "\u2713 Opened Holdpoint builder"
+    )
+  );
+  console.log(`  url: ${chalk4.cyan(url.toString())}`);
+}
+
+// src/commands/evolve.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { execSync as execSync5 } from "child_process";
+import chalk5 from "chalk";
+import ora3 from "ora";
+import { parseHoldpointYaml as parseHoldpointYaml4, generateYaml } from "@holdpoint/yaml-core";
 
 // src/evolve/scanner.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync } from "fs";
-import { join as join2 } from "path";
-import { execSync } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync } from "fs";
+import { join as join3 } from "path";
+import { execSync as execSync3 } from "child_process";
 function tryReadJson(path) {
   try {
-    return JSON.parse(readFileSync2(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return null;
   }
 }
 function tryReadText(path) {
   try {
-    return readFileSync2(path, "utf8");
+    return readFileSync4(path, "utf8");
   } catch {
     return "";
   }
 }
 function scanProject(cwd = process.cwd()) {
-  const exists = (p) => existsSync3(join2(cwd, p));
+  const exists = (p) => existsSync5(join3(cwd, p));
   const packageManager = exists("pnpm-lock.yaml") ? "pnpm" : exists("yarn.lock") ? "yarn" : exists("bun.lockb") ? "bun" : "npm";
-  const pkg = tryReadJson(join2(cwd, "package.json"));
+  const pkg = tryReadJson(join3(cwd, "package.json"));
   const scripts = pkg?.scripts ?? {};
   const deps = /* @__PURE__ */ new Set([
     ...Object.keys(pkg?.dependencies ?? {}),
     ...Object.keys(pkg?.devDependencies ?? {})
   ]);
-  const pyprojectText = tryReadText(join2(cwd, "pyproject.toml"));
-  const requirementsText = tryReadText(join2(cwd, "requirements.txt"));
-  const pipfileText = tryReadText(join2(cwd, "Pipfile"));
+  const pyprojectText = tryReadText(join3(cwd, "pyproject.toml"));
+  const requirementsText = tryReadText(join3(cwd, "requirements.txt"));
+  const pipfileText = tryReadText(join3(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");
@@ -241,23 +665,138 @@ function scanProject(cwd = process.cwd()) {
     hasOpenApi: exists("openapi.yaml") || exists("openapi.yml") || exists("openapi.json") || exists("api/openapi.yaml"),
     // CI
     hasGithubActions: exists(".github/workflows"),
+    // Release tooling — gates the `changelog-update` suggest template,
+    // since projects using changesets get release notes from .changeset
+    // files automatically and don't want a manual-CHANGELOG-entry check.
+    hasChangesets: exists(".changeset/config.json"),
     packageManager,
     scripts,
     deps
   };
 }
 
-// src/evolve/templates.ts
-function pmScript(profile, script, fallback) {
-  if (!profile.scripts[script]) return fallback;
-  if (profile.packageManager === "npm") return `npm run ${script}`;
-  return `${profile.packageManager} ${script}`;
-}
-function getTemplates(profile) {
-  return [
-    // ── Universal checks (always proposed for any project) ──────────────────
-    {
-      id: "git-commit",
+// src/evolve/dead-checker.ts
+import { execSync as execSync4 } from "child_process";
+import { readdirSync as readdirSync2, existsSync as existsSync6 } from "fs";
+import { join as join4 } from "path";
+var NAMED_SCOPES = /* @__PURE__ */ new Set([
+  "frontend",
+  "backend",
+  "socket",
+  "visual",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "ruby",
+  "database",
+  "prisma",
+  "testing",
+  "infra",
+  "ci",
+  "docs",
+  "structural"
+]);
+var WALK_IGNORED = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".mypy_cache",
+  "target",
+  ".cache",
+  "coverage"
+]);
+function walkDir(dir, root, depth, maxDepth) {
+  if (depth > maxDepth) return [];
+  let entries = [];
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (WALK_IGNORED.has(entry) || entry.startsWith(".")) continue;
+    const full = join4(dir, entry);
+    const rel = full.slice(root.length + 1);
+    results.push(rel);
+    const children = walkDir(full, root, depth + 1, maxDepth);
+    results.push(...children);
+  }
+  return results;
+}
+function getRepoFiles(cwd) {
+  try {
+    const out = execSync4("git ls-files", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const files = out.trim().split("\n").filter(Boolean);
+    if (files.length > 0) return files;
+  } catch {
+  }
+  return walkDir(cwd, cwd, 0, 6);
+}
+function extractPathFromRegex(pattern) {
+  const cleaned = pattern.replace(/^\^/, "").replace(/\$$/, "").replace(/\\\./g, ".").replace(/\(\?:/g, "").replace(/\)/g, "").replace(/[|*+?[\]{}()]/g, "");
+  const candidate = cleaned.replace(/\/$/, "").trim();
+  if (candidate.length > 0 && /^[\w\-./]+$/.test(candidate)) return candidate;
+  return void 0;
+}
+function detectStaleChecks(config, repoFiles) {
+  const stale = [];
+  const userPatterns = config.patterns ?? {};
+  for (const check of config.checks) {
+    if (!check.when) continue;
+    if (NAMED_SCOPES.has(check.when)) continue;
+    if (check.conditionId) continue;
+    const patternAlias = check.when in userPatterns ? check.when : void 0;
+    const regexStr = patternAlias ? userPatterns[patternAlias] : check.when;
+    let re;
+    try {
+      re = new RegExp(regexStr);
+    } catch {
+      stale.push({ check, reason: `Invalid regex: '${regexStr}'` });
+      continue;
+    }
+    const matches = repoFiles.filter((f) => re.test(f));
+    if (matches.length === 0) {
+      const label = patternAlias ? `Pattern '${patternAlias}' (= '${regexStr}')` : `Regex '${regexStr}'`;
+      const suggestedConditionPath = extractPathFromRegex(regexStr);
+      const pathGone = !suggestedConditionPath || !existsSync6(join4(process.cwd(), suggestedConditionPath));
+      if (pathGone) {
+        stale.push({
+          check,
+          reason: `${label} matches 0 files in the repo`,
+          ...suggestedConditionPath ? { suggestedConditionPath } : {}
+        });
+      }
+    }
+  }
+  return stale;
+}
+
+// src/evolve/templates.ts
+function pmScript(profile, script, fallback) {
+  if (!profile.scripts[script]) return 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) ──────────────────
+    {
+      id: "git-commit",
       label: "Commit all changes before finishing",
       cmd: 'git rev-parse --is-inside-work-tree 2>/dev/null || exit 0; [ -z "$(git status --porcelain)" ] && exit 0; git status --short; exit 1',
       trigger: () => true
@@ -266,7 +805,11 @@ function getTemplates(profile) {
       id: "changelog-update",
       label: "Add a CHANGELOG.md entry for this session",
       prompt: "Before committing, add an entry to CHANGELOG.md describing what was done. Use Keep a Changelog format \u2014 add under ## [Unreleased] (create the file and that section if absent). Group entries as Added, Changed, Fixed, or Removed. Be concise but specific. The entry text will serve as the commit message.",
-      trigger: () => true
+      // Don't propose this for changesets-using projects — those get
+      // release notes from .changeset/*.md files automatically and the
+      // sibling `changelog-changeset` check is what they should use
+      // instead. Proposing both would be confusing and contradictory.
+      trigger: (p) => !p.hasChangesets
     },
     {
       id: "readme-sync",
@@ -276,8 +819,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 ──────────────────────────────────────────────
@@ -414,441 +957,41 @@ function getTemplates(profile) {
   ];
 }
 
-// src/evolve/dead-checker.ts
-import { execSync as execSync2 } from "child_process";
-import { readdirSync as readdirSync2, existsSync as existsSync4 } from "fs";
-import { join as join3 } from "path";
-var NAMED_SCOPES = /* @__PURE__ */ new Set([
-  "frontend",
-  "backend",
-  "socket",
-  "visual",
-  "python",
-  "go",
-  "rust",
-  "java",
-  "ruby",
-  "database",
-  "prisma",
-  "testing",
-  "infra",
-  "ci",
-  "docs",
-  "structural"
-]);
-var WALK_IGNORED = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  ".next",
-  ".turbo",
-  "__pycache__",
-  ".venv",
-  "venv",
-  ".mypy_cache",
-  "target",
-  ".cache",
-  "coverage"
-]);
-function walkDir(dir, root, depth, maxDepth) {
-  if (depth > maxDepth) return [];
-  let entries = [];
-  try {
-    entries = readdirSync2(dir);
-  } catch {
-    return [];
-  }
-  const results = [];
-  for (const entry of entries) {
-    if (WALK_IGNORED.has(entry) || entry.startsWith(".")) continue;
-    const full = join3(dir, entry);
-    const rel = full.slice(root.length + 1);
-    results.push(rel);
-    const children = walkDir(full, root, depth + 1, maxDepth);
-    results.push(...children);
-  }
-  return results;
-}
-function getRepoFiles(cwd) {
-  try {
-    const out = execSync2("git ls-files", {
-      cwd,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "ignore"]
-    });
-    const files = out.trim().split("\n").filter(Boolean);
-    if (files.length > 0) return files;
-  } catch {
-  }
-  return walkDir(cwd, cwd, 0, 6);
-}
-function extractPathFromRegex(pattern) {
-  const cleaned = pattern.replace(/^\^/, "").replace(/\$$/, "").replace(/\\\./g, ".").replace(/\(\?:/g, "").replace(/\)/g, "").replace(/[|*+?[\]{}()]/g, "");
-  const candidate = cleaned.replace(/\/$/, "").trim();
-  if (candidate.length > 0 && /^[\w\-./]+$/.test(candidate)) return candidate;
-  return void 0;
-}
-function detectStaleChecks(config, repoFiles) {
-  const stale = [];
-  const userPatterns = config.patterns ?? {};
-  for (const check of config.checks) {
-    if (!check.when) continue;
-    if (NAMED_SCOPES.has(check.when)) continue;
-    if (check.conditionId) continue;
-    const patternAlias = check.when in userPatterns ? check.when : void 0;
-    const regexStr = patternAlias ? userPatterns[patternAlias] : check.when;
-    let re;
-    try {
-      re = new RegExp(regexStr);
-    } catch {
-      stale.push({ check, reason: `Invalid regex: '${regexStr}'` });
-      continue;
-    }
-    const matches = repoFiles.filter((f) => re.test(f));
-    if (matches.length === 0) {
-      const label = patternAlias ? `Pattern '${patternAlias}' (= '${regexStr}')` : `Regex '${regexStr}'`;
-      const suggestedConditionPath = extractPathFromRegex(regexStr);
-      const pathGone = !suggestedConditionPath || !existsSync4(join3(process.cwd(), suggestedConditionPath));
-      if (pathGone) {
-        stale.push({
-          check,
-          reason: `${label} matches 0 files in the repo`,
-          ...suggestedConditionPath ? { suggestedConditionPath } : {}
-        });
-      }
+// src/commands/evolve.ts
+function extractHeader(yaml) {
+  const lines = yaml.split("\n");
+  const commentLines = [];
+  for (const line of lines) {
+    if (line.startsWith("#") || commentLines.length > 0 && line.trim() === "") {
+      commentLines.push(line);
+    } else {
+      break;
     }
   }
-  return stale;
-}
-
-// src/commands/check.ts
-function getStagedFiles() {
-  try {
-    const out = execSync3("git diff --cached --name-only", {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "ignore"]
-    });
-    return out.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
+  while (commentLines.length > 0 && commentLines[commentLines.length - 1]?.trim() === "") {
+    commentLines.pop();
   }
+  return commentLines.join("\n");
 }
-function getAllChangedFiles() {
-  try {
-    const out = execSync3("git diff --name-only HEAD", {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "ignore"]
-    });
-    return out.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
-  }
+function withHeader(header, newYaml) {
+  if (!header) return newYaml;
+  return header + "\n\n" + newYaml;
 }
-async function checkCommand(options) {
-  if (!existsSync5("checks.yaml")) {
-    console.error(chalk2.red("No checks.yaml found. Run `holdpoint init` first."));
+async function evolveCommand(options) {
+  if (!existsSync7("checks.yaml")) {
+    console.error(chalk5.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
-  const yamlContent = readFileSync3("checks.yaml", "utf8");
-  let config;
-  try {
-    config = parseHoldpointYaml2(yamlContent);
-  } catch (err) {
-    console.error(chalk2.red("Invalid checks.yaml:"), err.message);
-    process.exit(1);
-  }
-  const changedFiles = options.staged ? getStagedFiles() : getAllChangedFiles();
-  const guides = Object.entries(config.context?.guides ?? {});
-  if (guides.length > 0) {
-    console.log(chalk2.cyan("\nProject guides:"));
-    for (const [key, text] of guides) {
-      console.log(chalk2.bold(`  ${key}:`), chalk2.dim(String(text).trim()));
-    }
-    console.log("");
-  }
-  if (changedFiles.length === 0) {
-    console.log(chalk2.yellow("No changed files detected. Running all checks with no file filter."));
-  }
-  const taskCount = config.checks.filter((c) => c.cmd !== void 0).length;
-  const spinner = ora2(`Running ${taskCount} task(s)\u2026`).start();
-  const effectiveFiles = changedFiles.length > 0 ? changedFiles : ["__all__"];
-  const results = runDeterministicChecks(config, effectiveFiles);
-  const runDrift = matchesWhen("structural", effectiveFiles);
-  if (runDrift) {
-    const profile = scanProject();
-    const existingIds = new Set(config.checks.map((c) => c.id));
-    const templates = getTemplates(profile);
-    const proposals = templates.filter((t) => t.trigger(profile) && !existingIds.has(t.id));
-    const repoFiles = getRepoFiles(process.cwd());
-    const staleChecks = detectStaleChecks(config, repoFiles);
-    if (proposals.length > 0 || staleChecks.length > 0) {
-      const lines = [];
-      if (proposals.length > 0) {
-        lines.push(`${proposals.length} new check(s) available for your project stack:`);
-        for (const p of proposals) lines.push(`  + ${p.label}`);
-      }
-      if (staleChecks.length > 0) {
-        lines.push(`${staleChecks.length} stale check(s) no longer match your project:`);
-        for (const s of staleChecks) lines.push(`  - ${s.check.label}: ${s.reason}`);
-      }
-      lines.push("\nRun: npx @holdpoint/cli@alpha evolve --apply");
-      results.push({
-        check: { id: "__holdpoint_evolve__", label: "Evolve checks with project structure" },
-        status: "fail",
-        output: lines.join("\n")
-      });
-    }
-  }
-  const passed = results.filter((r) => r.status === "pass");
-  const failed = results.filter((r) => r.status === "fail");
-  const skipped = results.filter((r) => r.status === "skip");
-  spinner.stop();
-  for (const result of results) {
-    printResult(result);
-  }
-  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`) : ""
-    ].filter(Boolean).join("  ")
-  );
-  const promptChecks = config.checks.filter(
-    (c) => c.prompt !== void 0 && matchesWhen(c.when, changedFiles.length > 0 ? changedFiles : ["__all__"], config.patterns)
-  );
-  if (promptChecks.length > 0) {
-    console.log(`
-${chalk2.cyan("Agent prompts to act on:")}`);
-    for (const c of promptChecks) {
-      console.log(`  ${chalk2.yellow("\u25A1")} [${c.label}] ${c.prompt ?? ""}`);
-    }
-  }
-  if (failed.length > 0) {
-    process.exit(1);
-  }
-}
-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 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, "    ")));
-  }
-  if (result.status === "skip" && result.skipReason) {
-    console.log(chalk2.dim(`    ${result.skipReason}`));
-  }
-}
-
-// src/commands/validate.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import chalk3 from "chalk";
-import { parseHoldpointYaml as parseHoldpointYaml3, validateConfig } from "@holdpoint/yaml-core";
-async function validateCommand() {
-  if (!existsSync6("checks.yaml")) {
-    console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
-    process.exit(1);
-  }
-  const text = readFileSync4("checks.yaml", "utf8");
-  let config;
-  try {
-    config = parseHoldpointYaml3(text);
-  } catch (err) {
-    console.error(chalk3.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(
-      chalk3.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:"));
-    for (const err of result.errors) {
-      console.error(`  ${chalk3.yellow(err.path)}: ${err.message}`);
-    }
-    process.exit(1);
-  }
-}
-
-// src/commands/update.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import chalk4 from "chalk";
-import ora3 from "ora";
-import { parseHoldpointYaml as parseHoldpointYaml4 } from "@holdpoint/yaml-core";
-import { buildHookJson as buildHookJson2, buildCheckScript as buildCheckScript2, buildConfigJson as buildConfigJson2 } from "@holdpoint/engine-copilot";
-import { buildEngineJson as buildClaudeEngineJson2 } from "@holdpoint/engine-claude";
-import { buildEngine as buildCursorEngine2 } from "@holdpoint/engine-cursor";
-async function updateCommand() {
-  if (!existsSync7("checks.yaml")) {
-    console.error(chalk4.red("No checks.yaml found. Run `holdpoint init` first."));
-    process.exit(1);
-  }
-  const spinner = ora3("Updating Holdpoint engine files\u2026").start();
-  const agent = detectAgent();
-  const config = parseHoldpointYaml4(readFileSync5("checks.yaml", "utf8"));
-  const generatedDir = ".github/holdpoint/generated";
-  mkdirSync2(generatedDir, { recursive: true });
-  writeFileSync2(`${generatedDir}/checks.immutable.json`, buildConfigJson2(config), "utf8");
-  if (agent === "copilot" || agent === "unknown") {
-    const hooksDir = ".github/hooks";
-    mkdirSync2(hooksDir, { recursive: true });
-    writeFileSync2(`${hooksDir}/holdpoint.json`, buildHookJson2(config), "utf8");
-    writeFileSync2(`${hooksDir}/holdpoint-check.mjs`, buildCheckScript2(config), "utf8");
-    spinner.text = `Updated ${chalk4.green(".github/hooks/holdpoint.json")} and ${chalk4.green(".github/hooks/holdpoint-check.mjs")}`;
-  }
-  if (agent === "claude") {
-    mkdirSync2(".claude", { recursive: true });
-    const settingsPath = ".claude/settings.json";
-    let existing = {};
-    if (existsSync7(settingsPath)) {
-      try {
-        existing = JSON.parse(readFileSync5(settingsPath, "utf8"));
-      } catch {
-      }
-    }
-    const hooks = JSON.parse(buildClaudeEngineJson2(config));
-    writeFileSync2(settingsPath, JSON.stringify({ ...existing, hooks: hooks.hooks }, null, 2));
-  }
-  if (agent === "cursor") {
-    const cursorRules = buildCursorEngine2(config);
-    const cursorPath = ".cursorrules";
-    if (existsSync7(cursorPath)) {
-      const content = readFileSync5(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);
-        writeFileSync2(cursorPath, updated);
-      } else {
-        writeFileSync2(cursorPath, content + "\n" + cursorRules);
-      }
-    }
-  }
-  spinner.succeed(chalk4.green("Engine files updated from current checks.yaml"));
-}
-
-// src/commands/build.ts
-import { createServer } from "http";
-import { createReadStream, existsSync as existsSync8 } from "fs";
-import { join as join4, extname, dirname as dirname2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync4 } 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 = join4(process.cwd(), "checks.yaml");
-    if (existsSync8(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");
-    }
-    return;
-  }
-  const candidate = join4(uiDir, url === "/" ? "index.html" : url);
-  const filePath = existsSync8(candidate) ? candidate : join4(uiDir, "index.html");
-  serveFile(res, filePath);
-}
-async function buildCommand() {
-  const port = 4321;
-  const uiDir = join4(__dirname2, "builder-ui");
-  if (!existsSync8(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 {
-        execSync4(`${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());
-    });
-  });
-}
-
-// src/commands/evolve.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import { execSync as execSync5 } from "child_process";
-import chalk6 from "chalk";
-import ora4 from "ora";
-import { parseHoldpointYaml as parseHoldpointYaml5, generateYaml } from "@holdpoint/yaml-core";
-function extractHeader(yaml) {
-  const lines = yaml.split("\n");
-  const commentLines = [];
-  for (const line of lines) {
-    if (line.startsWith("#") || commentLines.length > 0 && line.trim() === "") {
-      commentLines.push(line);
-    } else {
-      break;
-    }
-  }
-  while (commentLines.length > 0 && commentLines[commentLines.length - 1]?.trim() === "") {
-    commentLines.pop();
-  }
-  return commentLines.join("\n");
-}
-function withHeader(header, newYaml) {
-  if (!header) return 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."));
-    process.exit(1);
-  }
-  const spinner = ora4("Scanning project profile\u2026").start();
+  const spinner = ora3("Scanning project profile\u2026").start();
   const cwd = process.cwd();
   const profile = scanProject(cwd);
   const repoFiles = getRepoFiles(cwd);
-  const yamlContent = readFileSync6("checks.yaml", "utf8");
+  const yamlContent = readFileSync5("checks.yaml", "utf8");
   let config;
   try {
-    config = parseHoldpointYaml5(yamlContent);
+    config = parseHoldpointYaml4(yamlContent);
   } catch (err) {
-    spinner.fail(chalk6.red("Invalid checks.yaml:") + " " + err.message);
+    spinner.fail(chalk5.red("Invalid checks.yaml:") + " " + err.message);
     process.exit(1);
   }
   spinner.stop();
@@ -857,7 +1000,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(chalk5.bold("\n\u{1F4CB} Project profile:"));
   const traits = [
     ["TypeScript", profile.hasTypeScript, "tsconfig.json"],
     ["ESLint", profile.hasEslint, "eslint.config.*"],
@@ -883,44 +1026,44 @@ 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(chalk5.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(`  ${chalk5.green("\u2713")} ${name.padEnd(18)} ${chalk5.dim(hint)}`);
     }
   }
   if (staleChecks.length > 0) {
-    console.log(chalk6.bold(`
+    console.log(chalk5.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 ? chalk5.dim(` \u2192 will wrap with conditionId: file_exists: ${suggestedConditionPath}`) : chalk5.dim(" \u2192 no path inferred; review manually");
+      console.log(`  ${chalk5.yellow("\u25CC")} ${chalk5.bold(check.id)}  ${chalk5.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(chalk5.green("\n\u2713 checks.yaml is fully in sync with the project profile."));
     return;
   }
   if (proposals.length > 0) {
-    console.log(chalk6.bold(`
+    console.log(chalk5.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 ? chalk5.cyan(` when: ${t.when}`) : "";
+      const type = t.cmd ? chalk5.dim("cmd") : chalk5.dim("prompt");
+      const preview = t.cmd ? chalk5.dim(`  ${t.cmd.slice(0, 80)}${t.cmd.length > 80 ? "\u2026" : ""}`) : chalk5.dim(`  ${(t.prompt ?? "").slice(0, 80)}${(t.prompt?.length ?? 0) > 80 ? "\u2026" : ""}`);
+      console.log(`  ${chalk5.green("+")} ${chalk5.bold(t.id.padEnd(24))} [${type}]${scope}`);
       console.log(`    ${preview}`);
     }
   }
   if (!options.apply) {
     console.log(
-      chalk6.red(`
+      chalk5.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 ${chalk5.bold("npx @holdpoint/cli suggest --apply")} to apply these changes.`
     );
     process.exit(1);
   }
-  const applySpinner = ora4("Applying changes to checks.yaml\u2026").start();
+  const applySpinner = ora3("Applying changes to checks.yaml\u2026").start();
   const newConditions = [...config.conditions];
   for (const t of proposals) {
     if (t.condition && !existingConditionIds.has(t.condition.id)) {
@@ -960,36 +1103,878 @@ async function evolveCommand(options) {
   writeFileSync3("checks.yaml", newYaml, "utf8");
   applySpinner.text = "Running holdpoint update\u2026";
   try {
-    execSync5("npx @holdpoint/cli@alpha update", { stdio: "pipe" });
+    execSync5("npx @holdpoint/cli update", { stdio: "pipe" });
   } catch {
     applySpinner.warn(
-      chalk6.yellow("checks.yaml updated, but `holdpoint update` failed \u2014 run it manually.")
+      chalk5.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(chalk5.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(chalk5.green(`${added} check${added === 1 ? "" : "s"} added`));
   if (wrapped > 0)
-    parts.push(chalk6.yellow(`${wrapped} stale check${wrapped === 1 ? "" : "s"} wrapped`));
+    parts.push(chalk5.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'")
+    chalk5.dim("\n  Review checks.yaml, then commit: ") + chalk5.yellow("git add checks.yaml && git commit -m 'chore: update holdpoint checks'")
   );
 }
 
+// src/commands/live.ts
+import chalk6 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(
+    chalk6.green(
+      started ? "\u2713 Started Holdpoint Live and opened the browser" : "\u2713 Opened Holdpoint Live"
+    )
+  );
+  console.log(`  url: ${chalk6.cyan(baseUrl.toString())}`);
+}
+
+// src/commands/daemon.ts
+import chalk7 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(chalk7.green(`\u2713 ${headline}`));
+  console.log(`  pid: ${chalk7.cyan(String(info.pid))}`);
+  console.log(`  port: ${chalk7.cyan(String(info.port))}`);
+  console.log(`  uptime: ${chalk7.cyan(formatUptime(info))}`);
+  if (sessionCount !== null) {
+    console.log(`  sessions: ${chalk7.cyan(String(sessionCount))}`);
+  }
+}
+async function daemonStatusCommand() {
+  const lock = await readHealthyDaemonLock2();
+  if (!lock) {
+    console.log(chalk7.yellow("Holdpoint Live daemon is not running."));
+    return;
+  }
+  const sessionCount = await fetchSessionCount(lock);
+  console.log(chalk7.green("\u2713 Holdpoint Live daemon is running"));
+  console.log(`  pid: ${chalk7.cyan(String(lock.pid))}`);
+  console.log(`  port: ${chalk7.cyan(String(lock.port))}`);
+  console.log(`  uptime: ${chalk7.cyan(formatUptime(lock))}`);
+  if (sessionCount !== null) {
+    console.log(`  sessions: ${chalk7.cyan(String(sessionCount))}`);
+  }
+}
+async function daemonStopCommand() {
+  const lock = readDaemonLock();
+  if (!lock) {
+    console.log(chalk7.yellow("Holdpoint Live daemon is not running."));
+    return;
+  }
+  if (!isProcessAlive(lock.pid)) {
+    removeDaemonLock(void 0, lock.token);
+    console.log(chalk7.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(chalk7.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(chalk7.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 chalk8 from "chalk";
+
+// src/engines.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname2, join as join5, resolve, sep } from "path";
+import { createRequire } from "module";
+import { fileURLToPath, pathToFileURL } from "url";
+import { parseEventV1 } from "@holdpoint/live-protocol";
+var require2 = createRequire(import.meta.url);
+var CLI_SRC_DIR = dirname2(fileURLToPath(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 isObject(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 (!existsSync8(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    return isObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function findNearestPackageRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (existsSync8(join5(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname2(current);
+    if (parent === current) {
+      return resolve(startDir);
+    }
+    current = parent;
+  }
+}
+function findPackageRootFromFile(path) {
+  let current = dirname2(path);
+  while (true) {
+    if (existsSync8(join5(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname2(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function getDependencyEnginePackageNames(projectRoot) {
+  const packageJson = readJsonFile(join5(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)) {
+      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 dirname2(packageJsonPath);
+  } catch {
+    if (packageName.startsWith("@holdpoint/")) {
+      const scopedName = packageName.split("/")[1];
+      if (scopedName) {
+        const packageDir = resolve(MONOREPO_ROOT, "packages", scopedName);
+        if (existsSync8(join5(packageDir, "package.json"))) {
+          return packageDir;
+        }
+      }
+    }
+    return null;
+  }
+}
+function formatImportError(error) {
+  return error instanceof Error && error.message ? error.message : String(error);
+}
+function parseManifest(value) {
+  if (!isObject(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 (!isObject(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 (!isObject(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) && existsSync8(sourceFallback)) {
+    return sourceFallback;
+  }
+  if (existsSync8(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(join5(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 = isObject(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 (!existsSync8(manifestPath)) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "manifest file does not exist"
+    };
+  }
+  if (!existsSync8(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(
+        `${chalk8.green("loaded")} ${chalk8.cyan(engine.manifest.id)} (${engine.manifest.displayName}) from ${chalk8.yellow(engine.packageName)} [${engine.source}]`
+      );
+      continue;
+    }
+    console.log(
+      `${chalk8.yellow("ignored")} ${chalk8.yellow(engine.packageName)} [${engine.source}] \u2014 ${engine.reason ?? "unknown reason"}`
+    );
+  }
+}
+
+// src/commands/event.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { parseEventV1 as parseEventV12, parseEventsBatch } from "@holdpoint/live-protocol";
+import { BridgeClient as BridgeClient2 } from "@holdpoint/sdk";
+function readStdin() {
+  return readFileSync7(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 execSync6 } from "child_process";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync } from "fs";
+import { join as join6, relative } from "path";
+import chalk9 from "chalk";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage",
+  "dist",
+  "node_modules",
+  "test-results"
+]);
+function runGit(command) {
+  try {
+    const out = execSync6(command, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync8(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 (!existsSync9("pnpm-workspace.yaml")) return [];
+  const lines = readFileSync8("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 existsSync9(join6(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("*") || !existsSync9(parent)) {
+    return [];
+  }
+  return readdirSync3(parent).map((entry) => join6(parent, entry, suffix)).map(normalizePath).filter((candidate) => existsSync9(join6(candidate, "package.json")));
+}
+function walkPackageRoots(start, roots) {
+  let entries;
+  try {
+    entries = readdirSync3(start);
+  } catch {
+    return;
+  }
+  if (start !== "." && existsSync9(join6(start, "package.json"))) {
+    roots.push(normalizePath(start));
+    return;
+  }
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry)) continue;
+    const candidate = join6(start, entry);
+    let stats;
+    try {
+      stats = statSync(candidate);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      walkPackageRoots(candidate, roots);
+    }
+  }
+}
+function readPackageRoot(path) {
+  const pkg = readJson(join6(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 : existsSync9("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(chalk9.green("\u2713 No changed files detected \u2014 no changeset required."));
+    return;
+  }
+  const packageRoots = discoverPackageRoots(options.include ?? []);
+  if (packageRoots.length === 0) {
+    console.log(chalk9.green("\u2713 No package roots detected \u2014 no changeset required."));
+    return;
+  }
+  const hasChangesetSetup = existsSync9(".changeset");
+  const { requiredFiles, hasChangeset } = analyzeChangesetRequirement({
+    changedFiles,
+    packageRoots
+  });
+  if (requiredFiles.length === 0) {
+    console.log(chalk9.green("\u2713 No release-affecting package files changed."));
+    return;
+  }
+  if (hasChangeset) {
+    console.log(chalk9.green("\u2713 Package changes include a changeset."));
+    return;
+  }
+  console.error(chalk9.red("\u2717 Package changes need a changeset."));
+  console.error("");
+  console.error(chalk9.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(chalk9.yellow("  mkdir -p .changeset"));
+  } else {
+    console.error("Add a changeset before finishing:");
+  }
+  console.error(chalk9.yellow("  pnpm changeset"));
+  console.error(chalk9.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("--agent <agent>", "Agent type: copilot | claude | cursor").action(initCommand);
-program.command("check").description("Run task checks from checks.yaml").option("--staged", "Only check against git-staged files").action(checkCommand);
+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").option("--hook <event>", "Only run checks bound to this lifecycle hook (default: before_done)").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