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

package/dist/index.js

@@ -5,9 +5,9 @@ import { Command } from "commander";
 
 // src/commands/init.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, copyFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk from "chalk";
 import ora from "ora";
 import { buildConfigJson, buildEngine } from "@holdpoint/engine-copilot";
@@ -58,34 +58,52 @@ function detectStack() {
   return "unknown";
 }
 
-// src/commands/init.ts
+// src/templates.ts
+import { copyFileSync, existsSync as existsSync2, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
-function getTemplatePath(stack) {
-  const name = stack === "unknown" ? "_base" : stack;
+function getBundledTemplatePath(filename) {
   const candidates = [
-    join(__dirname, "templates", `${name}.yaml`),
+    join(__dirname, "templates", filename),
     // dist/templates/ (published package)
-    join(__dirname, "../../../templates", `${name}.yaml`),
+    join(__dirname, "../../../templates", filename),
     // monorepo dev fallback
-    join(process.cwd(), "templates", `${name}.yaml`)
+    join(process.cwd(), "templates", filename)
     // cwd fallback
   ];
-  for (const p of candidates) {
-    if (existsSync2(p)) return p;
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
   }
   return "";
 }
-function getMasterPromptPath() {
+function ensureBundledFile(outputPath, templateFilename, fallbackContent) {
+  if (existsSync2(outputPath)) {
+    return false;
+  }
+  const templatePath = getBundledTemplatePath(templateFilename);
+  if (templatePath) {
+    copyFileSync(templatePath, outputPath);
+  } else {
+    writeFileSync(outputPath, fallbackContent, "utf8");
+  }
+  return true;
+}
+
+// src/commands/init.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+function getTemplatePath(stack) {
+  const name = stack === "unknown" ? "_base" : stack;
   const candidates = [
-    join(__dirname, "templates/MASTER_PROMPT.md"),
+    join2(__dirname2, "templates", `${name}.yaml`),
     // dist/templates/ (published package)
-    join(__dirname, "../../../templates/MASTER_PROMPT.md"),
+    join2(__dirname2, "../../../templates", `${name}.yaml`),
     // monorepo dev fallback
-    join(process.cwd(), "templates/MASTER_PROMPT.md")
+    join2(process.cwd(), "templates", `${name}.yaml`)
     // cwd fallback
   ];
   for (const p of candidates) {
-    if (existsSync2(p)) return p;
+    if (existsSync3(p)) return p;
   }
   return "";
 }
@@ -102,6 +120,21 @@ checks:
     label: "JSDoc on changed public functions"
     prompt: "Ensure all changed public functions and exports have JSDoc comments."
 `;
+var MINIMAL_MASTER_PROMPT = `# Holdpoint
+
+Run \`holdpoint check\` before marking any task complete.
+See \`checks.yaml\` for the full list of checks.
+`;
+var MINIMAL_PREREQUISITES = `# Holdpoint prerequisites
+
+Holdpoint installed repo-local adapters 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.
+- **OpenAI Codex** \u2014 project-level hooks require trust approval. Run \`codex trust\` in the Codex TUI or review the hook with \`/hooks\`.
+- **General** \u2014 Holdpoint expects Node.js 18+ and a git repository so \`holdpoint init\`, \`holdpoint update\`, and \`holdpoint check\` can run normally.
+
+Docs: https://holdpoint.dev/docs
+`;
 async function initCommand(options) {
   const spinner = ora("Initialising Holdpoint\u2026").start();
   const stack = options.stack ?? detectStack();
@@ -110,7 +143,7 @@ async function initCommand(options) {
   spinner.text = `Stack: ${chalk.cyan(stack)} \u2014 installing for: ${chalk.cyan(agents.join(", "))}`;
   const pm = detectPackageManager();
   let yamlContent = MINIMAL_CHECKS_YAML;
-  if (!existsSync2("checks.yaml")) {
+  if (!existsSync3("checks.yaml")) {
     const templatePath = getTemplatePath(stack);
     if (templatePath) {
       yamlContent = readFileSync2(templatePath, "utf8");
@@ -118,31 +151,31 @@ async function initCommand(options) {
     if (pm !== "pnpm") {
       yamlContent = yamlContent.replace(/\bpnpm\b/g, pm);
     }
-    writeFileSync("checks.yaml", yamlContent, "utf8");
+    writeFileSync2("checks.yaml", yamlContent, "utf8");
   } else {
     yamlContent = readFileSync2("checks.yaml", "utf8");
   }
   const config = parseHoldpointYaml(yamlContent);
   const generatedDir = ".github/holdpoint/generated";
   mkdirSync(generatedDir, { recursive: true });
-  writeFileSync(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
+  writeFileSync2(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
   if (agents.includes("copilot")) {
     const extDir = ".github/extensions/holdpoint";
     mkdirSync(extDir, { recursive: true });
-    writeFileSync(join(extDir, "extension.mjs"), buildEngine(config), "utf8");
+    writeFileSync2(join2(extDir, "extension.mjs"), buildEngine(config), "utf8");
   }
   if (agents.includes("claude")) {
     mkdirSync(".claude", { recursive: true });
     const settingsPath = ".claude/settings.json";
     let existing = {};
-    if (existsSync2(settingsPath)) {
+    if (existsSync3(settingsPath)) {
       try {
         existing = JSON.parse(readFileSync2(settingsPath, "utf8"));
       } catch {
       }
     }
     const holdpointHooks = JSON.parse(buildClaudeEngineJson(config));
-    writeFileSync(
+    writeFileSync2(
       settingsPath,
       JSON.stringify({ ...existing, hooks: holdpointHooks.hooks }, null, 2),
       "utf8"
@@ -151,36 +184,30 @@ async function initCommand(options) {
   if (agents.includes("cursor")) {
     const cursorRules = buildCursorEngine(config);
     const cursorPath = ".cursorrules";
-    if (existsSync2(cursorPath)) {
+    if (existsSync3(cursorPath)) {
       const existing = readFileSync2(cursorPath, "utf8");
       if (!existing.includes("Holdpoint Rules")) {
-        writeFileSync(cursorPath, existing + "\n" + cursorRules, "utf8");
+        writeFileSync2(cursorPath, existing + "\n" + cursorRules, "utf8");
       }
     } else {
-      writeFileSync(cursorPath, cursorRules, "utf8");
+      writeFileSync2(cursorPath, cursorRules, "utf8");
     }
   }
   if (agents.includes("codex")) {
     mkdirSync(".codex", { recursive: true });
-    writeFileSync(".codex/hooks.json", buildCodexHooksJson(config), "utf8");
-    writeFileSync(".codex/holdpoint-check.mjs", buildCodexCheckScript(config), "utf8");
-    writeFileSync(".codex/config.toml", buildCodexConfigToml(), "utf8");
+    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 = existsSync2(agentsMdPath) ? readFileSync2(agentsMdPath, "utf8") : "";
-    writeFileSync(agentsMdPath, spliceAgentsMd(existing, config), "utf8");
-  }
-  if (!existsSync2("MASTER_PROMPT.md")) {
-    const guidePath = getMasterPromptPath();
-    if (guidePath) {
-      copyFileSync(guidePath, "MASTER_PROMPT.md");
-    } else {
-      writeFileSync(
-        "MASTER_PROMPT.md",
-        "# Holdpoint\n\nRun `holdpoint check` before marking any task complete.\nSee `checks.yaml` for the full list of checks.\n",
-        "utf8"
-      );
-    }
+    const existing = existsSync3(agentsMdPath) ? readFileSync2(agentsMdPath, "utf8") : "";
+    writeFileSync2(agentsMdPath, spliceAgentsMd(existing, config), "utf8");
   }
+  ensureBundledFile("MASTER_PROMPT.md", "MASTER_PROMPT.md", MINIMAL_MASTER_PROMPT);
+  ensureBundledFile(
+    "HOLDPOINT_PREREQUISITES.md",
+    "HOLDPOINT_PREREQUISITES.md",
+    MINIMAL_PREREQUISITES
+  );
   spinner.text = "Installing holdpoint as a devDependency\u2026";
   const installCmds = {
     pnpm: "pnpm add -D holdpoint@alpha",
@@ -200,8 +227,13 @@ async function initCommand(options) {
   console.log(`
 ${chalk.cyan("Next steps:")}
   1. Edit ${chalk.yellow("checks.yaml")} to customise your eval checkpoints
-  2. Commit ${chalk.yellow("checks.yaml")} and the generated engine files
-  3. Run ${chalk.yellow("holdpoint check")} at any time to validate
+  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
+
+${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(", "))}
@@ -209,13 +241,16 @@ ${chalk.cyan("Next steps:")}
 }
 
 // src/commands/check.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
 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 execSync2 } 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";
@@ -276,16 +311,16 @@ function recordCommitCache(sha) {
   try {
     const existing = readCommitCache();
     const updated = [sha, ...[...existing].filter((s) => s !== sha)].slice(0, COMMIT_CACHE_MAX);
-    mkdirSync2(join2(COMMIT_CACHE_PATH, ".."), { recursive: true });
-    writeFileSync2(COMMIT_CACHE_PATH, JSON.stringify({ verified: updated }, null, 2) + "\n", "utf8");
+    mkdirSync2(join3(COMMIT_CACHE_PATH, ".."), { recursive: true });
+    writeFileSync3(COMMIT_CACHE_PATH, JSON.stringify({ verified: updated }, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 function recordCheckReport(run) {
   try {
-    mkdirSync2(join2(CHECK_REPORTS_PATH, ".."), { recursive: true });
+    mkdirSync2(join3(CHECK_REPORTS_PATH, ".."), { recursive: true });
     let existing = { runs: [] };
-    if (existsSync3(CHECK_REPORTS_PATH)) {
+    if (existsSync4(CHECK_REPORTS_PATH)) {
       try {
         existing = JSON.parse(readFileSync3(CHECK_REPORTS_PATH, "utf8"));
         if (!Array.isArray(existing.runs)) existing.runs = [];
@@ -296,12 +331,12 @@ function recordCheckReport(run) {
     const updated = {
       runs: [run, ...existing.runs].slice(0, CHECK_REPORTS_MAX)
     };
-    writeFileSync2(CHECK_REPORTS_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    writeFileSync3(CHECK_REPORTS_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 async function checkCommand(options) {
-  if (!existsSync3("checks.yaml")) {
+  if (!existsSync4("checks.yaml")) {
     console.error(chalk2.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
@@ -420,6 +455,30 @@ ${chalk2.cyan("Agent prompts to act on:")}`);
     }
   };
   recordCheckReport(run);
+  const project = identifyProject(process.cwd());
+  const bridge = new BridgeClient();
+  const liveEvents = reportResults.filter(
+    (result) => result.kind === "cmd"
+  ).map((result, index) => ({
+    v: 1,
+    id: randomUUID(),
+    ts: Date.now() + index,
+    engine: "holdpoint",
+    session_id: "check-runner",
+    project_hash: project.hash,
+    cwd: process.cwd(),
+    type: "check_run",
+    payload: {
+      check_id: result.id,
+      label: result.label,
+      status: result.status,
+      duration_ms: 0,
+      ...result.output ? { output: result.output } : {}
+    }
+  }));
+  if (liveEvents.length > 0) {
+    await bridge.sendEvents(liveEvents);
+  }
   if (failed.length > 0) {
     process.exit(1);
   }
@@ -441,11 +500,11 @@ function printResult(result) {
 }
 
 // src/commands/validate.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import chalk3 from "chalk";
 import { parseHoldpointYaml as parseHoldpointYaml3, validateConfig } from "@holdpoint/yaml-core";
 async function validateCommand() {
-  if (!existsSync4("checks.yaml")) {
+  if (!existsSync5("checks.yaml")) {
     console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
@@ -475,7 +534,7 @@ async function validateCommand() {
 }
 
 // src/commands/update.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
 import chalk4 from "chalk";
 import ora3 from "ora";
 import { parseHoldpointYaml as parseHoldpointYaml4 } from "@holdpoint/yaml-core";
@@ -488,8 +547,18 @@ import {
   buildCheckScript as buildCodexCheckScript2,
   spliceAgentsMd as spliceAgentsMd2
 } 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:
+
+- **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.
+- **OpenAI Codex** \u2014 project-level hooks require trust approval. Run \`codex trust\` in the Codex TUI or review the hook with \`/hooks\`.
+- **General** \u2014 Holdpoint expects Node.js 18+ and a git repository so \`holdpoint init\`, \`holdpoint update\`, and \`holdpoint check\` can run normally.
+
+Docs: https://holdpoint.dev/docs
+`;
 async function updateCommand() {
-  if (!existsSync5("checks.yaml")) {
+  if (!existsSync6("checks.yaml")) {
     console.error(chalk4.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
@@ -499,24 +568,24 @@ async function updateCommand() {
   const agents = detected.length > 0 ? detected : ["copilot", "claude", "cursor", "codex"];
   const generatedDir = ".github/holdpoint/generated";
   mkdirSync3(generatedDir, { recursive: true });
-  writeFileSync3(`${generatedDir}/checks.immutable.json`, buildConfigJson2(config), "utf8");
+  writeFileSync4(`${generatedDir}/checks.immutable.json`, buildConfigJson2(config), "utf8");
   if (agents.includes("copilot")) {
     const extDir = ".github/extensions/holdpoint";
     mkdirSync3(extDir, { recursive: true });
-    writeFileSync3(`${extDir}/extension.mjs`, buildEngine2(config), "utf8");
+    writeFileSync4(`${extDir}/extension.mjs`, buildEngine2(config), "utf8");
   }
   if (agents.includes("claude")) {
     mkdirSync3(".claude", { recursive: true });
     const settingsPath = ".claude/settings.json";
     let existing = {};
-    if (existsSync5(settingsPath)) {
+    if (existsSync6(settingsPath)) {
       try {
         existing = JSON.parse(readFileSync5(settingsPath, "utf8"));
       } catch {
       }
     }
     const hooks = JSON.parse(buildClaudeEngineJson2(config));
-    writeFileSync3(
+    writeFileSync4(
       settingsPath,
       JSON.stringify({ ...existing, hooks: hooks.hooks }, null, 2) + "\n"
     );
@@ -524,47 +593,59 @@ async function updateCommand() {
   if (agents.includes("cursor")) {
     const cursorRules = buildCursorEngine2(config);
     const cursorPath = ".cursorrules";
-    if (existsSync5(cursorPath)) {
+    if (existsSync6(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);
-        writeFileSync3(cursorPath, updated);
+        writeFileSync4(cursorPath, updated);
       } else {
-        writeFileSync3(cursorPath, content + "\n" + cursorRules);
+        writeFileSync4(cursorPath, content + "\n" + cursorRules);
       }
     }
   }
   if (agents.includes("codex")) {
     mkdirSync3(".codex", { recursive: true });
-    writeFileSync3(".codex/hooks.json", buildCodexHooksJson2(config), "utf8");
-    writeFileSync3(".codex/holdpoint-check.mjs", buildCodexCheckScript2(config), "utf8");
+    writeFileSync4(".codex/hooks.json", buildCodexHooksJson2(config), "utf8");
+    writeFileSync4(".codex/holdpoint-check.mjs", buildCodexCheckScript2(config), "utf8");
     const configTomlPath = ".codex/config.toml";
-    if (!existsSync5(configTomlPath)) {
-      writeFileSync3(configTomlPath, buildCodexConfigToml2(), "utf8");
+    if (!existsSync6(configTomlPath)) {
+      writeFileSync4(configTomlPath, buildCodexConfigToml2(), "utf8");
     } else {
       const existing2 = readFileSync5(configTomlPath, "utf8");
       if (!existing2.includes("[features]")) {
-        writeFileSync3(configTomlPath, existing2.trimEnd() + "\n\n" + buildCodexConfigToml2(), "utf8");
+        writeFileSync4(configTomlPath, existing2.trimEnd() + "\n\n" + buildCodexConfigToml2(), "utf8");
       }
     }
     const agentsMdPath = "AGENTS.md";
-    const existing = existsSync5(agentsMdPath) ? readFileSync5(agentsMdPath, "utf8") : "";
-    writeFileSync3(agentsMdPath, spliceAgentsMd2(existing, config), "utf8");
+    const existing = existsSync6(agentsMdPath) ? readFileSync5(agentsMdPath, "utf8") : "";
+    writeFileSync4(agentsMdPath, spliceAgentsMd2(existing, config), "utf8");
   }
+  const wrotePrerequisites = ensureBundledFile(
+    "HOLDPOINT_PREREQUISITES.md",
+    "HOLDPOINT_PREREQUISITES.md",
+    MINIMAL_PREREQUISITES2
+  );
   spinner.succeed(chalk4.green("Engine files updated from current checks.yaml"));
+  if (wrotePrerequisites) {
+    console.log(
+      chalk4.cyan(
+        "Created HOLDPOINT_PREREQUISITES.md with Copilot experimental-mode and other agent setup notes."
+      )
+    );
+  }
 }
 
 // src/commands/build.ts
 import { createServer } from "http";
-import { createReadStream, existsSync as existsSync6 } from "fs";
-import { join as join3, extname, dirname as dirname2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { 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 __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript",
@@ -586,8 +667,8 @@ function serveFile(res, filePath) {
 function handleRequest(req, res, uiDir) {
   const url = (req.url ?? "/").split("?")[0] ?? "/";
   if (url === "/__holdpoint/initial-yaml") {
-    const checksPath = join3(process.cwd(), "checks.yaml");
-    if (existsSync6(checksPath)) {
+    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 {
@@ -597,8 +678,8 @@ function handleRequest(req, res, uiDir) {
     return;
   }
   if (url === "/__holdpoint/initial-reports") {
-    const reportsPath = join3(process.cwd(), ".holdpoint", "check-reports.json");
-    if (existsSync6(reportsPath)) {
+    const reportsPath = join4(process.cwd(), ".holdpoint", "check-reports.json");
+    if (existsSync7(reportsPath)) {
       res.writeHead(200, { "Content-Type": "application/json" });
       createReadStream(reportsPath).pipe(res);
     } else {
@@ -607,21 +688,21 @@ function handleRequest(req, res, uiDir) {
     }
     return;
   }
-  const candidate = join3(uiDir, url === "/" ? "index.html" : url);
-  const filePath = existsSync6(candidate) ? candidate : join3(uiDir, "index.html");
+  const candidate = join4(uiDir, url === "/" ? "index.html" : url);
+  const filePath = existsSync7(candidate) ? candidate : join4(uiDir, "index.html");
   serveFile(res, filePath);
 }
 async function buildCommand() {
   const port = 4321;
-  const uiDir = join3(__dirname2, "builder-ui");
-  if (!existsSync6(uiDir)) {
+  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((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     server.listen(port, () => {
       console.log(
         `
@@ -638,21 +719,21 @@ ${chalk5.green("\u2713")} Holdpoint builder running at ${chalk5.cyan(`http://loc
     server.on("error", reject);
     process.on("SIGINT", () => {
       console.log(chalk5.dim("\n  Stopping builder\u2026"));
-      server.close(() => resolve());
+      server.close(() => resolve2());
     });
   });
 }
 
 // src/commands/evolve.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { execSync as execSync6 } from "child_process";
 import chalk6 from "chalk";
 import ora4 from "ora";
 import { parseHoldpointYaml as parseHoldpointYaml5, generateYaml } from "@holdpoint/yaml-core";
 
 // src/evolve/scanner.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync } from "fs";
+import { join as join5 } from "path";
 import { execSync as execSync4 } from "child_process";
 function tryReadJson(path) {
   try {
@@ -669,17 +750,17 @@ function tryReadText(path) {
   }
 }
 function scanProject(cwd = process.cwd()) {
-  const exists = (p) => existsSync7(join4(cwd, p));
+  const exists = (p) => existsSync8(join5(cwd, p));
   const packageManager = exists("pnpm-lock.yaml") ? "pnpm" : exists("yarn.lock") ? "yarn" : exists("bun.lockb") ? "bun" : "npm";
-  const pkg = tryReadJson(join4(cwd, "package.json"));
+  const pkg = tryReadJson(join5(cwd, "package.json"));
   const scripts = pkg?.scripts ?? {};
   const deps = /* @__PURE__ */ new Set([
     ...Object.keys(pkg?.dependencies ?? {}),
     ...Object.keys(pkg?.devDependencies ?? {})
   ]);
-  const pyprojectText = tryReadText(join4(cwd, "pyproject.toml"));
-  const requirementsText = tryReadText(join4(cwd, "requirements.txt"));
-  const pipfileText = tryReadText(join4(cwd, "Pipfile"));
+  const pyprojectText = tryReadText(join5(cwd, "pyproject.toml"));
+  const requirementsText = tryReadText(join5(cwd, "requirements.txt"));
+  const pipfileText = tryReadText(join5(cwd, "Pipfile"));
   const allPyText = pyprojectText + requirementsText + pipfileText;
   const hasPytest = exists("pytest.ini") || exists("setup.cfg") || allPyText.includes("pytest") || allPyText.includes("[tool.pytest");
   const hasRuff = allPyText.includes("ruff") || deps.has("ruff");
@@ -732,8 +813,8 @@ function scanProject(cwd = process.cwd()) {
 
 // src/evolve/dead-checker.ts
 import { execSync as execSync5 } from "child_process";
-import { readdirSync as readdirSync2, existsSync as existsSync8 } from "fs";
-import { join as join5 } from "path";
+import { readdirSync as readdirSync2, existsSync as existsSync9 } from "fs";
+import { join as join6 } from "path";
 var NAMED_SCOPES = /* @__PURE__ */ new Set([
   "frontend",
   "backend",
@@ -778,7 +859,7 @@ function walkDir(dir, root, depth, maxDepth) {
   const results = [];
   for (const entry of entries) {
     if (WALK_IGNORED.has(entry) || entry.startsWith(".")) continue;
-    const full = join5(dir, entry);
+    const full = join6(dir, entry);
     const rel = full.slice(root.length + 1);
     results.push(rel);
     const children = walkDir(full, root, depth + 1, maxDepth);
@@ -825,7 +906,7 @@ function detectStaleChecks(config, repoFiles) {
     if (matches.length === 0) {
       const label = patternAlias ? `Pattern '${patternAlias}' (= '${regexStr}')` : `Regex '${regexStr}'`;
       const suggestedConditionPath = extractPathFromRegex(regexStr);
-      const pathGone = !suggestedConditionPath || !existsSync8(join5(process.cwd(), suggestedConditionPath));
+      const pathGone = !suggestedConditionPath || !existsSync9(join6(process.cwd(), suggestedConditionPath));
       if (pathGone) {
         stale.push({
           check,
@@ -1026,7 +1107,7 @@ function withHeader(header, newYaml) {
   return header + "\n\n" + newYaml;
 }
 async function evolveCommand(options) {
-  if (!existsSync9("checks.yaml")) {
+  if (!existsSync10("checks.yaml")) {
     console.error(chalk6.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
@@ -1148,7 +1229,7 @@ async function evolveCommand(options) {
   };
   const header = extractHeader(yamlContent);
   const newYaml = withHeader(header, generateYaml(updatedConfig));
-  writeFileSync4("checks.yaml", newYaml, "utf8");
+  writeFileSync5("checks.yaml", newYaml, "utf8");
   applySpinner.text = "Running holdpoint update\u2026";
   try {
     execSync6("npx @holdpoint/cli@alpha update", { stdio: "pipe" });
@@ -1173,9 +1254,652 @@ function printAppliedSummary(added, wrapped) {
   );
 }
 
+// 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;
+  }
+}
+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);
+  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);
+  }
+  openBrowser(baseUrl.toString());
+  console.log(
+    chalk7.green(
+      started ? "\u2713 Started Holdpoint Live and opened the browser" : "\u2713 Opened Holdpoint Live"
+    )
+  );
+  console.log(`  url: ${chalk7.cyan(baseUrl.toString())}`);
+}
+
+// src/commands/daemon.ts
+import chalk8 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(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))}`);
+  if (sessionCount !== null) {
+    console.log(`  sessions: ${chalk8.cyan(String(sessionCount))}`);
+  }
+}
+async function daemonStatusCommand() {
+  const lock = await readHealthyDaemonLock2();
+  if (!lock) {
+    console.log(chalk8.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))}`);
+  if (sessionCount !== null) {
+    console.log(`  sessions: ${chalk8.cyan(String(sessionCount))}`);
+  }
+}
+async function daemonStopCommand() {
+  const lock = readDaemonLock();
+  if (!lock) {
+    console.log(chalk8.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."));
+    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(chalk8.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(chalk8.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 chalk9 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 { createRequire } from "module";
+import { fileURLToPath as fileURLToPath4, 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 MONOREPO_ROOT = resolve(CLI_SRC_DIR, "../../..");
+var BUILTIN_LIVE_ENGINE_PACKAGES = ["@holdpoint/engine-claude"];
+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 (!existsSync12(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
+    return isObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function findNearestPackageRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (existsSync12(join8(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname5(current);
+    if (parent === current) {
+      return resolve(startDir);
+    }
+    current = parent;
+  }
+}
+function findPackageRootFromFile(path) {
+  let current = dirname5(path);
+  while (true) {
+    if (existsSync12(join8(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname5(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function getDependencyEnginePackageNames(projectRoot) {
+  const packageJson = readJsonFile(join8(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 dirname5(packageJsonPath);
+  } catch {
+    if (packageName.startsWith("@holdpoint/")) {
+      const scopedName = packageName.split("/")[1];
+      if (scopedName) {
+        const packageDir = resolve(MONOREPO_ROOT, "packages", scopedName);
+        if (existsSync12(join8(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) && existsSync12(sourceFallback)) {
+    return sourceFallback;
+  }
+  if (existsSync12(declaredPath)) {
+    return declaredPath;
+  }
+  return sourceFallback;
+}
+async function resolveCandidate(packageName, source, projectRoot) {
+  const packageRoot = resolvePackageRoot(packageName, projectRoot);
+  if (!packageRoot) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "package could not be resolved from this project"
+    };
+  }
+  const packageJson = readJsonFile(join8(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 (!existsSync12(manifestPath)) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "manifest file does not exist"
+    };
+  }
+  if (!existsSync12(adapterPath)) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: "adapter file does not exist"
+    };
+  }
+  try {
+    const manifestModule = await importModule(manifestPath);
+    const manifest = parseManifest(manifestModule.manifest);
+    if (!manifest) {
+      return {
+        packageName,
+        source,
+        status: "ignored",
+        reason: "manifest export is invalid"
+      };
+    }
+    return {
+      packageName,
+      source,
+      status: "loaded",
+      manifest,
+      packageRoot,
+      adapterPath
+    };
+  } catch (error) {
+    return {
+      packageName,
+      source,
+      status: "ignored",
+      reason: `manifest import failed: ${formatImportError(error)}`
+    };
+  }
+}
+async function discoverLiveEnginesDetailed(options) {
+  const projectRoot = findNearestPackageRoot(options?.cwd ?? process.cwd());
+  const dependencyPackages = getDependencyEnginePackageNames(projectRoot);
+  const seenPackages = /* @__PURE__ */ new Set();
+  const results = [];
+  const loadedIds = /* @__PURE__ */ new Set();
+  const candidates = [
+    ...BUILTIN_LIVE_ENGINE_PACKAGES.map((packageName) => ({
+      packageName,
+      source: "built-in"
+    })),
+    ...dependencyPackages.map((packageName) => ({ packageName, source: "dependency" }))
+  ];
+  for (const candidate of candidates) {
+    if (seenPackages.has(candidate.packageName)) {
+      continue;
+    }
+    seenPackages.add(candidate.packageName);
+    const result = await resolveCandidate(candidate.packageName, candidate.source, projectRoot);
+    if (result.status === "loaded" && result.manifest) {
+      if (loadedIds.has(result.manifest.id)) {
+        results.push({
+          packageName: result.packageName,
+          source: result.source,
+          status: "ignored",
+          reason: `engine id \`${result.manifest.id}\` collides with an already loaded adapter`,
+          manifest: result.manifest
+        });
+        continue;
+      }
+      loadedIds.add(result.manifest.id);
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function discoverLiveEngines(options) {
+  const results = await discoverLiveEnginesDetailed(options);
+  return results.map(({ packageName, source, status, reason, manifest }) => ({
+    packageName,
+    source,
+    status,
+    ...reason ? { reason } : {},
+    ...manifest ? { manifest } : {}
+  }));
+}
+async function loadLiveAdapter(engineId, options) {
+  const results = await discoverLiveEnginesDetailed(options);
+  const match = results.find(
+    (result) => result.status === "loaded" && result.manifest?.id === engineId
+  );
+  if (!match?.adapterPath || !match.manifest) {
+    return null;
+  }
+  try {
+    const adapterModule = await importModule(match.adapterPath);
+    return parseLiveAdapter(adapterModule.adapter, match.manifest);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/engines.ts
+async function enginesCommand(options = {}) {
+  const engines = await discoverLiveEngines();
+  if (options.json) {
+    console.log(JSON.stringify(engines, null, 2));
+    return;
+  }
+  if (engines.length === 0) {
+    console.log("No Holdpoint live adapters 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}]`
+      );
+      continue;
+    }
+    console.log(
+      `${chalk9.yellow("ignored")} ${chalk9.yellow(engine.packageName)} [${engine.source}] \u2014 ${engine.reason ?? "unknown reason"}`
+    );
+  }
+}
+
+// src/commands/event.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { parseEventV1 as parseEventV12, parseEventsBatch } from "@holdpoint/live-protocol";
+import { BridgeClient as BridgeClient2 } from "@holdpoint/sdk";
+function readStdin() {
+  return readFileSync9(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/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.name("holdpoint").description("Universal eval-guard for AI coding agents (alpha)").version(CLI_VERSION).action(() => {
+  void liveCommand();
+});
 program.command("init").description("Initialise Holdpoint in the current project").option("--stack <stack>", "Stack type: typescript | python | nextjs | fullstack").option(
   "--agent <agent>",
   "Agent to install for: copilot | claude | cursor | codex (default: all four)"
@@ -1184,6 +1908,14 @@ program.command("check").description("Run task checks from checks.yaml").option(
 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("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("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.parse();
 //# sourceMappingURL=index.js.map