@osfactory/har 1.14.0 → 1.14.2

package/dist/index.js

@@ -35872,6 +35872,20 @@ function resolveMainWorkingTree(cwd) {
   }
   return path7.resolve(toplevel);
 }
+function listLinkedWorktrees(cwd) {
+  const porcelain = tryGit(cwd, "worktree list --porcelain");
+  if (!porcelain) return [];
+  const main = resolveMainWorkingTree(cwd);
+  const mainResolved = main ? path7.resolve(main) : void 0;
+  const paths = [];
+  for (const line of porcelain.split("\n")) {
+    if (!line.startsWith("worktree ")) continue;
+    const worktree = path7.resolve(line.slice("worktree ".length));
+    if (mainResolved && worktree === mainResolved) continue;
+    paths.push(worktree);
+  }
+  return paths;
+}
 function canonicalizeControlRepoPath(repoPath) {
   const resolved = path7.resolve(repoPath);
   const toplevel = tryGit(resolved, "rev-parse --show-toplevel");
@@ -37467,13 +37481,55 @@ var init_work_units = __esm({
 // src/core/sync-sources.ts
 function resolveSyncSourcePaths(canonicalPath, workspacePath) {
   const canonical = path18.resolve(canonicalPath);
-  if (!workspacePath) return [canonical];
-  const workspace = path18.resolve(workspacePath);
-  if (workspace === canonical) return [canonical];
-  const canonicalRoot = resolveHarnessRoot(canonical);
-  const workspaceRoot = resolveHarnessRoot(workspace);
-  if (path18.resolve(canonicalRoot) === path18.resolve(workspaceRoot)) return [canonical];
-  return [canonical, workspace];
+  const paths = [canonical];
+  const seenRoots = /* @__PURE__ */ new Set([path18.resolve(resolveHarnessRoot(canonical))]);
+  const add = (candidate) => {
+    const resolved = path18.resolve(candidate);
+    const root = path18.resolve(resolveHarnessRoot(resolved));
+    if (seenRoots.has(root)) return;
+    seenRoots.add(root);
+    paths.push(resolved);
+  };
+  if (workspacePath) add(workspacePath);
+  for (const worktree of listLinkedWorktrees(canonical)) {
+    if (hasHarnessEvidence(worktree)) add(worktree);
+  }
+  return paths;
+}
+function hasHarnessEvidence(repoPath) {
+  const root = resolveHarnessRoot(repoPath);
+  const harDir = path18.join(root, DEFAULT_HAR_DIR);
+  if (!fs18.existsSync(harDir)) return false;
+  for (const sub of EVIDENCE_SUBDIRS) {
+    const dir = path18.join(harDir, sub);
+    if (!fs18.existsSync(dir)) continue;
+    try {
+      if (fs18.readdirSync(dir).length > 0) return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function mergeSlotStatuses(groups) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const slot of group) {
+      const existing = byId.get(slot.agentId);
+      byId.set(slot.agentId, existing ? preferSlotStatus(existing, slot) : slot);
+    }
+  }
+  return [...byId.values()].sort((a, b2) => a.agentId - b2.agentId);
+}
+function preferSlotStatus(a, b2) {
+  if (a.active !== b2.active) return a.active ? a : b2;
+  const aCreated = a.sessionCreatedAt ?? "";
+  const bCreated = b2.sessionCreatedAt ?? "";
+  if (aCreated !== bCreated) return aCreated >= bCreated ? a : b2;
+  const aRun = a.lastRunAt ?? "";
+  const bRun = b2.lastRunAt ?? "";
+  if (aRun !== bRun) return aRun >= bRun ? a : b2;
+  return a;
 }
 function mergeById(groups, id) {
   const seen = /* @__PURE__ */ new Map();
@@ -37537,16 +37593,19 @@ function collectCommitBindingsForSync(sourcePaths) {
     (record2) => record2.bindingId
   );
 }
-var path18;
+var fs18, path18, EVIDENCE_SUBDIRS;
 var init_sync_sources = __esm({
   "src/core/sync-sources.ts"() {
     "use strict";
+    fs18 = __toESM(require("fs"));
     path18 = __toESM(require("path"));
     init_manifest();
     init_commit_bindings();
+    init_control_repo_path();
     init_runs();
     init_validations();
     init_work_units();
+    EVIDENCE_SUBDIRS = ["slots", "runs", "work-units", "validations"];
   }
 });
 
@@ -37689,18 +37748,18 @@ function spawnResult(cmd, args, opts, shell) {
     proc.on("close", (code) => resolve70({ code: code ?? 1, stdout, stderr }));
   });
 }
-var import_child_process4, fs18, path19, realSystemOps, defaultExec, stderrLog, realSleep;
+var import_child_process4, fs19, path19, realSystemOps, defaultExec, stderrLog, realSleep;
 var init_exec = __esm({
   "src/runtime/exec.ts"() {
     "use strict";
     import_child_process4 = require("child_process");
-    fs18 = __toESM(require("fs"));
+    fs19 = __toESM(require("fs"));
     path19 = __toESM(require("path"));
     realSystemOps = {
       which(cmd) {
         if (cmd.includes("/")) {
           try {
-            fs18.accessSync(cmd, fs18.constants.X_OK);
+            fs19.accessSync(cmd, fs19.constants.X_OK);
             return cmd;
           } catch {
             return null;
@@ -37710,8 +37769,8 @@ var init_exec = __esm({
           if (!dir) continue;
           const candidate = path19.join(dir, cmd);
           try {
-            fs18.accessSync(candidate, fs18.constants.X_OK);
-            if (fs18.statSync(candidate).isFile()) return candidate;
+            fs19.accessSync(candidate, fs19.constants.X_OK);
+            if (fs19.statSync(candidate).isFile()) return candidate;
           } catch {
           }
         }
@@ -37758,15 +37817,15 @@ function declaredNodePackageManager(dir, env3 = {}, _ops = realSystemOps) {
   const explicit = env3.HARNESS_NODE_PACKAGE_MANAGER;
   if (explicit) return explicit;
   const pkgPath = path20.join(dir, "package.json");
-  if (fs19.existsSync(pkgPath)) {
-    const raw = fs19.readFileSync(pkgPath, "utf8");
+  if (fs20.existsSync(pkgPath)) {
+    const raw = fs20.readFileSync(pkgPath, "utf8");
     const match = raw.match(/"packageManager"\s*:\s*"([a-z]*)@/);
     if (match && match[1]) return match[1];
   }
-  if (fs19.existsSync(path20.join(dir, "bun.lock")) || fs19.existsSync(path20.join(dir, "bun.lockb"))) return "bun";
-  if (fs19.existsSync(path20.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs19.existsSync(path20.join(dir, "yarn.lock"))) return "yarn";
-  if (fs19.existsSync(path20.join(dir, "package-lock.json"))) return "npm";
+  if (fs20.existsSync(path20.join(dir, "bun.lock")) || fs20.existsSync(path20.join(dir, "bun.lockb"))) return "bun";
+  if (fs20.existsSync(path20.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs20.existsSync(path20.join(dir, "yarn.lock"))) return "yarn";
+  if (fs20.existsSync(path20.join(dir, "package-lock.json"))) return "npm";
   return "";
 }
 function nodePackageManager(dir, env3 = {}, ops = realSystemOps) {
@@ -37794,11 +37853,11 @@ function nodeLockfile(manager) {
 async function nodeInstall(dir, manager, declared = "", ops = realSystemOps) {
   const substituting = declared !== "" && declared !== manager;
   const lockfile = substituting ? nodeLockfile(manager) : "";
-  const hadLockfile = lockfile !== "" && fs19.existsSync(path20.join(dir, lockfile));
+  const hadLockfile = lockfile !== "" && fs20.existsSync(path20.join(dir, lockfile));
   const result = await ops.run(manager, ["install", "--silent"], { cwd: dir, stream: true });
   if (substituting && !hadLockfile && lockfile !== "") {
-    fs19.rmSync(path20.join(dir, lockfile), { force: true });
-    if (manager === "bun") fs19.rmSync(path20.join(dir, "bun.lockb"), { force: true });
+    fs20.rmSync(path20.join(dir, lockfile), { force: true });
+    if (manager === "bun") fs20.rmSync(path20.join(dir, "bun.lockb"), { force: true });
   }
   return result.code;
 }
@@ -37818,11 +37877,11 @@ function pkgExec(manager, env3 = {}, ops = realSystemOps) {
   if (ops.which("pnpm")) return "pnpm dlx";
   return "npx --yes";
 }
-var fs19, path20, NODE_PACKAGE_MANAGERS;
+var fs20, path20, NODE_PACKAGE_MANAGERS;
 var init_node_pm = __esm({
   "src/runtime/node-pm.ts"() {
     "use strict";
-    fs19 = __toESM(require("fs"));
+    fs20 = __toESM(require("fs"));
     path20 = __toESM(require("path"));
     init_exec();
     NODE_PACKAGE_MANAGERS = ["npm", "bun", "pnpm", "yarn"];
@@ -37836,15 +37895,15 @@ function quoteEnvValue(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function toolchainReady(workDir) {
-  if (fs20.existsSync(path21.join(workDir, "package.json")) && fs20.existsSync(path21.join(workDir, "node_modules"))) {
+  if (fs21.existsSync(path21.join(workDir, "package.json")) && fs21.existsSync(path21.join(workDir, "node_modules"))) {
     return true;
   }
-  return fs20.existsSync(path21.join(workDir, ".har", "venv"));
+  return fs21.existsSync(path21.join(workDir, ".har", "venv"));
 }
 function detectEcosystem(dir, env3 = {}) {
   const configured = env3.HARNESS_ECOSYSTEM ?? "auto";
   if (configured && configured !== "auto") return configured;
-  const has = (name) => fs20.existsSync(path21.join(dir, name));
+  const has = (name) => fs21.existsSync(path21.join(dir, name));
   if (has("package.json")) return "node";
   if (has("pyproject.toml") || has("setup.py") || has("setup.cfg") || has("requirements.txt") || has("Pipfile")) {
     return "python";
@@ -37877,22 +37936,22 @@ function pythonRequiresMinimum(spec) {
 }
 function pythonReadDotVersion(dir) {
   const file = path21.join(dir, ".python-version");
-  if (!fs20.existsSync(file)) return null;
-  const first = fs20.readFileSync(file, "utf8").split("\n")[0].replace(/\s/g, "");
+  if (!fs21.existsSync(file)) return null;
+  const first = fs21.readFileSync(file, "utf8").split("\n")[0].replace(/\s/g, "");
   return first || null;
 }
 function pythonReadRequiresSpec(dir) {
   const pyproject = path21.join(dir, "pyproject.toml");
-  if (fs20.existsSync(pyproject)) {
-    for (const line of fs20.readFileSync(pyproject, "utf8").split("\n")) {
+  if (fs21.existsSync(pyproject)) {
+    for (const line of fs21.readFileSync(pyproject, "utf8").split("\n")) {
       const m = line.match(/^\s*requires-python\s*=\s*"([^"]*)"/);
       if (m) return m[1];
     }
   }
   const setupCfg = path21.join(dir, "setup.cfg");
-  if (fs20.existsSync(setupCfg)) {
+  if (fs21.existsSync(setupCfg)) {
     let inOptions = false;
-    for (const line of fs20.readFileSync(setupCfg, "utf8").split("\n")) {
+    for (const line of fs21.readFileSync(setupCfg, "utf8").split("\n")) {
       if (/^\[options\]/.test(line)) {
         inOptions = true;
         continue;
@@ -37916,10 +37975,10 @@ function pythonProjectMinimum(dir) {
   return reqMin ?? dotVer;
 }
 function pythonIsUvProject(dir) {
-  if (fs20.existsSync(path21.join(dir, "uv.lock"))) return true;
+  if (fs21.existsSync(path21.join(dir, "uv.lock"))) return true;
   const pyproject = path21.join(dir, "pyproject.toml");
-  if (!fs20.existsSync(pyproject)) return false;
-  return /^\[tool\.uv\]/m.test(fs20.readFileSync(pyproject, "utf8"));
+  if (!fs21.existsSync(pyproject)) return false;
+  return /^\[tool\.uv\]/m.test(fs21.readFileSync(pyproject, "utf8"));
 }
 function iosFindProjectFile(dir, suffix) {
   const matches = [];
@@ -37927,7 +37986,7 @@ function iosFindProjectFile(dir, suffix) {
     const abs = rel ? path21.join(dir, rel) : dir;
     let entries;
     try {
-      entries = fs20.readdirSync(abs, { withFileTypes: true });
+      entries = fs21.readdirSync(abs, { withFileTypes: true });
     } catch {
       return;
     }
@@ -37950,15 +38009,15 @@ function iosHasProject(dir, env3) {
   const workspace = env3.HARNESS_XCODE_WORKSPACE;
   const project = env3.HARNESS_XCODE_PROJECT;
   if (workspace || project) {
-    if (workspace && fs20.existsSync(path21.join(dir, workspace))) return true;
-    if (project && fs20.existsSync(path21.join(dir, project))) return true;
+    if (workspace && fs21.existsSync(path21.join(dir, workspace))) return true;
+    if (project && fs21.existsSync(path21.join(dir, project))) return true;
     return false;
   }
   if (iosFindProjectFile(dir, ".xcworkspace")) return true;
   return iosFindProjectFile(dir, ".xcodeproj") !== null;
 }
 function iosProjectGenerator(dir) {
-  const has = (name) => fs20.existsSync(path21.join(dir, name));
+  const has = (name) => fs21.existsSync(path21.join(dir, name));
   if (has("Project.swift") || has("Workspace.swift")) return "tuist";
   if (has("project.yml") || has("project.yaml")) return "xcodegen";
   if (has("Podfile")) return "pod";
@@ -37967,11 +38026,11 @@ function iosProjectGenerator(dir) {
 async function provisionToolchain(options) {
   return new Provisioner(options).provision();
 }
-var fs20, path21, ProvisionError, Provisioner;
+var fs21, path21, ProvisionError, Provisioner;
 var init_provision = __esm({
   "src/runtime/provision.ts"() {
     "use strict";
-    fs20 = __toESM(require("fs"));
+    fs21 = __toESM(require("fs"));
     path21 = __toESM(require("path"));
     init_exec();
     init_node_pm();
@@ -38003,11 +38062,11 @@ var init_provision = __esm({
         this.logFn(message);
       }
       appendEnv(key, value) {
-        fs20.appendFileSync(this.envFile, `${key}=${quoteEnvValue(value)}
+        fs21.appendFileSync(this.envFile, `${key}=${quoteEnvValue(value)}
 `);
       }
       appendPathPrefix(prefix) {
-        if (!prefix || !fs20.existsSync(prefix)) return;
+        if (!prefix || !fs21.existsSync(prefix)) return;
         this.appendEnv("PATH", `${prefix}:${process.env.PATH ?? ""}`);
       }
       /** Extra process env for subprocesses (venv activation is PATH + VIRTUAL_ENV). */
@@ -38075,7 +38134,7 @@ var init_provision = __esm({
           const found = await this.pythonUvFind(dir, minimum);
           if (executable(found)) return found;
         }
-        if (fs20.existsSync(path21.join(dir, ".python-version"))) {
+        if (fs21.existsSync(path21.join(dir, ".python-version"))) {
           const found = await this.pythonUvFind(dir, pythonReadDotVersion(dir));
           if (executable(found)) return found;
           if (this.ops.which("pyenv")) {
@@ -38142,23 +38201,23 @@ var init_provision = __esm({
         }
         await this.pythonWarnIfBelowMinimum(interpreter, projectMin);
         const venvPython = path21.join(venvDir, "bin", "python");
-        if (fs20.existsSync(venvDir) && fs20.existsSync(venvPython) && projectMin) {
+        if (fs21.existsSync(venvDir) && fs21.existsSync(venvPython) && projectMin) {
           const venvVer = await this.pythonVersionFromBin(venvPython);
           if (venvVer && !pythonVersionGe(venvVer, projectMin)) {
             this.log(`Existing venv Python ${venvVer} is older than required ${projectMin} \u2014 recreating...`);
-            fs20.rmSync(venvDir, { recursive: true, force: true });
+            fs21.rmSync(venvDir, { recursive: true, force: true });
           }
         }
-        if (!fs20.existsSync(venvDir)) {
+        if (!fs21.existsSync(venvDir)) {
           if (!await this.pythonCreateVenv(dir, venvDir, interpreter)) {
-            fs20.rmSync(venvDir, { recursive: true, force: true });
+            fs21.rmSync(venvDir, { recursive: true, force: true });
             this.log("venv creation failed (on Debian/Ubuntu install python3-venv) \u2014 using resolved interpreter");
             this.appendEnv("HARNESS_ECOSYSTEM", "python");
             this.appendEnv("PYTHON_BIN", interpreter);
             return;
           }
         }
-        if (!fs20.existsSync(venvPython)) {
+        if (!fs21.existsSync(venvPython)) {
           this.log(`Python venv at ${venvRel} is missing or broken \u2014 using resolved interpreter`);
           this.appendEnv("HARNESS_ECOSYSTEM", "python");
           this.appendEnv("PYTHON_BIN", interpreter);
@@ -38178,19 +38237,19 @@ var init_provision = __esm({
               quietStderr: quiet,
               stream: !quiet
             });
-            if (fs20.existsSync(path21.join(dir, "pyproject.toml"))) {
+            if (fs21.existsSync(path21.join(dir, "pyproject.toml"))) {
               const dev = await pip(["install", "-q", "-e", ".[dev]"], true);
               if (dev.code !== 0) {
                 const plain = await pip(["install", "-q", "-e", "."], false);
                 if (plain.code !== 0) throw new ProvisionError("pip install -e . failed");
               }
-            } else if (fs20.existsSync(path21.join(dir, "requirements.txt"))) {
+            } else if (fs21.existsSync(path21.join(dir, "requirements.txt"))) {
               const result = await pip(["install", "-q", "-r", "requirements.txt"], false);
               if (result.code !== 0) throw new ProvisionError("pip install -r requirements.txt failed");
-            } else if (fs20.existsSync(path21.join(dir, "setup.py")) || fs20.existsSync(path21.join(dir, "setup.cfg"))) {
+            } else if (fs21.existsSync(path21.join(dir, "setup.py")) || fs21.existsSync(path21.join(dir, "setup.cfg"))) {
               const result = await pip(["install", "-q", "-e", "."], false);
               if (result.code !== 0) throw new ProvisionError("pip install -e . failed");
-            } else if (fs20.existsSync(path21.join(dir, "Pipfile")) && this.ops.which("pipenv")) {
+            } else if (fs21.existsSync(path21.join(dir, "Pipfile")) && this.ops.which("pipenv")) {
               const result = await this.ops.run("pipenv", ["install", "--dev"], {
                 cwd: dir,
                 stream: true,
@@ -38250,7 +38309,7 @@ var init_provision = __esm({
         const mvn = this.ops.which("mvn");
         if (mvn) {
           this.appendEnv("MVN_BIN", mvn);
-        } else if (fs20.existsSync(path21.join(dir, "gradlew"))) {
+        } else if (fs21.existsSync(path21.join(dir, "gradlew"))) {
           this.appendEnv("GRADLE_BIN", path21.join(dir, "gradlew"));
         } else {
           const gradle = this.ops.which("gradle");
@@ -38303,8 +38362,8 @@ var init_provision = __esm({
         }
       }
       async iosPodInstall(dir) {
-        if (!fs20.existsSync(path21.join(dir, "Podfile"))) return;
-        if (fs20.existsSync(path21.join(dir, "Pods"))) return;
+        if (!fs21.existsSync(path21.join(dir, "Podfile"))) return;
+        if (fs21.existsSync(path21.join(dir, "Pods"))) return;
         if (!this.ops.which("pod")) {
           this.log("ERROR: this repo uses CocoaPods (Podfile, no Pods/) and pod is not on PATH.");
           this.log("       Install CocoaPods, or set HARNESS_INSTALL_CMD in harness.env to provision the project another way.");
@@ -38330,8 +38389,8 @@ var init_provision = __esm({
       // ── monorepo root ──
       async provisionMonorepoRoot() {
         if (!this.relPrefix || !this.worktreeDir) return;
-        if (!fs20.existsSync(path21.join(this.worktreeDir, "package.json"))) return;
-        if (fs20.existsSync(path21.join(this.worktreeDir, "node_modules"))) return;
+        if (!fs21.existsSync(path21.join(this.worktreeDir, "package.json"))) return;
+        if (fs21.existsSync(path21.join(this.worktreeDir, "node_modules"))) return;
         const manager = nodePackageManager(this.worktreeDir, this.env, this.ops);
         this.log(`Installing monorepo root dependencies in ${this.worktreeDir} with ${manager}...`);
         const code = await nodeInstall(
@@ -38454,8 +38513,8 @@ function seedGitExclude(repoRoot, git2 = defaultGit) {
   if (!commonDir) return;
   const resolved = path22.isAbsolute(commonDir) ? commonDir : path22.resolve(repoRoot, commonDir);
   const excludeFile = path22.join(resolved, "info", "exclude");
-  if (!fs21.existsSync(path22.dirname(excludeFile))) return;
-  const existing = fs21.existsSync(excludeFile) ? fs21.readFileSync(excludeFile, "utf8") : "";
+  if (!fs22.existsSync(path22.dirname(excludeFile))) return;
+  const existing = fs22.existsSync(excludeFile) ? fs22.readFileSync(excludeFile, "utf8") : "";
   const lines = new Set(existing.split("\n"));
   let appended = "";
   for (const pattern of GIT_EXCLUDE_PATTERNS) {
@@ -38464,7 +38523,7 @@ function seedGitExclude(repoRoot, git2 = defaultGit) {
   }
   if (!appended) return;
   const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
-  fs21.appendFileSync(excludeFile, prefix + appended);
+  fs22.appendFileSync(excludeFile, prefix + appended);
 }
 function resolveResumeSession(repoPath, agentId) {
   const session = readSlotRegistry(repoPath, agentId);
@@ -38477,7 +38536,7 @@ function resolveResumeSession(repoPath, agentId) {
     };
   }
   const workDir = session?.workDir ?? "";
-  if (!workDir || !fs21.existsSync(workDir) || !fs21.statSync(workDir).isDirectory()) {
+  if (!workDir || !fs22.existsSync(workDir) || !fs22.statSync(workDir).isDirectory()) {
     return {
       ok: false,
       code: "missing-work-dir",
@@ -38485,7 +38544,7 @@ function resolveResumeSession(repoPath, agentId) {
     };
   }
   const envFile = path22.join(workDir, `.env.agent.${agentId}`);
-  if (!fs21.existsSync(envFile)) {
+  if (!fs22.existsSync(envFile)) {
     return {
       ok: false,
       code: "missing-env-file",
@@ -38517,7 +38576,7 @@ function removeSessionWorktree(options) {
   }
   const owned = options.mode === void 0 || options.mode === "worktree";
   if (!owned) {
-    if (worktreePath && fs21.existsSync(worktreePath) && options.mode === "external") {
+    if (worktreePath && fs22.existsSync(worktreePath) && options.mode === "external") {
       result.preservedWorktree = worktreePath;
     }
     tryGit3(git2, ["worktree", "prune"], options.repoRoot);
@@ -38531,17 +38590,17 @@ function removeSessionWorktree(options) {
     }
     return result;
   }
-  if (worktreePath && fs21.existsSync(worktreePath)) {
+  if (worktreePath && fs22.existsSync(worktreePath)) {
     for (const name of [
       `.env.agent.${options.agentId}`,
       `ecosystem.agent.${options.agentId}.config.cjs`
     ]) {
-      fs21.rmSync(path22.join(worktreePath, name), { force: true });
+      fs22.rmSync(path22.join(worktreePath, name), { force: true });
     }
     try {
       git2(["worktree", "remove", worktreePath, "--force"], options.repoRoot);
     } catch {
-      fs21.rmSync(worktreePath, { recursive: true, force: true });
+      fs22.rmSync(worktreePath, { recursive: true, force: true });
     }
     result.removedWorktree = worktreePath;
   }
@@ -38556,12 +38615,12 @@ function removeSessionWorktree(options) {
   }
   return result;
 }
-var import_child_process5, fs21, os8, path22, crypto6, defaultGit, GIT_EXCLUDE_PATTERNS;
+var import_child_process5, fs22, os8, path22, crypto6, defaultGit, GIT_EXCLUDE_PATTERNS;
 var init_worktree = __esm({
   "src/runtime/worktree.ts"() {
     "use strict";
     import_child_process5 = require("child_process");
-    fs21 = __toESM(require("fs"));
+    fs22 = __toESM(require("fs"));
     os8 = __toESM(require("os"));
     path22 = __toESM(require("path"));
     crypto6 = __toESM(require("crypto"));
@@ -38621,8 +38680,8 @@ function appendTelemetryEnvToFile(envFilePath, attrs) {
 ${TELEMETRY_MARKER_END}
 `;
   let existing = "";
-  if (fs22.existsSync(envFilePath)) {
-    existing = fs22.readFileSync(envFilePath, "utf8");
+  if (fs23.existsSync(envFilePath)) {
+    existing = fs23.readFileSync(envFilePath, "utf8");
     const start = existing.indexOf(TELEMETRY_MARKER_START);
     if (start >= 0) {
       const end = existing.indexOf(TELEMETRY_MARKER_END, start);
@@ -38633,15 +38692,15 @@ ${TELEMETRY_MARKER_END}
       }
     }
   }
-  fs22.mkdirSync(path23.dirname(envFilePath), { recursive: true });
+  fs23.mkdirSync(path23.dirname(envFilePath), { recursive: true });
   const combined = (existing.replace(/\n+$/, "\n") + block).replace(/^\n+/, "");
-  fs22.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
+  fs23.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
 }
-var fs22, path23, TELEMETRY_MARKER_START, TELEMETRY_MARKER_END;
+var fs23, path23, TELEMETRY_MARKER_START, TELEMETRY_MARKER_END;
 var init_telemetry_env = __esm({
   "src/core/telemetry-env.ts"() {
     "use strict";
-    fs22 = __toESM(require("fs"));
+    fs23 = __toESM(require("fs"));
     path23 = __toESM(require("path"));
     init_control_config();
     init_shell();
@@ -38665,8 +38724,8 @@ function substituteEnvTemplate(template, values) {
 }
 function generateAgentEnvFile(options) {
   const templatePath = options.templatePath ?? path24.join(options.harnessDir, "env.template");
-  if (!fs23.existsSync(templatePath)) return false;
-  const template = fs23.readFileSync(templatePath, "utf8");
+  if (!fs24.existsSync(templatePath)) return false;
+  const template = fs24.readFileSync(templatePath, "utf8");
   const v2 = options.values;
   const rendered = substituteEnvTemplate(template, {
     AGENT_ID: v2.agentId,
@@ -38678,8 +38737,8 @@ function generateAgentEnvFile(options) {
     BROWSER_PORT: v2.browserPort,
     REPO_ROOT: v2.repoRoot
   });
-  fs23.mkdirSync(path24.dirname(options.envFile), { recursive: true });
-  fs23.writeFileSync(options.envFile, rendered);
+  fs24.mkdirSync(path24.dirname(options.envFile), { recursive: true });
+  fs24.writeFileSync(options.envFile, rendered);
   return true;
 }
 function appendSessionTelemetry(options) {
@@ -38707,11 +38766,11 @@ function appendSessionTelemetry(options) {
   appendTelemetryEnvToFile(envFile, attrs);
   return envFile;
 }
-var fs23, path24, AGENT_ENV_TEMPLATE_VARS;
+var fs24, path24, AGENT_ENV_TEMPLATE_VARS;
 var init_agent_env = __esm({
   "src/runtime/agent-env.ts"() {
     "use strict";
-    fs23 = __toESM(require("fs"));
+    fs24 = __toESM(require("fs"));
     path24 = __toESM(require("path"));
     init_telemetry_env();
     init_slot_registry();
@@ -38736,20 +38795,20 @@ function resolveTemplatesDir() {
     path25.join(__dirname, "..", "harness", "templates")
   ];
   for (const dir of candidates) {
-    if (fs24.existsSync(path25.join(dir, "har-boilerplate"))) return dir;
+    if (fs25.existsSync(path25.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 = path25.join(dir, name);
-  return fs24.existsSync(filePath) ? filePath : null;
+  return fs25.existsSync(filePath) ? filePath : null;
 }
-var fs24, path25;
+var fs25, path25;
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
-    fs24 = __toESM(require("fs"));
+    fs25 = __toESM(require("fs"));
     path25 = __toESM(require("path"));
   }
 });
@@ -38761,10 +38820,10 @@ function templatesDirFor(options) {
 function readProfileManifest(profile, options) {
   const templates = templatesDirFor(options);
   const manifestPath = path26.join(templates, "profiles", profile, "profile.manifest.json");
-  if (!fs25.existsSync(manifestPath)) {
+  if (!fs26.existsSync(manifestPath)) {
     throw new Error(`Profile manifest not found: ${manifestPath}. Run npm run build.`);
   }
-  const parsed = ProfileManifestSchema.safeParse(JSON.parse(fs25.readFileSync(manifestPath, "utf8")));
+  const parsed = ProfileManifestSchema.safeParse(JSON.parse(fs26.readFileSync(manifestPath, "utf8")));
   if (!parsed.success) {
     throw new Error(`Invalid profile manifest for ${profile}: ${parsed.error.message}`);
   }
@@ -38782,7 +38841,7 @@ function readProfileCapabilities(profile, options) {
 }
 function resolveProfileBundleDir(bundle, options) {
   const dir = path26.join(templatesDirFor(options), bundle.path);
-  if (!fs25.existsSync(dir)) {
+  if (!fs26.existsSync(dir)) {
     throw new Error(`Profile bundle not found: ${bundle.id} (${bundle.path}). Run npm run build.`);
   }
   return dir;
@@ -38801,21 +38860,21 @@ function renderProfileDoc(profile, docName, options) {
   const parts = sections.map((name) => {
     const profilePath = path26.join(templates, "profiles", profile, "docs", dir, `${name}.md`);
     const sharedPath = path26.join(templates, "shared-docs", dir, `${name}.md`);
-    const sectionPath = fs25.existsSync(profilePath) ? profilePath : sharedPath;
-    if (!fs25.existsSync(sectionPath)) {
+    const sectionPath = fs26.existsSync(profilePath) ? profilePath : sharedPath;
+    if (!fs26.existsSync(sectionPath)) {
       throw new Error(`Doc section not found for ${profile}/${docName}: ${name} (${sectionPath})`);
     }
-    return fs25.readFileSync(sectionPath, "utf8");
+    return fs26.readFileSync(sectionPath, "utf8");
   });
   return parts.join("\n");
 }
 function readComposedTemplateContent(entry) {
   if (entry.content !== void 0) return entry.content;
-  return fs25.readFileSync(entry.sourcePath, "utf8");
+  return fs26.readFileSync(entry.sourcePath, "utf8");
 }
 function walkTemplateFiles(dir, prefix = "") {
   const out = [];
-  for (const entry of fs25.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs26.readdirSync(dir, { withFileTypes: true })) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
       out.push(...walkTemplateFiles(path26.join(dir, entry.name), rel));
@@ -38844,11 +38903,11 @@ function composeProfileTemplateMap(profile, options) {
   }
   return map;
 }
-var fs25, path26, ProfileBundleRefSchema, ProfileCapabilitiesSchema, ProfileManifestSchema;
+var fs26, path26, ProfileBundleRefSchema, ProfileCapabilitiesSchema, ProfileManifestSchema;
 var init_profiles = __esm({
   "src/harness/profiles.ts"() {
     "use strict";
-    fs25 = __toESM(require("fs"));
+    fs26 = __toESM(require("fs"));
     path26 = __toESM(require("path"));
     init_zod();
     init_paths();
@@ -38905,13 +38964,13 @@ function harnessUsesPm2(repoPath) {
   const capabilities = harnessCapabilities(repoPath);
   if (capabilities) return capabilities.processManager === "pm2";
   const harnessRoot = resolveHarnessRoot(repoPath);
-  return fs26.existsSync(path27.join(harnessRoot, ".har", "ecosystem.agent.template.cjs"));
+  return fs27.existsSync(path27.join(harnessRoot, ".har", "ecosystem.agent.template.cjs"));
 }
-var fs26, path27;
+var fs27, path27;
 var init_capabilities = __esm({
   "src/harness/capabilities.ts"() {
     "use strict";
-    fs26 = __toESM(require("fs"));
+    fs27 = __toESM(require("fs"));
     path27 = __toESM(require("path"));
     init_manifest();
     init_env();
@@ -38922,7 +38981,7 @@ var init_capabilities = __esm({
 // src/core/slot-ports.ts
 function loadInfraState(harnessRoot, repoRoot) {
   let statePath = path28.join(harnessRoot, ".har", "state", "infra.env");
-  if (!fs27.existsSync(statePath) && repoRoot) {
+  if (!fs28.existsSync(statePath) && repoRoot) {
     try {
       const commonDir = (0, import_child_process6.execSync)("git rev-parse --git-common-dir", {
         cwd: repoRoot,
@@ -38940,8 +38999,8 @@ function loadInfraState(harnessRoot, repoRoot) {
     } catch {
     }
   }
-  if (!fs27.existsSync(statePath)) return {};
-  return parseHarnessEnvSource(fs27.readFileSync(statePath, "utf8")).values;
+  if (!fs28.existsSync(statePath)) return {};
+  return parseHarnessEnvSource(fs28.readFileSync(statePath, "utf8")).values;
 }
 function portStep(env3) {
   return Number(env3.HARNESS_PORT_STEP ?? 10);
@@ -39008,12 +39067,12 @@ function allocateAppPorts(repoPath, agentId) {
     allocated: frontend !== feDefault || api !== apiDefault || debug !== debugDefault
   };
 }
-var import_child_process6, fs27, path28;
+var import_child_process6, fs28, path28;
 var init_slot_ports = __esm({
   "src/core/slot-ports.ts"() {
     "use strict";
     import_child_process6 = require("child_process");
-    fs27 = __toESM(require("fs"));
+    fs28 = __toESM(require("fs"));
     path28 = __toESM(require("path"));
     init_env();
     init_manifest();
@@ -39082,9 +39141,9 @@ function infraStatePath(harnessDir) {
 }
 function readInfraState(harnessDir) {
   const statePath = infraStatePath(harnessDir);
-  if (!fs28.existsSync(statePath)) return {};
+  if (!fs29.existsSync(statePath)) return {};
   const ports = {};
-  for (const line of fs28.readFileSync(statePath, "utf8").split("\n")) {
+  for (const line of fs29.readFileSync(statePath, "utf8").split("\n")) {
     const match = line.match(/^export\s+([A-Z_]+)=(\d+)\s*$/);
     if (match) ports[match[1]] = Number(match[2]);
   }
@@ -39092,8 +39151,8 @@ function readInfraState(harnessDir) {
 }
 function writeInfraState(harnessDir, ports) {
   const statePath = infraStatePath(harnessDir);
-  fs28.mkdirSync(path29.dirname(statePath), { recursive: true });
-  fs28.writeFileSync(
+  fs29.mkdirSync(path29.dirname(statePath), { recursive: true });
+  fs29.writeFileSync(
     statePath,
     `# Persisted by setup-infra.sh \u2014 host ports for shared docker compose services.
 export AGENT_DB_PORT=${ports.AGENT_DB_PORT}
@@ -39254,7 +39313,7 @@ async function setupInfra(options) {
     }
   }
   const sharedEcosystem = path29.join(harnessDir, "ecosystem.shared.config.cjs");
-  if (fs28.existsSync(sharedEcosystem)) {
+  if (fs29.existsSync(sharedEcosystem)) {
     log("Starting shared app services from ecosystem.shared.config.cjs...");
     const [pkgCmd, ...pkgArgs] = pkgExecPrefix;
     exec(pkgCmd, [...pkgArgs, "pm2", "startOrReload", sharedEcosystem], { cwd: repoRoot });
@@ -39317,11 +39376,11 @@ async function removeMinioBucket(agentId, options) {
   const port = options.minioPort ?? 19e3;
   await request("DELETE", `http://localhost:${port}/agent-${agentId}?force=true`, "minioadmin:minioadmin");
 }
-var fs28, path29, INFRA_LANES, defaultHttpRequest;
+var fs29, path29, INFRA_LANES, defaultHttpRequest;
 var init_infra = __esm({
   "src/runtime/infra.ts"() {
     "use strict";
-    fs28 = __toESM(require("fs"));
+    fs29 = __toESM(require("fs"));
     path29 = __toESM(require("path"));
     init_slot_ports();
     init_exec();
@@ -39366,7 +39425,7 @@ function renderTemplate(template, vars) {
   );
 }
 function generateEcosystemConfig(options) {
-  const template = fs29.readFileSync(options.templatePath, "utf8");
+  const template = fs30.readFileSync(options.templatePath, "utf8");
   const rendered = renderTemplate(template, {
     AGENT_ID: String(options.agentId),
     HARNESS_PROJECT_NAME: options.projectName,
@@ -39374,7 +39433,7 @@ function generateEcosystemConfig(options) {
     DEBUG_PORT: String(options.debugPort)
   });
   const configPath = path30.join(options.workDir, `ecosystem.agent.${options.agentId}.config.cjs`);
-  fs29.writeFileSync(configPath, rendered);
+  fs30.writeFileSync(configPath, rendered);
   return configPath;
 }
 function pm2(args, options, cwd) {
@@ -39420,11 +39479,11 @@ async function waitForHealthCheck(options) {
   log(`Check logs: ./.har/agent-cli.sh ${agentId} logs`);
   return false;
 }
-var fs29, path30, defaultHttpStatus;
+var fs30, path30, defaultHttpStatus;
 var init_process = __esm({
   "src/runtime/process.ts"() {
     "use strict";
-    fs29 = __toESM(require("fs"));
+    fs30 = __toESM(require("fs"));
     path30 = __toESM(require("path"));
     init_exec();
     defaultHttpStatus = async (url) => {
@@ -39452,7 +39511,7 @@ function simSlug(value) {
 function repoDigest(repoRoot) {
   let resolved = repoRoot;
   try {
-    resolved = fs30.realpathSync(repoRoot);
+    resolved = fs31.realpathSync(repoRoot);
   } catch {
   }
   return crypto7.createHash("sha1").update(resolved).digest("hex").slice(0, 6);
@@ -39473,7 +39532,7 @@ function claimFile(harnessDir, agentId) {
 }
 function writeClaim(harnessDir, agentId, udid, name, createdByHar, now = () => /* @__PURE__ */ new Date()) {
   const file = claimFile(harnessDir, agentId);
-  fs30.mkdirSync(path31.dirname(file), { recursive: true });
+  fs31.mkdirSync(path31.dirname(file), { recursive: true });
   const claim = {
     agentId,
     udid,
@@ -39481,21 +39540,21 @@ function writeClaim(harnessDir, agentId, udid, name, createdByHar, now = () => /
     createdByHar,
     claimedAt: now().toISOString()
   };
-  fs30.writeFileSync(file, JSON.stringify(claim, null, 2) + "\n");
+  fs31.writeFileSync(file, JSON.stringify(claim, null, 2) + "\n");
 }
 function readClaim(harnessDir, agentId) {
   const file = claimFile(harnessDir, agentId);
-  if (!fs30.existsSync(file)) return void 0;
+  if (!fs31.existsSync(file)) return void 0;
   try {
-    return JSON.parse(fs30.readFileSync(file, "utf8"));
+    return JSON.parse(fs31.readFileSync(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 function claimOwnerOf(harnessDir, udid, selfAgentId, slotIsLive) {
   const dir = claimsDir(harnessDir);
-  if (!fs30.existsSync(dir)) return void 0;
-  for (const entry of fs30.readdirSync(dir)) {
+  if (!fs31.existsSync(dir)) return void 0;
+  for (const entry of fs31.readdirSync(dir)) {
     const match = entry.match(/^agent-(\d+)\.json$/);
     if (!match) continue;
     const id = Number(match[1]);
@@ -39697,7 +39756,7 @@ function releaseSimulator(ctx, stdout = (message) => process.stdout.write(`${mes
   const log = ctx.log ?? simLog;
   const claim = readClaim(ctx.harnessDir, ctx.agentId);
   if (claim) {
-    fs30.rmSync(claimFile(ctx.harnessDir, ctx.agentId), { force: true });
+    fs31.rmSync(claimFile(ctx.harnessDir, ctx.agentId), { force: true });
     if (claim.createdByHar === true && claim.udid) {
       simctl.tryCall(["shutdown", claim.udid]);
       if (simctl.tryCall(["delete", claim.udid])) {
@@ -39710,12 +39769,12 @@ function releaseSimulator(ctx, stdout = (message) => process.stdout.write(`${mes
   }
   deleteDevicesWithPrefix(simctl, deviceLabelPrefix(ctx.env, ctx.repoRoot, ctx.agentId), log);
 }
-var crypto7, fs30, path31, simLog, Simctl;
+var crypto7, fs31, path31, simLog, Simctl;
 var init_xcode_sim = __esm({
   "src/runtime/xcode-sim.ts"() {
     "use strict";
     crypto7 = __toESM(require("crypto"));
-    fs30 = __toESM(require("fs"));
+    fs31 = __toESM(require("fs"));
     path31 = __toESM(require("path"));
     init_exec();
     simLog = (message) => process.stderr.write(`==> simulator: ${message}
@@ -39853,7 +39912,7 @@ function inspectControlUpReadiness(repoPath) {
   const control = controlContainerOnPort(containers, port);
   const warnings = [];
   const controlHarnessDir = path32.join(resolved, "control", ".har");
-  const harnessSlot1Active = fs31.existsSync(controlHarnessDir) && readSlotRegistry(path32.join(resolved, "control"), 1)?.status === "active";
+  const harnessSlot1Active = fs32.existsSync(controlHarnessDir) && readSlotRegistry(path32.join(resolved, "control"), 1)?.status === "active";
   if (control) {
     return {
       warnings,
@@ -39882,12 +39941,12 @@ function inspectControlUpReadiness(repoPath) {
     harnessSlot1Active
   };
 }
-var import_child_process7, fs31, path32;
+var import_child_process7, fs32, path32;
 var init_control_port = __esm({
   "src/core/control-port.ts"() {
     "use strict";
     import_child_process7 = require("child_process");
-    fs31 = __toESM(require("fs"));
+    fs32 = __toESM(require("fs"));
     path32 = __toESM(require("path"));
     init_control_config();
     init_slot_registry();
@@ -39922,20 +39981,20 @@ function sameGitCheckout2(a, b2) {
 }
 function discoverWorktree(harnessRoot, agentId, projectName) {
   const session = readSlotRegistry(harnessRoot, agentId);
-  if (session?.worktreePath && fs32.existsSync(session.worktreePath)) {
+  if (session?.worktreePath && fs33.existsSync(session.worktreePath)) {
     return session.worktreePath;
   }
   const legacy = path33.join(os9.homedir(), "worktrees", `${projectName}-agent-${agentId}`);
-  if (fs32.existsSync(legacy) && sameGitCheckout2(harnessRoot, legacy)) return legacy;
+  if (fs33.existsSync(legacy) && sameGitCheckout2(harnessRoot, legacy)) return legacy;
   const worktreesRoot = path33.join(os9.homedir(), "worktrees");
-  if (!fs32.existsSync(worktreesRoot)) return void 0;
+  if (!fs33.existsSync(worktreesRoot)) return void 0;
   const suffix = `-har-agent-${agentId}-`;
   const relPrefix = runGit(harnessRoot, "rev-parse --show-prefix") ?? "";
-  for (const name of fs32.readdirSync(worktreesRoot)) {
+  for (const name of fs33.readdirSync(worktreesRoot)) {
     if (!name.includes(suffix)) continue;
     const candidate = path33.join(worktreesRoot, name);
     if (!sameGitCheckout2(harnessRoot, candidate)) continue;
-    if (!fs32.existsSync(path33.join(candidate, relPrefix, `.env.agent.${agentId}`))) continue;
+    if (!fs33.existsSync(path33.join(candidate, relPrefix, `.env.agent.${agentId}`))) continue;
     return candidate;
   }
   return void 0;
@@ -39947,9 +40006,9 @@ function collectOccupiedSlot(repoPath, agentId) {
   const session = readSlotRegistry(harnessRoot, agentId);
   const worktreePath = discoverWorktree(harnessRoot, agentId, projectName);
   const workDir = session?.workDir;
-  const envInWorkDir = workDir ? fs32.existsSync(path33.join(workDir, `.env.agent.${agentId}`)) : false;
-  const envInRoot = fs32.existsSync(path33.join(harnessRoot, `.env.agent.${agentId}`));
-  const envInWorktree = worktreePath ? fs32.existsSync(path33.join(worktreePath, `.env.agent.${agentId}`)) : false;
+  const envInWorkDir = workDir ? fs33.existsSync(path33.join(workDir, `.env.agent.${agentId}`)) : false;
+  const envInRoot = fs33.existsSync(path33.join(harnessRoot, `.env.agent.${agentId}`));
+  const envInWorktree = worktreePath ? fs33.existsSync(path33.join(worktreePath, `.env.agent.${agentId}`)) : false;
   const active = session !== void 0 && session.status !== "completed" || envInWorkDir || envInRoot || envInWorktree;
   if (!active) return void 0;
   const dirty = worktreePath ? worktreeDirty(worktreePath) : void 0;
@@ -40040,11 +40099,11 @@ function checkLaunchGuard(repoPath, agentId, options = {}) {
     reason: formatOccupiedSlot(slot, repoPath)
   };
 }
-var fs32, os9, path33, import_child_process8;
+var fs33, os9, path33, import_child_process8;
 var init_slot_launch_guard_occupied = __esm({
   "src/core/slot-launch-guard-occupied.ts"() {
     "use strict";
-    fs32 = __toESM(require("fs"));
+    fs33 = __toESM(require("fs"));
     os9 = __toESM(require("os"));
     path33 = __toESM(require("path"));
     import_child_process8 = require("child_process");
@@ -40096,40 +40155,40 @@ exit 0
 `;
 }
 function upsertMarkedBlock(filePath, block) {
-  if (!fs33.existsSync(filePath)) {
-    fs33.writeFileSync(filePath, `#!/bin/sh
+  if (!fs34.existsSync(filePath)) {
+    fs34.writeFileSync(filePath, `#!/bin/sh
 ${block}
 `, { mode: 493 });
     return "created";
   }
-  const content = fs33.readFileSync(filePath, "utf8");
+  const content = fs34.readFileSync(filePath, "utf8");
   if (content.includes(MARKER_START)) {
     const pattern = new RegExp(
       `${escapeRegExp(MARKER_START)}[\\s\\S]*?${escapeRegExp(MARKER_END)}`
     );
-    fs33.writeFileSync(filePath, content.replace(pattern, block));
-    fs33.chmodSync(filePath, 493);
+    fs34.writeFileSync(filePath, content.replace(pattern, block));
+    fs34.chmodSync(filePath, 493);
     return "updated";
   }
   const suffix = content.endsWith("\n") ? "" : "\n";
-  fs33.writeFileSync(filePath, `${content}${suffix}
+  fs34.writeFileSync(filePath, `${content}${suffix}
 ${block}
 `);
-  fs33.chmodSync(filePath, 493);
+  fs34.chmodSync(filePath, 493);
   return "appended";
 }
 function removeMarkedBlock(filePath) {
-  if (!fs33.existsSync(filePath)) return false;
-  const content = fs33.readFileSync(filePath, "utf8");
+  if (!fs34.existsSync(filePath)) return false;
+  const content = fs34.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() === "") {
-    fs33.rmSync(filePath);
+    fs34.rmSync(filePath);
   } else {
-    fs33.writeFileSync(filePath, stripped);
+    fs34.writeFileSync(filePath, stripped);
   }
   return true;
 }
@@ -40151,14 +40210,14 @@ Or re-run with --force to write into that directory anyway.`
     );
   }
   const hooksDir = resolveHooksDir(checkout);
-  fs33.mkdirSync(hooksDir, { recursive: true });
+  fs34.mkdirSync(hooksDir, { recursive: true });
   const invocation = options.harInvocation ?? defaultHarInvocation();
-  fs33.writeFileSync(
+  fs34.writeFileSync(
     path34.join(hooksDir, "har-pre-commit"),
     buildHookScript(invocation, "check", "har: binary not found; skipping commit gate (reinstall with har hooks install)"),
     { mode: 493 }
   );
-  fs33.writeFileSync(
+  fs34.writeFileSync(
     path34.join(hooksDir, "har-post-commit"),
     buildHookScript(invocation, "record-commit", "har: binary not found; skipping commit association"),
     { mode: 493 }
@@ -40177,8 +40236,8 @@ function uninstallHooks(repoPath) {
   removed = removeMarkedBlock(path34.join(hooksDir, "post-commit")) || removed;
   for (const file of ["har-pre-commit", "har-post-commit"]) {
     const full = path34.join(hooksDir, file);
-    if (fs33.existsSync(full)) {
-      fs33.rmSync(full);
+    if (fs34.existsSync(full)) {
+      fs34.rmSync(full);
       removed = true;
     }
   }
@@ -40214,14 +40273,14 @@ function getHooksStatus(repoPath) {
   const gate = getCommitGateConfig(checkout);
   const hasBlock = (name) => {
     const file = path34.join(hooksDir, name);
-    return fs33.existsSync(file) && fs33.readFileSync(file, "utf8").includes(MARKER_START);
+    return fs34.existsSync(file) && fs34.readFileSync(file, "utf8").includes(MARKER_START);
   };
   return {
     checkout,
     hooksDir,
     configuredHooksPath: getConfiguredHooksPath(checkout),
-    preCommitInstalled: hasBlock("pre-commit") && fs33.existsSync(path34.join(hooksDir, "har-pre-commit")),
-    postCommitInstalled: hasBlock("post-commit") && fs33.existsSync(path34.join(hooksDir, "har-post-commit")),
+    preCommitInstalled: hasBlock("pre-commit") && fs34.existsSync(path34.join(hooksDir, "har-pre-commit")),
+    postCommitInstalled: hasBlock("post-commit") && fs34.existsSync(path34.join(hooksDir, "har-post-commit")),
     gate,
     effectiveMode: resolveEffectiveMode(checkout, gate)
   };
@@ -40232,7 +40291,7 @@ function checkCommitGate(cwd) {
   }
   const checkout = resolveCheckoutRoot(cwd);
   if (!checkout) return { exitCode: 0, messages: [] };
-  if (!fs33.existsSync(path34.join(checkout, ".har", "stages.json"))) {
+  if (!fs34.existsSync(path34.join(checkout, ".har", "stages.json"))) {
     return { exitCode: 0, messages: [] };
   }
   const gate = getCommitGateConfig(checkout);
@@ -40308,11 +40367,11 @@ async function recordCommitAssociation(cwd) {
     return { attached: false };
   }
 }
-var fs33, os10, path34, MARKER_START, MARKER_END, PRE_COMMIT_BLOCK, POST_COMMIT_BLOCK;
+var fs34, os10, path34, MARKER_START, MARKER_END, PRE_COMMIT_BLOCK, POST_COMMIT_BLOCK;
 var init_hooks = __esm({
   "src/core/hooks.ts"() {
     "use strict";
-    fs33 = __toESM(require("fs"));
+    fs34 = __toESM(require("fs"));
     os10 = __toESM(require("os"));
     path34 = __toESM(require("path"));
     init_shell();
@@ -40813,9 +40872,9 @@ var init_slot_database = __esm({
 // src/runtime/hooks.ts
 function readHookHarnessEnv(harnessDir) {
   const envPath = path37.join(harnessDir, "harness.env");
-  if (!fs34.existsSync(envPath)) return {};
+  if (!fs35.existsSync(envPath)) return {};
   try {
-    return parseHarnessEnvSource(fs34.readFileSync(envPath, "utf8")).values;
+    return parseHarnessEnvSource(fs35.readFileSync(envPath, "utf8")).values;
   } catch {
     return {};
   }
@@ -40844,7 +40903,7 @@ function hookDisplayPath(hook) {
 }
 function runLifecycleHook(hook, context) {
   const file = lifecycleHookPath(context.harnessDir, hook);
-  if (!fs34.existsSync(file)) return { ran: false, code: 0 };
+  if (!fs35.existsSync(file)) return { ran: false, code: 0 };
   context.log?.(`Running ${hookDisplayPath(hook)}...`);
   const env3 = hookEnv(hook, context);
   const cwd = context.workDir ?? path37.dirname(context.harnessDir);
@@ -40862,11 +40921,11 @@ function runLifecycleHook(hook, context) {
 function postHookFailureMode(env3) {
   return env3.HARNESS_HOOK_POST_FAILURE === "fail" ? "fail" : "warn";
 }
-var fs34, path37, import_child_process12, LIFECYCLE_HOOKS, HOOK_CONTRACT_VERSION, HOOKS_DIR;
+var fs35, path37, import_child_process12, LIFECYCLE_HOOKS, HOOK_CONTRACT_VERSION, HOOKS_DIR;
 var init_hooks2 = __esm({
   "src/runtime/hooks.ts"() {
     "use strict";
-    fs34 = __toESM(require("fs"));
+    fs35 = __toESM(require("fs"));
     path37 = __toESM(require("path"));
     import_child_process12 = require("child_process");
     init_schema2();
@@ -41009,7 +41068,7 @@ function detectProcessManager(repoPath) {
   const harnessRoot = resolveHarnessRoot(repoPath);
   const manifest = readManifest(harnessRoot);
   if (manifest?.profile === "ios") return "simulator";
-  if (fs35.existsSync(path38.join(getHarnessDir(harnessRoot), "simulator.sh"))) return "simulator";
+  if (fs36.existsSync(path38.join(getHarnessDir(harnessRoot), "simulator.sh"))) return "simulator";
   return "none";
 }
 function heredocEnvFile(envFile, agentId, workDir, worktreeDir) {
@@ -41021,8 +41080,8 @@ function heredocEnvFile(envFile, agentId, workDir, worktreeDir) {
     "NODE_ENV=test",
     ""
   ].join("\n");
-  fs35.mkdirSync(path38.dirname(envFile), { recursive: true });
-  fs35.writeFileSync(envFile, content);
+  fs36.mkdirSync(path38.dirname(envFile), { recursive: true });
+  fs36.writeFileSync(envFile, content);
 }
 async function launchSession(options) {
   const repoRoot = resolveHarnessRoot(options.repoPath);
@@ -41283,7 +41342,7 @@ async function launchSession(options) {
           throw new Error("simulator acquisition failed");
         }
         ({ udid: simUdid, name: simName } = sim);
-        fs35.appendFileSync(
+        fs36.appendFileSync(
           session.envFile,
           [
             `HARNESS_SIMULATOR_UDID=${quoteEnvValue(simUdid)}`,
@@ -41391,20 +41450,20 @@ function seedExtraExcludePattern(repoRoot, pattern, exec) {
   if (commonDir.code !== 0) return;
   const resolved = path38.isAbsolute(commonDir.stdout.trim()) ? commonDir.stdout.trim() : path38.resolve(repoRoot, commonDir.stdout.trim());
   const excludeFile = path38.join(resolved, "info", "exclude");
-  if (!fs35.existsSync(path38.dirname(excludeFile))) return;
-  const existing = fs35.existsSync(excludeFile) ? fs35.readFileSync(excludeFile, "utf8") : "";
+  if (!fs36.existsSync(path38.dirname(excludeFile))) return;
+  const existing = fs36.existsSync(excludeFile) ? fs36.readFileSync(excludeFile, "utf8") : "";
   if (existing.split("\n").includes(pattern)) return;
-  fs35.appendFileSync(excludeFile, `${pattern}
+  fs36.appendFileSync(excludeFile, `${pattern}
 `);
 }
 function repoRooted(requested, resolved) {
   return path38.resolve(requested) === resolved ? requested : resolved;
 }
-var fs35, path38, stderrLine;
+var fs36, path38, stderrLine;
 var init_launch = __esm({
   "src/runtime/launch.ts"() {
     "use strict";
-    fs35 = __toESM(require("fs"));
+    fs36 = __toESM(require("fs"));
     path38 = __toESM(require("path"));
     init_env();
     init_manifest();
@@ -41484,7 +41543,7 @@ async function teardownSession(options) {
   ];
   for (const dir of [repoRoot, workDir]) {
     if (!dir) continue;
-    for (const file of generated(dir)) fs36.rmSync(file, { force: true });
+    for (const file of generated(dir)) fs37.rmSync(file, { force: true });
   }
   const removed = removeSessionWorktree({
     repoRoot,
@@ -41528,11 +41587,11 @@ async function teardownSession(options) {
   out(`\u2713 Agent ${agentId} torn down`);
   return { code: 0 };
 }
-var fs36, path39, os11;
+var fs37, path39, os11;
 var init_teardown = __esm({
   "src/runtime/teardown.ts"() {
     "use strict";
-    fs36 = __toESM(require("fs"));
+    fs37 = __toESM(require("fs"));
     path39 = __toESM(require("path"));
     os11 = __toESM(require("os"));
     init_env();
@@ -41554,7 +41613,7 @@ var init_teardown = __esm({
 // src/runtime/verify.ts
 function resolveVerifyRunner(harnessDir) {
   const installed = path40.join(harnessDir, "lib", "verify-runner.mjs");
-  if (fs37.existsSync(installed)) return installed;
+  if (fs38.existsSync(installed)) return installed;
   return path40.join(
     resolveTemplatesDir(),
     "runtime-bundles",
@@ -41615,11 +41674,11 @@ exec node ${JSON.stringify(resolveVerifyRunner(harnessDir))} --agent ${agentId}$
     env: baseEnv
   };
 }
-var fs37, path40, XC_TARGET_FLAGS_FUNCTION, XC_BLOCK, API_PORT_BLOCK, VerifyPlanError;
+var fs38, path40, XC_TARGET_FLAGS_FUNCTION, XC_BLOCK, API_PORT_BLOCK, VerifyPlanError;
 var init_verify = __esm({
   "src/runtime/verify.ts"() {
     "use strict";
-    fs37 = __toESM(require("fs"));
+    fs38 = __toESM(require("fs"));
     path40 = __toESM(require("path"));
     init_paths();
     init_manifest();
@@ -41949,13 +42008,13 @@ function resolveStageScriptPath(repoPath, stage) {
     return path41.join(harnessDir, scriptName);
   }
   const stageScript = path41.join(harnessDir, "stages", `${stage.id}.sh`);
-  if (fs38.existsSync(stageScript)) {
+  if (fs39.existsSync(stageScript)) {
     return stageScript;
   }
   const fallback = stage.kind === "inspect" ? "agent-cli.sh" : RUNTIME_SCRIPT_FOR_KIND[stage.kind];
   if (fallback) {
     const fallbackPath = path41.join(harnessDir, fallback);
-    if (fs38.existsSync(fallbackPath)) return fallbackPath;
+    if (fs39.existsSync(fallbackPath)) return fallbackPath;
   }
   throw new Error(
     `Stage "${stage.id}" has no runnable script. Add script to stages.json, create .har/stages/${stage.id}.sh, or run verification via har_run_verification.`
@@ -42036,8 +42095,8 @@ function inspectOp(stage) {
 }
 function harnessScriptIsLegacy(repoPath, scriptName) {
   const file = path41.join(getHarnessDir(resolveHarnessRoot(repoPath)), scriptName);
-  if (!fs38.existsSync(file)) return false;
-  return !fs38.readFileSync(file, "utf8").includes("exec har env");
+  if (!fs39.existsSync(file)) return false;
+  return !fs39.readFileSync(file, "utf8").includes("exec har env");
 }
 function warnLegacyRuntimeScript(repoPath, scriptName) {
   const key = `${path41.resolve(repoPath)}:${scriptName}`;
@@ -42149,11 +42208,11 @@ async function runPackageRuntimeStage(repoPath, stage, options, capture) {
   }
   return void 0;
 }
-var fs38, path41, RUNTIME_SCRIPT_FOR_KIND, warnedLegacyScripts, LocalScriptExecutor, localScriptExecutor;
+var fs39, path41, RUNTIME_SCRIPT_FOR_KIND, warnedLegacyScripts, LocalScriptExecutor, localScriptExecutor;
 var init_local_executor = __esm({
   "src/core/local-executor.ts"() {
     "use strict";
-    fs38 = __toESM(require("fs"));
+    fs39 = __toESM(require("fs"));
     path41 = __toESM(require("path"));
     init_manifest();
     init_env();
@@ -42211,10 +42270,10 @@ var init_local_executor = __esm({
         const harnessDir = getHarnessDir(repoPath);
         const artifactsDirName = getArtifactsDir(repoPath);
         const artifactsDir = path41.join(harnessDir, artifactsDirName);
-        if (!fs38.existsSync(artifactsDir)) return [];
+        if (!fs39.existsSync(artifactsDir)) return [];
         const entries = [];
         const walk = (dir, prefix) => {
-          for (const entry of fs38.readdirSync(dir, { withFileTypes: true })) {
+          for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
             const full = path41.join(dir, entry.name);
             const relative6 = path41.join(prefix, entry.name);
             if (entry.isDirectory()) {
@@ -42222,7 +42281,7 @@ var init_local_executor = __esm({
               continue;
             }
             if (filter2?.stageId && !relative6.includes(filter2.stageId)) continue;
-            const stat = fs38.statSync(full);
+            const stat = fs39.statSync(full);
             entries.push({
               path: full,
               relativePath: relative6,
@@ -42281,11 +42340,11 @@ function gitPrefix2(cwd) {
 }
 function discoverSessionWorktreePath(harnessRoot, agentId) {
   const worktreesRoot = path42.join(os12.homedir(), "worktrees");
-  if (!fs39.existsSync(worktreesRoot)) return void 0;
+  if (!fs40.existsSync(worktreesRoot)) return void 0;
   const suffix = `-har-agent-${agentId}-`;
   const relPrefix = gitPrefix2(harnessRoot);
-  const matches = fs39.readdirSync(worktreesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.includes(suffix)).map((entry) => path42.join(worktreesRoot, entry.name)).filter(
-    (candidate) => sameGitCheckout3(harnessRoot, candidate) && fs39.existsSync(path42.join(candidate, relPrefix, `.env.agent.${agentId}`))
+  const matches = fs40.readdirSync(worktreesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.includes(suffix)).map((entry) => path42.join(worktreesRoot, entry.name)).filter(
+    (candidate) => sameGitCheckout3(harnessRoot, candidate) && fs40.existsSync(path42.join(candidate, relPrefix, `.env.agent.${agentId}`))
   );
   return matches.sort()[0];
 }
@@ -42293,7 +42352,7 @@ function resolveAgentEnvFile(harnessRoot, agentId) {
   const session = readSlotRegistry(harnessRoot, agentId);
   if (session?.workDir) {
     const inWorkDir = path42.join(session.workDir, `.env.agent.${agentId}`);
-    if (fs39.existsSync(inWorkDir)) return inWorkDir;
+    if (fs40.existsSync(inWorkDir)) return inWorkDir;
   }
   const env3 = readHarnessEnv(harnessRoot);
   const projectName = env3.HARNESS_PROJECT_NAME ?? path42.basename(harnessRoot);
@@ -42302,16 +42361,16 @@ function resolveAgentEnvFile(harnessRoot, agentId) {
     path42.join(harnessRoot, `.env.agent.${agentId}`),
     path42.join(os12.homedir(), "worktrees", `${projectName}-agent-${agentId}`, relPrefix, `.env.agent.${agentId}`)
   ]) {
-    if (fs39.existsSync(candidate)) return candidate;
+    if (fs40.existsSync(candidate)) return candidate;
   }
   const worktreesRoot = path42.join(os12.homedir(), "worktrees");
-  if (!fs39.existsSync(worktreesRoot)) return void 0;
+  if (!fs40.existsSync(worktreesRoot)) return void 0;
   const suffix = `-har-agent-${agentId}-`;
-  for (const name of fs39.readdirSync(worktreesRoot).sort()) {
+  for (const name of fs40.readdirSync(worktreesRoot).sort()) {
     if (!name.includes(suffix)) continue;
     const candidateDir = path42.join(worktreesRoot, name);
     const candidate = path42.join(candidateDir, relPrefix, `.env.agent.${agentId}`);
-    if (!fs39.existsSync(candidate)) continue;
+    if (!fs40.existsSync(candidate)) continue;
     if (!sameGitCheckout3(harnessRoot, candidateDir)) continue;
     return candidate;
   }
@@ -42319,7 +42378,7 @@ function resolveAgentEnvFile(harnessRoot, agentId) {
 }
 function parseEnvFilePorts(envFile) {
   const values = {};
-  for (const line of fs39.readFileSync(envFile, "utf8").split("\n")) {
+  for (const line of fs40.readFileSync(envFile, "utf8").split("\n")) {
     const match = line.match(/^(?:export\s+)?([A-Z_][A-Z0-9_]*)=(.*)$/);
     if (!match) continue;
     values[match[1]] = match[2].replace(/^["']|["']$/g, "");
@@ -42347,8 +42406,8 @@ function loadAgentPorts(harnessRoot, agentId) {
   const allocated = allocateAppPorts(harnessRoot, agentId);
   const infraEnv = path42.join(getHarnessDir(harnessRoot), "state", "infra.env");
   const infraState = {};
-  if (fs39.existsSync(infraEnv)) {
-    for (const line of fs39.readFileSync(infraEnv, "utf8").split("\n")) {
+  if (fs40.existsSync(infraEnv)) {
+    for (const line of fs40.readFileSync(infraEnv, "utf8").split("\n")) {
       const match = line.match(/^(?:export\s+)?([A-Z_][A-Z0-9_]*)=(.*)$/);
       if (match) infraState[match[1]] = match[2].replace(/^["']|["']$/g, "");
     }
@@ -42437,11 +42496,11 @@ function collectSlotStatus(harnessRoot, agentId, runs, pm2Procs, untrackedPaths)
     "worktrees",
     `${projectName}-agent-${agentId}`
   );
-  const worktreePath = session?.worktreePath && fs39.existsSync(session.worktreePath) ? session.worktreePath : fs39.existsSync(legacyWorktreePath) ? legacyWorktreePath : discoverSessionWorktreePath(harnessRoot, agentId);
+  const worktreePath = session?.worktreePath && fs40.existsSync(session.worktreePath) ? session.worktreePath : fs40.existsSync(legacyWorktreePath) ? legacyWorktreePath : discoverSessionWorktreePath(harnessRoot, agentId);
   const workDir = resolveAgentWorkDir(harnessRoot, agentId);
-  const envInWorkDir = workDir ? fs39.existsSync(path42.join(workDir, `.env.agent.${agentId}`)) : false;
-  const envInRoot = fs39.existsSync(path42.join(harnessRoot, `.env.agent.${agentId}`));
-  const envInWorktree = worktreePath ? fs39.existsSync(path42.join(worktreePath, `.env.agent.${agentId}`)) : false;
+  const envInWorkDir = workDir ? fs40.existsSync(path42.join(workDir, `.env.agent.${agentId}`)) : false;
+  const envInRoot = fs40.existsSync(path42.join(harnessRoot, `.env.agent.${agentId}`));
+  const envInWorktree = worktreePath ? fs40.existsSync(path42.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");
@@ -42549,11 +42608,11 @@ function collectEnvironmentStatus(repoPath) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var fs39, os12, path42, import_child_process14, BYPASS_WARNING_MS;
+var fs40, os12, path42, import_child_process14, BYPASS_WARNING_MS;
 var init_slot_status = __esm({
   "src/core/slot-status.ts"() {
     "use strict";
-    fs39 = __toESM(require("fs"));
+    fs40 = __toESM(require("fs"));
     os12 = __toESM(require("os"));
     path42 = __toESM(require("path"));
     import_child_process14 = require("child_process");
@@ -43196,8 +43255,8 @@ function encodeClaudeProjectDir(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function readJsonlRecords(filePath) {
-  if (!fs40.existsSync(filePath)) return [];
-  const lines = fs40.readFileSync(filePath, "utf8").split(/\r?\n/);
+  if (!fs41.existsSync(filePath)) return [];
+  const lines = fs41.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines) {
     const trimmed = line.trim();
@@ -43289,18 +43348,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 (!fs40.existsSync(root)) return [];
+  if (!fs41.existsSync(root)) return [];
   const primary = [];
   const fallback = [];
-  for (const entry of fs40.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs41.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const projectDir = path44.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 fs40.readdirSync(projectDir)) {
+    for (const file of fs41.readdirSync(projectDir)) {
       if (!file.endsWith(".jsonl")) continue;
       const filePath = path44.join(projectDir, file);
-      const stat = fs40.statSync(filePath);
+      const stat = fs41.statSync(filePath);
       const records = readJsonlRecords(filePath);
       let primaryHit = primaryEncoded;
       let fallbackHit = fallbackEncoded;
@@ -43443,11 +43502,11 @@ function harvestClaudeEvents(slot) {
   ).flatMap((entry) => entry.match.records);
   return capHarvestedEvents(extractPromptEvents(records, sessionKey, slot));
 }
-var fs40, os14, path44, MAX_HARVESTED_SESSION_EVENTS;
+var fs41, os14, path44, MAX_HARVESTED_SESSION_EVENTS;
 var init_claude = __esm({
   "src/core/usage-harvest/claude.ts"() {
     "use strict";
-    fs40 = __toESM(require("fs"));
+    fs41 = __toESM(require("fs"));
     os14 = __toESM(require("os"));
     path44 = __toESM(require("path"));
     init_schema2();
@@ -43464,8 +43523,8 @@ function codexSessionsRoot() {
   return process.env.HAR_CODEX_SESSIONS_DIR ? path45.resolve(process.env.HAR_CODEX_SESSIONS_DIR) : path45.join(os15.homedir(), ".codex", "sessions");
 }
 function walkJsonlFiles(dir, out = []) {
-  if (!fs41.existsSync(dir)) return out;
-  for (const entry of fs41.readdirSync(dir, { withFileTypes: true })) {
+  if (!fs42.existsSync(dir)) return out;
+  for (const entry of fs42.readdirSync(dir, { withFileTypes: true })) {
     const full = path45.join(dir, entry.name);
     if (entry.isDirectory()) walkJsonlFiles(full, out);
     else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(full);
@@ -43473,7 +43532,7 @@ function walkJsonlFiles(dir, out = []) {
   return out;
 }
 function readJsonl(filePath) {
-  const lines = fs41.readFileSync(filePath, "utf8").split(/\r?\n/);
+  const lines = fs42.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines) {
     const trimmed = line.trim();
@@ -43540,7 +43599,7 @@ function harvestCodexUsage(slot) {
     const extracted = extractCodexTokens(records);
     if (!extracted.cwd) continue;
     if (extracted.tokensInput + extracted.tokensOutput + extracted.tokensCacheRead === 0) continue;
-    const mtime = fs41.statSync(file).mtimeMs;
+    const mtime = fs42.statSync(file).mtimeMs;
     if (workspaceMatchesTarget(extracted.cwd, primaryTargets)) {
       if (mtime >= bestPrimaryMtime) {
         bestPrimaryMtime = mtime;
@@ -43576,11 +43635,11 @@ function harvestCodexUsage(slot) {
     lastSeenAt: best.seen?.lastAt ?? now
   };
 }
-var fs41, os15, path45;
+var fs42, os15, path45;
 var init_codex = __esm({
   "src/core/usage-harvest/codex.ts"() {
     "use strict";
-    fs41 = __toESM(require("fs"));
+    fs42 = __toESM(require("fs"));
     os15 = __toESM(require("os"));
     path45 = __toESM(require("path"));
     init_schema2();
@@ -43639,8 +43698,8 @@ function getStatePath() {
 function readState() {
   const statePath = getStatePath();
   try {
-    if (!fs42.existsSync(statePath)) return { states: [] };
-    const parsed = JSON.parse(fs42.readFileSync(statePath, "utf8"));
+    if (!fs43.existsSync(statePath)) return { states: [] };
+    const parsed = JSON.parse(fs43.readFileSync(statePath, "utf8"));
     return Array.isArray(parsed.states) ? parsed : { states: [] };
   } catch {
     return { states: [] };
@@ -43648,8 +43707,8 @@ function readState() {
 }
 function writeState(state) {
   const statePath = getStatePath();
-  fs42.mkdirSync(path46.dirname(statePath), { recursive: true });
-  fs42.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
+  fs43.mkdirSync(path46.dirname(statePath), { recursive: true });
+  fs43.writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
 }
 function readPortalWatermark(repoPath, portalUrl) {
   const canonical = canonicalizeControlRepoPath(repoPath);
@@ -43714,11 +43773,11 @@ function selectSince(rows, since, getTimestamp) {
   }
   return { selected, maxSyncedAt };
 }
-var fs42, os16, path46;
+var fs43, os16, path46;
 var init_portal_watermark = __esm({
   "src/core/portal-watermark.ts"() {
     "use strict";
-    fs42 = __toESM(require("fs"));
+    fs43 = __toESM(require("fs"));
     os16 = __toESM(require("os"));
     path46 = __toESM(require("path"));
     init_control_repo_path();
@@ -44427,10 +44486,26 @@ async function collectPortalTelemetry(repoPath, slots, controlApiUrl, since, por
     };
   }
 }
+function collectEnvironmentStatusForSync(canonicalPath, sourcePaths) {
+  const collected = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (const source of sourcePaths) {
+    const key = path48.resolve(source);
+    let status = collected.get(key);
+    if (!status) {
+      status = collectEnvironmentStatus(source);
+      collected.set(key, status);
+    }
+    groups.push(status.slots);
+  }
+  const canonicalKey = path48.resolve(canonicalPath);
+  const canonical = collected.get(canonicalKey) ?? collectEnvironmentStatus(canonicalPath);
+  return { ...canonical, slots: mergeSlotStatuses(groups) };
+}
 async function buildPortalPayload(repoPath, sourcePaths, controlApiUrl, since, full = false, portal) {
   const rawRunsBySource = collectRunsBySource(sourcePaths);
   const runs = mergeRunsBySource(rawRunsBySource);
-  const status = collectEnvironmentStatus(repoPath);
+  const status = collectEnvironmentStatusForSync(repoPath, sourcePaths);
   const manifest = readManifest(repoPath);
   const stagesRegistry = readStageRegistry(repoPath);
   const validations = collectValidationsForSync(sourcePaths);
@@ -44787,7 +44862,7 @@ async function syncRepoWithControl(options) {
     }
     const sourcePaths = resolveSyncSourcePaths(repoPath, workspacePath);
     const runs = collectRunsForSync(sourcePaths);
-    const status = collectEnvironmentStatus(repoPath);
+    const status = collectEnvironmentStatusForSync(repoPath, sourcePaths);
     const cloudWork = collectWorkUnitsForSync(sourcePaths);
     const harnessRoot = resolveHarnessRoot(repoPath);
     const response = await fetch(`${process.env.HAR_CLOUD_API_URL}/api/sync`, {
@@ -44862,7 +44937,7 @@ async function syncRepoRunsAndSlots(apiUrl, repoId, repoPath, workspacePath, dry
     },
     sourcePaths
   );
-  const status = collectEnvironmentStatus(repoPath);
+  const status = collectEnvironmentStatusForSync(repoPath, sourcePaths);
   const slotsBody = SyncSlotsInputSchema.parse({
     slots: status.slots,
     generatedAt: status.generatedAt
@@ -52696,10 +52771,10 @@ var require_lib2 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve70, reject) => {
       let fd;
-      const fs81 = (0, node_1.default)();
+      const fs82 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs81.closeSync(fd);
+          fs82.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -52711,9 +52786,9 @@ var require_lib2 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs81.openSync(filepath, "r");
+        fd = fs82.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs81.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs82.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -52725,22 +52800,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs81.readFile(filepath, handler);
+      fs82.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs81 = (0, node_1.default)();
+      const fs82 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs81.openSync(filepath, "r");
+        const fd = fs82.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs81.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs82.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs81.closeSync(fd);
+        fs82.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs81.readFileSync(filepath));
+      return (0, exports2.detect)(fs82.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -66095,7 +66170,7 @@ function installedPackageVersion(hooksHome) {
       "otel-hook",
       "package.json"
     );
-    const pkg = JSON.parse(fs69.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs70.readFileSync(pkgPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -66146,15 +66221,15 @@ function buildOtelHooksConfig(options) {
   };
 }
 function writeOtelHooksConfig(config2, hooksHome = getOtelHooksHome()) {
-  fs69.mkdirSync(hooksHome, { recursive: true });
+  fs70.mkdirSync(hooksHome, { recursive: true });
   const configPath = getOtelHooksConfigPath(hooksHome);
-  fs69.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+  fs70.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
 `);
   return configPath;
 }
 function writeOtelHooksWrapper(otelHookCommand, hooksHome = getOtelHooksHome()) {
-  fs69.mkdirSync(hooksHome, { recursive: true });
-  fs69.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
+  fs70.mkdirSync(hooksHome, { recursive: true });
+  fs70.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
   const wrapperPath = getOtelHooksWrapperPath(hooksHome);
   const configPath = getOtelHooksConfigPath(hooksHome);
   const stateDir = getOtelHooksStateDir(hooksHome);
@@ -66177,9 +66252,9 @@ set -uo pipefail
   "$@" || true
 exit 0
 `;
-  fs69.writeFileSync(wrapperPath, script, { mode: 493 });
+  fs70.writeFileSync(wrapperPath, script, { mode: 493 });
   try {
-    fs69.chmodSync(wrapperPath, 493);
+    fs70.chmodSync(wrapperPath, 493);
   } catch {
   }
   return wrapperPath;
@@ -66192,7 +66267,7 @@ function commandExists3(command2) {
 }
 function resolveOtelHookCommand(hooksHome) {
   const local = localOtelHookBin(hooksHome);
-  if (fs69.existsSync(local)) return local;
+  if (fs70.existsSync(local)) return local;
   return null;
 }
 function resolveHooksInstaller(hooksHome) {
@@ -66207,7 +66282,7 @@ function resolveHooksInstaller(hooksHome) {
   return candidates.find((candidate) => commandExists3(candidate.command)) ?? null;
 }
 function tryInstallPackage(hooksHome) {
-  fs69.mkdirSync(hooksHome, { recursive: true });
+  fs70.mkdirSync(hooksHome, { recursive: true });
   const installer = resolveHooksInstaller(hooksHome);
   if (!installer) {
     return {
@@ -66220,7 +66295,7 @@ function tryInstallPackage(hooksHome) {
     encoding: "utf8",
     timeout: 18e4
   });
-  if (result.status === 0 && fs69.existsSync(localOtelHookBin(hooksHome))) {
+  if (result.status === 0 && fs70.existsSync(localOtelHookBin(hooksHome))) {
     return { ok: true, detail: described };
   }
   return {
@@ -66252,8 +66327,8 @@ function removeLegacyPythonArtifacts(hooksHome) {
   ];
   for (const target of legacyPaths) {
     try {
-      if (fs69.existsSync(target)) {
-        fs69.rmSync(target, { recursive: true, force: true });
+      if (fs70.existsSync(target)) {
+        fs70.rmSync(target, { recursive: true, force: true });
       }
     } catch {
     }
@@ -66301,10 +66376,10 @@ function runSetupProvider(providerId, otelHookCommand, wrapperPath) {
   };
 }
 function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
-  if (!fs69.existsSync(filePath)) return false;
+  if (!fs70.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs69.readFileSync(filePath, "utf8");
+    raw = fs70.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -66351,15 +66426,15 @@ function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
     return changed;
   };
   if (!walk(parsed)) return false;
-  fs69.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs70.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
-  if (!fs69.existsSync(filePath)) return false;
+  if (!fs70.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs69.readFileSync(filePath, "utf8");
+    raw = fs70.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -66394,7 +66469,7 @@ function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
     }
   }
   if (!changed) return false;
-  fs69.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs70.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
@@ -66424,7 +66499,7 @@ function ensureOtelHooks(options) {
   const hooksHome = getOtelHooksHome();
   const errors = [];
   const providersSetup = [];
-  fs69.mkdirSync(hooksHome, { recursive: true });
+  fs70.mkdirSync(hooksHome, { recursive: true });
   let otelHookCommand = resolveOtelHookCommand(hooksHome);
   const needsInstall = !otelHookCommand || installedPackageVersion(hooksHome) !== pinnedVersion();
   if (needsInstall) {
@@ -66518,12 +66593,12 @@ function ensureOtelHooks(options) {
 function disableOtelHooksExport() {
   return writeOtelHooksConfig(buildOtelHooksConfig({ enabled: false }));
 }
-var import_child_process19, fs69, os22, path79, OTEL_HOOKS_PACKAGE, HOOK_TIMEOUT_SECONDS, HOOK_EXPORT_TIMEOUT_MS, HOOK_FLUSH_TIMEOUT_MS, OTEL_HOOKS_PROVIDERS, OTEL_HOOKS_AGENTS, LEGACY_CURSOR_ONLY_HOOK_EVENTS;
+var import_child_process19, fs70, os22, path79, OTEL_HOOKS_PACKAGE, HOOK_TIMEOUT_SECONDS, HOOK_EXPORT_TIMEOUT_MS, HOOK_FLUSH_TIMEOUT_MS, 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_process19 = require("child_process");
-    fs69 = __toESM(require("fs"));
+    fs70 = __toESM(require("fs"));
     os22 = __toESM(require("os"));
     path79 = __toESM(require("path"));
     init_control_config();
@@ -73395,12 +73470,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f2;
     };
-    function addFormats(ajv, list, fs81, exportName) {
+    function addFormats(ajv, list, fs82, exportName) {
       var _a2;
       var _b2;
       (_a2 = (_b2 = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b2.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f2 of list)
-        ajv.addFormat(f2, fs81[f2]);
+        ajv.addFormat(f2, fs82[f2]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -78267,7 +78342,7 @@ init_sync_context();
 var path51 = __toESM(require("path"));
 
 // src/harness/agent-skills.ts
-var fs43 = __toESM(require("fs"));
+var fs44 = __toESM(require("fs"));
 var os17 = __toESM(require("os"));
 var path50 = __toESM(require("path"));
 var readline = __toESM(require("readline"));
@@ -78279,17 +78354,17 @@ 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 = path50.join(resolveTemplatesDir(), "agent-skills");
-  if (!fs43.existsSync(dir)) {
+  if (!fs44.existsSync(dir)) {
     throw new Error("Agent skills templates not found (templates/agent-skills). Run npm run build.");
   }
   return dir;
 }
 function readSkillsManifest() {
   const manifestPath = path50.join(agentSkillsTemplateDir(), "skills.manifest.json");
-  return JSON.parse(fs43.readFileSync(manifestPath, "utf8"));
+  return JSON.parse(fs44.readFileSync(manifestPath, "utf8"));
 }
 function readSkillBody(entry) {
-  return fs43.readFileSync(path50.join(agentSkillsTemplateDir(), entry.body), "utf8");
+  return fs44.readFileSync(path50.join(agentSkillsTemplateDir(), entry.body), "utf8");
 }
 function renderYamlValue(value) {
   if (typeof value === "string") return JSON.stringify(value);
@@ -78353,7 +78428,7 @@ function resolveScaffoldPath(repoPath, file) {
   return path50.join(repoPath, file.relPath);
 }
 function isHarManaged(filePath) {
-  return fs43.readFileSync(filePath, "utf8").includes(MANAGED_HEADER);
+  return fs44.readFileSync(filePath, "utf8").includes(MANAGED_HEADER);
 }
 function scaffoldAgentSkills(repoPath, agents, options = {}) {
   const written = [];
@@ -78361,7 +78436,7 @@ function scaffoldAgentSkills(repoPath, agents, options = {}) {
   const records = [];
   for (const file of renderSkillFiles(agents)) {
     const destPath = resolveScaffoldPath(repoPath, file);
-    if (fs43.existsSync(destPath) && !options.force && !isHarManaged(destPath)) {
+    if (fs44.existsSync(destPath) && !options.force && !isHarManaged(destPath)) {
       warn(`Skipped ${file.relPath} \u2014 exists with user modifications (use --force to overwrite)`);
       skipped.push(file.relPath);
       continue;
@@ -78395,16 +78470,16 @@ function removeAgentSkills(repoPath, agents) {
   const removed = [];
   for (const file of renderSkillFiles(agents)) {
     const destPath = resolveScaffoldPath(repoPath, file);
-    if (!fs43.existsSync(destPath)) continue;
+    if (!fs44.existsSync(destPath)) continue;
     if (!isHarManaged(destPath)) {
       warn(`Kept ${file.relPath} \u2014 has user modifications`);
       continue;
     }
-    fs43.rmSync(destPath);
+    fs44.rmSync(destPath);
     removed.push(file.relPath);
     const parent = path50.dirname(destPath);
-    if (fs43.existsSync(parent) && fs43.readdirSync(parent).length === 0) {
-      fs43.rmdirSync(parent);
+    if (fs44.existsSync(parent) && fs44.readdirSync(parent).length === 0) {
+      fs44.rmdirSync(parent);
     }
   }
   const manifest = readManifest(repoPath);
@@ -78423,9 +78498,9 @@ function detectAgentTargets(repoPath) {
   const manifest = readManifest(repoPath);
   const scaffolded = new Set((manifest?.scaffoldedAgentFiles ?? []).map((entry) => entry.agent));
   const detected = new Set(scaffolded);
-  if (fs43.existsSync(path50.join(repoPath, ".claude"))) detected.add("claude");
-  if (fs43.existsSync(path50.join(repoPath, ".cursor"))) detected.add("cursor");
-  if (fs43.existsSync(path50.join(os17.homedir(), ".codex"))) detected.add("codex");
+  if (fs44.existsSync(path50.join(repoPath, ".claude"))) detected.add("claude");
+  if (fs44.existsSync(path50.join(repoPath, ".cursor"))) detected.add("cursor");
+  if (fs44.existsSync(path50.join(os17.homedir(), ".codex"))) detected.add("codex");
   return AGENT_SKILL_TARGETS.filter((agent) => detected.has(agent));
 }
 function parseAgentTargets(raw) {
@@ -78558,7 +78633,7 @@ function handleRemove(argv) {
 }
 
 // src/cli/commands/env.ts
-var fs72 = __toESM(require("fs"));
+var fs73 = __toESM(require("fs"));
 var path83 = __toESM(require("path"));
 
 // src/cli/finish-command.ts
@@ -78569,17 +78644,17 @@ async function finishCommand(code) {
 }
 
 // src/core/harness.ts
-var fs66 = __toESM(require("fs"));
+var fs67 = __toESM(require("fs"));
 var path75 = __toESM(require("path"));
 
 // src/harness/generator.ts
-var fs49 = __toESM(require("fs"));
+var fs50 = __toESM(require("fs"));
 var path57 = __toESM(require("path"));
 init_file_ops();
 init_logging();
 
 // src/core/gitignore.ts
-var fs44 = __toESM(require("fs"));
+var fs45 = __toESM(require("fs"));
 var path52 = __toESM(require("path"));
 var HARNESS_ROOT_GITIGNORE_PATTERNS = [
   ".env.agent.*",
@@ -78587,7 +78662,7 @@ var HARNESS_ROOT_GITIGNORE_PATTERNS = [
 ];
 function ensureRootGitignorePatterns(checkoutDir) {
   const gitignorePath = path52.join(checkoutDir, ".gitignore");
-  const content = fs44.existsSync(gitignorePath) ? fs44.readFileSync(gitignorePath, "utf8") : "";
+  const content = fs45.existsSync(gitignorePath) ? fs45.readFileSync(gitignorePath, "utf8") : "";
   const lines = content.split("\n").map((line) => line.trim());
   const missing = HARNESS_ROOT_GITIGNORE_PATTERNS.filter((pattern) => !lines.includes(pattern));
   if (missing.length === 0) return;
@@ -78596,11 +78671,11 @@ function ensureRootGitignorePatterns(checkoutDir) {
   const block = lines.some((line) => line.includes("HAR agent slot artifacts")) || header2.length === 0 ? `${missing.join("\n")}
 ` : `${header2}${missing.join("\n")}
 `;
-  fs44.writeFileSync(gitignorePath, `${content}${suffix}${block}`);
+  fs45.writeFileSync(gitignorePath, `${content}${suffix}${block}`);
 }
 
 // src/harness/gitignore-template.ts
-var fs45 = __toESM(require("fs"));
+var fs46 = __toESM(require("fs"));
 var path53 = __toESM(require("path"));
 var HARNESS_GITIGNORE_TEMPLATE = "gitignore.template";
 var HARNESS_GITIGNORE_FILE = ".gitignore";
@@ -78612,22 +78687,22 @@ function templateFileForHarness(harnessFile) {
 }
 function resolveGitignoreTemplateSource(boilerplateDir) {
   const primary = path53.join(boilerplateDir, HARNESS_GITIGNORE_TEMPLATE);
-  if (fs45.existsSync(primary)) return primary;
+  if (fs46.existsSync(primary)) return primary;
   const legacy = path53.join(boilerplateDir, HARNESS_GITIGNORE_FILE);
-  if (fs45.existsSync(legacy)) return legacy;
+  if (fs46.existsSync(legacy)) return legacy;
   return null;
 }
 function writeHarnessGitignore(harnessDir, boilerplateDir) {
   const src = resolveGitignoreTemplateSource(boilerplateDir);
   if (!src) return;
-  fs45.writeFileSync(path53.join(harnessDir, HARNESS_GITIGNORE_FILE), fs45.readFileSync(src, "utf8"));
+  fs46.writeFileSync(path53.join(harnessDir, HARNESS_GITIGNORE_FILE), fs46.readFileSync(src, "utf8"));
 }
 function isExpectedHarnessOnlyFile(harnessFile, templateFiles) {
   return harnessFile === HARNESS_GITIGNORE_FILE && templateFiles.includes(HARNESS_GITIGNORE_TEMPLATE);
 }
 
 // src/harness/drift.ts
-var fs46 = __toESM(require("fs"));
+var fs47 = __toESM(require("fs"));
 var path54 = __toESM(require("path"));
 init_env();
 init_manifest();
@@ -78757,7 +78832,7 @@ function compareHarnessToTemplate(repoPath) {
   for (const file of templateFiles) {
     const harnessFile = harnessFileForTemplate(file);
     const harnessPath = path54.join(harnessDir, harnessFile);
-    if (userOwnedFiles.has(harnessFile) && fs46.existsSync(harnessPath)) {
+    if (userOwnedFiles.has(harnessFile) && fs47.existsSync(harnessPath)) {
       ownedByUser.push(harnessFile);
       continue;
     }
@@ -78765,11 +78840,11 @@ function compareHarnessToTemplate(repoPath) {
       readComposedTemplateContent(composed.get(file)),
       projectName
     );
-    if (!fs46.existsSync(harnessPath)) {
+    if (!fs47.existsSync(harnessPath)) {
       missing.push(harnessFile);
       continue;
     }
-    const installedChecksum = computeFileChecksum(fs46.readFileSync(harnessPath, "utf8"));
+    const installedChecksum = computeFileChecksum(fs47.readFileSync(harnessPath, "utf8"));
     const templateChecksum = computeFileChecksum(templateContent);
     const recordedFile = fileBaseline?.[harnessFile];
     const recordedTemplate = templateBaseline?.[harnessFile];
@@ -78782,10 +78857,10 @@ function compareHarnessToTemplate(repoPath) {
     else if (status === "upstream-updated") upstreamUpdated.push(harnessFile);
     else conflict.push(harnessFile);
   }
-  if (fs46.existsSync(harnessDir)) {
-    for (const file of fs46.readdirSync(harnessDir)) {
+  if (fs47.existsSync(harnessDir)) {
+    for (const file of fs47.readdirSync(harnessDir)) {
       const full = path54.join(harnessDir, file);
-      if (!fs46.statSync(full).isFile()) continue;
+      if (!fs47.statSync(full).isFile()) continue;
       if (file === "manifest.json" || file === "plugins.json" || file.startsWith("ADAPT-PROMPT") || file.startsWith("MIGRATE-PROMPT")) {
         continue;
       }
@@ -78819,7 +78894,7 @@ function compareHarnessToTemplate(repoPath) {
 init_manifest();
 
 // src/harness/plugin-ledger.ts
-var fs47 = __toESM(require("fs"));
+var fs48 = __toESM(require("fs"));
 var path55 = __toESM(require("path"));
 init_zod();
 init_file_ops();
@@ -78847,9 +78922,9 @@ function getPluginLedgerPath(repoPath) {
 }
 function readPluginLedger(repoPath) {
   const ledgerPath = getPluginLedgerPath(repoPath);
-  if (!fs47.existsSync(ledgerPath)) return null;
+  if (!fs48.existsSync(ledgerPath)) return null;
   try {
-    const raw = JSON.parse(fs47.readFileSync(ledgerPath, "utf8"));
+    const raw = JSON.parse(fs48.readFileSync(ledgerPath, "utf8"));
     const parsed = PluginLedgerSchema.safeParse(raw);
     return parsed.success ? parsed.data : null;
   } catch {
@@ -78859,8 +78934,8 @@ function readPluginLedger(repoPath) {
 function writePluginLedger(repoPath, ledger) {
   const ledgerPath = getPluginLedgerPath(repoPath);
   const harnessDir = path55.dirname(ledgerPath);
-  if (!fs47.existsSync(harnessDir)) {
-    fs47.mkdirSync(harnessDir, { recursive: true });
+  if (!fs48.existsSync(harnessDir)) {
+    fs48.mkdirSync(harnessDir, { recursive: true });
   }
   writeFileSafe(ledgerPath, `${JSON.stringify(ledger, null, 2)}
 `);
@@ -78900,7 +78975,7 @@ init_schema2();
 init_stages();
 
 // src/harness/lifecycle-shims.ts
-var fs48 = __toESM(require("fs"));
+var fs49 = __toESM(require("fs"));
 var path56 = __toESM(require("path"));
 init_manifest();
 init_stages();
@@ -78933,10 +79008,10 @@ function retireLifecycleShims(repoPath) {
   const pruned = [];
   for (const shim3 of LIFECYCLE_SHIM_FILES) {
     const file = path56.join(harnessDir, shim3);
-    if (!fs48.existsSync(file) || !fs48.statSync(file).isFile()) continue;
-    const content = fs48.readFileSync(file, "utf8");
+    if (!fs49.existsSync(file) || !fs49.statSync(file).isFile()) continue;
+    const content = fs49.readFileSync(file, "utf8");
     if (!isManagedShimContent(content)) continue;
-    fs48.rmSync(file);
+    fs49.rmSync(file);
     pruned.push(shim3);
   }
   const stagesRewritten = stripLifecycleShimCommands(repoPath);
@@ -78972,21 +79047,21 @@ function scaffoldHarnessBoilerplate(repoPath, options = {}) {
   const profile = options.profile ?? "default";
   const profileManifest = readProfileManifest(profile);
   const bundleIds = profileManifest.bundles.map((b2) => b2.id);
-  if (fs49.existsSync(harnessDir) && !options.force) {
+  if (fs50.existsSync(harnessDir) && !options.force) {
     throw new Error(
       '.har/ already exists. Use --force to overwrite or run "har env maintain" to update in place.'
     );
   }
-  if (options.force && fs49.existsSync(harnessDir)) {
-    fs49.rmSync(harnessDir, { recursive: true, force: true });
+  if (options.force && fs50.existsSync(harnessDir)) {
+    fs50.rmSync(harnessDir, { recursive: true, force: true });
   }
-  fs49.mkdirSync(harnessDir, { recursive: true });
+  fs50.mkdirSync(harnessDir, { recursive: true });
   for (const bundle of profileManifest.bundles) {
     const bundleDir = resolveProfileBundleDir(bundle);
     copyDirRecursive(bundleDir, harnessDir);
   }
   for (const docName of Object.keys(profileManifest.docs)) {
-    fs49.writeFileSync(path57.join(harnessDir, docName), renderProfileDoc(profile, docName));
+    fs50.writeFileSync(path57.join(harnessDir, docName), renderProfileDoc(profile, docName));
   }
   const gitignoreSource = composeProfileTemplateMap(profile).get(HARNESS_GITIGNORE_TEMPLATE);
   if (gitignoreSource) {
@@ -78995,10 +79070,10 @@ function scaffoldHarnessBoilerplate(repoPath, options = {}) {
   syncAgentSlotsToHarnessEnv(repoPath);
   retireLifecycleShims(repoPath);
   const harnessEnvPath = path57.join(harnessDir, "harness.env");
-  if (fs49.existsSync(harnessEnvPath)) {
-    let content = fs49.readFileSync(harnessEnvPath, "utf8");
+  if (fs50.existsSync(harnessEnvPath)) {
+    let content = fs50.readFileSync(harnessEnvPath, "utf8");
     content = substituteTemplateTokens(content, projectName);
-    fs49.writeFileSync(harnessEnvPath, content);
+    fs50.writeFileSync(harnessEnvPath, content);
     const validation2 = validateHarnessEnvSource(content);
     if (!validation2.ok) {
       const details = validation2.issues.filter((i) => i.severity === "error").map((i) => i.line !== void 0 ? `line ${i.line}: ${i.message}` : i.message).join("\n  ");
@@ -79036,14 +79111,14 @@ function finalizeHarness(repoPath, adaptationSummary, stack) {
 }
 
 // src/harness/agent-md.ts
-var fs51 = __toESM(require("fs"));
+var fs52 = __toESM(require("fs"));
 var path60 = __toESM(require("path"));
 init_file_ops();
 init_logging();
 init_manifest();
 
 // src/harness/instruction-files.ts
-var fs50 = __toESM(require("fs"));
+var fs51 = __toESM(require("fs"));
 var os19 = __toESM(require("os"));
 var path59 = __toESM(require("path"));
 
@@ -81795,12 +81870,12 @@ function outsideContentShrinkMessage(beforeLines, afterLines) {
 }
 function detectInstructionFiles(repoPath) {
   return {
-    agentsMd: fs50.existsSync(path59.join(repoPath, AGENTS_MD)),
-    agentMd: fs50.existsSync(path59.join(repoPath, LEGACY_AGENT_MD)),
-    claudeMd: fs50.existsSync(path59.join(repoPath, CLAUDE_MD)),
-    cursorDir: fs50.existsSync(path59.join(repoPath, ".cursor")),
-    claudeDir: fs50.existsSync(path59.join(repoPath, ".claude")),
-    codexHome: fs50.existsSync(path59.join(os19.homedir(), ".codex"))
+    agentsMd: fs51.existsSync(path59.join(repoPath, AGENTS_MD)),
+    agentMd: fs51.existsSync(path59.join(repoPath, LEGACY_AGENT_MD)),
+    claudeMd: fs51.existsSync(path59.join(repoPath, CLAUDE_MD)),
+    cursorDir: fs51.existsSync(path59.join(repoPath, ".cursor")),
+    claudeDir: fs51.existsSync(path59.join(repoPath, ".claude")),
+    codexHome: fs51.existsSync(path59.join(os19.homedir(), ".codex"))
   };
 }
 function formatDetectionReport(detection) {
@@ -81865,7 +81940,7 @@ function loadHarAgentsSectionFromTemplate(options = {}) {
   if (!templatePath) {
     throw new Error("AGENTS.md.template not found. Run npm run build.");
   }
-  const content = fs50.readFileSync(templatePath, "utf8");
+  const content = fs51.readFileSync(templatePath, "utf8");
   const start = content.indexOf(HAR_SECTION_START);
   const end = content.indexOf(HAR_SECTION_END);
   if (start === -1 || end === -1 || end < start) {
@@ -81883,7 +81958,7 @@ function loadAgentsMdTemplate() {
   if (!templatePath) {
     throw new Error("AGENTS.md.template not found. Run npm run build.");
   }
-  return fs50.readFileSync(templatePath, "utf8");
+  return fs51.readFileSync(templatePath, "utf8");
 }
 function upsertMarkedBlock2(content, block, startMarker, endMarker) {
   const existingBlock = findLastCompleteMarkedBlock(content, startMarker, endMarker);
@@ -81919,11 +81994,11 @@ function upsertAgentsMdHarSection(repoPath, options = {}) {
   const dest = path59.join(repoPath, AGENTS_MD);
   const ejected = readManifest(repoPath)?.ejected === true;
   const section = loadHarAgentsSectionFromTemplate({ ejected });
-  if (!fs50.existsSync(dest)) {
+  if (!fs51.existsSync(dest)) {
     writeFileSafe(dest, loadAgentsMdTemplate());
     return "created";
   }
-  const existing = fs50.readFileSync(dest, "utf8");
+  const existing = fs51.readFileSync(dest, "utf8");
   const sanitized = stripClaudePointerFromAgentsMd(existing);
   const { content, action } = upsertMarkedBlock2(
     sanitized,
@@ -81950,13 +82025,13 @@ function upsertAgentsMdHarSection(repoPath, options = {}) {
 function migrateLegacyAgentMd(repoPath) {
   const legacyPath = path59.join(repoPath, LEGACY_AGENT_MD);
   const agentsPath = path59.join(repoPath, AGENTS_MD);
-  if (!fs50.existsSync(legacyPath)) return false;
-  const legacy = fs50.readFileSync(legacyPath, "utf8");
-  if (!fs50.existsSync(agentsPath)) {
+  if (!fs51.existsSync(legacyPath)) return false;
+  const legacy = fs51.readFileSync(legacyPath, "utf8");
+  if (!fs51.existsSync(agentsPath)) {
     writeFileSafe(agentsPath, legacy);
     upsertAgentsMdHarSection(repoPath);
   } else {
-    const agents = fs50.readFileSync(agentsPath, "utf8");
+    const agents = fs51.readFileSync(agentsPath, "utf8");
     const legacyTrimmed = legacy.trim();
     if (legacyTrimmed.length > 0 && !agents.includes(legacyTrimmed)) {
       const suffix = agents.endsWith("\n") ? "" : "\n";
@@ -81966,7 +82041,7 @@ ${legacyTrimmed}
     }
     upsertAgentsMdHarSection(repoPath);
   }
-  fs50.unlinkSync(legacyPath);
+  fs51.unlinkSync(legacyPath);
   info(`Migrated ${LEGACY_AGENT_MD} \u2192 ${AGENTS_MD} (removed legacy file)`);
   return true;
 }
@@ -81976,7 +82051,7 @@ function loadClaudeMdTemplate() {
   if (!templatePath) {
     throw new Error("CLAUDE.md.template not found. Run npm run build.");
   }
-  return fs50.readFileSync(templatePath, "utf8");
+  return fs51.readFileSync(templatePath, "utf8");
 }
 function isHarOwnedClaudeMd(content) {
   const trimmed = content.trim();
@@ -81990,11 +82065,11 @@ function hasAgentsImport(content) {
 function ensureClaudeMdPointer(repoPath, options = {}) {
   const dest = path59.join(repoPath, CLAUDE_MD);
   const thin = loadClaudeMdTemplate();
-  if (!fs50.existsSync(dest)) {
+  if (!fs51.existsSync(dest)) {
     writeFileSafe(dest, thin);
     return "created";
   }
-  const existing = fs50.readFileSync(dest, "utf8");
+  const existing = fs51.readFileSync(dest, "utf8");
   if (isHarOwnedClaudeMd(existing) || options.force) {
     if (existing.trim() === CLAUDE_MD_IMPORT) return "skipped";
     writeFileSafe(dest, thin);
@@ -82132,15 +82207,15 @@ function readAgentMdProposal(repoPath) {
   const metaPath = path60.join(harnessDir, AGENTS_MD_PROPOSAL_META);
   const legacyProposalPath = path60.join(harnessDir, AGENT_MD_PROPOSAL);
   const legacyMetaPath = path60.join(harnessDir, AGENT_MD_PROPOSAL_META);
-  const resolvedProposal = fs51.existsSync(proposalPath) ? proposalPath : fs51.existsSync(legacyProposalPath) ? legacyProposalPath : null;
+  const resolvedProposal = fs52.existsSync(proposalPath) ? proposalPath : fs52.existsSync(legacyProposalPath) ? legacyProposalPath : null;
   if (!resolvedProposal) return null;
   const resolvedMeta = resolvedProposal === proposalPath ? metaPath : legacyMetaPath;
-  const content = fs51.readFileSync(resolvedProposal, "utf8");
+  const content = fs52.readFileSync(resolvedProposal, "utf8");
   let rationale = "";
   let createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  if (fs51.existsSync(resolvedMeta)) {
+  if (fs52.existsSync(resolvedMeta)) {
     try {
-      const meta = JSON.parse(fs51.readFileSync(resolvedMeta, "utf8"));
+      const meta = JSON.parse(fs52.readFileSync(resolvedMeta, "utf8"));
       rationale = meta.rationale ?? "";
       createdAt = meta.createdAt ?? createdAt;
     } catch {
@@ -82158,7 +82233,7 @@ function clearAgentMdProposal(repoPath) {
     AGENT_MD_PROPOSAL_META
   ]) {
     const p = path60.join(harnessDir, file);
-    if (fs51.existsSync(p)) fs51.unlinkSync(p);
+    if (fs52.existsSync(p)) fs52.unlinkSync(p);
   }
 }
 function wouldProposalShrinkExisting(existing, proposal) {
@@ -82172,8 +82247,8 @@ function applyAgentMdProposalMerge(repoPath, options = {}) {
   const proposal = readAgentMdProposal(repoPath);
   if (!proposal) return false;
   const agentsMdPath = path60.join(repoPath, AGENTS_MD);
-  if (fs51.existsSync(agentsMdPath)) {
-    const existing = fs51.readFileSync(agentsMdPath, "utf8");
+  if (fs52.existsSync(agentsMdPath)) {
+    const existing = fs52.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) {
@@ -82196,7 +82271,7 @@ function finalizeAgentsMdInstructionFiles(repoPath) {
 }
 
 // src/harness/validator.ts
-var fs53 = __toESM(require("fs"));
+var fs54 = __toESM(require("fs"));
 var path62 = __toESM(require("path"));
 init_shell();
 init_env();
@@ -82204,7 +82279,7 @@ init_manifest();
 init_stages();
 
 // src/harness/verification.ts
-var fs52 = __toESM(require("fs"));
+var fs53 = __toESM(require("fs"));
 var path61 = __toESM(require("path"));
 init_env();
 init_provision();
@@ -82233,7 +82308,7 @@ function nodeSmokeCommand(repoPath) {
   const pkgPath = path61.join(repoPath, "package.json");
   let scripts = {};
   try {
-    scripts = JSON.parse(fs52.readFileSync(pkgPath, "utf8")).scripts ?? {};
+    scripts = JSON.parse(fs53.readFileSync(pkgPath, "utf8")).scripts ?? {};
   } catch {
     scripts = {};
   }
@@ -82264,7 +82339,7 @@ function nodeSmokeCommand(repoPath) {
 function nodeScriptOrSkip(repoPath, script) {
   const pkgPath = path61.join(repoPath, "package.json");
   try {
-    const scripts = JSON.parse(fs52.readFileSync(pkgPath, "utf8")).scripts ?? {};
+    const scripts = JSON.parse(fs53.readFileSync(pkgPath, "utf8")).scripts ?? {};
     if (scripts[script]) {
       return script === "test" ? "${NPM_BIN:-npm} test" : `\${NPM_BIN:-npm} run ${script}`;
     }
@@ -82389,7 +82464,7 @@ function ensureEcosystemVerificationStages(repoPath) {
   const skipped = /* @__PURE__ */ new Set();
   for (const stage of defaults.stages) {
     if (stages.some((s) => s.id === stage.id)) continue;
-    if (stage.script && !fs52.existsSync(path61.join(harnessDir, stage.script))) {
+    if (stage.script && !fs53.existsSync(path61.join(harnessDir, stage.script))) {
       skipped.add(stage.id);
       continue;
     }
@@ -82447,7 +82522,7 @@ var SHELL_SCRIPTS = [
 function validateHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
-  if (!fs53.existsSync(harnessDir)) {
+  if (!fs54.existsSync(harnessDir)) {
     return {
       pass: false,
       issues: [{ file: ".har", message: "Harness directory not found", severity: "error" }]
@@ -82455,14 +82530,14 @@ function validateHarness(repoPath) {
   }
   for (const file of getRequiredFiles(repoPath)) {
     const filePath = path62.join(harnessDir, file);
-    if (!fs53.existsSync(filePath)) {
+    if (!fs54.existsSync(filePath)) {
       issues.push({ file, message: "Required file missing", severity: "error" });
     }
   }
   for (const script of SHELL_SCRIPTS) {
     const scriptPath = path62.join(harnessDir, script);
-    if (!fs53.existsSync(scriptPath)) continue;
-    const stat = fs53.statSync(scriptPath);
+    if (!fs54.existsSync(scriptPath)) continue;
+    const stat = fs54.statSync(scriptPath);
     if (!(stat.mode & 73)) {
       issues.push({ file: script, message: "Script is not executable", severity: "warning" });
     }
@@ -82478,8 +82553,8 @@ function validateHarness(repoPath) {
   const manifest = readManifest(repoPath);
   const profile = manifest?.profile ?? "default";
   const ecosystemPath = path62.join(harnessDir, "ecosystem.agent.template.cjs");
-  if (profile !== "cli" && fs53.existsSync(ecosystemPath)) {
-    const content = fs53.readFileSync(ecosystemPath, "utf8");
+  if (profile !== "cli" && fs54.existsSync(ecosystemPath)) {
+    const content = fs54.readFileSync(ecosystemPath, "utf8");
     if (!content.includes("module.exports")) {
       issues.push({
         file: "ecosystem.agent.template.cjs",
@@ -82489,8 +82564,8 @@ function validateHarness(repoPath) {
     }
   }
   const harnessEnvPath = path62.join(harnessDir, "harness.env");
-  if (fs53.existsSync(harnessEnvPath)) {
-    const content = fs53.readFileSync(harnessEnvPath, "utf8");
+  if (fs54.existsSync(harnessEnvPath)) {
+    const content = fs54.readFileSync(harnessEnvPath, "utf8");
     if (content.includes("TODO: set migrate command")) {
       issues.push({ file: "harness.env", message: "Migrate command still has TODO", severity: "warning" });
     }
@@ -82507,16 +82582,16 @@ function validateHarness(repoPath) {
     }
   }
   const verifyPath = path62.join(harnessDir, "verify.sh");
-  if (fs53.existsSync(verifyPath)) {
-    const content = fs53.readFileSync(verifyPath, "utf8");
+  if (fs54.existsSync(verifyPath)) {
+    const content = fs54.readFileSync(verifyPath, "utf8");
     if (content.includes("echo 'TODO:")) {
       issues.push({ file: "verify.sh", message: "Verification steps still have TODO placeholders", severity: "warning" });
     }
   }
   const stagesPath = path62.join(harnessDir, "stages.json");
-  if (fs53.existsSync(stagesPath)) {
+  if (fs54.existsSync(stagesPath)) {
     try {
-      JSON.parse(fs53.readFileSync(stagesPath, "utf8"));
+      JSON.parse(fs54.readFileSync(stagesPath, "utf8"));
       const registry2 = readStageRegistry(repoPath);
       if (registry2.stages.length === 0) {
         issues.push({ file: "stages.json", message: "No harness stages declared", severity: "warning" });
@@ -82539,8 +82614,8 @@ function validateHarness(repoPath) {
     issues.push({ file: "stages.json", message: "Stage registry missing", severity: "warning" });
   }
   const readmePath = path62.join(harnessDir, "README.md");
-  if (fs53.existsSync(readmePath)) {
-    const content = fs53.readFileSync(readmePath, "utf8");
+  if (fs54.existsSync(readmePath)) {
+    const content = fs54.readFileSync(readmePath, "utf8");
     if (!content.includes(".har")) {
       issues.push({ file: "README.md", message: "README should document .har/ paths", severity: "warning" });
     }
@@ -82555,7 +82630,7 @@ async function smokeTestHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
   const setupScript = path62.join(harnessDir, "setup-infra.sh");
-  if (fs53.existsSync(setupScript)) {
+  if (fs54.existsSync(setupScript)) {
     const result = run(`bash "${setupScript}"`, { cwd: repoPath });
     if (result.code !== 0) {
       issues.push({
@@ -82570,7 +82645,7 @@ async function smokeTestHarness(repoPath) {
 }
 
 // src/harness/maintain-bundle.ts
-var fs59 = __toESM(require("fs"));
+var fs60 = __toESM(require("fs"));
 var os21 = __toESM(require("os"));
 var path67 = __toESM(require("path"));
 init_file_ops();
@@ -82578,34 +82653,34 @@ init_shell();
 init_manifest();
 
 // src/harness/plugin-drift.ts
-var fs58 = __toESM(require("fs"));
+var fs59 = __toESM(require("fs"));
 var path66 = __toESM(require("path"));
 init_manifest();
 
 // src/harness/plugins.ts
-var fs57 = __toESM(require("fs"));
+var fs58 = __toESM(require("fs"));
 var path65 = __toESM(require("path"));
 init_zod();
 init_logging();
 init_paths();
 
 // src/harness/parser.ts
-var fs54 = __toESM(require("fs"));
+var fs55 = __toESM(require("fs"));
 init_manifest();
 function harnessExists(repoPath) {
-  return fs54.existsSync(`${repoPath}/.har/stages.json`);
+  return fs55.existsSync(`${repoPath}/.har/stages.json`);
 }
 
 // src/harness/bundle-resolve.ts
 var import_child_process16 = require("child_process");
-var fs55 = __toESM(require("fs"));
+var fs56 = __toESM(require("fs"));
 var os20 = __toESM(require("os"));
 var path63 = __toESM(require("path"));
 init_paths();
 function findManifestPath(dir, config2) {
   for (const name of config2.manifestFiles) {
     const candidate = path63.join(dir, name);
-    if (fs55.existsSync(candidate)) return candidate;
+    if (fs56.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -82614,9 +82689,9 @@ function hasManifest(dir, config2) {
 }
 function readPackageVersion(dir) {
   const pkgPath = path63.join(dir, "package.json");
-  if (!fs55.existsSync(pkgPath)) return void 0;
+  if (!fs56.existsSync(pkgPath)) return void 0;
   try {
-    const pkg = JSON.parse(fs55.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs56.readFileSync(pkgPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : void 0;
   } catch {
     return void 0;
@@ -82626,7 +82701,7 @@ function readManifestId(dir, config2) {
   const manifestPath = findManifestPath(dir, config2);
   if (!manifestPath) return void 0;
   try {
-    const raw = JSON.parse(fs55.readFileSync(manifestPath, "utf8"));
+    const raw = JSON.parse(fs56.readFileSync(manifestPath, "utf8"));
     return typeof raw.id === "string" ? raw.id : void 0;
   } catch {
     return void 0;
@@ -82649,7 +82724,7 @@ function expandHome(p) {
   return p;
 }
 function makeTempDir(prefix) {
-  return fs55.mkdtempSync(path63.join(os20.tmpdir(), prefix));
+  return fs56.mkdtempSync(path63.join(os20.tmpdir(), prefix));
 }
 function manifestNames(config2) {
   return config2.manifestFiles.join(" or ");
@@ -82668,7 +82743,7 @@ function isLocalBundleDir(dir, repoPath, config2) {
 function resolvePathSpec(spec, repoPath, config2) {
   const raw = spec.startsWith("file:") ? spec.slice("file:".length) : spec;
   const dir = path63.resolve(expandHome(raw));
-  if (!fs55.existsSync(dir) || !fs55.statSync(dir).isDirectory()) {
+  if (!fs56.existsSync(dir) || !fs56.statSync(dir).isDirectory()) {
     throw new Error(`${config2.label} path not found: ${spec}`);
   }
   if (!hasManifest(dir, config2)) {
@@ -82692,19 +82767,19 @@ function resolveNpmSpec(spec, config2) {
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 12e4
     });
-    const tarballs = fs55.readdirSync(tmp).filter((f2) => f2.endsWith(".tgz"));
+    const tarballs = fs56.readdirSync(tmp).filter((f2) => f2.endsWith(".tgz"));
     if (tarballs.length === 0) {
       throw new Error(`npm pack produced no tarball for ${spec}`);
     }
     const extractDir = path63.join(tmp, "extract");
-    fs55.mkdirSync(extractDir);
+    fs56.mkdirSync(extractDir);
     (0, import_child_process16.execFileSync)("tar", ["-xzf", path63.join(tmp, tarballs[0]), "-C", extractDir], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
     let dir = path63.join(extractDir, "package");
     if (!hasManifest(dir, config2)) {
-      const nested = fs55.readdirSync(extractDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path63.join(extractDir, e.name)).find((d) => hasManifest(d, config2));
+      const nested = fs56.readdirSync(extractDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path63.join(extractDir, e.name)).find((d) => hasManifest(d, config2));
       if (!nested) {
         throw new Error(
           `npm package ${spec} has no ${manifestNames(config2)} (not a HAR ${config2.label} bundle)`
@@ -82722,7 +82797,7 @@ function resolveNpmSpec(spec, config2) {
     };
   } catch (err) {
     for (const d of cleanupDirs) {
-      fs55.rmSync(d, { recursive: true, force: true });
+      fs56.rmSync(d, { recursive: true, force: true });
     }
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to install ${config2.label} from npm (${spec}): ${message}`);
@@ -82751,8 +82826,8 @@ function resolveGitSpec(spec, config2) {
     let dir = cloneDir;
     if (!hasManifest(dir, config2)) {
       const nestedRoot = path63.join(cloneDir, config2.gitNestedDir);
-      if (fs55.existsSync(nestedRoot)) {
-        const child = fs55.readdirSync(nestedRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path63.join(nestedRoot, e.name)).find((d) => hasManifest(d, config2));
+      if (fs56.existsSync(nestedRoot)) {
+        const child = fs56.readdirSync(nestedRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path63.join(nestedRoot, e.name)).find((d) => hasManifest(d, config2));
         if (child) dir = child;
       }
     }
@@ -82771,7 +82846,7 @@ function resolveGitSpec(spec, config2) {
     };
   } catch (err) {
     for (const d of cleanupDirs) {
-      fs55.rmSync(d, { recursive: true, force: true });
+      fs56.rmSync(d, { recursive: true, force: true });
     }
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to install ${config2.label} from git (${spec}): ${message}`);
@@ -82828,17 +82903,17 @@ function resolveBundleSource(spec, repoPath, config2) {
 }
 function listTemplateBundleIds(config2) {
   const root = path63.join(resolveTemplatesDir(), config2.templatesSubdir);
-  if (!fs55.existsSync(root)) return [];
-  return fs55.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => hasManifest(path63.join(root, name), config2)).sort();
+  if (!fs56.existsSync(root)) return [];
+  return fs56.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => hasManifest(path63.join(root, name), config2)).sort();
 }
 function listLocalBundleIds(repoPath, config2) {
   const root = path63.resolve(repoPath, config2.localDir);
-  if (!fs55.existsSync(root)) return [];
-  return fs55.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => hasManifest(path63.join(root, name), config2)).sort();
+  if (!fs56.existsSync(root)) return [];
+  return fs56.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => hasManifest(path63.join(root, name), config2)).sort();
 }
 function cleanupResolvedBundle(source) {
   for (const dir of source.cleanupDirs) {
-    fs55.rmSync(dir, { recursive: true, force: true });
+    fs56.rmSync(dir, { recursive: true, force: true });
   }
 }
 
@@ -82880,7 +82955,7 @@ function cleanupResolvedPlugin(source) {
 }
 
 // src/harness/plugin-prompt.ts
-var fs56 = __toESM(require("fs"));
+var fs57 = __toESM(require("fs"));
 var path64 = __toESM(require("path"));
 init_paths();
 init_file_ops();
@@ -82897,7 +82972,7 @@ function loadTemplate() {
       "Plugin adaptation prompt template not found: adaptation-prompt-plugin.md. Run npm run build."
     );
   }
-  return fs56.readFileSync(filePath, "utf8");
+  return fs57.readFileSync(filePath, "utf8");
 }
 function resolveInstallCommand(repoPath) {
   const env3 = readHarnessEnv(repoPath);
@@ -82978,7 +83053,7 @@ function primaryStageId(manifest) {
 }
 function resolveBundledPluginDir(pluginId) {
   const dir = path65.join(resolveTemplatesDir(), "plugins", pluginId);
-  if (!fs57.existsSync(dir)) {
+  if (!fs58.existsSync(dir)) {
     throw new Error(`Plugin not found: ${pluginId}. Run npm run build.`);
   }
   return dir;
@@ -82988,7 +83063,7 @@ function readPluginManifestFromDir(pluginDir, expectedId) {
   if (!manifestPath) {
     throw new Error(`No template.manifest.json in ${pluginDir}`);
   }
-  const raw = JSON.parse(fs57.readFileSync(manifestPath, "utf8"));
+  const raw = JSON.parse(fs58.readFileSync(manifestPath, "utf8"));
   if (raw.kind === LINE_BUNDLE_KIND || path65.basename(manifestPath) === "line.manifest.json") {
     throw new Error(
       `${path65.basename(manifestPath)} declares "kind": "line" \u2014 this is a factory line bundle, not a verification plugin. Install it with: har line add <spec>`
@@ -83008,39 +83083,39 @@ function readPluginManifest(pluginId) {
 }
 function ensureParentDir(filePath) {
   const parent = path65.dirname(filePath);
-  if (!fs57.existsSync(parent)) {
-    fs57.mkdirSync(parent, { recursive: true });
+  if (!fs58.existsSync(parent)) {
+    fs58.mkdirSync(parent, { recursive: true });
   }
 }
 function copyPluginFile(pluginDir, file, repoPath, force) {
   const srcPath = path65.join(pluginDir, file.src);
   const destPath = path65.join(repoPath, file.dest);
-  if (!fs57.existsSync(srcPath)) {
+  if (!fs58.existsSync(srcPath)) {
     throw new Error(`Plugin file missing: ${file.src}`);
   }
-  if (fs57.existsSync(destPath) && !force) {
+  if (fs58.existsSync(destPath) && !force) {
     throw new Error(
       `File already exists: ${file.dest}. Use --force to overwrite or remove it first.`
     );
   }
   ensureParentDir(destPath);
-  fs57.copyFileSync(srcPath, destPath);
+  fs58.copyFileSync(srcPath, destPath);
   if (file.executable) {
-    fs57.chmodSync(destPath, 493);
+    fs58.chmodSync(destPath, 493);
   }
   return { written: true, path: file.dest };
 }
 function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
   const packagePath = path65.join(repoPath, "package.json");
-  if (!fs57.existsSync(packagePath)) {
+  if (!fs58.existsSync(packagePath)) {
     throw new Error("No package.json in repo root. Add one before applying this plugin.");
   }
   const fragmentPath = path65.join(pluginDir, fragmentRelPath);
-  if (!fs57.existsSync(fragmentPath)) {
+  if (!fs58.existsSync(fragmentPath)) {
     throw new Error(`Package fragment missing: ${fragmentRelPath}`);
   }
-  const pkg = JSON.parse(fs57.readFileSync(packagePath, "utf8"));
-  const fragment = JSON.parse(fs57.readFileSync(fragmentPath, "utf8"));
+  const pkg = JSON.parse(fs58.readFileSync(packagePath, "utf8"));
+  const fragment = JSON.parse(fs58.readFileSync(fragmentPath, "utf8"));
   for (const section of ["scripts", "devDependencies"]) {
     const existing = pkg[section] ?? {};
     const incoming = fragment[section] ?? {};
@@ -83053,7 +83128,7 @@ function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
     }
     pkg[section] = existing;
   }
-  fs57.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
+  fs58.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
 }
 function patchStageRegistry(repoPath, stages, verificationStageIds, force) {
   const registry2 = readStageRegistry(repoPath);
@@ -83090,7 +83165,7 @@ function assertStagesNotPresent(repoPath, stageIds, force) {
   const registry2 = readStageRegistry(repoPath);
   for (const stageId of stageIds) {
     const scriptPath = path65.join(repoPath, ".har", "stages", `${stageId}.sh`);
-    if (fs57.existsSync(scriptPath)) {
+    if (fs58.existsSync(scriptPath)) {
       throw new Error(
         `Stage script already exists: .har/stages/${stageId}.sh. Use --force to overwrite.`
       );
@@ -83123,7 +83198,7 @@ function applyPluginFromDir(repoPath, pluginDir, options, meta) {
       if (file.skipFlag === "skipCi" && options.skipCi) {
         continue;
       }
-      if (fs57.existsSync(path65.join(resolved, file.dest)) && !force) {
+      if (fs58.existsSync(path65.join(resolved, file.dest)) && !force) {
         warnings.push(`Skipped optional file (exists): ${file.dest}`);
         continue;
       }
@@ -83205,7 +83280,7 @@ function detectInstalledPlugins(repoPath) {
     return ledger.plugins.map((p) => p.id).sort();
   }
   const registryPath = path66.join(resolved, ".har", "stages.json");
-  if (!fs58.existsSync(registryPath)) return [];
+  if (!fs59.existsSync(registryPath)) return [];
   const registry2 = readStageRegistry(resolved);
   const stageIds = new Set(registry2.stages.map((stage) => stage.id));
   const installed = [];
@@ -83227,13 +83302,13 @@ function resolvePluginBaseline(repoPath, pluginId) {
   const entry = ledger?.plugins.find((p) => p.id === pluginId);
   if (entry?.source === "local") {
     const localDir = path66.join(resolved, LOCAL_PLUGINS_DIR, pluginId);
-    if (fs58.existsSync(path66.join(localDir, "template.manifest.json"))) {
+    if (fs59.existsSync(path66.join(localDir, "template.manifest.json"))) {
       return { kind: "local", dir: localDir, manifest: readPluginManifestFromDir(localDir) };
     }
     return null;
   }
   const bundled = path66.join(resolveTemplatesDir(), "plugins", pluginId);
-  if (fs58.existsSync(path66.join(bundled, "template.manifest.json"))) {
+  if (fs59.existsSync(path66.join(bundled, "template.manifest.json"))) {
     return { kind: "bundled", dir: bundled, manifest: readPluginManifestFromDir(bundled) };
   }
   return null;
@@ -83246,14 +83321,14 @@ function requireBaseline(repoPath, pluginId) {
   return baseline;
 }
 function readBaselineFile(baseline, srcRel) {
-  return fs58.readFileSync(path66.join(baseline.dir, srcRel), "utf8");
+  return fs59.readFileSync(path66.join(baseline.dir, srcRel), "utf8");
 }
 function listPluginDestPaths(baseline, repoPath) {
   const manifest = baseline.manifest;
   const paths = manifest.files.map((file) => file.dest);
   if (manifest.optionalFiles) {
     for (const file of manifest.optionalFiles) {
-      if (fs58.existsSync(path66.join(repoPath, file.dest))) {
+      if (fs59.existsSync(path66.join(repoPath, file.dest))) {
         paths.push(file.dest);
       }
     }
@@ -83313,8 +83388,8 @@ function readTemplatePluginFile(repoPath, pluginId, dest) {
 }
 function readInstalledPluginFile(repoPath, pluginId, dest) {
   const installedPath = path66.join(path66.resolve(repoPath), dest);
-  if (!fs58.existsSync(installedPath)) return null;
-  const content = fs58.readFileSync(installedPath, "utf8");
+  if (!fs59.existsSync(installedPath)) return null;
+  const content = fs59.readFileSync(installedPath, "utf8");
   const baseline = requireBaseline(repoPath, pluginId);
   const fragmentRel = baseline.manifest.merge?.[dest];
   if (fragmentRel) {
@@ -83356,7 +83431,7 @@ function comparePluginToTemplate(repoPath, pluginId) {
     if (dest === "package.json") {
       const fragmentRel = manifest.merge?.[dest];
       const installedPath = path66.join(resolved, dest);
-      const installedRaw = fs58.readFileSync(installedPath, "utf8");
+      const installedRaw = fs59.readFileSync(installedPath, "utf8");
       if (fragmentRel && pluginKeysMatch(installedRaw, readBaselineFile(baseline, fragmentRel))) {
         unchanged.push(dest);
       } else if (computeFileChecksum(installedContent) === computeFileChecksum(templateContent)) {
@@ -83456,12 +83531,12 @@ function actionHint(file, kind) {
   return `Upstream template updated since your last finalize \u2014 read maintain/diffs/${file}.diff and apply into .har/${file}.`;
 }
 function createUnifiedDiff(installedContent, templateContent, installedLabel, templateLabel) {
-  const tmpDir = fs59.mkdtempSync(path67.join(os21.tmpdir(), "har-maintain-diff-"));
+  const tmpDir = fs60.mkdtempSync(path67.join(os21.tmpdir(), "har-maintain-diff-"));
   try {
     const installedPath = path67.join(tmpDir, "installed");
     const templatePath = path67.join(tmpDir, "template");
-    fs59.writeFileSync(installedPath, installedContent);
-    fs59.writeFileSync(templatePath, templateContent);
+    fs60.writeFileSync(installedPath, installedContent);
+    fs60.writeFileSync(templatePath, templateContent);
     const result = run(`diff -u "${installedPath}" "${templatePath}"`);
     const body = result.stdout.trim();
     if (!body) return "";
@@ -83470,7 +83545,7 @@ function createUnifiedDiff(installedContent, templateContent, installedLabel, te
 ${body.split("\n").slice(2).join("\n")}
 `;
   } finally {
-    fs59.rmSync(tmpDir, { recursive: true, force: true });
+    fs60.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function buildActions(repoPath, profile, drift) {
@@ -83494,7 +83569,7 @@ function buildActions(repoPath, profile, drift) {
       file,
       kind,
       template: `maintain/templates/${file}`,
-      installed: fs59.existsSync(installedPath) ? `maintain/installed/${file}` : void 0,
+      installed: fs60.existsSync(installedPath) ? `maintain/installed/${file}` : void 0,
       diff: `maintain/diffs/${file}.diff`,
       hint: actionHint(file, kind)
     });
@@ -83666,8 +83741,8 @@ function buildReadme(report) {
 function writeBundleArtifacts(repoPath, profile, drift, report) {
   const harnessDir = getHarnessDir(repoPath);
   const bundleDir = path67.join(harnessDir, MAINTAIN_DIR);
-  if (fs59.existsSync(bundleDir)) {
-    fs59.rmSync(bundleDir, { recursive: true, force: true });
+  if (fs60.existsSync(bundleDir)) {
+    fs60.rmSync(bundleDir, { recursive: true, force: true });
   }
   const dirs = [
     bundleDir,
@@ -83677,15 +83752,15 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
     path67.join(bundleDir, "stale")
   ];
   for (const dir of dirs) {
-    fs59.mkdirSync(dir, { recursive: true });
+    fs60.mkdirSync(dir, { recursive: true });
   }
   const affectedFiles = [...drift.missing, ...drift.upstreamUpdated, ...drift.conflict];
   for (const file of affectedFiles) {
     const templateContent = readBundledTemplateContent(repoPath, profile, file);
     writeFileSafe(path67.join(bundleDir, "templates", file), templateContent);
     const harnessPath = path67.join(harnessDir, file);
-    if (fs59.existsSync(harnessPath)) {
-      const installedContent = fs59.readFileSync(harnessPath, "utf8");
+    if (fs60.existsSync(harnessPath)) {
+      const installedContent = fs60.readFileSync(harnessPath, "utf8");
       writeFileSafe(path67.join(bundleDir, "installed", file), installedContent);
       const diff = createUnifiedDiff(
         installedContent,
@@ -83719,8 +83794,8 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
 }
 function ensureParentDir2(filePath) {
   const parent = path67.dirname(filePath);
-  if (!fs59.existsSync(parent)) {
-    fs59.mkdirSync(parent, { recursive: true });
+  if (!fs60.existsSync(parent)) {
+    fs60.mkdirSync(parent, { recursive: true });
   }
 }
 function writePluginBundleArtifacts(repoPath, bundleDir, report) {
@@ -83731,7 +83806,7 @@ function writePluginBundleArtifacts(repoPath, bundleDir, report) {
     const installedDir = path67.join(pluginRoot, "installed");
     const diffsDir = path67.join(pluginRoot, "diffs");
     for (const dir of [templatesDir, installedDir, diffsDir]) {
-      fs59.mkdirSync(dir, { recursive: true });
+      fs60.mkdirSync(dir, { recursive: true });
     }
     const templateContent = readTemplatePluginFile(repoPath, action.pluginId, action.file);
     if (templateContent === null) continue;
@@ -83787,8 +83862,8 @@ function buildMaintainBundle(repoPath, validation2, drift) {
 }
 function removeMaintainBundle(repoPath) {
   const bundleDir = path67.join(getHarnessDir(repoPath), MAINTAIN_DIR);
-  if (fs59.existsSync(bundleDir)) {
-    fs59.rmSync(bundleDir, { recursive: true, force: true });
+  if (fs60.existsSync(bundleDir)) {
+    fs60.rmSync(bundleDir, { recursive: true, force: true });
   }
 }
 function formatMaintainBundlePromptSection(report) {
@@ -83897,7 +83972,7 @@ init_manifest();
 init_stages();
 
 // src/harness/doctor.ts
-var fs64 = __toESM(require("fs"));
+var fs65 = __toESM(require("fs"));
 var path73 = __toESM(require("path"));
 init_package_version();
 init_slot_registry();
@@ -83914,7 +83989,7 @@ function compareSemver(a, b2) {
 }
 
 // src/harness/eject.ts
-var fs60 = __toESM(require("fs"));
+var fs61 = __toESM(require("fs"));
 var path68 = __toESM(require("path"));
 init_package_version();
 init_manifest();
@@ -83922,7 +83997,7 @@ var EJECTED_RUNTIME_DIR = "runtime";
 var EJECTED_RUNTIME_BUNDLE = "har.cjs";
 function resolveRuntimeBundleSource() {
   if (process.env.HAR_EJECT_RUNTIME_SOURCE) {
-    return fs60.existsSync(process.env.HAR_EJECT_RUNTIME_SOURCE) ? process.env.HAR_EJECT_RUNTIME_SOURCE : null;
+    return fs61.existsSync(process.env.HAR_EJECT_RUNTIME_SOURCE) ? process.env.HAR_EJECT_RUNTIME_SOURCE : null;
   }
   const candidates = [
     // Bundled CLI: __dirname is dist/ and index.js is the self-contained runtime.
@@ -83931,7 +84006,7 @@ function resolveRuntimeBundleSource() {
     path68.resolve(__dirname, "..", "..", "dist", "index.js")
   ];
   for (const candidate of candidates) {
-    if (fs60.existsSync(candidate)) return candidate;
+    if (fs61.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -83973,11 +84048,11 @@ function ejectHarness(repoPath) {
   }
   const version2 = getHarPackageVersion();
   const runtimeDir = path68.join(harnessDir, EJECTED_RUNTIME_DIR);
-  fs60.mkdirSync(runtimeDir, { recursive: true });
+  fs61.mkdirSync(runtimeDir, { recursive: true });
   const runtimeFile = path68.join(runtimeDir, EJECTED_RUNTIME_BUNDLE);
-  fs60.copyFileSync(bundleSource, runtimeFile);
-  fs60.chmodSync(runtimeFile, 493);
-  fs60.writeFileSync(path68.join(runtimeDir, "README.md"), RUNTIME_README(version2));
+  fs61.copyFileSync(bundleSource, runtimeFile);
+  fs61.chmodSync(runtimeFile, 493);
+  fs61.writeFileSync(path68.join(runtimeDir, "README.md"), RUNTIME_README(version2));
   retireLifecycleShims(resolved);
   writeManifest(resolved, {
     ...manifest,
@@ -83998,7 +84073,7 @@ function adoptHarness(repoPath) {
   if (!manifest.ejected) {
     throw new Error("Harness is not ejected \u2014 the packaged runtime is already in use.");
   }
-  fs60.rmSync(path68.join(harnessDir, EJECTED_RUNTIME_DIR), { recursive: true, force: true });
+  fs61.rmSync(path68.join(harnessDir, EJECTED_RUNTIME_DIR), { recursive: true, force: true });
   const retired = retireLifecycleShims(resolved);
   const rest = { ...manifest };
   delete rest.ejected;
@@ -84016,7 +84091,7 @@ init_env();
 init_manifest();
 
 // src/harness/line-ledger.ts
-var fs61 = __toESM(require("fs"));
+var fs62 = __toESM(require("fs"));
 var path69 = __toESM(require("path"));
 init_file_ops();
 init_manifest();
@@ -84026,9 +84101,9 @@ function getLineLedgerPath(repoPath) {
 }
 function readLineLedger(repoPath) {
   const ledgerPath = getLineLedgerPath(repoPath);
-  if (!fs61.existsSync(ledgerPath)) return null;
+  if (!fs62.existsSync(ledgerPath)) return null;
   try {
-    const parsed = LineLedgerSchema.safeParse(JSON.parse(fs61.readFileSync(ledgerPath, "utf8")));
+    const parsed = LineLedgerSchema.safeParse(JSON.parse(fs62.readFileSync(ledgerPath, "utf8")));
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
@@ -84037,8 +84112,8 @@ function readLineLedger(repoPath) {
 function writeLineLedger(repoPath, ledger) {
   const ledgerPath = getLineLedgerPath(repoPath);
   const harnessDir = path69.dirname(ledgerPath);
-  if (!fs61.existsSync(harnessDir)) {
-    fs61.mkdirSync(harnessDir, { recursive: true });
+  if (!fs62.existsSync(harnessDir)) {
+    fs62.mkdirSync(harnessDir, { recursive: true });
   }
   writeFileSafe(ledgerPath, `${JSON.stringify(ledger, null, 2)}
 `);
@@ -84054,7 +84129,7 @@ function upsertLineLedgerEntry(repoPath, entry) {
 }
 
 // src/harness/lines.ts
-var fs62 = __toESM(require("fs"));
+var fs63 = __toESM(require("fs"));
 var path71 = __toESM(require("path"));
 init_logging();
 
@@ -84198,7 +84273,7 @@ function readLineManifestFromDir(bundleDir, expectedId) {
   if (!manifestPath) {
     throw new Error(`No ${LINE_MANIFEST_FILES.join(" or ")} in ${bundleDir}`);
   }
-  const raw = JSON.parse(fs62.readFileSync(manifestPath, "utf8"));
+  const raw = JSON.parse(fs63.readFileSync(manifestPath, "utf8"));
   if (raw.kind !== LINE_BUNDLE_KIND) {
     throw new Error(
       `${path71.basename(manifestPath)} is not a factory line bundle (missing "kind": "line"). Verification plugins install with: har env add-plugin <spec>`
@@ -84215,10 +84290,10 @@ function readLineManifestFromDir(bundleDir, expectedId) {
 }
 function readLineProgramFromDir(bundleDir, manifest) {
   const programPath = path71.join(bundleDir, manifest.program);
-  if (!fs62.existsSync(programPath)) {
+  if (!fs63.existsSync(programPath)) {
     throw new Error(`Line program missing: ${manifest.program} (referenced by line.manifest.json)`);
   }
-  const parsed = LineProgramSchema.safeParse(JSON.parse(fs62.readFileSync(programPath, "utf8")));
+  const parsed = LineProgramSchema.safeParse(JSON.parse(fs63.readFileSync(programPath, "utf8")));
   if (!parsed.success) {
     throw new Error(`Invalid line program (${manifest.program}): ${parsed.error.message}`);
   }
@@ -84231,31 +84306,31 @@ function readLineProgramFromDir(bundleDir, manifest) {
 }
 function readInstalledLineProgram(repoPath, lineId) {
   const programPath = path71.join(path71.resolve(repoPath), lineProgramPathRel(lineId));
-  if (!fs62.existsSync(programPath)) return null;
-  const parsed = LineProgramSchema.safeParse(JSON.parse(fs62.readFileSync(programPath, "utf8")));
+  if (!fs63.existsSync(programPath)) return null;
+  const parsed = LineProgramSchema.safeParse(JSON.parse(fs63.readFileSync(programPath, "utf8")));
   return parsed.success ? parsed.data : null;
 }
 function ensureParentDir3(filePath) {
-  fs62.mkdirSync(path71.dirname(filePath), { recursive: true });
+  fs63.mkdirSync(path71.dirname(filePath), { recursive: true });
 }
 function copyBundleFile(bundleDir, file, repoPath, force) {
   const srcPath = path71.join(bundleDir, file.src);
   const destPath = path71.join(repoPath, file.dest);
-  if (!fs62.existsSync(srcPath)) {
+  if (!fs63.existsSync(srcPath)) {
     throw new Error(`Line file missing: ${file.src}`);
   }
   if (path71.resolve(srcPath) === path71.resolve(destPath)) {
     return file.dest;
   }
-  if (fs62.existsSync(destPath) && !force) {
+  if (fs63.existsSync(destPath) && !force) {
     throw new Error(
       `File already exists: ${file.dest}. Use --force to overwrite or remove it first.`
     );
   }
   ensureParentDir3(destPath);
-  fs62.copyFileSync(srcPath, destPath);
+  fs63.copyFileSync(srcPath, destPath);
   if (file.executable) {
-    fs62.chmodSync(destPath, 493);
+    fs63.chmodSync(destPath, 493);
   }
   return file.dest;
 }
@@ -84314,20 +84389,20 @@ function applyLineFromDir(repoPath, bundleDir, options, meta) {
   const programDest = path71.join(resolved, lineProgramPathRel(manifest.id));
   const programSrc = path71.join(bundleDir, manifest.program);
   if (path71.resolve(programSrc) !== path71.resolve(programDest)) {
-    if (fs62.existsSync(programDest) && !force) {
+    if (fs63.existsSync(programDest) && !force) {
       throw new Error(
         `Line already installed: ${lineProgramPathRel(manifest.id)}. Use --force to replace.`
       );
     }
     ensureParentDir3(programDest);
-    fs62.copyFileSync(programSrc, programDest);
+    fs63.copyFileSync(programSrc, programDest);
   }
   filesWritten.push(lineProgramPathRel(manifest.id));
   const manifestDest = path71.join(resolved, lineDirRel(manifest.id), "line.manifest.json");
   const manifestSrc = findManifestPath(bundleDir, LINE_BUNDLE_CONFIG);
   if (path71.resolve(manifestSrc) !== path71.resolve(manifestDest)) {
     ensureParentDir3(manifestDest);
-    fs62.copyFileSync(manifestSrc, manifestDest);
+    fs63.copyFileSync(manifestSrc, manifestDest);
     filesWritten.push(`${lineDirRel(manifest.id)}/line.manifest.json`);
   }
   registerStagesOnly(resolved, stages, force);
@@ -84408,7 +84483,7 @@ init_stages();
 init_hooks2();
 
 // src/harness/migrations.ts
-var fs63 = __toESM(require("fs"));
+var fs64 = __toESM(require("fs"));
 var path72 = __toESM(require("path"));
 init_schema2();
 init_manifest();
@@ -84459,24 +84534,24 @@ function harnessEnvIsPre10(content) {
 }
 function scriptIsVendored(harnessDir, script) {
   const file = path72.join(harnessDir, script);
-  if (!fs63.existsSync(file)) return false;
-  const content = fs63.readFileSync(file, "utf8");
+  if (!fs64.existsSync(file)) return false;
+  const content = fs64.readFileSync(file, "utf8");
   return !content.includes("exec har env") && !content.includes("runtime/har.cjs");
 }
 function isPre10Harness(repoPath) {
   const resolved = path72.resolve(repoPath);
   const harnessDir = getHarnessDir(resolved);
-  if (!fs63.existsSync(harnessDir)) return false;
+  if (!fs64.existsSync(harnessDir)) return false;
   const manifest = readManifest(resolved);
   if (manifest?.ejected) return false;
   for (const file of LEGACY_MACHINERY_FILES) {
-    if (fs63.existsSync(path72.join(harnessDir, file))) return true;
+    if (fs64.existsSync(path72.join(harnessDir, file))) return true;
   }
   for (const script of MANAGED_SHIM_FILES) {
     if (scriptIsVendored(harnessDir, script)) return true;
   }
   const envPath = path72.join(harnessDir, "harness.env");
-  if (fs63.existsSync(envPath) && harnessEnvIsPre10(fs63.readFileSync(envPath, "utf8"))) {
+  if (fs64.existsSync(envPath) && harnessEnvIsPre10(fs64.readFileSync(envPath, "utf8"))) {
     return true;
   }
   return false;
@@ -84621,7 +84696,7 @@ function buildPre10Plan(repoPath) {
   const deleteLifecycleScripts = [];
   const residue = [];
   for (const script of MANAGED_SHIM_FILES) {
-    if (!fs63.existsSync(path72.join(harnessDir, script))) continue;
+    if (!fs64.existsSync(path72.join(harnessDir, script))) continue;
     deleteLifecycleScripts.push(script);
     if (scriptIsVendored(harnessDir, script)) {
       const target = SCRIPT_RESIDUE_TARGET[script] ?? "review";
@@ -84636,16 +84711,16 @@ function buildPre10Plan(repoPath) {
   const survivingScripts = [];
   for (const dir of ["stages", "hooks"]) {
     const full = path72.join(harnessDir, dir);
-    if (!fs63.existsSync(full)) continue;
-    for (const entry of fs63.readdirSync(full)) {
+    if (!fs64.existsSync(full)) continue;
+    for (const entry of fs64.readdirSync(full)) {
       if (entry.endsWith(".sh") || entry.endsWith(".mjs")) survivingScripts.push(path72.join(dir, entry));
     }
   }
-  for (const entry of fs63.readdirSync(harnessDir)) {
+  for (const entry of fs64.readdirSync(harnessDir)) {
     if (!entry.endsWith(".sh")) continue;
     if (MANAGED_SHIM_FILES.includes(entry)) continue;
     if (LEGACY_MACHINERY_FILES.includes(entry)) continue;
-    if (!fs63.statSync(path72.join(harnessDir, entry)).isFile()) continue;
+    if (!fs64.statSync(path72.join(harnessDir, entry)).isFile()) continue;
     survivingScripts.push(entry);
   }
   const referencedBy = (machineryFile) => {
@@ -84654,12 +84729,12 @@ function buildPre10Plan(repoPath) {
       `(?:\\bsource\\b|\\bbash\\b|\\bexec\\b|(?:^|[;&|(])\\s*\\.\\s)[^\\n#]*${base}`
     );
     return survivingScripts.filter(
-      (script) => fs63.readFileSync(path72.join(harnessDir, script), "utf8").split("\n").some((line) => !/^\s*#/.test(line) && loadRe.test(line))
+      (script) => fs64.readFileSync(path72.join(harnessDir, script), "utf8").split("\n").some((line) => !/^\s*#/.test(line) && loadRe.test(line))
     );
   };
   const retireDocs = [];
   for (const doc of RETIRED_DOC_FILES) {
-    if (!fs63.existsSync(path72.join(harnessDir, doc))) continue;
+    if (!fs64.existsSync(path72.join(harnessDir, doc))) continue;
     retireDocs.push(doc);
     residue.push({
       source: doc,
@@ -84673,7 +84748,7 @@ function buildPre10Plan(repoPath) {
   const retainMachinery = [];
   for (const file of LEGACY_MACHINERY_FILES) {
     const full = path72.join(harnessDir, file);
-    if (!fs63.existsSync(full)) continue;
+    if (!fs64.existsSync(full)) continue;
     const refs = referencedBy(file);
     if (refs.length > 0) {
       retainMachinery.push(file);
@@ -84687,7 +84762,7 @@ function buildPre10Plan(repoPath) {
     }
     deleteMachinery.push(file);
     const recorded = fileBaseline[file];
-    const installed = computeFileChecksum(fs63.readFileSync(full, "utf8"));
+    const installed = computeFileChecksum(fs64.readFileSync(full, "utf8"));
     if (recorded !== void 0 && installed !== recorded) {
       editedMachinery.push(file);
       residue.push({
@@ -84700,8 +84775,8 @@ function buildPre10Plan(repoPath) {
   }
   let env3 = null;
   const envPath = path72.join(harnessDir, "harness.env");
-  if (fs63.existsSync(envPath)) {
-    const content = fs63.readFileSync(envPath, "utf8");
+  if (fs64.existsSync(envPath)) {
+    const content = fs64.readFileSync(envPath, "utf8");
     if (harnessEnvIsPre10(content) || migrateHarnessEnvContent(content).commentedKeys.length > 0) {
       env3 = migrateHarnessEnvContent(content);
       for (const fn of env3.customFunctions) {
@@ -84726,7 +84801,7 @@ function buildPre10Plan(repoPath) {
   for (const file of composed.keys()) {
     if (MANAGED_SHIM_FILES.includes(file)) continue;
     if (file === "gitignore.template") continue;
-    if (!fs63.existsSync(path72.join(harnessDir, file))) installMissing.push(file);
+    if (!fs64.existsSync(path72.join(harnessDir, file))) installMissing.push(file);
   }
   let phantomVerificationIds = [];
   try {
@@ -84761,13 +84836,13 @@ function applyPre10Plan(repoPath, plan) {
   const harnessDir = getHarnessDir(resolved);
   const effective = plan ?? buildPre10Plan(resolved);
   const backupDir = path72.join(harnessDir, MIGRATE_BACKUP_DIR);
-  fs63.mkdirSync(backupDir, { recursive: true });
+  fs64.mkdirSync(backupDir, { recursive: true });
   const backup = (file) => {
     const src = path72.join(harnessDir, file);
-    if (!fs63.existsSync(src)) return;
+    if (!fs64.existsSync(src)) return;
     const dest = path72.join(backupDir, file);
-    fs63.mkdirSync(path72.dirname(dest), { recursive: true });
-    fs63.copyFileSync(src, dest);
+    fs64.mkdirSync(path72.dirname(dest), { recursive: true });
+    fs64.copyFileSync(src, dest);
   };
   const written = [];
   const deleted = [];
@@ -84775,7 +84850,7 @@ function applyPre10Plan(repoPath, plan) {
   const composed = composeProfileTemplateMap(effective.profile);
   for (const script of effective.deleteLifecycleScripts) {
     backup(script);
-    fs63.rmSync(path72.join(harnessDir, script), { force: true });
+    fs64.rmSync(path72.join(harnessDir, script), { force: true });
     deleted.push(script);
   }
   if (stripLifecycleShimCommands(resolved)) {
@@ -84783,26 +84858,26 @@ function applyPre10Plan(repoPath, plan) {
   }
   for (const file of effective.deleteMachinery) {
     backup(file);
-    fs63.rmSync(path72.join(harnessDir, file), { force: true });
+    fs64.rmSync(path72.join(harnessDir, file), { force: true });
     deleted.push(file);
   }
   for (const doc of effective.retireDocs ?? []) {
     backup(doc);
   }
   const libDir = path72.join(harnessDir, "lib");
-  if (fs63.existsSync(libDir) && fs63.readdirSync(libDir).length === 0) {
-    fs63.rmdirSync(libDir);
+  if (fs64.existsSync(libDir) && fs64.readdirSync(libDir).length === 0) {
+    fs64.rmdirSync(libDir);
     deleted.push("lib/");
   }
   for (const file of effective.installMissing ?? []) {
     const source = composed.get(file);
     if (!source) continue;
     const dest = path72.join(harnessDir, file);
-    if (fs63.existsSync(dest)) continue;
+    if (fs64.existsSync(dest)) continue;
     const rendered = substituteTemplateTokens(readComposedTemplateContent(source), projectName);
-    fs63.mkdirSync(path72.dirname(dest), { recursive: true });
-    fs63.writeFileSync(dest, rendered);
-    if (/\.(sh|mjs)$/.test(file)) fs63.chmodSync(dest, 493);
+    fs64.mkdirSync(path72.dirname(dest), { recursive: true });
+    fs64.writeFileSync(dest, rendered);
+    if (/\.(sh|mjs)$/.test(file)) fs64.chmodSync(dest, 493);
     written.push(file);
   }
   if (effective.phantomVerificationIds.length > 0) {
@@ -84817,7 +84892,7 @@ function applyPre10Plan(repoPath, plan) {
   }
   if (effective.env) {
     backup("harness.env");
-    fs63.writeFileSync(path72.join(harnessDir, "harness.env"), effective.env.content);
+    fs64.writeFileSync(path72.join(harnessDir, "harness.env"), effective.env.content);
     written.push("harness.env");
   }
   const manifest = readManifest(resolved);
@@ -84832,7 +84907,7 @@ function applyPre10Plan(repoPath, plan) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
-  fs63.writeFileSync(
+  fs64.writeFileSync(
     path72.join(harnessDir, MIGRATE_PLAN_FILE),
     JSON.stringify({ ...effective, appliedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
   );
@@ -84855,25 +84930,25 @@ function pendingMigrations(repoPath) {
 function writeMigrationPlan(repoPath, plan) {
   const harnessDir = getHarnessDir(path72.resolve(repoPath));
   const planPath = path72.join(harnessDir, MIGRATE_PLAN_FILE);
-  fs63.mkdirSync(path72.dirname(planPath), { recursive: true });
-  fs63.writeFileSync(planPath, JSON.stringify(plan, null, 2) + "\n");
+  fs64.mkdirSync(path72.dirname(planPath), { recursive: true });
+  fs64.writeFileSync(planPath, JSON.stringify(plan, null, 2) + "\n");
   return planPath;
 }
 function removeMigrationArtifacts(repoPath) {
   const harnessDir = getHarnessDir(path72.resolve(repoPath));
-  fs63.rmSync(path72.join(harnessDir, MIGRATE_DIR), { recursive: true, force: true });
-  fs63.rmSync(path72.join(harnessDir, "MIGRATE-PROMPT.md"), { force: true });
+  fs64.rmSync(path72.join(harnessDir, MIGRATE_DIR), { recursive: true, force: true });
+  fs64.rmSync(path72.join(harnessDir, "MIGRATE-PROMPT.md"), { force: true });
 }
 
 // src/harness/doctor.ts
 function listHarnessShellScripts(harnessDir) {
   const out = [];
   const push = (dir, prefix) => {
-    if (!fs64.existsSync(dir)) return;
-    for (const entry of fs64.readdirSync(dir).sort()) {
+    if (!fs65.existsSync(dir)) return;
+    for (const entry of fs65.readdirSync(dir).sort()) {
       if (!entry.endsWith(".sh")) continue;
       const full = path73.join(dir, entry);
-      if (!fs64.statSync(full).isFile()) continue;
+      if (!fs65.statSync(full).isFile()) continue;
       out.push(prefix ? `${prefix}/${entry}` : entry);
     }
   };
@@ -84900,8 +84975,8 @@ var PRE_1_0_FUNCTION_RE = /^\s*(har_infra_enabled|har_pg|har_node_[a-z_]+|har_pk
 var LEGACY_TRIPLET_RE = /^export\s+HARNESS_[A-Z0-9_]+_PORT_(DEFAULT|SCAN_START|SCAN_END)=/m;
 function detectContract(harnessDir) {
   const envPath = path73.join(harnessDir, "harness.env");
-  if (!fs64.existsSync(envPath)) return "none";
-  const content = fs64.readFileSync(envPath, "utf8");
+  if (!fs65.existsSync(envPath)) return "none";
+  const content = fs65.readFileSync(envPath, "utf8");
   if (PRE_1_0_FUNCTION_RE.test(content) || LEGACY_TRIPLET_RE.test(content)) {
     return "pre-1.0";
   }
@@ -84934,7 +85009,7 @@ function runDoctor(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const findings = [];
   const skipped = /* @__PURE__ */ new Set();
-  if (!fs64.existsSync(harnessDir)) {
+  if (!fs65.existsSync(harnessDir)) {
     return {
       ok: false,
       contract: "none",
@@ -85004,8 +85079,8 @@ function runDoctor(repoPath) {
   let registry2 = null;
   try {
     const stagesPath = path73.join(harnessDir, "stages.json");
-    if (fs64.existsSync(stagesPath)) {
-      const raw = JSON.parse(fs64.readFileSync(stagesPath, "utf8"));
+    if (fs65.existsSync(stagesPath)) {
+      const raw = JSON.parse(fs65.readFileSync(stagesPath, "utf8"));
       if (typeof raw !== "object" || raw === null || !Array.isArray(raw.stages)) {
         throw new Error("stages.json has no `stages` array \u2014 the registry is structurally invalid");
       }
@@ -85037,7 +85112,7 @@ function runDoctor(repoPath) {
       const file = resolveStageFile(harnessDir, stage);
       if (!file) continue;
       const rel = path73.relative(harnessDir, file);
-      if (!fs64.existsSync(file)) {
+      if (!fs65.existsSync(file)) {
         findings.push({
           check: "stage-files",
           severity: contractSeverity,
@@ -85047,7 +85122,7 @@ function runDoctor(repoPath) {
         });
         continue;
       }
-      if (rel.endsWith(".sh") && !(fs64.statSync(file).mode & 73)) {
+      if (rel.endsWith(".sh") && !(fs65.statSync(file).mode & 73)) {
         findings.push({
           check: "stage-files",
           severity: "warning",
@@ -85070,7 +85145,7 @@ function runDoctor(repoPath) {
         continue;
       }
       const file = resolveStageFile(harnessDir, stage);
-      if (file && !fs64.existsSync(file)) {
+      if (file && !fs65.existsSync(file)) {
         findings.push({
           check: "lifecycle-stages",
           severity: contractSeverity,
@@ -85123,7 +85198,7 @@ function runDoctor(repoPath) {
   } else {
     const runtimeRel = path73.join(EJECTED_RUNTIME_DIR, EJECTED_RUNTIME_BUNDLE);
     const runtimePath = path73.join(harnessDir, runtimeRel);
-    if (!fs64.existsSync(runtimePath)) {
+    if (!fs65.existsSync(runtimePath)) {
       findings.push({
         check: "ejected-runtime",
         severity: "error",
@@ -85136,7 +85211,7 @@ function runDoctor(repoPath) {
   for (const entry of listSlotRegistryEntries(repoPath)) {
     if (entry.status === "completed") continue;
     const dir = entry.worktreePath ?? entry.workDir;
-    if (dir && !fs64.existsSync(dir)) {
+    if (dir && !fs65.existsSync(dir)) {
       findings.push({
         check: "slot-registry",
         severity: "warning",
@@ -85147,10 +85222,10 @@ function runDoctor(repoPath) {
     }
   }
   const hooksDir = path73.join(harnessDir, "hooks");
-  if (fs64.existsSync(hooksDir)) {
-    for (const file of fs64.readdirSync(hooksDir).sort()) {
+  if (fs65.existsSync(hooksDir)) {
+    for (const file of fs65.readdirSync(hooksDir).sort()) {
       const full = path73.join(hooksDir, file);
-      if (!fs64.statSync(full).isFile() || !file.endsWith(".sh")) continue;
+      if (!fs65.statSync(full).isFile() || !file.endsWith(".sh")) continue;
       if (!LIFECYCLE_HOOKS.includes(file.replace(/\.sh$/, ""))) {
         findings.push({
           check: "hooks",
@@ -85161,7 +85236,7 @@ function runDoctor(repoPath) {
         });
         continue;
       }
-      if (!(fs64.statSync(full).mode & 73)) {
+      if (!(fs65.statSync(full).mode & 73)) {
         findings.push({
           check: "hooks",
           severity: "warning",
@@ -85176,12 +85251,12 @@ function runDoctor(repoPath) {
     const full = path73.join(harnessDir, rel);
     let content;
     try {
-      content = fs64.readFileSync(full, "utf8");
+      content = fs65.readFileSync(full, "utf8");
     } catch {
       continue;
     }
     for (const machinery of LEGACY_MACHINERY_FILES) {
-      if (fs64.existsSync(path73.join(harnessDir, machinery))) continue;
+      if (fs65.existsSync(path73.join(harnessDir, machinery))) continue;
       const base = machinery.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       const loadRe = new RegExp(
         `(?:\\bsource\\b|\\bbash\\b|\\bexec\\b|(?:^|[;&|(])\\s*\\.\\s)[^\\n#]*${base}`
@@ -85285,7 +85360,7 @@ function summarizeDoctorReport(report) {
 }
 
 // src/harness/migrate-prompt.ts
-var fs65 = __toESM(require("fs"));
+var fs66 = __toESM(require("fs"));
 var path74 = __toESM(require("path"));
 init_paths();
 init_file_ops();
@@ -85400,7 +85475,7 @@ function loadTemplate2() {
   if (!filePath) {
     throw new Error("Migration prompt template not found: migration-prompt.md. Run npm run build.");
   }
-  return fs65.readFileSync(filePath, "utf8");
+  return fs66.readFileSync(filePath, "utf8");
 }
 function buildMigrationPrompt(plan, applied) {
   return loadTemplate2().replace("{{MIGRATION_SECTION}}", buildMigrationSection(plan, applied));
@@ -85414,8 +85489,8 @@ function writeMigrationPrompt(repoPath, content) {
 // src/core/harness.ts
 function listHarnessScripts(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs66.existsSync(harnessDir)) return [];
-  return fs66.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
+  if (!fs67.existsSync(harnessDir)) return [];
+  return fs67.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
 }
 function describeProject(repoPath) {
   const resolved = path75.resolve(repoPath);
@@ -85439,7 +85514,7 @@ function describeProject(repoPath) {
 }
 async function initHarness(options) {
   const repoPath = path75.resolve(options.repoPath);
-  if (!fs66.existsSync(repoPath)) {
+  if (!fs67.existsSync(repoPath)) {
     throw new Error(`Path not found: ${repoPath}`);
   }
   const scaffold = scaffoldHarnessBoilerplate(repoPath, {
@@ -85462,7 +85537,7 @@ async function initHarness(options) {
 async function maintainHarness(options) {
   const repoPath = path75.resolve(options.repoPath);
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs66.existsSync(harnessDir)) {
+  if (!fs67.existsSync(harnessDir)) {
     throw new Error('No .har/ found. Run "har onboard" first.');
   }
   let migration;
@@ -85540,7 +85615,7 @@ function addPlugin(repoPath, pluginId, options = {}) {
 }
 
 // src/harness/adaptation-prompt.ts
-var fs67 = __toESM(require("fs"));
+var fs68 = __toESM(require("fs"));
 var path76 = __toESM(require("path"));
 var readline5 = __toESM(require("readline"));
 
@@ -85632,7 +85707,7 @@ function loadTemplate3(name) {
   if (!filePath) {
     throw new Error(`Adaptation prompt template not found: ${name}. Run npm run build.`);
   }
-  return fs67.readFileSync(filePath, "utf8");
+  return fs68.readFileSync(filePath, "utf8");
 }
 function applyProfilePlaceholders(content, profile) {
   return content.replace(/\{\{PROFILE\}\}/g, profile).replace(/\{\{PROFILE_HINT\}\}/g, PROFILE_HINTS[profile]);
@@ -85710,7 +85785,7 @@ async function offerAdaptationPromptClipboard(content, options = {}) {
 }
 
 // src/harness/cursor-rule.ts
-var fs68 = __toESM(require("fs"));
+var fs69 = __toESM(require("fs"));
 var path77 = __toESM(require("path"));
 var readline6 = __toESM(require("readline"));
 init_file_ops();
@@ -85721,17 +85796,17 @@ function getCursorRulePath(repoPath) {
   return path77.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
 }
 function isCursorWorkspace(repoPath) {
-  return fs68.existsSync(path77.join(repoPath, ".cursor"));
+  return fs69.existsSync(path77.join(repoPath, ".cursor"));
 }
 function cursorRuleExists(repoPath) {
-  return fs68.existsSync(getCursorRulePath(repoPath));
+  return fs69.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 = fs68.readFileSync(templatePath, "utf8");
+  const content = fs69.readFileSync(templatePath, "utf8");
   writeFileSafe(getCursorRulePath(repoPath), content);
 }
 async function handleCursorRule(options) {
@@ -86564,7 +86639,7 @@ init_work_units();
 init_manifest();
 
 // src/core/cleanup-service.ts
-var fs70 = __toESM(require("fs"));
+var fs71 = __toESM(require("fs"));
 var os23 = __toESM(require("os"));
 var path81 = __toESM(require("path"));
 var import_child_process20 = require("child_process");
@@ -86663,7 +86738,7 @@ function classifySlotCandidate(repoPath, projectName, slot, options) {
   return candidate;
 }
 function resolveRepoForWorktree(worktreePath) {
-  if (!fs70.existsSync(worktreePath)) return void 0;
+  if (!fs71.existsSync(worktreePath)) return void 0;
   const commonDir = runGit3(worktreePath, "rev-parse --git-common-dir");
   if (!commonDir) return void 0;
   const gitRoot = path81.resolve(worktreePath, commonDir, "..");
@@ -86672,9 +86747,9 @@ function resolveRepoForWorktree(worktreePath) {
 }
 function discoverOrphanWorktrees(knownPaths) {
   const worktreesRoot = getWorktreesRoot();
-  if (!fs70.existsSync(worktreesRoot)) return [];
+  if (!fs71.existsSync(worktreesRoot)) return [];
   const orphans = [];
-  for (const entry of fs70.readdirSync(worktreesRoot, { withFileTypes: true })) {
+  for (const entry of fs71.readdirSync(worktreesRoot, { withFileTypes: true })) {
     if (!entry.isDirectory() || !entry.name.includes("-har-agent-")) continue;
     const worktreePath = path81.resolve(path81.join(worktreesRoot, entry.name));
     if (knownPaths.has(worktreePath)) continue;
@@ -86701,7 +86776,7 @@ async function discoverCleanupCandidates(options = {}) {
   const candidates = [];
   const knownWorktreePaths = /* @__PURE__ */ new Set();
   for (const repoPath of repoPaths) {
-    if (!fs70.existsSync(repoPath) || !readManifest(repoPath)) continue;
+    if (!fs71.existsSync(repoPath) || !readManifest(repoPath)) continue;
     const harnessRoot = resolveHarnessRoot(repoPath);
     const canonicalRepo = canonicalizeControlRepoPath(harnessRoot);
     const status = collectEnvironmentStatus(harnessRoot);
@@ -86814,7 +86889,7 @@ async function executeCleanupCandidates(candidates, options = {}) {
         continue;
       }
       if (candidate.kind === "orphan_worktree" && candidate.worktreePath) {
-        if (fs70.existsSync(candidate.worktreePath)) {
+        if (fs71.existsSync(candidate.worktreePath)) {
           const repoRoot = candidate.repoPath !== getWorktreesRoot() ? candidate.repoPath : resolveRepoForWorktree(candidate.worktreePath);
           if (repoRoot) {
             try {
@@ -86825,8 +86900,8 @@ async function executeCleanupCandidates(candidates, options = {}) {
             } catch {
             }
           }
-          if (fs70.existsSync(candidate.worktreePath)) {
-            fs70.rmSync(candidate.worktreePath, { recursive: true, force: true });
+          if (fs71.existsSync(candidate.worktreePath)) {
+            fs71.rmSync(candidate.worktreePath, { recursive: true, force: true });
           }
         }
         outcomes.push({ candidate, ok: true });
@@ -86972,7 +87047,7 @@ function warnIfDockerUnavailable(status = detectDockerStatus()) {
 }
 
 // src/core/onboarding-preferences.ts
-var fs71 = __toESM(require("fs"));
+var fs72 = __toESM(require("fs"));
 var os24 = __toESM(require("os"));
 var path82 = __toESM(require("path"));
 init_schema2();
@@ -86985,8 +87060,8 @@ function getOnboardingPreferencesPath() {
 function readOnboardingPreferences() {
   const preferencePath = getOnboardingPreferencesPath();
   try {
-    if (!fs71.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
-    return OnboardingPreferencesSchema.parse(JSON.parse(fs71.readFileSync(preferencePath, "utf8")));
+    if (!fs72.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
+    return OnboardingPreferencesSchema.parse(JSON.parse(fs72.readFileSync(preferencePath, "utf8")));
   } catch {
     return OnboardingPreferencesSchema.parse({});
   }
@@ -87011,8 +87086,8 @@ function writeOnboardingPreferences(overrides) {
   };
   const parsed = OnboardingPreferencesSchema.parse(preference);
   const preferencePath = getOnboardingPreferencesPath();
-  fs71.mkdirSync(path82.dirname(preferencePath), { recursive: true });
-  fs71.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
+  fs72.mkdirSync(path82.dirname(preferencePath), { recursive: true });
+  fs72.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return parsed;
 }
@@ -87640,7 +87715,7 @@ async function handleAddPlugin(argv) {
     console.error(`  Docs: ${result.docsPath}`);
     console.error("");
     info(`Adaptation prompt saved to ${result.adaptPromptPath}`);
-    const promptContent = fs72.readFileSync(path83.join(repoPath, result.adaptPromptPath), "utf8");
+    const promptContent = fs73.readFileSync(path83.join(repoPath, result.adaptPromptPath), "utf8");
     await offerAdaptationPromptClipboard(promptContent, { fileLabel: result.adaptPromptPath });
   } catch (err) {
     error(err.message);
@@ -88185,7 +88260,7 @@ init_portal_targets();
 init_control_config();
 
 // src/core/portal-connect.ts
-var fs73 = __toESM(require("fs"));
+var fs74 = __toESM(require("fs"));
 var path84 = __toESM(require("path"));
 var import_crypto2 = require("crypto");
 init_control_repo_path();
@@ -88356,7 +88431,7 @@ function remainingConnections(connections, usedAliases) {
 init_portal_targets();
 function attachRepoIfPresent(alias, repoPath) {
   const resolved = path84.resolve(repoPath ?? ".");
-  if (!fs73.existsSync(resolved)) return null;
+  if (!fs74.existsSync(resolved)) return null;
   const canonical = canonicalizeControlRepoPath(resolved);
   attachRepoPortalTarget(canonical, alias);
   recordRepoForControlSync(canonical);
@@ -88424,7 +88499,7 @@ async function runPortalConnect(input) {
 }
 function listRegisteredReposForConnect(repoPath) {
   const resolved = repoPath ? path84.resolve(repoPath) : null;
-  const current = resolved && fs73.existsSync(resolved) ? canonicalizeControlRepoPath(resolved) : null;
+  const current = resolved && fs74.existsSync(resolved) ? canonicalizeControlRepoPath(resolved) : null;
   return [.../* @__PURE__ */ new Set([...current ? [current] : [], ...listRegisteredRepos()])];
 }
 
@@ -88740,7 +88815,7 @@ init_control_port();
 init_control_sync();
 
 // src/core/control-sync-selection.ts
-var fs74 = __toESM(require("fs"));
+var fs75 = __toESM(require("fs"));
 var os25 = __toESM(require("os"));
 var path85 = __toESM(require("path"));
 init_control_repo_path();
@@ -88753,8 +88828,8 @@ function getSelectionPath() {
 function readSyncSelection() {
   const selectionPath = getSelectionPath();
   try {
-    if (!fs74.existsSync(selectionPath)) return null;
-    const parsed = JSON.parse(fs74.readFileSync(selectionPath, "utf8"));
+    if (!fs75.existsSync(selectionPath)) return null;
+    const parsed = JSON.parse(fs75.readFileSync(selectionPath, "utf8"));
     if (!Array.isArray(parsed.repos)) return null;
     return parsed.repos.map((repoPath) => canonicalizeControlRepoPath(repoPath));
   } catch {
@@ -88764,8 +88839,8 @@ function readSyncSelection() {
 function writeSyncSelection(repos) {
   const selectionPath = getSelectionPath();
   const canonical = Array.from(new Set(repos.map((repoPath) => canonicalizeControlRepoPath(repoPath))));
-  fs74.mkdirSync(path85.dirname(selectionPath), { recursive: true });
-  fs74.writeFileSync(selectionPath, JSON.stringify({ repos: canonical }, null, 2) + "\n");
+  fs75.mkdirSync(path85.dirname(selectionPath), { recursive: true });
+  fs75.writeFileSync(selectionPath, JSON.stringify({ repos: canonical }, null, 2) + "\n");
 }
 function resolveSyncSelection(input) {
   const { discovered, stored, forceSelect, isTTY } = input;
@@ -88792,7 +88867,7 @@ function resolveSyncSelection(input) {
 }
 
 // src/core/control-unregister.ts
-var fs75 = __toESM(require("fs"));
+var fs76 = __toESM(require("fs"));
 var path86 = __toESM(require("path"));
 init_control_repo_path();
 init_control_registry();
@@ -88805,7 +88880,7 @@ function listUnregisterWorktreeCandidates(repoPath) {
   const add = (partial2) => {
     const resolved = path86.resolve(partial2.worktreePath);
     if (!resolved || resolved === harnessRoot) return;
-    const exists = partial2.exists ?? fs75.existsSync(resolved);
+    const exists = partial2.exists ?? fs76.existsSync(resolved);
     const prev = byPath.get(resolved);
     if (prev) {
       byPath.set(resolved, {
@@ -88919,28 +88994,28 @@ async function teardownWorktrees(repoPath, candidates, dryRun) {
         trigger: "cli"
       });
       if (result.code !== 0) {
-        if (fs75.existsSync(candidate.worktreePath)) {
-          fs75.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs76.existsSync(candidate.worktreePath)) {
+          fs76.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs75.existsSync(candidate.worktreePath),
-        error: result.code !== 0 && fs75.existsSync(candidate.worktreePath) ? result.stderr : void 0
+        deleted: !fs76.existsSync(candidate.worktreePath),
+        error: result.code !== 0 && fs76.existsSync(candidate.worktreePath) ? result.stderr : void 0
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       try {
-        if (fs75.existsSync(candidate.worktreePath)) {
-          fs75.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs76.existsSync(candidate.worktreePath)) {
+          fs76.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       } catch {
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs75.existsSync(candidate.worktreePath),
+        deleted: !fs76.existsSync(candidate.worktreePath),
         error: message
       });
     }
@@ -89003,13 +89078,13 @@ init_control_config();
 init_control_registry();
 
 // src/core/harness-scrub.ts
-var fs76 = __toESM(require("fs"));
+var fs77 = __toESM(require("fs"));
 var path87 = __toESM(require("path"));
 var HARNESS_SCRUB_DIRS = ["runs", "validations", "commit-bindings", "state", "slots"];
 function scrubLocalHarnessDirs(repoPath) {
   const results = [];
   const resolved = path87.resolve(repoPath);
-  if (!fs76.existsSync(resolved)) {
+  if (!fs77.existsSync(resolved)) {
     for (const directory of HARNESS_SCRUB_DIRS) {
       results.push({
         path: path87.join(resolved, ".har", directory),
@@ -89022,23 +89097,23 @@ function scrubLocalHarnessDirs(repoPath) {
   }
   for (const directory of HARNESS_SCRUB_DIRS) {
     const target = path87.join(resolved, ".har", directory);
-    if (!fs76.existsSync(target)) {
+    if (!fs77.existsSync(target)) {
       results.push({ path: target, directory, deleted: true });
       continue;
     }
     try {
-      fs76.rmSync(target, { recursive: true, force: true });
+      fs77.rmSync(target, { recursive: true, force: true });
       results.push({
         path: target,
         directory,
-        deleted: !fs76.existsSync(target),
-        error: fs76.existsSync(target) ? "failed to remove directory" : void 0
+        deleted: !fs77.existsSync(target),
+        error: fs77.existsSync(target) ? "failed to remove directory" : void 0
       });
     } catch (err) {
       results.push({
         path: target,
         directory,
-        deleted: !fs76.existsSync(target),
+        deleted: !fs77.existsSync(target),
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -89725,7 +89800,7 @@ var path90 = __toESM(require("path"));
 init_hooks();
 
 // src/core/claude-hooks.ts
-var fs77 = __toESM(require("fs"));
+var fs78 = __toESM(require("fs"));
 var path89 = __toESM(require("path"));
 init_paths();
 var CLAUDE_GUARD_RELATIVE_PATH = ".har/hooks/claude-worktree-guard.sh";
@@ -89738,8 +89813,8 @@ function isHarGuardEntry(entry) {
   );
 }
 function readSettings(settingsPath) {
-  if (!fs77.existsSync(settingsPath)) return {};
-  const raw = fs77.readFileSync(settingsPath, "utf8").trim();
+  if (!fs78.existsSync(settingsPath)) return {};
+  const raw = fs78.readFileSync(settingsPath, "utf8").trim();
   if (raw === "") return {};
   const parsed = JSON.parse(raw);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -89748,8 +89823,8 @@ function readSettings(settingsPath) {
   return parsed;
 }
 function writeSettings(settingsPath, settings) {
-  fs77.mkdirSync(path89.dirname(settingsPath), { recursive: true });
-  fs77.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs78.mkdirSync(path89.dirname(settingsPath), { recursive: true });
+  fs78.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function installClaudeGuard(repoPath) {
   const templatePath = resolveTemplateFile("claude-worktree-guard.sh.template");
@@ -89757,9 +89832,9 @@ function installClaudeGuard(repoPath) {
     throw new Error("Guard template not found (claude-worktree-guard.sh.template). Run npm run build.");
   }
   const guardScript = path89.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  fs77.mkdirSync(path89.dirname(guardScript), { recursive: true });
-  fs77.copyFileSync(templatePath, guardScript);
-  fs77.chmodSync(guardScript, 493);
+  fs78.mkdirSync(path89.dirname(guardScript), { recursive: true });
+  fs78.copyFileSync(templatePath, guardScript);
+  fs78.chmodSync(guardScript, 493);
   const settingsPath = path89.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
   const settings = readSettings(settingsPath);
   const hooks = settings.hooks ?? {};
@@ -89775,14 +89850,14 @@ function installClaudeGuard(repoPath) {
 function uninstallClaudeGuard(repoPath) {
   let removed = false;
   const guardScript = path89.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  if (fs77.existsSync(guardScript)) {
-    fs77.rmSync(guardScript);
+  if (fs78.existsSync(guardScript)) {
+    fs78.rmSync(guardScript);
     removed = true;
     const parent = path89.dirname(guardScript);
-    if (fs77.existsSync(parent) && fs77.readdirSync(parent).length === 0) fs77.rmdirSync(parent);
+    if (fs78.existsSync(parent) && fs78.readdirSync(parent).length === 0) fs78.rmdirSync(parent);
   }
   const settingsPath = path89.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (fs77.existsSync(settingsPath)) {
+  if (fs78.existsSync(settingsPath)) {
     const settings = readSettings(settingsPath);
     const preToolUse = settings.hooks?.PreToolUse;
     if (preToolUse) {
@@ -89808,7 +89883,7 @@ function uninstallClaudeGuard(repoPath) {
 }
 function claudeGuardInstalled(repoPath) {
   const settingsPath = path89.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (!fs77.existsSync(settingsPath)) return false;
+  if (!fs78.existsSync(settingsPath)) return false;
   try {
     const settings = readSettings(settingsPath);
     return (settings.hooks?.PreToolUse ?? []).some(isHarGuardEntry);
@@ -97050,13 +97125,13 @@ init_runs();
 var path92 = __toESM(require("path"));
 
 // src/harness/line-create.ts
-var fs78 = __toESM(require("fs"));
+var fs79 = __toESM(require("fs"));
 var path91 = __toESM(require("path"));
 init_paths();
 init_schema2();
 var LINE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 function renderSkeleton(templatePath, tokens) {
-  let content = fs78.readFileSync(templatePath, "utf8");
+  let content = fs79.readFileSync(templatePath, "utf8");
   for (const [token, value] of Object.entries(tokens)) {
     content = content.replace(new RegExp(token, "g"), value);
   }
@@ -97075,7 +97150,7 @@ function createLine(repoPath, options) {
   }
   const lineDir = path91.join(resolved, LOCAL_LINES_DIR, id);
   const lineDirRel2 = `${LOCAL_LINES_DIR}/${id}`;
-  if (fs78.existsSync(lineDir) && !options.force) {
+  if (fs79.existsSync(lineDir) && !options.force) {
     throw new Error(`Line already exists: ${lineDirRel2}/. Use --force to overwrite.`);
   }
   const stationIds = options.stations?.length ? options.stations : ["S1", "S2"];
@@ -97149,9 +97224,9 @@ function createLine(repoPath, options) {
   const filesWritten = [];
   const write = (rel, content, executable = false) => {
     const abs = path91.join(lineDir, rel);
-    fs78.mkdirSync(path91.dirname(abs), { recursive: true });
-    fs78.writeFileSync(abs, content);
-    if (executable) fs78.chmodSync(abs, 493);
+    fs79.mkdirSync(path91.dirname(abs), { recursive: true });
+    fs79.writeFileSync(abs, content);
+    if (executable) fs79.chmodSync(abs, 493);
     filesWritten.push(`${lineDirRel2}/${rel}`);
   };
   write("line.manifest.json", `${JSON.stringify(manifest, null, 2)}
@@ -99224,13 +99299,13 @@ var lineCommand = {
 var path98 = __toESM(require("path"));
 
 // src/harness/plugin-create.ts
-var fs79 = __toESM(require("fs"));
+var fs80 = __toESM(require("fs"));
 var path97 = __toESM(require("path"));
 init_paths();
 init_schema2();
 var PLUGIN_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 function renderSkeleton2(templatePath, tokens) {
-  let content = fs79.readFileSync(templatePath, "utf8");
+  let content = fs80.readFileSync(templatePath, "utf8");
   for (const [token, value] of Object.entries(tokens)) {
     content = content.replace(new RegExp(token, "g"), value);
   }
@@ -99255,7 +99330,7 @@ function createLocalPlugin(repoPath, options) {
   }
   const pluginDir = path97.join(resolved, LOCAL_PLUGINS_DIR, id);
   const pluginDirRel = `${LOCAL_PLUGINS_DIR}/${id}`;
-  if (fs79.existsSync(pluginDir) && !options.force) {
+  if (fs80.existsSync(pluginDir) && !options.force) {
     throw new Error(`Plugin already exists: ${pluginDirRel}/. Use --force to overwrite.`);
   }
   const description = options.description ?? `Custom ${kind} stage (local plugin: ${id})`;
@@ -99298,9 +99373,9 @@ function createLocalPlugin(repoPath, options) {
   const filesWritten = [];
   const write = (rel, content, executable = false) => {
     const abs = path97.join(pluginDir, rel);
-    fs79.mkdirSync(path97.dirname(abs), { recursive: true });
-    fs79.writeFileSync(abs, content);
-    if (executable) fs79.chmodSync(abs, 493);
+    fs80.mkdirSync(path97.dirname(abs), { recursive: true });
+    fs80.writeFileSync(abs, content);
+    if (executable) fs80.chmodSync(abs, 493);
     filesWritten.push(`${pluginDirRel}/${rel}`);
   };
   write("template.manifest.json", `${JSON.stringify(manifest, null, 2)}
@@ -99800,16 +99875,16 @@ async function runCli() {
 }
 
 // src/core/prefer-local-runtime.ts
-var fs80 = __toESM(require("fs"));
+var fs81 = __toESM(require("fs"));
 var path100 = __toESM(require("path"));
 var import_child_process22 = require("child_process");
 init_package_version();
 var PACKAGE_NAME = "@osfactory/har";
 function readPackageJson(dir) {
   const pkgPath = path100.join(dir, "package.json");
-  if (!fs80.existsSync(pkgPath)) return null;
+  if (!fs81.existsSync(pkgPath)) return null;
   try {
-    return JSON.parse(fs80.readFileSync(pkgPath, "utf8"));
+    return JSON.parse(fs81.readFileSync(pkgPath, "utf8"));
   } catch {
     return null;
   }
@@ -99823,11 +99898,11 @@ function resolveHarEntry(pkgDir, pkg) {
     rel = pkg.bin;
   }
   const entry = path100.resolve(pkgDir, rel);
-  return fs80.existsSync(entry) ? entry : null;
+  return fs81.existsSync(entry) ? entry : null;
 }
 function sameFile(a, b2) {
   try {
-    return fs80.realpathSync(a) === fs80.realpathSync(b2);
+    return fs81.realpathSync(a) === fs81.realpathSync(b2);
   } catch {
     return path100.resolve(a) === path100.resolve(b2);
   }