@osfactory/har 0.46.0 → 0.46.2

package/dist/index.js

@@ -553,8 +553,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path61, errorMaps, issueData } = params;
-      const fullPath = [...path61, ...issueData.path || []];
+      const { data, path: path62, errorMaps, issueData } = params;
+      const fullPath = [...path62, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -862,11 +862,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path61, key) {
+      constructor(parent, value, path62, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path61;
+        this._path = path62;
         this._key = key;
       }
       get path() {
@@ -28010,6 +28010,109 @@ Compared to other leading proprietary and open-weights models Command A delivers
   }
 });
 
+// packages/schemas/src/cursor-pricing-overlay.ts
+function isCursorNativeModel(modelId) {
+  const id = modelId.toLowerCase();
+  const normalized = id.startsWith("cursor-") ? id.slice("cursor-".length) : id;
+  return normalized.startsWith("composer") || normalized.includes("grok-4.5");
+}
+function estimateCursorNativeCostUsd(usage2, modelId) {
+  if (!isCursorNativeModel(modelId)) return null;
+  try {
+    const result = ve(usage2, modelId, { provider: CURSOR_PRICING_PROVIDER });
+    return result?.total_price ?? null;
+  } catch {
+    return null;
+  }
+}
+var CURSOR_PRICING_PROVIDER;
+var init_cursor_pricing_overlay = __esm({
+  "packages/schemas/src/cursor-pricing-overlay.ts"() {
+    "use strict";
+    init_dist();
+    CURSOR_PRICING_PROVIDER = {
+      id: "cursor",
+      name: "Cursor",
+      pricing_urls: ["https://cursor.com/docs/models-and-pricing"],
+      api_pattern: String.raw`https://(.*\.)?cursor\.(com|sh)`,
+      model_match: {
+        or: [{ starts_with: "composer" }, { contains: "grok-4.5" }]
+      },
+      provider_match: { contains: "cursor" },
+      models: [
+        {
+          id: "composer-2.5-fast",
+          name: "Composer 2.5 (Fast)",
+          description: "Fast-mode variant of Composer 2.5.",
+          match: {
+            or: [
+              { equals: "composer-2.5-fast" },
+              { equals: "cursor-composer-2.5-fast" }
+            ]
+          },
+          prices: {
+            input_mtok: 3,
+            cache_read_mtok: 0.5,
+            output_mtok: 15
+          }
+        },
+        {
+          id: "composer-2.5",
+          name: "Composer 2.5",
+          description: "Cursor's own agentic coding model.",
+          match: {
+            or: [
+              { equals: "composer-2.5" },
+              { equals: "cursor-composer-2.5" }
+            ]
+          },
+          prices: {
+            input_mtok: 0.5,
+            cache_read_mtok: 0.2,
+            output_mtok: 2.5
+          }
+        },
+        {
+          id: "grok-4.5-fast",
+          name: "Grok 4.5 (Fast)",
+          description: "Fast-mode variant of Grok 4.5.",
+          match: {
+            or: [
+              { equals: "grok-4.5-fast" },
+              { equals: "grok-4.5-high-fast" },
+              { equals: "cursor-grok-4.5-high-fast" },
+              { equals: "cursor-grok-4.5-fast" }
+            ]
+          },
+          prices: {
+            input_mtok: 4,
+            cache_read_mtok: 1,
+            output_mtok: 18
+          }
+        },
+        {
+          id: "grok-4.5",
+          name: "Grok 4.5",
+          description: "Jointly trained by Cursor and SpaceXAI for long-running coding and knowledge work.",
+          match: {
+            or: [
+              { equals: "grok-4.5" },
+              { equals: "grok-4.5-high" },
+              { equals: "cursor-grok-4.5-high" },
+              { equals: "cursor-grok-4.5" }
+            ]
+          },
+          prices: {
+            input_mtok: 2,
+            cache_read_mtok: 0.5,
+            output_mtok: 6
+          }
+        }
+      ]
+    };
+  }
+});
+
 // packages/schemas/src/usage-pricing.ts
 function num(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
@@ -28056,6 +28159,10 @@ function estimateModelCostUsd(modelId, totals, agentTool) {
       continue;
     }
   }
