@osfactory/har 0.54.0 → 0.55.0

package/dist/index.js

@@ -4517,6 +4517,8 @@ var init_schema = __esm({
       remediations: external_exports.array(external_exports.string()),
       ports: external_exports.record(external_exports.number()).optional(),
       allocatedPorts: external_exports.boolean().optional(),
+      /** A warning already states why this port was chosen — suppresses the generic note. */
+      portChoiceExplained: external_exports.boolean().optional(),
       /** Non-blocking notices (e.g. har control up holds the default port but an alternate was picked). */
       warnings: external_exports.array(external_exports.string()).optional()
     });
@@ -29790,9 +29792,546 @@ var init_slot_launch_guard_occupied = __esm({
   }
 });
 
+// src/core/change-batch.ts
+function git(checkoutDir, args, env3) {
+  const result = run(`git ${args}`, { cwd: checkoutDir, env: env3 });
+  if (result.code !== 0) {
+    throw new Error(`git ${args} failed (${result.code}): ${result.stderr.trim()}`);
+  }
+  return result.stdout.trim();
+}
+function tryGit2(checkoutDir, args) {
+  const result = run(`git ${args}`, { cwd: checkoutDir });
+  return result.code === 0 ? result.stdout.trim() : void 0;
+}
+function isCheckoutRoot(checkoutDir) {
+  const toplevel = tryGit2(checkoutDir, "rev-parse --show-toplevel");
+  if (!toplevel) return false;
+  try {
+    return fs16.realpathSync(toplevel) === fs16.realpathSync(checkoutDir);
+  } catch {
+    return false;
+  }
+}
+function getHeadTree(checkoutDir) {
+  return tryGit2(checkoutDir, "rev-parse -q --verify HEAD^{tree}");
+}
+function getHeadSha(checkoutDir) {
+  return tryGit2(checkoutDir, "rev-parse -q --verify HEAD");
+}
+function getCurrentBranch(checkoutDir) {
+  const branch = tryGit2(checkoutDir, "rev-parse --abbrev-ref HEAD");
+  return branch && branch !== "HEAD" ? branch : void 0;
+}
+function getEmptyTree(checkoutDir) {
+  return git(checkoutDir, "hash-object -t tree /dev/null");
+}
+function isMergeOrRebaseInProgress(checkoutDir) {
+  if (tryGit2(checkoutDir, "rev-parse -q --verify MERGE_HEAD") !== void 0) return true;
+  for (const dir of ["rebase-merge", "rebase-apply"]) {
+    const gitPath = tryGit2(checkoutDir, `rev-parse --git-path ${dir}`);
+    if (gitPath && fs16.existsSync(path16.resolve(checkoutDir, gitPath))) return true;
+  }
+  return false;
+}
+function computeStagedTree(checkoutDir) {
+  return git(checkoutDir, "write-tree");
+}
+function parseNameStatus(output) {
+  const files = [];
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    const status = parts[0]?.charAt(0);
+    if (!status) continue;
+    if ((status === "R" || status === "C") && parts.length >= 3) {
+      files.push({ path: parts[2], status, oldPath: parts[1] });
+    } else if (parts.length >= 2) {
+      files.push({ path: parts[1], status });
+    }
+  }
+  return files;
+}
+function computeWorktreeSnapshot(checkoutDir) {
+  const tmpDir = fs16.mkdtempSync(path16.join(os6.tmpdir(), "har-idx-"));
+  const tmpIndex = path16.join(tmpDir, "index");
+  const env3 = { GIT_INDEX_FILE: tmpIndex };
+  try {
+    const headTree = getHeadTree(checkoutDir);
+    if (headTree) {
+      git(checkoutDir, "read-tree HEAD", env3);
+    } else {
+      git(checkoutDir, "read-tree --empty", env3);
+    }
+    git(checkoutDir, "add -A .", env3);
+    const treeHash = git(checkoutDir, "write-tree", env3);
+    const baseTree = headTree ?? getEmptyTree(checkoutDir);
+    const diffOutput = baseTree === treeHash ? "" : git(
+      checkoutDir,
+      `diff-tree -r -M --name-status --ignore-submodules=all ${baseTree} ${treeHash}`
+    );
+    return {
+      treeHash,
+      headSha: getHeadSha(checkoutDir),
+      branch: getCurrentBranch(checkoutDir),
+      changedFiles: parseNameStatus(diffOutput)
+    };
+  } finally {
+    fs16.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+var fs16, os6, path16;
+var init_change_batch = __esm({
+  "src/core/change-batch.ts"() {
+    "use strict";
+    fs16 = __toESM(require("fs"));
+    os6 = __toESM(require("os"));
+    path16 = __toESM(require("path"));
+    init_shell();
+  }
+});
+
+// src/core/validations.ts
+function resolveValidationCheckoutDir(input) {
+  const candidates = [input.worktreePath, input.workDir, input.harnessRoot].filter(
+    (value) => Boolean(value)
+  );
+  return candidates.find(isCheckoutRoot) ?? candidates[0] ?? input.harnessRoot;
+}
+function getValidationsDir(checkoutDir) {
+  return path17.join(checkoutDir, ".har", VALIDATIONS_DIR);
+}
+function validationPath(checkoutDir, treeHash) {
+  return path17.join(getValidationsDir(checkoutDir), `${treeHash}.json`);
+}
+function writeRecord(checkoutDir, record2) {
+  const dir = getValidationsDir(checkoutDir);
+  fs17.mkdirSync(dir, { recursive: true });
+  fs17.writeFileSync(
+    validationPath(checkoutDir, record2.treeHash),
+    `${JSON.stringify(record2, null, 2)}
+`
+  );
+}
+function ensureValidationsIgnored(checkoutDir) {
+  const harDir = path17.join(checkoutDir, ".har");
+  if (!fs17.existsSync(harDir)) return;
+  const gitignorePath = path17.join(harDir, ".gitignore");
+  const content = fs17.existsSync(gitignorePath) ? fs17.readFileSync(gitignorePath, "utf8") : "";
+  if (content.split("\n").some((line) => line.trim() === `${VALIDATIONS_DIR}/`)) return;
+  const suffix = content.length === 0 || content.endsWith("\n") ? "" : "\n";
+  fs17.writeFileSync(gitignorePath, `${content}${suffix}${VALIDATIONS_DIR}/
+`);
+}
+function recordValidation(input) {
+  if (!isCheckoutRoot(input.checkoutDir)) {
+    throw new Error(`Not the root of a git checkout: ${input.checkoutDir}`);
+  }
+  ensureValidationsIgnored(input.checkoutDir);
+  ensureValidationsIgnored(input.harnessRoot);
+  const snapshot = computeWorktreeSnapshot(input.checkoutDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = findValidation(input.checkoutDir, snapshot.treeHash);
+  const record2 = ValidationRecordSchema.parse({
+    validationId: existing?.validationId ?? crypto3.randomUUID(),
+    treeHash: snapshot.treeHash,
+    headSha: snapshot.headSha,
+    branch: snapshot.branch,
+    workDir: path17.resolve(input.checkoutDir),
+    harnessRoot: path17.resolve(input.harnessRoot),
+    agentId: input.agentId,
+    status: input.status,
+    full: input.full,
+    runId: input.runId,
+    changedFiles: snapshot.changedFiles,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    commitSha: existing?.commitSha,
+    committedAt: existing?.committedAt
+  });
+  writeRecord(input.checkoutDir, record2);
+  if (path17.resolve(input.harnessRoot) !== path17.resolve(input.checkoutDir)) {
+    writeRecord(input.harnessRoot, record2);
+  }
+  markDirty(input.checkoutDir);
+  return record2;
+}
+function findValidation(checkoutDir, treeHash) {
+  const file = validationPath(checkoutDir, treeHash);
+  if (!fs17.existsSync(file)) return void 0;
+  try {
+    return ValidationRecordSchema.parse(JSON.parse(fs17.readFileSync(file, "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+function attachCommit(checkoutDir, treeHash, commitSha) {
+  const record2 = findValidation(checkoutDir, treeHash);
+  if (!record2) return void 0;
+  const updated = {
+    ...record2,
+    commitSha,
+    committedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeRecord(checkoutDir, updated);
+  if (record2.harnessRoot && path17.resolve(record2.harnessRoot) !== path17.resolve(checkoutDir) && fs17.existsSync(path17.join(record2.harnessRoot, ".har"))) {
+    writeRecord(record2.harnessRoot, updated);
+  }
+  return updated;
+}
+function listValidations(harnessRoot) {
+  const dir = getValidationsDir(harnessRoot);
+  if (!fs17.existsSync(dir)) return [];
+  const records = [];
+  for (const entry of fs17.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      records.push(ValidationRecordSchema.parse(JSON.parse(fs17.readFileSync(path17.join(dir, entry), "utf8"))));
+    } catch {
+    }
+  }
+  return records.sort((a, b2) => b2.updatedAt.localeCompare(a.updatedAt));
+}
+var crypto3, fs17, path17, VALIDATIONS_DIR;
+var init_validations = __esm({
+  "src/core/validations.ts"() {
+    "use strict";
+    crypto3 = __toESM(require("crypto"));
+    fs17 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
+    init_schema2();
+    init_change_batch();
+    init_sync_context();
+    VALIDATIONS_DIR = "validations";
+  }
+});
+
+// src/core/hooks.ts
+function tryGit3(cwd, args) {
+  const result = run(`git ${args}`, { cwd });
+  return result.code === 0 ? result.stdout.trim() : void 0;
+}
+function resolveCheckoutRoot(cwd) {
+  return tryGit3(cwd, "rev-parse --show-toplevel");
+}
+function resolveHooksDir(checkoutDir) {
+  const hooksPath = tryGit3(checkoutDir, "rev-parse --git-path hooks");
+  if (!hooksPath) throw new Error(`Not a git checkout: ${checkoutDir}`);
+  return path18.resolve(checkoutDir, hooksPath);
+}
+function getConfiguredHooksPath(checkoutDir) {
+  return tryGit3(checkoutDir, "config core.hooksPath") || void 0;
+}
+function defaultHarInvocation() {
+  const entry = process.argv[1];
+  if (entry && entry.endsWith(".js")) {
+    return `"${process.execPath}" "${path18.resolve(entry)}"`;
+  }
+  if (entry) return `"${path18.resolve(entry)}"`;
+  return "har";
+}
+function buildHookScript(harInvocation, subcommand, failOpenNotice) {
+  return `#!/bin/sh
+# Managed by \`har hooks\` \u2014 do not edit; reinstall with \`har hooks install\`.
+if ${harInvocation} --version >/dev/null 2>&1; then
+  exec ${harInvocation} hooks ${subcommand}
+fi
+if command -v har >/dev/null 2>&1; then
+  exec har hooks ${subcommand}
+fi
+toplevel="$(git rev-parse --show-toplevel 2>/dev/null)"
+if [ -n "$toplevel" ] && [ -x "$toplevel/node_modules/.bin/har" ]; then
+  exec "$toplevel/node_modules/.bin/har" hooks ${subcommand}
+fi
+echo "${failOpenNotice}" >&2
+exit 0
+`;
+}
+function upsertMarkedBlock(filePath, block) {
+  if (!fs18.existsSync(filePath)) {
+    fs18.writeFileSync(filePath, `#!/bin/sh
+${block}
+`, { mode: 493 });
+    return "created";
+  }
+  const content = fs18.readFileSync(filePath, "utf8");
+  if (content.includes(MARKER_START)) {
+    const pattern = new RegExp(
+      `${escapeRegExp(MARKER_START)}[\\s\\S]*?${escapeRegExp(MARKER_END)}`
+    );
+    fs18.writeFileSync(filePath, content.replace(pattern, block));
+    fs18.chmodSync(filePath, 493);
+    return "updated";
+  }
+  const suffix = content.endsWith("\n") ? "" : "\n";
+  fs18.writeFileSync(filePath, `${content}${suffix}
+${block}
+`);
+  fs18.chmodSync(filePath, 493);
+  return "appended";
+}
+function removeMarkedBlock(filePath) {
+  if (!fs18.existsSync(filePath)) return false;
+  const content = fs18.readFileSync(filePath, "utf8");
+  if (!content.includes(MARKER_START)) return false;
+  const pattern = new RegExp(
+    `\\n?${escapeRegExp(MARKER_START)}[\\s\\S]*?${escapeRegExp(MARKER_END)}\\n?`
+  );
+  const stripped = content.replace(pattern, "\n");
+  if (stripped.replace(/^#!\/bin\/sh\n?/, "").trim() === "") {
+    fs18.rmSync(filePath);
+  } else {
+    fs18.writeFileSync(filePath, stripped);
+  }
+  return true;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function installHooks(options) {
+  const checkout = resolveCheckoutRoot(options.repoPath);
+  if (!checkout) throw new Error(`Not a git repository: ${options.repoPath}`);
+  const configuredHooksPath = getConfiguredHooksPath(checkout);
+  if (configuredHooksPath && !options.force) {
+    throw new Error(
+      `core.hooksPath is set to "${configuredHooksPath}" (managed hooks, e.g. husky).
+Add this to your managed pre-commit hook instead:
+
+  ${PRE_COMMIT_BLOCK.split("\n").join("\n  ")}
+
+Or re-run with --force to write into that directory anyway.`
+    );
+  }
+  const hooksDir = resolveHooksDir(checkout);
+  fs18.mkdirSync(hooksDir, { recursive: true });
+  const invocation = options.harInvocation ?? defaultHarInvocation();
+  fs18.writeFileSync(
+    path18.join(hooksDir, "har-pre-commit"),
+    buildHookScript(invocation, "check", "har: binary not found; skipping commit gate (reinstall with har hooks install)"),
+    { mode: 493 }
+  );
+  fs18.writeFileSync(
+    path18.join(hooksDir, "har-post-commit"),
+    buildHookScript(invocation, "record-commit", "har: binary not found; skipping commit association"),
+    { mode: 493 }
+  );
+  const preCommit = upsertMarkedBlock(path18.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
+  const postCommit = upsertMarkedBlock(path18.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
+  ensureValidationsIgnored(checkout);
+  return { hooksDir, preCommit, postCommit };
+}
+function uninstallHooks(repoPath) {
+  const checkout = resolveCheckoutRoot(repoPath);
+  if (!checkout) throw new Error(`Not a git repository: ${repoPath}`);
+  const hooksDir = resolveHooksDir(checkout);
+  let removed = false;
+  removed = removeMarkedBlock(path18.join(hooksDir, "pre-commit")) || removed;
+  removed = removeMarkedBlock(path18.join(hooksDir, "post-commit")) || removed;
+  for (const file of ["har-pre-commit", "har-post-commit"]) {
+    const full = path18.join(hooksDir, file);
+    if (fs18.existsSync(full)) {
+      fs18.rmSync(full);
+      removed = true;
+    }
+  }
+  return { hooksDir, removed };
+}
+function getCommitGateConfig(checkoutDir) {
+  try {
+    const registry2 = readStageRegistry(checkoutDir);
+    return CommitGateConfigSchema.parse(registry2.commitGate ?? {});
+  } catch {
+    return CommitGateConfigSchema.parse({});
+  }
+}
+function isAgentWorktree(checkoutDir) {
+  const branch = getCurrentBranch(checkoutDir);
+  if (branch && (/^har-agent-\d+$/.test(branch) || /-har-agent-\d+-[a-z0-9]+$/.test(branch))) {
+    return true;
+  }
+  const worktreesRoot = path18.join(os7.homedir(), "worktrees");
+  const resolved = path18.resolve(checkoutDir);
+  const name = path18.basename(resolved);
+  return resolved.startsWith(`${worktreesRoot}${path18.sep}`) && (/-agent-\d+$/.test(name) || /-har-agent-\d+-[a-z0-9]+$/.test(name));
+}
+function resolveEffectiveMode(checkoutDir, gate) {
+  if (!gate.enabled) return "off";
+  if (gate.scope === "all") return gate.mode;
+  return isAgentWorktree(checkoutDir) ? gate.mode : "warn";
+}
+function getHooksStatus(repoPath) {
+  const checkout = resolveCheckoutRoot(repoPath);
+  if (!checkout) throw new Error(`Not a git repository: ${repoPath}`);
+  const hooksDir = resolveHooksDir(checkout);
+  const gate = getCommitGateConfig(checkout);
+  const hasBlock = (name) => {
+    const file = path18.join(hooksDir, name);
+    return fs18.existsSync(file) && fs18.readFileSync(file, "utf8").includes(MARKER_START);
+  };
+  return {
+    checkout,
+    hooksDir,
+    configuredHooksPath: getConfiguredHooksPath(checkout),
+    preCommitInstalled: hasBlock("pre-commit") && fs18.existsSync(path18.join(hooksDir, "har-pre-commit")),
+    postCommitInstalled: hasBlock("post-commit") && fs18.existsSync(path18.join(hooksDir, "har-post-commit")),
+    gate,
+    effectiveMode: resolveEffectiveMode(checkout, gate)
+  };
+}
+function checkCommitGate(cwd) {
+  if (process.env.HAR_SKIP_GATE === "1") {
+    return { exitCode: 0, messages: ["har: commit gate skipped (HAR_SKIP_GATE=1)"] };
+  }
+  const checkout = resolveCheckoutRoot(cwd);
+  if (!checkout) return { exitCode: 0, messages: [] };
+  if (!fs18.existsSync(path18.join(checkout, ".har", "stages.json"))) {
+    return { exitCode: 0, messages: [] };
+  }
+  const gate = getCommitGateConfig(checkout);
+  const mode = resolveEffectiveMode(checkout, gate);
+  if (mode === "off") return { exitCode: 0, messages: [] };
+  if (!getHeadSha(checkout)) {
+    return { exitCode: 0, messages: ["har: commit gate skipped (initial commit)"] };
+  }
+  if (isMergeOrRebaseInProgress(checkout)) {
+    return { exitCode: 0, messages: ["har: commit gate skipped (merge/rebase in progress)"] };
+  }
+  let stagedTree;
+  try {
+    stagedTree = computeStagedTree(checkout);
+  } catch {
+    return { exitCode: 0, messages: ["har: commit gate skipped (index has unmerged entries)"] };
+  }
+  if (stagedTree === getHeadTree(checkout)) {
+    return { exitCode: 0, messages: [] };
+  }
+  const record2 = findValidation(checkout, stagedTree);
+  if (record2 && record2.status === "pass" && record2.full) {
+    return {
+      exitCode: 0,
+      messages: [
+        `har: batch ${stagedTree.slice(0, 8)} verified${record2.runId ? ` by run ${record2.runId.slice(0, 8)}` : ""} \u2713`
+      ]
+    };
+  }
+  const messages = [];
+  const verb = mode === "block" ? "commit blocked" : "warning";
+  messages.push(
+    `har: ${verb} \u2014 no passing verification for this exact change batch (tree ${stagedTree.slice(0, 8)}).`
+  );
+  if (record2 && record2.status === "fail") {
+    messages.push(
+      `  This exact batch was verified and FAILED${record2.runId ? ` (run ${record2.runId.slice(0, 8)})` : ""}. Fix and re-run.`
+    );
+  } else if (record2 && !record2.full) {
+    messages.push(
+      `  This batch only passed a partial verify${record2.runId ? ` (run ${record2.runId.slice(0, 8)})` : ""}; the gate requires --full.`
+    );
+  }
+  messages.push("  Run the full pipeline:   har env verify <agentId> --full");
+  messages.push(
+    "  Note: verify hashes the WORKING TREE \u2014 stage exactly what you verified (git add -A)."
+  );
+  messages.push("  Bypass (humans only):    HAR_SKIP_GATE=1 git commit \u2026   or   git commit --no-verify");
+  messages.push("  Configure via commitGate { mode: block|warn, scope: worktrees|all } in .har/stages.json");
+  return { exitCode: mode === "block" ? 1 : 0, messages };
+}
+async function recordCommitAssociation(cwd) {
+  try {
+    const checkout = resolveCheckoutRoot(cwd);
+    if (!checkout) return { attached: false };
+    const commitSha = getHeadSha(checkout);
+    const tree = tryGit3(checkout, "rev-parse HEAD^{tree}");
+    if (!commitSha || !tree) return { attached: false };
+    const updated = attachCommit(checkout, tree, commitSha);
+    if (updated) {
+      markDirty(updated.harnessRoot);
+      return { attached: true, commitSha };
+    }
+    return { attached: false, commitSha };
+  } catch {
+    return { attached: false };
+  }
+}
+var fs18, os7, path18, MARKER_START, MARKER_END, PRE_COMMIT_BLOCK, POST_COMMIT_BLOCK;
+var init_hooks = __esm({
+  "src/core/hooks.ts"() {
+    "use strict";
+    fs18 = __toESM(require("fs"));
+    os7 = __toESM(require("os"));
+    path18 = __toESM(require("path"));
+    init_shell();
+    init_schema2();
+    init_stages();
+    init_change_batch();
+    init_validations();
+    init_sync_context();
+    MARKER_START = "# >>> har commit gate (managed by `har hooks`) >>>";
+    MARKER_END = "# <<< har commit gate <<<";
+    PRE_COMMIT_BLOCK = [
+      MARKER_START,
+      'if [ "$HAR_SKIP_GATE" != "1" ]; then',
+      '  "$(git rev-parse --git-path hooks)/har-pre-commit" || exit 1',
+      "fi",
+      MARKER_END
+    ].join("\n");
+    POST_COMMIT_BLOCK = [
+      MARKER_START,
+      '"$(git rev-parse --git-path hooks)/har-post-commit" || true',
+      MARKER_END
+    ].join("\n");
+  }
+});
+
+// src/core/worktree-untracked.ts
+function listUntrackedAbsentFromWorktree(repoPath) {
+  const toplevel = resolveCheckoutRoot(repoPath);
+  if (!toplevel) return [];
+  try {
+    const raw = (0, import_child_process6.execSync)(
+      "git --literal-pathspecs ls-files --others --exclude-standard --directory -z",
+      {
+        cwd: toplevel,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"],
+        timeout: 1e4,
+        maxBuffer: 8 * 1024 * 1024
+      }
+    );
+    return raw.split("\0").filter(Boolean).sort();
+  } catch {
+    return [];
+  }
+}
+function formatUntrackedWorktreeWarning(paths, maxListed = MAX_LISTED) {
+  if (paths.length === 0) return void 0;
+  const shown = paths.slice(0, maxListed);
+  const omitted = paths.length - shown.length;
+  const listed = shown.join(", ") + (omitted > 0 ? ` (+${omitted} more)` : "");
+  const n = paths.length;
+  const noun = n === 1 ? "path" : "paths";
+  const them = n === 1 ? "It is" : "They are";
+  return `${n} untracked ${noun} will not appear in the session worktree: ${listed}. ${them} only in the main checkout \u2014 track them, or launch with --no-worktree.`;
+}
+function worktreeCheckEnabled(env3, worktree) {
+  if (worktree === false) return false;
+  if (worktree === true) return true;
+  return (env3.HARNESS_USE_WORKTREE ?? "true").toLowerCase() !== "false";
+}
+var import_child_process6, MAX_LISTED;
+var init_worktree_untracked = __esm({
+  "src/core/worktree-untracked.ts"() {
+    "use strict";
+    import_child_process6 = require("child_process");
+    init_hooks();
+    MAX_LISTED = 8;
+  }
+});
+
 // src/utils/package-runner.ts
 function commandExists(command2) {
-  const result = (0, import_child_process6.spawnSync)("sh", ["-c", `command -v ${JSON.stringify(command2)}`], {
+  const result = (0, import_child_process7.spawnSync)("sh", ["-c", `command -v ${JSON.stringify(command2)}`], {
     encoding: "utf8"
   });
   return result.status === 0 && Boolean(result.stdout?.trim());
@@ -29803,11 +30342,11 @@ function packageRunner() {
   cached = available ?? RUNNERS[0];
   return cached;
 }
-var import_child_process6, RUNNERS, cached;
+var import_child_process7, RUNNERS, cached;
 var init_package_runner = __esm({
   "src/utils/package-runner.ts"() {
     "use strict";
-    import_child_process6 = require("child_process");
+    import_child_process7 = require("child_process");
     RUNNERS = ["npx --yes", "bunx", "pnpm dlx", "yarn dlx"];
   }
 });
@@ -29815,7 +30354,7 @@ var init_package_runner = __esm({
 // src/core/slot-preflight.ts
 function listPm2Processes() {
   try {
-    const raw = (0, import_child_process7.execSync)(`${packageRunner()} pm2 jlist`, {
+    const raw = (0, import_child_process8.execSync)(`${packageRunner()} pm2 jlist`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
       timeout: 3e3
@@ -29860,10 +30399,14 @@ function checkInfraPort(env3, varName, defaultPort, scanStart, scanEnd) {
   }
   return { port };
 }
+function scanUntrackedWorktreePaths(repoPath, env3) {
+  if (!worktreeCheckEnabled(env3, void 0)) return [];
+  return listUntrackedAbsentFromWorktree(repoPath);
+}
 function inspectSlotReadiness(repoPath, agentId, options = {}) {
   const harnessRoot = resolveHarnessRoot(repoPath);
   const env3 = readHarnessEnv(harnessRoot);
-  const projectName = env3.HARNESS_PROJECT_NAME ?? path16.basename(harnessRoot);
+  const projectName = env3.HARNESS_PROJECT_NAME ?? path19.basename(harnessRoot);
   const usesPm2 = harnessUsesPm2(repoPath);
   const blockers = [];
   const remediations = [];
@@ -29917,6 +30460,7 @@ function inspectSlotReadiness(repoPath, agentId, options = {}) {
     }
   }
   let allocatedPorts = false;
+  let portChoiceExplained = false;
   if (usesPm2 && (options.allocatePorts ?? true)) {
     const alloc = allocateAppPorts(repoPath, agentId);
     if ("error" in alloc) {
@@ -29936,7 +30480,9 @@ function inspectSlotReadiness(repoPath, agentId, options = {}) {
         agentId,
         portStep(env3)
       );
-      warnings.push(...controlDefaultPortWarnings(containers, feDefault, alloc.frontend));
+      const portWarnings = controlDefaultPortWarnings(containers, feDefault, alloc.frontend);
+      portChoiceExplained = portWarnings.length > 0;
+      warnings.push(...portWarnings);
       for (const [label, port] of Object.entries({ frontend: alloc.frontend, api: alloc.api })) {
         const control = controlContainerOnPort(containers, port);
         if (control) {
@@ -29988,6 +30534,11 @@ function inspectSlotReadiness(repoPath, agentId, options = {}) {
       }
     }
   }
+  if (worktreeCheckEnabled(env3, options.worktree)) {
+    const untracked = options.untrackedPaths ?? scanUntrackedWorktreePaths(repoPath, env3);
+    const untrackedWarning = formatUntrackedWorktreeWarning(untracked);
+    if (untrackedWarning) warnings.push(untrackedWarning);
+  }
   const canLaunch = blockers.length === 0;
   return {
     canLaunch,
@@ -29996,6 +30547,7 @@ function inspectSlotReadiness(repoPath, agentId, options = {}) {
     remediations: [...new Set(remediations)],
     ports: Object.keys(ports).length > 0 ? ports : void 0,
     allocatedPorts: allocatedPorts || void 0,
+    portChoiceExplained: portChoiceExplained || void 0,
     warnings: warnings.length > 0 ? warnings : void 0
   };
 }
@@ -30012,7 +30564,7 @@ function formatPreflightReport(agentId, readiness) {
         p.db !== void 0 ? `db=${p.db}` : void 0
       ].filter(Boolean);
       if (parts.length) lines2.push(`  Ports: ${parts.join(" ")}`);
-      if (readiness.allocatedPorts && !readiness.warnings?.length) {
+      if (readiness.allocatedPorts && !readiness.portChoiceExplained) {
         lines2.push("  (alternate ports selected \u2014 defaults were busy)");
       }
     }
@@ -30028,20 +30580,24 @@ function formatPreflightReport(agentId, readiness) {
     lines2.push(`  [${b2.code}] ${b2.message}`);
     if (b2.remediation) lines2.push(`    \u2192 ${b2.remediation}`);
   }
+  for (const w2 of readiness.warnings ?? []) {
+    lines2.push(`  WARN: ${w2}`);
+  }
   return lines2.join("\n");
 }
-var path16, import_child_process7;
+var path19, import_child_process8;
 var init_slot_preflight = __esm({
   "src/core/slot-preflight.ts"() {
     "use strict";
-    path16 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     init_env();
     init_manifest();
     init_control_port();
     init_slot_launch_guard_occupied();
     init_slot_ports();
     init_slot_registry();
-    import_child_process7 = require("child_process");
+    init_worktree_untracked();
+    import_child_process8 = require("child_process");
     init_package_runner();
   }
 });
@@ -30049,7 +30605,7 @@ var init_slot_preflight = __esm({
 // src/core/slot-status.ts
 function readGitRemote(repoPath) {
   try {
-    const remote = (0, import_child_process8.execSync)("git remote get-url origin", {
+    const remote = (0, import_child_process9.execSync)("git remote get-url origin", {
       cwd: repoPath,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
@@ -30061,7 +30617,7 @@ function readGitRemote(repoPath) {
 }
 function runGit2(cwd, args) {
   try {
-    return (0, import_child_process8.execSync)(`git ${args}`, {
+    return (0, import_child_process9.execSync)(`git ${args}`, {
       cwd,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
@@ -30075,7 +30631,7 @@ function readWorktreeBranch(worktreePath) {
 }
 function gitCommonDir3(cwd) {
   const out = runGit2(cwd, "rev-parse --git-common-dir");
-  return out ? path17.resolve(cwd, out) : void 0;
+  return out ? path20.resolve(cwd, out) : void 0;
 }
 function sameGitCheckout3(a, b2) {
   const left2 = gitCommonDir3(a);
@@ -30087,12 +30643,12 @@ function gitPrefix2(cwd) {
   return out ?? "";
 }
 function discoverSessionWorktreePath(harnessRoot, agentId) {
-  const worktreesRoot = path17.join(os6.homedir(), "worktrees");
-  if (!fs16.existsSync(worktreesRoot)) return void 0;
+  const worktreesRoot = path20.join(os8.homedir(), "worktrees");
+  if (!fs19.existsSync(worktreesRoot)) return void 0;
   const suffix = `-har-agent-${agentId}-`;
   const relPrefix = gitPrefix2(harnessRoot);
-  const matches = fs16.readdirSync(worktreesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.includes(suffix)).map((entry) => path17.join(worktreesRoot, entry.name)).filter(
-    (candidate) => sameGitCheckout3(harnessRoot, candidate) && fs16.existsSync(path17.join(candidate, relPrefix, `.env.agent.${agentId}`))
+  const matches = fs19.readdirSync(worktreesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.includes(suffix)).map((entry) => path20.join(worktreesRoot, entry.name)).filter(
+    (candidate) => sameGitCheckout3(harnessRoot, candidate) && fs19.existsSync(path20.join(candidate, relPrefix, `.env.agent.${agentId}`))
   );
   return matches.sort()[0];
 }
@@ -30137,7 +30693,7 @@ function lastBuildPass(run2) {
 }
 function listPm2Processes2() {
   try {
-    const raw = (0, import_child_process8.execSync)(`${packageRunner()} pm2 jlist`, {
+    const raw = (0, import_child_process9.execSync)(`${packageRunner()} pm2 jlist`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"],
       timeout: 3e3
@@ -30165,20 +30721,20 @@ function detectPm2Issue(projectName, agentId, session, procs) {
   }
   return void 0;
 }
-function collectSlotStatus(harnessRoot, agentId, runs, pm2Procs) {
+function collectSlotStatus(harnessRoot, agentId, runs, pm2Procs, untrackedPaths) {
   const env3 = readHarnessEnv(harnessRoot);
-  const projectName = env3.HARNESS_PROJECT_NAME ?? path17.basename(harnessRoot);
+  const projectName = env3.HARNESS_PROJECT_NAME ?? path20.basename(harnessRoot);
   const session = readSlotRegistry(harnessRoot, agentId);
-  const legacyWorktreePath = path17.join(
-    os6.homedir(),
+  const legacyWorktreePath = path20.join(
+    os8.homedir(),
     "worktrees",
     `${projectName}-agent-${agentId}`
   );
-  const worktreePath = session?.worktreePath && fs16.existsSync(session.worktreePath) ? session.worktreePath : fs16.existsSync(legacyWorktreePath) ? legacyWorktreePath : discoverSessionWorktreePath(harnessRoot, agentId);
+  const worktreePath = session?.worktreePath && fs19.existsSync(session.worktreePath) ? session.worktreePath : fs19.existsSync(legacyWorktreePath) ? legacyWorktreePath : discoverSessionWorktreePath(harnessRoot, agentId);
   const workDir = resolveAgentWorkDir(harnessRoot, agentId);
-  const envInWorkDir = workDir ? fs16.existsSync(path17.join(workDir, `.env.agent.${agentId}`)) : false;
-  const envInRoot = fs16.existsSync(path17.join(harnessRoot, `.env.agent.${agentId}`));
-  const envInWorktree = worktreePath ? fs16.existsSync(path17.join(worktreePath, `.env.agent.${agentId}`)) : false;
+  const envInWorkDir = workDir ? fs19.existsSync(path20.join(workDir, `.env.agent.${agentId}`)) : false;
+  const envInRoot = fs19.existsSync(path20.join(harnessRoot, `.env.agent.${agentId}`));
+  const envInWorktree = worktreePath ? fs19.existsSync(path20.join(worktreePath, `.env.agent.${agentId}`)) : false;
   const active = session !== void 0 && session.status !== "completed" || envInWorkDir || envInRoot || envInWorktree;
   const latest = latestRunForAgent(runs, agentId);
   const verifyRun = runs.find((r) => r.agentId === agentId && r.stageId === "verify");
@@ -30194,7 +30750,8 @@ function collectSlotStatus(harnessRoot, agentId, runs, pm2Procs) {
   const pm2Issue = detectPm2Issue(projectName, agentId, session, pm2Procs);
   const readiness = inspectSlotReadiness(harnessRoot, agentId, {
     allocatePorts: true,
-    occupied: { active, dirty: drift.dirty }
+    occupied: { active, dirty: drift.dirty },
+    untrackedPaths: untrackedPaths ?? scanUntrackedWorktreePaths(harnessRoot, env3)
   });
   const resumeHint = session?.status === "failed" || session?.status === "starting" ? `har env launch ${agentId} --resume (alias: har env recover ${agentId})` : void 0;
   return {
@@ -30231,23 +30788,24 @@ function collectEnvironmentStatus(repoPath) {
   const manifest = readManifest(harnessRoot);
   const slotIds = getAgentSlotIds(harnessRoot);
   const pm2Procs = listPm2Processes2();
+  const untrackedPaths = scanUntrackedWorktreePaths(harnessRoot, readHarnessEnv(harnessRoot));
   return {
-    repoPath: path17.resolve(repoPath),
+    repoPath: path20.resolve(repoPath),
     harnessRoot,
     gitRemote: readGitRemote(harnessRoot),
     profile: manifest?.profile,
-    slots: slotIds.map((id) => collectSlotStatus(harnessRoot, id, runs, pm2Procs)),
+    slots: slotIds.map((id) => collectSlotStatus(harnessRoot, id, runs, pm2Procs, untrackedPaths)),
     generatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var fs16, os6, path17, import_child_process8, BYPASS_WARNING_MS;
+var fs19, os8, path20, import_child_process9, BYPASS_WARNING_MS;
 var init_slot_status = __esm({
   "src/core/slot-status.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    os6 = __toESM(require("os"));
-    path17 = __toESM(require("path"));
-    import_child_process8 = require("child_process");
+    fs19 = __toESM(require("fs"));
+    os8 = __toESM(require("os"));
+    path20 = __toESM(require("path"));
+    import_child_process9 = require("child_process");
     init_env();
     init_manifest();
     init_stages();
@@ -30260,256 +30818,41 @@ var init_slot_status = __esm({
   }
 });
 
-// src/core/change-batch.ts
-function git(checkoutDir, args, env3) {
-  const result = run(`git ${args}`, { cwd: checkoutDir, env: env3 });
-  if (result.code !== 0) {
-    throw new Error(`git ${args} failed (${result.code}): ${result.stderr.trim()}`);
-  }
-  return result.stdout.trim();
-}
-function tryGit2(checkoutDir, args) {
-  const result = run(`git ${args}`, { cwd: checkoutDir });
-  return result.code === 0 ? result.stdout.trim() : void 0;
-}
-function isCheckoutRoot(checkoutDir) {
-  const toplevel = tryGit2(checkoutDir, "rev-parse --show-toplevel");
-  if (!toplevel) return false;
-  try {
-    return fs17.realpathSync(toplevel) === fs17.realpathSync(checkoutDir);
-  } catch {
-    return false;
-  }
-}
-function getHeadTree(checkoutDir) {
-  return tryGit2(checkoutDir, "rev-parse -q --verify HEAD^{tree}");
-}
-function getHeadSha(checkoutDir) {
-  return tryGit2(checkoutDir, "rev-parse -q --verify HEAD");
-}
-function getCurrentBranch(checkoutDir) {
-  const branch = tryGit2(checkoutDir, "rev-parse --abbrev-ref HEAD");
-  return branch && branch !== "HEAD" ? branch : void 0;
-}
-function getEmptyTree(checkoutDir) {
-  return git(checkoutDir, "hash-object -t tree /dev/null");
-}
-function isMergeOrRebaseInProgress(checkoutDir) {
-  if (tryGit2(checkoutDir, "rev-parse -q --verify MERGE_HEAD") !== void 0) return true;
-  for (const dir of ["rebase-merge", "rebase-apply"]) {
-    const gitPath = tryGit2(checkoutDir, `rev-parse --git-path ${dir}`);
-    if (gitPath && fs17.existsSync(path18.resolve(checkoutDir, gitPath))) return true;
-  }
-  return false;
-}
-function computeStagedTree(checkoutDir) {
-  return git(checkoutDir, "write-tree");
-}
-function parseNameStatus(output) {
-  const files = [];
-  for (const line of output.split("\n")) {
-    if (!line.trim()) continue;
-    const parts = line.split("	");
-    const status = parts[0]?.charAt(0);
-    if (!status) continue;
-    if ((status === "R" || status === "C") && parts.length >= 3) {
-      files.push({ path: parts[2], status, oldPath: parts[1] });
-    } else if (parts.length >= 2) {
-      files.push({ path: parts[1], status });
-    }
-  }
-  return files;
-}
-function computeWorktreeSnapshot(checkoutDir) {
-  const tmpDir = fs17.mkdtempSync(path18.join(os7.tmpdir(), "har-idx-"));
-  const tmpIndex = path18.join(tmpDir, "index");
-  const env3 = { GIT_INDEX_FILE: tmpIndex };
-  try {
-    const headTree = getHeadTree(checkoutDir);
-    if (headTree) {
-      git(checkoutDir, "read-tree HEAD", env3);
-    } else {
-      git(checkoutDir, "read-tree --empty", env3);
-    }
-    git(checkoutDir, "add -A .", env3);
-    const treeHash = git(checkoutDir, "write-tree", env3);
-    const baseTree = headTree ?? getEmptyTree(checkoutDir);
-    const diffOutput = baseTree === treeHash ? "" : git(
-      checkoutDir,
-      `diff-tree -r -M --name-status --ignore-submodules=all ${baseTree} ${treeHash}`
-    );
-    return {
-      treeHash,
-      headSha: getHeadSha(checkoutDir),
-      branch: getCurrentBranch(checkoutDir),
-      changedFiles: parseNameStatus(diffOutput)
-    };
-  } finally {
-    fs17.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-var fs17, os7, path18;
-var init_change_batch = __esm({
-  "src/core/change-batch.ts"() {
-    "use strict";
-    fs17 = __toESM(require("fs"));
-    os7 = __toESM(require("os"));
-    path18 = __toESM(require("path"));
-    init_shell();
-  }
-});
-
-// src/core/validations.ts
-function resolveValidationCheckoutDir(input) {
-  const candidates = [input.worktreePath, input.workDir, input.harnessRoot].filter(
-    (value) => Boolean(value)
-  );
-  return candidates.find(isCheckoutRoot) ?? candidates[0] ?? input.harnessRoot;
-}
-function getValidationsDir(checkoutDir) {
-  return path19.join(checkoutDir, ".har", VALIDATIONS_DIR);
-}
-function validationPath(checkoutDir, treeHash) {
-  return path19.join(getValidationsDir(checkoutDir), `${treeHash}.json`);
-}
-function writeRecord(checkoutDir, record2) {
-  const dir = getValidationsDir(checkoutDir);
-  fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(
-    validationPath(checkoutDir, record2.treeHash),
-    `${JSON.stringify(record2, null, 2)}
-`
-  );
-}
-function ensureValidationsIgnored(checkoutDir) {
-  const harDir = path19.join(checkoutDir, ".har");
-  if (!fs18.existsSync(harDir)) return;
-  const gitignorePath = path19.join(harDir, ".gitignore");
-  const content = fs18.existsSync(gitignorePath) ? fs18.readFileSync(gitignorePath, "utf8") : "";
-  if (content.split("\n").some((line) => line.trim() === `${VALIDATIONS_DIR}/`)) return;
-  const suffix = content.length === 0 || content.endsWith("\n") ? "" : "\n";
-  fs18.writeFileSync(gitignorePath, `${content}${suffix}${VALIDATIONS_DIR}/
-`);
-}
-function recordValidation(input) {
-  if (!isCheckoutRoot(input.checkoutDir)) {
-    throw new Error(`Not the root of a git checkout: ${input.checkoutDir}`);
-  }
-  ensureValidationsIgnored(input.checkoutDir);
-  ensureValidationsIgnored(input.harnessRoot);
-  const snapshot = computeWorktreeSnapshot(input.checkoutDir);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = findValidation(input.checkoutDir, snapshot.treeHash);
-  const record2 = ValidationRecordSchema.parse({
-    validationId: existing?.validationId ?? crypto3.randomUUID(),
-    treeHash: snapshot.treeHash,
-    headSha: snapshot.headSha,
-    branch: snapshot.branch,
-    workDir: path19.resolve(input.checkoutDir),
-    harnessRoot: path19.resolve(input.harnessRoot),
-    agentId: input.agentId,
-    status: input.status,
-    full: input.full,
-    runId: input.runId,
-    changedFiles: snapshot.changedFiles,
-    createdAt: existing?.createdAt ?? now,
-    updatedAt: now,
-    commitSha: existing?.commitSha,
-    committedAt: existing?.committedAt
-  });
-  writeRecord(input.checkoutDir, record2);
-  if (path19.resolve(input.harnessRoot) !== path19.resolve(input.checkoutDir)) {
-    writeRecord(input.harnessRoot, record2);
-  }
-  markDirty(input.checkoutDir);
-  return record2;
-}
-function findValidation(checkoutDir, treeHash) {
-  const file = validationPath(checkoutDir, treeHash);
-  if (!fs18.existsSync(file)) return void 0;
-  try {
-    return ValidationRecordSchema.parse(JSON.parse(fs18.readFileSync(file, "utf8")));
-  } catch {
-    return void 0;
-  }
-}
-function attachCommit(checkoutDir, treeHash, commitSha) {
-  const record2 = findValidation(checkoutDir, treeHash);
-  if (!record2) return void 0;
-  const updated = {
-    ...record2,
-    commitSha,
-    committedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeRecord(checkoutDir, updated);
-  if (record2.harnessRoot && path19.resolve(record2.harnessRoot) !== path19.resolve(checkoutDir) && fs18.existsSync(path19.join(record2.harnessRoot, ".har"))) {
-    writeRecord(record2.harnessRoot, updated);
-  }
-  return updated;
-}
-function listValidations(harnessRoot) {
-  const dir = getValidationsDir(harnessRoot);
-  if (!fs18.existsSync(dir)) return [];
-  const records = [];
-  for (const entry of fs18.readdirSync(dir)) {
-    if (!entry.endsWith(".json")) continue;
-    try {
-      records.push(ValidationRecordSchema.parse(JSON.parse(fs18.readFileSync(path19.join(dir, entry), "utf8"))));
-    } catch {
-    }
-  }
-  return records.sort((a, b2) => b2.updatedAt.localeCompare(a.updatedAt));
-}
-var crypto3, fs18, path19, VALIDATIONS_DIR;
-var init_validations = __esm({
-  "src/core/validations.ts"() {
-    "use strict";
-    crypto3 = __toESM(require("crypto"));
-    fs18 = __toESM(require("fs"));
-    path19 = __toESM(require("path"));
-    init_schema2();
-    init_change_batch();
-    init_sync_context();
-    VALIDATIONS_DIR = "validations";
-  }
-});
-
 // src/core/work-units.ts
 function harEvidenceDir(harnessRoot, name) {
-  return path20.join(harnessRoot, ".har", name);
+  return path21.join(harnessRoot, ".har", name);
 }
 function hashedRecordPath(harnessRoot, dir, id) {
   const digest = crypto4.createHash("sha256").update(id).digest("hex");
-  return path20.join(harEvidenceDir(harnessRoot, dir), `${digest}.json`);
+  return path21.join(harEvidenceDir(harnessRoot, dir), `${digest}.json`);
 }
 function writeRecord2(file, value) {
-  fs19.mkdirSync(path20.dirname(file), { recursive: true });
+  fs20.mkdirSync(path21.dirname(file), { recursive: true });
   const temp = `${file}.${process.pid}.tmp`;
-  fs19.writeFileSync(temp, `${JSON.stringify(value, null, 2)}
+  fs20.writeFileSync(temp, `${JSON.stringify(value, null, 2)}
 `);
-  fs19.renameSync(temp, file);
+  fs20.renameSync(temp, file);
 }
 function ensureWorkEvidenceIgnored(harnessRoot) {
-  const harDir = path20.join(harnessRoot, ".har");
-  if (!fs19.existsSync(harDir)) return;
-  const gitignorePath = path20.join(harDir, ".gitignore");
-  const content = fs19.existsSync(gitignorePath) ? fs19.readFileSync(gitignorePath, "utf8") : "";
+  const harDir = path21.join(harnessRoot, ".har");
+  if (!fs20.existsSync(harDir)) return;
+  const gitignorePath = path21.join(harDir, ".gitignore");
+  const content = fs20.existsSync(gitignorePath) ? fs20.readFileSync(gitignorePath, "utf8") : "";
   const lines2 = new Set(content.split("\n").map((line) => line.trim()));
   const missing = EVIDENCE_DIRS.map((dir) => `${dir}/`).filter((dir) => !lines2.has(dir));
   if (missing.length === 0) return;
   const separator = content.length === 0 || content.endsWith("\n") ? "" : "\n";
-  fs19.writeFileSync(gitignorePath, `${content}${separator}${missing.join("\n")}
+  fs20.writeFileSync(gitignorePath, `${content}${separator}${missing.join("\n")}
 `);
 }
 function listRecords(harnessRoot, dir, parse4) {
   const recordDir = harEvidenceDir(harnessRoot, dir);
-  if (!fs19.existsSync(recordDir)) return [];
+  if (!fs20.existsSync(recordDir)) return [];
   const records = [];
-  for (const name of fs19.readdirSync(recordDir)) {
+  for (const name of fs20.readdirSync(recordDir)) {
     if (!name.endsWith(".json")) continue;
     try {
-      records.push(parse4(JSON.parse(fs19.readFileSync(path20.join(recordDir, name), "utf8"))));
+      records.push(parse4(JSON.parse(fs20.readFileSync(path21.join(recordDir, name), "utf8"))));
     } catch {
     }
   }
@@ -30518,9 +30861,9 @@ function listRecords(harnessRoot, dir, parse4) {
 function findWorkUnit(harnessRoot, workUnitId) {
   const metadata = WorkUnitMetadataSchema.parse({ workUnitId });
   const file = hashedRecordPath(harnessRoot, WORK_UNITS_DIR, metadata.workUnitId);
-  if (!fs19.existsSync(file)) return void 0;
+  if (!fs20.existsSync(file)) return void 0;
   try {
-    return WorkUnitRecordSchema.parse(JSON.parse(fs19.readFileSync(file, "utf8")));
+    return WorkUnitRecordSchema.parse(JSON.parse(fs20.readFileSync(file, "utf8")));
   } catch {
     return void 0;
   }
@@ -30598,10 +30941,10 @@ function bindValidationToAttempt(harnessRoot, input) {
     VALIDATION_BINDINGS_DIR,
     stableKey
   );
-  if (fs19.existsSync(existingFile)) {
+  if (fs20.existsSync(existingFile)) {
     try {
       return ValidationBindingRecordSchema.parse(
-        JSON.parse(fs19.readFileSync(existingFile, "utf8"))
+        JSON.parse(fs20.readFileSync(existingFile, "utf8"))
       );
     } catch {
     }
@@ -30636,13 +30979,13 @@ function decideWorkUnitOutcome(harnessRoot, workUnitId, outcome) {
   markDirty(harnessRoot);
   return record2;
 }
-var crypto4, fs19, path20, WORK_UNITS_DIR, WORK_ATTEMPTS_DIR, VALIDATION_BINDINGS_DIR, EVIDENCE_DIRS;
+var crypto4, fs20, path21, WORK_UNITS_DIR, WORK_ATTEMPTS_DIR, VALIDATION_BINDINGS_DIR, EVIDENCE_DIRS;
 var init_work_units = __esm({
   "src/core/work-units.ts"() {
     "use strict";
     crypto4 = __toESM(require("crypto"));
-    fs19 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
+    fs20 = __toESM(require("fs"));
+    path21 = __toESM(require("path"));
     init_schema2();
     init_sync_context();
     WORK_UNITS_DIR = "work-units";
@@ -31265,8 +31608,8 @@ function appendTelemetryEnvToFile(envFilePath, attrs) {
 ${TELEMETRY_MARKER_END}
 `;
   let existing = "";
-  if (fs20.existsSync(envFilePath)) {
-    existing = fs20.readFileSync(envFilePath, "utf8");
+  if (fs21.existsSync(envFilePath)) {
+    existing = fs21.readFileSync(envFilePath, "utf8");
     const start = existing.indexOf(TELEMETRY_MARKER_START);
     if (start >= 0) {
       const end = existing.indexOf(TELEMETRY_MARKER_END, start);
@@ -31277,16 +31620,16 @@ ${TELEMETRY_MARKER_END}
       }
     }
   }
-  fs20.mkdirSync(path21.dirname(envFilePath), { recursive: true });
+  fs21.mkdirSync(path22.dirname(envFilePath), { recursive: true });
   const combined = (existing.replace(/\n+$/, "\n") + block).replace(/^\n+/, "");
-  fs20.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
+  fs21.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
 }
-var fs20, path21, TELEMETRY_MARKER_START, TELEMETRY_MARKER_END;
+var fs21, path22, TELEMETRY_MARKER_START, TELEMETRY_MARKER_END;
 var init_telemetry_env = __esm({
   "src/core/telemetry-env.ts"() {
     "use strict";
-    fs20 = __toESM(require("fs"));
-    path21 = __toESM(require("path"));
+    fs21 = __toESM(require("fs"));
+    path22 = __toESM(require("path"));
     init_control_config();
     init_shell();
     TELEMETRY_MARKER_START = "# HAR session attribution (generated)";
@@ -31299,32 +31642,32 @@ function stripTrailingSeparators(value) {
   return value.replace(/[/\\]+$/, "");
 }
 function isWorkspaceUnderPath(workspace, basePath) {
-  const workspaceNorm = stripTrailingSeparators(path22.resolve(workspace));
-  const baseNorm = stripTrailingSeparators(path22.resolve(basePath));
+  const workspaceNorm = stripTrailingSeparators(path23.resolve(workspace));
+  const baseNorm = stripTrailingSeparators(path23.resolve(basePath));
   if (!workspaceNorm || !baseNorm) return false;
-  return workspaceNorm === baseNorm || workspaceNorm.startsWith(`${baseNorm}${path22.sep}`);
+  return workspaceNorm === baseNorm || workspaceNorm.startsWith(`${baseNorm}${path23.sep}`);
 }
 function workspaceMatchesTarget(workspace, targets) {
   return targets.some((target) => isWorkspaceUnderPath(workspace, target));
 }
-var path22;
+var path23;
 var init_workspace_path_match = __esm({
   "src/core/workspace-path-match.ts"() {
     "use strict";
-    path22 = __toESM(require("path"));
+    path23 = __toESM(require("path"));
   }
 });
 
 // src/core/usage-harvest/claude.ts
 function claudeProjectsRoot() {
-  return process.env.HAR_CLAUDE_PROJECTS_DIR ? path23.resolve(process.env.HAR_CLAUDE_PROJECTS_DIR) : path23.join(os9.homedir(), ".claude", "projects");
+  return process.env.HAR_CLAUDE_PROJECTS_DIR ? path24.resolve(process.env.HAR_CLAUDE_PROJECTS_DIR) : path24.join(os10.homedir(), ".claude", "projects");
 }
 function encodeClaudeProjectDir(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function readJsonlRecords(filePath) {
-  if (!fs21.existsSync(filePath)) return [];
-  const lines2 = fs21.readFileSync(filePath, "utf8").split(/\r?\n/);
+  if (!fs22.existsSync(filePath)) return [];
+  const lines2 = fs22.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines2) {
     const trimmed = line.trim();
@@ -31389,18 +31732,18 @@ function findMatchingClaudeTranscripts(slot) {
   const fallbackTargets = slot.includeRepoPathFallback && slot.repoPath && !primaryTargets.includes(slot.repoPath) ? [slot.repoPath] : [];
   if (primaryTargets.length === 0 && fallbackTargets.length === 0) return [];
   const root = claudeProjectsRoot();
-  if (!fs21.existsSync(root)) return [];
+  if (!fs22.existsSync(root)) return [];
   const primary = [];
   const fallback = [];
-  for (const entry of fs21.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs22.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const projectDir = path23.join(root, entry.name);
+    const projectDir = path24.join(root, entry.name);
     const primaryEncoded = primaryTargets.some((t) => entry.name === encodeClaudeProjectDir(t));
     const fallbackEncoded = fallbackTargets.some((t) => entry.name === encodeClaudeProjectDir(t));
-    for (const file of fs21.readdirSync(projectDir)) {
+    for (const file of fs22.readdirSync(projectDir)) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = path23.join(projectDir, file);
-      const stat = fs21.statSync(filePath);
+      const filePath = path24.join(projectDir, file);
+      const stat = fs22.statSync(filePath);
       const records = readJsonlRecords(filePath);
       let primaryHit = primaryEncoded;
       let fallbackHit = fallbackEncoded;
@@ -31519,13 +31862,13 @@ function harvestClaudeEvents(slot) {
   });
   return extractPromptEvents(matches[0].records, sessionKey, slot).slice(-40);
 }
-var fs21, os9, path23;
+var fs22, os10, path24;
 var init_claude = __esm({
   "src/core/usage-harvest/claude.ts"() {
     "use strict";
-    fs21 = __toESM(require("fs"));
-    os9 = __toESM(require("os"));
-    path23 = __toESM(require("path"));
+    fs22 = __toESM(require("fs"));
+    os10 = __toESM(require("os"));
+    path24 = __toESM(require("path"));
     init_telemetry_config();
     init_telemetry_env();
     init_workspace_path_match();
@@ -31534,19 +31877,19 @@ var init_claude = __esm({
 
 // src/core/usage-harvest/codex.ts
 function codexSessionsRoot() {
-  return process.env.HAR_CODEX_SESSIONS_DIR ? path24.resolve(process.env.HAR_CODEX_SESSIONS_DIR) : path24.join(os10.homedir(), ".codex", "sessions");
+  return process.env.HAR_CODEX_SESSIONS_DIR ? path25.resolve(process.env.HAR_CODEX_SESSIONS_DIR) : path25.join(os11.homedir(), ".codex", "sessions");
 }
 function walkJsonlFiles(dir, out = []) {
-  if (!fs22.existsSync(dir)) return out;
-  for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
-    const full = path24.join(dir, entry.name);
+  if (!fs23.existsSync(dir)) return out;
+  for (const entry of fs23.readdirSync(dir, { withFileTypes: true })) {
+    const full = path25.join(dir, entry.name);
     if (entry.isDirectory()) walkJsonlFiles(full, out);
     else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(full);
   }
   return out;
 }
 function readJsonl(filePath) {
-  const lines2 = fs22.readFileSync(filePath, "utf8").split(/\r?\n/);
+  const lines2 = fs23.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines2) {
     const trimmed = line.trim();
@@ -31613,7 +31956,7 @@ function harvestCodexUsage(slot) {
     const extracted = extractCodexTokens(records);
     if (!extracted.cwd) continue;
     if (extracted.tokensInput + extracted.tokensOutput + extracted.tokensCacheRead === 0) continue;
-    const mtime = fs22.statSync(file).mtimeMs;
+    const mtime = fs23.statSync(file).mtimeMs;
     if (workspaceMatchesTarget(extracted.cwd, primaryTargets)) {
       if (mtime >= bestPrimaryMtime) {
         bestPrimaryMtime = mtime;
@@ -31648,13 +31991,13 @@ function harvestCodexUsage(slot) {
     lastSeenAt: now
   };
 }
-var fs22, os10, path24;
+var fs23, os11, path25;
 var init_codex = __esm({
   "src/core/usage-harvest/codex.ts"() {
     "use strict";
-    fs22 = __toESM(require("fs"));
-    os10 = __toESM(require("os"));
-    path24 = __toESM(require("path"));
+    fs23 = __toESM(require("fs"));
+    os11 = __toESM(require("os"));
+    path25 = __toESM(require("path"));
     init_telemetry_env();
     init_workspace_path_match();
   }
@@ -31702,15 +32045,15 @@ var init_usage_harvest = __esm({
 // src/core/portal-watermark.ts
 function getStatePath() {
   if (process.env.HAR_PORTAL_SYNC_STATE_PATH) {
-    return path25.resolve(process.env.HAR_PORTAL_SYNC_STATE_PATH);
+    return path26.resolve(process.env.HAR_PORTAL_SYNC_STATE_PATH);
   }
-  return path25.join(os11.homedir(), ".har", "portal-sync-state.json");
+  return path26.join(os12.homedir(), ".har", "portal-sync-state.json");
 }
 function readState() {
   const statePath = getStatePath();
   try {
-    if (!fs23.existsSync(statePath)) return { states: [] };
-    const parsed = JSON.parse(fs23.readFileSync(statePath, "utf8"));
+    if (!fs24.existsSync(statePath)) return { states: [] };
+    const parsed = JSON.parse(fs24.readFileSync(statePath, "utf8"));
     return Array.isArray(parsed.states) ? parsed : { states: [] };
   } catch {
     return { states: [] };
@@ -31718,8 +32061,8 @@ function readState() {
 }
 function writeState(state) {
   const statePath = getStatePath();
-  fs23.mkdirSync(path25.dirname(statePath), { recursive: true });
-  fs23.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
+  fs24.mkdirSync(path26.dirname(statePath), { recursive: true });
+  fs24.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
 }
 function readPortalWatermark(repoPath, portalUrl) {
   const canonical = canonicalizeControlRepoPath(repoPath);
@@ -31773,13 +32116,13 @@ function selectSince(rows, since, getTimestamp) {
   }
   return { selected, maxSyncedAt };
 }
-var fs23, os11, path25;
+var fs24, os12, path26;
 var init_portal_watermark = __esm({
   "src/core/portal-watermark.ts"() {
     "use strict";
-    fs23 = __toESM(require("fs"));
-    os11 = __toESM(require("os"));
-    path25 = __toESM(require("path"));
+    fs24 = __toESM(require("fs"));
+    os12 = __toESM(require("os"));
+    path26 = __toESM(require("path"));
     init_control_repo_path();
   }
 });
@@ -31800,8 +32143,8 @@ async function getJson(url) {
 async function resolveControlRepoId(apiUrl, repoPath) {
   const repos = await getJson(`${apiUrl}/api/repos`);
   if (!Array.isArray(repos)) return null;
-  const target = path26.resolve(repoPath);
-  return repos.find((repo) => path26.resolve(repo.path) === target)?.id ?? null;
+  const target = path27.resolve(repoPath);
+  return repos.find((repo) => path27.resolve(repo.path) === target)?.id ?? null;
 }
 function optionalString(value) {
   return value == null ? void 0 : value;
@@ -31870,11 +32213,11 @@ async function fetchPersistedPortalTelemetry(repoPath, apiUrl, options) {
     maxSyncedAt: maxTimestamp(usage2.maxSyncedAt, events.maxSyncedAt)
   };
 }
-var path26, FETCH_TIMEOUT_MS;
+var path27, FETCH_TIMEOUT_MS;
 var init_control_persisted_usage = __esm({
   "src/core/control-persisted-usage.ts"() {
     "use strict";
-    path26 = __toESM(require("path"));
+    path27 = __toESM(require("path"));
     init_portal_watermark();
     FETCH_TIMEOUT_MS = 3e3;
   }
@@ -32206,7 +32549,7 @@ async function buildPortalPayload(repoPath, controlApiUrl, since, full = false)
   );
   if (full && isTelemetryEnabled() && usage2.length === 0 && runs.some((r) => r.agentId != null)) {
     warn(
-      `${path27.basename(repoPath)}: agent runs found but no usage harvested \u2014 attribution will be missing. This happens when agent sessions ran outside the har worktree slot (e.g. in the main checkout). Run agents inside \`har env launch\`.`
+      `${path28.basename(repoPath)}: agent runs found but no usage harvested \u2014 attribution will be missing. This happens when agent sessions ran outside the har worktree slot (e.g. in the main checkout). Run agents inside \`har env launch\`.`
     );
   }
   const syncBody = {
@@ -32333,7 +32676,7 @@ async function syncRepoWithLocalControl(options) {
     const listResponse = await fetch(`${apiUrl}/api/repos`);
     if (!listResponse.ok) throw new Error("Failed to list repos from Control API");
     const repos = await listResponse.json();
-    const existing = repos.find((r) => path27.resolve(r.path) === repoPath);
+    const existing = repos.find((r) => path28.resolve(r.path) === repoPath);
     if (!existing) {
       return;
     }
@@ -32546,7 +32889,7 @@ async function syncRunWithLocalControl(repoPath, run2, apiUrl) {
     const listResponse = await fetch(`${apiUrl}/api/repos`);
     if (!listResponse.ok) return;
     const repos = await listResponse.json();
-    repoId = repos.find((r) => path27.resolve(r.path) === repoPath)?.id;
+    repoId = repos.find((r) => path28.resolve(r.path) === repoPath)?.id;
   }
   if (!repoId) return;
   const runsBody = SyncRunsInputSchema.parse({ runs: [run2] });
@@ -32576,11 +32919,11 @@ async function syncRunWithControlAsync(repoPath, run2) {
 `);
   }
 }
-var path27, DEFAULT_MAX_BATCH_BYTES, DEFAULT_SYNC_OVERLAP_MS, MAX_FETCH_ATTEMPTS, SYNC_TIMEOUT_MS, EXPLICIT_SYNC_TIMEOUT_MS;
+var path28, DEFAULT_MAX_BATCH_BYTES, DEFAULT_SYNC_OVERLAP_MS, MAX_FETCH_ATTEMPTS, SYNC_TIMEOUT_MS, EXPLICIT_SYNC_TIMEOUT_MS;
 var init_control_sync = __esm({
   "src/core/control-sync.ts"() {
     "use strict";
-    path27 = __toESM(require("path"));
+    path28 = __toESM(require("path"));
     init_manifest();
     init_stages();
     init_schema2();
@@ -32612,7 +32955,7 @@ var init_control_sync = __esm({
 // src/core/sync-context.ts
 function markDirty(repoPath) {
   if (!repoPath) return;
-  dirtyRepos.add(path28.resolve(repoPath));
+  dirtyRepos.add(path29.resolve(repoPath));
 }
 function markAllRegisteredDirty() {
   syncAllRegistered = true;
@@ -32637,11 +32980,11 @@ async function syncDirtyRepos() {
   } catch {
   }
 }
-var path28, dirtyRepos, syncAllRegistered;
+var path29, dirtyRepos, syncAllRegistered;
 var init_sync_context = __esm({
   "src/core/sync-context.ts"() {
     "use strict";
-    path28 = __toESM(require("path"));
+    path29 = __toESM(require("path"));
     dirtyRepos = /* @__PURE__ */ new Set();
     syncAllRegistered = false;
   }
@@ -53412,32 +53755,32 @@ __export(otel_hooks_exports, {
 });
 function getOtelHooksHome() {
   if (process.env.HAR_OTEL_HOOKS_HOME) {
-    return path47.resolve(process.env.HAR_OTEL_HOOKS_HOME);
+    return path48.resolve(process.env.HAR_OTEL_HOOKS_HOME);
   }
-  return path47.join(os15.homedir(), ".har", "otel-hooks");
+  return path48.join(os16.homedir(), ".har", "otel-hooks");
 }
 function getOtelHooksConfigPath(hooksHome = getOtelHooksHome()) {
-  return path47.join(hooksHome, "otel_config.json");
+  return path48.join(hooksHome, "otel_config.json");
 }
 function getOtelHooksWrapperPath(hooksHome = getOtelHooksHome()) {
-  return path47.join(hooksHome, "run-otel-hook.sh");
+  return path48.join(hooksHome, "run-otel-hook.sh");
 }
 function getOtelHooksStateDir(hooksHome = getOtelHooksHome()) {
-  return path47.join(hooksHome, "state");
+  return path48.join(hooksHome, "state");
 }
 function localOtelHookBin(hooksHome) {
-  return path47.join(hooksHome, "node_modules", ".bin", "otel-hook");
+  return path48.join(hooksHome, "node_modules", ".bin", "otel-hook");
 }
 function installedPackageVersion(hooksHome) {
   try {
-    const pkgPath = path47.join(
+    const pkgPath = path48.join(
       hooksHome,
       "node_modules",
       "@osfactory",
       "otel-hook",
       "package.json"
     );
-    const pkg = JSON.parse(fs41.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs42.readFileSync(pkgPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -53488,15 +53831,15 @@ function buildOtelHooksConfig(options) {
   };
 }
 function writeOtelHooksConfig(config2, hooksHome = getOtelHooksHome()) {
-  fs41.mkdirSync(hooksHome, { recursive: true });
+  fs42.mkdirSync(hooksHome, { recursive: true });
   const configPath = getOtelHooksConfigPath(hooksHome);
-  fs41.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+  fs42.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
 `);
   return configPath;
 }
 function writeOtelHooksWrapper(otelHookCommand, hooksHome = getOtelHooksHome()) {
-  fs41.mkdirSync(hooksHome, { recursive: true });
-  fs41.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
+  fs42.mkdirSync(hooksHome, { recursive: true });
+  fs42.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
   const wrapperPath = getOtelHooksWrapperPath(hooksHome);
   const configPath = getOtelHooksConfigPath(hooksHome);
   const stateDir = getOtelHooksStateDir(hooksHome);
@@ -53508,22 +53851,22 @@ exec "${otelHookCommand}" run \\
   --state-dir "${stateDir}" \\
   "$@"
 `;
-  fs41.writeFileSync(wrapperPath, script, { mode: 493 });
+  fs42.writeFileSync(wrapperPath, script, { mode: 493 });
   try {
-    fs41.chmodSync(wrapperPath, 493);
+    fs42.chmodSync(wrapperPath, 493);
   } catch {
   }
   return wrapperPath;
 }
 function commandExists3(command2) {
-  const result = (0, import_child_process11.spawnSync)("sh", ["-c", `command -v ${JSON.stringify(command2)}`], {
+  const result = (0, import_child_process12.spawnSync)("sh", ["-c", `command -v ${JSON.stringify(command2)}`], {
     encoding: "utf8"
   });
   return result.status === 0 && Boolean(result.stdout?.trim());
 }
 function resolveOtelHookCommand(hooksHome) {
   const local = localOtelHookBin(hooksHome);
-  if (fs41.existsSync(local)) return local;
+  if (fs42.existsSync(local)) return local;
   return null;
 }
 function resolveHooksInstaller(hooksHome) {
@@ -53538,7 +53881,7 @@ function resolveHooksInstaller(hooksHome) {
   return candidates.find((candidate) => commandExists3(candidate.command)) ?? null;
 }
 function tryInstallPackage(hooksHome) {
-  fs41.mkdirSync(hooksHome, { recursive: true });
+  fs42.mkdirSync(hooksHome, { recursive: true });
   const installer = resolveHooksInstaller(hooksHome);
   if (!installer) {
     return {
@@ -53547,11 +53890,11 @@ function tryInstallPackage(hooksHome) {
     };
   }
   const described = `${installer.command} ${installer.args.join(" ")}`;
-  const result = (0, import_child_process11.spawnSync)(installer.command, installer.args, {
+  const result = (0, import_child_process12.spawnSync)(installer.command, installer.args, {
     encoding: "utf8",
     timeout: 18e4
   });
-  if (result.status === 0 && fs41.existsSync(localOtelHookBin(hooksHome))) {
+  if (result.status === 0 && fs42.existsSync(localOtelHookBin(hooksHome))) {
     return { ok: true, detail: described };
   }
   return {
@@ -53569,7 +53912,7 @@ function uninstallLegacyPythonHooks(hooksHome) {
   for (const [cmd, args] of attempts) {
     if (!commandExists3(cmd)) continue;
     try {
-      (0, import_child_process11.spawnSync)(cmd, args, { encoding: "utf8", timeout: 6e4 });
+      (0, import_child_process12.spawnSync)(cmd, args, { encoding: "utf8", timeout: 6e4 });
     } catch {
     }
   }
@@ -53577,14 +53920,14 @@ function uninstallLegacyPythonHooks(hooksHome) {
 }
 function removeLegacyPythonArtifacts(hooksHome) {
   const legacyPaths = [
-    path47.join(hooksHome, ".venv"),
-    path47.join(hooksHome, "otel_config.yaml"),
-    path47.join(hooksHome, "venv")
+    path48.join(hooksHome, ".venv"),
+    path48.join(hooksHome, "otel_config.yaml"),
+    path48.join(hooksHome, "venv")
   ];
   for (const target of legacyPaths) {
     try {
-      if (fs41.existsSync(target)) {
-        fs41.rmSync(target, { recursive: true, force: true });
+      if (fs42.existsSync(target)) {
+        fs42.rmSync(target, { recursive: true, force: true });
       }
     } catch {
     }
@@ -53601,7 +53944,7 @@ function normalizeLegacyProviderFlagsInCommand(command2) {
 }
 function runSetupProvider(providerId, otelHookCommand, wrapperPath) {
   const hookCommand = `${wrapperPath} --provider ${providerId}`;
-  const result = (0, import_child_process11.spawnSync)(
+  const result = (0, import_child_process12.spawnSync)(
     otelHookCommand,
     [
       "setup",
@@ -53625,10 +53968,10 @@ function runSetupProvider(providerId, otelHookCommand, wrapperPath) {
   };
 }
 function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
-  if (!fs41.existsSync(filePath)) return false;
+  if (!fs42.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs41.readFileSync(filePath, "utf8");
+    raw = fs42.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -53675,15 +54018,15 @@ function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
     return changed;
   };
   if (!walk(parsed)) return false;
-  fs41.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs42.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
-  if (!fs41.existsSync(filePath)) return false;
+  if (!fs42.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs41.readFileSync(filePath, "utf8");
+    raw = fs42.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -53718,21 +54061,21 @@ function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
     }
   }
   if (!changed) return false;
-  fs41.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs42.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function rewriteKnownHookRegistrations(wrapperPath) {
-  const home = os15.homedir();
+  const home = os16.homedir();
   const candidates = [
-    path47.join(home, ".cursor", "hooks.json"),
-    path47.join(home, ".claude", "settings.json"),
-    path47.join(home, ".codex", "hooks.json")
+    path48.join(home, ".cursor", "hooks.json"),
+    path48.join(home, ".claude", "settings.json"),
+    path48.join(home, ".codex", "hooks.json")
   ];
   for (const filePath of candidates) {
     try {
       rewriteHookCommandsToWrapper(filePath, wrapperPath);
-      if (filePath.endsWith(`${path47.sep}.cursor${path47.sep}hooks.json`)) {
+      if (filePath.endsWith(`${path48.sep}.cursor${path48.sep}hooks.json`)) {
         pruneLegacyCursorHookEvents(filePath, wrapperPath);
       }
     } catch {
@@ -53748,7 +54091,7 @@ function ensureOtelHooks(options) {
   const hooksHome = getOtelHooksHome();
   const errors = [];
   const providersSetup = [];
-  fs41.mkdirSync(hooksHome, { recursive: true });
+  fs42.mkdirSync(hooksHome, { recursive: true });
   let otelHookCommand = resolveOtelHookCommand(hooksHome);
   const needsInstall = !otelHookCommand || installedPackageVersion(hooksHome) !== pinnedVersion();
   if (needsInstall) {
@@ -53842,14 +54185,14 @@ function ensureOtelHooks(options) {
 function disableOtelHooksExport() {
   return writeOtelHooksConfig(buildOtelHooksConfig({ enabled: false }));
 }
-var import_child_process11, fs41, os15, path47, OTEL_HOOKS_PACKAGE, OTEL_HOOKS_PROVIDERS, OTEL_HOOKS_AGENTS, LEGACY_CURSOR_ONLY_HOOK_EVENTS;
+var import_child_process12, fs42, os16, path48, OTEL_HOOKS_PACKAGE, OTEL_HOOKS_PROVIDERS, OTEL_HOOKS_AGENTS, LEGACY_CURSOR_ONLY_HOOK_EVENTS;
 var init_otel_hooks = __esm({
   "src/core/otel-hooks.ts"() {
     "use strict";
-    import_child_process11 = require("child_process");
-    fs41 = __toESM(require("fs"));
-    os15 = __toESM(require("os"));
-    path47 = __toESM(require("path"));
+    import_child_process12 = require("child_process");
+    fs42 = __toESM(require("fs"));
+    os16 = __toESM(require("os"));
+    path48 = __toESM(require("path"));
     init_control_config();
     init_telemetry_config();
     OTEL_HOOKS_PACKAGE = "@osfactory/otel-hook@0.1.2";
@@ -65603,34 +65946,34 @@ init_telemetry_config();
 init_sync_context();
 
 // src/cli/commands/agents.ts
-var path31 = __toESM(require("path"));
+var path32 = __toESM(require("path"));
 
 // src/harness/agent-skills.ts
-var fs25 = __toESM(require("fs"));
-var os12 = __toESM(require("os"));
-var path30 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var os13 = __toESM(require("os"));
+var path31 = __toESM(require("path"));
 var readline = __toESM(require("readline"));
 init_file_ops();
 init_logging();
 
 // src/utils/paths.ts
-var fs24 = __toESM(require("fs"));
-var path29 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 function resolveTemplatesDir() {
   const candidates = [
-    path29.join(__dirname, "templates"),
-    path29.join(__dirname, "..", "templates"),
-    path29.join(__dirname, "..", "harness", "templates")
+    path30.join(__dirname, "templates"),
+    path30.join(__dirname, "..", "templates"),
+    path30.join(__dirname, "..", "harness", "templates")
   ];
   for (const dir of candidates) {
-    if (fs24.existsSync(path29.join(dir, "har-boilerplate"))) return dir;
+    if (fs25.existsSync(path30.join(dir, "har-boilerplate"))) return dir;
   }
   throw new Error("Templates directory not found. Run npm run build.");
 }
 function resolveTemplateFile(name) {
   const dir = resolveTemplatesDir();
-  const filePath = path29.join(dir, name);
-  return fs24.existsSync(filePath) ? filePath : null;
+  const filePath = path30.join(dir, name);
+  return fs25.existsSync(filePath) ? filePath : null;
 }
 
 // src/harness/agent-skills.ts
@@ -65638,18 +65981,18 @@ init_manifest();
 var AGENT_SKILL_TARGETS = ["claude", "cursor", "codex"];
 var MANAGED_HEADER = "<!-- managed by har \u2014 regenerated by `har agents install` / `har env maintain`; edit at your own risk -->";
 function agentSkillsTemplateDir() {
-  const dir = path30.join(resolveTemplatesDir(), "agent-skills");
-  if (!fs25.existsSync(dir)) {
+  const dir = path31.join(resolveTemplatesDir(), "agent-skills");
+  if (!fs26.existsSync(dir)) {
     throw new Error("Agent skills templates not found (templates/agent-skills). Run npm run build.");
   }
   return dir;
 }
 function readSkillsManifest() {
-  const manifestPath = path30.join(agentSkillsTemplateDir(), "skills.manifest.json");
-  return JSON.parse(fs25.readFileSync(manifestPath, "utf8"));
+  const manifestPath = path31.join(agentSkillsTemplateDir(), "skills.manifest.json");
+  return JSON.parse(fs26.readFileSync(manifestPath, "utf8"));
 }
 function readSkillBody(entry) {
-  return fs25.readFileSync(path30.join(agentSkillsTemplateDir(), entry.body), "utf8");
+  return fs26.readFileSync(path31.join(agentSkillsTemplateDir(), entry.body), "utf8");
 }
 function renderYamlValue(value) {
   if (typeof value === "string") return JSON.stringify(value);
@@ -65681,7 +66024,7 @@ function renderSkillFiles(agents) {
         agent: "claude",
         skill: entry.id,
         scope: "repo",
-        relPath: path30.join(".claude", "skills", entry.id, "SKILL.md"),
+        relPath: path31.join(".claude", "skills", entry.id, "SKILL.md"),
         content: renderClaudeSkill(entry, body)
       });
     }
@@ -65690,7 +66033,7 @@ function renderSkillFiles(agents) {
         agent: "cursor",
         skill: entry.id,
         scope: "repo",
-        relPath: path30.join(".cursor", "commands", `${entry.id}.md`),
+        relPath: path31.join(".cursor", "commands", `${entry.id}.md`),
         content: renderPlainSkill(body)
       });
     }
@@ -65699,7 +66042,7 @@ function renderSkillFiles(agents) {
         agent: "codex",
         skill: entry.id,
         scope: "global",
-        relPath: path30.posix.join("~", ".codex", "prompts", `${entry.codex.promptName}.md`),
+        relPath: path31.posix.join("~", ".codex", "prompts", `${entry.codex.promptName}.md`),
         content: renderPlainSkill(body)
       });
     }
@@ -65708,12 +66051,12 @@ function renderSkillFiles(agents) {
 }
 function resolveScaffoldPath(repoPath, file) {
   if (file.scope === "global") {
-    return path30.join(os12.homedir(), file.relPath.replace(/^~\//, ""));
+    return path31.join(os13.homedir(), file.relPath.replace(/^~\//, ""));
   }
-  return path30.join(repoPath, file.relPath);
+  return path31.join(repoPath, file.relPath);
 }
 function isHarManaged(filePath) {
-  return fs25.readFileSync(filePath, "utf8").includes(MANAGED_HEADER);
+  return fs26.readFileSync(filePath, "utf8").includes(MANAGED_HEADER);
 }
 function scaffoldAgentSkills(repoPath, agents, options = {}) {
   const written = [];
@@ -65721,7 +66064,7 @@ function scaffoldAgentSkills(repoPath, agents, options = {}) {
   const records = [];
   for (const file of renderSkillFiles(agents)) {
     const destPath = resolveScaffoldPath(repoPath, file);
-    if (fs25.existsSync(destPath) && !options.force && !isHarManaged(destPath)) {
+    if (fs26.existsSync(destPath) && !options.force && !isHarManaged(destPath)) {
       warn(`Skipped ${file.relPath} \u2014 exists with user modifications (use --force to overwrite)`);
       skipped.push(file.relPath);
       continue;
@@ -65755,16 +66098,16 @@ function removeAgentSkills(repoPath, agents) {
   const removed = [];
   for (const file of renderSkillFiles(agents)) {
     const destPath = resolveScaffoldPath(repoPath, file);
-    if (!fs25.existsSync(destPath)) continue;
+    if (!fs26.existsSync(destPath)) continue;
     if (!isHarManaged(destPath)) {
       warn(`Kept ${file.relPath} \u2014 has user modifications`);
       continue;
     }
-    fs25.rmSync(destPath);
+    fs26.rmSync(destPath);
     removed.push(file.relPath);
-    const parent = path30.dirname(destPath);
-    if (fs25.existsSync(parent) && fs25.readdirSync(parent).length === 0) {
-      fs25.rmdirSync(parent);
+    const parent = path31.dirname(destPath);
+    if (fs26.existsSync(parent) && fs26.readdirSync(parent).length === 0) {
+      fs26.rmdirSync(parent);
     }
   }
   const manifest = readManifest(repoPath);
@@ -65783,9 +66126,9 @@ function detectAgentTargets(repoPath) {
   const manifest = readManifest(repoPath);
   const scaffolded = new Set((manifest?.scaffoldedAgentFiles ?? []).map((entry) => entry.agent));
   const detected = new Set(scaffolded);
-  if (fs25.existsSync(path30.join(repoPath, ".claude"))) detected.add("claude");
-  if (fs25.existsSync(path30.join(repoPath, ".cursor"))) detected.add("cursor");
-  if (fs25.existsSync(path30.join(os12.homedir(), ".codex"))) detected.add("codex");
+  if (fs26.existsSync(path31.join(repoPath, ".claude"))) detected.add("claude");
+  if (fs26.existsSync(path31.join(repoPath, ".cursor"))) detected.add("cursor");
+  if (fs26.existsSync(path31.join(os13.homedir(), ".codex"))) detected.add("codex");
   return AGENT_SKILL_TARGETS.filter((agent) => detected.has(agent));
 }
 function parseAgentTargets(raw) {
@@ -65872,7 +66215,7 @@ var agentsCommand = {
   }
 };
 function handleInstall(argv) {
-  const repoPath = path31.resolve(argv.repo);
+  const repoPath = path32.resolve(argv.repo);
   header("har agents install");
   try {
     const targets = resolveTargets(argv, repoPath);
@@ -65898,7 +66241,7 @@ function handleInstall(argv) {
   }
 }
 function handleRemove(argv) {
-  const repoPath = path31.resolve(argv.repo);
+  const repoPath = path32.resolve(argv.repo);
   header("har agents remove");
   try {
     const targets = resolveTargets(argv, repoPath);
@@ -65928,25 +66271,25 @@ async function finishCommand(code) {
 }
 
 // src/core/harness.ts
-var fs37 = __toESM(require("fs"));
-var path42 = __toESM(require("path"));
+var fs38 = __toESM(require("fs"));
+var path43 = __toESM(require("path"));
 
 // src/harness/generator.ts
-var fs28 = __toESM(require("fs"));
-var path34 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var path35 = __toESM(require("path"));
 init_file_ops();
 init_logging();
 
 // src/core/gitignore.ts
-var fs26 = __toESM(require("fs"));
-var path32 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path33 = __toESM(require("path"));
 var HARNESS_ROOT_GITIGNORE_PATTERNS = [
   ".env.agent.*",
   "ecosystem.agent.*.config.cjs"
 ];
 function ensureRootGitignorePatterns(checkoutDir) {
-  const gitignorePath = path32.join(checkoutDir, ".gitignore");
-  const content = fs26.existsSync(gitignorePath) ? fs26.readFileSync(gitignorePath, "utf8") : "";
+  const gitignorePath = path33.join(checkoutDir, ".gitignore");
+  const content = fs27.existsSync(gitignorePath) ? fs27.readFileSync(gitignorePath, "utf8") : "";
   const lines2 = content.split("\n").map((line) => line.trim());
   const missing = HARNESS_ROOT_GITIGNORE_PATTERNS.filter((pattern) => !lines2.includes(pattern));
   if (missing.length === 0) return;
@@ -65955,12 +66298,12 @@ function ensureRootGitignorePatterns(checkoutDir) {
   const block = lines2.some((line) => line.includes("HAR agent slot artifacts")) || header2.length === 0 ? `${missing.join("\n")}
 ` : `${header2}${missing.join("\n")}
 `;
-  fs26.writeFileSync(gitignorePath, `${content}${suffix}${block}`);
+  fs27.writeFileSync(gitignorePath, `${content}${suffix}${block}`);
 }
 
 // src/harness/gitignore-template.ts
-var fs27 = __toESM(require("fs"));
-var path33 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path34 = __toESM(require("path"));
 var HARNESS_GITIGNORE_TEMPLATE = "gitignore.template";
 var HARNESS_GITIGNORE_FILE = ".gitignore";
 function harnessFileForTemplate(templateFile) {
@@ -65970,16 +66313,16 @@ function templateFileForHarness(harnessFile) {
   return harnessFile === HARNESS_GITIGNORE_FILE ? HARNESS_GITIGNORE_TEMPLATE : harnessFile;
 }
 function resolveGitignoreTemplateSource(boilerplateDir) {
-  const primary = path33.join(boilerplateDir, HARNESS_GITIGNORE_TEMPLATE);
-  if (fs27.existsSync(primary)) return primary;
-  const legacy = path33.join(boilerplateDir, HARNESS_GITIGNORE_FILE);
-  if (fs27.existsSync(legacy)) return legacy;
+  const primary = path34.join(boilerplateDir, HARNESS_GITIGNORE_TEMPLATE);
+  if (fs28.existsSync(primary)) return primary;
+  const legacy = path34.join(boilerplateDir, HARNESS_GITIGNORE_FILE);
+  if (fs28.existsSync(legacy)) return legacy;
   return null;
 }
 function writeHarnessGitignore(harnessDir, boilerplateDir) {
   const src = resolveGitignoreTemplateSource(boilerplateDir);
   if (!src) return;
-  fs27.writeFileSync(path33.join(harnessDir, HARNESS_GITIGNORE_FILE), fs27.readFileSync(src, "utf8"));
+  fs28.writeFileSync(path34.join(harnessDir, HARNESS_GITIGNORE_FILE), fs28.readFileSync(src, "utf8"));
 }
 function isExpectedHarnessOnlyFile(harnessFile, templateFiles) {
   return harnessFile === HARNESS_GITIGNORE_FILE && templateFiles.includes(HARNESS_GITIGNORE_TEMPLATE);
@@ -66000,27 +66343,27 @@ var CLI_PRUNE_FILES = [
 ];
 function pruneCliProfile(harnessDir) {
   for (const file of CLI_PRUNE_FILES) {
-    const filePath = path34.join(harnessDir, file);
-    if (fs28.existsSync(filePath)) {
-      fs28.unlinkSync(filePath);
+    const filePath = path35.join(harnessDir, file);
+    if (fs29.existsSync(filePath)) {
+      fs29.unlinkSync(filePath);
     }
   }
 }
 function scaffoldHarnessBoilerplate(repoPath, options = {}) {
-  const harnessDir = path34.join(repoPath, DEFAULT_HAR_DIR);
-  const projectName = path34.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const harnessDir = path35.join(repoPath, DEFAULT_HAR_DIR);
+  const projectName = path35.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
   const profile = options.profile ?? "default";
-  const boilerplateDir = path34.join(resolveTemplatesDir(), PROFILE_DIRS[profile]);
-  if (fs28.existsSync(harnessDir) && !options.force) {
+  const boilerplateDir = path35.join(resolveTemplatesDir(), PROFILE_DIRS[profile]);
+  if (fs29.existsSync(harnessDir) && !options.force) {
     throw new Error(
       '.har/ already exists. Use --force to overwrite or run "har env maintain" to update in place.'
     );
   }
-  if (!fs28.existsSync(boilerplateDir)) {
+  if (!fs29.existsSync(boilerplateDir)) {
     throw new Error(`Boilerplate template not found at ${boilerplateDir}`);
   }
-  if (options.force && fs28.existsSync(harnessDir)) {
-    fs28.rmSync(harnessDir, { recursive: true, force: true });
+  if (options.force && fs29.existsSync(harnessDir)) {
+    fs29.rmSync(harnessDir, { recursive: true, force: true });
   }
   copyDirRecursive(boilerplateDir, harnessDir);
   writeHarnessGitignore(harnessDir, boilerplateDir);
@@ -66028,11 +66371,11 @@ function scaffoldHarnessBoilerplate(repoPath, options = {}) {
     pruneCliProfile(harnessDir);
   }
   syncAgentSlotsToHarnessEnv(repoPath);
-  const harnessEnvPath = path34.join(harnessDir, "harness.env");
-  if (fs28.existsSync(harnessEnvPath)) {
-    let content = fs28.readFileSync(harnessEnvPath, "utf8");
+  const harnessEnvPath = path35.join(harnessDir, "harness.env");
+  if (fs29.existsSync(harnessEnvPath)) {
+    let content = fs29.readFileSync(harnessEnvPath, "utf8");
     content = content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
-    fs28.writeFileSync(harnessEnvPath, content);
+    fs29.writeFileSync(harnessEnvPath, content);
   }
   const manifest = createManifest(
     repoPath,
@@ -66054,16 +66397,16 @@ function finalizeHarness(repoPath, adaptationSummary, stack) {
 }
 
 // src/harness/agent-md.ts
-var fs30 = __toESM(require("fs"));
-var path36 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var path37 = __toESM(require("path"));
 init_file_ops();
 init_logging();
 init_manifest();
 
 // src/harness/instruction-files.ts
-var fs29 = __toESM(require("fs"));
-var os13 = __toESM(require("os"));
-var path35 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
+var os14 = __toESM(require("os"));
+var path36 = __toESM(require("path"));
 
 // node_modules/@inquirer/core/dist/esm/lib/key.mjs
 var isUpKey = (key) => (
@@ -68396,7 +68739,7 @@ var AgentsMdShrinkError = class extends Error {
     this.name = "AgentsMdShrinkError";
   }
 };
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function countNonEmptyLines(text) {
@@ -68405,7 +68748,7 @@ function countNonEmptyLines(text) {
 function stripClaudePointerFromAgentsMd(content) {
   if (!content.includes(CLAUDE_HAR_SECTION_START)) return content;
   const pattern = new RegExp(
-    `${escapeRegExp(CLAUDE_HAR_SECTION_START)}[\\s\\S]*?${escapeRegExp(CLAUDE_HAR_SECTION_END)}\\n?`,
+    `${escapeRegExp2(CLAUDE_HAR_SECTION_START)}[\\s\\S]*?${escapeRegExp2(CLAUDE_HAR_SECTION_END)}\\n?`,
     "g"
   );
   return content.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
@@ -68457,12 +68800,12 @@ function outsideContentShrinkMessage(beforeLines, afterLines) {
 }
 function detectInstructionFiles(repoPath) {
   return {
-    agentsMd: fs29.existsSync(path35.join(repoPath, AGENTS_MD)),
-    agentMd: fs29.existsSync(path35.join(repoPath, LEGACY_AGENT_MD)),
-    claudeMd: fs29.existsSync(path35.join(repoPath, CLAUDE_MD)),
-    cursorDir: fs29.existsSync(path35.join(repoPath, ".cursor")),
-    claudeDir: fs29.existsSync(path35.join(repoPath, ".claude")),
-    codexHome: fs29.existsSync(path35.join(os13.homedir(), ".codex"))
+    agentsMd: fs30.existsSync(path36.join(repoPath, AGENTS_MD)),
+    agentMd: fs30.existsSync(path36.join(repoPath, LEGACY_AGENT_MD)),
+    claudeMd: fs30.existsSync(path36.join(repoPath, CLAUDE_MD)),
+    cursorDir: fs30.existsSync(path36.join(repoPath, ".cursor")),
+    claudeDir: fs30.existsSync(path36.join(repoPath, ".claude")),
+    codexHome: fs30.existsSync(path36.join(os14.homedir(), ".codex"))
   };
 }
 function formatDetectionReport(detection) {
@@ -68517,7 +68860,7 @@ function loadHarAgentsSectionFromTemplate() {
   if (!templatePath) {
     throw new Error("AGENTS.md.template not found. Run npm run build.");
   }
-  const content = fs29.readFileSync(templatePath, "utf8");
+  const content = fs30.readFileSync(templatePath, "utf8");
   const start = content.indexOf(HAR_SECTION_START);
   const end = content.indexOf(HAR_SECTION_END);
   if (start === -1 || end === -1 || end < start) {
@@ -68530,9 +68873,9 @@ function loadAgentsMdTemplate() {
   if (!templatePath) {
     throw new Error("AGENTS.md.template not found. Run npm run build.");
   }
-  return fs29.readFileSync(templatePath, "utf8");
+  return fs30.readFileSync(templatePath, "utf8");
 }
-function upsertMarkedBlock(content, block, startMarker, endMarker) {
+function upsertMarkedBlock2(content, block, startMarker, endMarker) {
   const existingBlock = findLastCompleteMarkedBlock(content, startMarker, endMarker);
   if (existingBlock) {
     const newContent = content.slice(0, existingBlock.start) + block + content.slice(existingBlock.end);
@@ -68554,7 +68897,7 @@ function mergeAgentsMdContent(existing, incoming) {
       harSection = sanitizedIncoming.slice(start, end + HAR_SECTION_END.length);
     }
   }
-  const { content } = upsertMarkedBlock(
+  const { content } = upsertMarkedBlock2(
     sanitizedExisting,
     harSection,
     HAR_SECTION_START,
@@ -68563,15 +68906,15 @@ function mergeAgentsMdContent(existing, incoming) {
   return content;
 }
 function upsertAgentsMdHarSection(repoPath, options = {}) {
-  const dest = path35.join(repoPath, AGENTS_MD);
+  const dest = path36.join(repoPath, AGENTS_MD);
   const section = loadHarAgentsSectionFromTemplate();
-  if (!fs29.existsSync(dest)) {
+  if (!fs30.existsSync(dest)) {
     writeFileSafe(dest, loadAgentsMdTemplate());
     return "created";
   }
-  const existing = fs29.readFileSync(dest, "utf8");
+  const existing = fs30.readFileSync(dest, "utf8");
   const sanitized = stripClaudePointerFromAgentsMd(existing);
-  const { content, action } = upsertMarkedBlock(
+  const { content, action } = upsertMarkedBlock2(
     sanitized,
     section,
     HAR_SECTION_START,
@@ -68594,15 +68937,15 @@ function upsertAgentsMdHarSection(repoPath, options = {}) {
   return action;
 }
 function migrateLegacyAgentMd(repoPath) {
-  const legacyPath = path35.join(repoPath, LEGACY_AGENT_MD);
-  const agentsPath = path35.join(repoPath, AGENTS_MD);
-  if (!fs29.existsSync(legacyPath)) return false;
-  const legacy = fs29.readFileSync(legacyPath, "utf8");
-  if (!fs29.existsSync(agentsPath)) {
+  const legacyPath = path36.join(repoPath, LEGACY_AGENT_MD);
+  const agentsPath = path36.join(repoPath, AGENTS_MD);
+  if (!fs30.existsSync(legacyPath)) return false;
+  const legacy = fs30.readFileSync(legacyPath, "utf8");
+  if (!fs30.existsSync(agentsPath)) {
     writeFileSafe(agentsPath, legacy);
     upsertAgentsMdHarSection(repoPath);
   } else {
-    const agents = fs29.readFileSync(agentsPath, "utf8");
+    const agents = fs30.readFileSync(agentsPath, "utf8");
     const legacyTrimmed = legacy.trim();
     if (legacyTrimmed.length > 0 && !agents.includes(legacyTrimmed)) {
       const suffix = agents.endsWith("\n") ? "" : "\n";
@@ -68612,7 +68955,7 @@ ${legacyTrimmed}
     }
     upsertAgentsMdHarSection(repoPath);
   }
-  fs29.unlinkSync(legacyPath);
+  fs30.unlinkSync(legacyPath);
   info(`Migrated ${LEGACY_AGENT_MD} \u2192 ${AGENTS_MD} (removed legacy file)`);
   return true;
 }
@@ -68622,7 +68965,7 @@ function loadClaudeMdTemplate(projectName) {
     throw new Error("CLAUDE.md.template not found. Run npm run build.");
   }
   const displayName = projectName.replace(/_/g, " ");
-  return fs29.readFileSync(templatePath, "utf8").replace(/__PROJECT_DISPLAY_NAME__/g, displayName);
+  return fs30.readFileSync(templatePath, "utf8").replace(/__PROJECT_DISPLAY_NAME__/g, displayName);
 }
 function isThinClaudePointer(content) {
   const trimmed = content.trim();
@@ -68636,21 +68979,21 @@ This repository uses a \`.har/\` harness. Read [AGENTS.md](./AGENTS.md) and
 [\`.har/README.md\`](./.har/README.md) before making changes.
 ${CLAUDE_HAR_SECTION_END}`;
 function ensureClaudeMdPointer(repoPath, options = {}) {
-  const dest = path35.join(repoPath, CLAUDE_MD);
-  const projectName = path35.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const dest = path36.join(repoPath, CLAUDE_MD);
+  const projectName = path36.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
   const thin = loadClaudeMdTemplate(projectName);
-  if (!fs29.existsSync(dest)) {
+  if (!fs30.existsSync(dest)) {
     writeFileSafe(dest, thin);
     return "created";
   }
-  const existing = fs29.readFileSync(dest, "utf8");
+  const existing = fs30.readFileSync(dest, "utf8");
   if (isThinClaudePointer(existing) || options.force) {
     writeFileSafe(dest, thin);
     return "updated";
   }
   if (existing.includes(CLAUDE_HAR_SECTION_START) || /\[AGENTS\.md\]/.test(existing)) {
     if (existing.includes(CLAUDE_HAR_SECTION_START)) {
-      const { content: content2, action: action2 } = upsertMarkedBlock(
+      const { content: content2, action: action2 } = upsertMarkedBlock2(
         existing,
         CLAUDE_POINTER_BLOCK,
         CLAUDE_HAR_SECTION_START,
@@ -68661,7 +69004,7 @@ function ensureClaudeMdPointer(repoPath, options = {}) {
     }
     return "skipped";
   }
-  const { content, action } = upsertMarkedBlock(
+  const { content, action } = upsertMarkedBlock2(
     existing,
     CLAUDE_POINTER_BLOCK,
     CLAUDE_HAR_SECTION_START,
@@ -68792,19 +69135,19 @@ var AGENT_MD_PROPOSAL = "AGENT.md.proposed";
 var AGENT_MD_PROPOSAL_META = "AGENT.md.proposed.meta.json";
 function readAgentMdProposal(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
-  const proposalPath = path36.join(harnessDir, AGENTS_MD_PROPOSAL);
-  const metaPath = path36.join(harnessDir, AGENTS_MD_PROPOSAL_META);
-  const legacyProposalPath = path36.join(harnessDir, AGENT_MD_PROPOSAL);
-  const legacyMetaPath = path36.join(harnessDir, AGENT_MD_PROPOSAL_META);
-  const resolvedProposal = fs30.existsSync(proposalPath) ? proposalPath : fs30.existsSync(legacyProposalPath) ? legacyProposalPath : null;
+  const proposalPath = path37.join(harnessDir, AGENTS_MD_PROPOSAL);
+  const metaPath = path37.join(harnessDir, AGENTS_MD_PROPOSAL_META);
+  const legacyProposalPath = path37.join(harnessDir, AGENT_MD_PROPOSAL);
+  const legacyMetaPath = path37.join(harnessDir, AGENT_MD_PROPOSAL_META);
+  const resolvedProposal = fs31.existsSync(proposalPath) ? proposalPath : fs31.existsSync(legacyProposalPath) ? legacyProposalPath : null;
   if (!resolvedProposal) return null;
   const resolvedMeta = resolvedProposal === proposalPath ? metaPath : legacyMetaPath;
-  const content = fs30.readFileSync(resolvedProposal, "utf8");
+  const content = fs31.readFileSync(resolvedProposal, "utf8");
   let rationale = "";
   let createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  if (fs30.existsSync(resolvedMeta)) {
+  if (fs31.existsSync(resolvedMeta)) {
     try {
-      const meta = JSON.parse(fs30.readFileSync(resolvedMeta, "utf8"));
+      const meta = JSON.parse(fs31.readFileSync(resolvedMeta, "utf8"));
       rationale = meta.rationale ?? "";
       createdAt = meta.createdAt ?? createdAt;
     } catch {
@@ -68821,8 +69164,8 @@ function clearAgentMdProposal(repoPath) {
     AGENT_MD_PROPOSAL,
     AGENT_MD_PROPOSAL_META
   ]) {
-    const p = path36.join(harnessDir, file);
-    if (fs30.existsSync(p)) fs30.unlinkSync(p);
+    const p = path37.join(harnessDir, file);
+    if (fs31.existsSync(p)) fs31.unlinkSync(p);
   }
 }
 function wouldProposalShrinkExisting(existing, proposal) {
@@ -68835,9 +69178,9 @@ function wouldProposalShrinkExisting(existing, proposal) {
 function applyAgentMdProposalMerge(repoPath, options = {}) {
   const proposal = readAgentMdProposal(repoPath);
   if (!proposal) return false;
-  const agentsMdPath = path36.join(repoPath, AGENTS_MD);
-  if (fs30.existsSync(agentsMdPath)) {
-    const existing = fs30.readFileSync(agentsMdPath, "utf8");
+  const agentsMdPath = path37.join(repoPath, AGENTS_MD);
+  if (fs31.existsSync(agentsMdPath)) {
+    const existing = fs31.readFileSync(agentsMdPath, "utf8");
     if (wouldProposalShrinkExisting(existing, proposal.content)) {
       const message = `${AGENTS_MD} proposal would drop project-specific content outside har:agent-environment markers \u2014 merge custom sections from .har/${AGENTS_MD_PROPOSAL} manually, then delete the proposal.`;
       if (options.rejectSignificantShrink) {
@@ -68860,8 +69203,8 @@ function finalizeAgentsMdInstructionFiles(repoPath) {
 }
 
 // src/harness/validator.ts
-var fs31 = __toESM(require("fs"));
-var path37 = __toESM(require("path"));
+var fs32 = __toESM(require("fs"));
+var path38 = __toESM(require("path"));
 init_shell();
 init_manifest();
 init_stages();
@@ -68916,22 +69259,22 @@ var SHELL_SCRIPTS = [
 function validateHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
-  if (!fs31.existsSync(harnessDir)) {
+  if (!fs32.existsSync(harnessDir)) {
     return {
       pass: false,
       issues: [{ file: ".har", message: "Harness directory not found", severity: "error" }]
     };
   }
   for (const file of getRequiredFiles(repoPath)) {
-    const filePath = path37.join(harnessDir, file);
-    if (!fs31.existsSync(filePath)) {
+    const filePath = path38.join(harnessDir, file);
+    if (!fs32.existsSync(filePath)) {
       issues.push({ file, message: "Required file missing", severity: "error" });
     }
   }
   for (const script of SHELL_SCRIPTS) {
-    const scriptPath = path37.join(harnessDir, script);
-    if (!fs31.existsSync(scriptPath)) continue;
-    const stat = fs31.statSync(scriptPath);
+    const scriptPath = path38.join(harnessDir, script);
+    if (!fs32.existsSync(scriptPath)) continue;
+    const stat = fs32.statSync(scriptPath);
     if (!(stat.mode & 73)) {
       issues.push({ file: script, message: "Script is not executable", severity: "warning" });
     }
@@ -68946,9 +69289,9 @@ function validateHarness(repoPath) {
   }
   const manifest = readManifest(repoPath);
   const profile = manifest?.profile ?? "default";
-  const ecosystemPath = path37.join(harnessDir, "ecosystem.agent.template.cjs");
-  if (profile !== "cli" && fs31.existsSync(ecosystemPath)) {
-    const content = fs31.readFileSync(ecosystemPath, "utf8");
+  const ecosystemPath = path38.join(harnessDir, "ecosystem.agent.template.cjs");
+  if (profile !== "cli" && fs32.existsSync(ecosystemPath)) {
+    const content = fs32.readFileSync(ecosystemPath, "utf8");
     if (!content.includes("module.exports")) {
       issues.push({
         file: "ecosystem.agent.template.cjs",
@@ -68957,9 +69300,9 @@ function validateHarness(repoPath) {
       });
     }
   }
-  const harnessEnvPath = path37.join(harnessDir, "harness.env");
-  if (fs31.existsSync(harnessEnvPath)) {
-    const content = fs31.readFileSync(harnessEnvPath, "utf8");
+  const harnessEnvPath = path38.join(harnessDir, "harness.env");
+  if (fs32.existsSync(harnessEnvPath)) {
+    const content = fs32.readFileSync(harnessEnvPath, "utf8");
     if (content.includes("TODO: set migrate command")) {
       issues.push({ file: "harness.env", message: "Migrate command still has TODO", severity: "warning" });
     }
@@ -68967,17 +69310,17 @@ function validateHarness(repoPath) {
       issues.push({ file: "harness.env", message: "Seed command still has TODO", severity: "warning" });
     }
   }
-  const verifyPath = path37.join(harnessDir, "verify.sh");
-  if (fs31.existsSync(verifyPath)) {
-    const content = fs31.readFileSync(verifyPath, "utf8");
+  const verifyPath = path38.join(harnessDir, "verify.sh");
+  if (fs32.existsSync(verifyPath)) {
+    const content = fs32.readFileSync(verifyPath, "utf8");
     if (content.includes("echo 'TODO:")) {
       issues.push({ file: "verify.sh", message: "Verification steps still have TODO placeholders", severity: "warning" });
     }
   }
-  const stagesPath = path37.join(harnessDir, "stages.json");
-  if (fs31.existsSync(stagesPath)) {
+  const stagesPath = path38.join(harnessDir, "stages.json");
+  if (fs32.existsSync(stagesPath)) {
     try {
-      JSON.parse(fs31.readFileSync(stagesPath, "utf8"));
+      JSON.parse(fs32.readFileSync(stagesPath, "utf8"));
       const registry2 = readStageRegistry(repoPath);
       if (registry2.stages.length === 0) {
         issues.push({ file: "stages.json", message: "No harness stages declared", severity: "warning" });
@@ -68992,9 +69335,9 @@ function validateHarness(repoPath) {
   } else {
     issues.push({ file: "stages.json", message: "Stage registry missing", severity: "warning" });
   }
-  const readmePath = path37.join(harnessDir, "README.md");
-  if (fs31.existsSync(readmePath)) {
-    const content = fs31.readFileSync(readmePath, "utf8");
+  const readmePath = path38.join(harnessDir, "README.md");
+  if (fs32.existsSync(readmePath)) {
+    const content = fs32.readFileSync(readmePath, "utf8");
     if (!content.includes(".har")) {
       issues.push({ file: "README.md", message: "README should document .har/ paths", severity: "warning" });
     }
@@ -69008,8 +69351,8 @@ function validateHarness(repoPath) {
 async function smokeTestHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
-  const setupScript = path37.join(harnessDir, "setup-infra.sh");
-  if (fs31.existsSync(setupScript)) {
+  const setupScript = path38.join(harnessDir, "setup-infra.sh");
+  if (fs32.existsSync(setupScript)) {
     const result = run(`bash "${setupScript}"`, { cwd: repoPath });
     if (result.code !== 0) {
       issues.push({
@@ -69024,8 +69367,8 @@ async function smokeTestHarness(repoPath) {
 }
 
 // src/harness/drift.ts
-var fs32 = __toESM(require("fs"));
-var path38 = __toESM(require("path"));
+var fs33 = __toESM(require("fs"));
+var path39 = __toESM(require("path"));
 init_env();
 init_manifest();
 init_stages();
@@ -69096,16 +69439,16 @@ function substituteProjectName(content, projectName) {
   return content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
 }
 function listBoilerplateFiles(boilerplateDir) {
-  if (!fs32.existsSync(boilerplateDir)) return [];
-  return fs32.readdirSync(boilerplateDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  if (!fs33.existsSync(boilerplateDir)) return [];
+  return fs33.readdirSync(boilerplateDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
 }
 function compareHarnessToTemplate(repoPath) {
-  const resolved = path38.resolve(repoPath);
+  const resolved = path39.resolve(repoPath);
   const manifest = readManifest(resolved);
   const profile = manifest?.profile ?? "default";
   const harnessDir = getHarnessDir(resolved);
-  const projectName = path38.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
-  const boilerplateDir = path38.join(resolveTemplatesDir(), PROFILE_DIRS2[profile]);
+  const projectName = path39.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const boilerplateDir = path39.join(resolveTemplatesDir(), PROFILE_DIRS2[profile]);
   const templateFiles = listBoilerplateFiles(boilerplateDir);
   const missing = [];
   const checksumMismatch = [];
@@ -69113,17 +69456,17 @@ function compareHarnessToTemplate(repoPath) {
   const unchanged = [];
   for (const file of templateFiles) {
     const harnessFile = harnessFileForTemplate(file);
-    const templatePath = path38.join(boilerplateDir, file);
-    const harnessPath = path38.join(harnessDir, harnessFile);
-    let templateContent = fs32.readFileSync(templatePath, "utf8");
+    const templatePath = path39.join(boilerplateDir, file);
+    const harnessPath = path39.join(harnessDir, harnessFile);
+    let templateContent = fs33.readFileSync(templatePath, "utf8");
     if (file === "harness.env") {
       templateContent = substituteProjectName(templateContent, projectName);
     }
-    if (!fs32.existsSync(harnessPath)) {
+    if (!fs33.existsSync(harnessPath)) {
       missing.push(harnessFile);
       continue;
     }
-    const harnessChecksum = computeFileChecksum(fs32.readFileSync(harnessPath, "utf8"));
+    const harnessChecksum = computeFileChecksum(fs33.readFileSync(harnessPath, "utf8"));
     const templateChecksum = computeFileChecksum(templateContent);
     if (harnessChecksum === templateChecksum) {
       unchanged.push(harnessFile);
@@ -69131,10 +69474,10 @@ function compareHarnessToTemplate(repoPath) {
       checksumMismatch.push(harnessFile);
     }
   }
-  if (fs32.existsSync(harnessDir)) {
-    for (const file of fs32.readdirSync(harnessDir)) {
-      const full = path38.join(harnessDir, file);
-      if (!fs32.statSync(full).isFile()) continue;
+  if (fs33.existsSync(harnessDir)) {
+    for (const file of fs33.readdirSync(harnessDir)) {
+      const full = path39.join(harnessDir, file);
+      if (!fs33.statSync(full).isFile()) continue;
       if (file === "manifest.json" || file.startsWith("ADAPT-PROMPT")) continue;
       if (profile === "cli" && CLI_EXPECTED_ABSENT.has(file)) {
         extra.push(file);
@@ -69165,29 +69508,29 @@ function compareHarnessToTemplate(repoPath) {
 }
 
 // src/harness/maintain-bundle.ts
-var fs36 = __toESM(require("fs"));
-var os14 = __toESM(require("os"));
-var path41 = __toESM(require("path"));
+var fs37 = __toESM(require("fs"));
+var os15 = __toESM(require("os"));
+var path42 = __toESM(require("path"));
 init_file_ops();
 init_shell();
 init_manifest();
 
 // src/harness/plugin-drift.ts
-var fs35 = __toESM(require("fs"));
-var path40 = __toESM(require("path"));
+var fs36 = __toESM(require("fs"));
+var path41 = __toESM(require("path"));
 init_manifest();
 
 // src/harness/plugins.ts
-var fs34 = __toESM(require("fs"));
-var path39 = __toESM(require("path"));
+var fs35 = __toESM(require("fs"));
+var path40 = __toESM(require("path"));
 init_zod();
 init_logging();
 
 // src/harness/parser.ts
-var fs33 = __toESM(require("fs"));
+var fs34 = __toESM(require("fs"));
 init_manifest();
 function harnessExists(repoPath) {
-  return fs33.existsSync(`${repoPath}/.har/setup-infra.sh`);
+  return fs34.existsSync(`${repoPath}/.har/setup-infra.sh`);
 }
 
 // src/harness/plugins.ts
@@ -69212,16 +69555,16 @@ var PluginManifestSchema = external_exports.object({
   docsPath: external_exports.string().min(1)
 });
 function resolvePluginDir(pluginId) {
-  const dir = path39.join(resolveTemplatesDir(), "plugins", pluginId);
-  if (!fs34.existsSync(dir)) {
+  const dir = path40.join(resolveTemplatesDir(), "plugins", pluginId);
+  if (!fs35.existsSync(dir)) {
     throw new Error(`Plugin not found: ${pluginId}. Run npm run build.`);
   }
   return dir;
 }
 function readPluginManifest(pluginId) {
-  const manifestPath = path39.join(resolvePluginDir(pluginId), "template.manifest.json");
+  const manifestPath = path40.join(resolvePluginDir(pluginId), "template.manifest.json");
   const parsed = PluginManifestSchema.safeParse(
-    JSON.parse(fs34.readFileSync(manifestPath, "utf8"))
+    JSON.parse(fs35.readFileSync(manifestPath, "utf8"))
   );
   if (!parsed.success) {
     throw new Error(`Invalid plugin manifest for ${pluginId}: ${parsed.error.message}`);
@@ -69232,40 +69575,40 @@ function readPluginManifest(pluginId) {
   return parsed.data;
 }
 function ensureParentDir(filePath) {
-  const parent = path39.dirname(filePath);
-  if (!fs34.existsSync(parent)) {
-    fs34.mkdirSync(parent, { recursive: true });
+  const parent = path40.dirname(filePath);
+  if (!fs35.existsSync(parent)) {
+    fs35.mkdirSync(parent, { recursive: true });
   }
 }
 function copyPluginFile(pluginDir, file, repoPath, force) {
-  const srcPath = path39.join(pluginDir, file.src);
-  const destPath = path39.join(repoPath, file.dest);
-  if (!fs34.existsSync(srcPath)) {
+  const srcPath = path40.join(pluginDir, file.src);
+  const destPath = path40.join(repoPath, file.dest);
+  if (!fs35.existsSync(srcPath)) {
     throw new Error(`Plugin file missing: ${file.src}`);
   }
-  if (fs34.existsSync(destPath) && !force) {
+  if (fs35.existsSync(destPath) && !force) {
     throw new Error(
       `File already exists: ${file.dest}. Use --force to overwrite or remove it first.`
     );
   }
   ensureParentDir(destPath);
-  fs34.copyFileSync(srcPath, destPath);
+  fs35.copyFileSync(srcPath, destPath);
   if (file.executable) {
-    fs34.chmodSync(destPath, 493);
+    fs35.chmodSync(destPath, 493);
   }
   return { written: true, path: file.dest };
 }
 function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
-  const packagePath = path39.join(repoPath, "package.json");
-  if (!fs34.existsSync(packagePath)) {
+  const packagePath = path40.join(repoPath, "package.json");
+  if (!fs35.existsSync(packagePath)) {
     throw new Error("No package.json in repo root. Add one before applying this plugin.");
   }
-  const fragmentPath = path39.join(pluginDir, fragmentRelPath);
-  if (!fs34.existsSync(fragmentPath)) {
+  const fragmentPath = path40.join(pluginDir, fragmentRelPath);
+  if (!fs35.existsSync(fragmentPath)) {
     throw new Error(`Package fragment missing: ${fragmentRelPath}`);
   }
-  const pkg = JSON.parse(fs34.readFileSync(packagePath, "utf8"));
-  const fragment = JSON.parse(fs34.readFileSync(fragmentPath, "utf8"));
+  const pkg = JSON.parse(fs35.readFileSync(packagePath, "utf8"));
+  const fragment = JSON.parse(fs35.readFileSync(fragmentPath, "utf8"));
   for (const section of ["scripts", "devDependencies"]) {
     const existing = pkg[section] ?? {};
     const incoming = fragment[section] ?? {};
@@ -69278,7 +69621,7 @@ function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
     }
     pkg[section] = existing;
   }
-  fs34.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
+  fs35.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
 }
 function patchStageRegistry(repoPath, manifest, force) {
   const registry2 = readStageRegistry(repoPath);
@@ -69318,8 +69661,8 @@ function assertHarnessPresent(repoPath) {
 }
 function assertStageNotPresent(repoPath, stageId, force) {
   if (force) return;
-  const scriptPath = path39.join(repoPath, ".har", "stages", `${stageId}.sh`);
-  if (fs34.existsSync(scriptPath)) {
+  const scriptPath = path40.join(repoPath, ".har", "stages", `${stageId}.sh`);
+  if (fs35.existsSync(scriptPath)) {
     throw new Error(
       `Stage script already exists: .har/stages/${stageId}.sh. Use --force to overwrite.`
     );
@@ -69332,7 +69675,7 @@ function assertStageNotPresent(repoPath, stageId, force) {
   }
 }
 function applyPlugin(repoPath, pluginId, options = {}) {
-  const resolved = path39.resolve(repoPath);
+  const resolved = path40.resolve(repoPath);
   const force = options.force ?? false;
   const warnings = [];
   const filesWritten = [];
@@ -69351,7 +69694,7 @@ function applyPlugin(repoPath, pluginId, options = {}) {
       if (file.skipFlag === "skipCi" && options.skipCi) {
         continue;
       }
-      if (fs34.existsSync(path39.join(resolved, file.dest)) && !force) {
+      if (fs35.existsSync(path40.join(resolved, file.dest)) && !force) {
         warnings.push(`Skipped optional file (exists): ${file.dest}`);
         continue;
       }
@@ -69386,18 +69729,18 @@ function applyPlugin(repoPath, pluginId, options = {}) {
   };
 }
 function listPluginIds() {
-  const root = path39.join(resolveTemplatesDir(), "plugins");
-  if (!fs34.existsSync(root)) return [...PLUGIN_IDS];
-  return fs34.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => PLUGIN_IDS.includes(name));
+  const root = path40.join(resolveTemplatesDir(), "plugins");
+  if (!fs35.existsSync(root)) return [...PLUGIN_IDS];
+  return fs35.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => PLUGIN_IDS.includes(name));
 }
 
 // src/harness/plugin-drift.ts
 init_stages();
 var PACKAGE_SECTIONS = ["scripts", "devDependencies"];
 function detectInstalledPlugins(repoPath) {
-  const resolved = path40.resolve(repoPath);
-  const registryPath = path40.join(resolved, ".har", "stages.json");
-  if (!fs35.existsSync(registryPath)) return [];
+  const resolved = path41.resolve(repoPath);
+  const registryPath = path41.join(resolved, ".har", "stages.json");
+  if (!fs36.existsSync(registryPath)) return [];
   const registry2 = readStageRegistry(resolved);
   const stageIds = new Set(registry2.stages.map((stage) => stage.id));
   const installed = [];
@@ -69410,17 +69753,17 @@ function detectInstalledPlugins(repoPath) {
   return installed;
 }
 function pluginTemplatePath(pluginId, srcRel) {
-  return path40.join(resolveTemplatesDir(), "plugins", pluginId, srcRel);
+  return path41.join(resolveTemplatesDir(), "plugins", pluginId, srcRel);
 }
 function readBundledPluginFile(pluginId, srcRel) {
-  return fs35.readFileSync(pluginTemplatePath(pluginId, srcRel), "utf8");
+  return fs36.readFileSync(pluginTemplatePath(pluginId, srcRel), "utf8");
 }
 function listPluginDestPaths(pluginId, repoPath) {
   const manifest = readPluginManifest(pluginId);
   const paths = manifest.files.map((file) => file.dest);
   if (manifest.optionalFiles) {
     for (const file of manifest.optionalFiles) {
-      if (fs35.existsSync(path40.join(repoPath, file.dest))) {
+      if (fs36.existsSync(path41.join(repoPath, file.dest))) {
         paths.push(file.dest);
       }
     }
@@ -69479,9 +69822,9 @@ function readTemplatePluginFile(pluginId, dest) {
   return null;
 }
 function readInstalledPluginFile(repoPath, pluginId, dest) {
-  const installedPath = path40.join(path40.resolve(repoPath), dest);
-  if (!fs35.existsSync(installedPath)) return null;
-  const content = fs35.readFileSync(installedPath, "utf8");
+  const installedPath = path41.join(path41.resolve(repoPath), dest);
+  if (!fs36.existsSync(installedPath)) return null;
+  const content = fs36.readFileSync(installedPath, "utf8");
   const manifest = readPluginManifest(pluginId);
   const fragmentRel = manifest.merge?.[dest];
   if (fragmentRel) {
@@ -69500,7 +69843,7 @@ function pluginActionHint(pluginId, dest, kind) {
 }
 function comparePluginToTemplate(repoPath, pluginId) {
   const manifest = readPluginManifest(pluginId);
-  const resolved = path40.resolve(repoPath);
+  const resolved = path41.resolve(repoPath);
   const destPaths = listPluginDestPaths(pluginId, resolved);
   const missing = [];
   const checksumMismatch = [];
@@ -69515,8 +69858,8 @@ function comparePluginToTemplate(repoPath, pluginId) {
     }
     if (dest === "package.json") {
       const fragmentRel = manifest.merge?.[dest];
-      const installedPath = path40.join(resolved, dest);
-      const installedRaw = fs35.readFileSync(installedPath, "utf8");
+      const installedPath = path41.join(resolved, dest);
+      const installedRaw = fs36.readFileSync(installedPath, "utf8");
       if (fragmentRel && pluginKeysMatch(installedRaw, readBundledPluginFile(pluginId, fragmentRel))) {
         unchanged.push(dest);
       } else if (computeFileChecksum(installedContent) === computeFileChecksum(templateContent)) {
@@ -69585,14 +69928,14 @@ function substituteProjectName2(content, projectName) {
   return content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
 }
 function projectNameFromRepo(repoPath) {
-  return path41.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  return path42.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
 }
 function boilerplateDirForProfile(profile) {
-  return path41.join(resolveTemplatesDir(), PROFILE_DIRS3[profile]);
+  return path42.join(resolveTemplatesDir(), PROFILE_DIRS3[profile]);
 }
 function readBundledTemplateContent(repoPath, profile, file) {
-  const templatePath = path41.join(boilerplateDirForProfile(profile), templateFileForHarness(file));
-  let content = fs36.readFileSync(templatePath, "utf8");
+  const templatePath = path42.join(boilerplateDirForProfile(profile), templateFileForHarness(file));
+  let content = fs37.readFileSync(templatePath, "utf8");
   if (file === "harness.env") {
     content = substituteProjectName2(content, projectNameFromRepo(repoPath));
   }
@@ -69623,12 +69966,12 @@ function actionHint(file, kind) {
   return `Read maintain/diffs/${file}.diff and merge into .har/${file}.`;
 }
 function createUnifiedDiff(installedContent, templateContent, installedLabel, templateLabel) {
-  const tmpDir = fs36.mkdtempSync(path41.join(os14.tmpdir(), "har-maintain-diff-"));
+  const tmpDir = fs37.mkdtempSync(path42.join(os15.tmpdir(), "har-maintain-diff-"));
   try {
-    const installedPath = path41.join(tmpDir, "installed");
-    const templatePath = path41.join(tmpDir, "template");
-    fs36.writeFileSync(installedPath, installedContent);
-    fs36.writeFileSync(templatePath, templateContent);
+    const installedPath = path42.join(tmpDir, "installed");
+    const templatePath = path42.join(tmpDir, "template");
+    fs37.writeFileSync(installedPath, installedContent);
+    fs37.writeFileSync(templatePath, templateContent);
     const result = run(`diff -u "${installedPath}" "${templatePath}"`);
     const body = result.stdout.trim();
     if (!body) return "";
@@ -69637,7 +69980,7 @@ function createUnifiedDiff(installedContent, templateContent, installedLabel, te
 ${body.split("\n").slice(2).join("\n")}
 `;
   } finally {
-    fs36.rmSync(tmpDir, { recursive: true, force: true });
+    fs37.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function buildActions(repoPath, profile, drift) {
@@ -69652,7 +69995,7 @@ function buildActions(repoPath, profile, drift) {
     });
   }
   for (const file of drift.checksumMismatch) {
-    const installedPath = path41.join(harnessDir, file);
+    const installedPath = path42.join(harnessDir, file);
     const installedRel = `maintain/installed/${file}`;
     const templateRel = `maintain/templates/${file}`;
     const diffRel = `maintain/diffs/${file}.diff`;
@@ -69660,7 +70003,7 @@ function buildActions(repoPath, profile, drift) {
       file,
       kind: "drift",
       template: templateRel,
-      installed: fs36.existsSync(installedPath) ? installedRel : void 0,
+      installed: fs37.existsSync(installedPath) ? installedRel : void 0,
       diff: diffRel,
       hint: actionHint(file, "drift")
     });
@@ -69812,28 +70155,28 @@ function buildReadme(report) {
 }
 function writeBundleArtifacts(repoPath, profile, drift, report) {
   const harnessDir = getHarnessDir(repoPath);
-  const bundleDir = path41.join(harnessDir, MAINTAIN_DIR);
-  if (fs36.existsSync(bundleDir)) {
-    fs36.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path42.join(harnessDir, MAINTAIN_DIR);
+  if (fs37.existsSync(bundleDir)) {
+    fs37.rmSync(bundleDir, { recursive: true, force: true });
   }
   const dirs = [
     bundleDir,
-    path41.join(bundleDir, "templates"),
-    path41.join(bundleDir, "installed"),
-    path41.join(bundleDir, "diffs"),
-    path41.join(bundleDir, "stale")
+    path42.join(bundleDir, "templates"),
+    path42.join(bundleDir, "installed"),
+    path42.join(bundleDir, "diffs"),
+    path42.join(bundleDir, "stale")
   ];
   for (const dir of dirs) {
-    fs36.mkdirSync(dir, { recursive: true });
+    fs37.mkdirSync(dir, { recursive: true });
   }
   const affectedFiles = [...drift.missing, ...drift.checksumMismatch];
   for (const file of affectedFiles) {
     const templateContent = readBundledTemplateContent(repoPath, profile, file);
-    writeFileSafe(path41.join(bundleDir, "templates", file), templateContent);
-    const harnessPath = path41.join(harnessDir, file);
-    if (fs36.existsSync(harnessPath)) {
-      const installedContent = fs36.readFileSync(harnessPath, "utf8");
-      writeFileSafe(path41.join(bundleDir, "installed", file), installedContent);
+    writeFileSafe(path42.join(bundleDir, "templates", file), templateContent);
+    const harnessPath = path42.join(harnessDir, file);
+    if (fs37.existsSync(harnessPath)) {
+      const installedContent = fs37.readFileSync(harnessPath, "utf8");
+      writeFileSafe(path42.join(bundleDir, "installed", file), installedContent);
       const diff = createUnifiedDiff(
         installedContent,
         templateContent,
@@ -69841,14 +70184,14 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
         `templates/${file}`
       );
       if (diff) {
-        writeFileSafe(path41.join(bundleDir, "diffs", `${file}.diff`), diff);
+        writeFileSafe(path42.join(bundleDir, "diffs", `${file}.diff`), diff);
       }
     }
   }
-  writeFileSafe(path41.join(bundleDir, "README.md"), buildReadme(report));
-  writeFileSafe(path41.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
+  writeFileSafe(path42.join(bundleDir, "README.md"), buildReadme(report));
+  writeFileSafe(path42.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
   writeFileSafe(
-    path41.join(bundleDir, "validation.json"),
+    path42.join(bundleDir, "validation.json"),
     JSON.stringify(report.validation, null, 2) + "\n"
   );
   if (report.stale.length > 0) {
@@ -69860,34 +70203,34 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
       ...report.stale.map((s) => `- **${s.file}** \u2014 ${s.hint}`),
       ""
     ];
-    writeFileSafe(path41.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
+    writeFileSafe(path42.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
   }
   return bundleDir;
 }
 function ensureParentDir2(filePath) {
-  const parent = path41.dirname(filePath);
-  if (!fs36.existsSync(parent)) {
-    fs36.mkdirSync(parent, { recursive: true });
+  const parent = path42.dirname(filePath);
+  if (!fs37.existsSync(parent)) {
+    fs37.mkdirSync(parent, { recursive: true });
   }
 }
 function writePluginBundleArtifacts(repoPath, bundleDir, report) {
   if (report.pluginActions.length === 0) return;
   for (const action of report.pluginActions) {
-    const pluginRoot = path41.join(bundleDir, "plugins", action.pluginId);
-    const templatesDir = path41.join(pluginRoot, "templates");
-    const installedDir = path41.join(pluginRoot, "installed");
-    const diffsDir = path41.join(pluginRoot, "diffs");
+    const pluginRoot = path42.join(bundleDir, "plugins", action.pluginId);
+    const templatesDir = path42.join(pluginRoot, "templates");
+    const installedDir = path42.join(pluginRoot, "installed");
+    const diffsDir = path42.join(pluginRoot, "diffs");
     for (const dir of [templatesDir, installedDir, diffsDir]) {
-      fs36.mkdirSync(dir, { recursive: true });
+      fs37.mkdirSync(dir, { recursive: true });
     }
     const templateContent = readTemplatePluginFile(action.pluginId, action.file);
     if (templateContent === null) continue;
-    const templatePath = path41.join(templatesDir, action.file);
+    const templatePath = path42.join(templatesDir, action.file);
     ensureParentDir2(templatePath);
     writeFileSafe(templatePath, templateContent);
     const installedContent = readInstalledPluginFile(repoPath, action.pluginId, action.file);
     if (installedContent !== null) {
-      const installedPath = path41.join(installedDir, action.file);
+      const installedPath = path42.join(installedDir, action.file);
       ensureParentDir2(installedPath);
       writeFileSafe(installedPath, installedContent);
       const diff = createUnifiedDiff(
@@ -69897,7 +70240,7 @@ function writePluginBundleArtifacts(repoPath, bundleDir, report) {
         `templates/${action.file}`
       );
       if (diff) {
-        const diffPath = path41.join(diffsDir, `${action.file}.diff`);
+        const diffPath = path42.join(diffsDir, `${action.file}.diff`);
         ensureParentDir2(diffPath);
         writeFileSafe(diffPath, diff);
       }
@@ -69933,9 +70276,9 @@ function buildMaintainBundle(repoPath, validation2, drift) {
   return { bundleDir, report };
 }
 function removeMaintainBundle(repoPath) {
-  const bundleDir = path41.join(getHarnessDir(repoPath), MAINTAIN_DIR);
-  if (fs36.existsSync(bundleDir)) {
-    fs36.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path42.join(getHarnessDir(repoPath), MAINTAIN_DIR);
+  if (fs37.existsSync(bundleDir)) {
+    fs37.rmSync(bundleDir, { recursive: true, force: true });
   }
 }
 function formatMaintainBundlePromptSection(report) {
@@ -70024,11 +70367,11 @@ init_manifest();
 init_stages();
 function listHarnessScripts(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs37.existsSync(harnessDir)) return [];
-  return fs37.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
+  if (!fs38.existsSync(harnessDir)) return [];
+  return fs38.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
 }
 function describeProject(repoPath) {
-  const resolved = path42.resolve(repoPath);
+  const resolved = path43.resolve(repoPath);
   const manifest = readManifest(resolved);
   const present = harnessExists(resolved);
   return {
@@ -70048,8 +70391,8 @@ function describeProject(repoPath) {
   };
 }
 async function initHarness(options) {
-  const repoPath = path42.resolve(options.repoPath);
-  if (!fs37.existsSync(repoPath)) {
+  const repoPath = path43.resolve(options.repoPath);
+  if (!fs38.existsSync(repoPath)) {
     throw new Error(`Path not found: ${repoPath}`);
   }
   const scaffold = scaffoldHarnessBoilerplate(repoPath, {
@@ -70069,9 +70412,9 @@ async function initHarness(options) {
   };
 }
 async function maintainHarness(options) {
-  const repoPath = path42.resolve(options.repoPath);
+  const repoPath = path43.resolve(options.repoPath);
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs37.existsSync(harnessDir)) {
+  if (!fs38.existsSync(harnessDir)) {
     throw new Error('No .har/ found. Run "har env init" first.');
   }
   const drift = compareHarnessToTemplate(repoPath);
@@ -70106,13 +70449,13 @@ function addPlugin(repoPath, pluginId, options = {}) {
 }
 
 // src/harness/custom-stage.ts
-var fs38 = __toESM(require("fs"));
-var path43 = __toESM(require("path"));
+var fs39 = __toESM(require("fs"));
+var path44 = __toESM(require("path"));
 init_schema2();
 init_stages();
 var STAGE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 function addCustomStage(repoPath, options) {
-  const resolved = path43.resolve(repoPath);
+  const resolved = path44.resolve(repoPath);
   if (!harnessExists(resolved)) {
     throw new Error('No .har/ harness found. Run "har env init" first.');
   }
@@ -70149,20 +70492,20 @@ function addCustomStage(repoPath, options) {
   if (options.command) {
     stage.command = options.command;
   } else {
-    const scriptRel = path43.join("stages", `${id}.sh`);
-    const scriptAbs = path43.join(resolved, ".har", scriptRel);
-    if (fs38.existsSync(scriptAbs) && !options.force) {
+    const scriptRel = path44.join("stages", `${id}.sh`);
+    const scriptAbs = path44.join(resolved, ".har", scriptRel);
+    if (fs39.existsSync(scriptAbs) && !options.force) {
       throw new Error(`Stage script already exists: .har/${scriptRel}. Use --force to overwrite.`);
     }
-    const skeletonPath = path43.join(
+    const skeletonPath = path44.join(
       resolveTemplatesDir(),
       "plugins",
       "custom-stage-skeleton.sh"
     );
-    const skeleton = fs38.readFileSync(skeletonPath, "utf8").replace(/__STAGE_ID__/g, id).replace(/__STAGE_KIND__/g, kind).replace(/__STAGE_DESCRIPTION__/g, stage.description);
-    fs38.mkdirSync(path43.dirname(scriptAbs), { recursive: true });
-    fs38.writeFileSync(scriptAbs, skeleton);
-    fs38.chmodSync(scriptAbs, 493);
+    const skeleton = fs39.readFileSync(skeletonPath, "utf8").replace(/__STAGE_ID__/g, id).replace(/__STAGE_KIND__/g, kind).replace(/__STAGE_DESCRIPTION__/g, stage.description);
+    fs39.mkdirSync(path44.dirname(scriptAbs), { recursive: true });
+    fs39.writeFileSync(scriptAbs, skeleton);
+    fs39.chmodSync(scriptAbs, 493);
     filesWritten.push(`.har/${scriptRel}`);
     stage.script = scriptRel;
     stage.artifacts = [
@@ -70210,18 +70553,18 @@ function addCustomStage(repoPath, options) {
 }
 
 // src/harness/adaptation-prompt.ts
-var fs39 = __toESM(require("fs"));
-var path44 = __toESM(require("path"));
+var fs40 = __toESM(require("fs"));
+var path45 = __toESM(require("path"));
 var readline5 = __toESM(require("readline"));
 
 // src/utils/clipboard.ts
-var import_child_process9 = require("child_process");
+var import_child_process10 = require("child_process");
 function commandExists2(command2) {
-  const probe = process.platform === "win32" ? (0, import_child_process9.spawnSync)("where", [command2], { encoding: "utf8", stdio: ["ignore", "ignore", "ignore"] }) : (0, import_child_process9.spawnSync)("which", [command2], { encoding: "utf8", stdio: ["ignore", "ignore", "ignore"] });
+  const probe = process.platform === "win32" ? (0, import_child_process10.spawnSync)("where", [command2], { encoding: "utf8", stdio: ["ignore", "ignore", "ignore"] }) : (0, import_child_process10.spawnSync)("which", [command2], { encoding: "utf8", stdio: ["ignore", "ignore", "ignore"] });
   return probe.status === 0;
 }
 function tryPipeCommand(command2, args, text) {
-  const result = (0, import_child_process9.spawnSync)(command2, args, {
+  const result = (0, import_child_process10.spawnSync)(command2, args, {
     input: text,
     encoding: "utf8",
     stdio: ["pipe", "ignore", "ignore"]
@@ -70241,7 +70584,7 @@ function copyViaPlatformTools(text) {
   }
   if (process.platform === "win32") {
     if (commandExists2("powershell")) {
-      const result = (0, import_child_process9.spawnSync)(
+      const result = (0, import_child_process10.spawnSync)(
         "powershell",
         [
           "-NoProfile",
@@ -70292,16 +70635,16 @@ init_logging();
 init_manifest();
 var ADAPTATION_PROMPT_FILE = "ADAPT-PROMPT.md";
 var PROFILE_HINTS = {
-  default: "Web app profile (SaaS/full-stack) \u2014 Docker Compose for shared infra (HARNESS_INFRA_SERVICES), PM2 for the primary application only, git worktree per agent slot by default. Launch provisions toolchain via harness.env (HARNESS_ECOSYSTEM, HARNESS_INSTALL_CMD) and writes paths to .env.agent.<id>. Identify the primary app agents modify; run supporting services shared. Install the Semgrep plugin (har env add-plugin semgrep) when the repo needs a SAST verification stage.",
-  cli: "CLI/library profile (typical SWE-bench) \u2014 no PM2. Optional Docker Compose via HARNESS_INFRA_SERVICES. Git worktree by default. Launch provisions toolchain declaratively (HARNESS_ECOSYSTEM auto-detects common ecosystems); verify must use resolved tool paths from .env.agent.<id>, never hardcoded interpreter or package-manager paths. Install the Semgrep plugin (har env add-plugin semgrep) when the repo needs a SAST verification stage.",
-  ios: "iOS mobile app profile \u2014 xcodebuild + iOS Simulator in an isolated git worktree. Set HARNESS_XCODE_SCHEME, workspace/project, HARNESS_SIMULATOR_NAME, HARNESS_BUNDLE_ID. Launch writes XCODEBUILD_BIN to .env.agent.<id>; verify uses it. Install RocketSim plugin (har env add-plugin rocketsim) for user-flow validation."
+  default: "Web app profile (SaaS/full-stack) \u2014 Docker Compose for shared infra (HARNESS_INFRA_SERVICES), PM2 for the primary application only, git worktree per agent slot by default. Launch provisions toolchain via harness.env (HARNESS_ECOSYSTEM, HARNESS_INSTALL_CMD) and writes paths to .env.agent.<id>. Identify the primary app agents modify; run supporting services shared.",
+  cli: "CLI/library profile (typical SWE-bench) \u2014 no PM2. Optional Docker Compose via HARNESS_INFRA_SERVICES. Git worktree by default. Launch provisions toolchain declaratively (HARNESS_ECOSYSTEM auto-detects common ecosystems); verify must use resolved tool paths from .env.agent.<id>, never hardcoded interpreter or package-manager paths.",
+  ios: "iOS mobile app profile \u2014 xcodebuild + iOS Simulator in an isolated git worktree. Set HARNESS_XCODE_SCHEME, workspace/project, HARNESS_SIMULATOR_NAME, HARNESS_BUNDLE_ID. Launch writes XCODEBUILD_BIN to .env.agent.<id>; verify uses it."
 };
 function loadTemplate(name) {
   const filePath = resolveTemplateFile(name);
   if (!filePath) {
     throw new Error(`Adaptation prompt template not found: ${name}. Run npm run build.`);
   }
-  return fs39.readFileSync(filePath, "utf8");
+  return fs40.readFileSync(filePath, "utf8");
 }
 function applyProfilePlaceholders(content, profile) {
   return content.replace(/\{\{PROFILE\}\}/g, profile).replace(/\{\{PROFILE_HINT\}\}/g, PROFILE_HINTS[profile]);
@@ -70323,7 +70666,7 @@ function buildMaintainAdaptationPrompt(_repoPath, bundleReport) {
 }
 function writeAdaptationPrompt(repoPath, content) {
   const harnessDir = getHarnessDir(repoPath);
-  const filePath = path44.join(harnessDir, ADAPTATION_PROMPT_FILE);
+  const filePath = path45.join(harnessDir, ADAPTATION_PROMPT_FILE);
   writeFileSafe(filePath, content);
   return filePath;
 }
@@ -70378,27 +70721,27 @@ async function offerAdaptationPromptClipboard(content, options = {}) {
 }
 
 // src/harness/cursor-rule.ts
-var fs40 = __toESM(require("fs"));
-var path45 = __toESM(require("path"));
+var fs41 = __toESM(require("fs"));
+var path46 = __toESM(require("path"));
 var readline6 = __toESM(require("readline"));
 init_file_ops();
 init_logging();
 var CURSOR_RULE_RELATIVE_PATH = ".cursor/rules/har-workflow.mdc";
 function getCursorRulePath(repoPath) {
-  return path45.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
+  return path46.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
 }
 function isCursorWorkspace(repoPath) {
-  return fs40.existsSync(path45.join(repoPath, ".cursor"));
+  return fs41.existsSync(path46.join(repoPath, ".cursor"));
 }
 function cursorRuleExists(repoPath) {
-  return fs40.existsSync(getCursorRulePath(repoPath));
+  return fs41.existsSync(getCursorRulePath(repoPath));
 }
 function scaffoldCursorRule(repoPath) {
   const templatePath = resolveTemplateFile("cursor-rule.mdc.template");
   if (!templatePath) {
     throw new Error("Cursor rule template not found (cursor-rule.mdc.template). Run npm run build.");
   }
-  const content = fs40.readFileSync(templatePath, "utf8");
+  const content = fs41.readFileSync(templatePath, "utf8");
   writeFileSafe(getCursorRulePath(repoPath), content);
 }
 async function handleCursorRule(options) {
@@ -70487,8 +70830,8 @@ init_validation();
 init_control_config();
 
 // src/core/control-lifecycle.ts
-var import_child_process10 = require("child_process");
-var path46 = __toESM(require("path"));
+var import_child_process11 = require("child_process");
+var path47 = __toESM(require("path"));
 
 // src/core/control-image.ts
 var DEFAULT_CONTROL_IMAGE = "theosfactory/har-control";
@@ -70514,10 +70857,10 @@ var CONTROL_DATA_VOLUME = "har_control_data";
 var CONTROL_CONTAINER_PORT = 3847;
 var CONTROL_DATA_DB_URL = "file:/data/har_control.db";
 function resolveControlDir() {
-  return path46.resolve(__dirname, "..", "control");
+  return path47.resolve(__dirname, "..", "control");
 }
 function resolveControlBuildContext() {
-  return path46.resolve(resolveControlDir(), "..");
+  return path47.resolve(resolveControlDir(), "..");
 }
 function buildDockerRunArgs(options) {
   const name = options.containerName ?? CONTROL_CONTAINER_NAME;
@@ -70540,7 +70883,7 @@ function buildDockerRunArgs(options) {
   return args;
 }
 function runDocker(args) {
-  const result = (0, import_child_process10.spawnSync)("docker", args, {
+  const result = (0, import_child_process11.spawnSync)("docker", args, {
     stdio: "inherit",
     env: process.env
   });
@@ -70550,7 +70893,7 @@ function runDocker(args) {
   return result.status ?? 1;
 }
 function controlContainerExists(name = CONTROL_CONTAINER_NAME) {
-  const result = (0, import_child_process10.spawnSync)("docker", ["ps", "-aq", "-f", `name=^${name}$`], {
+  const result = (0, import_child_process11.spawnSync)("docker", ["ps", "-aq", "-f", `name=^${name}$`], {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "ignore"]
   });
@@ -70573,7 +70916,7 @@ async function startMissionControl(options) {
       "-t",
       imageRef,
       "-f",
-      path46.join(resolveControlDir(), "Dockerfile"),
+      path47.join(resolveControlDir(), "Dockerfile"),
       resolveControlBuildContext()
     ]);
     if (buildCode !== 0) {
@@ -70720,7 +71063,7 @@ async function ensureTelemetryInfrastructure(options) {
 // src/core/run-service.ts
 init_telemetry_config();
 init_telemetry_env();
-var path48 = __toESM(require("path"));
+var path49 = __toESM(require("path"));
 init_local_executor();
 function extractShellOutput(result) {
   const stdout = result.logs?.find((log) => log.stream === "stdout")?.content ?? result.logs?.find((log) => !log.stream)?.content ?? "";
@@ -70819,7 +71162,8 @@ var RunService = class {
   }
   async launchEnvironment(options) {
     const guard = checkLaunchGuard2(options.repoPath, options.agentId, {
-      resume: options.resume
+      resume: options.resume,
+      worktree: options.worktree
     });
     if (!guard.allowed) {
       const slot = guard.slot;
@@ -70838,27 +71182,28 @@ var RunService = class {
         } : void 0
       };
     }
-    let telemetryBanner = "";
+    let launchBanner = (guard.readiness?.warnings ?? []).map((warning) => `WARN: ${warning}
+`).join("");
     if (isTelemetryEnabled() && process.env.NODE_ENV !== "test") {
       const ensured = await ensureTelemetryInfrastructure({ startIfNeeded: true });
       if (ensured.message) {
-        telemetryBanner += `${ensured.message}
+        launchBanner += `${ensured.message}
 Usage from Cursor / Claude / Codex (@osfactory/otel-hook) will appear under Worktrees. Disable: har telemetry off
 `;
       }
       if (ensured.warning) {
-        telemetryBanner += `${ensured.warning}
+        launchBanner += `${ensured.warning}
 `;
       }
       try {
         const { ensureOtelHooks: ensureOtelHooks2 } = await Promise.resolve().then(() => (init_otel_hooks(), otel_hooks_exports));
         const hooks = ensureOtelHooks2({ setupAgents: true });
-        if (hooks.message) telemetryBanner += `${hooks.message}
+        if (hooks.message) launchBanner += `${hooks.message}
 `;
-        if (hooks.warning) telemetryBanner += `${hooks.warning}
+        if (hooks.warning) launchBanner += `${hooks.warning}
 `;
       } catch (err) {
-        telemetryBanner += `@osfactory/otel-hook setup skipped: ${err instanceof Error ? err.message : String(err)}
+        launchBanner += `@osfactory/otel-hook setup skipped: ${err instanceof Error ? err.message : String(err)}
 `;
       }
     }
@@ -70923,12 +71268,12 @@ Usage from Cursor / Claude / Codex (@osfactory/otel-hook) will appear under Work
           suffix: session.suffix,
           createdAt: session.createdAt
         });
-        const envFile = path48.join(session.workDir, `.env.agent.${options.agentId}`);
+        const envFile = path49.join(session.workDir, `.env.agent.${options.agentId}`);
         try {
           appendTelemetryEnvToFile(envFile, {
             sessionKey,
             agentId: options.agentId,
-            repoPath: path48.resolve(options.repoPath),
+            repoPath: path49.resolve(options.repoPath),
             workDir: session.workDir,
             branch: session.branch,
             suffix: session.suffix,
@@ -70951,8 +71296,8 @@ Usage from Cursor / Claude / Codex (@osfactory/otel-hook) will appear under Work
           });
         }
       }
-      if (telemetryBanner) {
-        envResult.stderr = `${telemetryBanner}${envResult.stderr ?? ""}`;
+      if (launchBanner) {
+        envResult.stderr = `${launchBanner}${envResult.stderr ?? ""}`;
       }
     }
     return envResult;
@@ -71164,279 +71509,7 @@ init_slot_status();
 
 // src/core/commit-gate-onboarding.ts
 var readline7 = __toESM(require("readline"));
-
-// src/core/hooks.ts
-var fs42 = __toESM(require("fs"));
-var os16 = __toESM(require("os"));
-var path49 = __toESM(require("path"));
-init_shell();
-init_schema2();
-init_stages();
-init_change_batch();
-init_validations();
-init_sync_context();
-var MARKER_START = "# >>> har commit gate (managed by `har hooks`) >>>";
-var MARKER_END = "# <<< har commit gate <<<";
-var PRE_COMMIT_BLOCK = [
-  MARKER_START,
-  'if [ "$HAR_SKIP_GATE" != "1" ]; then',
-  '  "$(git rev-parse --git-path hooks)/har-pre-commit" || exit 1',
-  "fi",
-  MARKER_END
-].join("\n");
-var POST_COMMIT_BLOCK = [
-  MARKER_START,
-  '"$(git rev-parse --git-path hooks)/har-post-commit" || true',
-  MARKER_END
-].join("\n");
-function tryGit3(cwd, args) {
-  const result = run(`git ${args}`, { cwd });
-  return result.code === 0 ? result.stdout.trim() : void 0;
-}
-function resolveCheckoutRoot(cwd) {
-  return tryGit3(cwd, "rev-parse --show-toplevel");
-}
-function resolveHooksDir(checkoutDir) {
-  const hooksPath = tryGit3(checkoutDir, "rev-parse --git-path hooks");
-  if (!hooksPath) throw new Error(`Not a git checkout: ${checkoutDir}`);
-  return path49.resolve(checkoutDir, hooksPath);
-}
-function getConfiguredHooksPath(checkoutDir) {
-  return tryGit3(checkoutDir, "config core.hooksPath") || void 0;
-}
-function defaultHarInvocation() {
-  const entry = process.argv[1];
-  if (entry && entry.endsWith(".js")) {
-    return `"${process.execPath}" "${path49.resolve(entry)}"`;
-  }
-  if (entry) return `"${path49.resolve(entry)}"`;
-  return "har";
-}
-function buildHookScript(harInvocation, subcommand, failOpenNotice) {
-  return `#!/bin/sh
-# Managed by \`har hooks\` \u2014 do not edit; reinstall with \`har hooks install\`.
-if ${harInvocation} --version >/dev/null 2>&1; then
-  exec ${harInvocation} hooks ${subcommand}
-fi
-if command -v har >/dev/null 2>&1; then
-  exec har hooks ${subcommand}
-fi
-toplevel="$(git rev-parse --show-toplevel 2>/dev/null)"
-if [ -n "$toplevel" ] && [ -x "$toplevel/node_modules/.bin/har" ]; then
-  exec "$toplevel/node_modules/.bin/har" hooks ${subcommand}
-fi
-echo "${failOpenNotice}" >&2
-exit 0
-`;
-}
-function upsertMarkedBlock2(filePath, block) {
-  if (!fs42.existsSync(filePath)) {
-    fs42.writeFileSync(filePath, `#!/bin/sh
-${block}
-`, { mode: 493 });
-    return "created";
-  }
-  const content = fs42.readFileSync(filePath, "utf8");
-  if (content.includes(MARKER_START)) {
-    const pattern = new RegExp(
-      `${escapeRegExp2(MARKER_START)}[\\s\\S]*?${escapeRegExp2(MARKER_END)}`
-    );
-    fs42.writeFileSync(filePath, content.replace(pattern, block));
-    fs42.chmodSync(filePath, 493);
-    return "updated";
-  }
-  const suffix = content.endsWith("\n") ? "" : "\n";
-  fs42.writeFileSync(filePath, `${content}${suffix}
-${block}
-`);
-  fs42.chmodSync(filePath, 493);
-  return "appended";
-}
-function removeMarkedBlock(filePath) {
-  if (!fs42.existsSync(filePath)) return false;
-  const content = fs42.readFileSync(filePath, "utf8");
-  if (!content.includes(MARKER_START)) return false;
-  const pattern = new RegExp(
-    `\\n?${escapeRegExp2(MARKER_START)}[\\s\\S]*?${escapeRegExp2(MARKER_END)}\\n?`
-  );
-  const stripped = content.replace(pattern, "\n");
-  if (stripped.replace(/^#!\/bin\/sh\n?/, "").trim() === "") {
-    fs42.rmSync(filePath);
-  } else {
-    fs42.writeFileSync(filePath, stripped);
-  }
-  return true;
-}
-function escapeRegExp2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function installHooks(options) {
-  const checkout = resolveCheckoutRoot(options.repoPath);
-  if (!checkout) throw new Error(`Not a git repository: ${options.repoPath}`);
-  const configuredHooksPath = getConfiguredHooksPath(checkout);
-  if (configuredHooksPath && !options.force) {
-    throw new Error(
-      `core.hooksPath is set to "${configuredHooksPath}" (managed hooks, e.g. husky).
-Add this to your managed pre-commit hook instead:
-
-  ${PRE_COMMIT_BLOCK.split("\n").join("\n  ")}
-
-Or re-run with --force to write into that directory anyway.`
-    );
-  }
-  const hooksDir = resolveHooksDir(checkout);
-  fs42.mkdirSync(hooksDir, { recursive: true });
-  const invocation = options.harInvocation ?? defaultHarInvocation();
-  fs42.writeFileSync(
-    path49.join(hooksDir, "har-pre-commit"),
-    buildHookScript(invocation, "check", "har: binary not found; skipping commit gate (reinstall with har hooks install)"),
-    { mode: 493 }
-  );
-  fs42.writeFileSync(
-    path49.join(hooksDir, "har-post-commit"),
-    buildHookScript(invocation, "record-commit", "har: binary not found; skipping commit association"),
-    { mode: 493 }
-  );
-  const preCommit = upsertMarkedBlock2(path49.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
-  const postCommit = upsertMarkedBlock2(path49.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
-  ensureValidationsIgnored(checkout);
-  return { hooksDir, preCommit, postCommit };
-}
-function uninstallHooks(repoPath) {
-  const checkout = resolveCheckoutRoot(repoPath);
-  if (!checkout) throw new Error(`Not a git repository: ${repoPath}`);
-  const hooksDir = resolveHooksDir(checkout);
-  let removed = false;
-  removed = removeMarkedBlock(path49.join(hooksDir, "pre-commit")) || removed;
-  removed = removeMarkedBlock(path49.join(hooksDir, "post-commit")) || removed;
-  for (const file of ["har-pre-commit", "har-post-commit"]) {
-    const full = path49.join(hooksDir, file);
-    if (fs42.existsSync(full)) {
-      fs42.rmSync(full);
-      removed = true;
-    }
-  }
-  return { hooksDir, removed };
-}
-function getCommitGateConfig(checkoutDir) {
-  try {
-    const registry2 = readStageRegistry(checkoutDir);
-    return CommitGateConfigSchema.parse(registry2.commitGate ?? {});
-  } catch {
-    return CommitGateConfigSchema.parse({});
-  }
-}
-function isAgentWorktree(checkoutDir) {
-  const branch = getCurrentBranch(checkoutDir);
-  if (branch && (/^har-agent-\d+$/.test(branch) || /-har-agent-\d+-[a-z0-9]+$/.test(branch))) {
-    return true;
-  }
-  const worktreesRoot = path49.join(os16.homedir(), "worktrees");
-  const resolved = path49.resolve(checkoutDir);
-  const name = path49.basename(resolved);
-  return resolved.startsWith(`${worktreesRoot}${path49.sep}`) && (/-agent-\d+$/.test(name) || /-har-agent-\d+-[a-z0-9]+$/.test(name));
-}
-function resolveEffectiveMode(checkoutDir, gate) {
-  if (!gate.enabled) return "off";
-  if (gate.scope === "all") return gate.mode;
-  return isAgentWorktree(checkoutDir) ? gate.mode : "warn";
-}
-function getHooksStatus(repoPath) {
-  const checkout = resolveCheckoutRoot(repoPath);
-  if (!checkout) throw new Error(`Not a git repository: ${repoPath}`);
-  const hooksDir = resolveHooksDir(checkout);
-  const gate = getCommitGateConfig(checkout);
-  const hasBlock = (name) => {
-    const file = path49.join(hooksDir, name);
-    return fs42.existsSync(file) && fs42.readFileSync(file, "utf8").includes(MARKER_START);
-  };
-  return {
-    checkout,
-    hooksDir,
-    configuredHooksPath: getConfiguredHooksPath(checkout),
-    preCommitInstalled: hasBlock("pre-commit") && fs42.existsSync(path49.join(hooksDir, "har-pre-commit")),
-    postCommitInstalled: hasBlock("post-commit") && fs42.existsSync(path49.join(hooksDir, "har-post-commit")),
-    gate,
-    effectiveMode: resolveEffectiveMode(checkout, gate)
-  };
-}
-function checkCommitGate(cwd) {
-  if (process.env.HAR_SKIP_GATE === "1") {
-    return { exitCode: 0, messages: ["har: commit gate skipped (HAR_SKIP_GATE=1)"] };
-  }
-  const checkout = resolveCheckoutRoot(cwd);
-  if (!checkout) return { exitCode: 0, messages: [] };
-  if (!fs42.existsSync(path49.join(checkout, ".har", "stages.json"))) {
-    return { exitCode: 0, messages: [] };
-  }
-  const gate = getCommitGateConfig(checkout);
-  const mode = resolveEffectiveMode(checkout, gate);
-  if (mode === "off") return { exitCode: 0, messages: [] };
-  if (!getHeadSha(checkout)) {
-    return { exitCode: 0, messages: ["har: commit gate skipped (initial commit)"] };
-  }
-  if (isMergeOrRebaseInProgress(checkout)) {
-    return { exitCode: 0, messages: ["har: commit gate skipped (merge/rebase in progress)"] };
-  }
-  let stagedTree;
-  try {
-    stagedTree = computeStagedTree(checkout);
-  } catch {
-    return { exitCode: 0, messages: ["har: commit gate skipped (index has unmerged entries)"] };
-  }
-  if (stagedTree === getHeadTree(checkout)) {
-    return { exitCode: 0, messages: [] };
-  }
-  const record2 = findValidation(checkout, stagedTree);
-  if (record2 && record2.status === "pass" && record2.full) {
-    return {
-      exitCode: 0,
-      messages: [
-        `har: batch ${stagedTree.slice(0, 8)} verified${record2.runId ? ` by run ${record2.runId.slice(0, 8)}` : ""} \u2713`
-      ]
-    };
-  }
-  const messages = [];
-  const verb = mode === "block" ? "commit blocked" : "warning";
-  messages.push(
-    `har: ${verb} \u2014 no passing verification for this exact change batch (tree ${stagedTree.slice(0, 8)}).`
-  );
-  if (record2 && record2.status === "fail") {
-    messages.push(
-      `  This exact batch was verified and FAILED${record2.runId ? ` (run ${record2.runId.slice(0, 8)})` : ""}. Fix and re-run.`
-    );
-  } else if (record2 && !record2.full) {
-    messages.push(
-      `  This batch only passed a partial verify${record2.runId ? ` (run ${record2.runId.slice(0, 8)})` : ""}; the gate requires --full.`
-    );
-  }
-  messages.push("  Run the full pipeline:   har env verify <agentId> --full");
-  messages.push(
-    "  Note: verify hashes the WORKING TREE \u2014 stage exactly what you verified (git add -A)."
-  );
-  messages.push("  Bypass (humans only):    HAR_SKIP_GATE=1 git commit \u2026   or   git commit --no-verify");
-  messages.push("  Configure via commitGate { mode: block|warn, scope: worktrees|all } in .har/stages.json");
-  return { exitCode: mode === "block" ? 1 : 0, messages };
-}
-async function recordCommitAssociation(cwd) {
-  try {
-    const checkout = resolveCheckoutRoot(cwd);
-    if (!checkout) return { attached: false };
-    const commitSha = getHeadSha(checkout);
-    const tree = tryGit3(checkout, "rev-parse HEAD^{tree}");
-    if (!commitSha || !tree) return { attached: false };
-    const updated = attachCommit(checkout, tree, commitSha);
-    if (updated) {
-      markDirty(updated.harnessRoot);
-      return { attached: true, commitSha };
-    }
-    return { attached: false, commitSha };
-  } catch {
-    return { attached: false };
-  }
-}
-
-// src/core/commit-gate-onboarding.ts
+init_hooks();
 init_stages();
 init_logging();
 function askYesNo4(question) {
@@ -71564,7 +71637,7 @@ Occupied slots always block a new launch:
 For a new unrelated task: checkout main (or your intended base) on the main
 repo checkout, free the slot (complete/teardown), then launch.`;
 var HAR_ENV_EPILOG = `Environment lifecycle:
-  preflight <id>   dry-run: ports, PM2, Docker, occupied-slot gates
+  preflight <id>   dry-run: ports, PM2, Docker, occupied-slot gates, untracked paths
   launch <id>      fresh session worktree from the main checkout's current HEAD
   recover <id>     alias for launch --resume (failed/starting only)
   verify <id>      run checks (--full before declaring done)
@@ -71760,7 +71833,7 @@ var envCommand = {
     handleRecover
   ).command(
     "preflight <id>",
-    "Check whether a slot can launch now (ports, PM2, Docker, occupied slot)",
+    "Check whether a slot can launch now (ports, PM2, Docker, occupied slot, untracked worktree paths)",
     (y) => y.positional("id", { type: "number", describe: "Agent slot id (see .har/stages.json agentSlots)" }).option("repo", { type: "string", default: "." }).option("json", { type: "boolean", default: false, describe: "Structured JSON output" }),
     handlePreflight
   ).command(
@@ -72119,11 +72192,14 @@ async function handleLaunch(argv) {
   const repo = path51.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   if (!argv.resume) {
-    const guard = checkLaunchGuard2(repo, agentId, {});
+    const guard = checkLaunchGuard2(repo, agentId, { worktree: argv.worktree });
     if (!guard.allowed && guard.blocked) {
       error(guard.reason ?? `Slot ${agentId} is occupied.`);
       return finishCommand(2);
     }
+    for (const warning of guard.readiness?.warnings ?? []) {
+      warn(warning);
+    }
   }
   const result = await launchEnvironment({
     repoPath: repo,
@@ -72390,13 +72466,13 @@ init_portal_credentials();
 // src/core/portal-login.ts
 var http = __toESM(require("http"));
 var import_crypto = require("crypto");
-var import_child_process12 = require("child_process");
+var import_child_process13 = require("child_process");
 var CALLBACK_PATH = "/callback";
 var LOGIN_TIMEOUT_MS = 3 * 6e4;
 function openBrowser(url) {
   const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try {
-    const child = (0, import_child_process12.spawn)(cmd, args, { stdio: "ignore", detached: true });
+    const child = (0, import_child_process13.spawn)(cmd, args, { stdio: "ignore", detached: true });
     child.on("error", () => {
     });
     child.unref();
@@ -73256,6 +73332,7 @@ async function handleLogin(argv) {
 
 // src/cli/commands/hooks.ts
 var path57 = __toESM(require("path"));
+init_hooks();
 
 // src/core/claude-hooks.ts
 var fs47 = __toESM(require("fs"));
@@ -80825,7 +80902,7 @@ var HAR_MCP_TOOLS = [
   },
   {
     name: "har_preflight_environment",
-    description: "Readiness gate before launch: checks ports, foreign PM2, Docker conflicts, and occupied slot. Returns canLaunch with actionable blockers. Call before har_launch_environment.",
+    description: "Readiness gate before launch: checks ports, foreign PM2, Docker conflicts, occupied slot, and untracked paths that will be missing from a session worktree. Returns canLaunch with actionable blockers and warnings. Call before har_launch_environment.",
     inputSchema: objectJsonSchema(
       {
         repo: repoJsonProperty,