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

package/dist/index.js

@@ -1,495 +1,24 @@
 #!/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 { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk2 from "chalk";
-import ora from "ora";
-import { buildConfigJson, buildEngine } from "@holdpoint/engine-copilot";
-import { buildEngineJson as buildClaudeEngineJson } from "@holdpoint/engine-claude";
-import {
-  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";
-import { parseHoldpointYaml } from "@holdpoint/yaml-core";
-
-// src/detect.ts
-import { existsSync, readFileSync } from "fs";
-function detectPackageManager() {
-  if (existsSync("pnpm-lock.yaml")) return "pnpm";
-  if (existsSync("yarn.lock")) return "yarn";
-  return "npm";
-}
-function detectInstalledAgents() {
-  const agents = [];
-  if (existsSync(".github/extensions/holdpoint/extension.mjs")) agents.push("copilot");
-  if (existsSync(".claude/settings.json")) agents.push("claude");
-  if (existsSync(".cursor/hooks.json")) {
-    try {
-      if (readFileSync(".cursor/hooks.json", "utf8").includes("HOLDPOINT_MANAGED=cursor")) {
-        agents.push("cursor");
-      }
-    } catch {
-    }
-  }
-  if (existsSync(".cursorrules")) {
-    try {
-      if (!agents.includes("cursor") && readFileSync(".cursorrules", "utf8").includes("Holdpoint Rules")) {
-        agents.push("cursor");
-      }
-    } catch {
-    }
-  }
-  if (existsSync(".codex/holdpoint-check.mjs")) agents.push("codex");
-  return agents;
-}
-
-// 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 getBundledTemplatePath(filename) {
-  const candidates = [
-    join(__dirname, "templates", filename),
-    // dist/templates/ (published package)
-    join(__dirname, "../../../templates", filename),
-    // monorepo dev fallback
-    join(process.cwd(), "templates", filename)
-    // cwd fallback
-  ];
-  for (const candidate of candidates) {
-    if (existsSync2(candidate)) return candidate;
-  }
-  return "";
-}
-function ensureBundledFile(outputPath, templateFilename, fallbackContent) {
-  if (existsSync2(outputPath)) {
-    return false;
-  }
-  const templatePath = getBundledTemplatePath(templateFilename);
-  if (templatePath) {
-    copyFileSync(templatePath, outputPath);
-  } else {
-    writeFileSync(outputPath, fallbackContent, "utf8");
-  }
-  return true;
-}
-
-// src/lib/preflight.ts
-import { execSync } from "child_process";
-import chalk from "chalk";
-function silentExec(cmd) {
-  try {
-    const stdout = execSync(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString();
-    return { ok: true, stdout };
-  } catch {
-    return { ok: false, stdout: "" };
-  }
-}
-function checkCopilot() {
-  const gh = silentExec("gh --version");
-  if (!gh.ok) {
-    return {
-      agent: "copilot",
-      status: "action_required",
-      message: "GitHub CLI not found on PATH",
-      command: "brew install gh    # or: https://cli.github.com/"
-    };
-  }
-  const copilot = silentExec("gh copilot --version");
-  if (!copilot.ok) {
-    return {
-      agent: "copilot",
-      status: "action_required",
-      message: "Copilot CLI extension not installed",
-      command: "gh extension install github/gh-copilot"
-    };
-  }
-  return {
-    agent: "copilot",
-    status: "action_required",
-    message: "Copilot CLI detected \u2014 experimental mode required for EXTENSIONS",
-    command: "Inside Copilot CLI, run: /experimental on"
-  };
-}
-function checkClaude() {
-  const claude = silentExec("claude --version");
-  if (!claude.ok) {
-    return {
-      agent: "claude",
-      status: "unknown",
-      message: "Claude Code binary not on PATH (hooks still written for when it is)"
-    };
-  }
-  return {
-    agent: "claude",
-    status: "ok",
-    message: "Claude Code detected \u2014 hooks installed at .claude/settings.json"
-  };
-}
-function checkCursor() {
-  return {
-    agent: "cursor",
-    status: "ok",
-    message: "Cursor \u2014 .cursor/hooks.json gate + .cursor/rules breadcrumb installed",
-    docs: "https://holdpoint.dev/docs#cursor"
-  };
-}
-function checkCodex() {
-  const codex = silentExec("codex --version");
-  if (!codex.ok) {
-    return {
-      agent: "codex",
-      status: "action_required",
-      message: "Codex CLI not found on PATH",
-      command: "Install Codex: https://github.com/openai/codex"
-    };
-  }
-  return {
-    agent: "codex",
-    status: "action_required",
-    message: "Codex detected \u2014 project-level hooks require trust approval",
-    command: "In the Codex TUI: codex trust    (or /hooks to review)"
-  };
-}
-var CHECKS = {
-  copilot: checkCopilot,
-  claude: checkClaude,
-  cursor: checkCursor,
-  codex: checkCodex
-};
-function runPreflight(agents) {
-  return agents.flatMap((agent) => {
-    const check = CHECKS[agent];
-    return check ? [check()] : [];
-  });
-}
-function printPreflight(results) {
-  if (results.length === 0) return;
-  const ok = results.filter((r) => r.status === "ok");
-  const unknown = results.filter((r) => r.status === "unknown");
-  const action = results.filter((r) => r.status === "action_required");
-  console.log("");
-  console.log(chalk.bold("Agent preflight:"));
-  for (const r of ok) {
-    console.log(`  ${chalk.green("\u2713")} ${r.agent.padEnd(7)} ${chalk.dim(r.message)}`);
-  }
-  for (const r of unknown) {
-    console.log(`  ${chalk.dim("?")} ${r.agent.padEnd(7)} ${chalk.dim(r.message)}`);
-  }
-  for (const r of action) {
-    console.log(`  ${chalk.yellow("\u2192")} ${chalk.bold(r.agent.padEnd(7))} ${r.message}`);
-    if (r.command) console.log(`      ${chalk.cyan(r.command)}`);
-  }
-}
-
-// src/claude-settings.ts
-var HOLDPOINT_CLAUDE_HOOK_MARKER = "HOLDPOINT_MANAGED=claude";
-function isObject(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-function asHookArray(value) {
-  return Array.isArray(value) ? value : [];
-}
-function isManagedHookCommand(value) {
-  return isObject(value) && typeof value.command === "string" && value.command.includes(HOLDPOINT_CLAUDE_HOOK_MARKER);
-}
-function isLegacyManagedHookCommand(value) {
-  if (!isObject(value) || typeof value.command !== "string") return false;
-  return value.command === "node_modules/.bin/holdpoint event --engine claude --from-hook || true" || value.command === "node_modules/.bin/holdpoint check --staged";
-}
-function isManagedHookEntry(value) {
-  if (!isObject(value)) return false;
-  const hooks = asHookArray(value.hooks);
-  return hooks.length > 0 && (hooks.every(isManagedHookCommand) || hooks.every(isLegacyManagedHookCommand));
-}
-function mergeClaudeSettings(existing, generated) {
-  const existingHooks = isObject(existing.hooks) ? existing.hooks : {};
-  const generatedHooks = isObject(generated.hooks) ? generated.hooks : {};
-  const mergedHooks = {};
-  for (const eventName of /* @__PURE__ */ new Set([
-    ...Object.keys(existingHooks),
-    ...Object.keys(generatedHooks)
-  ])) {
-    const preserved = asHookArray(existingHooks[eventName]).filter(
-      (entry) => !isManagedHookEntry(entry)
-    );
-    const next = asHookArray(generatedHooks[eventName]);
-    if (preserved.length > 0 || next.length > 0) {
-      mergedHooks[eventName] = [...preserved, ...next];
-    }
-  }
-  return { ...existing, ...generated, hooks: mergedHooks };
-}
-
-// src/cursor-hooks.ts
-var HOLDPOINT_CURSOR_HOOK_MARKER = "HOLDPOINT_MANAGED=cursor";
-function isObject2(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-function asHookArray2(value) {
-  return Array.isArray(value) ? value : [];
-}
-function isManagedCursorHook(value) {
-  return isObject2(value) && typeof value.command === "string" && (value.command.includes(HOLDPOINT_CURSOR_HOOK_MARKER) || value.command.includes(".cursor/holdpoint-hook.mjs"));
-}
-function mergeCursorHooks(existing, generated) {
-  const existingHooks = isObject2(existing.hooks) ? existing.hooks : {};
-  const generatedHooks = isObject2(generated.hooks) ? generated.hooks : {};
-  const mergedHooks = {};
-  for (const eventName of /* @__PURE__ */ new Set([
-    ...Object.keys(existingHooks),
-    ...Object.keys(generatedHooks)
-  ])) {
-    const preserved = asHookArray2(existingHooks[eventName]).filter(
-      (entry) => !isManagedCursorHook(entry)
-    );
-    const next = asHookArray2(generatedHooks[eventName]);
-    if (preserved.length > 0 || next.length > 0) {
-      mergedHooks[eventName] = [...preserved, ...next];
-    }
-  }
-  return { ...existing, ...generated, hooks: mergedHooks };
-}
-
-// src/lib/instructions-breadcrumb.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
-import { dirname as dirname2 } from "path";
-var START_MARKER = "<!-- HOLDPOINT_MANAGED \u2014 content between these markers is auto-generated by holdpoint init / holdpoint update -->";
-var END_MARKER = "<!-- /HOLDPOINT_MANAGED -->";
-var BREADCRUMB_BODY = `## Holdpoint workflow
-
-This repo uses [Holdpoint](https://holdpoint.dev) to gate task completion on deterministic checks.
-
-Before marking any task done:
-
-1. Run \`holdpoint check\` (or it will run automatically via Stop / TaskCompleted hooks).
-2. Fix any failures. Re-run until exit 0.
-3. Never bypass with \`--no-verify\` or by skipping the agent's stop hook.
-
-Full workflow reference: [\`MASTER_PROMPT.md\`](./MASTER_PROMPT.md) (always injected at session start).
-Deep reference: [\`HOLDPOINT_REFERENCE.md\`](./HOLDPOINT_REFERENCE.md) (read on demand).
-Active checks: [\`checks.yaml\`](./checks.yaml).`;
-function spliceBreadcrumb(filePath, body = BREADCRUMB_BODY, createIfMissing = true) {
-  const block = `${START_MARKER}
-
-${body}
-
-${END_MARKER}`;
-  if (!existsSync3(filePath)) {
-    if (!createIfMissing) return;
-    mkdirSync(dirname2(filePath), { recursive: true });
-    writeFileSync2(filePath, block + "\n", "utf8");
-    return;
-  }
-  const existing = readFileSync2(filePath, "utf8");
-  const startIdx = existing.indexOf(START_MARKER);
-  const endIdx = existing.indexOf(END_MARKER);
-  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
-    const before = existing.slice(0, startIdx);
-    const after = existing.slice(endIdx + END_MARKER.length);
-    writeFileSync2(filePath, before + block + after, "utf8");
-    return;
-  }
-  const sep2 = existing.endsWith("\n") ? "\n" : "\n\n";
-  writeFileSync2(filePath, existing + sep2 + block + "\n", "utf8");
-}
-
-// src/commands/init.ts
-var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-function getDefaultTemplatePath() {
-  const candidates = [
-    join2(__dirname2, "templates", "default.yaml"),
-    // dist/templates/ (published package)
-    join2(__dirname2, "../../../templates", "default.yaml"),
-    // monorepo dev fallback
-    join2(process.cwd(), "templates", "default.yaml")
-    // cwd fallback
-  ];
-  for (const p of candidates) {
-    if (existsSync4(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'"
-
-  - id: jsdoc
-    label: "JSDoc on changed public functions"
-    prompt: "Ensure all changed public functions and exports have JSDoc comments."
-`;
-var MINIMAL_MASTER_PROMPT = `# Holdpoint
-
-Run \`holdpoint check\` before marking any task complete.
-See \`checks.yaml\` for the full list of checks.
-`;
-var MINIMAL_HOLDPOINT_REFERENCE = `# Holdpoint reference
-
-Read \`MASTER_PROMPT.md\` first for the mandatory workflow, then use this file for deeper project-specific Holdpoint notes.
-`;
-var MINIMAL_PREREQUISITES = `# Holdpoint prerequisites
-
-Holdpoint installed repo-local engine integrations for one or more AI coding agents. Before relying on them locally, review these setup notes:
-
-- **GitHub Copilot CLI** \u2014 Holdpoint's \`.github/extensions/holdpoint/extension.mjs\` uses the Copilot CLI **EXTENSIONS** feature. Today that feature is gated behind experimental mode. In Copilot CLI, run \`/experimental on\` so **EXTENSIONS** appears in the enabled feature set before using Holdpoint locally.
-- **Cursor** \u2014 project-level hooks run in trusted workspaces. After opening the repo in Cursor, confirm the workspace is trusted and review Settings \u2192 Hooks if hooks do not fire.
-- **OpenAI Codex** \u2014 project-level hooks require trust approval. Run \`codex trust\` in the Codex TUI or review the hook with \`/hooks\`.
-- **General** \u2014 Holdpoint expects Node.js 18+ and a git repository so \`holdpoint init\`, \`holdpoint update\`, and \`holdpoint check\` can run normally.
-
-Docs: https://holdpoint.dev/docs
-`;
-async function initCommand(options) {
-  const spinner = ora("Initialising Holdpoint\u2026").start();
-  const agentOpt = options.agent;
-  const agents = !agentOpt || agentOpt === "all" ? ["copilot", "claude", "cursor", "codex"] : [agentOpt];
-  spinner.text = `Installing for: ${chalk2.cyan(agents.join(", "))}`;
-  const pm = detectPackageManager();
-  let yamlContent = MINIMAL_CHECKS_YAML;
-  if (!existsSync4("checks.yaml")) {
-    const templatePath = getDefaultTemplatePath();
-    if (templatePath) {
-      yamlContent = readFileSync3(templatePath, "utf8");
-    }
-    if (pm !== "pnpm") {
-      yamlContent = yamlContent.replace(/\bpnpm\b/g, pm);
-    }
-    writeFileSync3("checks.yaml", yamlContent, "utf8");
-  } else {
-    yamlContent = readFileSync3("checks.yaml", "utf8");
-  }
-  const config = parseHoldpointYaml(yamlContent);
-  const generatedDir = ".github/holdpoint/generated";
-  mkdirSync2(generatedDir, { recursive: true });
-  writeFileSync3(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
-  if (agents.includes("copilot")) {
-    const extDir = ".github/extensions/holdpoint";
-    mkdirSync2(extDir, { recursive: true });
-    writeFileSync3(join2(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 (existsSync4(settingsPath)) {
-      try {
-        existing = JSON.parse(readFileSync3(settingsPath, "utf8"));
-      } catch {
-      }
-    }
-    const holdpointHooks = JSON.parse(buildClaudeEngineJson(config));
-    writeFileSync3(
-      settingsPath,
-      JSON.stringify(mergeClaudeSettings(existing, holdpointHooks), null, 2),
-      "utf8"
-    );
-    spliceBreadcrumb("CLAUDE.md");
-  }
-  if (agents.includes("cursor")) {
-    mkdirSync2(".cursor", { recursive: true });
-    const cursorHooksPath = ".cursor/hooks.json";
-    let existingHooks = {};
-    if (existsSync4(cursorHooksPath)) {
-      try {
-        existingHooks = JSON.parse(readFileSync3(cursorHooksPath, "utf8"));
-      } catch {
-      }
-    }
-    const cursorHooks = JSON.parse(buildCursorHooksJson(config));
-    writeFileSync3(
-      cursorHooksPath,
-      JSON.stringify(mergeCursorHooks(existingHooks, cursorHooks), null, 2) + "\n",
-      "utf8"
-    );
-    writeFileSync3(".cursor/holdpoint-hook.mjs", buildCursorCheckScript(), "utf8");
-    const cursorRules = buildCursorEngine(config);
-    const cursorPath = ".cursorrules";
-    if (existsSync4(cursorPath)) {
-      const existing = readFileSync3(cursorPath, "utf8");
-      if (!existing.includes("Holdpoint Rules")) {
-        writeFileSync3(cursorPath, `${existing.trimEnd()}
-
-${cursorRules}`, "utf8");
-      }
-    } else {
-      writeFileSync3(cursorPath, cursorRules, "utf8");
-    }
-    spliceBreadcrumb(".cursor/rules/holdpoint.md");
-  }
-  if (agents.includes("codex")) {
-    mkdirSync2(".codex", { recursive: true });
-    writeFileSync3(".codex/hooks.json", buildCodexHooksJson(config), "utf8");
-    writeFileSync3(".codex/holdpoint-check.mjs", buildCodexCheckScript(config), "utf8");
-    writeFileSync3(".codex/config.toml", buildCodexConfigToml(), "utf8");
-    spliceBreadcrumb("AGENTS.md");
-  }
-  ensureBundledFile("MASTER_PROMPT.md", "MASTER_PROMPT.md", MINIMAL_MASTER_PROMPT);
-  ensureBundledFile(
-    "HOLDPOINT_REFERENCE.md",
-    "HOLDPOINT_REFERENCE.md",
-    MINIMAL_HOLDPOINT_REFERENCE
-  );
-  ensureBundledFile(
-    "HOLDPOINT_PREREQUISITES.md",
-    "HOLDPOINT_PREREQUISITES.md",
-    MINIMAL_PREREQUISITES
-  );
-  spinner.text = "Installing holdpoint as a devDependency\u2026";
-  const installCmds = {
-    pnpm: "pnpm add -D holdpoint",
-    yarn: "yarn add --dev holdpoint",
-    npm: "npm install --save-dev holdpoint"
-  };
-  const installCmd = installCmds[pm];
-  try {
-    execSync2(installCmd, { stdio: "pipe" });
-    spinner.succeed(chalk2.bold.green("Holdpoint initialised!"));
-  } catch {
-    spinner.warn(
-      chalk2.yellow(`Holdpoint initialised, but could not install the package automatically.`) + `
-  Run manually: ${chalk2.yellow(installCmd)}`
-    );
-  }
-  const preflight = runPreflight(agents);
-  printPreflight(preflight);
-  console.log(`
-${chalk2.cyan("Next steps:")}
-  1. Edit ${chalk2.yellow("checks.yaml")} to customise your eval checkpoints
-  2. Address any ${chalk2.yellow("\u2192")} items above (full notes in ${chalk2.yellow("HOLDPOINT_PREREQUISITES.md")})
-  3. Commit ${chalk2.yellow("checks.yaml")}, ${chalk2.yellow("HOLDPOINT_PREREQUISITES.md")}, and the generated engine files
-  4. Run ${chalk2.yellow("holdpoint check")} at any time to validate
-
-  Visual builder: ${chalk2.yellow("holdpoint builder")}  (opens the daemon at /builder)
-  Agents: ${chalk2.cyan(agents.join(", "))}
-`);
-}
-
 // src/commands/check.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
-import chalk3 from "chalk";
-import ora2 from "ora";
-import { parseHoldpointYaml as parseHoldpointYaml2, matchesWhen } from "@holdpoint/yaml-core";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { parseHoldpointYaml, matchesWhen } from "@holdpoint/yaml-core";
 import { runDeterministicChecks } from "@holdpoint/yaml-core/runner";
-import { execSync as execSync3 } from "child_process";
+import { execSync } from "child_process";
 import { randomUUID } from "crypto";
 import { identifyProject } from "@holdpoint/live-daemon";
 import { BridgeClient } from "@holdpoint/sdk";
@@ -499,7 +28,7 @@ var CHECK_REPORTS_PATH = ".holdpoint/check-reports.json";
 var CHECK_REPORTS_MAX = 50;
 function getStagedFiles() {
   try {
-    const out = execSync3("git diff --cached --name-only", {
+    const out = execSync("git diff --cached --name-only", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -510,7 +39,7 @@ function getStagedFiles() {
 }
 function getAllChangedFiles() {
   try {
-    const out = execSync3("git diff --name-only HEAD", {
+    const out = execSync("git diff --name-only HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -521,7 +50,7 @@ function getAllChangedFiles() {
 }
 function getLastCommitFiles() {
   try {
-    const out = execSync3("git diff --name-only HEAD~1 HEAD", {
+    const out = execSync("git diff --name-only HEAD~1 HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -532,7 +61,7 @@ function getLastCommitFiles() {
 }
 function getHeadSha() {
   try {
-    return execSync3("git rev-parse HEAD", {
+    return execSync("git rev-parse HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -542,7 +71,7 @@ function getHeadSha() {
 }
 function readCommitCache() {
   try {
-    const raw = readFileSync4(COMMIT_CACHE_PATH, "utf8");
+    const raw = readFileSync(COMMIT_CACHE_PATH, "utf8");
     const parsed = JSON.parse(raw);
     return new Set(Array.isArray(parsed.verified) ? parsed.verified : []);
   } catch {
@@ -553,18 +82,18 @@ function recordCommitCache(sha) {
   try {
     const existing = readCommitCache();
     const updated = [sha, ...[...existing].filter((s) => s !== sha)].slice(0, COMMIT_CACHE_MAX);
-    mkdirSync3(join3(COMMIT_CACHE_PATH, ".."), { recursive: true });
-    writeFileSync4(COMMIT_CACHE_PATH, JSON.stringify({ verified: updated }, null, 2) + "\n", "utf8");
+    mkdirSync(join(COMMIT_CACHE_PATH, ".."), { recursive: true });
+    writeFileSync(COMMIT_CACHE_PATH, JSON.stringify({ verified: updated }, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 function recordCheckReport(run) {
   try {
-    mkdirSync3(join3(CHECK_REPORTS_PATH, ".."), { recursive: true });
+    mkdirSync(join(CHECK_REPORTS_PATH, ".."), { recursive: true });
     let existing = { runs: [] };
-    if (existsSync5(CHECK_REPORTS_PATH)) {
+    if (existsSync(CHECK_REPORTS_PATH)) {
       try {
-        existing = JSON.parse(readFileSync4(CHECK_REPORTS_PATH, "utf8"));
+        existing = JSON.parse(readFileSync(CHECK_REPORTS_PATH, "utf8"));
         if (!Array.isArray(existing.runs)) existing.runs = [];
       } catch {
         existing = { runs: [] };
@@ -573,21 +102,38 @@ function recordCheckReport(run) {
     const updated = {
       runs: [run, ...existing.runs].slice(0, CHECK_REPORTS_MAX)
     };
-    writeFileSync4(CHECK_REPORTS_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    writeFileSync(CHECK_REPORTS_PATH, JSON.stringify(updated, null, 2) + "\n", "utf8");
   } catch {
   }
 }
 async function checkCommand(options) {
-  if (!existsSync5("checks.yaml")) {
-    console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
-    process.exit(1);
+  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 = readFileSync4("checks.yaml", "utf8");
+  const yamlContent = readFileSync("checks.yaml", "utf8");
   let config;
   try {
-    config = parseHoldpointYaml2(yamlContent);
+    config = parseHoldpointYaml(yamlContent);
   } catch (err) {
-    console.error(chalk3.red("Invalid checks.yaml:"), err.message);
+    console.error(chalk.red("Invalid checks.yaml:"), err.message);
     process.exit(1);
   }
   const headSha = getHeadSha();
@@ -600,7 +146,7 @@ async function checkCommand(options) {
     } else {
       if (headSha && readCommitCache().has(headSha)) {
         console.log(
-          chalk3.green(`\u2713 Commit ${headSha.slice(0, 8)} already verified \u2014 nothing to re-check.`)
+          chalk.green(`\u2713 Commit ${headSha.slice(0, 8)} already verified \u2014 nothing to re-check.`)
         );
         process.exit(0);
       }
@@ -609,10 +155,10 @@ async function checkCommand(options) {
         changedFiles = lastCommit;
         usedHeadShaForCache = true;
         console.log(
-          chalk3.yellow("No staged files. Running checks scoped to the most recent commit's files.")
+          chalk.yellow("No staged files. Running checks scoped to the most recent commit's files.")
         );
       } else {
-        console.log(chalk3.green("\u2713 No staged changes and no recent commit \u2014 nothing to check."));
+        console.log(chalk.green("\u2713 No staged changes and no recent commit \u2014 nothing to check."));
         process.exit(0);
       }
     }
@@ -620,10 +166,10 @@ async function checkCommand(options) {
     changedFiles = getAllChangedFiles();
     if (changedFiles.length === 0) {
       console.log(
-        chalk3.yellow("No changed files detected. Running all checks with no file filter.")
+        chalk.yellow("No changed files detected. Running all checks with no file filter.")
       );
       console.log(
-        chalk3.dim(
+        chalk.dim(
           "  Tip: if you just ran `holdpoint init`, commit the generated files to clear the git-commit check."
         )
       );
@@ -631,14 +177,14 @@ async function checkCommand(options) {
   }
   const guides = Object.entries(config.context?.guides ?? {});
   if (guides.length > 0) {
-    console.log(chalk3.cyan("\nProject guides:"));
+    console.log(chalk.cyan("\nProject guides:"));
     for (const [key, text] of guides) {
-      console.log(chalk3.bold(`  ${key}:`), chalk3.dim(String(text).trim()));
+      console.log(chalk.bold(`  ${key}:`), chalk.dim(String(text).trim()));
     }
     console.log("");
   }
   const taskCount = config.checks.filter((c) => c.cmd !== void 0).length;
-  const spinner = ora2(`Running ${taskCount} task(s)\u2026`).start();
+  const spinner = ora(`Running ${taskCount} task(s)\u2026`).start();
   const effectiveFiles = changedFiles.length > 0 ? changedFiles : ["__all__"];
   const results = runDeterministicChecks(config, effectiveFiles);
   const passed = results.filter((r) => r.status === "pass");
@@ -651,19 +197,29 @@ async function checkCommand(options) {
   console.log("");
   console.log(
     [
-      chalk3.green(`\u2713 ${passed.length} passed`),
-      failed.length > 0 ? chalk3.red(`\u2717 ${failed.length} failed`) : "",
-      skipped.length > 0 ? chalk3.gray(`\u25CC ${skipped.length} skipped`) : ""
+      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 = config.checks.filter(
-    (c) => c.prompt !== void 0 && matchesWhen(c.when, changedFiles.length > 0 ? changedFiles : ["__all__"], config.patterns)
-  );
+  const promptChecks = changedFiles.length > 0 ? config.checks.filter(
+    (c) => c.prompt !== void 0 && matchesWhen(c.when, changedFiles, config.patterns)
+  ) : [];
   if (promptChecks.length > 0) {
     console.log(`
-${chalk3.cyan("Agent prompts to act on:")}`);
+${chalk.cyan("Agent prompts to act on:")}`);
     for (const c of promptChecks) {
-      console.log(`  ${chalk3.yellow("\u25A1")} [${c.label}] ${c.prompt ?? ""}`);
+      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 = [
@@ -729,70 +285,70 @@ ${chalk3.cyan("Agent prompts to act on:")}`);
   }
 }
 function printResult(result) {
-  const icon = result.status === "pass" ? chalk3.green("\u2713") : result.status === "fail" ? chalk3.red("\u2717") : result.status === "skip" ? chalk3.gray("\u25CC") : chalk3.yellow("\u2026");
+  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(chalk3.dim(trimmed.replace(/^/gm, "    ")));
+    console.log(chalk.dim(trimmed.replace(/^/gm, "    ")));
   }
   if (result.status === "skip" && result.skipReason) {
-    console.log(chalk3.dim(`    ${result.skipReason}`));
+    console.log(chalk.dim(`    ${result.skipReason}`));
   }
 }
 
 // src/commands/validate.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import chalk4 from "chalk";
-import { parseHoldpointYaml as parseHoldpointYaml3, validateConfig } from "@holdpoint/yaml-core";
+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 (!existsSync6("checks.yaml")) {
-    console.error(chalk4.red("No checks.yaml found. Run `holdpoint init` first."));
+  if (!existsSync2("checks.yaml")) {
+    console.error(chalk2.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
-  const text = readFileSync5("checks.yaml", "utf8");
+  const text = readFileSync2("checks.yaml", "utf8");
   let config;
   try {
-    config = parseHoldpointYaml3(text);
+    config = parseHoldpointYaml2(text);
   } catch (err) {
-    console.error(chalk4.red("Parse error:"), err.message);
+    console.error(chalk2.red("Parse error:"), err.message);
     process.exit(1);
   }
   const result = validateConfig(config);
   if (result.valid) {
-    console.log(chalk4.green("\u2713 checks.yaml is valid"));
+    console.log(chalk2.green("\u2713 checks.yaml is valid"));
     console.log(
-      chalk4.dim(
+      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 {
-    console.error(chalk4.red("\u2717 checks.yaml has errors:"));
+    console.error(chalk2.red("\u2717 checks.yaml has errors:"));
     for (const err of result.errors) {
-      console.error(`  ${chalk4.yellow(err.path)}: ${err.message}`);
+      console.error(`  ${chalk2.yellow(err.path)}: ${err.message}`);
     }
     process.exit(1);
   }
 }
 
 // src/commands/update.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
-import chalk5 from "chalk";
-import ora3 from "ora";
-import { parseHoldpointYaml as parseHoldpointYaml4 } from "@holdpoint/yaml-core";
-import { buildConfigJson as buildConfigJson2, buildEngine as buildEngine2 } from "@holdpoint/engine-copilot";
-import { buildEngineJson as buildClaudeEngineJson2 } from "@holdpoint/engine-claude";
+import { 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 buildCursorCheckScript2,
-  buildEngine as buildCursorEngine2,
-  buildHooksJson as buildCursorHooksJson2
+  buildCheckScript as buildCursorCheckScript,
+  buildEngine as buildCursorEngine,
+  buildHooksJson as buildCursorHooksJson
 } from "@holdpoint/engine-cursor";
 import {
-  buildConfigToml as buildCodexConfigToml2,
-  buildHooksJson as buildCodexHooksJson2,
-  buildCheckScript as buildCodexCheckScript2
+  buildConfigToml as buildCodexConfigToml,
+  buildHooksJson as buildCodexHooksJson,
+  buildCheckScript as buildCodexCheckScript
 } from "@holdpoint/engine-codex";
-var MINIMAL_PREREQUISITES2 = `# Holdpoint prerequisites
+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:
 
@@ -803,66 +359,66 @@ Holdpoint installed repo-local engine integrations for one or more AI coding age
 
 Docs: https://holdpoint.dev/docs
 `;
-var MINIMAL_HOLDPOINT_REFERENCE2 = `# Holdpoint reference
+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 (!existsSync7("checks.yaml")) {
-    console.error(chalk5.red("No checks.yaml found. Run `holdpoint init` first."));
+  if (!existsSync3("checks.yaml")) {
+    console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
-  const spinner = ora3("Updating Holdpoint engine files\u2026").start();
-  const config = parseHoldpointYaml4(readFileSync6("checks.yaml", "utf8"));
+  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";
-  mkdirSync4(generatedDir, { recursive: true });
-  writeFileSync5(`${generatedDir}/checks.immutable.json`, buildConfigJson2(config), "utf8");
+  mkdirSync2(generatedDir, { recursive: true });
+  writeFileSync2(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
   if (agents.includes("copilot")) {
     const extDir = ".github/extensions/holdpoint";
-    mkdirSync4(extDir, { recursive: true });
-    writeFileSync5(`${extDir}/extension.mjs`, buildEngine2(config), "utf8");
+    mkdirSync2(extDir, { recursive: true });
+    writeFileSync2(`${extDir}/extension.mjs`, buildEngine(config), "utf8");
     spliceBreadcrumb(".github/copilot-instructions.md");
   }
   if (agents.includes("claude")) {
-    mkdirSync4(".claude", { recursive: true });
+    mkdirSync2(".claude", { recursive: true });
     const settingsPath = ".claude/settings.json";
     let existing = {};
-    if (existsSync7(settingsPath)) {
+    if (existsSync3(settingsPath)) {
       try {
-        existing = JSON.parse(readFileSync6(settingsPath, "utf8"));
+        existing = JSON.parse(readFileSync3(settingsPath, "utf8"));
       } catch {
       }
     }
-    const hooks = JSON.parse(buildClaudeEngineJson2(config));
-    writeFileSync5(
+    const hooks = JSON.parse(buildClaudeEngineJson(config));
+    writeFileSync2(
       settingsPath,
       JSON.stringify(mergeClaudeSettings(existing, hooks), null, 2) + "\n"
     );
     spliceBreadcrumb("CLAUDE.md");
   }
   if (agents.includes("cursor")) {
-    mkdirSync4(".cursor", { recursive: true });
+    mkdirSync2(".cursor", { recursive: true });
     const cursorHooksPath = ".cursor/hooks.json";
     let existingHooks = {};
-    if (existsSync7(cursorHooksPath)) {
+    if (existsSync3(cursorHooksPath)) {
       try {
-        existingHooks = JSON.parse(readFileSync6(cursorHooksPath, "utf8"));
+        existingHooks = JSON.parse(readFileSync3(cursorHooksPath, "utf8"));
       } catch {
       }
     }
-    const cursorHooks = JSON.parse(buildCursorHooksJson2(config));
-    writeFileSync5(
+    const cursorHooks = JSON.parse(buildCursorHooksJson(config));
+    writeFileSync2(
       cursorHooksPath,
       JSON.stringify(mergeCursorHooks(existingHooks, cursorHooks), null, 2) + "\n",
       "utf8"
     );
-    writeFileSync5(".cursor/holdpoint-hook.mjs", buildCursorCheckScript2(), "utf8");
-    const cursorRules = buildCursorEngine2(config);
+    writeFileSync2(".cursor/holdpoint-hook.mjs", buildCursorCheckScript(), "utf8");
+    const cursorRules = buildCursorEngine(config);
     const cursorPath = ".cursorrules";
-    if (existsSync7(cursorPath)) {
-      const content = readFileSync6(cursorPath, "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) {
@@ -873,28 +429,28 @@ async function updateCommand() {
 
 ` : "") + cursorRules + (suffix ? `
 ${suffix}` : "");
-        writeFileSync5(cursorPath, updated);
+        writeFileSync2(cursorPath, updated);
       } else {
-        writeFileSync5(cursorPath, `${content.trimEnd()}
+        writeFileSync2(cursorPath, `${content.trimEnd()}
 
 ${cursorRules}`);
       }
     } else {
-      writeFileSync5(cursorPath, cursorRules);
+      writeFileSync2(cursorPath, cursorRules);
     }
     spliceBreadcrumb(".cursor/rules/holdpoint.md");
   }
   if (agents.includes("codex")) {
-    mkdirSync4(".codex", { recursive: true });
-    writeFileSync5(".codex/hooks.json", buildCodexHooksJson2(config), "utf8");
-    writeFileSync5(".codex/holdpoint-check.mjs", buildCodexCheckScript2(config), "utf8");
+    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 (!existsSync7(configTomlPath)) {
-      writeFileSync5(configTomlPath, buildCodexConfigToml2(), "utf8");
+    if (!existsSync3(configTomlPath)) {
+      writeFileSync2(configTomlPath, buildCodexConfigToml(), "utf8");
     } else {
-      const existing = readFileSync6(configTomlPath, "utf8");
+      const existing = readFileSync3(configTomlPath, "utf8");
       if (!existing.includes("[features]")) {
-        writeFileSync5(configTomlPath, existing.trimEnd() + "\n\n" + buildCodexConfigToml2(), "utf8");
+        writeFileSync2(configTomlPath, existing.trimEnd() + "\n\n" + buildCodexConfigToml(), "utf8");
       }
     }
     spliceBreadcrumb("AGENTS.md");
@@ -902,22 +458,22 @@ ${cursorRules}`);
   const wroteReference = ensureBundledFile(
     "HOLDPOINT_REFERENCE.md",
     "HOLDPOINT_REFERENCE.md",
-    MINIMAL_HOLDPOINT_REFERENCE2
+    MINIMAL_HOLDPOINT_REFERENCE
   );
   const wrotePrerequisites = ensureBundledFile(
     "HOLDPOINT_PREREQUISITES.md",
     "HOLDPOINT_PREREQUISITES.md",
-    MINIMAL_PREREQUISITES2
+    MINIMAL_PREREQUISITES
   );
-  spinner.succeed(chalk5.green("Engine files updated from current checks.yaml"));
+  spinner.succeed(chalk3.green("Engine files updated from current checks.yaml"));
   if (wroteReference) {
     console.log(
-      chalk5.cyan("Created HOLDPOINT_REFERENCE.md with the full Holdpoint workflow reference.")
+      chalk3.cyan("Created HOLDPOINT_REFERENCE.md with the full Holdpoint workflow reference.")
     );
   }
   if (wrotePrerequisites) {
     console.log(
-      chalk5.cyan(
+      chalk3.cyan(
         "Created HOLDPOINT_PREREQUISITES.md with Copilot experimental-mode and other agent setup notes."
       )
     );
@@ -925,7 +481,7 @@ ${cursorRules}`);
 }
 
 // src/commands/build.ts
-import chalk6 from "chalk";
+import chalk4 from "chalk";
 
 // src/lib/ensure-daemon.ts
 import { spawn } from "child_process";
@@ -960,27 +516,27 @@ async function ensureDaemon(timeoutMs = 5e3) {
 }
 
 // src/lib/open-browser.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function openBrowser(url) {
   const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   try {
-    execSync4(`${openCmd} ${JSON.stringify(url)}`, { stdio: "ignore" });
+    execSync2(`${openCmd} ${JSON.stringify(url)}`, { stdio: "ignore" });
   } catch {
   }
 }
 
 // src/lib/project.ts
-import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname4, join as join4 } from "path";
+import { 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 = join4(current, "checks.yaml");
-    if (existsSync8(candidate)) {
+    const candidate = join2(current, "checks.yaml");
+    if (existsSync4(candidate)) {
       return candidate;
     }
-    const parent = dirname4(current);
+    const parent = dirname(current);
     if (parent === current) {
       return null;
     }
@@ -990,7 +546,7 @@ function findChecksYaml(startDir) {
 function tryResolveCurrentProject() {
   const checksYaml = findChecksYaml(process.cwd());
   if (checksYaml) {
-    return identifyProject2(dirname4(checksYaml));
+    return identifyProject2(dirname(checksYaml));
   }
   try {
     return identifyProject2(process.cwd());
@@ -1016,50 +572,50 @@ async function buildCommand() {
   appendProjectAuthParams(url, tryResolveCurrentProject());
   openBrowser(url.toString());
   console.log(
-    chalk6.green(
+    chalk4.green(
       started ? "\u2713 Started Holdpoint Live and opened the builder" : "\u2713 Opened Holdpoint builder"
     )
   );
-  console.log(`  url: ${chalk6.cyan(url.toString())}`);
+  console.log(`  url: ${chalk4.cyan(url.toString())}`);
 }
 
 // src/commands/evolve.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { execSync as execSync7 } from "child_process";
-import chalk7 from "chalk";
-import ora4 from "ora";
-import { parseHoldpointYaml as parseHoldpointYaml5, generateYaml } from "@holdpoint/yaml-core";
+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 existsSync9, readFileSync as readFileSync7, readdirSync } from "fs";
-import { join as join5 } from "path";
-import { execSync as execSync5 } 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(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return null;
   }
 }
 function tryReadText(path) {
   try {
-    return readFileSync7(path, "utf8");
+    return readFileSync4(path, "utf8");
   } catch {
     return "";
   }
 }
 function scanProject(cwd = process.cwd()) {
-  const exists = (p) => existsSync9(join5(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(join5(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(join5(cwd, "pyproject.toml"));
-  const requirementsText = tryReadText(join5(cwd, "requirements.txt"));
-  const pipfileText = tryReadText(join5(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");
@@ -1104,6 +660,10 @@ 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
@@ -1111,9 +671,9 @@ function scanProject(cwd = process.cwd()) {
 }
 
 // src/evolve/dead-checker.ts
-import { execSync as execSync6 } from "child_process";
-import { readdirSync as readdirSync2, existsSync as existsSync10 } from "fs";
-import { join as join6 } from "path";
+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",
@@ -1158,7 +718,7 @@ function walkDir(dir, root, depth, maxDepth) {
   const results = [];
   for (const entry of entries) {
     if (WALK_IGNORED.has(entry) || entry.startsWith(".")) continue;
-    const full = join6(dir, entry);
+    const full = join4(dir, entry);
     const rel = full.slice(root.length + 1);
     results.push(rel);
     const children = walkDir(full, root, depth + 1, maxDepth);
@@ -1168,7 +728,7 @@ function walkDir(dir, root, depth, maxDepth) {
 }
 function getRepoFiles(cwd) {
   try {
-    const out = execSync6("git ls-files", {
+    const out = execSync4("git ls-files", {
       cwd,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
@@ -1205,7 +765,7 @@ function detectStaleChecks(config, repoFiles) {
     if (matches.length === 0) {
       const label = patternAlias ? `Pattern '${patternAlias}' (= '${regexStr}')` : `Regex '${regexStr}'`;
       const suggestedConditionPath = extractPathFromRegex(regexStr);
-      const pathGone = !suggestedConditionPath || !existsSync10(join6(process.cwd(), suggestedConditionPath));
+      const pathGone = !suggestedConditionPath || !existsSync6(join4(process.cwd(), suggestedConditionPath));
       if (pathGone) {
         stale.push({
           check,
@@ -1240,7 +800,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",
@@ -1409,20 +973,20 @@ function withHeader(header, newYaml) {
   return header + "\n\n" + newYaml;
 }
 async function evolveCommand(options) {
-  if (!existsSync11("checks.yaml")) {
-    console.error(chalk7.red("No checks.yaml found. Run `holdpoint init` first."));
+  if (!existsSync7("checks.yaml")) {
+    console.error(chalk5.red("No checks.yaml found. Run `holdpoint init` first."));
     process.exit(1);
   }
-  const spinner = 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 = readFileSync8("checks.yaml", "utf8");
+  const yamlContent = readFileSync5("checks.yaml", "utf8");
   let config;
   try {
-    config = parseHoldpointYaml5(yamlContent);
+    config = parseHoldpointYaml4(yamlContent);
   } catch (err) {
-    spinner.fail(chalk7.red("Invalid checks.yaml:") + " " + err.message);
+    spinner.fail(chalk5.red("Invalid checks.yaml:") + " " + err.message);
     process.exit(1);
   }
   spinner.stop();
@@ -1431,7 +995,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(chalk7.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.*"],
@@ -1457,44 +1021,44 @@ async function evolveCommand(options) {
   ];
   const detected = traits.filter(([, yes]) => yes);
   if (detected.length === 0) {
-    console.log(chalk7.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(`  ${chalk7.green("\u2713")} ${name.padEnd(18)} ${chalk7.dim(hint)}`);
+      console.log(`  ${chalk5.green("\u2713")} ${name.padEnd(18)} ${chalk5.dim(hint)}`);
     }
   }
   if (staleChecks.length > 0) {
-    console.log(chalk7.bold(`
+    console.log(chalk5.bold(`
 \u26A0\uFE0F  Stale checks (${staleChecks.length}):`));
     for (const { check, reason, suggestedConditionPath } of staleChecks) {
-      const fix = suggestedConditionPath ? chalk7.dim(` \u2192 will wrap with conditionId: file_exists: ${suggestedConditionPath}`) : chalk7.dim(" \u2192 no path inferred; review manually");
-      console.log(`  ${chalk7.yellow("\u25CC")} ${chalk7.bold(check.id)}  ${chalk7.dim(reason)}${fix}`);
+      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(chalk7.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(chalk7.bold(`
+    console.log(chalk5.bold(`
 \u{1F4A1} Proposed additions (${proposals.length}):`));
     for (const t of proposals) {
-      const scope = t.when ? chalk7.cyan(` when: ${t.when}`) : "";
-      const type = t.cmd ? chalk7.dim("cmd") : chalk7.dim("prompt");
-      const preview = t.cmd ? chalk7.dim(`  ${t.cmd.slice(0, 80)}${t.cmd.length > 80 ? "\u2026" : ""}`) : chalk7.dim(`  ${(t.prompt ?? "").slice(0, 80)}${(t.prompt?.length ?? 0) > 80 ? "\u2026" : ""}`);
-      console.log(`  ${chalk7.green("+")} ${chalk7.bold(t.id.padEnd(24))} [${type}]${scope}`);
+      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(
-      chalk7.red(`
+      chalk5.red(`
 \u2717 checks.yaml is out of sync with the project profile.`) + `
-  Run ${chalk7.bold("npx @holdpoint/cli suggest --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)) {
@@ -1531,33 +1095,33 @@ async function evolveCommand(options) {
   };
   const header = extractHeader(yamlContent);
   const newYaml = withHeader(header, generateYaml(updatedConfig));
-  writeFileSync6("checks.yaml", newYaml, "utf8");
+  writeFileSync3("checks.yaml", newYaml, "utf8");
   applySpinner.text = "Running holdpoint update\u2026";
   try {
-    execSync7("npx @holdpoint/cli update", { stdio: "pipe" });
+    execSync5("npx @holdpoint/cli update", { stdio: "pipe" });
   } catch {
     applySpinner.warn(
-      chalk7.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(chalk7.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(chalk7.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(chalk7.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(
-    chalk7.dim("\n  Review checks.yaml, then commit: ") + chalk7.yellow("git add checks.yaml && git commit -m 'chore: update 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 chalk8 from "chalk";
+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}`);
@@ -1571,15 +1135,15 @@ async function liveCommand(options = {}) {
   }
   openBrowser(baseUrl.toString());
   console.log(
-    chalk8.green(
+    chalk6.green(
       started ? "\u2713 Started Holdpoint Live and opened the browser" : "\u2713 Opened Holdpoint Live"
     )
   );
-  console.log(`  url: ${chalk8.cyan(baseUrl.toString())}`);
+  console.log(`  url: ${chalk6.cyan(baseUrl.toString())}`);
 }
 
 // src/commands/daemon.ts
-import chalk9 from "chalk";
+import chalk7 from "chalk";
 import {
   DaemonAlreadyRunningError,
   isProcessAlive,
@@ -1620,38 +1184,38 @@ async function daemonStartCommand() {
   const { info, started } = await ensureDaemon();
   const sessionCount = await fetchSessionCount(info);
   const headline = started ? "Started Holdpoint Live daemon" : "Reused existing Holdpoint Live daemon";
-  console.log(chalk9.green(`\u2713 ${headline}`));
-  console.log(`  pid: ${chalk9.cyan(String(info.pid))}`);
-  console.log(`  port: ${chalk9.cyan(String(info.port))}`);
-  console.log(`  uptime: ${chalk9.cyan(formatUptime(info))}`);
+  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: ${chalk9.cyan(String(sessionCount))}`);
+    console.log(`  sessions: ${chalk7.cyan(String(sessionCount))}`);
   }
 }
 async function daemonStatusCommand() {
   const lock = await readHealthyDaemonLock2();
   if (!lock) {
-    console.log(chalk9.yellow("Holdpoint Live daemon is not running."));
+    console.log(chalk7.yellow("Holdpoint Live daemon is not running."));
     return;
   }
   const sessionCount = await fetchSessionCount(lock);
-  console.log(chalk9.green("\u2713 Holdpoint Live daemon is running"));
-  console.log(`  pid: ${chalk9.cyan(String(lock.pid))}`);
-  console.log(`  port: ${chalk9.cyan(String(lock.port))}`);
-  console.log(`  uptime: ${chalk9.cyan(formatUptime(lock))}`);
+  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: ${chalk9.cyan(String(sessionCount))}`);
+    console.log(`  sessions: ${chalk7.cyan(String(sessionCount))}`);
   }
 }
 async function daemonStopCommand() {
   const lock = readDaemonLock();
   if (!lock) {
-    console.log(chalk9.yellow("Holdpoint Live daemon is not running."));
+    console.log(chalk7.yellow("Holdpoint Live daemon is not running."));
     return;
   }
   if (!isProcessAlive(lock.pid)) {
     removeDaemonLock(void 0, lock.token);
-    console.log(chalk9.yellow("Removed stale Holdpoint Live lockfile."));
+    console.log(chalk7.yellow("Removed stale Holdpoint Live lockfile."));
     return;
   }
   process.kill(lock.pid, "SIGTERM");
@@ -1659,7 +1223,7 @@ async function daemonStopCommand() {
   while (Date.now() < deadline) {
     if (!isProcessAlive(lock.pid)) {
       removeDaemonLock(void 0, lock.token);
-      console.log(chalk9.green(`\u2713 Stopped Holdpoint Live daemon (${lock.pid})`));
+      console.log(chalk7.green(`\u2713 Stopped Holdpoint Live daemon (${lock.pid})`));
       return;
     }
     await sleep2(100);
@@ -1667,7 +1231,7 @@ async function daemonStopCommand() {
   process.kill(lock.pid, "SIGKILL");
   await sleep2(100);
   removeDaemonLock(void 0, lock.token);
-  console.log(chalk9.green(`\u2713 Force-stopped Holdpoint Live daemon (${lock.pid})`));
+  console.log(chalk7.green(`\u2713 Force-stopped Holdpoint Live daemon (${lock.pid})`));
 }
 async function daemonServeCommand(options) {
   try {
@@ -1685,16 +1249,16 @@ async function daemonServeCommand(options) {
 }
 
 // src/commands/engines.ts
-import chalk10 from "chalk";
+import chalk8 from "chalk";
 
 // src/engines.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname5, join as join7, resolve, sep } from "path";
+import { 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 as fileURLToPath3, pathToFileURL } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 import { parseEventV1 } from "@holdpoint/live-protocol";
 var require2 = createRequire(import.meta.url);
-var CLI_SRC_DIR = dirname5(fileURLToPath3(import.meta.url));
+var CLI_SRC_DIR = dirname2(fileURLToPath(import.meta.url));
 var MONOREPO_ROOT = resolve(CLI_SRC_DIR, "../../..");
 var BUILTIN_LIVE_ENGINE_PACKAGES = [
   "@holdpoint/engine-claude",
@@ -1702,19 +1266,19 @@ var BUILTIN_LIVE_ENGINE_PACKAGES = [
   "@holdpoint/engine-cursor"
 ];
 var HOLDPOINT_ENGINE_KEYWORD = "holdpoint-engine";
-function isObject3(value) {
+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)) {
+  if (!existsSync8(path)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
-    return isObject3(parsed) ? parsed : null;
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    return isObject(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -1722,10 +1286,10 @@ function readJsonFile(path) {
 function findNearestPackageRoot(startDir) {
   let current = resolve(startDir);
   while (true) {
-    if (existsSync12(join7(current, "package.json"))) {
+    if (existsSync8(join5(current, "package.json"))) {
       return current;
     }
-    const parent = dirname5(current);
+    const parent = dirname2(current);
     if (parent === current) {
       return resolve(startDir);
     }
@@ -1733,12 +1297,12 @@ function findNearestPackageRoot(startDir) {
   }
 }
 function findPackageRootFromFile(path) {
-  let current = dirname5(path);
+  let current = dirname2(path);
   while (true) {
-    if (existsSync12(join7(current, "package.json"))) {
+    if (existsSync8(join5(current, "package.json"))) {
       return current;
     }
-    const parent = dirname5(current);
+    const parent = dirname2(current);
     if (parent === current) {
       return null;
     }
@@ -1746,14 +1310,14 @@ function findPackageRootFromFile(path) {
   }
 }
 function getDependencyEnginePackageNames(projectRoot) {
-  const packageJson = readJsonFile(join7(projectRoot, "package.json"));
+  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 (!isObject3(deps)) {
+    if (!isObject(deps)) {
       continue;
     }
     for (const packageName of Object.keys(deps)) {
@@ -1781,13 +1345,13 @@ function resolvePackageRoot(packageName, projectRoot) {
     const packageJsonPath = require2.resolve(`${packageName}/package.json`, {
       paths: [projectRoot, process.cwd()]
     });
-    return dirname5(packageJsonPath);
+    return dirname2(packageJsonPath);
   } catch {
     if (packageName.startsWith("@holdpoint/")) {
       const scopedName = packageName.split("/")[1];
       if (scopedName) {
         const packageDir = resolve(MONOREPO_ROOT, "packages", scopedName);
-        if (existsSync12(join7(packageDir, "package.json"))) {
+        if (existsSync8(join5(packageDir, "package.json"))) {
           return packageDir;
         }
       }
@@ -1799,7 +1363,7 @@ function formatImportError(error) {
   return error instanceof Error && error.message ? error.message : String(error);
 }
 function parseManifest(value) {
-  if (!isObject3(value)) {
+  if (!isObject(value)) {
     return null;
   }
   if (value.manifestVersion !== 1) {
@@ -1818,7 +1382,7 @@ function parseManifest(value) {
   };
 }
 function parseLiveCapabilities(value) {
-  if (!isObject3(value)) {
+  if (!isObject(value)) {
     return null;
   }
   const capabilities = {};
@@ -1841,7 +1405,7 @@ function parseLiveCapabilities(value) {
   return capabilities;
 }
 function parseLiveAdapter(value, manifest) {
-  if (!isObject3(value)) {
+  if (!isObject(value)) {
     return null;
   }
   if (typeof value.id !== "string" || typeof value.displayName !== "string") {
@@ -1889,10 +1453,10 @@ function resolvePackageAssetPath(packageRoot, relativePath) {
     packageRoot,
     relativePath.replace(/^\.\/dist\//, "./src/").replace(/\.js$/, ".ts")
   );
-  if (packageRoot.startsWith(resolve(MONOREPO_ROOT, "packages") + sep) && existsSync12(sourceFallback)) {
+  if (packageRoot.startsWith(resolve(MONOREPO_ROOT, "packages") + sep) && existsSync8(sourceFallback)) {
     return sourceFallback;
   }
-  if (existsSync12(declaredPath)) {
+  if (existsSync8(declaredPath)) {
     return declaredPath;
   }
   return sourceFallback;
@@ -1907,7 +1471,7 @@ async function resolveCandidate(packageName, source, projectRoot) {
       reason: "package could not be resolved from this project"
     };
   }
-  const packageJson = readJsonFile(join7(packageRoot, "package.json"));
+  const packageJson = readJsonFile(join5(packageRoot, "package.json"));
   if (!packageJson) {
     return {
       packageName,
@@ -1925,7 +1489,7 @@ async function resolveCandidate(packageName, source, projectRoot) {
       reason: `missing \`${HOLDPOINT_ENGINE_KEYWORD}\` keyword`
     };
   }
-  const metadata = isObject3(packageJson.holdpoint) ? packageJson.holdpoint : void 0;
+  const metadata = isObject(packageJson.holdpoint) ? packageJson.holdpoint : void 0;
   if (!metadata?.manifest) {
     return {
       packageName,
@@ -1944,7 +1508,7 @@ async function resolveCandidate(packageName, source, projectRoot) {
   }
   const manifestPath = resolvePackageAssetPath(packageRoot, metadata.manifest);
   const adapterPath = resolvePackageAssetPath(packageRoot, metadata.adapter);
-  if (!existsSync12(manifestPath)) {
+  if (!existsSync8(manifestPath)) {
     return {
       packageName,
       source,
@@ -1952,7 +1516,7 @@ async function resolveCandidate(packageName, source, projectRoot) {
       reason: "manifest file does not exist"
     };
   }
-  if (!existsSync12(adapterPath)) {
+  if (!existsSync8(adapterPath)) {
     return {
       packageName,
       source,
@@ -2064,22 +1628,22 @@ async function enginesCommand(options = {}) {
   for (const engine of engines) {
     if (engine.status === "loaded" && engine.manifest) {
       console.log(
-        `${chalk10.green("loaded")} ${chalk10.cyan(engine.manifest.id)} (${engine.manifest.displayName}) from ${chalk10.yellow(engine.packageName)} [${engine.source}]`
+        `${chalk8.green("loaded")} ${chalk8.cyan(engine.manifest.id)} (${engine.manifest.displayName}) from ${chalk8.yellow(engine.packageName)} [${engine.source}]`
       );
       continue;
     }
     console.log(
-      `${chalk10.yellow("ignored")} ${chalk10.yellow(engine.packageName)} [${engine.source}] \u2014 ${engine.reason ?? "unknown reason"}`
+      `${chalk8.yellow("ignored")} ${chalk8.yellow(engine.packageName)} [${engine.source}] \u2014 ${engine.reason ?? "unknown reason"}`
     );
   }
 }
 
 // src/commands/event.ts
-import { readFileSync as readFileSync10 } from "fs";
+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 readFileSync10(0, "utf8");
+  return readFileSync7(0, "utf8");
 }
 async function eventCommand(options) {
   const stdin = readStdin().trim();
@@ -2129,10 +1693,10 @@ async function eventCommand(options) {
 }
 
 // src/commands/changeset.ts
-import { execSync as execSync8 } from "child_process";
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync11, statSync } from "fs";
-import { join as join8, relative } from "path";
-import chalk11 from "chalk";
+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",
@@ -2144,7 +1708,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 ]);
 function runGit(command) {
   try {
-    const out = execSync8(command, {
+    const out = execSync6(command, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -2155,7 +1719,7 @@ function runGit(command) {
 }
 function readJson(path) {
   try {
-    return JSON.parse(readFileSync11(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return null;
   }
@@ -2198,22 +1762,22 @@ function getChangedFiles(options) {
   return runGit("git diff --name-only HEAD~1 HEAD");
 }
 function parsePnpmWorkspacePatterns() {
-  if (!existsSync13("pnpm-workspace.yaml")) return [];
-  const lines = readFileSync11("pnpm-workspace.yaml", "utf8").split(/\r?\n/);
+  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 existsSync13(join8(normalized, "package.json")) ? [normalized] : [];
+    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("*") || !existsSync13(parent)) {
+  if (!parent || suffix.includes("*") || !existsSync9(parent)) {
     return [];
   }
-  return readdirSync3(parent).map((entry) => join8(parent, entry, suffix)).map(normalizePath).filter((candidate) => existsSync13(join8(candidate, "package.json")));
+  return readdirSync3(parent).map((entry) => join6(parent, entry, suffix)).map(normalizePath).filter((candidate) => existsSync9(join6(candidate, "package.json")));
 }
 function walkPackageRoots(start, roots) {
   let entries;
@@ -2222,13 +1786,13 @@ function walkPackageRoots(start, roots) {
   } catch {
     return;
   }
-  if (start !== "." && existsSync13(join8(start, "package.json"))) {
+  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 = join8(start, entry);
+    const candidate = join6(start, entry);
     let stats;
     try {
       stats = statSync(candidate);
@@ -2241,7 +1805,7 @@ function walkPackageRoots(start, roots) {
   }
 }
 function readPackageRoot(path) {
-  const pkg = readJson(join8(path, "package.json"));
+  const pkg = readJson(join6(path, "package.json"));
   if (!pkg) return null;
   return {
     path: normalizePath(path === "." ? "" : path),
@@ -2269,7 +1833,7 @@ function discoverPackageRoots(includePatterns = []) {
   }
   const discovered = [];
   walkPackageRoots(".", discovered);
-  const roots = discovered.length > 0 ? discovered : existsSync13("package.json") ? ["."] : [];
+  const roots = discovered.length > 0 ? discovered : existsSync9("package.json") ? ["."] : [];
   return uniquePackageRoots(
     roots.map(readPackageRoot).filter((pkg) => Boolean(pkg)).filter((pkg) => !pkg.private)
   );
@@ -2330,30 +1894,30 @@ function analyzeChangesetRequirement(input) {
 async function requireChangesetCommand(options) {
   const changedFiles = getChangedFiles(options);
   if (changedFiles.length === 0) {
-    console.log(chalk11.green("\u2713 No changed files detected \u2014 no changeset required."));
+    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(chalk11.green("\u2713 No package roots detected \u2014 no changeset required."));
+    console.log(chalk9.green("\u2713 No package roots detected \u2014 no changeset required."));
     return;
   }
-  const hasChangesetSetup = existsSync13(".changeset");
+  const hasChangesetSetup = existsSync9(".changeset");
   const { requiredFiles, hasChangeset } = analyzeChangesetRequirement({
     changedFiles,
     packageRoots
   });
   if (requiredFiles.length === 0) {
-    console.log(chalk11.green("\u2713 No release-affecting package files changed."));
+    console.log(chalk9.green("\u2713 No release-affecting package files changed."));
     return;
   }
   if (hasChangeset) {
-    console.log(chalk11.green("\u2713 Package changes include a changeset."));
+    console.log(chalk9.green("\u2713 Package changes include a changeset."));
     return;
   }
-  console.error(chalk11.red("\u2717 Package changes need a changeset."));
+  console.error(chalk9.red("\u2717 Package changes need a changeset."));
   console.error("");
-  console.error(chalk11.bold("Changed package files:"));
+  console.error(chalk9.bold("Changed package files:"));
   for (const item of requiredFiles.slice(0, 12)) {
     console.error(`  - ${item.file} (${item.packageName})`);
   }
@@ -2365,12 +1929,12 @@ async function requireChangesetCommand(options) {
     console.error(
       "No .changeset directory was found. Create one and add a changeset before finishing:"
     );
-    console.error(chalk11.yellow("  mkdir -p .changeset"));
+    console.error(chalk9.yellow("  mkdir -p .changeset"));
   } else {
     console.error("Add a changeset before finishing:");
   }
-  console.error(chalk11.yellow("  pnpm changeset"));
-  console.error(chalk11.dim("  or add a .changeset/<name>.md file manually"));
+  console.error(chalk9.yellow("  pnpm changeset"));
+  console.error(chalk9.dim("  or add a .changeset/<name>.md file manually"));
   process.exit(1);
 }