+  for (const candidate of pricingModelCandidates(modelId)) {
+    const overlay = estimateCursorNativeCostUsd(usage2, candidate);
+    if (overlay != null) return overlay;
+  }
   return null;
 }
 function enrichUsageWithPricing(usage2) {
@@ -28095,6 +28202,7 @@ var init_usage_pricing = __esm({
   "packages/schemas/src/usage-pricing.ts"() {
     "use strict";
     init_dist();
+    init_cursor_pricing_overlay();
   }
 });
 
@@ -32522,32 +32630,32 @@ __export(otel_hooks_exports, {
 });
 function getOtelHooksHome() {
   if (process.env.HAR_OTEL_HOOKS_HOME) {
-    return path46.resolve(process.env.HAR_OTEL_HOOKS_HOME);
+    return path47.resolve(process.env.HAR_OTEL_HOOKS_HOME);
   }
-  return path46.join(os15.homedir(), ".har", "otel-hooks");
+  return path47.join(os15.homedir(), ".har", "otel-hooks");
 }
 function getOtelHooksConfigPath(hooksHome = getOtelHooksHome()) {
-  return path46.join(hooksHome, "otel_config.json");
+  return path47.join(hooksHome, "otel_config.json");
 }
 function getOtelHooksWrapperPath(hooksHome = getOtelHooksHome()) {
-  return path46.join(hooksHome, "run-otel-hook.sh");
+  return path47.join(hooksHome, "run-otel-hook.sh");
 }
 function getOtelHooksStateDir(hooksHome = getOtelHooksHome()) {
-  return path46.join(hooksHome, "state");
+  return path47.join(hooksHome, "state");
 }
 function localOtelHookBin(hooksHome) {
-  return path46.join(hooksHome, "node_modules", ".bin", "otel-hook");
+  return path47.join(hooksHome, "node_modules", ".bin", "otel-hook");
 }
 function installedPackageVersion(hooksHome) {
   try {
-    const pkgPath = path46.join(
+    const pkgPath = path47.join(
       hooksHome,
       "node_modules",
       "@osfactory",
       "otel-hook",
       "package.json"
     );
-    const pkg = JSON.parse(fs40.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs41.readFileSync(pkgPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -32598,15 +32706,15 @@ function buildOtelHooksConfig(options) {
   };
 }
 function writeOtelHooksConfig(config2, hooksHome = getOtelHooksHome()) {
-  fs40.mkdirSync(hooksHome, { recursive: true });
+  fs41.mkdirSync(hooksHome, { recursive: true });
   const configPath = getOtelHooksConfigPath(hooksHome);
-  fs40.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+  fs41.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
 `);
   return configPath;
 }
 function writeOtelHooksWrapper(otelHookCommand, hooksHome = getOtelHooksHome()) {
-  fs40.mkdirSync(hooksHome, { recursive: true });
-  fs40.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
+  fs41.mkdirSync(hooksHome, { recursive: true });
+  fs41.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
   const wrapperPath = getOtelHooksWrapperPath(hooksHome);
   const configPath = getOtelHooksConfigPath(hooksHome);
   const stateDir = getOtelHooksStateDir(hooksHome);
@@ -32618,9 +32726,9 @@ exec "${otelHookCommand}" run \\
   --state-dir "${stateDir}" \\
   "$@"
 `;
-  fs40.writeFileSync(wrapperPath, script, { mode: 493 });
+  fs41.writeFileSync(wrapperPath, script, { mode: 493 });
   try {
-    fs40.chmodSync(wrapperPath, 493);
+    fs41.chmodSync(wrapperPath, 493);
   } catch {
   }
   return wrapperPath;
@@ -32633,11 +32741,11 @@ function commandExists2(command2) {
 }
 function resolveOtelHookCommand(hooksHome) {
   const local = localOtelHookBin(hooksHome);
-  if (fs40.existsSync(local)) return local;
+  if (fs41.existsSync(local)) return local;
   return null;
 }
 function tryInstallPackage(hooksHome) {
-  fs40.mkdirSync(hooksHome, { recursive: true });
+  fs41.mkdirSync(hooksHome, { recursive: true });
   if (!commandExists2("npm")) {
     return {
       ok: false,
@@ -32649,7 +32757,7 @@ function tryInstallPackage(hooksHome) {
     ["install", "--prefix", hooksHome, "--no-fund", "--no-audit", OTEL_HOOKS_PACKAGE],
     { encoding: "utf8", timeout: 18e4 }
   );
-  if (result.status === 0 && fs40.existsSync(localOtelHookBin(hooksHome))) {
+  if (result.status === 0 && fs41.existsSync(localOtelHookBin(hooksHome))) {
     return { ok: true, detail: `npm install --prefix ${hooksHome} ${OTEL_HOOKS_PACKAGE}` };
   }
   return {
@@ -32675,14 +32783,14 @@ function uninstallLegacyPythonHooks(hooksHome) {
 }
 function removeLegacyPythonArtifacts(hooksHome) {
   const legacyPaths = [
-    path46.join(hooksHome, ".venv"),
-    path46.join(hooksHome, "otel_config.yaml"),
-    path46.join(hooksHome, "venv")
+    path47.join(hooksHome, ".venv"),
+    path47.join(hooksHome, "otel_config.yaml"),
+    path47.join(hooksHome, "venv")
   ];
   for (const target of legacyPaths) {
     try {
-      if (fs40.existsSync(target)) {
-        fs40.rmSync(target, { recursive: true, force: true });
+      if (fs41.existsSync(target)) {
+        fs41.rmSync(target, { recursive: true, force: true });
       }
     } catch {
     }
@@ -32723,10 +32831,10 @@ function runSetupProvider(providerId, otelHookCommand, wrapperPath) {
   };
 }
 function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
-  if (!fs40.existsSync(filePath)) return false;
+  if (!fs41.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs40.readFileSync(filePath, "utf8");
+    raw = fs41.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -32773,15 +32881,15 @@ function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
     return changed;
   };
   if (!walk(parsed)) return false;
-  fs40.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs41.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
-  if (!fs40.existsSync(filePath)) return false;
+  if (!fs41.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs40.readFileSync(filePath, "utf8");
+    raw = fs41.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -32816,21 +32924,21 @@ function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
     }
   }
   if (!changed) return false;
-  fs40.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs41.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function rewriteKnownHookRegistrations(wrapperPath) {
   const home = os15.homedir();
   const candidates = [
-    path46.join(home, ".cursor", "hooks.json"),
-    path46.join(home, ".claude", "settings.json"),
-    path46.join(home, ".codex", "hooks.json")
+    path47.join(home, ".cursor", "hooks.json"),
+    path47.join(home, ".claude", "settings.json"),
+    path47.join(home, ".codex", "hooks.json")
   ];
   for (const filePath of candidates) {
     try {
       rewriteHookCommandsToWrapper(filePath, wrapperPath);
-      if (filePath.endsWith(`${path46.sep}.cursor${path46.sep}hooks.json`)) {
+      if (filePath.endsWith(`${path47.sep}.cursor${path47.sep}hooks.json`)) {
         pruneLegacyCursorHookEvents(filePath, wrapperPath);
       }
     } catch {
@@ -32846,7 +32954,7 @@ function ensureOtelHooks(options) {
   const hooksHome = getOtelHooksHome();
   const errors = [];
   const providersSetup = [];
-  fs40.mkdirSync(hooksHome, { recursive: true });
+  fs41.mkdirSync(hooksHome, { recursive: true });
   let otelHookCommand = resolveOtelHookCommand(hooksHome);
   const needsInstall = !otelHookCommand || installedPackageVersion(hooksHome) !== pinnedVersion();
   if (needsInstall) {
@@ -32940,14 +33048,14 @@ function ensureOtelHooks(options) {
 function disableOtelHooksExport() {
   return writeOtelHooksConfig(buildOtelHooksConfig({ enabled: false }));
 }
-var import_child_process10, fs40, os15, path46, OTEL_HOOKS_PACKAGE, OTEL_HOOKS_PROVIDERS, OTEL_HOOKS_AGENTS, LEGACY_CURSOR_ONLY_HOOK_EVENTS;
+var import_child_process10, fs41, os15, path47, OTEL_HOOKS_PACKAGE, OTEL_HOOKS_PROVIDERS, OTEL_HOOKS_AGENTS, LEGACY_CURSOR_ONLY_HOOK_EVENTS;
 var init_otel_hooks = __esm({
   "src/core/otel-hooks.ts"() {
     "use strict";
     import_child_process10 = require("child_process");
-    fs40 = __toESM(require("fs"));
+    fs41 = __toESM(require("fs"));
     os15 = __toESM(require("os"));
-    path46 = __toESM(require("path"));
+    path47 = __toESM(require("path"));
     init_control_config();
     init_telemetry_config();
     OTEL_HOOKS_PACKAGE = "@osfactory/otel-hook@0.1.2";
@@ -34063,15 +34171,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path61 = [graph[toModel].parent, toModel];
+      const path62 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path61.unshift(graph[cur].parent);
+        path62.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path61;
+      fn.conversion = path62;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -40001,7 +40109,7 @@ var require_iso2022 = __commonJS({
 // node_modules/chardet/index.js
 var require_chardet = __commonJS({
   "node_modules/chardet/index.js"(exports2, module2) {
-    var fs47 = require("fs");
+    var fs48 = require("fs");
     var utf8 = require_utf8();
     var unicode = require_unicode();
     var mbcs = require_mbcs();
@@ -40075,28 +40183,28 @@ var require_chardet = __commonJS({
       var fd;
       var handler = function(err, buffer) {
         if (fd) {
-          fs47.closeSync(fd);
+          fs48.closeSync(fd);
         }
         if (err) return cb(err, null);
         cb(null, self.detect(buffer, opts));
       };
       if (opts && opts.sampleSize) {
-        fd = fs47.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs47.read(fd, sample, 0, opts.sampleSize, null, function(err) {
+        fd = fs48.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
+        fs48.read(fd, sample, 0, opts.sampleSize, null, function(err) {
           handler(err, sample);
         });
         return;
       }
-      fs47.readFile(filepath, handler);
+      fs48.readFile(filepath, handler);
     };
     module2.exports.detectFileSync = function(filepath, opts) {
       if (opts && opts.sampleSize) {
-        var fd = fs47.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
-        fs47.readSync(fd, sample2, 0, opts.sampleSize);
-        fs47.closeSync(fd);
+        var fd = fs48.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
+        fs48.readSync(fd, sample2, 0, opts.sampleSize);
+        fs48.closeSync(fd);
         return self.detect(sample2, opts);
       }
-      return self.detect(fs47.readFileSync(filepath), opts);
+      return self.detect(fs48.readFileSync(filepath), opts);
     };
     module2.exports.detectAll = function(buffer, opts) {
       if (typeof opts !== "object") {
@@ -43561,16 +43669,16 @@ var require_os_tmpdir = __commonJS({
     var isWindows = process.platform === "win32";
     var trailingSlashRe = isWindows ? /[^:]\\$/ : /.\/$/;
     module2.exports = function() {
-      var path61;
+      var path62;
       if (isWindows) {
-        path61 = process.env.TEMP || process.env.TMP || (process.env.SystemRoot || process.env.windir) + "\\temp";
+        path62 = process.env.TEMP || process.env.TMP || (process.env.SystemRoot || process.env.windir) + "\\temp";
       } else {
-        path61 = process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp";
+        path62 = process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp";
       }
-      if (trailingSlashRe.test(path61)) {
-        path61 = path61.slice(0, -1);
+      if (trailingSlashRe.test(path62)) {
+        path62 = path62.slice(0, -1);
       }
-      return path61;
+      return path62;
     };
   }
 });
@@ -43578,8 +43686,8 @@ var require_os_tmpdir = __commonJS({
 // node_modules/tmp/lib/tmp.js
 var require_tmp = __commonJS({
   "node_modules/tmp/lib/tmp.js"(exports2, module2) {
-    var fs47 = require("fs");
-    var path61 = require("path");
+    var fs48 = require("fs");
+    var path62 = require("path");
     var crypto6 = require("crypto");
     var osTmpDir = require_os_tmpdir();
     var _c2 = process.binding("constants");
@@ -43621,7 +43729,7 @@ var require_tmp = __commonJS({
     }
     function _generateTmpName(opts) {
       if (opts.name) {
-        return path61.join(opts.dir || tmpDir, opts.name);
+        return path62.join(opts.dir || tmpDir, opts.name);
       }
       if (opts.template) {
         return opts.template.replace(TEMPLATE_PATTERN, _randomChars(6));
@@ -43632,7 +43740,7 @@ var require_tmp = __commonJS({
         _randomChars(12),
         opts.postfix || ""
       ].join("");
-      return path61.join(opts.dir || tmpDir, name);
+      return path62.join(opts.dir || tmpDir, name);
     }
     function tmpName(options, callback) {
       var args = _parseArguments(options, callback), opts = args[0], cb = args[1], tries = opts.name ? 1 : opts.tries || DEFAULT_TRIES;
@@ -43642,7 +43750,7 @@ var require_tmp = __commonJS({
         return cb(new Error("Invalid template provided"));
       (function _getUniqueName() {
         const name = _generateTmpName(opts);
-        fs47.stat(name, function(err) {
+        fs48.stat(name, function(err) {
           if (!err) {
             if (tries-- > 0) return _getUniqueName();
             return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
@@ -43660,7 +43768,7 @@ var require_tmp = __commonJS({
       do {
         const name = _generateTmpName(opts);
         try {
-          fs47.statSync(name);
+          fs48.statSync(name);
         } catch (e) {
           return name;
         }
@@ -43672,13 +43780,13 @@ var require_tmp = __commonJS({
       opts.postfix = _isUndefined(opts.postfix) ? ".tmp" : opts.postfix;
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs47.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+        fs48.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
           if (err2) return cb(err2);
           if (opts.discardDescriptor) {
-            return fs47.close(fd, function _discardCallback(err3) {
+            return fs48.close(fd, function _discardCallback(err3) {
               if (err3) {
                 try {
-                  fs47.unlinkSync(name);
+                  fs48.unlinkSync(name);
                 } catch (e) {
                   if (!isENOENT(e)) {
                     err3 = e;
@@ -43701,9 +43809,9 @@ var require_tmp = __commonJS({
       opts.postfix = opts.postfix || ".tmp";
       const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
       const name = tmpNameSync(opts);
-      var fd = fs47.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      var fd = fs48.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
       if (opts.discardDescriptor) {
-        fs47.closeSync(fd);
+        fs48.closeSync(fd);
         fd = void 0;
       }
       return {
@@ -43715,9 +43823,9 @@ var require_tmp = __commonJS({
     function _rmdirRecursiveSync(root) {
       const dirs = [root];
       do {
-        var dir2 = dirs.pop(), deferred = false, files = fs47.readdirSync(dir2);
+        var dir2 = dirs.pop(), deferred = false, files = fs48.readdirSync(dir2);
         for (var i = 0, length = files.length; i < length; i++) {
-          var file2 = path61.join(dir2, files[i]), stat = fs47.lstatSync(file2);
+          var file2 = path62.join(dir2, files[i]), stat = fs48.lstatSync(file2);
           if (stat.isDirectory()) {
             if (!deferred) {
               deferred = true;
@@ -43725,11 +43833,11 @@ var require_tmp = __commonJS({
             }
             dirs.push(file2);
           } else {
-            fs47.unlinkSync(file2);
+            fs48.unlinkSync(file2);
           }
         }
         if (!deferred) {
-          fs47.rmdirSync(dir2);
+          fs48.rmdirSync(dir2);
         }
       } while (dirs.length !== 0);
     }
@@ -43737,7 +43845,7 @@ var require_tmp = __commonJS({
       var args = _parseArguments(options, callback), opts = args[0], cb = args[1];
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs47.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+        fs48.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
           if (err2) return cb(err2);
           cb(null, name, _prepareTmpDirRemoveCallback(name, opts));
         });
@@ -43746,7 +43854,7 @@ var require_tmp = __commonJS({
     function dirSync(options) {
       var args = _parseArguments(options), opts = args[0];
       const name = tmpNameSync(opts);
-      fs47.mkdirSync(name, opts.mode || DIR_MODE);
+      fs48.mkdirSync(name, opts.mode || DIR_MODE);
       return {
         name,
         removeCallback: _prepareTmpDirRemoveCallback(name, opts)
@@ -43756,7 +43864,7 @@ var require_tmp = __commonJS({
       const removeCallback = _prepareRemoveCallback(function _removeCallback(fdPath) {
         try {
           if (0 <= fdPath[0]) {
-            fs47.closeSync(fdPath[0]);
+            fs48.closeSync(fdPath[0]);
           }
         } catch (e) {
           if (!isEBADF(e) && !isENOENT(e)) {
@@ -43764,7 +43872,7 @@ var require_tmp = __commonJS({
           }
         }
         try {
-          fs47.unlinkSync(fdPath[1]);
+          fs48.unlinkSync(fdPath[1]);
         } catch (e) {
           if (!isENOENT(e)) {
             throw e;
@@ -43777,7 +43885,7 @@ var require_tmp = __commonJS({
       return removeCallback;
     }
     function _prepareTmpDirRemoveCallback(name, opts) {
-      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs47.rmdirSync.bind(fs47);
+      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs48.rmdirSync.bind(fs48);
       const removeCallback = _prepareRemoveCallback(removeFunction, name);
       if (!opts.keep) {
         _removeObjects.unshift(removeCallback);
@@ -56910,8 +57018,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path61) {
-      let input = path61;
+    function removeDotSegments(path62) {
+      let input = path62;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -57163,8 +57271,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path61, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path61 && path61 !== "/" ? path61 : void 0;
+        const [path62, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path62 && path62 !== "/" ? path62 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -60557,12 +60665,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs47, exportName) {
+    function addFormats(ajv, list, fs48, 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 f of list)
-        ajv.addFormat(f, fs47[f]);
+        ajv.addFormat(f, fs48[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -61846,11 +61954,11 @@ var parser = new YargsParser({
   resolve: import_path2.resolve,
   // TODO: figure  out a  way to combine ESM and CJS coverage, such  that
   // we can exercise all the lines below:
-  require: (path61) => {
+  require: (path62) => {
     if (typeof require !== "undefined") {
-      return require(path61);
-    } else if (path61.match(/\.json$/)) {
-      return JSON.parse((0, import_fs2.readFileSync)(path61, "utf8"));
+      return require(path62);
+    } else if (path62.match(/\.json$/)) {
+      return JSON.parse((0, import_fs2.readFileSync)(path62, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -65759,7 +65867,7 @@ function handleRemove(argv) {
 }
 
 // src/cli/commands/env.ts
-var path50 = __toESM(require("path"));
+var path51 = __toESM(require("path"));
 
 // src/cli/finish-command.ts
 init_sync_context();
@@ -65769,8 +65877,8 @@ async function finishCommand(code) {
 }
 
 // src/core/harness.ts
-var fs36 = __toESM(require("fs"));
-var path41 = __toESM(require("path"));
+var fs37 = __toESM(require("fs"));
+var path42 = __toESM(require("path"));
 
 // src/harness/generator.ts
 var fs28 = __toESM(require("fs"));
@@ -65894,9 +66002,485 @@ function finalizeHarness(repoPath, adaptationSummary, stack) {
   success("Harness adaptation complete.");
 }
 
-// src/harness/validator.ts
+// src/harness/agent-md.ts
+var fs30 = __toESM(require("fs"));
+var path36 = __toESM(require("path"));
+init_file_ops();
+init_logging();
+init_manifest();
+
+// src/harness/instruction-files.ts
 var fs29 = __toESM(require("fs"));
+var os13 = __toESM(require("os"));
 var path35 = __toESM(require("path"));
+var readline2 = __toESM(require("readline"));
+init_file_ops();
+init_logging();
+var AGENTS_MD = "AGENTS.md";
+var LEGACY_AGENT_MD = "AGENT.md";
+var CLAUDE_MD = "CLAUDE.md";
+var HAR_SECTION_START = "<!-- har:agent-environment:start -->";
+var HAR_SECTION_END = "<!-- har:agent-environment:end -->";
+var CLAUDE_HAR_SECTION_START = "<!-- har:claude-pointer:start -->";
+var CLAUDE_HAR_SECTION_END = "<!-- har:claude-pointer:end -->";
+var AgentsMdShrinkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentsMdShrinkError";
+  }
+};
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function countNonEmptyLines(text) {
+  return text.split("\n").filter((line) => line.trim().length > 0).length;
+}
+function stripClaudePointerFromAgentsMd(content) {
+  if (!content.includes(CLAUDE_HAR_SECTION_START)) return content;
+  const pattern = new RegExp(
+    `${escapeRegExp(CLAUDE_HAR_SECTION_START)}[\\s\\S]*?${escapeRegExp(CLAUDE_HAR_SECTION_END)}\\n?`,
+    "g"
+  );
+  return content.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
+}
+function extractOutsideHarSection(content) {
+  const sanitized = stripClaudePointerFromAgentsMd(content);
+  return removeCompleteMarkedBlocks(sanitized, HAR_SECTION_START, HAR_SECTION_END).trim();
+}
+function findLastCompleteMarkedBlock(content, startMarker, endMarker) {
+  let last = null;
+  let searchFrom = 0;
+  while (searchFrom < content.length) {
+    const start = content.indexOf(startMarker, searchFrom);
+    if (start === -1) break;
+    const end = content.indexOf(endMarker, start + startMarker.length);
+    if (end === -1) break;
+    const nestedStart = content.indexOf(startMarker, start + startMarker.length);
+    if (nestedStart !== -1 && nestedStart < end) {
+      searchFrom = start + startMarker.length;
+      continue;
+    }
+    last = { start, end: end + endMarker.length };
+    searchFrom = end + endMarker.length;
+  }
+  return last;
+}
+function removeCompleteMarkedBlocks(content, startMarker, endMarker) {
+  let result = content;
+  let block = findLastCompleteMarkedBlock(result, startMarker, endMarker);
+  while (block) {
+    result = result.slice(0, block.start) + result.slice(block.end);
+    block = findLastCompleteMarkedBlock(result, startMarker, endMarker);
+  }
+  return result;
+}
+function checkOutsideContentPreserved(before, after, options) {
+  const outsideBefore = extractOutsideHarSection(before);
+  const outsideAfter = extractOutsideHarSection(after);
+  const beforeLines = countNonEmptyLines(outsideBefore);
+  const afterLines = countNonEmptyLines(outsideAfter);
+  const minRatio = options.minOutsidePreservationRatio ?? 0.9;
+  if (beforeLines >= 5 && afterLines < beforeLines * minRatio) {
+    return "shrink";
+  }
+  return "ok";
+}
+function outsideContentShrinkMessage(beforeLines, afterLines) {
+  return `Refusing to update ${AGENTS_MD}: refresh would drop project-specific content outside har:agent-environment markers (${beforeLines} \u2192 ${afterLines} non-empty lines). Keep custom sections outside those markers, or merge manually before --finalize.`;
+}
+function detectInstructionFiles(repoPath) {
+  return {
+    agentsMd: fs29.existsSync(path35.join(repoPath, AGENTS_MD)),
+    agentMd: fs29.existsSync(path35.join(repoPath, LEGACY_AGENT_MD)),
+    claudeMd: fs29.existsSync(path35.join(repoPath, CLAUDE_MD)),
+    cursorDir: fs29.existsSync(path35.join(repoPath, ".cursor")),
+    claudeDir: fs29.existsSync(path35.join(repoPath, ".claude")),
+    codexHome: fs29.existsSync(path35.join(os13.homedir(), ".codex"))
+  };
+}
+function formatDetectionReport(detection) {
+  const lines2 = ["Detected:"];
+  lines2.push(`  - ${AGENTS_MD} (${detection.agentsMd ? "exists" : "missing"})`);
+  if (detection.agentMd) {
+    lines2.push(`  - ${LEGACY_AGENT_MD} (legacy \u2014 will migrate into ${AGENTS_MD})`);
+  }
+  lines2.push(`  - ${CLAUDE_MD} (${detection.claudeMd ? "exists" : "missing"})`);
+  lines2.push(`  - .cursor/ (${detection.cursorDir ? "exists" : "missing"})`);
+  lines2.push(`  - .claude/ (${detection.claudeDir ? "exists" : "missing"})`);
+  lines2.push(`  - ~/.codex (${detection.codexHome ? "exists" : "missing"})`);
+  return lines2.join("\n");
+}
+function buildInstallPlan(detection, targets, options = {}) {
+  const writeAgentsMd = options.writeAgentsMd !== false;
+  const skillsEnabled = options.skillsEnabled !== false;
+  const cursorExplicit = options.cursorRule;
+  const wantsCursor = cursorExplicit === true || cursorExplicit !== false && (targets.includes("cursor") || detection.cursorDir);
+  return {
+    agentsMd: writeAgentsMd,
+    migrateLegacyAgentMd: writeAgentsMd && detection.agentMd,
+    claudeMd: skillsEnabled && targets.includes("claude"),
+    cursorRule: wantsCursor,
+    skills: skillsEnabled ? targets : []
+  };
+}
+function formatInstallPlan(plan, detection) {
+  const mark = (on) => on ? "[x]" : "[ ]";
+  const lines2 = ["After you confirm, HAR will:"];
+  const agentsAction = detection.agentsMd ? `Update ${AGENTS_MD} \u2014 refresh HAR / agent environment section` : `Create ${AGENTS_MD} \u2014 shared HAR workflow (Codex + cross-tool)`;
+  lines2.push(`  ${mark(plan.agentsMd)} ${agentsAction}`);
+  if (plan.migrateLegacyAgentMd) {
+    lines2.push(`  ${mark(true)} Migrate ${LEGACY_AGENT_MD} \u2192 ${AGENTS_MD}, then remove legacy file`);
+  }
+  lines2.push(
+    `  ${mark(plan.claudeMd)} Claude \u2014 ensure ${CLAUDE_MD} points at ${AGENTS_MD}; install .claude/skills if confirmed`
+  );
+  lines2.push(
+    `  ${mark(plan.cursorRule)} Cursor \u2014 install/refresh .cursor/rules/har-workflow.mdc + commands if confirmed`
+  );
+  lines2.push(
+    `  ${mark(plan.skills.includes("codex"))} Codex \u2014 global ~/.codex/prompts (skills); project contract is ${AGENTS_MD}`
+  );
+  return lines2.join("\n");
+}
+function loadHarAgentsSectionFromTemplate() {
+  const templatePath = resolveTemplateFile("AGENTS.md.template");
+  if (!templatePath) {
+    throw new Error("AGENTS.md.template not found. Run npm run build.");
+  }
+  const content = fs29.readFileSync(templatePath, "utf8");
+  const start = content.indexOf(HAR_SECTION_START);
+  const end = content.indexOf(HAR_SECTION_END);
+  if (start === -1 || end === -1 || end < start) {
+    throw new Error("AGENTS.md.template is missing har:agent-environment markers.");
+  }
+  return content.slice(start, end + HAR_SECTION_END.length);
+}
+function loadAgentsMdTemplate() {
+  const templatePath = resolveTemplateFile("AGENTS.md.template");
+  if (!templatePath) {
+    throw new Error("AGENTS.md.template not found. Run npm run build.");
+  }
+  return fs29.readFileSync(templatePath, "utf8");
+}
+function upsertMarkedBlock(content, block, startMarker, endMarker) {
+  const existingBlock = findLastCompleteMarkedBlock(content, startMarker, endMarker);
+  if (existingBlock) {
+    const newContent = content.slice(0, existingBlock.start) + block + content.slice(existingBlock.end);
+    return { content: newContent, action: "updated" };
+  }
+  const suffix = content.endsWith("\n") ? "" : "\n";
+  return { content: `${content}${suffix}
+${block}
+`, action: "appended" };
+}
+function mergeAgentsMdContent(existing, incoming) {
+  const sanitizedExisting = stripClaudePointerFromAgentsMd(existing);
+  const sanitizedIncoming = stripClaudePointerFromAgentsMd(incoming);
+  let harSection = loadHarAgentsSectionFromTemplate();
+  if (sanitizedIncoming.includes(HAR_SECTION_START)) {
+    const start = sanitizedIncoming.indexOf(HAR_SECTION_START);
+    const end = sanitizedIncoming.indexOf(HAR_SECTION_END, start + HAR_SECTION_START.length);
+    if (end !== -1) {
+      harSection = sanitizedIncoming.slice(start, end + HAR_SECTION_END.length);
+    }
+  }
+  const { content } = upsertMarkedBlock(
+    sanitizedExisting,
+    harSection,
+    HAR_SECTION_START,
+    HAR_SECTION_END
+  );
+  return content;
+}
+function upsertAgentsMdHarSection(repoPath, options = {}) {
+  const dest = path35.join(repoPath, AGENTS_MD);
+  const section = loadHarAgentsSectionFromTemplate();
+  if (!fs29.existsSync(dest)) {
+    writeFileSafe(dest, loadAgentsMdTemplate());
+    return "created";
+  }
+  const existing = fs29.readFileSync(dest, "utf8");
+  const sanitized = stripClaudePointerFromAgentsMd(existing);
+  const { content, action } = upsertMarkedBlock(
+    sanitized,
+    section,
+    HAR_SECTION_START,
+    HAR_SECTION_END
+  );
+  if (checkOutsideContentPreserved(existing, content, options) === "shrink") {
+    const beforeLines = countNonEmptyLines(extractOutsideHarSection(existing));
+    const afterLines = countNonEmptyLines(extractOutsideHarSection(content));
+    const message = outsideContentShrinkMessage(beforeLines, afterLines);
+    if (options.rejectSignificantShrink) {
+      throw new AgentsMdShrinkError(message);
+    }
+    warn(message);
+    return "skipped";
+  }
+  if (content === existing) {
+    return "skipped";
+  }
+  writeFileSafe(dest, content);
+  return action;
+}
+function migrateLegacyAgentMd(repoPath) {
+  const legacyPath = path35.join(repoPath, LEGACY_AGENT_MD);
+  const agentsPath = path35.join(repoPath, AGENTS_MD);
+  if (!fs29.existsSync(legacyPath)) return false;
+  const legacy = fs29.readFileSync(legacyPath, "utf8");
+  if (!fs29.existsSync(agentsPath)) {
+    writeFileSafe(agentsPath, legacy);
+    upsertAgentsMdHarSection(repoPath);
+  } else {
+    const agents = fs29.readFileSync(agentsPath, "utf8");
+    const legacyTrimmed = legacy.trim();
+    if (legacyTrimmed.length > 0 && !agents.includes(legacyTrimmed)) {
+      const suffix = agents.endsWith("\n") ? "" : "\n";
+      writeFileSafe(agentsPath, `${agents}${suffix}
+${legacyTrimmed}
+`);
+    }
+    upsertAgentsMdHarSection(repoPath);
+  }
+  fs29.unlinkSync(legacyPath);
+  info(`Migrated ${LEGACY_AGENT_MD} \u2192 ${AGENTS_MD} (removed legacy file)`);
+  return true;
+}
+function loadClaudeMdTemplate(projectName) {
+  const templatePath = resolveTemplateFile("CLAUDE.md.template");
+  if (!templatePath) {
+    throw new Error("CLAUDE.md.template not found. Run npm run build.");
+  }
+  const displayName = projectName.replace(/_/g, " ");
+  return fs29.readFileSync(templatePath, "utf8").replace(/__PROJECT_DISPLAY_NAME__/g, displayName);
+}
+function isThinClaudePointer(content) {
+  const trimmed = content.trim();
+  if (trimmed.length > 600) return false;
+  return /AGENTS\.md|AGENT\.md/.test(trimmed) && (trimmed.includes(".har/README.md") || trimmed.includes("har-workflow"));
+}
+var CLAUDE_POINTER_BLOCK = `${CLAUDE_HAR_SECTION_START}
+## HAR
+
+This repository uses a \`.har/\` harness. Read [AGENTS.md](./AGENTS.md) and
+[\`.har/README.md\`](./.har/README.md) before making changes.
+${CLAUDE_HAR_SECTION_END}`;
+function ensureClaudeMdPointer(repoPath, options = {}) {
+  const dest = path35.join(repoPath, CLAUDE_MD);
+  const projectName = path35.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const thin = loadClaudeMdTemplate(projectName);
+  if (!fs29.existsSync(dest)) {
+    writeFileSafe(dest, thin);
+    return "created";
+  }
+  const existing = fs29.readFileSync(dest, "utf8");
+  if (isThinClaudePointer(existing) || options.force) {
+    writeFileSafe(dest, thin);
+    return "updated";
+  }
+  if (existing.includes(CLAUDE_HAR_SECTION_START) || /\[AGENTS\.md\]/.test(existing)) {
+    if (existing.includes(CLAUDE_HAR_SECTION_START)) {
+      const { content: content2, action: action2 } = upsertMarkedBlock(
+        existing,
+        CLAUDE_POINTER_BLOCK,
+        CLAUDE_HAR_SECTION_START,
+        CLAUDE_HAR_SECTION_END
+      );
+      writeFileSafe(dest, content2);
+      return action2;
+    }
+    return "skipped";
+  }
+  const { content, action } = upsertMarkedBlock(
+    existing,
+    CLAUDE_POINTER_BLOCK,
+    CLAUDE_HAR_SECTION_START,
+    CLAUDE_HAR_SECTION_END
+  );
+  writeFileSafe(dest, content);
+  return action;
+}
+async function askYesNo2(question, defaultYes = true) {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve47) => {
+    process.stderr.write(`${question} `);
+    rl.once("line", (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (trimmed === "") {
+        resolve47(defaultYes);
+        return;
+      }
+      resolve47(/^y(es)?$/i.test(trimmed));
+    });
+  });
+}
+async function handleInstructionFiles(options) {
+  const { repoPath, mode } = options;
+  const writeAgentsMd = options.writeAgentsMd !== false;
+  const skillsEnabled = options.enabled !== false;
+  const detection = detectInstructionFiles(repoPath);
+  let targets;
+  if (!skillsEnabled) {
+    targets = [];
+  } else if (typeof options.agents === "string") {
+    targets = parseAgentTargets(options.agents);
+  } else {
+    targets = detectAgentTargets(repoPath);
+  }
+  if (skillsEnabled && targets.length === 0 && mode === "init" && typeof options.agents !== "string" && !options.autoYes) {
+    targets = [...AGENT_SKILL_TARGETS];
+  }
+  let plan = buildInstallPlan(detection, targets, {
+    writeAgentsMd,
+    cursorRule: options.cursorRule,
+    skillsEnabled
+  });
+  divider();
+  process.stderr.write(`${formatDetectionReport(detection)}
+
+`);
+  process.stderr.write(`${formatInstallPlan(plan, detection)}
+`);
+  divider();
+  const shouldPrompt = !options.autoYes && skillsEnabled && typeof options.agents !== "string" && !(mode === "maintain" && targets.length > 0 && !detection.agentMd);
+  if (shouldPrompt && targets.length > 0) {
+    const accepted = await askYesNo2(
+      `Install HAR agent instructions for: ${targets.join(", ")}? [Y/n]`
+    );
+    if (!accepted) {
+      info("Skipped agent instruction adapters (AGENTS.md will still be updated)");
+      targets = [];
+      plan = buildInstallPlan(detection, targets, {
+        writeAgentsMd,
+        cursorRule: options.cursorRule === true ? true : false,
+        skillsEnabled: false
+      });
+    }
+  }
+  let migratedLegacy = false;
+  let agentsMdAction = null;
+  let claudeMdAction = null;
+  if (writeAgentsMd) {
+    if (detection.agentMd) {
+      migratedLegacy = migrateLegacyAgentMd(repoPath);
+    }
+    agentsMdAction = upsertAgentsMdHarSection(repoPath, {
+      rejectSignificantShrink: options.finalize === true
+    });
+    if (agentsMdAction === "created") {
+      success(`Wrote ${AGENTS_MD}`);
+    } else if (agentsMdAction === "updated" || agentsMdAction === "appended") {
+      info(
+        `${agentsMdAction === "updated" ? "Refreshed" : "Appended"} HAR section in ${AGENTS_MD}`
+      );
+    } else if (agentsMdAction === "skipped" && options.finalize) {
+      warn(
+        `${AGENTS_MD} left unchanged \u2014 project-specific content outside har:agent-environment markers was preserved.`
+      );
+    }
+  } else {
+    agentsMdAction = "skipped";
+  }
+  if (plan.claudeMd) {
+    claudeMdAction = ensureClaudeMdPointer(repoPath);
+    if (claudeMdAction === "created") {
+      success(`Wrote ${CLAUDE_MD} (pointer \u2192 ${AGENTS_MD})`);
+    } else if (claudeMdAction === "updated" || claudeMdAction === "appended") {
+      info(
+        `${claudeMdAction === "updated" ? "Updated" : "Appended"} ${CLAUDE_MD} pointer \u2192 ${AGENTS_MD}`
+      );
+    }
+  } else {
+    claudeMdAction = "skipped";
+  }
+  return {
+    detection,
+    plan,
+    targets,
+    agentsMdAction,
+    migratedLegacy,
+    claudeMdAction
+  };
+}
+
+// src/harness/agent-md.ts
+var AGENTS_MD_PROPOSAL = "AGENTS.md.proposed";
+var AGENTS_MD_PROPOSAL_META = "AGENTS.md.proposed.meta.json";
+var AGENT_MD_PROPOSAL = "AGENT.md.proposed";
+var AGENT_MD_PROPOSAL_META = "AGENT.md.proposed.meta.json";
+function readAgentMdProposal(repoPath) {
+  const harnessDir = getHarnessDir(repoPath);
+  const proposalPath = path36.join(harnessDir, AGENTS_MD_PROPOSAL);
+  const metaPath = path36.join(harnessDir, AGENTS_MD_PROPOSAL_META);
+  const legacyProposalPath = path36.join(harnessDir, AGENT_MD_PROPOSAL);
+  const legacyMetaPath = path36.join(harnessDir, AGENT_MD_PROPOSAL_META);
+  const resolvedProposal = fs30.existsSync(proposalPath) ? proposalPath : fs30.existsSync(legacyProposalPath) ? legacyProposalPath : null;
+  if (!resolvedProposal) return null;
+  const resolvedMeta = resolvedProposal === proposalPath ? metaPath : legacyMetaPath;
+  const content = fs30.readFileSync(resolvedProposal, "utf8");
+  let rationale = "";
+  let createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (fs30.existsSync(resolvedMeta)) {
+    try {
+      const meta = JSON.parse(fs30.readFileSync(resolvedMeta, "utf8"));
+      rationale = meta.rationale ?? "";
+      createdAt = meta.createdAt ?? createdAt;
+    } catch {
+      rationale = "";
+    }
+  }
+  return { content, rationale, createdAt };
+}
+function clearAgentMdProposal(repoPath) {
+  const harnessDir = getHarnessDir(repoPath);
+  for (const file of [
+    AGENTS_MD_PROPOSAL,
+    AGENTS_MD_PROPOSAL_META,
+    AGENT_MD_PROPOSAL,
+    AGENT_MD_PROPOSAL_META
+  ]) {
+    const p = path36.join(harnessDir, file);
+    if (fs30.existsSync(p)) fs30.unlinkSync(p);
+  }
+}
+function wouldProposalShrinkExisting(existing, proposal) {
+  const outsideExisting = extractOutsideHarSection(existing);
+  const outsideMerged = extractOutsideHarSection(mergeAgentsMdContent(existing, proposal));
+  const existingLines = outsideExisting.split("\n").filter((l) => l.trim()).length;
+  const mergedLines = outsideMerged.split("\n").filter((l) => l.trim()).length;
+  return existingLines >= 5 && mergedLines < existingLines * 0.9;
+}
+function applyAgentMdProposalMerge(repoPath, options = {}) {
+  const proposal = readAgentMdProposal(repoPath);
+  if (!proposal) return false;
+  const agentsMdPath = path36.join(repoPath, AGENTS_MD);
+  if (fs30.existsSync(agentsMdPath)) {
+    const existing = fs30.readFileSync(agentsMdPath, "utf8");
+    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) {
+        throw new AgentsMdShrinkError(message);
+      }
+      warn(message);
+      return false;
+    }
+    writeFileSafe(agentsMdPath, mergeAgentsMdContent(existing, proposal.content));
+  } else {
+    writeFileSafe(agentsMdPath, proposal.content);
+  }
+  clearAgentMdProposal(repoPath);
+  info(`Merged ${AGENTS_MD} proposal into repo root (preserved content outside managed markers)`);
+  return true;
+}
+function finalizeAgentsMdInstructionFiles(repoPath) {
+  applyAgentMdProposalMerge(repoPath, { rejectSignificantShrink: true });
+  upsertAgentsMdHarSection(repoPath, { rejectSignificantShrink: true });
+}
+
+// src/harness/validator.ts
+var fs31 = __toESM(require("fs"));
+var path37 = __toESM(require("path"));
 init_shell();
 init_manifest();
 init_stages();
@@ -65951,22 +66535,22 @@ var SHELL_SCRIPTS = [
 function validateHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
-  if (!fs29.existsSync(harnessDir)) {
+  if (!fs31.existsSync(harnessDir)) {
     return {
       pass: false,
       issues: [{ file: ".har", message: "Harness directory not found", severity: "error" }]
     };
   }
   for (const file of getRequiredFiles(repoPath)) {
-    const filePath = path35.join(harnessDir, file);
-    if (!fs29.existsSync(filePath)) {
+    const filePath = path37.join(harnessDir, file);
+    if (!fs31.existsSync(filePath)) {
       issues.push({ file, message: "Required file missing", severity: "error" });
     }
   }
   for (const script of SHELL_SCRIPTS) {
-    const scriptPath = path35.join(harnessDir, script);
-    if (!fs29.existsSync(scriptPath)) continue;
-    const stat = fs29.statSync(scriptPath);
+    const scriptPath = path37.join(harnessDir, script);
+    if (!fs31.existsSync(scriptPath)) continue;
+    const stat = fs31.statSync(scriptPath);
     if (!(stat.mode & 73)) {
       issues.push({ file: script, message: "Script is not executable", severity: "warning" });
     }
@@ -65981,9 +66565,9 @@ function validateHarness(repoPath) {
   }
   const manifest = readManifest(repoPath);
   const profile = manifest?.profile ?? "default";
-  const ecosystemPath = path35.join(harnessDir, "ecosystem.agent.template.cjs");
-  if (profile !== "cli" && fs29.existsSync(ecosystemPath)) {
-    const content = fs29.readFileSync(ecosystemPath, "utf8");
+  const ecosystemPath = path37.join(harnessDir, "ecosystem.agent.template.cjs");
+  if (profile !== "cli" && fs31.existsSync(ecosystemPath)) {
+    const content = fs31.readFileSync(ecosystemPath, "utf8");
     if (!content.includes("module.exports")) {
       issues.push({
         file: "ecosystem.agent.template.cjs",
@@ -65992,9 +66576,9 @@ function validateHarness(repoPath) {
       });
     }
   }
-  const harnessEnvPath = path35.join(harnessDir, "harness.env");
-  if (fs29.existsSync(harnessEnvPath)) {
-    const content = fs29.readFileSync(harnessEnvPath, "utf8");
+  const harnessEnvPath = path37.join(harnessDir, "harness.env");
+  if (fs31.existsSync(harnessEnvPath)) {
+    const content = fs31.readFileSync(harnessEnvPath, "utf8");
     if (content.includes("TODO: set migrate command")) {
       issues.push({ file: "harness.env", message: "Migrate command still has TODO", severity: "warning" });
     }
@@ -66002,17 +66586,17 @@ function validateHarness(repoPath) {
       issues.push({ file: "harness.env", message: "Seed command still has TODO", severity: "warning" });
     }
   }
-  const verifyPath = path35.join(harnessDir, "verify.sh");
-  if (fs29.existsSync(verifyPath)) {
-    const content = fs29.readFileSync(verifyPath, "utf8");
+  const verifyPath = path37.join(harnessDir, "verify.sh");
+  if (fs31.existsSync(verifyPath)) {
+    const content = fs31.readFileSync(verifyPath, "utf8");
     if (content.includes("echo 'TODO:")) {
       issues.push({ file: "verify.sh", message: "Verification steps still have TODO placeholders", severity: "warning" });
     }
   }
-  const stagesPath = path35.join(harnessDir, "stages.json");
-  if (fs29.existsSync(stagesPath)) {
+  const stagesPath = path37.join(harnessDir, "stages.json");
+  if (fs31.existsSync(stagesPath)) {
     try {
-      JSON.parse(fs29.readFileSync(stagesPath, "utf8"));
+      JSON.parse(fs31.readFileSync(stagesPath, "utf8"));
       const registry2 = readStageRegistry(repoPath);
       if (registry2.stages.length === 0) {
         issues.push({ file: "stages.json", message: "No harness stages declared", severity: "warning" });
@@ -66027,9 +66611,9 @@ function validateHarness(repoPath) {
   } else {
     issues.push({ file: "stages.json", message: "Stage registry missing", severity: "warning" });
   }
-  const readmePath = path35.join(harnessDir, "README.md");
-  if (fs29.existsSync(readmePath)) {
-    const content = fs29.readFileSync(readmePath, "utf8");
+  const readmePath = path37.join(harnessDir, "README.md");
+  if (fs31.existsSync(readmePath)) {
+    const content = fs31.readFileSync(readmePath, "utf8");
     if (!content.includes(".har")) {
       issues.push({ file: "README.md", message: "README should document .har/ paths", severity: "warning" });
     }
@@ -66043,8 +66627,8 @@ function validateHarness(repoPath) {
 async function smokeTestHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
-  const setupScript = path35.join(harnessDir, "setup-infra.sh");
-  if (fs29.existsSync(setupScript)) {
+  const setupScript = path37.join(harnessDir, "setup-infra.sh");
+  if (fs31.existsSync(setupScript)) {
     const result = run(`bash "${setupScript}"`, { cwd: repoPath });
     if (result.code !== 0) {
       issues.push({
@@ -66059,8 +66643,8 @@ async function smokeTestHarness(repoPath) {
 }
 
 // src/harness/drift.ts
-var fs30 = __toESM(require("fs"));
-var path36 = __toESM(require("path"));
+var fs32 = __toESM(require("fs"));
+var path38 = __toESM(require("path"));
 init_env();
 init_manifest();
 init_stages();
@@ -66131,16 +66715,16 @@ function substituteProjectName(content, projectName) {
   return content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
 }
 function listBoilerplateFiles(boilerplateDir) {
-  if (!fs30.existsSync(boilerplateDir)) return [];
-  return fs30.readdirSync(boilerplateDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  if (!fs32.existsSync(boilerplateDir)) return [];
+  return fs32.readdirSync(boilerplateDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
 }
 function compareHarnessToTemplate(repoPath) {
-  const resolved = path36.resolve(repoPath);
+  const resolved = path38.resolve(repoPath);
   const manifest = readManifest(resolved);
   const profile = manifest?.profile ?? "default";
   const harnessDir = getHarnessDir(resolved);
-  const projectName = path36.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
-  const boilerplateDir = path36.join(resolveTemplatesDir(), PROFILE_DIRS2[profile]);
+  const projectName = path38.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const boilerplateDir = path38.join(resolveTemplatesDir(), PROFILE_DIRS2[profile]);
   const templateFiles = listBoilerplateFiles(boilerplateDir);
   const missing = [];
   const checksumMismatch = [];
@@ -66148,17 +66732,17 @@ function compareHarnessToTemplate(repoPath) {
   const unchanged = [];
   for (const file of templateFiles) {
     const harnessFile = harnessFileForTemplate(file);
-    const templatePath = path36.join(boilerplateDir, file);
-    const harnessPath = path36.join(harnessDir, harnessFile);
-    let templateContent = fs30.readFileSync(templatePath, "utf8");
+    const templatePath = path38.join(boilerplateDir, file);
+    const harnessPath = path38.join(harnessDir, harnessFile);
+    let templateContent = fs32.readFileSync(templatePath, "utf8");
     if (file === "harness.env") {
       templateContent = substituteProjectName(templateContent, projectName);
     }
-    if (!fs30.existsSync(harnessPath)) {
+    if (!fs32.existsSync(harnessPath)) {
       missing.push(harnessFile);
       continue;
     }
-    const harnessChecksum = computeFileChecksum(fs30.readFileSync(harnessPath, "utf8"));
+    const harnessChecksum = computeFileChecksum(fs32.readFileSync(harnessPath, "utf8"));
     const templateChecksum = computeFileChecksum(templateContent);
     if (harnessChecksum === templateChecksum) {
       unchanged.push(harnessFile);
@@ -66166,10 +66750,10 @@ function compareHarnessToTemplate(repoPath) {
       checksumMismatch.push(harnessFile);
     }
   }
-  if (fs30.existsSync(harnessDir)) {
-    for (const file of fs30.readdirSync(harnessDir)) {
-      const full = path36.join(harnessDir, file);
-      if (!fs30.statSync(full).isFile()) continue;
+  if (fs32.existsSync(harnessDir)) {
+    for (const file of fs32.readdirSync(harnessDir)) {
+      const full = path38.join(harnessDir, file);
+      if (!fs32.statSync(full).isFile()) continue;
       if (file === "manifest.json" || file.startsWith("ADAPT-PROMPT")) continue;
       if (profile === "cli" && CLI_EXPECTED_ABSENT.has(file)) {
         extra.push(file);
@@ -66200,29 +66784,29 @@ function compareHarnessToTemplate(repoPath) {
 }
 
 // src/harness/maintain-bundle.ts
-var fs35 = __toESM(require("fs"));
+var fs36 = __toESM(require("fs"));
 var os14 = __toESM(require("os"));
-var path40 = __toESM(require("path"));
+var path41 = __toESM(require("path"));
 init_file_ops();
 init_shell();
 init_manifest();
 
 // src/harness/plugin-drift.ts
-var fs33 = __toESM(require("fs"));
-var path38 = __toESM(require("path"));
+var fs35 = __toESM(require("fs"));
+var path40 = __toESM(require("path"));
 init_manifest();
 
 // src/harness/plugins.ts
-var fs32 = __toESM(require("fs"));
-var path37 = __toESM(require("path"));
+var fs34 = __toESM(require("fs"));
+var path39 = __toESM(require("path"));
 init_zod();
 init_logging();
 
 // src/harness/parser.ts
-var fs31 = __toESM(require("fs"));
+var fs33 = __toESM(require("fs"));
 init_manifest();
 function harnessExists(repoPath) {
-  return fs31.existsSync(`${repoPath}/.har/setup-infra.sh`);
+  return fs33.existsSync(`${repoPath}/.har/setup-infra.sh`);
 }
 
 // src/harness/plugins.ts
@@ -66247,16 +66831,16 @@ var PluginManifestSchema = external_exports.object({
   docsPath: external_exports.string().min(1)
 });
 function resolvePluginDir(pluginId) {
-  const dir = path37.join(resolveTemplatesDir(), "plugins", pluginId);
-  if (!fs32.existsSync(dir)) {
+  const dir = path39.join(resolveTemplatesDir(), "plugins", pluginId);
+  if (!fs34.existsSync(dir)) {
     throw new Error(`Plugin not found: ${pluginId}. Run npm run build.`);
   }
   return dir;
 }
 function readPluginManifest(pluginId) {
-  const manifestPath = path37.join(resolvePluginDir(pluginId), "template.manifest.json");
+  const manifestPath = path39.join(resolvePluginDir(pluginId), "template.manifest.json");
   const parsed = PluginManifestSchema.safeParse(
-    JSON.parse(fs32.readFileSync(manifestPath, "utf8"))
+    JSON.parse(fs34.readFileSync(manifestPath, "utf8"))
   );
   if (!parsed.success) {
     throw new Error(`Invalid plugin manifest for ${pluginId}: ${parsed.error.message}`);
@@ -66267,40 +66851,40 @@ function readPluginManifest(pluginId) {
   return parsed.data;
 }
 function ensureParentDir(filePath) {
-  const parent = path37.dirname(filePath);
-  if (!fs32.existsSync(parent)) {
-    fs32.mkdirSync(parent, { recursive: true });
+  const parent = path39.dirname(filePath);
+  if (!fs34.existsSync(parent)) {
+    fs34.mkdirSync(parent, { recursive: true });
   }
 }
 function copyPluginFile(pluginDir, file, repoPath, force) {
-  const srcPath = path37.join(pluginDir, file.src);
-  const destPath = path37.join(repoPath, file.dest);
-  if (!fs32.existsSync(srcPath)) {
+  const srcPath = path39.join(pluginDir, file.src);
+  const destPath = path39.join(repoPath, file.dest);
+  if (!fs34.existsSync(srcPath)) {
     throw new Error(`Plugin file missing: ${file.src}`);
   }
-  if (fs32.existsSync(destPath) && !force) {
+  if (fs34.existsSync(destPath) && !force) {
     throw new Error(
       `File already exists: ${file.dest}. Use --force to overwrite or remove it first.`
     );
   }
   ensureParentDir(destPath);
-  fs32.copyFileSync(srcPath, destPath);
+  fs34.copyFileSync(srcPath, destPath);
   if (file.executable) {
-    fs32.chmodSync(destPath, 493);
+    fs34.chmodSync(destPath, 493);
   }
   return { written: true, path: file.dest };
 }
 function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
-  const packagePath = path37.join(repoPath, "package.json");
-  if (!fs32.existsSync(packagePath)) {
+  const packagePath = path39.join(repoPath, "package.json");
+  if (!fs34.existsSync(packagePath)) {
     throw new Error("No package.json in repo root. Add one before applying this plugin.");
   }
-  const fragmentPath = path37.join(pluginDir, fragmentRelPath);
-  if (!fs32.existsSync(fragmentPath)) {
+  const fragmentPath = path39.join(pluginDir, fragmentRelPath);
+  if (!fs34.existsSync(fragmentPath)) {
     throw new Error(`Package fragment missing: ${fragmentRelPath}`);
   }
-  const pkg = JSON.parse(fs32.readFileSync(packagePath, "utf8"));
-  const fragment = JSON.parse(fs32.readFileSync(fragmentPath, "utf8"));
+  const pkg = JSON.parse(fs34.readFileSync(packagePath, "utf8"));
+  const fragment = JSON.parse(fs34.readFileSync(fragmentPath, "utf8"));
   for (const section of ["scripts", "devDependencies"]) {
     const existing = pkg[section] ?? {};
     const incoming = fragment[section] ?? {};
@@ -66313,7 +66897,7 @@ function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
     }
     pkg[section] = existing;
   }
-  fs32.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
+  fs34.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
 }
 function patchStageRegistry(repoPath, manifest, force) {
   const registry2 = readStageRegistry(repoPath);
@@ -66353,8 +66937,8 @@ function assertHarnessPresent(repoPath) {
 }
 function assertStageNotPresent(repoPath, stageId, force) {
   if (force) return;
-  const scriptPath = path37.join(repoPath, ".har", "stages", `${stageId}.sh`);
-  if (fs32.existsSync(scriptPath)) {
+  const scriptPath = path39.join(repoPath, ".har", "stages", `${stageId}.sh`);
+  if (fs34.existsSync(scriptPath)) {
     throw new Error(
       `Stage script already exists: .har/stages/${stageId}.sh. Use --force to overwrite.`
     );
@@ -66367,7 +66951,7 @@ function assertStageNotPresent(repoPath, stageId, force) {
   }
 }
 function applyPlugin(repoPath, pluginId, options = {}) {
-  const resolved = path37.resolve(repoPath);
+  const resolved = path39.resolve(repoPath);
   const force = options.force ?? false;
   const warnings = [];
   const filesWritten = [];
@@ -66386,7 +66970,7 @@ function applyPlugin(repoPath, pluginId, options = {}) {
       if (file.skipFlag === "skipCi" && options.skipCi) {
         continue;
       }
-      if (fs32.existsSync(path37.join(resolved, file.dest)) && !force) {
+      if (fs34.existsSync(path39.join(resolved, file.dest)) && !force) {
         warnings.push(`Skipped optional file (exists): ${file.dest}`);
         continue;
       }
@@ -66421,18 +67005,18 @@ function applyPlugin(repoPath, pluginId, options = {}) {
   };
 }
 function listPluginIds() {
-  const root = path37.join(resolveTemplatesDir(), "plugins");
-  if (!fs32.existsSync(root)) return [...PLUGIN_IDS];
-  return fs32.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => PLUGIN_IDS.includes(name));
+  const root = path39.join(resolveTemplatesDir(), "plugins");
+  if (!fs34.existsSync(root)) return [...PLUGIN_IDS];
+  return fs34.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => PLUGIN_IDS.includes(name));
 }
 
 // src/harness/plugin-drift.ts
 init_stages();
 var PACKAGE_SECTIONS = ["scripts", "devDependencies"];
 function detectInstalledPlugins(repoPath) {
-  const resolved = path38.resolve(repoPath);
-  const registryPath = path38.join(resolved, ".har", "stages.json");
-  if (!fs33.existsSync(registryPath)) return [];
+  const resolved = path40.resolve(repoPath);
+  const registryPath = path40.join(resolved, ".har", "stages.json");
+  if (!fs35.existsSync(registryPath)) return [];
   const registry2 = readStageRegistry(resolved);
   const stageIds = new Set(registry2.stages.map((stage) => stage.id));
   const installed = [];
@@ -66445,17 +67029,17 @@ function detectInstalledPlugins(repoPath) {
   return installed;
 }
 function pluginTemplatePath(pluginId, srcRel) {
-  return path38.join(resolveTemplatesDir(), "plugins", pluginId, srcRel);
+  return path40.join(resolveTemplatesDir(), "plugins", pluginId, srcRel);
 }
 function readBundledPluginFile(pluginId, srcRel) {
-  return fs33.readFileSync(pluginTemplatePath(pluginId, srcRel), "utf8");
+  return fs35.readFileSync(pluginTemplatePath(pluginId, srcRel), "utf8");
 }
 function listPluginDestPaths(pluginId, repoPath) {
   const manifest = readPluginManifest(pluginId);
   const paths = manifest.files.map((file) => file.dest);
   if (manifest.optionalFiles) {
     for (const file of manifest.optionalFiles) {
-      if (fs33.existsSync(path38.join(repoPath, file.dest))) {
+      if (fs35.existsSync(path40.join(repoPath, file.dest))) {
         paths.push(file.dest);
       }
     }
@@ -66514,9 +67098,9 @@ function readTemplatePluginFile(pluginId, dest) {
   return null;
 }
 function readInstalledPluginFile(repoPath, pluginId, dest) {
-  const installedPath = path38.join(path38.resolve(repoPath), dest);
-  if (!fs33.existsSync(installedPath)) return null;
-  const content = fs33.readFileSync(installedPath, "utf8");
+  const installedPath = path40.join(path40.resolve(repoPath), dest);
+  if (!fs35.existsSync(installedPath)) return null;
+  const content = fs35.readFileSync(installedPath, "utf8");
   const manifest = readPluginManifest(pluginId);
   const fragmentRel = manifest.merge?.[dest];
   if (fragmentRel) {
@@ -66535,7 +67119,7 @@ function pluginActionHint(pluginId, dest, kind) {
 }
 function comparePluginToTemplate(repoPath, pluginId) {
   const manifest = readPluginManifest(pluginId);
-  const resolved = path38.resolve(repoPath);
+  const resolved = path40.resolve(repoPath);
   const destPaths = listPluginDestPaths(pluginId, resolved);
   const missing = [];
   const checksumMismatch = [];
@@ -66550,8 +67134,8 @@ function comparePluginToTemplate(repoPath, pluginId) {
     }
     if (dest === "package.json") {
       const fragmentRel = manifest.merge?.[dest];
-      const installedPath = path38.join(resolved, dest);
-      const installedRaw = fs33.readFileSync(installedPath, "utf8");
+      const installedPath = path40.join(resolved, dest);
+      const installedRaw = fs35.readFileSync(installedPath, "utf8");
       if (fragmentRel && pluginKeysMatch(installedRaw, readBundledPluginFile(pluginId, fragmentRel))) {
         unchanged.push(dest);
       } else if (computeFileChecksum(installedContent) === computeFileChecksum(templateContent)) {
@@ -66609,293 +67193,6 @@ function buildPluginDriftActions(repoPath, pluginDrift) {
   );
 }
 
-// src/harness/instruction-files.ts
-var fs34 = __toESM(require("fs"));
-var os13 = __toESM(require("os"));
-var path39 = __toESM(require("path"));
-var readline2 = __toESM(require("readline"));
-init_file_ops();
-init_logging();
-var AGENTS_MD = "AGENTS.md";
-var LEGACY_AGENT_MD = "AGENT.md";
-var CLAUDE_MD = "CLAUDE.md";
-var HAR_SECTION_START = "<!-- har:agent-environment:start -->";
-var HAR_SECTION_END = "<!-- har:agent-environment:end -->";
-var CLAUDE_HAR_SECTION_START = "<!-- har:claude-pointer:start -->";
-var CLAUDE_HAR_SECTION_END = "<!-- har:claude-pointer:end -->";
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function detectInstructionFiles(repoPath) {
-  return {
-    agentsMd: fs34.existsSync(path39.join(repoPath, AGENTS_MD)),
-    agentMd: fs34.existsSync(path39.join(repoPath, LEGACY_AGENT_MD)),
-    claudeMd: fs34.existsSync(path39.join(repoPath, CLAUDE_MD)),
-    cursorDir: fs34.existsSync(path39.join(repoPath, ".cursor")),
-    claudeDir: fs34.existsSync(path39.join(repoPath, ".claude")),
-    codexHome: fs34.existsSync(path39.join(os13.homedir(), ".codex"))
-  };
-}
-function formatDetectionReport(detection) {
-  const lines2 = ["Detected:"];
-  lines2.push(`  - ${AGENTS_MD} (${detection.agentsMd ? "exists" : "missing"})`);
-  if (detection.agentMd) {
-    lines2.push(`  - ${LEGACY_AGENT_MD} (legacy \u2014 will migrate into ${AGENTS_MD})`);
-  }
-  lines2.push(`  - ${CLAUDE_MD} (${detection.claudeMd ? "exists" : "missing"})`);
-  lines2.push(`  - .cursor/ (${detection.cursorDir ? "exists" : "missing"})`);
-  lines2.push(`  - .claude/ (${detection.claudeDir ? "exists" : "missing"})`);
-  lines2.push(`  - ~/.codex (${detection.codexHome ? "exists" : "missing"})`);
-  return lines2.join("\n");
-}
-function buildInstallPlan(detection, targets, options = {}) {
-  const writeAgentsMd = options.writeAgentsMd !== false;
-  const skillsEnabled = options.skillsEnabled !== false;
-  const cursorExplicit = options.cursorRule;
-  const wantsCursor = cursorExplicit === true || cursorExplicit !== false && (targets.includes("cursor") || detection.cursorDir);
-  return {
-    agentsMd: writeAgentsMd,
-    migrateLegacyAgentMd: writeAgentsMd && detection.agentMd,
-    claudeMd: skillsEnabled && targets.includes("claude"),
-    cursorRule: wantsCursor,
-    skills: skillsEnabled ? targets : []
-  };
-}
-function formatInstallPlan(plan, detection) {
-  const mark = (on) => on ? "[x]" : "[ ]";
-  const lines2 = ["After you confirm, HAR will:"];
-  const agentsAction = detection.agentsMd ? `Update ${AGENTS_MD} \u2014 refresh HAR / agent environment section` : `Create ${AGENTS_MD} \u2014 shared HAR workflow (Codex + cross-tool)`;
-  lines2.push(`  ${mark(plan.agentsMd)} ${agentsAction}`);
-  if (plan.migrateLegacyAgentMd) {
-    lines2.push(`  ${mark(true)} Migrate ${LEGACY_AGENT_MD} \u2192 ${AGENTS_MD}, then remove legacy file`);
-  }
-  lines2.push(
-    `  ${mark(plan.claudeMd)} Claude \u2014 ensure ${CLAUDE_MD} points at ${AGENTS_MD}; install .claude/skills if confirmed`
-  );
-  lines2.push(
-    `  ${mark(plan.cursorRule)} Cursor \u2014 install/refresh .cursor/rules/har-workflow.mdc + commands if confirmed`
-  );
-  lines2.push(
-    `  ${mark(plan.skills.includes("codex"))} Codex \u2014 global ~/.codex/prompts (skills); project contract is ${AGENTS_MD}`
-  );
-  return lines2.join("\n");
-}
-function loadHarAgentsSectionFromTemplate() {
-  const templatePath = resolveTemplateFile("AGENTS.md.template");
-  if (!templatePath) {
-    throw new Error("AGENTS.md.template not found. Run npm run build.");
-  }
-  const content = fs34.readFileSync(templatePath, "utf8");
-  const start = content.indexOf(HAR_SECTION_START);
-  const end = content.indexOf(HAR_SECTION_END);
-  if (start === -1 || end === -1 || end < start) {
-    throw new Error("AGENTS.md.template is missing har:agent-environment markers.");
-  }
-  return content.slice(start, end + HAR_SECTION_END.length);
-}
-function loadAgentsMdTemplate() {
-  const templatePath = resolveTemplateFile("AGENTS.md.template");
-  if (!templatePath) {
-    throw new Error("AGENTS.md.template not found. Run npm run build.");
-  }
-  return fs34.readFileSync(templatePath, "utf8");
-}
-function upsertMarkedBlock(content, block, startMarker, endMarker) {
-  if (content.includes(startMarker)) {
-    const pattern = new RegExp(
-      `${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}`
-    );
-    return { content: content.replace(pattern, block), action: "updated" };
-  }
-  const suffix = content.endsWith("\n") ? "" : "\n";
-  return { content: `${content}${suffix}
-${block}
-`, action: "appended" };
-}
-function upsertAgentsMdHarSection(repoPath) {
-  const dest = path39.join(repoPath, AGENTS_MD);
-  const section = loadHarAgentsSectionFromTemplate();
-  if (!fs34.existsSync(dest)) {
-    writeFileSafe(dest, loadAgentsMdTemplate());
-    return "created";
-  }
-  const existing = fs34.readFileSync(dest, "utf8");
-  const { content, action } = upsertMarkedBlock(
-    existing,
-    section,
-    HAR_SECTION_START,
-    HAR_SECTION_END
-  );
-  writeFileSafe(dest, content);
-  return action;
-}
-function migrateLegacyAgentMd(repoPath) {
-  const legacyPath = path39.join(repoPath, LEGACY_AGENT_MD);
-  const agentsPath = path39.join(repoPath, AGENTS_MD);
-  if (!fs34.existsSync(legacyPath)) return false;
-  const legacy = fs34.readFileSync(legacyPath, "utf8");
-  if (!fs34.existsSync(agentsPath)) {
-    writeFileSafe(agentsPath, legacy);
-    upsertAgentsMdHarSection(repoPath);
-  } else {
-    upsertAgentsMdHarSection(repoPath);
-  }
-  fs34.unlinkSync(legacyPath);
-  info(`Migrated ${LEGACY_AGENT_MD} \u2192 ${AGENTS_MD} (removed legacy file)`);
-  return true;
-}
-function loadClaudeMdTemplate(projectName) {
-  const templatePath = resolveTemplateFile("CLAUDE.md.template");
-  if (!templatePath) {
-    throw new Error("CLAUDE.md.template not found. Run npm run build.");
-  }
-  const displayName = projectName.replace(/_/g, " ");
-  return fs34.readFileSync(templatePath, "utf8").replace(/__PROJECT_DISPLAY_NAME__/g, displayName);
-}
-function isThinClaudePointer(content) {
-  const trimmed = content.trim();
-  if (trimmed.length > 600) return false;
-  return /AGENTS\.md|AGENT\.md/.test(trimmed) && (trimmed.includes(".har/README.md") || trimmed.includes("har-workflow"));
-}
-var CLAUDE_POINTER_BLOCK = `${CLAUDE_HAR_SECTION_START}
-## HAR
-
-This repository uses a \`.har/\` harness. Read [AGENTS.md](./AGENTS.md) and
-[\`.har/README.md\`](./.har/README.md) before making changes.
-${CLAUDE_HAR_SECTION_END}`;
-function ensureClaudeMdPointer(repoPath, options = {}) {
-  const dest = path39.join(repoPath, CLAUDE_MD);
-  const projectName = path39.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
-  const thin = loadClaudeMdTemplate(projectName);
-  if (!fs34.existsSync(dest)) {
-    writeFileSafe(dest, thin);
-    return "created";
-  }
-  const existing = fs34.readFileSync(dest, "utf8");
-  if (isThinClaudePointer(existing) || options.force) {
-    writeFileSafe(dest, thin);
-    return "updated";
-  }
-  if (existing.includes(CLAUDE_HAR_SECTION_START) || /\[AGENTS\.md\]/.test(existing)) {
-    if (existing.includes(CLAUDE_HAR_SECTION_START)) {
-      const { content: content2, action: action2 } = upsertMarkedBlock(
-        existing,
-        CLAUDE_POINTER_BLOCK,
-        CLAUDE_HAR_SECTION_START,
-        CLAUDE_HAR_SECTION_END
-      );
-      writeFileSafe(dest, content2);
-      return action2;
-    }
-    return "skipped";
-  }
-  const { content, action } = upsertMarkedBlock(
-    existing,
-    CLAUDE_POINTER_BLOCK,
-    CLAUDE_HAR_SECTION_START,
-    CLAUDE_HAR_SECTION_END
-  );
-  writeFileSafe(dest, content);
-  return action;
-}
-async function askYesNo2(question, defaultYes = true) {
-  const rl = readline2.createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve47) => {
-    process.stderr.write(`${question} `);
-    rl.once("line", (answer) => {
-      rl.close();
-      const trimmed = answer.trim();
-      if (trimmed === "") {
-        resolve47(defaultYes);
-        return;
-      }
-      resolve47(/^y(es)?$/i.test(trimmed));
-    });
-  });
-}
-async function handleInstructionFiles(options) {
-  const { repoPath, mode } = options;
-  const writeAgentsMd = options.writeAgentsMd !== false;
-  const skillsEnabled = options.enabled !== false;
-  const detection = detectInstructionFiles(repoPath);
-  let targets;
-  if (!skillsEnabled) {
-    targets = [];
-  } else if (typeof options.agents === "string") {
-    targets = parseAgentTargets(options.agents);
-  } else {
-    targets = detectAgentTargets(repoPath);
-  }
-  if (skillsEnabled && targets.length === 0 && mode === "init" && typeof options.agents !== "string" && !options.autoYes) {
-    targets = [...AGENT_SKILL_TARGETS];
-  }
-  let plan = buildInstallPlan(detection, targets, {
-    writeAgentsMd,
-    cursorRule: options.cursorRule,
-    skillsEnabled
-  });
-  divider();
-  process.stderr.write(`${formatDetectionReport(detection)}
-
-`);
-  process.stderr.write(`${formatInstallPlan(plan, detection)}
-`);
-  divider();
-  const shouldPrompt = !options.autoYes && skillsEnabled && typeof options.agents !== "string" && !(mode === "maintain" && targets.length > 0 && !detection.agentMd);
-  if (shouldPrompt && targets.length > 0) {
-    const accepted = await askYesNo2(
-      `Install HAR agent instructions for: ${targets.join(", ")}? [Y/n]`
-    );
-    if (!accepted) {
-      info("Skipped agent instruction adapters (AGENTS.md will still be updated)");
-      targets = [];
-      plan = buildInstallPlan(detection, targets, {
-        writeAgentsMd,
-        cursorRule: options.cursorRule === true ? true : false,
-        skillsEnabled: false
-      });
-    }
-  }
-  let migratedLegacy = false;
-  let agentsMdAction = null;
-  let claudeMdAction = null;
-  if (writeAgentsMd) {
-    if (detection.agentMd) {
-      migratedLegacy = migrateLegacyAgentMd(repoPath);
-    }
-    agentsMdAction = upsertAgentsMdHarSection(repoPath);
-    if (agentsMdAction === "created") {
-      success(`Wrote ${AGENTS_MD}`);
-    } else if (agentsMdAction === "updated" || agentsMdAction === "appended") {
-      info(
-        `${agentsMdAction === "updated" ? "Refreshed" : "Appended"} HAR section in ${AGENTS_MD}`
-      );
-    }
-  } else {
-    agentsMdAction = "skipped";
-  }
-  if (plan.claudeMd) {
-    claudeMdAction = ensureClaudeMdPointer(repoPath);
-    if (claudeMdAction === "created") {
-      success(`Wrote ${CLAUDE_MD} (pointer \u2192 ${AGENTS_MD})`);
-    } else if (claudeMdAction === "updated" || claudeMdAction === "appended") {
-      info(
-        `${claudeMdAction === "updated" ? "Updated" : "Appended"} ${CLAUDE_MD} pointer \u2192 ${AGENTS_MD}`
-      );
-    }
-  } else {
-    claudeMdAction = "skipped";
-  }
-  return {
-    detection,
-    plan,
-    targets,
-    agentsMdAction,
-    migratedLegacy,
-    claudeMdAction
-  };
-}
-
 // src/harness/maintain-bundle.ts
 var MAINTAIN_DIR = "maintain";
 var PROFILE_DIRS3 = {
@@ -66907,14 +67204,14 @@ function substituteProjectName2(content, projectName) {
   return content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
 }
 function projectNameFromRepo(repoPath) {
-  return path40.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  return path41.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
 }
 function boilerplateDirForProfile(profile) {
-  return path40.join(resolveTemplatesDir(), PROFILE_DIRS3[profile]);
+  return path41.join(resolveTemplatesDir(), PROFILE_DIRS3[profile]);
 }
 function readBundledTemplateContent(repoPath, profile, file) {
-  const templatePath = path40.join(boilerplateDirForProfile(profile), templateFileForHarness(file));
-  let content = fs35.readFileSync(templatePath, "utf8");
+  const templatePath = path41.join(boilerplateDirForProfile(profile), templateFileForHarness(file));
+  let content = fs36.readFileSync(templatePath, "utf8");
   if (file === "harness.env") {
     content = substituteProjectName2(content, projectNameFromRepo(repoPath));
   }
@@ -66945,12 +67242,12 @@ function actionHint(file, kind) {
   return `Read maintain/diffs/${file}.diff and merge into .har/${file}.`;
 }
 function createUnifiedDiff(installedContent, templateContent, installedLabel, templateLabel) {
-  const tmpDir = fs35.mkdtempSync(path40.join(os14.tmpdir(), "har-maintain-diff-"));
+  const tmpDir = fs36.mkdtempSync(path41.join(os14.tmpdir(), "har-maintain-diff-"));
   try {
-    const installedPath = path40.join(tmpDir, "installed");
-    const templatePath = path40.join(tmpDir, "template");
-    fs35.writeFileSync(installedPath, installedContent);
-    fs35.writeFileSync(templatePath, templateContent);
+    const installedPath = path41.join(tmpDir, "installed");
+    const templatePath = path41.join(tmpDir, "template");
+    fs36.writeFileSync(installedPath, installedContent);
+    fs36.writeFileSync(templatePath, templateContent);
     const result = run(`diff -u "${installedPath}" "${templatePath}"`);
     const body = result.stdout.trim();
     if (!body) return "";
@@ -66959,7 +67256,7 @@ function createUnifiedDiff(installedContent, templateContent, installedLabel, te
 ${body.split("\n").slice(2).join("\n")}
 `;
   } finally {
-    fs35.rmSync(tmpDir, { recursive: true, force: true });
+    fs36.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function buildActions(repoPath, profile, drift) {
@@ -66974,7 +67271,7 @@ function buildActions(repoPath, profile, drift) {
     });
   }
   for (const file of drift.checksumMismatch) {
-    const installedPath = path40.join(harnessDir, file);
+    const installedPath = path41.join(harnessDir, file);
     const installedRel = `maintain/installed/${file}`;
     const templateRel = `maintain/templates/${file}`;
     const diffRel = `maintain/diffs/${file}.diff`;
@@ -66982,7 +67279,7 @@ function buildActions(repoPath, profile, drift) {
       file,
       kind: "drift",
       template: templateRel,
-      installed: fs35.existsSync(installedPath) ? installedRel : void 0,
+      installed: fs36.existsSync(installedPath) ? installedRel : void 0,
       diff: diffRel,
       hint: actionHint(file, "drift")
     });
@@ -67101,6 +67398,10 @@ function buildReadme(report) {
     lines2.push("", "## Agent instruction files (generator 0.5.0)", "");
     lines2.push(
       "Repo-root agent docs are **outside** `.har/` checksum drift. Apply while adapting:",
+      "",
+      "**Merge contract:** `har env maintain --finalize` refreshes only the content between",
+      "`<!-- har:agent-environment:start/end -->` in `AGENTS.md`. Custom `## Project` sections and",
+      "other guidance **outside** those markers must survive finalize \u2014 relocate them if needed.",
       ""
     );
     for (const note of report.instructionFiles) {
@@ -67130,28 +67431,28 @@ function buildReadme(report) {
 }
 function writeBundleArtifacts(repoPath, profile, drift, report) {
   const harnessDir = getHarnessDir(repoPath);
-  const bundleDir = path40.join(harnessDir, MAINTAIN_DIR);
-  if (fs35.existsSync(bundleDir)) {
-    fs35.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path41.join(harnessDir, MAINTAIN_DIR);
+  if (fs36.existsSync(bundleDir)) {
+    fs36.rmSync(bundleDir, { recursive: true, force: true });
   }
   const dirs = [
     bundleDir,
-    path40.join(bundleDir, "templates"),
-    path40.join(bundleDir, "installed"),
-    path40.join(bundleDir, "diffs"),
-    path40.join(bundleDir, "stale")
+    path41.join(bundleDir, "templates"),
+    path41.join(bundleDir, "installed"),
+    path41.join(bundleDir, "diffs"),
+    path41.join(bundleDir, "stale")
   ];
   for (const dir of dirs) {
-    fs35.mkdirSync(dir, { recursive: true });
+    fs36.mkdirSync(dir, { recursive: true });
   }
   const affectedFiles = [...drift.missing, ...drift.checksumMismatch];
   for (const file of affectedFiles) {
     const templateContent = readBundledTemplateContent(repoPath, profile, file);
-    writeFileSafe(path40.join(bundleDir, "templates", file), templateContent);
-    const harnessPath = path40.join(harnessDir, file);
-    if (fs35.existsSync(harnessPath)) {
-      const installedContent = fs35.readFileSync(harnessPath, "utf8");
-      writeFileSafe(path40.join(bundleDir, "installed", file), installedContent);
+    writeFileSafe(path41.join(bundleDir, "templates", file), templateContent);
+    const harnessPath = path41.join(harnessDir, file);
+    if (fs36.existsSync(harnessPath)) {
+      const installedContent = fs36.readFileSync(harnessPath, "utf8");
+      writeFileSafe(path41.join(bundleDir, "installed", file), installedContent);
       const diff = createUnifiedDiff(
         installedContent,
         templateContent,
@@ -67159,14 +67460,14 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
         `templates/${file}`
       );
       if (diff) {
-        writeFileSafe(path40.join(bundleDir, "diffs", `${file}.diff`), diff);
+        writeFileSafe(path41.join(bundleDir, "diffs", `${file}.diff`), diff);
       }
     }
   }
-  writeFileSafe(path40.join(bundleDir, "README.md"), buildReadme(report));
-  writeFileSafe(path40.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
+  writeFileSafe(path41.join(bundleDir, "README.md"), buildReadme(report));
+  writeFileSafe(path41.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
   writeFileSafe(
-    path40.join(bundleDir, "validation.json"),
+    path41.join(bundleDir, "validation.json"),
     JSON.stringify(report.validation, null, 2) + "\n"
   );
   if (report.stale.length > 0) {
@@ -67178,34 +67479,34 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
       ...report.stale.map((s) => `- **${s.file}** \u2014 ${s.hint}`),
       ""
     ];
-    writeFileSafe(path40.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
+    writeFileSafe(path41.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
   }
   return bundleDir;
 }
 function ensureParentDir2(filePath) {
-  const parent = path40.dirname(filePath);
-  if (!fs35.existsSync(parent)) {
-    fs35.mkdirSync(parent, { recursive: true });
+  const parent = path41.dirname(filePath);
+  if (!fs36.existsSync(parent)) {
+    fs36.mkdirSync(parent, { recursive: true });
   }
 }
 function writePluginBundleArtifacts(repoPath, bundleDir, report) {
   if (report.pluginActions.length === 0) return;
   for (const action of report.pluginActions) {
-    const pluginRoot = path40.join(bundleDir, "plugins", action.pluginId);
-    const templatesDir = path40.join(pluginRoot, "templates");
-    const installedDir = path40.join(pluginRoot, "installed");
-    const diffsDir = path40.join(pluginRoot, "diffs");
+    const pluginRoot = path41.join(bundleDir, "plugins", action.pluginId);
+    const templatesDir = path41.join(pluginRoot, "templates");
+    const installedDir = path41.join(pluginRoot, "installed");
+    const diffsDir = path41.join(pluginRoot, "diffs");
     for (const dir of [templatesDir, installedDir, diffsDir]) {
-      fs35.mkdirSync(dir, { recursive: true });
+      fs36.mkdirSync(dir, { recursive: true });
     }
     const templateContent = readTemplatePluginFile(action.pluginId, action.file);
     if (templateContent === null) continue;
-    const templatePath = path40.join(templatesDir, action.file);
+    const templatePath = path41.join(templatesDir, action.file);
     ensureParentDir2(templatePath);
     writeFileSafe(templatePath, templateContent);
     const installedContent = readInstalledPluginFile(repoPath, action.pluginId, action.file);
     if (installedContent !== null) {
-      const installedPath = path40.join(installedDir, action.file);
+      const installedPath = path41.join(installedDir, action.file);
       ensureParentDir2(installedPath);
       writeFileSafe(installedPath, installedContent);
       const diff = createUnifiedDiff(
@@ -67215,7 +67516,7 @@ function writePluginBundleArtifacts(repoPath, bundleDir, report) {
         `templates/${action.file}`
       );
       if (diff) {
-        const diffPath = path40.join(diffsDir, `${action.file}.diff`);
+        const diffPath = path41.join(diffsDir, `${action.file}.diff`);
         ensureParentDir2(diffPath);
         writeFileSafe(diffPath, diff);
       }
@@ -67251,9 +67552,9 @@ function buildMaintainBundle(repoPath, validation2, drift) {
   return { bundleDir, report };
 }
 function removeMaintainBundle(repoPath) {
-  const bundleDir = path40.join(getHarnessDir(repoPath), MAINTAIN_DIR);
-  if (fs35.existsSync(bundleDir)) {
-    fs35.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path41.join(getHarnessDir(repoPath), MAINTAIN_DIR);
+  if (fs36.existsSync(bundleDir)) {
+    fs36.rmSync(bundleDir, { recursive: true, force: true });
   }
 }
 function formatMaintainBundlePromptSection(report) {
@@ -67342,11 +67643,11 @@ init_manifest();
 init_stages();
 function listHarnessScripts(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs36.existsSync(harnessDir)) return [];
-  return fs36.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
+  if (!fs37.existsSync(harnessDir)) return [];
+  return fs37.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
 }
 function describeProject(repoPath) {
-  const resolved = path41.resolve(repoPath);
+  const resolved = path42.resolve(repoPath);
   const manifest = readManifest(resolved);
   const present = harnessExists(resolved);
   return {
@@ -67366,8 +67667,8 @@ function describeProject(repoPath) {
   };
 }
 async function initHarness(options) {
-  const repoPath = path41.resolve(options.repoPath);
-  if (!fs36.existsSync(repoPath)) {
+  const repoPath = path42.resolve(options.repoPath);
+  if (!fs37.existsSync(repoPath)) {
     throw new Error(`Path not found: ${repoPath}`);
   }
   const scaffold = scaffoldHarnessBoilerplate(repoPath, {
@@ -67387,9 +67688,9 @@ async function initHarness(options) {
   };
 }
 async function maintainHarness(options) {
-  const repoPath = path41.resolve(options.repoPath);
+  const repoPath = path42.resolve(options.repoPath);
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs36.existsSync(harnessDir)) {
+  if (!fs37.existsSync(harnessDir)) {
     throw new Error('No .har/ found. Run "har env init" first.');
   }
   const drift = compareHarnessToTemplate(repoPath);
@@ -67399,6 +67700,7 @@ async function maintainHarness(options) {
       throw new Error("Cannot finalize: harness validation has errors. Fix them first.");
     }
     syncAgentSlotsToHarnessEnv(repoPath);
+    finalizeAgentsMdInstructionFiles(repoPath);
     const existing = readManifest(repoPath);
     finalizeHarness(
       repoPath,
@@ -67423,13 +67725,13 @@ function addPlugin(repoPath, pluginId, options = {}) {
 }
 
 // src/harness/custom-stage.ts
-var fs37 = __toESM(require("fs"));
-var path42 = __toESM(require("path"));
+var fs38 = __toESM(require("fs"));
+var path43 = __toESM(require("path"));
 init_schema2();
 init_stages();
 var STAGE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 function addCustomStage(repoPath, options) {
-  const resolved = path42.resolve(repoPath);
+  const resolved = path43.resolve(repoPath);
   if (!harnessExists(resolved)) {
     throw new Error('No .har/ harness found. Run "har env init" first.');
   }
@@ -67466,20 +67768,20 @@ function addCustomStage(repoPath, options) {
   if (options.command) {
     stage.command = options.command;
   } else {
-    const scriptRel = path42.join("stages", `${id}.sh`);
-    const scriptAbs = path42.join(resolved, ".har", scriptRel);
-    if (fs37.existsSync(scriptAbs) && !options.force) {
+    const scriptRel = path43.join("stages", `${id}.sh`);
+    const scriptAbs = path43.join(resolved, ".har", scriptRel);
+    if (fs38.existsSync(scriptAbs) && !options.force) {
       throw new Error(`Stage script already exists: .har/${scriptRel}. Use --force to overwrite.`);
     }
-    const skeletonPath = path42.join(
+    const skeletonPath = path43.join(
       resolveTemplatesDir(),
       "plugins",
       "custom-stage-skeleton.sh"
     );
-    const skeleton = fs37.readFileSync(skeletonPath, "utf8").replace(/__STAGE_ID__/g, id).replace(/__STAGE_KIND__/g, kind).replace(/__STAGE_DESCRIPTION__/g, stage.description);
-    fs37.mkdirSync(path42.dirname(scriptAbs), { recursive: true });
-    fs37.writeFileSync(scriptAbs, skeleton);
-    fs37.chmodSync(scriptAbs, 493);
+    const skeleton = fs38.readFileSync(skeletonPath, "utf8").replace(/__STAGE_ID__/g, id).replace(/__STAGE_KIND__/g, kind).replace(/__STAGE_DESCRIPTION__/g, stage.description);
+    fs38.mkdirSync(path43.dirname(scriptAbs), { recursive: true });
+    fs38.writeFileSync(scriptAbs, skeleton);
+    fs38.chmodSync(scriptAbs, 493);
     filesWritten.push(`.har/${scriptRel}`);
     stage.script = scriptRel;
     stage.artifacts = [
@@ -67527,8 +67829,8 @@ function addCustomStage(repoPath, options) {
 }
 
 // src/harness/adaptation-prompt.ts
-var fs38 = __toESM(require("fs"));
-var path43 = __toESM(require("path"));
+var fs39 = __toESM(require("fs"));
+var path44 = __toESM(require("path"));
 var readline3 = __toESM(require("readline"));
 
 // src/utils/clipboard.ts
@@ -67618,7 +67920,7 @@ function loadTemplate(name) {
   if (!filePath) {
     throw new Error(`Adaptation prompt template not found: ${name}. Run npm run build.`);
   }
-  return fs38.readFileSync(filePath, "utf8");
+  return fs39.readFileSync(filePath, "utf8");
 }
 function applyProfilePlaceholders(content, profile) {
   return content.replace(/\{\{PROFILE\}\}/g, profile).replace(/\{\{PROFILE_HINT\}\}/g, PROFILE_HINTS[profile]);
@@ -67640,7 +67942,7 @@ function buildMaintainAdaptationPrompt(_repoPath, bundleReport) {
 }
 function writeAdaptationPrompt(repoPath, content) {
   const harnessDir = getHarnessDir(repoPath);
-  const filePath = path43.join(harnessDir, ADAPTATION_PROMPT_FILE);
+  const filePath = path44.join(harnessDir, ADAPTATION_PROMPT_FILE);
   writeFileSafe(filePath, content);
   return filePath;
 }
@@ -67695,27 +67997,27 @@ async function offerAdaptationPromptClipboard(content, options = {}) {
 }
 
 // src/harness/cursor-rule.ts
-var fs39 = __toESM(require("fs"));
-var path44 = __toESM(require("path"));
+var fs40 = __toESM(require("fs"));
+var path45 = __toESM(require("path"));
 var readline4 = __toESM(require("readline"));
 init_file_ops();
 init_logging();
 var CURSOR_RULE_RELATIVE_PATH = ".cursor/rules/har-workflow.mdc";
 function getCursorRulePath(repoPath) {
-  return path44.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
+  return path45.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
 }
 function isCursorWorkspace(repoPath) {
-  return fs39.existsSync(path44.join(repoPath, ".cursor"));
+  return fs40.existsSync(path45.join(repoPath, ".cursor"));
 }
 function cursorRuleExists(repoPath) {
-  return fs39.existsSync(getCursorRulePath(repoPath));
+  return fs40.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 = fs39.readFileSync(templatePath, "utf8");
+  const content = fs40.readFileSync(templatePath, "utf8");
   writeFileSafe(getCursorRulePath(repoPath), content);
 }
 async function handleCursorRule(options) {
@@ -67805,7 +68107,7 @@ init_control_config();
 
 // src/core/control-lifecycle.ts
 var import_child_process9 = require("child_process");
-var path45 = __toESM(require("path"));
+var path46 = __toESM(require("path"));
 
 // src/core/control-image.ts
 var DEFAULT_CONTROL_IMAGE = "theosfactory/har-control";
@@ -67831,10 +68133,10 @@ var CONTROL_DATA_VOLUME = "har_control_data";
 var CONTROL_CONTAINER_PORT = 3847;
 var CONTROL_DATA_DB_URL = "file:/data/har_control.db";
 function resolveControlDir() {
-  return path45.resolve(__dirname, "..", "control");
+  return path46.resolve(__dirname, "..", "control");
 }
 function resolveControlBuildContext() {
-  return path45.resolve(resolveControlDir(), "..");
+  return path46.resolve(resolveControlDir(), "..");
 }
 function buildDockerRunArgs(options) {
   const name = options.containerName ?? CONTROL_CONTAINER_NAME;
@@ -67890,7 +68192,7 @@ async function startMissionControl(options) {
       "-t",
       imageRef,
       "-f",
-      path45.join(resolveControlDir(), "Dockerfile"),
+      path46.join(resolveControlDir(), "Dockerfile"),
       resolveControlBuildContext()
     ]);
     if (buildCode !== 0) {
@@ -68037,7 +68339,7 @@ async function ensureTelemetryInfrastructure(options) {
 // src/core/run-service.ts
 init_telemetry_config();
 init_telemetry_env();
-var path47 = __toESM(require("path"));
+var path48 = __toESM(require("path"));
 init_local_executor();
 function extractShellOutput(result) {
   const stdout = result.logs?.find((log) => log.stream === "stdout")?.content ?? result.logs?.find((log) => !log.stream)?.content ?? "";
@@ -68240,12 +68542,12 @@ Usage from Cursor / Claude / Codex (@osfactory/otel-hook) will appear under Work
           suffix: session.suffix,
           createdAt: session.createdAt
         });
-        const envFile = path47.join(session.workDir, `.env.agent.${options.agentId}`);
+        const envFile = path48.join(session.workDir, `.env.agent.${options.agentId}`);
         try {
           appendTelemetryEnvToFile(envFile, {
             sessionKey,
             agentId: options.agentId,
-            repoPath: path47.resolve(options.repoPath),
+            repoPath: path48.resolve(options.repoPath),
             workDir: session.workDir,
             branch: session.branch,
             suffix: session.suffix,
@@ -68483,9 +68785,9 @@ init_slot_status();
 var readline5 = __toESM(require("readline"));
 
 // src/core/hooks.ts
-var fs41 = __toESM(require("fs"));
+var fs42 = __toESM(require("fs"));
 var os16 = __toESM(require("os"));
-var path48 = __toESM(require("path"));
+var path49 = __toESM(require("path"));
 init_shell();
 init_schema2();
 init_stages();
@@ -68516,7 +68818,7 @@ function resolveCheckoutRoot(cwd) {
 function resolveHooksDir(checkoutDir) {
   const hooksPath = tryGit3(checkoutDir, "rev-parse --git-path hooks");
   if (!hooksPath) throw new Error(`Not a git checkout: ${checkoutDir}`);
-  return path48.resolve(checkoutDir, hooksPath);
+  return path49.resolve(checkoutDir, hooksPath);
 }
 function getConfiguredHooksPath(checkoutDir) {
   return tryGit3(checkoutDir, "config core.hooksPath") || void 0;
@@ -68524,9 +68826,9 @@ function getConfiguredHooksPath(checkoutDir) {
 function defaultHarInvocation() {
   const entry = process.argv[1];
   if (entry && entry.endsWith(".js")) {
-    return `"${process.execPath}" "${path48.resolve(entry)}"`;
+    return `"${process.execPath}" "${path49.resolve(entry)}"`;
   }
-  if (entry) return `"${path48.resolve(entry)}"`;
+  if (entry) return `"${path49.resolve(entry)}"`;
   return "har";
 }
 function buildHookScript(harInvocation, subcommand, failOpenNotice) {
@@ -68547,40 +68849,40 @@ exit 0
 `;
 }
 function upsertMarkedBlock2(filePath, block) {
-  if (!fs41.existsSync(filePath)) {
-    fs41.writeFileSync(filePath, `#!/bin/sh
+  if (!fs42.existsSync(filePath)) {
+    fs42.writeFileSync(filePath, `#!/bin/sh
 ${block}
 `, { mode: 493 });
     return "created";
   }
-  const content = fs41.readFileSync(filePath, "utf8");
+  const content = fs42.readFileSync(filePath, "utf8");
   if (content.includes(MARKER_START)) {
     const pattern = new RegExp(
       `${escapeRegExp2(MARKER_START)}[\\s\\S]*?${escapeRegExp2(MARKER_END)}`
     );
-    fs41.writeFileSync(filePath, content.replace(pattern, block));
-    fs41.chmodSync(filePath, 493);
+    fs42.writeFileSync(filePath, content.replace(pattern, block));
+    fs42.chmodSync(filePath, 493);
     return "updated";
   }
   const suffix = content.endsWith("\n") ? "" : "\n";
-  fs41.writeFileSync(filePath, `${content}${suffix}
+  fs42.writeFileSync(filePath, `${content}${suffix}
 ${block}
 `);
-  fs41.chmodSync(filePath, 493);
+  fs42.chmodSync(filePath, 493);
   return "appended";
 }
 function removeMarkedBlock(filePath) {
-  if (!fs41.existsSync(filePath)) return false;
-  const content = fs41.readFileSync(filePath, "utf8");
+  if (!fs42.existsSync(filePath)) return false;
+  const content = fs42.readFileSync(filePath, "utf8");
   if (!content.includes(MARKER_START)) return false;
   const pattern = new RegExp(
     `\\n?${escapeRegExp2(MARKER_START)}[\\s\\S]*?${escapeRegExp2(MARKER_END)}\\n?`
   );
   const stripped = content.replace(pattern, "\n");
   if (stripped.replace(/^#!\/bin\/sh\n?/, "").trim() === "") {
-    fs41.rmSync(filePath);
+    fs42.rmSync(filePath);
   } else {
-    fs41.writeFileSync(filePath, stripped);
+    fs42.writeFileSync(filePath, stripped);
   }
   return true;
 }
@@ -68602,20 +68904,20 @@ Or re-run with --force to write into that directory anyway.`
     );
   }
   const hooksDir = resolveHooksDir(checkout);
-  fs41.mkdirSync(hooksDir, { recursive: true });
+  fs42.mkdirSync(hooksDir, { recursive: true });
   const invocation = options.harInvocation ?? defaultHarInvocation();
-  fs41.writeFileSync(
-    path48.join(hooksDir, "har-pre-commit"),
+  fs42.writeFileSync(
+    path49.join(hooksDir, "har-pre-commit"),
     buildHookScript(invocation, "check", "har: binary not found; skipping commit gate (reinstall with har hooks install)"),
     { mode: 493 }
   );
-  fs41.writeFileSync(
-    path48.join(hooksDir, "har-post-commit"),
+  fs42.writeFileSync(
+    path49.join(hooksDir, "har-post-commit"),
     buildHookScript(invocation, "record-commit", "har: binary not found; skipping commit association"),
     { mode: 493 }
   );
-  const preCommit = upsertMarkedBlock2(path48.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
-  const postCommit = upsertMarkedBlock2(path48.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
+  const preCommit = upsertMarkedBlock2(path49.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
+  const postCommit = upsertMarkedBlock2(path49.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
   ensureValidationsIgnored(checkout);
   return { hooksDir, preCommit, postCommit };
 }
@@ -68624,12 +68926,12 @@ function uninstallHooks(repoPath) {
   if (!checkout) throw new Error(`Not a git repository: ${repoPath}`);
   const hooksDir = resolveHooksDir(checkout);
   let removed = false;
-  removed = removeMarkedBlock(path48.join(hooksDir, "pre-commit")) || removed;
-  removed = removeMarkedBlock(path48.join(hooksDir, "post-commit")) || removed;
+  removed = removeMarkedBlock(path49.join(hooksDir, "pre-commit")) || removed;
+  removed = removeMarkedBlock(path49.join(hooksDir, "post-commit")) || removed;
   for (const file of ["har-pre-commit", "har-post-commit"]) {
-    const full = path48.join(hooksDir, file);
-    if (fs41.existsSync(full)) {
-      fs41.rmSync(full);
+    const full = path49.join(hooksDir, file);
+    if (fs42.existsSync(full)) {
+      fs42.rmSync(full);
       removed = true;
     }
   }
@@ -68648,10 +68950,10 @@ function isAgentWorktree(checkoutDir) {
   if (branch && (/^har-agent-\d+$/.test(branch) || /-har-agent-\d+-[a-z0-9]+$/.test(branch))) {
     return true;
   }
-  const worktreesRoot = path48.join(os16.homedir(), "worktrees");
-  const resolved = path48.resolve(checkoutDir);
-  const name = path48.basename(resolved);
-  return resolved.startsWith(`${worktreesRoot}${path48.sep}`) && (/-agent-\d+$/.test(name) || /-har-agent-\d+-[a-z0-9]+$/.test(name));
+  const worktreesRoot = path49.join(os16.homedir(), "worktrees");
+  const resolved = path49.resolve(checkoutDir);
+  const name = path49.basename(resolved);
+  return resolved.startsWith(`${worktreesRoot}${path49.sep}`) && (/-agent-\d+$/.test(name) || /-har-agent-\d+-[a-z0-9]+$/.test(name));
 }
 function resolveEffectiveMode(checkoutDir, gate) {
   if (!gate.enabled) return "off";
@@ -68664,15 +68966,15 @@ function getHooksStatus(repoPath) {
   const hooksDir = resolveHooksDir(checkout);
   const gate = getCommitGateConfig(checkout);
   const hasBlock = (name) => {
-    const file = path48.join(hooksDir, name);
-    return fs41.existsSync(file) && fs41.readFileSync(file, "utf8").includes(MARKER_START);
+    const file = path49.join(hooksDir, name);
+    return fs42.existsSync(file) && fs42.readFileSync(file, "utf8").includes(MARKER_START);
   };
   return {
     checkout,
     hooksDir,
     configuredHooksPath: getConfiguredHooksPath(checkout),
-    preCommitInstalled: hasBlock("pre-commit") && fs41.existsSync(path48.join(hooksDir, "har-pre-commit")),
-    postCommitInstalled: hasBlock("post-commit") && fs41.existsSync(path48.join(hooksDir, "har-post-commit")),
+    preCommitInstalled: hasBlock("pre-commit") && fs42.existsSync(path49.join(hooksDir, "har-pre-commit")),
+    postCommitInstalled: hasBlock("post-commit") && fs42.existsSync(path49.join(hooksDir, "har-post-commit")),
     gate,
     effectiveMode: resolveEffectiveMode(checkout, gate)
   };
@@ -68683,7 +68985,7 @@ function checkCommitGate(cwd) {
   }
   const checkout = resolveCheckoutRoot(cwd);
   if (!checkout) return { exitCode: 0, messages: [] };
-  if (!fs41.existsSync(path48.join(checkout, ".har", "stages.json"))) {
+  if (!fs42.existsSync(path49.join(checkout, ".har", "stages.json"))) {
     return { exitCode: 0, messages: [] };
   }
   const gate = getCommitGateConfig(checkout);
@@ -68805,21 +69107,21 @@ async function handleCommitGateOnboarding(options) {
 }
 
 // src/core/onboarding-preferences.ts
-var fs42 = __toESM(require("fs"));
+var fs43 = __toESM(require("fs"));
 var os17 = __toESM(require("os"));
-var path49 = __toESM(require("path"));
+var path50 = __toESM(require("path"));
 init_schema2();
 function getOnboardingPreferencesPath() {
   if (process.env.HAR_PREFERENCES_PATH) {
-    return path49.resolve(process.env.HAR_PREFERENCES_PATH);
+    return path50.resolve(process.env.HAR_PREFERENCES_PATH);
   }
-  return path49.join(os17.homedir(), ".har", "preferences.json");
+  return path50.join(os17.homedir(), ".har", "preferences.json");
 }
 function readOnboardingPreferences() {
   const preferencePath = getOnboardingPreferencesPath();
   try {
-    if (!fs42.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
-    return OnboardingPreferencesSchema.parse(JSON.parse(fs42.readFileSync(preferencePath, "utf8")));
+    if (!fs43.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
+    return OnboardingPreferencesSchema.parse(JSON.parse(fs43.readFileSync(preferencePath, "utf8")));
   } catch {
     return OnboardingPreferencesSchema.parse({});
   }
@@ -68844,8 +69146,8 @@ function writeOnboardingPreferences(overrides) {
   };
   const parsed = OnboardingPreferencesSchema.parse(preference);
   const preferencePath = getOnboardingPreferencesPath();
-  fs42.mkdirSync(path49.dirname(preferencePath), { recursive: true });
-  fs42.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
+  fs43.mkdirSync(path50.dirname(preferencePath), { recursive: true });
+  fs43.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return parsed;
 }
@@ -69136,7 +69438,7 @@ var envCommand = {
   }
 };
 async function handleInit(argv) {
-  const repoPath = path50.resolve(argv.repo);
+  const repoPath = path51.resolve(argv.repo);
   const onboarding = resolveOnboardingOptions(argv);
   header("har env init");
   info(`Repository: ${repoPath}`);
@@ -69182,7 +69484,7 @@ async function handleInit(argv) {
   }
 }
 async function handleMaintain(argv) {
-  const repoPath = path50.resolve(argv.repo);
+  const repoPath = path51.resolve(argv.repo);
   const onboarding = resolveOnboardingOptions(argv);
   header("har env maintain");
   info(`Repository: ${repoPath}`);
@@ -69237,6 +69539,8 @@ async function handleMaintain(argv) {
       mode: "maintain",
       autoYes: argv.yes,
       cursorRule: onboarding.cursorRule,
+      writeAgentsMd: !argv.finalize,
+      finalize: argv.finalize,
       ...onboarding.agentSkills
     });
   } catch (err) {
@@ -69288,7 +69592,9 @@ async function applyAgentIntegrations(options) {
     enabled: options.enabled,
     cursorRule: options.cursorRule,
     autoYes: options.autoYes,
-    mode: options.mode
+    mode: options.mode,
+    writeAgentsMd: options.writeAgentsMd,
+    finalize: options.finalize
   });
   const cursorRuleFlag = options.cursorRule === false ? false : options.cursorRule === true || instruction.plan.cursorRule ? true : false;
   await handleCursorRule({
@@ -69309,7 +69615,7 @@ async function applyAgentIntegrations(options) {
   }
 }
 async function handleAddPlugin(argv) {
-  const repoPath = path50.resolve(argv.repo);
+  const repoPath = path51.resolve(argv.repo);
   const available = listPluginIds();
   if (argv.list) {
     for (const id of available) {
@@ -69347,7 +69653,7 @@ async function handleAddPlugin(argv) {
   }
 }
 async function handleAddStage(argv) {
-  const repoPath = path50.resolve(argv.repo);
+  const repoPath = path51.resolve(argv.repo);
   const available = listPluginIds();
   if (argv.list) {
     warn("har env add-stage --list is deprecated; prefer: har env add-plugin --list");
@@ -69413,7 +69719,7 @@ async function handleAddStage(argv) {
   });
 }
 async function handlePreflight(argv) {
-  const repo = path50.resolve(argv.repo);
+  const repo = path51.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await preflightEnvironment({
     repoPath: repo,
@@ -69429,7 +69735,7 @@ async function handlePreflight(argv) {
   return finishCommand(result.code);
 }
 async function handleLaunch(argv) {
-  const repo = path50.resolve(argv.repo);
+  const repo = path51.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   if (!argv.resume) {
     const guard = checkLaunchGuard2(repo, agentId, {});
@@ -69484,7 +69790,7 @@ async function handleRecover(argv) {
   });
 }
 async function handleVerify(argv) {
-  const repo = path50.resolve(argv.repo);
+  const repo = path51.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await runVerification({
     repoPath: repo,
@@ -69496,7 +69802,7 @@ async function handleVerify(argv) {
   return finishCommand(result.code);
 }
 async function handleTeardown(argv) {
-  const repo = path50.resolve(argv.repo);
+  const repo = path51.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await teardownEnvironment({
     repoPath: repo,
@@ -69507,7 +69813,7 @@ async function handleTeardown(argv) {
   return finishCommand(result.code);
 }
 async function handleComplete(argv) {
-  const repo = path50.resolve(argv.repo);
+  const repo = path51.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await completeEnvironment({
     repoPath: repo,
@@ -69528,7 +69834,7 @@ async function handleComplete(argv) {
   return finishCommand(result.code);
 }
 async function handleStatus(argv) {
-  const repoPath = path50.resolve(argv.repo);
+  const repoPath = path51.resolve(argv.repo);
   if (argv.json) {
     const status = collectEnvironmentStatus(repoPath);
     const output = EnvironmentStatusSchema.parse(status);
@@ -69541,7 +69847,7 @@ async function handleStatus(argv) {
   });
 }
 async function handleRunsList(argv) {
-  const repoPath = path50.resolve(argv.repo);
+  const repoPath = path51.resolve(argv.repo);
   const runs = listRuns(repoPath, { stageId: argv.stage, limit: argv.limit });
   if (argv.json) {
     process.stdout.write(JSON.stringify({ runs }, null, 2) + "\n");
@@ -69558,7 +69864,7 @@ async function handleRunsList(argv) {
   }
 }
 async function handleRunsGet(argv) {
-  const run2 = getRun(path50.resolve(argv.repo), argv.runId);
+  const run2 = getRun(path51.resolve(argv.repo), argv.runId);
   if (!run2) {
     error(`Run not found: ${argv.runId}`);
     return finishCommand(1);
@@ -69640,7 +69946,7 @@ function printNextSteps() {
 }
 
 // src/cli/commands/control.ts
-var path54 = __toESM(require("path"));
+var path55 = __toESM(require("path"));
 
 // node_modules/@inquirer/core/dist/esm/lib/key.mjs
 var isUpKey = (key) => (
@@ -71694,9 +72000,9 @@ var import_run_async = __toESM(require_run_async(), 1);
 var import_mute_stream2 = __toESM(require_lib(), 1);
 var import_ansi_escapes5 = __toESM(require_ansi_escapes(), 1);
 var _ = {
-  set: (obj, path61 = "", value) => {
+  set: (obj, path62 = "", value) => {
     let pointer = obj;
-    path61.split(".").forEach((key, index, arr) => {
+    path62.split(".").forEach((key, index, arr) => {
       if (key === "__proto__" || key === "constructor")
         return;
       if (index === arr.length - 1) {
@@ -71707,8 +72013,8 @@ var _ = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path61 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path61, regexp).filter(Boolean).reduce(
+  get: (obj, path62 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path62, regexp).filter(Boolean).reduce(
       // @ts-expect-error implicit any on res[key]
       (res, key) => res !== null && res !== void 0 ? res[key] : res,
       obj
@@ -71962,21 +72268,21 @@ init_control_port();
 init_control_sync();
 
 // src/core/control-sync-selection.ts
-var fs43 = __toESM(require("fs"));
+var fs44 = __toESM(require("fs"));
 var os18 = __toESM(require("os"));
-var path51 = __toESM(require("path"));
+var path52 = __toESM(require("path"));
 init_control_repo_path();
 function getSelectionPath() {
   if (process.env.HAR_CONTROL_SYNC_SELECTION_PATH) {
-    return path51.resolve(process.env.HAR_CONTROL_SYNC_SELECTION_PATH);
+    return path52.resolve(process.env.HAR_CONTROL_SYNC_SELECTION_PATH);
   }
-  return path51.join(os18.homedir(), ".har", "sync-selection.json");
+  return path52.join(os18.homedir(), ".har", "sync-selection.json");
 }
 function readSyncSelection() {
   const selectionPath = getSelectionPath();
   try {
-    if (!fs43.existsSync(selectionPath)) return null;
-    const parsed = JSON.parse(fs43.readFileSync(selectionPath, "utf8"));
+    if (!fs44.existsSync(selectionPath)) return null;
+    const parsed = JSON.parse(fs44.readFileSync(selectionPath, "utf8"));
     if (!Array.isArray(parsed.repos)) return null;
     return parsed.repos.map((repoPath) => canonicalizeControlRepoPath(repoPath));
   } catch {
@@ -71986,8 +72292,8 @@ function readSyncSelection() {
 function writeSyncSelection(repos) {
   const selectionPath = getSelectionPath();
   const canonical = Array.from(new Set(repos.map((repoPath) => canonicalizeControlRepoPath(repoPath))));
-  fs43.mkdirSync(path51.dirname(selectionPath), { recursive: true });
-  fs43.writeFileSync(selectionPath, JSON.stringify({ repos: canonical }, null, 2) + "\n");
+  fs44.mkdirSync(path52.dirname(selectionPath), { recursive: true });
+  fs44.writeFileSync(selectionPath, JSON.stringify({ repos: canonical }, null, 2) + "\n");
 }
 function resolveSyncSelection(input) {
   const { discovered, stored, forceSelect, isTTY } = input;
@@ -72094,8 +72400,8 @@ If your browser did not open, paste that URL.
 }
 
 // src/core/control-unregister.ts
-var fs44 = __toESM(require("fs"));
-var path52 = __toESM(require("path"));
+var fs45 = __toESM(require("fs"));
+var path53 = __toESM(require("path"));
 init_control_repo_path();
 init_control_registry();
 init_control_config();
@@ -72105,9 +72411,9 @@ function listUnregisterWorktreeCandidates(repoPath) {
   const harnessRoot = canonicalizeControlRepoPath(repoPath);
   const byPath = /* @__PURE__ */ new Map();
   const add = (partial2) => {
-    const resolved = path52.resolve(partial2.worktreePath);
+    const resolved = path53.resolve(partial2.worktreePath);
     if (!resolved || resolved === harnessRoot) return;
-    const exists = partial2.exists ?? fs44.existsSync(resolved);
+    const exists = partial2.exists ?? fs45.existsSync(resolved);
     const prev = byPath.get(resolved);
     if (prev) {
       byPath.set(resolved, {
@@ -72221,28 +72527,28 @@ async function teardownWorktrees(repoPath, candidates, dryRun) {
         trigger: "cli"
       });
       if (result.code !== 0) {
-        if (fs44.existsSync(candidate.worktreePath)) {
-          fs44.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs45.existsSync(candidate.worktreePath)) {
+          fs45.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs44.existsSync(candidate.worktreePath),
-        error: result.code !== 0 && fs44.existsSync(candidate.worktreePath) ? result.stderr : void 0
+        deleted: !fs45.existsSync(candidate.worktreePath),
+        error: result.code !== 0 && fs45.existsSync(candidate.worktreePath) ? result.stderr : void 0
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       try {
-        if (fs44.existsSync(candidate.worktreePath)) {
-          fs44.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs45.existsSync(candidate.worktreePath)) {
+          fs45.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       } catch {
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs44.existsSync(candidate.worktreePath),
+        deleted: !fs45.existsSync(candidate.worktreePath),
         error: message
       });
     }
@@ -72305,16 +72611,16 @@ init_control_config();
 init_control_registry();
 
 // src/core/harness-scrub.ts
-var fs45 = __toESM(require("fs"));
-var path53 = __toESM(require("path"));
+var fs46 = __toESM(require("fs"));
+var path54 = __toESM(require("path"));
 var HARNESS_SCRUB_DIRS = ["runs", "validations", "state", "slots"];
 function scrubLocalHarnessDirs(repoPath) {
   const results = [];
-  const resolved = path53.resolve(repoPath);
-  if (!fs45.existsSync(resolved)) {
+  const resolved = path54.resolve(repoPath);
+  if (!fs46.existsSync(resolved)) {
     for (const directory of HARNESS_SCRUB_DIRS) {
       results.push({
-        path: path53.join(resolved, ".har", directory),
+        path: path54.join(resolved, ".har", directory),
         directory,
         deleted: false,
         error: "repository path does not exist"
@@ -72323,24 +72629,24 @@ function scrubLocalHarnessDirs(repoPath) {
     return results;
   }
   for (const directory of HARNESS_SCRUB_DIRS) {
-    const target = path53.join(resolved, ".har", directory);
-    if (!fs45.existsSync(target)) {
+    const target = path54.join(resolved, ".har", directory);
+    if (!fs46.existsSync(target)) {
       results.push({ path: target, directory, deleted: true });
       continue;
     }
     try {
-      fs45.rmSync(target, { recursive: true, force: true });
+      fs46.rmSync(target, { recursive: true, force: true });
       results.push({
         path: target,
         directory,
-        deleted: !fs45.existsSync(target),
-        error: fs45.existsSync(target) ? "failed to remove directory" : void 0
+        deleted: !fs46.existsSync(target),
+        error: fs46.existsSync(target) ? "failed to remove directory" : void 0
       });
     } catch (err) {
       results.push({
         path: target,
         directory,
-        deleted: !fs45.existsSync(target),
+        deleted: !fs46.existsSync(target),
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -72351,7 +72657,7 @@ function scrubLocalHarnessForRepos(repoPaths) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repoPaths) {
-    const key = path53.resolve(repoPath);
+    const key = path54.resolve(repoPath);
     if (seen.has(key)) continue;
     seen.add(key);
     results.push(...scrubLocalHarnessDirs(key));
@@ -72607,7 +72913,7 @@ async function handleDown() {
   return finishCommand(code);
 }
 async function handleRegister(argv) {
-  const repoPath = path54.resolve(argv.repo);
+  const repoPath = path55.resolve(argv.repo);
   header("har control register");
   info(`Repository: ${repoPath}`);
   try {
@@ -72699,7 +73005,7 @@ async function handleReset(argv) {
   }
 }
 async function handleUnregister(argv) {
-  const repoPath = path54.resolve(argv.repo);
+  const repoPath = path55.resolve(argv.repo);
   const worktrees = listUnregisterWorktreeCandidates(repoPath);
   try {
     let deleteWorktrees = argv.deleteWorktrees;
@@ -72878,11 +73184,11 @@ async function handleLogin(argv) {
 }
 
 // src/cli/commands/hooks.ts
-var path56 = __toESM(require("path"));
+var path57 = __toESM(require("path"));
 
 // src/core/claude-hooks.ts
-var fs46 = __toESM(require("fs"));
-var path55 = __toESM(require("path"));
+var fs47 = __toESM(require("fs"));
+var path56 = __toESM(require("path"));
 var CLAUDE_GUARD_RELATIVE_PATH = ".har/hooks/claude-worktree-guard.sh";
 var CLAUDE_SETTINGS_RELATIVE_PATH = ".claude/settings.json";
 var GUARD_MATCHER = "Edit|Write|MultiEdit|NotebookEdit";
@@ -72893,8 +73199,8 @@ function isHarGuardEntry(entry) {
   );
 }
 function readSettings(settingsPath) {
-  if (!fs46.existsSync(settingsPath)) return {};
-  const raw = fs46.readFileSync(settingsPath, "utf8").trim();
+  if (!fs47.existsSync(settingsPath)) return {};
+  const raw = fs47.readFileSync(settingsPath, "utf8").trim();
   if (raw === "") return {};
   const parsed = JSON.parse(raw);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -72903,19 +73209,19 @@ function readSettings(settingsPath) {
   return parsed;
 }
 function writeSettings(settingsPath, settings) {
-  fs46.mkdirSync(path55.dirname(settingsPath), { recursive: true });
-  fs46.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs47.mkdirSync(path56.dirname(settingsPath), { recursive: true });
+  fs47.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function installClaudeGuard(repoPath) {
   const templatePath = resolveTemplateFile("claude-worktree-guard.sh.template");
   if (!templatePath) {
     throw new Error("Guard template not found (claude-worktree-guard.sh.template). Run npm run build.");
   }
-  const guardScript = path55.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  fs46.mkdirSync(path55.dirname(guardScript), { recursive: true });
-  fs46.copyFileSync(templatePath, guardScript);
-  fs46.chmodSync(guardScript, 493);
-  const settingsPath = path55.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  const guardScript = path56.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  fs47.mkdirSync(path56.dirname(guardScript), { recursive: true });
+  fs47.copyFileSync(templatePath, guardScript);
+  fs47.chmodSync(guardScript, 493);
+  const settingsPath = path56.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
   const settings = readSettings(settingsPath);
   const hooks = settings.hooks ?? {};
   const preToolUse = (hooks.PreToolUse ?? []).filter((entry) => !isHarGuardEntry(entry));
@@ -72929,15 +73235,15 @@ function installClaudeGuard(repoPath) {
 }
 function uninstallClaudeGuard(repoPath) {
   let removed = false;
-  const guardScript = path55.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  if (fs46.existsSync(guardScript)) {
-    fs46.rmSync(guardScript);
+  const guardScript = path56.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  if (fs47.existsSync(guardScript)) {
+    fs47.rmSync(guardScript);
     removed = true;
-    const parent = path55.dirname(guardScript);
-    if (fs46.existsSync(parent) && fs46.readdirSync(parent).length === 0) fs46.rmdirSync(parent);
+    const parent = path56.dirname(guardScript);
+    if (fs47.existsSync(parent) && fs47.readdirSync(parent).length === 0) fs47.rmdirSync(parent);
   }
-  const settingsPath = path55.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (fs46.existsSync(settingsPath)) {
+  const settingsPath = path56.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (fs47.existsSync(settingsPath)) {
     const settings = readSettings(settingsPath);
     const preToolUse = settings.hooks?.PreToolUse;
     if (preToolUse) {
@@ -72962,8 +73268,8 @@ function uninstallClaudeGuard(repoPath) {
   return { removed };
 }
 function claudeGuardInstalled(repoPath) {
-  const settingsPath = path55.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (!fs46.existsSync(settingsPath)) return false;
+  const settingsPath = path56.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (!fs47.existsSync(settingsPath)) return false;
   try {
     const settings = readSettings(settingsPath);
     return (settings.hooks?.PreToolUse ?? []).some(isHarGuardEntry);
@@ -72980,7 +73286,7 @@ function repoOption(y) {
 function handleInstall2(argv) {
   try {
     if (argv.claude) {
-      const result2 = installClaudeGuard(path56.resolve(argv.repo));
+      const result2 = installClaudeGuard(path57.resolve(argv.repo));
       success("Claude Code worktree guard installed.");
       info(`Guard script:  ${result2.guardScript}`);
       info(`Settings:      ${result2.settingsPath} (PreToolUse: Edit|Write|MultiEdit|NotebookEdit)`);
@@ -72988,7 +73294,7 @@ function handleInstall2(argv) {
       info("Commit both files so the guard travels with the repo.");
       return;
     }
-    const result = installHooks({ repoPath: path56.resolve(argv.repo), force: argv.force });
+    const result = installHooks({ repoPath: path57.resolve(argv.repo), force: argv.force });
     success(`Commit gate installed in ${result.hooksDir}`);
     info(`pre-commit: ${result.preCommit}, post-commit: ${result.postCommit}`);
     info("Commits of unverified change batches will be blocked in agent worktrees.");
@@ -73001,7 +73307,7 @@ function handleInstall2(argv) {
 function handleUninstall(argv) {
   try {
     if (argv.claude) {
-      const result2 = uninstallClaudeGuard(path56.resolve(argv.repo));
+      const result2 = uninstallClaudeGuard(path57.resolve(argv.repo));
       if (result2.removed) {
         success("Claude Code worktree guard removed.");
       } else {
@@ -73009,7 +73315,7 @@ function handleUninstall(argv) {
       }
       return;
     }
-    const result = uninstallHooks(path56.resolve(argv.repo));
+    const result = uninstallHooks(path57.resolve(argv.repo));
     if (result.removed) {
       success(`Commit gate removed from ${result.hooksDir}`);
     } else {
@@ -73022,7 +73328,7 @@ function handleUninstall(argv) {
 }
 function handleStatus2(argv) {
   try {
-    const status = getHooksStatus(path56.resolve(argv.repo));
+    const status = getHooksStatus(path57.resolve(argv.repo));
     if (argv.json) {
       process.stdout.write(`${JSON.stringify(status, null, 2)}
 `);
@@ -73040,7 +73346,7 @@ function handleStatus2(argv) {
     );
     info(`Effective:     ${status.effectiveMode} (in this checkout)`);
     info(
-      `Claude guard:  ${claudeGuardInstalled(path56.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
+      `Claude guard:  ${claudeGuardInstalled(path57.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
     );
   } catch (err) {
     error(err instanceof Error ? err.message : String(err));
@@ -73301,10 +73607,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path61) {
-  if (!path61)
+function getElementAtPath(obj, path62) {
+  if (!path62)
     return obj;
-  return path61.reduce((acc, key) => acc?.[key], obj);
+  return path62.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -73624,11 +73930,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path61, issues) {
+function prefixIssues(path62, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path61);
+    iss.path.unshift(path62);
     return iss;
   });
 }
@@ -80102,7 +80408,7 @@ var Server = class extends Protocol {
 };
 
 // src/mcp/server.ts
-var path57 = __toESM(require("path"));
+var path58 = __toESM(require("path"));
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var import_node_process3 = __toESM(require("node:process"), 1);
@@ -80745,7 +81051,7 @@ async function handleMcpToolCall(toolName, args, defaultRepo = ".") {
       const input = ControlUpInputSchema.parse({ ...args, repo });
       const result = await startControlAndSync({
         detach: input.detach,
-        cwd: path57.resolve(input.repo)
+        cwd: path58.resolve(input.repo)
       });
       if (result.code !== 0) {
         return {
@@ -80809,11 +81115,11 @@ var mcpCommand = {
 };
 
 // src/cli/commands/onboard.ts
-var path59 = __toESM(require("path"));
+var path60 = __toESM(require("path"));
 init_stages();
 
 // src/core/onboarding.ts
-var path58 = __toESM(require("path"));
+var path59 = __toESM(require("path"));
 init_control_config();
 init_control_sync();
 init_otel_hooks();
@@ -80948,7 +81254,7 @@ async function defaultEnsureControl(options) {
   return { started: true, apiUrl: result.apiUrl };
 }
 async function runOnboarding(options, deps = {}) {
-  const repoPath = path58.resolve(options.repoPath);
+  const repoPath = path59.resolve(options.repoPath);
   const applyTelemetry = deps.applyTelemetry ?? applyOnboardingTelemetry;
   const ensureControl = deps.ensureControl ?? defaultEnsureControl;
   const init = deps.initHarness ?? initHarness;
@@ -81136,7 +81442,7 @@ async function promptChoices(args) {
     };
   }
   const pluginChoices = listPluginChoices();
-  const repoPath = path59.resolve(args.repo);
+  const repoPath = path60.resolve(args.repo);
   const alreadyPresent = harnessExists(repoPath);
   const needProfile = !alreadyPresent && !args.skipInit && args.profile === void 0;
   const needAgentSlots = shouldConfigureSlots && flaggedSlots === void 0;
@@ -81253,7 +81559,7 @@ function printSummary(result) {
   console.error("");
 }
 async function handleOnboard(argv) {
-  const repoPath = path59.resolve(argv.repo);
+  const repoPath = path60.resolve(argv.repo);
   header("har onboard");
   info(`Repository: ${repoPath}`);
   try {
@@ -81484,7 +81790,7 @@ var preferencesCommand = {
 };
 
 // src/cli/commands/telemetry.ts
-var path60 = __toESM(require("path"));
+var path61 = __toESM(require("path"));
 init_control_config();
 init_control_sync();
 init_manifest();
@@ -81577,7 +81883,7 @@ async function handleOff() {
   info("Mission Control will not auto-start. Existing usage rows are kept.");
 }
 async function handleWriteEnv(argv) {
-  const repoPath = path60.resolve(argv.repo);
+  const repoPath = path61.resolve(argv.repo);
   const harnessRoot = resolveHarnessRoot(repoPath);
   const session = readSlotRegistry(harnessRoot, argv.agentId);
   const workDir = argv.workDir ?? session?.workDir ?? repoPath;
@@ -81589,7 +81895,7 @@ async function handleWriteEnv(argv) {
     suffix,
     createdAt: session?.createdAt
   });
-  const envFile = argv.envFile ?? path60.join(workDir, `.env.agent.${argv.agentId}`);
+  const envFile = argv.envFile ?? path61.join(workDir, `.env.agent.${argv.agentId}`);
   const attrs = {
     sessionKey,
     agentId: argv.agentId,
@@ -81605,7 +81911,7 @@ async function handleWriteEnv(argv) {
   success(`Wrote session attribution to ${envFile}`);
 }
 function handlePrintEnv(argv) {
-  const repoPath = path60.resolve(argv.repo);
+  const repoPath = path61.resolve(argv.repo);
   const workDir = argv.workDir ?? repoPath;
   const sessionKey = buildSessionKey({
     branch: argv.branch,