@osfactory/har 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/index.js

@@ -593,8 +593,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path88, errorMaps, issueData } = params;
-      const fullPath = [...path88, ...issueData.path || []];
+      const { data, path: path89, errorMaps, issueData } = params;
+      const fullPath = [...path89, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -902,11 +902,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path88, key) {
+      constructor(parent, value, path89, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path88;
+        this._path = path89;
         this._key = key;
       }
       get path() {
@@ -31543,8 +31543,8 @@ var init_parseUtil2 = __esm({
     init_errors2();
     init_en2();
     makeIssue2 = (params) => {
-      const { data, path: path88, errorMaps, issueData } = params;
-      const fullPath = [...path88, ...issueData.path || []];
+      const { data, path: path89, errorMaps, issueData } = params;
+      const fullPath = [...path89, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -31852,11 +31852,11 @@ var init_types2 = __esm({
     init_parseUtil2();
     init_util2();
     ParseInputLazyPath2 = class {
-      constructor(parent, value, path88, key) {
+      constructor(parent, value, path89, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path88;
+        this._path = path89;
         this._key = key;
       }
       get path() {
@@ -38852,16 +38852,16 @@ var init_local_executor = __esm({
         const walk = (dir, prefix) => {
           for (const entry of fs35.readdirSync(dir, { withFileTypes: true })) {
             const full = path36.join(dir, entry.name);
-            const relative4 = path36.join(prefix, entry.name);
+            const relative5 = path36.join(prefix, entry.name);
             if (entry.isDirectory()) {
-              walk(full, relative4);
+              walk(full, relative5);
               continue;
             }
-            if (filter2?.stageId && !relative4.includes(filter2.stageId)) continue;
+            if (filter2?.stageId && !relative5.includes(filter2.stageId)) continue;
             const stat = fs35.statSync(full);
             entries.push({
               path: full,
-              relativePath: relative4,
+              relativePath: relative5,
               sizeBytes: stat.size,
               modifiedAt: stat.mtime.toISOString()
             });
@@ -43100,15 +43100,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path88 = [graph[toModel].parent, toModel];
+      const path89 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path88.unshift(graph[cur].parent);
+        path89.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path88;
+      fn.conversion = path89;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -49038,7 +49038,7 @@ var require_iso2022 = __commonJS({
 // node_modules/chardet/index.js
 var require_chardet = __commonJS({
   "node_modules/chardet/index.js"(exports2, module2) {
-    var fs73 = require("fs");
+    var fs75 = require("fs");
     var utf8 = require_utf8();
     var unicode = require_unicode();
     var mbcs = require_mbcs();
@@ -49112,28 +49112,28 @@ var require_chardet = __commonJS({
       var fd;
       var handler = function(err, buffer) {
         if (fd) {
-          fs73.closeSync(fd);
+          fs75.closeSync(fd);
         }
         if (err) return cb(err, null);
         cb(null, self.detect(buffer, opts));
       };
       if (opts && opts.sampleSize) {
-        fd = fs73.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs73.read(fd, sample, 0, opts.sampleSize, null, function(err) {
+        fd = fs75.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
+        fs75.read(fd, sample, 0, opts.sampleSize, null, function(err) {
           handler(err, sample);
         });
         return;
       }
-      fs73.readFile(filepath, handler);
+      fs75.readFile(filepath, handler);
     };
     module2.exports.detectFileSync = function(filepath, opts) {
       if (opts && opts.sampleSize) {
-        var fd = fs73.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
-        fs73.readSync(fd, sample2, 0, opts.sampleSize);
-        fs73.closeSync(fd);
+        var fd = fs75.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
+        fs75.readSync(fd, sample2, 0, opts.sampleSize);
+        fs75.closeSync(fd);
         return self.detect(sample2, opts);
       }
-      return self.detect(fs73.readFileSync(filepath), opts);
+      return self.detect(fs75.readFileSync(filepath), opts);
     };
     module2.exports.detectAll = function(buffer, opts) {
       if (typeof opts !== "object") {
@@ -52598,16 +52598,16 @@ var require_os_tmpdir = __commonJS({
     var isWindows = process.platform === "win32";
     var trailingSlashRe = isWindows ? /[^:]\\$/ : /.\/$/;
     module2.exports = function() {
-      var path88;
+      var path89;
       if (isWindows) {
-        path88 = process.env.TEMP || process.env.TMP || (process.env.SystemRoot || process.env.windir) + "\\temp";
+        path89 = process.env.TEMP || process.env.TMP || (process.env.SystemRoot || process.env.windir) + "\\temp";
       } else {
-        path88 = process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp";
+        path89 = process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp";
       }
-      if (trailingSlashRe.test(path88)) {
-        path88 = path88.slice(0, -1);
+      if (trailingSlashRe.test(path89)) {
+        path89 = path89.slice(0, -1);
       }
-      return path88;
+      return path89;
     };
   }
 });
@@ -52615,8 +52615,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 fs73 = require("fs");
-    var path88 = require("path");
+    var fs75 = require("fs");
+    var path89 = require("path");
     var crypto8 = require("crypto");
     var osTmpDir = require_os_tmpdir();
     var _c2 = process.binding("constants");
@@ -52658,7 +52658,7 @@ var require_tmp = __commonJS({
     }
     function _generateTmpName(opts) {
       if (opts.name) {
-        return path88.join(opts.dir || tmpDir, opts.name);
+        return path89.join(opts.dir || tmpDir, opts.name);
       }
       if (opts.template) {
         return opts.template.replace(TEMPLATE_PATTERN, _randomChars(6));
@@ -52669,7 +52669,7 @@ var require_tmp = __commonJS({
         _randomChars(12),
         opts.postfix || ""
       ].join("");
-      return path88.join(opts.dir || tmpDir, name);
+      return path89.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;
@@ -52679,7 +52679,7 @@ var require_tmp = __commonJS({
         return cb(new Error("Invalid template provided"));
       (function _getUniqueName() {
         const name = _generateTmpName(opts);
-        fs73.stat(name, function(err) {
+        fs75.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));
@@ -52697,7 +52697,7 @@ var require_tmp = __commonJS({
       do {
         const name = _generateTmpName(opts);
         try {
-          fs73.statSync(name);
+          fs75.statSync(name);
         } catch (e) {
           return name;
         }
@@ -52709,13 +52709,13 @@ var require_tmp = __commonJS({
       opts.postfix = _isUndefined(opts.postfix) ? ".tmp" : opts.postfix;
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs73.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+        fs75.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
           if (err2) return cb(err2);
           if (opts.discardDescriptor) {
-            return fs73.close(fd, function _discardCallback(err3) {
+            return fs75.close(fd, function _discardCallback(err3) {
               if (err3) {
                 try {
-                  fs73.unlinkSync(name);
+                  fs75.unlinkSync(name);
                 } catch (e) {
                   if (!isENOENT(e)) {
                     err3 = e;
@@ -52738,9 +52738,9 @@ var require_tmp = __commonJS({
       opts.postfix = opts.postfix || ".tmp";
       const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
       const name = tmpNameSync(opts);
-      var fd = fs73.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      var fd = fs75.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
       if (opts.discardDescriptor) {
-        fs73.closeSync(fd);
+        fs75.closeSync(fd);
         fd = void 0;
       }
       return {
@@ -52752,9 +52752,9 @@ var require_tmp = __commonJS({
     function _rmdirRecursiveSync(root) {
       const dirs = [root];
       do {
-        var dir2 = dirs.pop(), deferred = false, files = fs73.readdirSync(dir2);
+        var dir2 = dirs.pop(), deferred = false, files = fs75.readdirSync(dir2);
         for (var i = 0, length = files.length; i < length; i++) {
-          var file2 = path88.join(dir2, files[i]), stat = fs73.lstatSync(file2);
+          var file2 = path89.join(dir2, files[i]), stat = fs75.lstatSync(file2);
           if (stat.isDirectory()) {
             if (!deferred) {
               deferred = true;
@@ -52762,11 +52762,11 @@ var require_tmp = __commonJS({
             }
             dirs.push(file2);
           } else {
-            fs73.unlinkSync(file2);
+            fs75.unlinkSync(file2);
           }
         }
         if (!deferred) {
-          fs73.rmdirSync(dir2);
+          fs75.rmdirSync(dir2);
         }
       } while (dirs.length !== 0);
     }
@@ -52774,7 +52774,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);
-        fs73.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+        fs75.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
           if (err2) return cb(err2);
           cb(null, name, _prepareTmpDirRemoveCallback(name, opts));
         });
@@ -52783,7 +52783,7 @@ var require_tmp = __commonJS({
     function dirSync(options) {
       var args = _parseArguments(options), opts = args[0];
       const name = tmpNameSync(opts);
-      fs73.mkdirSync(name, opts.mode || DIR_MODE);
+      fs75.mkdirSync(name, opts.mode || DIR_MODE);
       return {
         name,
         removeCallback: _prepareTmpDirRemoveCallback(name, opts)
@@ -52793,7 +52793,7 @@ var require_tmp = __commonJS({
       const removeCallback = _prepareRemoveCallback(function _removeCallback(fdPath) {
         try {
           if (0 <= fdPath[0]) {
-            fs73.closeSync(fdPath[0]);
+            fs75.closeSync(fdPath[0]);
           }
         } catch (e) {
           if (!isEBADF(e) && !isENOENT(e)) {
@@ -52801,7 +52801,7 @@ var require_tmp = __commonJS({
           }
         }
         try {
-          fs73.unlinkSync(fdPath[1]);
+          fs75.unlinkSync(fdPath[1]);
         } catch (e) {
           if (!isENOENT(e)) {
             throw e;
@@ -52814,7 +52814,7 @@ var require_tmp = __commonJS({
       return removeCallback;
     }
     function _prepareTmpDirRemoveCallback(name, opts) {
-      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs73.rmdirSync.bind(fs73);
+      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs75.rmdirSync.bind(fs75);
       const removeCallback = _prepareRemoveCallback(removeFunction, name);
       if (!opts.keep) {
         _removeObjects.unshift(removeCallback);
@@ -62773,32 +62773,32 @@ __export(otel_hooks_exports, {
 });
 function getOtelHooksHome() {
   if (process.env.HAR_OTEL_HOOKS_HOME) {
-    return path70.resolve(process.env.HAR_OTEL_HOOKS_HOME);
+    return path71.resolve(process.env.HAR_OTEL_HOOKS_HOME);
   }
-  return path70.join(os21.homedir(), ".har", "otel-hooks");
+  return path71.join(os21.homedir(), ".har", "otel-hooks");
 }
 function getOtelHooksConfigPath(hooksHome = getOtelHooksHome()) {
-  return path70.join(hooksHome, "otel_config.json");
+  return path71.join(hooksHome, "otel_config.json");
 }
 function getOtelHooksWrapperPath(hooksHome = getOtelHooksHome()) {
-  return path70.join(hooksHome, "run-otel-hook.sh");
+  return path71.join(hooksHome, "run-otel-hook.sh");
 }
 function getOtelHooksStateDir(hooksHome = getOtelHooksHome()) {
-  return path70.join(hooksHome, "state");
+  return path71.join(hooksHome, "state");
 }
 function localOtelHookBin(hooksHome) {
-  return path70.join(hooksHome, "node_modules", ".bin", "otel-hook");
+  return path71.join(hooksHome, "node_modules", ".bin", "otel-hook");
 }
 function installedPackageVersion(hooksHome) {
   try {
-    const pkgPath = path70.join(
+    const pkgPath = path71.join(
       hooksHome,
       "node_modules",
       "@osfactory",
       "otel-hook",
       "package.json"
     );
-    const pkg = JSON.parse(fs64.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs65.readFileSync(pkgPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -62849,15 +62849,15 @@ function buildOtelHooksConfig(options) {
   };
 }
 function writeOtelHooksConfig(config2, hooksHome = getOtelHooksHome()) {
-  fs64.mkdirSync(hooksHome, { recursive: true });
+  fs65.mkdirSync(hooksHome, { recursive: true });
   const configPath = getOtelHooksConfigPath(hooksHome);
-  fs64.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+  fs65.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
 `);
   return configPath;
 }
 function writeOtelHooksWrapper(otelHookCommand, hooksHome = getOtelHooksHome()) {
-  fs64.mkdirSync(hooksHome, { recursive: true });
-  fs64.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
+  fs65.mkdirSync(hooksHome, { recursive: true });
+  fs65.mkdirSync(getOtelHooksStateDir(hooksHome), { recursive: true });
   const wrapperPath = getOtelHooksWrapperPath(hooksHome);
   const configPath = getOtelHooksConfigPath(hooksHome);
   const stateDir = getOtelHooksStateDir(hooksHome);
@@ -62869,9 +62869,9 @@ exec "${otelHookCommand}" run \\
   --state-dir "${stateDir}" \\
   "$@"
 `;
-  fs64.writeFileSync(wrapperPath, script, { mode: 493 });
+  fs65.writeFileSync(wrapperPath, script, { mode: 493 });
   try {
-    fs64.chmodSync(wrapperPath, 493);
+    fs65.chmodSync(wrapperPath, 493);
   } catch {
   }
   return wrapperPath;
@@ -62884,7 +62884,7 @@ function commandExists3(command2) {
 }
 function resolveOtelHookCommand(hooksHome) {
   const local = localOtelHookBin(hooksHome);
-  if (fs64.existsSync(local)) return local;
+  if (fs65.existsSync(local)) return local;
   return null;
 }
 function resolveHooksInstaller(hooksHome) {
@@ -62899,7 +62899,7 @@ function resolveHooksInstaller(hooksHome) {
   return candidates.find((candidate) => commandExists3(candidate.command)) ?? null;
 }
 function tryInstallPackage(hooksHome) {
-  fs64.mkdirSync(hooksHome, { recursive: true });
+  fs65.mkdirSync(hooksHome, { recursive: true });
   const installer = resolveHooksInstaller(hooksHome);
   if (!installer) {
     return {
@@ -62912,7 +62912,7 @@ function tryInstallPackage(hooksHome) {
     encoding: "utf8",
     timeout: 18e4
   });
-  if (result.status === 0 && fs64.existsSync(localOtelHookBin(hooksHome))) {
+  if (result.status === 0 && fs65.existsSync(localOtelHookBin(hooksHome))) {
     return { ok: true, detail: described };
   }
   return {
@@ -62938,14 +62938,14 @@ function uninstallLegacyPythonHooks(hooksHome) {
 }
 function removeLegacyPythonArtifacts(hooksHome) {
   const legacyPaths = [
-    path70.join(hooksHome, ".venv"),
-    path70.join(hooksHome, "otel_config.yaml"),
-    path70.join(hooksHome, "venv")
+    path71.join(hooksHome, ".venv"),
+    path71.join(hooksHome, "otel_config.yaml"),
+    path71.join(hooksHome, "venv")
   ];
   for (const target of legacyPaths) {
     try {
-      if (fs64.existsSync(target)) {
-        fs64.rmSync(target, { recursive: true, force: true });
+      if (fs65.existsSync(target)) {
+        fs65.rmSync(target, { recursive: true, force: true });
       }
     } catch {
     }
@@ -62986,10 +62986,10 @@ function runSetupProvider(providerId, otelHookCommand, wrapperPath) {
   };
 }
 function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
-  if (!fs64.existsSync(filePath)) return false;
+  if (!fs65.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs64.readFileSync(filePath, "utf8");
+    raw = fs65.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -63036,15 +63036,15 @@ function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
     return changed;
   };
   if (!walk(parsed)) return false;
-  fs64.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs65.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
-  if (!fs64.existsSync(filePath)) return false;
+  if (!fs65.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs64.readFileSync(filePath, "utf8");
+    raw = fs65.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -63079,21 +63079,21 @@ function pruneLegacyCursorHookEvents(filePath, wrapperPath) {
     }
   }
   if (!changed) return false;
-  fs64.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs65.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function rewriteKnownHookRegistrations(wrapperPath) {
   const home = os21.homedir();
   const candidates = [
-    path70.join(home, ".cursor", "hooks.json"),
-    path70.join(home, ".claude", "settings.json"),
-    path70.join(home, ".codex", "hooks.json")
+    path71.join(home, ".cursor", "hooks.json"),
+    path71.join(home, ".claude", "settings.json"),
+    path71.join(home, ".codex", "hooks.json")
   ];
   for (const filePath of candidates) {
     try {
       rewriteHookCommandsToWrapper(filePath, wrapperPath);
-      if (filePath.endsWith(`${path70.sep}.cursor${path70.sep}hooks.json`)) {
+      if (filePath.endsWith(`${path71.sep}.cursor${path71.sep}hooks.json`)) {
         pruneLegacyCursorHookEvents(filePath, wrapperPath);
       }
     } catch {
@@ -63109,7 +63109,7 @@ function ensureOtelHooks(options) {
   const hooksHome = getOtelHooksHome();
   const errors = [];
   const providersSetup = [];
-  fs64.mkdirSync(hooksHome, { recursive: true });
+  fs65.mkdirSync(hooksHome, { recursive: true });
   let otelHookCommand = resolveOtelHookCommand(hooksHome);
   const needsInstall = !otelHookCommand || installedPackageVersion(hooksHome) !== pinnedVersion();
   if (needsInstall) {
@@ -63203,14 +63203,14 @@ function ensureOtelHooks(options) {
 function disableOtelHooksExport() {
   return writeOtelHooksConfig(buildOtelHooksConfig({ enabled: false }));
 }
-var import_child_process18, fs64, os21, path70, OTEL_HOOKS_PACKAGE, OTEL_HOOKS_PROVIDERS, OTEL_HOOKS_AGENTS, LEGACY_CURSOR_ONLY_HOOK_EVENTS;
+var import_child_process18, fs65, os21, path71, 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_process18 = require("child_process");
-    fs64 = __toESM(require("fs"));
+    fs65 = __toESM(require("fs"));
     os21 = __toESM(require("os"));
-    path70 = __toESM(require("path"));
+    path71 = __toESM(require("path"));
     init_control_config();
     init_telemetry_config();
     OTEL_HOOKS_PACKAGE = "@osfactory/otel-hook@0.2.0";
@@ -66430,8 +66430,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path88) {
-      let input = path88;
+    function removeDotSegments(path89) {
+      let input = path89;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -66683,8 +66683,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path88, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path88 && path88 !== "/" ? path88 : void 0;
+        const [path89, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path89 && path89 !== "/" ? path89 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -66849,49 +66849,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative4, options, skipNormalization) {
+    function resolveComponent(base, relative5, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse4(serialize(base, options), options);
-        relative4 = parse4(serialize(relative4, options), options);
+        relative5 = parse4(serialize(relative5, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative4.scheme) {
-        target.scheme = relative4.scheme;
-        target.userinfo = relative4.userinfo;
-        target.host = relative4.host;
-        target.port = relative4.port;
-        target.path = removeDotSegments(relative4.path || "");
-        target.query = relative4.query;
+      if (!options.tolerant && relative5.scheme) {
+        target.scheme = relative5.scheme;
+        target.userinfo = relative5.userinfo;
+        target.host = relative5.host;
+        target.port = relative5.port;
+        target.path = removeDotSegments(relative5.path || "");
+        target.query = relative5.query;
       } else {
-        if (relative4.userinfo !== void 0 || relative4.host !== void 0 || relative4.port !== void 0) {
-          target.userinfo = relative4.userinfo;
-          target.host = relative4.host;
-          target.port = relative4.port;
-          target.path = removeDotSegments(relative4.path || "");
-          target.query = relative4.query;
+        if (relative5.userinfo !== void 0 || relative5.host !== void 0 || relative5.port !== void 0) {
+          target.userinfo = relative5.userinfo;
+          target.host = relative5.host;
+          target.port = relative5.port;
+          target.path = removeDotSegments(relative5.path || "");
+          target.query = relative5.query;
         } else {
-          if (!relative4.path) {
+          if (!relative5.path) {
             target.path = base.path;
-            if (relative4.query !== void 0) {
-              target.query = relative4.query;
+            if (relative5.query !== void 0) {
+              target.query = relative5.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative4.path[0] === "/") {
-              target.path = removeDotSegments(relative4.path);
+            if (relative5.path[0] === "/") {
+              target.path = removeDotSegments(relative5.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative4.path;
+                target.path = "/" + relative5.path;
               } else if (!base.path) {
-                target.path = relative4.path;
+                target.path = relative5.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative4.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative5.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative4.query;
+            target.query = relative5.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -66899,7 +66899,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative4.fragment;
+      target.fragment = relative5.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -70077,12 +70077,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs73, exportName) {
+    function addFormats(ajv, list, fs75, 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, fs73[f]);
+        ajv.addFormat(f, fs75[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -71366,11 +71366,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: (path88) => {
+  require: (path89) => {
     if (typeof require !== "undefined") {
-      return require(path88);
-    } else if (path88.match(/\.json$/)) {
-      return JSON.parse((0, import_fs2.readFileSync)(path88, "utf8"));
+      return require(path89);
+    } else if (path89.match(/\.json$/)) {
+      return JSON.parse((0, import_fs2.readFileSync)(path89, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -75240,7 +75240,8 @@ function handleRemove(argv) {
 }
 
 // src/cli/commands/env.ts
-var path74 = __toESM(require("path"));
+var fs68 = __toESM(require("fs"));
+var path75 = __toESM(require("path"));
 
 // src/cli/finish-command.ts
 init_sync_context();
@@ -75250,8 +75251,8 @@ async function finishCommand(code) {
 }
 
 // src/core/harness.ts
-var fs61 = __toESM(require("fs"));
-var path66 = __toESM(require("path"));
+var fs62 = __toESM(require("fs"));
+var path67 = __toESM(require("path"));
 
 // src/harness/generator.ts
 var fs47 = __toESM(require("fs"));
@@ -77717,9 +77718,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, path88 = "", value) => {
+  set: (obj, path89 = "", value) => {
     let pointer = obj;
-    path88.split(".").forEach((key, index, arr) => {
+    path89.split(".").forEach((key, index, arr) => {
       if (key === "__proto__" || key === "constructor")
         return;
       if (index === arr.length - 1) {
@@ -77730,8 +77731,8 @@ var _ = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path88 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path88, regexp).filter(Boolean).reduce(
+  get: (obj, path89 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path89, regexp).filter(Boolean).reduce(
       // @ts-expect-error implicit any on res[key]
       (res, key) => res !== null && res !== void 0 ? res[key] : res,
       obj
@@ -78836,21 +78837,21 @@ async function smokeTestHarness(repoPath) {
 }
 
 // src/harness/maintain-bundle.ts
-var fs56 = __toESM(require("fs"));
+var fs57 = __toESM(require("fs"));
 var os20 = __toESM(require("os"));
-var path61 = __toESM(require("path"));
+var path62 = __toESM(require("path"));
 init_file_ops();
 init_shell();
 init_manifest();
 
 // src/harness/plugin-drift.ts
-var fs55 = __toESM(require("fs"));
-var path60 = __toESM(require("path"));
+var fs56 = __toESM(require("fs"));
+var path61 = __toESM(require("path"));
 init_manifest();
 
 // src/harness/plugins.ts
-var fs54 = __toESM(require("fs"));
-var path59 = __toESM(require("path"));
+var fs55 = __toESM(require("fs"));
+var path60 = __toESM(require("path"));
 init_zod2();
 init_logging();
 init_paths();
@@ -79114,6 +79115,55 @@ function cleanupResolvedPlugin(source) {
   }
 }
 
+// src/harness/plugin-prompt.ts
+var fs54 = __toESM(require("fs"));
+var path59 = __toESM(require("path"));
+init_paths();
+init_file_ops();
+init_node_pm();
+init_manifest();
+init_env();
+function pluginAdaptationPromptFile(pluginId) {
+  return `ADAPT-PROMPT-${pluginId}.md`;
+}
+function loadTemplate() {
+  const filePath = resolveTemplateFile("adaptation-prompt-plugin.md");
+  if (!filePath) {
+    throw new Error(
+      "Plugin adaptation prompt template not found: adaptation-prompt-plugin.md. Run npm run build."
+    );
+  }
+  return fs54.readFileSync(filePath, "utf8");
+}
+function resolveInstallCommand(repoPath) {
+  const env3 = readHarnessEnv(repoPath);
+  if (env3.HARNESS_INSTALL_CMD) return env3.HARNESS_INSTALL_CMD;
+  return `${nodePackageManager(repoPath, env3)} install`;
+}
+var BARE_INSTALL_RE = /^(npm|pnpm|yarn|bun)\s+install$/;
+function buildPluginAdaptationPrompt(repoPath, result) {
+  const mergedPackageJson = result.filesWritten.includes("package.json");
+  const installCmd = resolveInstallCommand(repoPath);
+  const packageMergeNote = mergedPackageJson ? [
+    "## Dependencies: merged is NOT installed",
+    "",
+    "The plugin merged new `devDependencies` into `package.json` \u2014 it did **not**",
+    "install them. Install first or every later step fails:",
+    "",
+    "```bash",
+    installCmd,
+    "```"
+  ].join("\n") : "## Dependencies\n\nThis plugin merged no package.json fragment \u2014 no dependency install is required.";
+  const setupSteps = result.nextSteps.filter((step) => !(mergedPackageJson && BARE_INSTALL_RE.test(step.trim()))).map((step, i) => `${i + 1}. \`${step}\``).join("\n");
+  const filesWritten = result.filesWritten.filter((f) => f !== "package.json").map((f) => `   - \`${f}\``).join("\n");
+  return loadTemplate().replace(/\{\{PLUGIN_ID\}\}/g, result.pluginId).replace(/\{\{STAGE_IDS\}\}/g, result.stageIds.map((id) => `\`${id}\``).join(", ")).replace(/\{\{DOCS_PATH\}\}/g, result.docsPath).replace("{{PACKAGE_MERGE_NOTE}}", packageMergeNote).replace("{{PLUGIN_SETUP_STEPS}}", setupSteps || "_No plugin-specific setup steps declared._").replace("{{FILES_WRITTEN}}", filesWritten || "   - _(no scaffolded files)_");
+}
+function writePluginAdaptationPrompt(repoPath, pluginId, content) {
+  const filePath = path59.join(getHarnessDir(repoPath), pluginAdaptationPromptFile(pluginId));
+  writeFileSafe(filePath, content);
+  return filePath;
+}
+
 // src/harness/plugins.ts
 init_schema2();
 init_stages();
@@ -79162,19 +79212,19 @@ function primaryStageId(manifest) {
   return manifest.stageId ?? stages[0].id;
 }
 function resolveBundledPluginDir(pluginId) {
-  const dir = path59.join(resolveTemplatesDir(), "plugins", pluginId);
-  if (!fs54.existsSync(dir)) {
+  const dir = path60.join(resolveTemplatesDir(), "plugins", pluginId);
+  if (!fs55.existsSync(dir)) {
     throw new Error(`Plugin not found: ${pluginId}. Run npm run build.`);
   }
   return dir;
 }
 function readPluginManifestFromDir(pluginDir, expectedId) {
-  const manifestPath = path59.join(pluginDir, "template.manifest.json");
-  if (!fs54.existsSync(manifestPath)) {
+  const manifestPath = path60.join(pluginDir, "template.manifest.json");
+  if (!fs55.existsSync(manifestPath)) {
     throw new Error(`No template.manifest.json in ${pluginDir}`);
   }
   const parsed = PluginManifestSchema.safeParse(
-    JSON.parse(fs54.readFileSync(manifestPath, "utf8"))
+    JSON.parse(fs55.readFileSync(manifestPath, "utf8"))
   );
   if (!parsed.success) {
     throw new Error(`Invalid plugin manifest: ${parsed.error.message}`);
@@ -79188,40 +79238,40 @@ function readPluginManifest(pluginId) {
   return readPluginManifestFromDir(resolveBundledPluginDir(pluginId), pluginId);
 }
 function ensureParentDir(filePath) {
-  const parent = path59.dirname(filePath);
-  if (!fs54.existsSync(parent)) {
-    fs54.mkdirSync(parent, { recursive: true });
+  const parent = path60.dirname(filePath);
+  if (!fs55.existsSync(parent)) {
+    fs55.mkdirSync(parent, { recursive: true });
   }
 }
 function copyPluginFile(pluginDir, file, repoPath, force) {
-  const srcPath = path59.join(pluginDir, file.src);
-  const destPath = path59.join(repoPath, file.dest);
-  if (!fs54.existsSync(srcPath)) {
+  const srcPath = path60.join(pluginDir, file.src);
+  const destPath = path60.join(repoPath, file.dest);
+  if (!fs55.existsSync(srcPath)) {
     throw new Error(`Plugin file missing: ${file.src}`);
   }
-  if (fs54.existsSync(destPath) && !force) {
+  if (fs55.existsSync(destPath) && !force) {
     throw new Error(
       `File already exists: ${file.dest}. Use --force to overwrite or remove it first.`
     );
   }
   ensureParentDir(destPath);
-  fs54.copyFileSync(srcPath, destPath);
+  fs55.copyFileSync(srcPath, destPath);
   if (file.executable) {
-    fs54.chmodSync(destPath, 493);
+    fs55.chmodSync(destPath, 493);
   }
   return { written: true, path: file.dest };
 }
 function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
-  const packagePath = path59.join(repoPath, "package.json");
-  if (!fs54.existsSync(packagePath)) {
+  const packagePath = path60.join(repoPath, "package.json");
+  if (!fs55.existsSync(packagePath)) {
     throw new Error("No package.json in repo root. Add one before applying this plugin.");
   }
-  const fragmentPath = path59.join(pluginDir, fragmentRelPath);
-  if (!fs54.existsSync(fragmentPath)) {
+  const fragmentPath = path60.join(pluginDir, fragmentRelPath);
+  if (!fs55.existsSync(fragmentPath)) {
     throw new Error(`Package fragment missing: ${fragmentRelPath}`);
   }
-  const pkg = JSON.parse(fs54.readFileSync(packagePath, "utf8"));
-  const fragment = JSON.parse(fs54.readFileSync(fragmentPath, "utf8"));
+  const pkg = JSON.parse(fs55.readFileSync(packagePath, "utf8"));
+  const fragment = JSON.parse(fs55.readFileSync(fragmentPath, "utf8"));
   for (const section of ["scripts", "devDependencies"]) {
     const existing = pkg[section] ?? {};
     const incoming = fragment[section] ?? {};
@@ -79234,7 +79284,7 @@ function mergePackageJson(repoPath, pluginDir, fragmentRelPath, warnings) {
     }
     pkg[section] = existing;
   }
-  fs54.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
+  fs55.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
 }
 function patchStageRegistry(repoPath, stages, verificationStageIds, force) {
   const registry2 = readStageRegistry(repoPath);
@@ -79270,8 +79320,8 @@ function assertStagesNotPresent(repoPath, stageIds, force) {
   if (force) return;
   const registry2 = readStageRegistry(repoPath);
   for (const stageId of stageIds) {
-    const scriptPath = path59.join(repoPath, ".har", "stages", `${stageId}.sh`);
-    if (fs54.existsSync(scriptPath)) {
+    const scriptPath = path60.join(repoPath, ".har", "stages", `${stageId}.sh`);
+    if (fs55.existsSync(scriptPath)) {
       throw new Error(
         `Stage script already exists: .har/stages/${stageId}.sh. Use --force to overwrite.`
       );
@@ -79284,7 +79334,7 @@ function assertStagesNotPresent(repoPath, stageIds, force) {
   }
 }
 function applyPluginFromDir(repoPath, pluginDir, options, meta) {
-  const resolved = path59.resolve(repoPath);
+  const resolved = path60.resolve(repoPath);
   const force = options.force ?? false;
   const warnings = [];
   const filesWritten = [];
@@ -79304,7 +79354,7 @@ function applyPluginFromDir(repoPath, pluginDir, options, meta) {
       if (file.skipFlag === "skipCi" && options.skipCi) {
         continue;
       }
-      if (fs54.existsSync(path59.join(resolved, file.dest)) && !force) {
+      if (fs55.existsSync(path60.join(resolved, file.dest)) && !force) {
         warnings.push(`Skipped optional file (exists): ${file.dest}`);
         continue;
       }
@@ -79330,15 +79380,7 @@ function applyPluginFromDir(repoPath, pluginDir, options, meta) {
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const primary = primaryStageId(manifest);
-  success(`Applied plugin: ${manifest.id}`);
-  info(`Registered stage(s): ${stageIds.join(", ")}`);
-  for (const file of filesWritten) {
-    info(`  + ${file}`);
-  }
-  for (const warning of warnings) {
-    warn(`  \u26A0 ${warning}`);
-  }
-  return {
+  const partialResult = {
     pluginId: manifest.id,
     stageId: primary,
     stageIds,
@@ -79348,6 +79390,22 @@ function applyPluginFromDir(repoPath, pluginDir, options, meta) {
     docsPath: manifest.docsPath,
     source: meta.source
   };
+  const promptContent = buildPluginAdaptationPrompt(resolved, {
+    ...partialResult,
+    adaptPromptPath: ""
+  });
+  const promptAbsPath = writePluginAdaptationPrompt(resolved, manifest.id, promptContent);
+  const adaptPromptPath = path60.relative(resolved, promptAbsPath);
+  success(`Applied plugin: ${manifest.id}`);
+  info(`Registered stage(s): ${stageIds.join(", ")}`);
+  for (const file of filesWritten) {
+    info(`  + ${file}`);
+  }
+  info(`  + ${adaptPromptPath} (adaptation prompt for your coding agent)`);
+  for (const warning of warnings) {
+    warn(`  \u26A0 ${warning}`);
+  }
+  return { ...partialResult, adaptPromptPath };
 }
 function applyPlugin(repoPath, pluginSpec, options = {}) {
   const spec = options.spec ?? pluginSpec;
@@ -79371,13 +79429,13 @@ init_stages();
 init_paths();
 var PACKAGE_SECTIONS = ["scripts", "devDependencies"];
 function detectInstalledPlugins(repoPath) {
-  const resolved = path60.resolve(repoPath);
+  const resolved = path61.resolve(repoPath);
   const ledger = readPluginLedger(resolved);
   if (ledger && ledger.plugins.length > 0) {
     return ledger.plugins.map((p) => p.id).sort();
   }
-  const registryPath = path60.join(resolved, ".har", "stages.json");
-  if (!fs55.existsSync(registryPath)) return [];
+  const registryPath = path61.join(resolved, ".har", "stages.json");
+  if (!fs56.existsSync(registryPath)) return [];
   const registry2 = readStageRegistry(resolved);
   const stageIds = new Set(registry2.stages.map((stage) => stage.id));
   const installed = [];
@@ -79394,18 +79452,18 @@ function detectInstalledPlugins(repoPath) {
   return installed.sort();
 }
 function resolvePluginBaseline(repoPath, pluginId) {
-  const resolved = path60.resolve(repoPath);
+  const resolved = path61.resolve(repoPath);
   const ledger = readPluginLedger(resolved);
   const entry = ledger?.plugins.find((p) => p.id === pluginId);
   if (entry?.source === "local") {
-    const localDir = path60.join(resolved, LOCAL_PLUGINS_DIR, pluginId);
-    if (fs55.existsSync(path60.join(localDir, "template.manifest.json"))) {
+    const localDir = path61.join(resolved, LOCAL_PLUGINS_DIR, pluginId);
+    if (fs56.existsSync(path61.join(localDir, "template.manifest.json"))) {
       return { kind: "local", dir: localDir, manifest: readPluginManifestFromDir(localDir) };
     }
     return null;
   }
-  const bundled = path60.join(resolveTemplatesDir(), "plugins", pluginId);
-  if (fs55.existsSync(path60.join(bundled, "template.manifest.json"))) {
+  const bundled = path61.join(resolveTemplatesDir(), "plugins", pluginId);
+  if (fs56.existsSync(path61.join(bundled, "template.manifest.json"))) {
     return { kind: "bundled", dir: bundled, manifest: readPluginManifestFromDir(bundled) };
   }
   return null;
@@ -79418,14 +79476,14 @@ function requireBaseline(repoPath, pluginId) {
   return baseline;
 }
 function readBaselineFile(baseline, srcRel) {
-  return fs55.readFileSync(path60.join(baseline.dir, srcRel), "utf8");
+  return fs56.readFileSync(path61.join(baseline.dir, srcRel), "utf8");
 }
 function listPluginDestPaths(baseline, repoPath) {
   const manifest = baseline.manifest;
   const paths = manifest.files.map((file) => file.dest);
   if (manifest.optionalFiles) {
     for (const file of manifest.optionalFiles) {
-      if (fs55.existsSync(path60.join(repoPath, file.dest))) {
+      if (fs56.existsSync(path61.join(repoPath, file.dest))) {
         paths.push(file.dest);
       }
     }
@@ -79484,9 +79542,9 @@ function readTemplatePluginFile(repoPath, pluginId, dest) {
   return null;
 }
 function readInstalledPluginFile(repoPath, pluginId, dest) {
-  const installedPath = path60.join(path60.resolve(repoPath), dest);
-  if (!fs55.existsSync(installedPath)) return null;
-  const content = fs55.readFileSync(installedPath, "utf8");
+  const installedPath = path61.join(path61.resolve(repoPath), dest);
+  if (!fs56.existsSync(installedPath)) return null;
+  const content = fs56.readFileSync(installedPath, "utf8");
   const baseline = requireBaseline(repoPath, pluginId);
   const fragmentRel = baseline.manifest.merge?.[dest];
   if (fragmentRel) {
@@ -79510,7 +79568,7 @@ function pluginActionHint(pluginId, dest, kind, baseline) {
   return `Merge maintain/plugins/${pluginId}/diffs/${dest}.diff or run: har env add-plugin ${pluginId} --force`;
 }
 function comparePluginToTemplate(repoPath, pluginId) {
-  const resolved = path60.resolve(repoPath);
+  const resolved = path61.resolve(repoPath);
   const baseline = requireBaseline(resolved, pluginId);
   const manifest = baseline.manifest;
   const destPaths = listPluginDestPaths(baseline, resolved);
@@ -79527,8 +79585,8 @@ function comparePluginToTemplate(repoPath, pluginId) {
     }
     if (dest === "package.json") {
       const fragmentRel = manifest.merge?.[dest];
-      const installedPath = path60.join(resolved, dest);
-      const installedRaw = fs55.readFileSync(installedPath, "utf8");
+      const installedPath = path61.join(resolved, dest);
+      const installedRaw = fs56.readFileSync(installedPath, "utf8");
       if (fragmentRel && pluginKeysMatch(installedRaw, readBaselineFile(baseline, fragmentRel))) {
         unchanged.push(dest);
       } else if (computeFileChecksum(installedContent) === computeFileChecksum(templateContent)) {
@@ -79590,7 +79648,7 @@ init_profiles();
 var MAINTAIN_DIR = "maintain";
 var substituteProjectName2 = substituteTemplateTokens;
 function projectNameFromRepo(repoPath) {
-  return path61.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  return path62.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
 }
 function readBundledTemplateContent(repoPath, profile, file) {
   const entry = composeProfileTemplateMap(profile).get(templateFileForHarness(file));
@@ -79628,12 +79686,12 @@ function actionHint(file, kind) {
   return `Upstream template updated since your last finalize \u2014 read maintain/diffs/${file}.diff and apply into .har/${file}.`;
 }
 function createUnifiedDiff(installedContent, templateContent, installedLabel, templateLabel) {
-  const tmpDir = fs56.mkdtempSync(path61.join(os20.tmpdir(), "har-maintain-diff-"));
+  const tmpDir = fs57.mkdtempSync(path62.join(os20.tmpdir(), "har-maintain-diff-"));
   try {
-    const installedPath = path61.join(tmpDir, "installed");
-    const templatePath = path61.join(tmpDir, "template");
-    fs56.writeFileSync(installedPath, installedContent);
-    fs56.writeFileSync(templatePath, templateContent);
+    const installedPath = path62.join(tmpDir, "installed");
+    const templatePath = path62.join(tmpDir, "template");
+    fs57.writeFileSync(installedPath, installedContent);
+    fs57.writeFileSync(templatePath, templateContent);
     const result = run(`diff -u "${installedPath}" "${templatePath}"`);
     const body = result.stdout.trim();
     if (!body) return "";
@@ -79642,7 +79700,7 @@ function createUnifiedDiff(installedContent, templateContent, installedLabel, te
 ${body.split("\n").slice(2).join("\n")}
 `;
   } finally {
-    fs56.rmSync(tmpDir, { recursive: true, force: true });
+    fs57.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function buildActions(repoPath, profile, drift) {
@@ -79661,12 +79719,12 @@ function buildActions(repoPath, profile, drift) {
     ...drift.conflict.map((f) => [f, "conflict"])
   ];
   for (const [file, kind] of upstreamAffected) {
-    const installedPath = path61.join(harnessDir, file);
+    const installedPath = path62.join(harnessDir, file);
     actions.push({
       file,
       kind,
       template: `maintain/templates/${file}`,
-      installed: fs56.existsSync(installedPath) ? `maintain/installed/${file}` : void 0,
+      installed: fs57.existsSync(installedPath) ? `maintain/installed/${file}` : void 0,
       diff: `maintain/diffs/${file}.diff`,
       hint: actionHint(file, kind)
     });
@@ -79837,28 +79895,28 @@ function buildReadme(report) {
 }
 function writeBundleArtifacts(repoPath, profile, drift, report) {
   const harnessDir = getHarnessDir(repoPath);
-  const bundleDir = path61.join(harnessDir, MAINTAIN_DIR);
-  if (fs56.existsSync(bundleDir)) {
-    fs56.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path62.join(harnessDir, MAINTAIN_DIR);
+  if (fs57.existsSync(bundleDir)) {
+    fs57.rmSync(bundleDir, { recursive: true, force: true });
   }
   const dirs = [
     bundleDir,
-    path61.join(bundleDir, "templates"),
-    path61.join(bundleDir, "installed"),
-    path61.join(bundleDir, "diffs"),
-    path61.join(bundleDir, "stale")
+    path62.join(bundleDir, "templates"),
+    path62.join(bundleDir, "installed"),
+    path62.join(bundleDir, "diffs"),
+    path62.join(bundleDir, "stale")
   ];
   for (const dir of dirs) {
-    fs56.mkdirSync(dir, { recursive: true });
+    fs57.mkdirSync(dir, { recursive: true });
   }
   const affectedFiles = [...drift.missing, ...drift.upstreamUpdated, ...drift.conflict];
   for (const file of affectedFiles) {
     const templateContent = readBundledTemplateContent(repoPath, profile, file);
-    writeFileSafe(path61.join(bundleDir, "templates", file), templateContent);
-    const harnessPath = path61.join(harnessDir, file);
-    if (fs56.existsSync(harnessPath)) {
-      const installedContent = fs56.readFileSync(harnessPath, "utf8");
-      writeFileSafe(path61.join(bundleDir, "installed", file), installedContent);
+    writeFileSafe(path62.join(bundleDir, "templates", file), templateContent);
+    const harnessPath = path62.join(harnessDir, file);
+    if (fs57.existsSync(harnessPath)) {
+      const installedContent = fs57.readFileSync(harnessPath, "utf8");
+      writeFileSafe(path62.join(bundleDir, "installed", file), installedContent);
       const diff = createUnifiedDiff(
         installedContent,
         templateContent,
@@ -79866,14 +79924,14 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
         `templates/${file}`
       );
       if (diff) {
-        writeFileSafe(path61.join(bundleDir, "diffs", `${file}.diff`), diff);
+        writeFileSafe(path62.join(bundleDir, "diffs", `${file}.diff`), diff);
       }
     }
   }
-  writeFileSafe(path61.join(bundleDir, "README.md"), buildReadme(report));
-  writeFileSafe(path61.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
+  writeFileSafe(path62.join(bundleDir, "README.md"), buildReadme(report));
+  writeFileSafe(path62.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
   writeFileSafe(
-    path61.join(bundleDir, "validation.json"),
+    path62.join(bundleDir, "validation.json"),
     JSON.stringify(report.validation, null, 2) + "\n"
   );
   if (report.stale.length > 0) {
@@ -79885,34 +79943,34 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
       ...report.stale.map((s) => `- **${s.file}** \u2014 ${s.hint}`),
       ""
     ];
-    writeFileSafe(path61.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
+    writeFileSafe(path62.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
   }
   return bundleDir;
 }
 function ensureParentDir2(filePath) {
-  const parent = path61.dirname(filePath);
-  if (!fs56.existsSync(parent)) {
-    fs56.mkdirSync(parent, { recursive: true });
+  const parent = path62.dirname(filePath);
+  if (!fs57.existsSync(parent)) {
+    fs57.mkdirSync(parent, { recursive: true });
   }
 }
 function writePluginBundleArtifacts(repoPath, bundleDir, report) {
   if (report.pluginActions.length === 0) return;
   for (const action of report.pluginActions) {
-    const pluginRoot = path61.join(bundleDir, "plugins", action.pluginId);
-    const templatesDir = path61.join(pluginRoot, "templates");
-    const installedDir = path61.join(pluginRoot, "installed");
-    const diffsDir = path61.join(pluginRoot, "diffs");
+    const pluginRoot = path62.join(bundleDir, "plugins", action.pluginId);
+    const templatesDir = path62.join(pluginRoot, "templates");
+    const installedDir = path62.join(pluginRoot, "installed");
+    const diffsDir = path62.join(pluginRoot, "diffs");
     for (const dir of [templatesDir, installedDir, diffsDir]) {
-      fs56.mkdirSync(dir, { recursive: true });
+      fs57.mkdirSync(dir, { recursive: true });
     }
     const templateContent = readTemplatePluginFile(repoPath, action.pluginId, action.file);
     if (templateContent === null) continue;
-    const templatePath = path61.join(templatesDir, action.file);
+    const templatePath = path62.join(templatesDir, action.file);
     ensureParentDir2(templatePath);
     writeFileSafe(templatePath, templateContent);
     const installedContent = readInstalledPluginFile(repoPath, action.pluginId, action.file);
     if (installedContent !== null) {
-      const installedPath = path61.join(installedDir, action.file);
+      const installedPath = path62.join(installedDir, action.file);
       ensureParentDir2(installedPath);
       writeFileSafe(installedPath, installedContent);
       const diff = createUnifiedDiff(
@@ -79922,7 +79980,7 @@ function writePluginBundleArtifacts(repoPath, bundleDir, report) {
         `templates/${action.file}`
       );
       if (diff) {
-        const diffPath = path61.join(diffsDir, `${action.file}.diff`);
+        const diffPath = path62.join(diffsDir, `${action.file}.diff`);
         ensureParentDir2(diffPath);
         writeFileSafe(diffPath, diff);
       }
@@ -79958,9 +80016,9 @@ function buildMaintainBundle(repoPath, validation2, drift) {
   return { bundleDir, report };
 }
 function removeMaintainBundle(repoPath) {
-  const bundleDir = path61.join(getHarnessDir(repoPath), MAINTAIN_DIR);
-  if (fs56.existsSync(bundleDir)) {
-    fs56.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path62.join(getHarnessDir(repoPath), MAINTAIN_DIR);
+  if (fs57.existsSync(bundleDir)) {
+    fs57.rmSync(bundleDir, { recursive: true, force: true });
   }
 }
 function formatMaintainBundlePromptSection(report) {
@@ -80069,13 +80127,13 @@ init_manifest();
 init_stages();
 
 // src/harness/doctor.ts
-var fs58 = __toESM(require("fs"));
-var path63 = __toESM(require("path"));
+var fs59 = __toESM(require("fs"));
+var path64 = __toESM(require("path"));
 init_slot_registry();
 
 // src/harness/eject.ts
-var fs57 = __toESM(require("fs"));
-var path62 = __toESM(require("path"));
+var fs58 = __toESM(require("fs"));
+var path63 = __toESM(require("path"));
 init_package_version();
 init_manifest();
 init_profiles();
@@ -80083,16 +80141,16 @@ var EJECTED_RUNTIME_DIR = "runtime";
 var EJECTED_RUNTIME_BUNDLE = "har.cjs";
 function resolveRuntimeBundleSource() {
   if (process.env.HAR_EJECT_RUNTIME_SOURCE) {
-    return fs57.existsSync(process.env.HAR_EJECT_RUNTIME_SOURCE) ? process.env.HAR_EJECT_RUNTIME_SOURCE : null;
+    return fs58.existsSync(process.env.HAR_EJECT_RUNTIME_SOURCE) ? process.env.HAR_EJECT_RUNTIME_SOURCE : null;
   }
   const candidates = [
     // Bundled CLI: __dirname is dist/ and index.js is the self-contained runtime.
-    path62.join(__dirname, "index.js"),
+    path63.join(__dirname, "index.js"),
     // Dev (tsx src/…): fall back to a previously built dist/ at the repo root.
-    path62.resolve(__dirname, "..", "..", "dist", "index.js")
+    path63.resolve(__dirname, "..", "..", "dist", "index.js")
   ];
   for (const candidate of candidates) {
-    if (fs57.existsSync(candidate)) return candidate;
+    if (fs58.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -80139,7 +80197,7 @@ Return to managed shims (removes this directory, regenerates \`.har/*.sh\`):
 
 `;
 function ejectHarness(repoPath) {
-  const resolved = path62.resolve(repoPath);
+  const resolved = path63.resolve(repoPath);
   const harnessDir = getHarnessDir(resolved);
   const manifest = readManifest(resolved);
   if (!manifest) {
@@ -80157,12 +80215,12 @@ function ejectHarness(repoPath) {
   const version2 = getHarPackageVersion();
   const profile = manifest.profile ?? "default";
   const composed = composeProfileTemplateMap(profile);
-  const runtimeDir = path62.join(harnessDir, EJECTED_RUNTIME_DIR);
-  fs57.mkdirSync(runtimeDir, { recursive: true });
-  const runtimeFile = path62.join(runtimeDir, EJECTED_RUNTIME_BUNDLE);
-  fs57.copyFileSync(bundleSource, runtimeFile);
-  fs57.chmodSync(runtimeFile, 493);
-  fs57.writeFileSync(path62.join(runtimeDir, "README.md"), RUNTIME_README(version2));
+  const runtimeDir = path63.join(harnessDir, EJECTED_RUNTIME_DIR);
+  fs58.mkdirSync(runtimeDir, { recursive: true });
+  const runtimeFile = path63.join(runtimeDir, EJECTED_RUNTIME_BUNDLE);
+  fs58.copyFileSync(bundleSource, runtimeFile);
+  fs58.chmodSync(runtimeFile, 493);
+  fs58.writeFileSync(path63.join(runtimeDir, "README.md"), RUNTIME_README(version2));
   const scripts = [];
   for (const shim3 of RUNTIME_SHIM_FILES) {
     const source = composed.get(shim3);
@@ -80170,9 +80228,9 @@ function ejectHarness(repoPath) {
     const templateContent = readComposedTemplateContent(source);
     const delegateArgs = shimDelegateArgs(templateContent);
     if (!delegateArgs) continue;
-    const scriptPath = path62.join(harnessDir, shim3);
-    fs57.writeFileSync(scriptPath, buildEjectedScript(shim3, delegateArgs, usageLine(templateContent), version2));
-    fs57.chmodSync(scriptPath, 493);
+    const scriptPath = path63.join(harnessDir, shim3);
+    fs58.writeFileSync(scriptPath, buildEjectedScript(shim3, delegateArgs, usageLine(templateContent), version2));
+    fs58.chmodSync(scriptPath, 493);
     scripts.push(shim3);
   }
   writeManifest(resolved, {
@@ -80185,7 +80243,7 @@ function ejectHarness(repoPath) {
   return { scripts, runtimeFile, version: version2 };
 }
 function adoptHarness(repoPath) {
-  const resolved = path62.resolve(repoPath);
+  const resolved = path63.resolve(repoPath);
   const harnessDir = getHarnessDir(resolved);
   const manifest = readManifest(resolved);
   if (!manifest) {
@@ -80196,18 +80254,18 @@ function adoptHarness(repoPath) {
   }
   const profile = manifest.profile ?? "default";
   const composed = composeProfileTemplateMap(profile);
-  const projectName = path62.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const projectName = path63.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
   const scripts = [];
   for (const shim3 of RUNTIME_SHIM_FILES) {
     const source = composed.get(shim3);
     if (!source) continue;
     const rendered = substituteTemplateTokens(readComposedTemplateContent(source), projectName);
-    const scriptPath = path62.join(harnessDir, shim3);
-    fs57.writeFileSync(scriptPath, rendered);
-    fs57.chmodSync(scriptPath, 493);
+    const scriptPath = path63.join(harnessDir, shim3);
+    fs58.writeFileSync(scriptPath, rendered);
+    fs58.chmodSync(scriptPath, 493);
     scripts.push(shim3);
   }
-  fs57.rmSync(path62.join(harnessDir, EJECTED_RUNTIME_DIR), { recursive: true, force: true });
+  fs58.rmSync(path63.join(harnessDir, EJECTED_RUNTIME_DIR), { recursive: true, force: true });
   const rest = { ...manifest };
   delete rest.ejected;
   delete rest.ejectedVersion;
@@ -80238,27 +80296,27 @@ var CHECK_LABELS = {
 var PRE_1_0_FUNCTION_RE = /^\s*(har_infra_enabled|har_pg|har_node_[a-z_]+|har_pkg_exec)\s*\(\)/m;
 var LEGACY_TRIPLET_RE = /^export\s+HARNESS_[A-Z0-9_]+_PORT_(DEFAULT|SCAN_START|SCAN_END)=/m;
 function detectContract(harnessDir) {
-  const envPath = path63.join(harnessDir, "harness.env");
-  if (!fs58.existsSync(envPath)) return "none";
-  const content = fs58.readFileSync(envPath, "utf8");
+  const envPath = path64.join(harnessDir, "harness.env");
+  if (!fs59.existsSync(envPath)) return "none";
+  const content = fs59.readFileSync(envPath, "utf8");
   if (PRE_1_0_FUNCTION_RE.test(content) || LEGACY_TRIPLET_RE.test(content)) {
     return "pre-1.0";
   }
   return "1.0";
 }
 function resolveStageFile(harnessDir, stage) {
-  if (stage.script) return path63.join(harnessDir, stage.script);
+  if (stage.script) return path64.join(harnessDir, stage.script);
   if (stage.command) {
     const first = stage.command.trim().split(/\s+/)[0];
     if (first.startsWith("./.har/")) {
-      return path63.join(harnessDir, first.replace(/^\.\/\.har\//, ""));
+      return path64.join(harnessDir, first.replace(/^\.\/\.har\//, ""));
     }
     if (first.startsWith(".har/")) {
-      return path63.join(harnessDir, first.replace(/^\.har\//, ""));
+      return path64.join(harnessDir, first.replace(/^\.har\//, ""));
     }
     return null;
   }
-  return path63.join(harnessDir, "stages", `${stage.id}.sh`);
+  return path64.join(harnessDir, "stages", `${stage.id}.sh`);
 }
 function checkStatus(findings, id) {
   const mine = findings.filter((f) => f.check === id);
@@ -80270,7 +80328,7 @@ function runDoctor(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const findings = [];
   const skipped = /* @__PURE__ */ new Set();
-  if (!fs58.existsSync(harnessDir)) {
+  if (!fs59.existsSync(harnessDir)) {
     return {
       ok: false,
       contract: "none",
@@ -80317,9 +80375,9 @@ function runDoctor(repoPath) {
   }
   let registry2 = null;
   try {
-    const stagesPath = path63.join(harnessDir, "stages.json");
-    if (fs58.existsSync(stagesPath)) {
-      const raw = JSON.parse(fs58.readFileSync(stagesPath, "utf8"));
+    const stagesPath = path64.join(harnessDir, "stages.json");
+    if (fs59.existsSync(stagesPath)) {
+      const raw = JSON.parse(fs59.readFileSync(stagesPath, "utf8"));
       if (typeof raw !== "object" || raw === null || !Array.isArray(raw.stages)) {
         throw new Error("stages.json has no `stages` array \u2014 the registry is structurally invalid");
       }
@@ -80350,8 +80408,8 @@ function runDoctor(repoPath) {
     for (const stage of registry2.stages) {
       const file = resolveStageFile(harnessDir, stage);
       if (!file) continue;
-      const rel = path63.relative(harnessDir, file);
-      if (!fs58.existsSync(file)) {
+      const rel = path64.relative(harnessDir, file);
+      if (!fs59.existsSync(file)) {
         findings.push({
           check: "stage-files",
           severity: contractSeverity,
@@ -80361,7 +80419,7 @@ function runDoctor(repoPath) {
         });
         continue;
       }
-      if (rel.endsWith(".sh") && !(fs58.statSync(file).mode & 73)) {
+      if (rel.endsWith(".sh") && !(fs59.statSync(file).mode & 73)) {
         findings.push({
           check: "stage-files",
           severity: "warning",
@@ -80384,13 +80442,13 @@ function runDoctor(repoPath) {
         continue;
       }
       const file = resolveStageFile(harnessDir, stage);
-      if (file && !fs58.existsSync(file)) {
+      if (file && !fs59.existsSync(file)) {
         findings.push({
           check: "lifecycle-stages",
           severity: contractSeverity,
-          file: path63.relative(harnessDir, file),
+          file: path64.relative(harnessDir, file),
           message: `Lifecycle stage \`${stage.id}\` (${kind}) points at a missing file`,
-          remedy: `Restore .har/${path63.relative(harnessDir, file)} or fix the \`${stage.id}\` entry in stages.json`
+          remedy: `Restore .har/${path64.relative(harnessDir, file)} or fix the \`${stage.id}\` entry in stages.json`
         });
       }
     }
@@ -80435,9 +80493,9 @@ function runDoctor(repoPath) {
   if (!manifest?.ejected) {
     skipped.add("ejected-runtime");
   } else {
-    const runtimeRel = path63.join(EJECTED_RUNTIME_DIR, EJECTED_RUNTIME_BUNDLE);
-    const runtimePath = path63.join(harnessDir, runtimeRel);
-    if (!fs58.existsSync(runtimePath)) {
+    const runtimeRel = path64.join(EJECTED_RUNTIME_DIR, EJECTED_RUNTIME_BUNDLE);
+    const runtimePath = path64.join(harnessDir, runtimeRel);
+    if (!fs59.existsSync(runtimePath)) {
       findings.push({
         check: "ejected-runtime",
         severity: "error",
@@ -80447,9 +80505,9 @@ function runDoctor(repoPath) {
       });
     }
     for (const shim3 of RUNTIME_SHIM_FILES) {
-      const shimPath = path63.join(harnessDir, shim3);
-      if (!fs58.existsSync(shimPath)) continue;
-      if (!(fs58.statSync(shimPath).mode & 73)) {
+      const shimPath = path64.join(harnessDir, shim3);
+      if (!fs59.existsSync(shimPath)) continue;
+      if (!(fs59.statSync(shimPath).mode & 73)) {
         findings.push({
           check: "ejected-runtime",
           severity: "warning",
@@ -80463,7 +80521,7 @@ function runDoctor(repoPath) {
   for (const entry of listSlotRegistryEntries(repoPath)) {
     if (entry.status === "completed") continue;
     const dir = entry.worktreePath ?? entry.workDir;
-    if (dir && !fs58.existsSync(dir)) {
+    if (dir && !fs59.existsSync(dir)) {
       findings.push({
         check: "slot-registry",
         severity: "warning",
@@ -80473,11 +80531,11 @@ function runDoctor(repoPath) {
       });
     }
   }
-  const hooksDir = path63.join(harnessDir, "hooks");
-  if (fs58.existsSync(hooksDir)) {
-    for (const file of fs58.readdirSync(hooksDir).sort()) {
-      const full = path63.join(hooksDir, file);
-      if (!fs58.statSync(full).isFile() || !file.endsWith(".sh")) continue;
+  const hooksDir = path64.join(harnessDir, "hooks");
+  if (fs59.existsSync(hooksDir)) {
+    for (const file of fs59.readdirSync(hooksDir).sort()) {
+      const full = path64.join(hooksDir, file);
+      if (!fs59.statSync(full).isFile() || !file.endsWith(".sh")) continue;
       if (!LIFECYCLE_HOOKS.includes(file.replace(/\.sh$/, ""))) {
         findings.push({
           check: "hooks",
@@ -80488,7 +80546,7 @@ function runDoctor(repoPath) {
         });
         continue;
       }
-      if (!(fs58.statSync(full).mode & 73)) {
+      if (!(fs59.statSync(full).mode & 73)) {
         findings.push({
           check: "hooks",
           severity: "warning",
@@ -80544,16 +80602,16 @@ function summarizeDoctorReport(report) {
 }
 
 // src/harness/migrations.ts
-var fs59 = __toESM(require("fs"));
-var path64 = __toESM(require("path"));
+var fs60 = __toESM(require("fs"));
+var path65 = __toESM(require("path"));
 init_schema2();
 init_manifest();
 init_profiles();
 init_stages();
 init_manifest();
 var MIGRATE_DIR = "migrate";
-var MIGRATE_BACKUP_DIR = path64.join(MIGRATE_DIR, "backup");
-var MIGRATE_PLAN_FILE = path64.join(MIGRATE_DIR, "plan.json");
+var MIGRATE_BACKUP_DIR = path65.join(MIGRATE_DIR, "backup");
+var MIGRATE_PLAN_FILE = path65.join(MIGRATE_DIR, "plan.json");
 var LEGACY_MACHINERY_FILES = [
   "agent-slot.sh",
   "provision-toolchain.sh",
@@ -80593,25 +80651,25 @@ function harnessEnvIsPre10(content) {
   return /^\s*(har_infra_enabled|har_pg|har_node_[a-z_]+|har_pkg_exec)\s*\(\)/m.test(content) || /^export\s+HARNESS_[A-Z0-9_]+_PORT_(DEFAULT|SCAN_START|SCAN_END)=/m.test(content);
 }
 function scriptIsVendored(harnessDir, script) {
-  const file = path64.join(harnessDir, script);
-  if (!fs59.existsSync(file)) return false;
-  const content = fs59.readFileSync(file, "utf8");
+  const file = path65.join(harnessDir, script);
+  if (!fs60.existsSync(file)) return false;
+  const content = fs60.readFileSync(file, "utf8");
   return !content.includes("exec har env") && !content.includes("runtime/har.cjs");
 }
 function isPre10Harness(repoPath) {
-  const resolved = path64.resolve(repoPath);
+  const resolved = path65.resolve(repoPath);
   const harnessDir = getHarnessDir(resolved);
-  if (!fs59.existsSync(harnessDir)) return false;
+  if (!fs60.existsSync(harnessDir)) return false;
   const manifest = readManifest(resolved);
   if (manifest?.ejected) return false;
   for (const file of LEGACY_MACHINERY_FILES) {
-    if (fs59.existsSync(path64.join(harnessDir, file))) return true;
+    if (fs60.existsSync(path65.join(harnessDir, file))) return true;
   }
   for (const script of RUNTIME_SHIM_FILES) {
     if (scriptIsVendored(harnessDir, script)) return true;
   }
-  const envPath = path64.join(harnessDir, "harness.env");
-  if (fs59.existsSync(envPath) && harnessEnvIsPre10(fs59.readFileSync(envPath, "utf8"))) {
+  const envPath = path65.join(harnessDir, "harness.env");
+  if (fs60.existsSync(envPath) && harnessEnvIsPre10(fs60.readFileSync(envPath, "utf8"))) {
     return true;
   }
   return false;
@@ -80744,10 +80802,10 @@ var SCRIPT_RESIDUE_TARGET = {
   "agent-cli.sh": "review"
 };
 function backupRel(file) {
-  return path64.join(MIGRATE_BACKUP_DIR, file);
+  return path65.join(MIGRATE_BACKUP_DIR, file);
 }
 function buildPre10Plan(repoPath) {
-  const resolved = path64.resolve(repoPath);
+  const resolved = path65.resolve(repoPath);
   const harnessDir = getHarnessDir(resolved);
   const manifest = readManifest(resolved);
   const profile = manifest?.profile ?? "default";
@@ -80757,11 +80815,11 @@ function buildPre10Plan(repoPath) {
   const residue = [];
   for (const script of RUNTIME_SHIM_FILES) {
     if (!composed.has(script)) continue;
-    if (!scriptIsVendored(harnessDir, script) && fs59.existsSync(path64.join(harnessDir, script))) {
+    if (!scriptIsVendored(harnessDir, script) && fs60.existsSync(path65.join(harnessDir, script))) {
       continue;
     }
     replaceWithShims.push(script);
-    if (fs59.existsSync(path64.join(harnessDir, script))) {
+    if (fs60.existsSync(path65.join(harnessDir, script))) {
       const target = SCRIPT_RESIDUE_TARGET[script] ?? "review";
       residue.push({
         source: script,
@@ -80773,27 +80831,27 @@ function buildPre10Plan(repoPath) {
   }
   const survivingScripts = [];
   for (const dir of ["stages", "hooks"]) {
-    const full = path64.join(harnessDir, dir);
-    if (!fs59.existsSync(full)) continue;
-    for (const entry of fs59.readdirSync(full)) {
-      if (entry.endsWith(".sh") || entry.endsWith(".mjs")) survivingScripts.push(path64.join(dir, entry));
+    const full = path65.join(harnessDir, dir);
+    if (!fs60.existsSync(full)) continue;
+    for (const entry of fs60.readdirSync(full)) {
+      if (entry.endsWith(".sh") || entry.endsWith(".mjs")) survivingScripts.push(path65.join(dir, entry));
     }
   }
   const referencedBy = (machineryFile) => {
-    const base = path64.basename(machineryFile).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const base = path65.basename(machineryFile).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const loadRe = new RegExp(
       `(?:\\bsource\\b|\\bbash\\b|\\bexec\\b|(?:^|[;&|(])\\s*\\.\\s)[^\\n#]*${base}`
     );
     return survivingScripts.filter(
-      (script) => fs59.readFileSync(path64.join(harnessDir, script), "utf8").split("\n").some((line) => !/^\s*#/.test(line) && loadRe.test(line))
+      (script) => fs60.readFileSync(path65.join(harnessDir, script), "utf8").split("\n").some((line) => !/^\s*#/.test(line) && loadRe.test(line))
     );
   };
   const deleteMachinery = [];
   const editedMachinery = [];
   const retainMachinery = [];
   for (const file of LEGACY_MACHINERY_FILES) {
-    const full = path64.join(harnessDir, file);
-    if (!fs59.existsSync(full)) continue;
+    const full = path65.join(harnessDir, file);
+    if (!fs60.existsSync(full)) continue;
     const refs = referencedBy(file);
     if (refs.length > 0) {
       retainMachinery.push(file);
@@ -80807,7 +80865,7 @@ function buildPre10Plan(repoPath) {
     }
     deleteMachinery.push(file);
     const recorded = fileBaseline[file];
-    const installed = computeFileChecksum(fs59.readFileSync(full, "utf8"));
+    const installed = computeFileChecksum(fs60.readFileSync(full, "utf8"));
     if (recorded !== void 0 && installed !== recorded) {
       editedMachinery.push(file);
       residue.push({
@@ -80819,9 +80877,9 @@ function buildPre10Plan(repoPath) {
     }
   }
   let env3 = null;
-  const envPath = path64.join(harnessDir, "harness.env");
-  if (fs59.existsSync(envPath)) {
-    const content = fs59.readFileSync(envPath, "utf8");
+  const envPath = path65.join(harnessDir, "harness.env");
+  if (fs60.existsSync(envPath)) {
+    const content = fs60.readFileSync(envPath, "utf8");
     if (harnessEnvIsPre10(content) || migrateHarnessEnvContent(content).commentedKeys.length > 0) {
       env3 = migrateHarnessEnvContent(content);
       for (const fn of env3.customFunctions) {
@@ -80846,7 +80904,7 @@ function buildPre10Plan(repoPath) {
   for (const file of composed.keys()) {
     if (RUNTIME_SHIM_FILES.includes(file)) continue;
     if (file === "gitignore.template") continue;
-    if (!fs59.existsSync(path64.join(harnessDir, file))) installMissing.push(file);
+    if (!fs60.existsSync(path65.join(harnessDir, file))) installMissing.push(file);
   }
   let phantomVerificationIds = [];
   try {
@@ -80876,51 +80934,51 @@ function buildPre10Plan(repoPath) {
   };
 }
 function applyPre10Plan(repoPath, plan) {
-  const resolved = path64.resolve(repoPath);
+  const resolved = path65.resolve(repoPath);
   const harnessDir = getHarnessDir(resolved);
   const effective = plan ?? buildPre10Plan(resolved);
-  const backupDir = path64.join(harnessDir, MIGRATE_BACKUP_DIR);
-  fs59.mkdirSync(backupDir, { recursive: true });
+  const backupDir = path65.join(harnessDir, MIGRATE_BACKUP_DIR);
+  fs60.mkdirSync(backupDir, { recursive: true });
   const backup = (file) => {
-    const src = path64.join(harnessDir, file);
-    if (!fs59.existsSync(src)) return;
-    const dest = path64.join(backupDir, file);
-    fs59.mkdirSync(path64.dirname(dest), { recursive: true });
-    fs59.copyFileSync(src, dest);
+    const src = path65.join(harnessDir, file);
+    if (!fs60.existsSync(src)) return;
+    const dest = path65.join(backupDir, file);
+    fs60.mkdirSync(path65.dirname(dest), { recursive: true });
+    fs60.copyFileSync(src, dest);
   };
   const written = [];
   const deleted = [];
-  const projectName = path64.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const projectName = path65.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
   const composed = composeProfileTemplateMap(effective.profile);
   for (const script of effective.replaceWithShims) {
     const source = composed.get(script);
     if (!source) continue;
     backup(script);
     const rendered = substituteTemplateTokens(readComposedTemplateContent(source), projectName);
-    const dest = path64.join(harnessDir, script);
-    fs59.writeFileSync(dest, rendered);
-    fs59.chmodSync(dest, 493);
+    const dest = path65.join(harnessDir, script);
+    fs60.writeFileSync(dest, rendered);
+    fs60.chmodSync(dest, 493);
     written.push(script);
   }
   for (const file of effective.deleteMachinery) {
     backup(file);
-    fs59.rmSync(path64.join(harnessDir, file), { force: true });
+    fs60.rmSync(path65.join(harnessDir, file), { force: true });
     deleted.push(file);
   }
-  const libDir = path64.join(harnessDir, "lib");
-  if (fs59.existsSync(libDir) && fs59.readdirSync(libDir).length === 0) {
-    fs59.rmdirSync(libDir);
+  const libDir = path65.join(harnessDir, "lib");
+  if (fs60.existsSync(libDir) && fs60.readdirSync(libDir).length === 0) {
+    fs60.rmdirSync(libDir);
     deleted.push("lib/");
   }
   for (const file of effective.installMissing ?? []) {
     const source = composed.get(file);
     if (!source) continue;
-    const dest = path64.join(harnessDir, file);
-    if (fs59.existsSync(dest)) continue;
+    const dest = path65.join(harnessDir, file);
+    if (fs60.existsSync(dest)) continue;
     const rendered = substituteTemplateTokens(readComposedTemplateContent(source), projectName);
-    fs59.mkdirSync(path64.dirname(dest), { recursive: true });
-    fs59.writeFileSync(dest, rendered);
-    if (/\.(sh|mjs)$/.test(file)) fs59.chmodSync(dest, 493);
+    fs60.mkdirSync(path65.dirname(dest), { recursive: true });
+    fs60.writeFileSync(dest, rendered);
+    if (/\.(sh|mjs)$/.test(file)) fs60.chmodSync(dest, 493);
     written.push(file);
   }
   if (effective.phantomVerificationIds.length > 0) {
@@ -80935,7 +80993,7 @@ function applyPre10Plan(repoPath, plan) {
   }
   if (effective.env) {
     backup("harness.env");
-    fs59.writeFileSync(path64.join(harnessDir, "harness.env"), effective.env.content);
+    fs60.writeFileSync(path65.join(harnessDir, "harness.env"), effective.env.content);
     written.push("harness.env");
   }
   const manifest = readManifest(resolved);
@@ -80950,8 +81008,8 @@ function applyPre10Plan(repoPath, plan) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
-  fs59.writeFileSync(
-    path64.join(harnessDir, MIGRATE_PLAN_FILE),
+  fs60.writeFileSync(
+    path65.join(harnessDir, MIGRATE_PLAN_FILE),
     JSON.stringify({ ...effective, appliedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
   );
   return { plan: effective, backupDir, written, deleted };
@@ -80971,21 +81029,21 @@ function pendingMigrations(repoPath) {
   );
 }
 function writeMigrationPlan(repoPath, plan) {
-  const harnessDir = getHarnessDir(path64.resolve(repoPath));
-  const planPath = path64.join(harnessDir, MIGRATE_PLAN_FILE);
-  fs59.mkdirSync(path64.dirname(planPath), { recursive: true });
-  fs59.writeFileSync(planPath, JSON.stringify(plan, null, 2) + "\n");
+  const harnessDir = getHarnessDir(path65.resolve(repoPath));
+  const planPath = path65.join(harnessDir, MIGRATE_PLAN_FILE);
+  fs60.mkdirSync(path65.dirname(planPath), { recursive: true });
+  fs60.writeFileSync(planPath, JSON.stringify(plan, null, 2) + "\n");
   return planPath;
 }
 function removeMigrationArtifacts(repoPath) {
-  const harnessDir = getHarnessDir(path64.resolve(repoPath));
-  fs59.rmSync(path64.join(harnessDir, MIGRATE_DIR), { recursive: true, force: true });
-  fs59.rmSync(path64.join(harnessDir, "MIGRATE-PROMPT.md"), { force: true });
+  const harnessDir = getHarnessDir(path65.resolve(repoPath));
+  fs60.rmSync(path65.join(harnessDir, MIGRATE_DIR), { recursive: true, force: true });
+  fs60.rmSync(path65.join(harnessDir, "MIGRATE-PROMPT.md"), { force: true });
 }
 
 // src/harness/migrate-prompt.ts
-var fs60 = __toESM(require("fs"));
-var path65 = __toESM(require("path"));
+var fs61 = __toESM(require("fs"));
+var path66 = __toESM(require("path"));
 init_paths();
 init_file_ops();
 init_manifest();
@@ -81094,18 +81152,18 @@ function buildMigrationSection(plan, applied) {
   lines2.push(...residueTable(plan), "");
   return lines2.join("\n");
 }
-function loadTemplate() {
+function loadTemplate2() {
   const filePath = resolveTemplateFile("migration-prompt.md");
   if (!filePath) {
     throw new Error("Migration prompt template not found: migration-prompt.md. Run npm run build.");
   }
-  return fs60.readFileSync(filePath, "utf8");
+  return fs61.readFileSync(filePath, "utf8");
 }
 function buildMigrationPrompt(plan, applied) {
-  return loadTemplate().replace("{{MIGRATION_SECTION}}", buildMigrationSection(plan, applied));
+  return loadTemplate2().replace("{{MIGRATION_SECTION}}", buildMigrationSection(plan, applied));
 }
 function writeMigrationPrompt(repoPath, content) {
-  const filePath = path65.join(getHarnessDir(repoPath), MIGRATE_PROMPT_FILE);
+  const filePath = path66.join(getHarnessDir(repoPath), MIGRATE_PROMPT_FILE);
   writeFileSafe(filePath, content);
   return filePath;
 }
@@ -81113,11 +81171,11 @@ function writeMigrationPrompt(repoPath, content) {
 // src/core/harness.ts
 function listHarnessScripts(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs61.existsSync(harnessDir)) return [];
-  return fs61.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
+  if (!fs62.existsSync(harnessDir)) return [];
+  return fs62.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
 }
 function describeProject(repoPath) {
-  const resolved = path66.resolve(repoPath);
+  const resolved = path67.resolve(repoPath);
   const manifest = readManifest(resolved);
   const present = harnessExists(resolved);
   return {
@@ -81137,8 +81195,8 @@ function describeProject(repoPath) {
   };
 }
 async function initHarness(options) {
-  const repoPath = path66.resolve(options.repoPath);
-  if (!fs61.existsSync(repoPath)) {
+  const repoPath = path67.resolve(options.repoPath);
+  if (!fs62.existsSync(repoPath)) {
     throw new Error(`Path not found: ${repoPath}`);
   }
   const scaffold = scaffoldHarnessBoilerplate(repoPath, {
@@ -81159,9 +81217,9 @@ async function initHarness(options) {
   };
 }
 async function maintainHarness(options) {
-  const repoPath = path66.resolve(options.repoPath);
+  const repoPath = path67.resolve(options.repoPath);
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs61.existsSync(harnessDir)) {
+  if (!fs62.existsSync(harnessDir)) {
     throw new Error('No .har/ found. Run "har env init" first.');
   }
   let migration;
@@ -81237,8 +81295,8 @@ function addPlugin(repoPath, pluginId, options = {}) {
 }
 
 // src/harness/adaptation-prompt.ts
-var fs62 = __toESM(require("fs"));
-var path67 = __toESM(require("path"));
+var fs63 = __toESM(require("fs"));
+var path68 = __toESM(require("path"));
 var readline5 = __toESM(require("readline"));
 
 // src/utils/clipboard.ts
@@ -81324,21 +81382,21 @@ var PROFILE_HINTS = {
   cli: "CLI/library profile (typical SWE-bench) \u2014 no PM2. Optional Docker Compose via HARNESS_INFRA_SERVICES. Git worktree by default. Launch provisions toolchain declaratively (HARNESS_ECOSYSTEM auto-detects common ecosystems); verify must use resolved tool paths from .env.agent.<id>, never hardcoded interpreter or package-manager paths.",
   ios: "iOS mobile app profile \u2014 xcodebuild + iOS Simulator in an isolated git worktree. Set HARNESS_XCODE_SCHEME, workspace/project, HARNESS_SIMULATOR_NAME, HARNESS_BUNDLE_ID. Launch writes XCODEBUILD_BIN to .env.agent.<id>; verify uses it."
 };
-function loadTemplate2(name) {
+function loadTemplate3(name) {
   const filePath = resolveTemplateFile(name);
   if (!filePath) {
     throw new Error(`Adaptation prompt template not found: ${name}. Run npm run build.`);
   }
-  return fs62.readFileSync(filePath, "utf8");
+  return fs63.readFileSync(filePath, "utf8");
 }
 function applyProfilePlaceholders(content, profile) {
   return content.replace(/\{\{PROFILE\}\}/g, profile).replace(/\{\{PROFILE_HINT\}\}/g, PROFILE_HINTS[profile]);
 }
 function buildInitAdaptationPrompt(_repoPath, profile) {
-  return applyProfilePlaceholders(loadTemplate2("adaptation-prompt-init.md"), profile);
+  return applyProfilePlaceholders(loadTemplate3("adaptation-prompt-init.md"), profile);
 }
 function buildMaintainAdaptationPrompt(_repoPath, bundleReport) {
-  const template = loadTemplate2("adaptation-prompt-maintain.md");
+  const template = loadTemplate3("adaptation-prompt-maintain.md");
   const section = bundleReport ? formatMaintainBundlePromptSection(bundleReport) : [
     "## Step 0 \u2014 Read the maintenance bundle",
     "",
@@ -81351,7 +81409,7 @@ function buildMaintainAdaptationPrompt(_repoPath, bundleReport) {
 }
 function writeAdaptationPrompt(repoPath, content) {
   const harnessDir = getHarnessDir(repoPath);
-  const filePath = path67.join(harnessDir, ADAPTATION_PROMPT_FILE);
+  const filePath = path68.join(harnessDir, ADAPTATION_PROMPT_FILE);
   writeFileSafe(filePath, content);
   return filePath;
 }
@@ -81380,9 +81438,10 @@ function askYesNo2(question) {
   });
 }
 async function offerAdaptationPromptClipboard(content, options = {}) {
+  const fileLabel = options.fileLabel ?? `.har/${ADAPTATION_PROMPT_FILE}`;
   const interactive = Boolean(process.stdin.isTTY && process.stderr.isTTY);
   if (!interactive && !options.autoYes) {
-    info("Prompt also saved to .har/ADAPT-PROMPT.md (open or copy from there)");
+    info(`Prompt also saved to ${fileLabel} (open or copy from there)`);
     return false;
   }
   let shouldCopy = options.autoYes === true;
@@ -81390,7 +81449,7 @@ async function offerAdaptationPromptClipboard(content, options = {}) {
     shouldCopy = await askYesNo2("Copy adaptation prompt to clipboard for your coding agent? [Y/n]");
   }
   if (!shouldCopy) {
-    info("Skipped clipboard copy \u2014 prompt is in .har/ADAPT-PROMPT.md");
+    info(`Skipped clipboard copy \u2014 prompt is in ${fileLabel}`);
     return false;
   }
   const result = copyTextToClipboard(content);
@@ -81401,33 +81460,33 @@ async function offerAdaptationPromptClipboard(content, options = {}) {
     return true;
   }
   warn(`Could not copy to clipboard: ${result.detail}`);
-  info("Open .har/ADAPT-PROMPT.md and paste that into your coding agent instead");
+  info(`Open ${fileLabel} and paste that into your coding agent instead`);
   return false;
 }
 
 // src/harness/cursor-rule.ts
-var fs63 = __toESM(require("fs"));
-var path68 = __toESM(require("path"));
+var fs64 = __toESM(require("fs"));
+var path69 = __toESM(require("path"));
 var readline6 = __toESM(require("readline"));
 init_file_ops();
 init_logging();
 init_paths();
 var CURSOR_RULE_RELATIVE_PATH = ".cursor/rules/har-workflow.mdc";
 function getCursorRulePath(repoPath) {
-  return path68.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
+  return path69.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
 }
 function isCursorWorkspace(repoPath) {
-  return fs63.existsSync(path68.join(repoPath, ".cursor"));
+  return fs64.existsSync(path69.join(repoPath, ".cursor"));
 }
 function cursorRuleExists(repoPath) {
-  return fs63.existsSync(getCursorRulePath(repoPath));
+  return fs64.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 = fs63.readFileSync(templatePath, "utf8");
+  const content = fs64.readFileSync(templatePath, "utf8");
   writeFileSafe(getCursorRulePath(repoPath), content);
 }
 async function handleCursorRule(options) {
@@ -81518,7 +81577,7 @@ init_control_config();
 
 // src/core/control-lifecycle.ts
 var import_child_process17 = require("child_process");
-var path69 = __toESM(require("path"));
+var path70 = __toESM(require("path"));
 
 // src/core/control-image.ts
 init_package_version();
@@ -81545,10 +81604,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 path69.resolve(__dirname, "..", "control");
+  return path70.resolve(__dirname, "..", "control");
 }
 function resolveControlBuildContext() {
-  return path69.resolve(resolveControlDir(), "..");
+  return path70.resolve(resolveControlDir(), "..");
 }
 function buildDockerRunArgs(options) {
   const name = options.containerName ?? CONTROL_CONTAINER_NAME;
@@ -81604,7 +81663,7 @@ async function startMissionControl(options) {
       "-t",
       imageRef,
       "-f",
-      path69.join(resolveControlDir(), "Dockerfile"),
+      path70.join(resolveControlDir(), "Dockerfile"),
       resolveControlBuildContext()
     ]);
     if (buildCode !== 0) {
@@ -81751,7 +81810,7 @@ async function ensureTelemetryInfrastructure(options) {
 // src/core/run-service.ts
 init_telemetry_config();
 init_telemetry_env();
-var path71 = __toESM(require("path"));
+var path72 = __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 ?? "";
@@ -81974,12 +82033,12 @@ Usage from Cursor / Claude / Codex (@osfactory/otel-hook) will appear under Work
           suffix: session.suffix,
           createdAt: session.createdAt
         });
-        const envFile = path71.join(session.workDir, `.env.agent.${options.agentId}`);
+        const envFile = path72.join(session.workDir, `.env.agent.${options.agentId}`);
         try {
           appendTelemetryEnvToFile(envFile, {
             sessionKey,
             agentId: options.agentId,
-            repoPath: path71.resolve(options.repoPath),
+            repoPath: path72.resolve(options.repoPath),
             workDir: session.workDir,
             branch: session.branch,
             suffix: session.suffix,
@@ -82221,9 +82280,9 @@ init_work_units();
 init_manifest();
 
 // src/core/cleanup-service.ts
-var fs65 = __toESM(require("fs"));
+var fs66 = __toESM(require("fs"));
 var os22 = __toESM(require("os"));
-var path72 = __toESM(require("path"));
+var path73 = __toESM(require("path"));
 var import_child_process19 = require("child_process");
 init_control_sync();
 init_control_repo_path();
@@ -82232,9 +82291,9 @@ init_manifest();
 var DEFAULT_STALE_DAYS = 7;
 function getWorktreesRoot() {
   if (process.env.HAR_WORKTREES_ROOT) {
-    return path72.resolve(process.env.HAR_WORKTREES_ROOT);
+    return path73.resolve(process.env.HAR_WORKTREES_ROOT);
   }
-  return path72.join(process.env.HOME || os22.homedir(), "worktrees");
+  return path73.join(process.env.HOME || os22.homedir(), "worktrees");
 }
 function runGit3(cwd, args) {
   try {
@@ -82248,7 +82307,7 @@ function runGit3(cwd, args) {
   }
 }
 function basenameRepo(repoPath) {
-  return path72.basename(canonicalizeControlRepoPath(repoPath));
+  return path73.basename(canonicalizeControlRepoPath(repoPath));
 }
 function ageDaysFrom(iso) {
   if (!iso) return void 0;
@@ -82260,12 +82319,12 @@ function matchesKeep(candidate, keep) {
   if (!keep?.length) return false;
   for (const pin of keep) {
     if (pin.worktreePath && candidate.worktreePath) {
-      if (path72.resolve(pin.worktreePath) === path72.resolve(candidate.worktreePath)) return true;
+      if (path73.resolve(pin.worktreePath) === path73.resolve(candidate.worktreePath)) return true;
     }
     if (pin.repoPath && pin.agentId !== void 0 && candidate.agentId !== void 0) {
       const repo = canonicalizeControlRepoPath(pin.repoPath);
-      const candidateRepo = path72.resolve(candidate.repoPath);
-      if ((repo === candidateRepo || path72.resolve(pin.repoPath) === candidateRepo) && pin.agentId === candidate.agentId) {
+      const candidateRepo = path73.resolve(candidate.repoPath);
+      if ((repo === candidateRepo || path73.resolve(pin.repoPath) === candidateRepo) && pin.agentId === candidate.agentId) {
         return true;
       }
     }
@@ -82320,20 +82379,20 @@ function classifySlotCandidate(repoPath, projectName, slot, options) {
   return candidate;
 }
 function resolveRepoForWorktree(worktreePath) {
-  if (!fs65.existsSync(worktreePath)) return void 0;
+  if (!fs66.existsSync(worktreePath)) return void 0;
   const commonDir = runGit3(worktreePath, "rev-parse --git-common-dir");
   if (!commonDir) return void 0;
-  const gitRoot = path72.resolve(worktreePath, commonDir, "..");
+  const gitRoot = path73.resolve(worktreePath, commonDir, "..");
   if (!readManifest(gitRoot)) return void 0;
   return canonicalizeControlRepoPath(gitRoot);
 }
 function discoverOrphanWorktrees(knownPaths) {
   const worktreesRoot = getWorktreesRoot();
-  if (!fs65.existsSync(worktreesRoot)) return [];
+  if (!fs66.existsSync(worktreesRoot)) return [];
   const orphans = [];
-  for (const entry of fs65.readdirSync(worktreesRoot, { withFileTypes: true })) {
+  for (const entry of fs66.readdirSync(worktreesRoot, { withFileTypes: true })) {
     if (!entry.isDirectory() || !entry.name.includes("-har-agent-")) continue;
-    const worktreePath = path72.resolve(path72.join(worktreesRoot, entry.name));
+    const worktreePath = path73.resolve(path73.join(worktreesRoot, entry.name));
     if (knownPaths.has(worktreePath)) continue;
     const repoPath = resolveRepoForWorktree(worktreePath) ?? worktreesRoot;
     const porcelain = runGit3(worktreePath, "status --porcelain");
@@ -82358,14 +82417,14 @@ async function discoverCleanupCandidates(options = {}) {
   const candidates = [];
   const knownWorktreePaths = /* @__PURE__ */ new Set();
   for (const repoPath of repoPaths) {
-    if (!fs65.existsSync(repoPath) || !readManifest(repoPath)) continue;
+    if (!fs66.existsSync(repoPath) || !readManifest(repoPath)) continue;
     const harnessRoot = resolveHarnessRoot(repoPath);
     const canonicalRepo = canonicalizeControlRepoPath(harnessRoot);
     const status = collectEnvironmentStatus(harnessRoot);
     const projectName = basenameRepo(harnessRoot);
     for (const slot of status.slots) {
-      if (slot.worktreePath) knownWorktreePaths.add(path72.resolve(slot.worktreePath));
-      if (slot.workDir) knownWorktreePaths.add(path72.resolve(slot.workDir));
+      if (slot.worktreePath) knownWorktreePaths.add(path73.resolve(slot.worktreePath));
+      if (slot.workDir) knownWorktreePaths.add(path73.resolve(slot.workDir));
       const candidate = classifySlotCandidate(canonicalRepo, projectName, slot, {
         staleDays: options.staleDays,
         keep: options.keep
@@ -82471,7 +82530,7 @@ async function executeCleanupCandidates(candidates, options = {}) {
         continue;
       }
       if (candidate.kind === "orphan_worktree" && candidate.worktreePath) {
-        if (fs65.existsSync(candidate.worktreePath)) {
+        if (fs66.existsSync(candidate.worktreePath)) {
           const repoRoot = candidate.repoPath !== getWorktreesRoot() ? candidate.repoPath : resolveRepoForWorktree(candidate.worktreePath);
           if (repoRoot) {
             try {
@@ -82482,8 +82541,8 @@ async function executeCleanupCandidates(candidates, options = {}) {
             } catch {
             }
           }
-          if (fs65.existsSync(candidate.worktreePath)) {
-            fs65.rmSync(candidate.worktreePath, { recursive: true, force: true });
+          if (fs66.existsSync(candidate.worktreePath)) {
+            fs66.rmSync(candidate.worktreePath, { recursive: true, force: true });
           }
         }
         outcomes.push({ candidate, ok: true });
@@ -82509,7 +82568,7 @@ function parseCleanupKeepPins(values) {
     }
     if (raw.startsWith("/") || raw.startsWith("~")) {
       return {
-        worktreePath: raw.startsWith("~") ? path72.join(process.env.HOME || os22.homedir(), raw.slice(2)) : path72.resolve(raw)
+        worktreePath: raw.startsWith("~") ? path73.join(process.env.HOME || os22.homedir(), raw.slice(2)) : path73.resolve(raw)
       };
     }
     return { repoPath: raw };
@@ -82629,21 +82688,21 @@ function warnIfDockerUnavailable(status = detectDockerStatus()) {
 }
 
 // src/core/onboarding-preferences.ts
-var fs66 = __toESM(require("fs"));
+var fs67 = __toESM(require("fs"));
 var os23 = __toESM(require("os"));
-var path73 = __toESM(require("path"));
+var path74 = __toESM(require("path"));
 init_schema2();
 function getOnboardingPreferencesPath() {
   if (process.env.HAR_PREFERENCES_PATH) {
-    return path73.resolve(process.env.HAR_PREFERENCES_PATH);
+    return path74.resolve(process.env.HAR_PREFERENCES_PATH);
   }
-  return path73.join(os23.homedir(), ".har", "preferences.json");
+  return path74.join(os23.homedir(), ".har", "preferences.json");
 }
 function readOnboardingPreferences() {
   const preferencePath = getOnboardingPreferencesPath();
   try {
-    if (!fs66.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
-    return OnboardingPreferencesSchema.parse(JSON.parse(fs66.readFileSync(preferencePath, "utf8")));
+    if (!fs67.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
+    return OnboardingPreferencesSchema.parse(JSON.parse(fs67.readFileSync(preferencePath, "utf8")));
   } catch {
     return OnboardingPreferencesSchema.parse({});
   }
@@ -82668,8 +82727,8 @@ function writeOnboardingPreferences(overrides) {
   };
   const parsed = OnboardingPreferencesSchema.parse(preference);
   const preferencePath = getOnboardingPreferencesPath();
-  fs66.mkdirSync(path73.dirname(preferencePath), { recursive: true });
-  fs66.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
+  fs67.mkdirSync(path74.dirname(preferencePath), { recursive: true });
+  fs67.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return parsed;
 }
@@ -83055,7 +83114,7 @@ var envCommand = {
   }
 };
 async function handleInit(argv) {
-  const repoPath = path74.resolve(argv.repo);
+  const repoPath = path75.resolve(argv.repo);
   const onboarding = resolveOnboardingOptions(argv);
   header("har env init");
   info(`Repository: ${repoPath}`);
@@ -83102,7 +83161,7 @@ async function handleInit(argv) {
   }
 }
 async function handleMaintain(argv) {
-  const repoPath = path74.resolve(argv.repo);
+  const repoPath = path75.resolve(argv.repo);
   const onboarding = resolveOnboardingOptions(argv);
   header("har env maintain");
   info(`Repository: ${repoPath}`);
@@ -83257,7 +83316,7 @@ async function applyAgentIntegrations(options) {
   }
 }
 async function handleAddPlugin(argv) {
-  const repoPath = path74.resolve(argv.repo);
+  const repoPath = path75.resolve(argv.repo);
   const available = listPluginIds();
   if (argv.list) {
     for (const id of available) {
@@ -83292,6 +83351,9 @@ async function handleAddPlugin(argv) {
     console.error("");
     console.error(`  Docs: ${result.docsPath}`);
     console.error("");
+    info(`Adaptation prompt saved to ${result.adaptPromptPath}`);
+    const promptContent = fs68.readFileSync(path75.join(repoPath, result.adaptPromptPath), "utf8");
+    await offerAdaptationPromptClipboard(promptContent, { fileLabel: result.adaptPromptPath });
   } catch (err) {
     error(err.message);
     return finishCommand(1);
@@ -83332,7 +83394,7 @@ async function handleAddStage(argv) {
   });
 }
 async function handlePreflight(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await preflightEnvironment({
     repoPath: repo,
@@ -83348,7 +83410,7 @@ async function handlePreflight(argv) {
   return finishCommand(result.code);
 }
 async function handleLaunch(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await launchEnvironment({
     repoPath: repo,
@@ -83390,7 +83452,7 @@ async function handleWorkLink(argv) {
     error("Provide --link or both --source and --url");
     return finishCommand(1);
   }
-  const harnessRoot = resolveHarnessRoot(path74.resolve(argv.repo));
+  const harnessRoot = resolveHarnessRoot(path75.resolve(argv.repo));
   const links = argv.link ? [parseWorkLinkSpec(argv.link)] : [{ source: argv.source, url: argv.url, label: argv.label }];
   try {
     const record2 = addWorkUnitLinks(harnessRoot, argv.workId, links);
@@ -83416,7 +83478,7 @@ async function handleRecover(argv) {
   });
 }
 async function handleVerify(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await runVerification({
     repoPath: repo,
@@ -83445,7 +83507,7 @@ async function handleVerify(argv) {
   return finishCommand(result.code);
 }
 async function handleTeardown(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await teardownEnvironment({
     repoPath: repo,
@@ -83456,7 +83518,7 @@ async function handleTeardown(argv) {
   return finishCommand(result.code);
 }
 async function handleComplete(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await completeEnvironment({
     repoPath: repo,
@@ -83477,7 +83539,7 @@ async function handleComplete(argv) {
   return finishCommand(result.code);
 }
 async function handleSetupInfra(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const result = await runStage({
     repoPath: repo,
     kind: "setup",
@@ -83487,7 +83549,7 @@ async function handleSetupInfra(argv) {
   return finishCommand(result.code ?? (result.status === "pass" ? 0 : 1));
 }
 async function handleAgent(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await runAgentOp({
     repoPath: repo,
@@ -83498,7 +83560,7 @@ async function handleAgent(argv) {
   return finishCommand(result.code);
 }
 async function handleDoctor(argv) {
-  const repoPath = path74.resolve(argv.repo);
+  const repoPath = path75.resolve(argv.repo);
   const report = runDoctor(repoPath);
   if (argv.json) {
     console.log(JSON.stringify(report, null, 2));
@@ -83527,7 +83589,7 @@ async function confirm(question) {
   return /^y(es)?$/i.test(answer.trim());
 }
 async function handleEject(argv) {
-  const repoPath = resolveHarnessRoot(path74.resolve(argv.repo));
+  const repoPath = resolveHarnessRoot(path75.resolve(argv.repo));
   header("har env eject");
   warn("This vendors the complete HAR runtime into .har/runtime/ and rewrites the");
   warn(".har/*.sh scripts to execute it directly \u2014 from then on YOU OWN those files:");
@@ -83557,7 +83619,7 @@ async function handleEject(argv) {
   return finishCommand(0);
 }
 async function handleAdopt(argv) {
-  const repoPath = resolveHarnessRoot(path74.resolve(argv.repo));
+  const repoPath = resolveHarnessRoot(path75.resolve(argv.repo));
   try {
     const result = adoptHarness(repoPath);
     success("Returned to managed shims \u2014 .har/runtime/ removed, eject flag cleared.");
@@ -83570,7 +83632,7 @@ async function handleAdopt(argv) {
   return finishCommand(0);
 }
 async function handleStatus(argv) {
-  const repoPath = path74.resolve(argv.repo);
+  const repoPath = path75.resolve(argv.repo);
   const result = await getEnvironmentStatus({
     repoPath,
     capture: false
@@ -83583,7 +83645,7 @@ async function handleStatus(argv) {
   if (result.stdout) process.stdout.write(result.stdout);
 }
 async function handleLogs(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await getEnvironmentLogs({
     repoPath: repo,
@@ -83595,7 +83657,7 @@ async function handleLogs(argv) {
   return finishCommand(result.code);
 }
 async function handleRunStage(argv) {
-  const repo = path74.resolve(argv.repo);
+  const repo = path75.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   if (!argv.stage) {
     error("Missing stage id. Usage: har env run-stage <id> <stage> [args..]");
@@ -83621,7 +83683,7 @@ async function handleRunStage(argv) {
 }
 async function handleArtifacts(argv) {
   const artifacts = listArtifacts({
-    repoPath: path74.resolve(argv.repo),
+    repoPath: path75.resolve(argv.repo),
     stageId: argv.stage
   });
   if (argv.json) {
@@ -83640,7 +83702,7 @@ async function handleArtifacts(argv) {
 async function handleCleanup(argv) {
   const keepValues = argv.keep?.split(",").map((value) => value.trim()).filter(Boolean);
   const keep = parseCleanupKeepPins(keepValues);
-  const repoPaths = argv.repo ? [path74.resolve(argv.repo)] : void 0;
+  const repoPaths = argv.repo ? [path75.resolve(argv.repo)] : void 0;
   const plan = await discoverCleanupCandidates({
     cwd: process.cwd(),
     repoPaths,
@@ -83689,7 +83751,7 @@ async function handleCleanup(argv) {
   return finishCommand(failed > 0 ? 1 : 0);
 }
 async function handleRunsList(argv) {
-  const repoPath = path74.resolve(argv.repo);
+  const repoPath = path75.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");
@@ -83706,7 +83768,7 @@ async function handleRunsList(argv) {
   }
 }
 async function handleRunsGet(argv) {
-  const run2 = getRun(path74.resolve(argv.repo), argv.runId);
+  const run2 = getRun(path75.resolve(argv.repo), argv.runId);
   if (!run2) {
     error(`Run not found: ${argv.runId}`);
     return finishCommand(1);
@@ -83823,7 +83885,7 @@ function printNextSteps() {
 }
 
 // src/cli/commands/control.ts
-var path79 = __toESM(require("path"));
+var path80 = __toESM(require("path"));
 init_control_config();
 init_portal_targets();
 
@@ -83831,8 +83893,8 @@ init_portal_targets();
 init_control_config();
 
 // src/core/portal-connect.ts
-var fs67 = __toESM(require("fs"));
-var path75 = __toESM(require("path"));
+var fs69 = __toESM(require("fs"));
+var path76 = __toESM(require("path"));
 var import_crypto2 = require("crypto");
 init_control_repo_path();
 init_control_registry();
@@ -84001,8 +84063,8 @@ function remainingConnections(connections, usedAliases) {
 // src/core/portal-connect.ts
 init_portal_targets();
 function attachRepoIfPresent(alias, repoPath) {
-  const resolved = path75.resolve(repoPath ?? ".");
-  if (!fs67.existsSync(resolved)) return null;
+  const resolved = path76.resolve(repoPath ?? ".");
+  if (!fs69.existsSync(resolved)) return null;
   const canonical = canonicalizeControlRepoPath(resolved);
   attachRepoPortalTarget(canonical, alias);
   recordRepoForControlSync(canonical);
@@ -84069,8 +84131,8 @@ async function runPortalConnect(input) {
   return { record: record2, attachedRepo, extraAttached, mappedInBrowser: true };
 }
 function listRegisteredReposForConnect(repoPath) {
-  const resolved = repoPath ? path75.resolve(repoPath) : null;
-  const current = resolved && fs67.existsSync(resolved) ? canonicalizeControlRepoPath(resolved) : null;
+  const resolved = repoPath ? path76.resolve(repoPath) : null;
+  const current = resolved && fs69.existsSync(resolved) ? canonicalizeControlRepoPath(resolved) : null;
   return [.../* @__PURE__ */ new Set([...current ? [current] : [], ...listRegisteredRepos()])];
 }
 
@@ -84386,21 +84448,21 @@ init_control_port();
 init_control_sync();
 
 // src/core/control-sync-selection.ts
-var fs68 = __toESM(require("fs"));
+var fs70 = __toESM(require("fs"));
 var os24 = __toESM(require("os"));
-var path76 = __toESM(require("path"));
+var path77 = __toESM(require("path"));
 init_control_repo_path();
 function getSelectionPath() {
   if (process.env.HAR_CONTROL_SYNC_SELECTION_PATH) {
-    return path76.resolve(process.env.HAR_CONTROL_SYNC_SELECTION_PATH);
+    return path77.resolve(process.env.HAR_CONTROL_SYNC_SELECTION_PATH);
   }
-  return path76.join(os24.homedir(), ".har", "sync-selection.json");
+  return path77.join(os24.homedir(), ".har", "sync-selection.json");
 }
 function readSyncSelection() {
   const selectionPath = getSelectionPath();
   try {
-    if (!fs68.existsSync(selectionPath)) return null;
-    const parsed = JSON.parse(fs68.readFileSync(selectionPath, "utf8"));
+    if (!fs70.existsSync(selectionPath)) return null;
+    const parsed = JSON.parse(fs70.readFileSync(selectionPath, "utf8"));
     if (!Array.isArray(parsed.repos)) return null;
     return parsed.repos.map((repoPath) => canonicalizeControlRepoPath(repoPath));
   } catch {
@@ -84410,8 +84472,8 @@ function readSyncSelection() {
 function writeSyncSelection(repos) {
   const selectionPath = getSelectionPath();
   const canonical = Array.from(new Set(repos.map((repoPath) => canonicalizeControlRepoPath(repoPath))));
-  fs68.mkdirSync(path76.dirname(selectionPath), { recursive: true });
-  fs68.writeFileSync(selectionPath, JSON.stringify({ repos: canonical }, null, 2) + "\n");
+  fs70.mkdirSync(path77.dirname(selectionPath), { recursive: true });
+  fs70.writeFileSync(selectionPath, JSON.stringify({ repos: canonical }, null, 2) + "\n");
 }
 function resolveSyncSelection(input) {
   const { discovered, stored, forceSelect, isTTY } = input;
@@ -84438,8 +84500,8 @@ function resolveSyncSelection(input) {
 }
 
 // src/core/control-unregister.ts
-var fs69 = __toESM(require("fs"));
-var path77 = __toESM(require("path"));
+var fs71 = __toESM(require("fs"));
+var path78 = __toESM(require("path"));
 init_control_repo_path();
 init_control_registry();
 init_control_config();
@@ -84449,9 +84511,9 @@ function listUnregisterWorktreeCandidates(repoPath) {
   const harnessRoot = canonicalizeControlRepoPath(repoPath);
   const byPath = /* @__PURE__ */ new Map();
   const add = (partial2) => {
-    const resolved = path77.resolve(partial2.worktreePath);
+    const resolved = path78.resolve(partial2.worktreePath);
     if (!resolved || resolved === harnessRoot) return;
-    const exists = partial2.exists ?? fs69.existsSync(resolved);
+    const exists = partial2.exists ?? fs71.existsSync(resolved);
     const prev = byPath.get(resolved);
     if (prev) {
       byPath.set(resolved, {
@@ -84565,28 +84627,28 @@ async function teardownWorktrees(repoPath, candidates, dryRun) {
         trigger: "cli"
       });
       if (result.code !== 0) {
-        if (fs69.existsSync(candidate.worktreePath)) {
-          fs69.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs71.existsSync(candidate.worktreePath)) {
+          fs71.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs69.existsSync(candidate.worktreePath),
-        error: result.code !== 0 && fs69.existsSync(candidate.worktreePath) ? result.stderr : void 0
+        deleted: !fs71.existsSync(candidate.worktreePath),
+        error: result.code !== 0 && fs71.existsSync(candidate.worktreePath) ? result.stderr : void 0
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       try {
-        if (fs69.existsSync(candidate.worktreePath)) {
-          fs69.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs71.existsSync(candidate.worktreePath)) {
+          fs71.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       } catch {
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs69.existsSync(candidate.worktreePath),
+        deleted: !fs71.existsSync(candidate.worktreePath),
         error: message
       });
     }
@@ -84649,16 +84711,16 @@ init_control_config();
 init_control_registry();
 
 // src/core/harness-scrub.ts
-var fs70 = __toESM(require("fs"));
-var path78 = __toESM(require("path"));
+var fs72 = __toESM(require("fs"));
+var path79 = __toESM(require("path"));
 var HARNESS_SCRUB_DIRS = ["runs", "validations", "state", "slots"];
 function scrubLocalHarnessDirs(repoPath) {
   const results = [];
-  const resolved = path78.resolve(repoPath);
-  if (!fs70.existsSync(resolved)) {
+  const resolved = path79.resolve(repoPath);
+  if (!fs72.existsSync(resolved)) {
     for (const directory of HARNESS_SCRUB_DIRS) {
       results.push({
-        path: path78.join(resolved, ".har", directory),
+        path: path79.join(resolved, ".har", directory),
         directory,
         deleted: false,
         error: "repository path does not exist"
@@ -84667,24 +84729,24 @@ function scrubLocalHarnessDirs(repoPath) {
     return results;
   }
   for (const directory of HARNESS_SCRUB_DIRS) {
-    const target = path78.join(resolved, ".har", directory);
-    if (!fs70.existsSync(target)) {
+    const target = path79.join(resolved, ".har", directory);
+    if (!fs72.existsSync(target)) {
       results.push({ path: target, directory, deleted: true });
       continue;
     }
     try {
-      fs70.rmSync(target, { recursive: true, force: true });
+      fs72.rmSync(target, { recursive: true, force: true });
       results.push({
         path: target,
         directory,
-        deleted: !fs70.existsSync(target),
-        error: fs70.existsSync(target) ? "failed to remove directory" : void 0
+        deleted: !fs72.existsSync(target),
+        error: fs72.existsSync(target) ? "failed to remove directory" : void 0
       });
     } catch (err) {
       results.push({
         path: target,
         directory,
-        deleted: !fs70.existsSync(target),
+        deleted: !fs72.existsSync(target),
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -84695,7 +84757,7 @@ function scrubLocalHarnessForRepos(repoPaths) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repoPaths) {
-    const key = path78.resolve(repoPath);
+    const key = path79.resolve(repoPath);
     if (seen.has(key)) continue;
     seen.add(key);
     results.push(...scrubLocalHarnessDirs(key));
@@ -84988,7 +85050,7 @@ async function handleDown() {
   return finishCommand(code);
 }
 async function handleRegister(argv) {
-  const repoPath = path79.resolve(argv.repo);
+  const repoPath = path80.resolve(argv.repo);
   header("har control register");
   info(`Repository: ${repoPath}`);
   try {
@@ -85086,7 +85148,7 @@ async function handleReset(argv) {
   }
 }
 async function handleUnregister(argv) {
-  const repoPath = path79.resolve(argv.repo);
+  const repoPath = path80.resolve(argv.repo);
   const worktrees = listUnregisterWorktreeCandidates(repoPath);
   try {
     let deleteWorktrees = argv.deleteWorktrees;
@@ -85367,12 +85429,12 @@ async function handleTrajectory(argv) {
 }
 
 // src/cli/commands/hooks.ts
-var path81 = __toESM(require("path"));
+var path82 = __toESM(require("path"));
 init_hooks();
 
 // src/core/claude-hooks.ts
-var fs71 = __toESM(require("fs"));
-var path80 = __toESM(require("path"));
+var fs73 = __toESM(require("fs"));
+var path81 = __toESM(require("path"));
 init_paths();
 var CLAUDE_GUARD_RELATIVE_PATH = ".har/hooks/claude-worktree-guard.sh";
 var CLAUDE_SETTINGS_RELATIVE_PATH = ".claude/settings.json";
@@ -85384,8 +85446,8 @@ function isHarGuardEntry(entry) {
   );
 }
 function readSettings(settingsPath) {
-  if (!fs71.existsSync(settingsPath)) return {};
-  const raw = fs71.readFileSync(settingsPath, "utf8").trim();
+  if (!fs73.existsSync(settingsPath)) return {};
+  const raw = fs73.readFileSync(settingsPath, "utf8").trim();
   if (raw === "") return {};
   const parsed = JSON.parse(raw);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -85394,19 +85456,19 @@ function readSettings(settingsPath) {
   return parsed;
 }
 function writeSettings(settingsPath, settings) {
-  fs71.mkdirSync(path80.dirname(settingsPath), { recursive: true });
-  fs71.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs73.mkdirSync(path81.dirname(settingsPath), { recursive: true });
+  fs73.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 = path80.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  fs71.mkdirSync(path80.dirname(guardScript), { recursive: true });
-  fs71.copyFileSync(templatePath, guardScript);
-  fs71.chmodSync(guardScript, 493);
-  const settingsPath = path80.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  const guardScript = path81.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  fs73.mkdirSync(path81.dirname(guardScript), { recursive: true });
+  fs73.copyFileSync(templatePath, guardScript);
+  fs73.chmodSync(guardScript, 493);
+  const settingsPath = path81.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
   const settings = readSettings(settingsPath);
   const hooks = settings.hooks ?? {};
   const preToolUse = (hooks.PreToolUse ?? []).filter((entry) => !isHarGuardEntry(entry));
@@ -85420,15 +85482,15 @@ function installClaudeGuard(repoPath) {
 }
 function uninstallClaudeGuard(repoPath) {
   let removed = false;
-  const guardScript = path80.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  if (fs71.existsSync(guardScript)) {
-    fs71.rmSync(guardScript);
+  const guardScript = path81.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  if (fs73.existsSync(guardScript)) {
+    fs73.rmSync(guardScript);
     removed = true;
-    const parent = path80.dirname(guardScript);
-    if (fs71.existsSync(parent) && fs71.readdirSync(parent).length === 0) fs71.rmdirSync(parent);
+    const parent = path81.dirname(guardScript);
+    if (fs73.existsSync(parent) && fs73.readdirSync(parent).length === 0) fs73.rmdirSync(parent);
   }
-  const settingsPath = path80.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (fs71.existsSync(settingsPath)) {
+  const settingsPath = path81.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (fs73.existsSync(settingsPath)) {
     const settings = readSettings(settingsPath);
     const preToolUse = settings.hooks?.PreToolUse;
     if (preToolUse) {
@@ -85453,8 +85515,8 @@ function uninstallClaudeGuard(repoPath) {
   return { removed };
 }
 function claudeGuardInstalled(repoPath) {
-  const settingsPath = path80.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (!fs71.existsSync(settingsPath)) return false;
+  const settingsPath = path81.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (!fs73.existsSync(settingsPath)) return false;
   try {
     const settings = readSettings(settingsPath);
     return (settings.hooks?.PreToolUse ?? []).some(isHarGuardEntry);
@@ -85471,7 +85533,7 @@ function repoOption(y) {
 function handleInstall2(argv) {
   try {
     if (argv.claude) {
-      const result2 = installClaudeGuard(path81.resolve(argv.repo));
+      const result2 = installClaudeGuard(path82.resolve(argv.repo));
       success("Claude Code worktree guard installed.");
       info(`Guard script:  ${result2.guardScript}`);
       info(`Settings:      ${result2.settingsPath} (PreToolUse: Edit|Write|MultiEdit|NotebookEdit)`);
@@ -85479,7 +85541,7 @@ function handleInstall2(argv) {
       info("Commit both files so the guard travels with the repo.");
       return;
     }
-    const result = installHooks({ repoPath: path81.resolve(argv.repo), force: argv.force });
+    const result = installHooks({ repoPath: path82.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.");
@@ -85492,7 +85554,7 @@ function handleInstall2(argv) {
 function handleUninstall(argv) {
   try {
     if (argv.claude) {
-      const result2 = uninstallClaudeGuard(path81.resolve(argv.repo));
+      const result2 = uninstallClaudeGuard(path82.resolve(argv.repo));
       if (result2.removed) {
         success("Claude Code worktree guard removed.");
       } else {
@@ -85500,7 +85562,7 @@ function handleUninstall(argv) {
       }
       return;
     }
-    const result = uninstallHooks(path81.resolve(argv.repo));
+    const result = uninstallHooks(path82.resolve(argv.repo));
     if (result.removed) {
       success(`Commit gate removed from ${result.hooksDir}`);
     } else {
@@ -85513,7 +85575,7 @@ function handleUninstall(argv) {
 }
 function handleStatus2(argv) {
   try {
-    const status = getHooksStatus(path81.resolve(argv.repo));
+    const status = getHooksStatus(path82.resolve(argv.repo));
     if (argv.json) {
       process.stdout.write(`${JSON.stringify(status, null, 2)}
 `);
@@ -85531,7 +85593,7 @@ function handleStatus2(argv) {
     );
     info(`Effective:     ${status.effectiveMode} (in this checkout)`);
     info(
-      `Claude guard:  ${claudeGuardInstalled(path81.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
+      `Claude guard:  ${claudeGuardInstalled(path82.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
     );
   } catch (err) {
     error(err instanceof Error ? err.message : String(err));
@@ -85792,10 +85854,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path88) {
-  if (!path88)
+function getElementAtPath(obj, path89) {
+  if (!path89)
     return obj;
-  return path88.reduce((acc, key) => acc?.[key], obj);
+  return path89.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -86115,11 +86177,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path88, issues) {
+function prefixIssues(path89, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path88);
+    iss.path.unshift(path89);
     return iss;
   });
 }
@@ -92593,7 +92655,7 @@ var Server = class extends Protocol {
 };
 
 // src/mcp/server.ts
-var path82 = __toESM(require("path"));
+var path83 = __toESM(require("path"));
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var import_node_process3 = __toESM(require("node:process"), 1);
@@ -93214,7 +93276,8 @@ async function handleMcpToolCall(toolName, args, defaultRepo = ".") {
         warnings: result.warnings,
         nextSteps: result.nextSteps,
         docsPath: result.docsPath,
-        source: result.source
+        source: result.source,
+        adaptPromptPath: result.adaptPromptPath
       });
     }
     case "har_launch_environment": {
@@ -93416,7 +93479,7 @@ async function handleMcpToolCall(toolName, args, defaultRepo = ".") {
       const input = ControlUpInputSchema.parse({ ...args, repo });
       const result = await startControlAndSync({
         detach: input.detach,
-        cwd: path82.resolve(input.repo)
+        cwd: path83.resolve(input.repo)
       });
       if (result.code !== 0) {
         return {
@@ -93480,11 +93543,11 @@ var mcpCommand = {
 };
 
 // src/cli/commands/onboard.ts
-var path84 = __toESM(require("path"));
+var path85 = __toESM(require("path"));
 init_stages();
 
 // src/core/onboarding.ts
-var path83 = __toESM(require("path"));
+var path84 = __toESM(require("path"));
 init_control_config();
 init_control_sync();
 init_otel_hooks();
@@ -93628,7 +93691,7 @@ async function defaultEnsureControl(options) {
   return { started: true, apiUrl: result.apiUrl };
 }
 async function runOnboarding(options, deps = {}) {
-  const repoPath = path83.resolve(options.repoPath);
+  const repoPath = path84.resolve(options.repoPath);
   const applyTelemetry = deps.applyTelemetry ?? applyOnboardingTelemetry;
   const ensureControl = deps.ensureControl ?? defaultEnsureControl;
   const init = deps.initHarness ?? initHarness;
@@ -93826,7 +93889,7 @@ async function promptChoices(args, docker) {
     };
   }
   const pluginChoices = listPluginChoices();
-  const repoPath = path84.resolve(args.repo);
+  const repoPath = path85.resolve(args.repo);
   const alreadyPresent = harnessExists(repoPath);
   const needProfile = !alreadyPresent && !args.skipInit && args.profile === void 0;
   const needAgentSlots = shouldConfigureSlots && flaggedSlots === void 0;
@@ -93947,7 +94010,7 @@ function printSummary(result) {
   console.error("");
 }
 async function handleOnboard(argv) {
-  const repoPath = path84.resolve(argv.repo);
+  const repoPath = path85.resolve(argv.repo);
   header("har onboard");
   info(`Repository: ${repoPath}`);
   try {
@@ -94065,23 +94128,23 @@ var onboardCommand = {
 };
 
 // src/cli/commands/plugin.ts
-var path86 = __toESM(require("path"));
+var path87 = __toESM(require("path"));
 
 // src/harness/plugin-create.ts
-var fs72 = __toESM(require("fs"));
-var path85 = __toESM(require("path"));
+var fs74 = __toESM(require("fs"));
+var path86 = __toESM(require("path"));
 init_paths();
 init_schema2();
 var PLUGIN_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 function renderSkeleton(templatePath, tokens) {
-  let content = fs72.readFileSync(templatePath, "utf8");
+  let content = fs74.readFileSync(templatePath, "utf8");
   for (const [token, value] of Object.entries(tokens)) {
     content = content.replace(new RegExp(token, "g"), value);
   }
   return content;
 }
 function createLocalPlugin(repoPath, options) {
-  const resolved = path85.resolve(repoPath);
+  const resolved = path86.resolve(repoPath);
   if (!harnessExists(resolved)) {
     throw new Error('No .har/ harness found. Run "har env init" first.');
   }
@@ -94097,9 +94160,9 @@ function createLocalPlugin(repoPath, options) {
       `Invalid stage kind "${kind}". Available: ${HarnessStageKindSchema.options.join(", ")}`
     );
   }
-  const pluginDir = path85.join(resolved, LOCAL_PLUGINS_DIR, id);
+  const pluginDir = path86.join(resolved, LOCAL_PLUGINS_DIR, id);
   const pluginDirRel = `${LOCAL_PLUGINS_DIR}/${id}`;
-  if (fs72.existsSync(pluginDir) && !options.force) {
+  if (fs74.existsSync(pluginDir) && !options.force) {
     throw new Error(`Plugin already exists: ${pluginDirRel}/. Use --force to overwrite.`);
   }
   const description = options.description ?? `Custom ${kind} stage (local plugin: ${id})`;
@@ -94141,16 +94204,16 @@ function createLocalPlugin(repoPath, options) {
   });
   const filesWritten = [];
   const write = (rel, content, executable = false) => {
-    const abs = path85.join(pluginDir, rel);
-    fs72.mkdirSync(path85.dirname(abs), { recursive: true });
-    fs72.writeFileSync(abs, content);
-    if (executable) fs72.chmodSync(abs, 493);
+    const abs = path86.join(pluginDir, rel);
+    fs74.mkdirSync(path86.dirname(abs), { recursive: true });
+    fs74.writeFileSync(abs, content);
+    if (executable) fs74.chmodSync(abs, 493);
     filesWritten.push(`${pluginDirRel}/${rel}`);
   };
   write("template.manifest.json", `${JSON.stringify(manifest, null, 2)}
 `);
   const stageScript = renderSkeleton(
-    path85.join(resolveTemplatesDir(), "plugins", "custom-stage-skeleton.sh"),
+    path86.join(resolveTemplatesDir(), "plugins", "custom-stage-skeleton.sh"),
     {
       __STAGE_ID__: id,
       __STAGE_KIND__: kind,
@@ -94159,7 +94222,7 @@ function createLocalPlugin(repoPath, options) {
   );
   write(`stages/${id}.sh`, stageScript, true);
   const readme = renderSkeleton(
-    path85.join(resolveTemplatesDir(), "plugins", "local-plugin-skeleton", "README.md"),
+    path86.join(resolveTemplatesDir(), "plugins", "local-plugin-skeleton", "README.md"),
     { __PLUGIN_ID__: id }
   );
   write("README.md", readme);
@@ -94177,6 +94240,7 @@ function createLocalPlugin(repoPath, options) {
     nextSteps: [
       `Edit ${pluginDirRel}/stages/${id}.sh \u2014 replace the TODO block with the real check`,
       `Install it: har env add-plugin ${id}   (re-run with --force after changes)`,
+      `Installing writes .har/ADAPT-PROMPT-${id}.md \u2014 a ready adaptation prompt for your coding agent`,
       `Document what it checks in ${pluginDirRel}/README.md`,
       "Publishing later (npm/git) needs zero format changes \u2014 see the README"
     ]
@@ -94190,7 +94254,7 @@ async function handlePluginCreate(argv) {
     error('Missing plugin id. Usage: har plugin create <id> [--kind test] [--description "..."]');
     return finishCommand(1);
   }
-  const repoPath = path86.resolve(argv.repo);
+  const repoPath = path87.resolve(argv.repo);
   header("har plugin create");
   info(`Repository: ${repoPath}`);
   info(`Plugin: ${argv.id}`);
@@ -94221,7 +94285,7 @@ async function handlePluginCreate(argv) {
   }
 }
 function handlePluginList(argv) {
-  const repoPath = path86.resolve(argv.repo);
+  const repoPath = path87.resolve(argv.repo);
   for (const id of listPluginIds()) {
     console.log(`${id}	(bundled)`);
   }
@@ -94388,7 +94452,7 @@ var preferencesCommand = {
 };
 
 // src/cli/commands/telemetry.ts
-var path87 = __toESM(require("path"));
+var path88 = __toESM(require("path"));
 init_control_config();
 init_control_sync();
 init_manifest();
@@ -94481,7 +94545,7 @@ async function handleOff() {
   info("Mission Control will not auto-start. Existing usage rows are kept.");
 }
 async function handleWriteEnv(argv) {
-  const repoPath = path87.resolve(argv.repo);
+  const repoPath = path88.resolve(argv.repo);
   const harnessRoot = resolveHarnessRoot(repoPath);
   const session = readSlotRegistry(harnessRoot, argv.agentId);
   const workDir = argv.workDir ?? session?.workDir ?? repoPath;
@@ -94493,7 +94557,7 @@ async function handleWriteEnv(argv) {
     suffix,
     createdAt: session?.createdAt
   });
-  const envFile = argv.envFile ?? path87.join(workDir, `.env.agent.${argv.agentId}`);
+  const envFile = argv.envFile ?? path88.join(workDir, `.env.agent.${argv.agentId}`);
   const attrs = {
     sessionKey,
     agentId: argv.agentId,
@@ -94509,7 +94573,7 @@ async function handleWriteEnv(argv) {
   success(`Wrote session attribution to ${envFile}`);
 }
 function handlePrintEnv(argv) {
-  const repoPath = path87.resolve(argv.repo);
+  const repoPath = path88.resolve(argv.repo);
   const workDir = argv.workDir ?? repoPath;
   const sessionKey = buildSessionKey({
     branch: argv.branch,