@osfactory/har 0.13.1 → 0.14.2

package/dist/index.js

@@ -765,14 +765,14 @@ var require_url_state_machine = __commonJS({
       return url.replace(/\u0009|\u000A|\u000D/g, "");
     }
     function shortenPath(url) {
-      const path47 = url.path;
-      if (path47.length === 0) {
+      const path48 = url.path;
+      if (path48.length === 0) {
         return;
       }
-      if (url.scheme === "file" && path47.length === 1 && isNormalizedWindowsDriveLetter(path47[0])) {
+      if (url.scheme === "file" && path48.length === 1 && isNormalizedWindowsDriveLetter(path48[0])) {
         return;
       }
-      path47.pop();
+      path48.pop();
     }
     function includesCredentials(url) {
       return url.username !== "" || url.password !== "";
@@ -6351,14 +6351,14 @@ __export(fileFromPath_exports, {
   fileFromPathSync: () => fileFromPathSync,
   isFile: () => isFile
 });
-function createFileFromPath(path47, { mtimeMs, size }, filenameOrOptions, options = {}) {
+function createFileFromPath(path48, { mtimeMs, size }, filenameOrOptions, options = {}) {
   let filename;
   if (isPlainObject_default2(filenameOrOptions)) {
     [options, filename] = [filenameOrOptions, void 0];
   } else {
     filename = filenameOrOptions;
   }
-  const file = new FileFromPath({ path: path47, size, lastModified: mtimeMs });
+  const file = new FileFromPath({ path: path48, size, lastModified: mtimeMs });
   if (!filename) {
     filename = file.name;
   }
@@ -6367,13 +6367,13 @@ function createFileFromPath(path47, { mtimeMs, size }, filenameOrOptions, option
     lastModified: file.lastModified
   });
 }
-function fileFromPathSync(path47, filenameOrOptions, options = {}) {
-  const stats = (0, import_fs5.statSync)(path47);
-  return createFileFromPath(path47, stats, filenameOrOptions, options);
+function fileFromPathSync(path48, filenameOrOptions, options = {}) {
+  const stats = (0, import_fs5.statSync)(path48);
+  return createFileFromPath(path48, stats, filenameOrOptions, options);
 }
-async function fileFromPath2(path47, filenameOrOptions, options) {
-  const stats = await import_fs5.promises.stat(path47);
-  return createFileFromPath(path47, stats, filenameOrOptions, options);
+async function fileFromPath2(path48, filenameOrOptions, options) {
+  const stats = await import_fs5.promises.stat(path48);
+  return createFileFromPath(path48, stats, filenameOrOptions, options);
 }
 var import_fs5, import_path5, import_node_domexception, __classPrivateFieldSet5, __classPrivateFieldGet6, _FileFromPath_path, _FileFromPath_start, MESSAGE, FileFromPath;
 var init_fileFromPath = __esm({
@@ -9629,8 +9629,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path47) {
-      let input = path47;
+    function removeDotSegments(path48) {
+      let input = path48;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -9882,8 +9882,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path47, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path47 && path47 !== "/" ? path47 : void 0;
+        const [path48, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path48 && path48 !== "/" ? path48 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -13276,12 +13276,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f2;
     };
-    function addFormats(ajv, list, fs40, exportName) {
+    function addFormats(ajv, list, fs41, exportName) {
       var _a3;
       var _b2;
       (_a3 = (_b2 = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b2.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f2 of list)
-        ajv.addFormat(f2, fs40[f2]);
+        ajv.addFormat(f2, fs41[f2]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -14565,11 +14565,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: (path47) => {
+  require: (path48) => {
     if (typeof require !== "undefined") {
-      return require(path47);
-    } else if (path47.match(/\.json$/)) {
-      return JSON.parse((0, import_fs2.readFileSync)(path47, "utf8"));
+      return require(path48);
+    } else if (path48.match(/\.json$/)) {
+      return JSON.parse((0, import_fs2.readFileSync)(path48, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -19250,8 +19250,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path47, errorMaps, issueData } = params;
-  const fullPath = [...path47, ...issueData.path || []];
+  const { data, path: path48, errorMaps, issueData } = params;
+  const fullPath = [...path48, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -19367,11 +19367,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path47, key) {
+  constructor(parent, value, path48, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path47;
+    this._path = path48;
     this._key = key;
   }
   get path() {
@@ -23129,6 +23129,22 @@ var AgentSessionUsageSchema = external_exports.object({
 var SyncUsageInputSchema = external_exports.object({
   usage: external_exports.array(AgentSessionUsageSchema)
 });
+var AgentSessionEventSchema = external_exports.object({
+  sessionKey: external_exports.string().min(1),
+  agentId: external_exports.number().int().min(HAR_AGENT_SLOT_MIN),
+  agentTool: AgentToolSchema,
+  eventName: external_exports.string().min(1),
+  sequence: external_exports.number().int().nonnegative().default(0),
+  timestamp: external_exports.string(),
+  attributes: external_exports.record(external_exports.unknown()).optional(),
+  promptText: external_exports.string().nullable().optional(),
+  responseText: external_exports.string().nullable().optional(),
+  rawTruncated: external_exports.string().nullable().optional(),
+  source: external_exports.enum(["otel", "harvest"]).default("otel")
+});
+var SyncSessionEventsInputSchema = external_exports.object({
+  events: external_exports.array(AgentSessionEventSchema)
+});
 
 // src/harness/manifest.ts
 var GENERATOR_VERSION = "0.4.0";
@@ -23482,15 +23498,15 @@ function handleRemove(argv) {
 }
 
 // src/cli/commands/env.ts
-var path40 = __toESM(require("path"));
+var path41 = __toESM(require("path"));
 
 // src/core/harness.ts
-var fs19 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 
 // src/harness/generator.ts
-var fs7 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 
 // src/core/gitignore.ts
 var fs6 = __toESM(require("fs"));
@@ -23513,6 +23529,277 @@ function ensureRootGitignorePatterns(checkoutDir) {
   fs6.writeFileSync(gitignorePath, `${content}${suffix}${block}`);
 }
 
+// src/harness/gitignore-template.ts
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var HARNESS_GITIGNORE_TEMPLATE = "gitignore.template";
+var HARNESS_GITIGNORE_FILE = ".gitignore";
+function harnessFileForTemplate(templateFile) {
+  return templateFile === HARNESS_GITIGNORE_TEMPLATE ? HARNESS_GITIGNORE_FILE : templateFile;
+}
+function templateFileForHarness(harnessFile) {
+  return harnessFile === HARNESS_GITIGNORE_FILE ? HARNESS_GITIGNORE_TEMPLATE : harnessFile;
+}
+function resolveGitignoreTemplateSource(boilerplateDir) {
+  const primary = path8.join(boilerplateDir, HARNESS_GITIGNORE_TEMPLATE);
+  if (fs7.existsSync(primary)) return primary;
+  const legacy = path8.join(boilerplateDir, HARNESS_GITIGNORE_FILE);
+  if (fs7.existsSync(legacy)) return legacy;
+  return null;
+}
+function writeHarnessGitignore(harnessDir, boilerplateDir) {
+  const src = resolveGitignoreTemplateSource(boilerplateDir);
+  if (!src) return;
+  fs7.writeFileSync(path8.join(harnessDir, HARNESS_GITIGNORE_FILE), fs7.readFileSync(src, "utf8"));
+}
+function isExpectedHarnessOnlyFile(harnessFile, templateFiles) {
+  return harnessFile === HARNESS_GITIGNORE_FILE && templateFiles.includes(HARNESS_GITIGNORE_TEMPLATE);
+}
+
+// src/harness/stages.ts
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+
+// src/harness/env.ts
+var fs8 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+function readHarnessEnv(repoPath) {
+  const envPath = path9.join(getHarnessDir(repoPath), "harness.env");
+  if (!fs8.existsSync(envPath)) return {};
+  const values = {};
+  for (const line of fs8.readFileSync(envPath, "utf8").split("\n")) {
+    const match = line.match(/^export\s+([A-Z0-9_]+)=(.*)$/);
+    if (!match) continue;
+    values[match[1]] = match[2].replace(/^"|"$/g, "");
+  }
+  return values;
+}
+function parseHarnessEnvInt(env3, key) {
+  const raw = env3[key];
+  if (raw === void 0 || raw === "") return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value)) return void 0;
+  return value;
+}
+
+// src/harness/stages.ts
+var STAGE_REGISTRY_FILE = "stages.json";
+var AGENT_REQUIRED_KINDS = /* @__PURE__ */ new Set([
+  "launch",
+  "verify",
+  "test",
+  "inspect",
+  "reset",
+  "teardown",
+  "custom"
+]);
+function getStageRegistryPath(repoPath) {
+  return path10.join(getHarnessDir(repoPath), STAGE_REGISTRY_FILE);
+}
+function synthesizeStageRegistry(repoPath) {
+  const harnessDir = getHarnessDir(repoPath);
+  const stages = [];
+  addStageIfRunnable(stages, harnessDir, {
+    id: "setup-infra",
+    kind: "setup",
+    description: "Start shared harness infrastructure.",
+    command: "./.har/setup-infra.sh",
+    requiresAgentId: false
+  });
+  addStageIfRunnable(stages, harnessDir, {
+    id: "launch",
+    kind: "launch",
+    description: "Launch an isolated agent environment slot.",
+    command: "./.har/launch.sh {agentId}",
+    requiresAgentId: true
+  });
+  addStageIfRunnable(stages, harnessDir, {
+    id: "verify",
+    kind: "verify",
+    description: "Run the project verification pipeline.",
+    command: "./.har/verify.sh {agentId}",
+    requiresAgentId: true,
+    acceptsArgs: ["--full"]
+  });
+  addStageIfRunnable(stages, harnessDir, {
+    id: "status",
+    kind: "inspect",
+    description: "Inspect a running agent environment slot.",
+    command: "./.har/agent-cli.sh {agentId} status",
+    requiresAgentId: true
+  });
+  addStageIfRunnable(stages, harnessDir, {
+    id: "logs",
+    kind: "inspect",
+    description: "Read recent logs for an agent slot.",
+    command: "./.har/agent-cli.sh {agentId} logs",
+    requiresAgentId: true
+  });
+  addStageIfRunnable(stages, harnessDir, {
+    id: "teardown",
+    kind: "teardown",
+    description: "Tear down an isolated agent environment slot.",
+    command: "./.har/teardown.sh {agentId}",
+    requiresAgentId: true
+  });
+  const harnessEnv = readHarnessEnv(repoPath);
+  const agentSlots = readAgentSlotsFromHarnessEnv(harnessEnv);
+  if (!agentSlots) {
+    throw new Error(
+      "Configure agent slot limits in .har/stages.json (agentSlots) or .har/harness.env (HARNESS_AGENT_SLOT_MIN/MAX)"
+    );
+  }
+  return {
+    version: "1",
+    artifactsDir: "artifacts",
+    logsDir: "logs",
+    agentSlots,
+    verificationStages: ["typecheck", "unit-tests", "api-health"],
+    stages
+  };
+}
+function readAgentSlotsFromHarnessEnv(harnessEnv) {
+  const max = parseHarnessEnvInt(harnessEnv, "HARNESS_AGENT_SLOT_MAX");
+  if (max === void 0) return null;
+  const min = parseHarnessEnvInt(harnessEnv, "HARNESS_AGENT_SLOT_MIN") ?? HAR_AGENT_SLOT_MIN;
+  if (max < min) {
+    throw new Error("HARNESS_AGENT_SLOT_MAX must be >= HARNESS_AGENT_SLOT_MIN in harness.env");
+  }
+  return { min, max };
+}
+function stageScriptExists(harnessDir, stage) {
+  if (stage.script) {
+    return fs9.existsSync(path10.join(harnessDir, stage.script));
+  }
+  if (stage.command) {
+    const scriptName = stage.command.split(/\s+/)[0].replace(/^\.\/\.har\//, "").replace(/^\.\//, "");
+    return fs9.existsSync(path10.join(harnessDir, scriptName));
+  }
+  return fs9.existsSync(path10.join(harnessDir, "stages", `${stage.id}.sh`));
+}
+function addStageIfRunnable(stages, harnessDir, stage) {
+  const parsed = HarnessStageSchema.parse(stage);
+  if (stageScriptExists(harnessDir, parsed)) {
+    stages.push(parsed);
+  }
+}
+function readStageRegistry(repoPath) {
+  const registryPath = getStageRegistryPath(repoPath);
+  if (!fs9.existsSync(registryPath)) {
+    return synthesizeStageRegistry(repoPath);
+  }
+  const raw = JSON.parse(fs9.readFileSync(registryPath, "utf8"));
+  const parsed = HarnessStageRegistrySchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`Invalid .har/${STAGE_REGISTRY_FILE}: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+function writeStageRegistry(repoPath, registry2) {
+  const registryPath = getStageRegistryPath(repoPath);
+  const parsed = HarnessStageRegistrySchema.safeParse(registry2);
+  if (!parsed.success) {
+    throw new Error(`Invalid stage registry: ${parsed.error.message}`);
+  }
+  fs9.writeFileSync(registryPath, JSON.stringify(parsed.data, null, 2) + "\n");
+}
+function listStages(repoPath) {
+  return readStageRegistry(repoPath).stages;
+}
+function getAgentSlotRange(repoPath) {
+  const registry2 = readStageRegistry(repoPath);
+  if (registry2.agentSlots) {
+    return registry2.agentSlots;
+  }
+  const fromEnv = readAgentSlotsFromHarnessEnv(readHarnessEnv(repoPath));
+  if (fromEnv) {
+    return fromEnv;
+  }
+  throw new Error(
+    "Configure agent slot limits in .har/stages.json (agentSlots) or .har/harness.env (HARNESS_AGENT_SLOT_MIN/MAX)"
+  );
+}
+function getAgentSlotIds(repoPath) {
+  const { min, max } = getAgentSlotRange(repoPath);
+  const ids = [];
+  for (let id = min; id <= max; id++) ids.push(id);
+  return ids;
+}
+function detectAgentSlotEnvMismatch(repoPath) {
+  const registryPath = getStageRegistryPath(repoPath);
+  if (!fs9.existsSync(registryPath)) return null;
+  let stagesSlots = null;
+  try {
+    const raw = JSON.parse(fs9.readFileSync(registryPath, "utf8"));
+    if (raw.agentSlots && Number.isInteger(raw.agentSlots.min) && Number.isInteger(raw.agentSlots.max)) {
+      stagesSlots = { min: raw.agentSlots.min, max: raw.agentSlots.max };
+    }
+  } catch {
+    return null;
+  }
+  if (!stagesSlots) return null;
+  const env3 = readHarnessEnv(repoPath);
+  const envMax = parseHarnessEnvInt(env3, "HARNESS_AGENT_SLOT_MAX");
+  if (envMax === void 0) return null;
+  const envMin = parseHarnessEnvInt(env3, "HARNESS_AGENT_SLOT_MIN") ?? HAR_AGENT_SLOT_MIN;
+  if (envMin === stagesSlots.min && envMax === stagesSlots.max) return null;
+  return { stages: stagesSlots, env: { min: envMin, max: envMax } };
+}
+function syncAgentSlotsToHarnessEnv(repoPath) {
+  const mismatch = detectAgentSlotEnvMismatch(repoPath);
+  if (!mismatch) return false;
+  const envPath = path10.join(getHarnessDir(repoPath), "harness.env");
+  if (!fs9.existsSync(envPath)) return false;
+  let content = fs9.readFileSync(envPath, "utf8");
+  const minLine = `export HARNESS_AGENT_SLOT_MIN=${mismatch.stages.min}`;
+  const maxLine = `export HARNESS_AGENT_SLOT_MAX=${mismatch.stages.max}`;
+  if (/^export HARNESS_AGENT_SLOT_MIN=/m.test(content)) {
+    content = content.replace(/^export HARNESS_AGENT_SLOT_MIN=.*$/m, minLine);
+  } else {
+    content = `${content.replace(/\s*$/, "")}
+${minLine}
+`;
+  }
+  if (/^export HARNESS_AGENT_SLOT_MAX=/m.test(content)) {
+    content = content.replace(/^export HARNESS_AGENT_SLOT_MAX=.*$/m, maxLine);
+  } else {
+    content = `${content.replace(/\s*$/, "")}
+${maxLine}
+`;
+  }
+  fs9.writeFileSync(envPath, content);
+  return true;
+}
+function stageRequiresAgentId(stage) {
+  if (typeof stage.requiresAgentId === "boolean") return stage.requiresAgentId;
+  return AGENT_REQUIRED_KINDS.has(stage.kind);
+}
+function resolveStage(repoPath, options) {
+  if (!options.id && !options.kind) return null;
+  const stages = listStages(repoPath);
+  if (options.id) {
+    return stages.find((stage) => stage.id === options.id) ?? null;
+  }
+  const matches = stages.filter((stage) => stage.kind === options.kind);
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    throw new Error(
+      `Multiple stages with kind "${options.kind}". Specify stage id. Available: ${matches.map((s2) => s2.id).join(", ")}`
+    );
+  }
+  return null;
+}
+function getVerificationStageIds(repoPath) {
+  const registry2 = readStageRegistry(repoPath);
+  if (Array.isArray(registry2.verificationStages) && registry2.verificationStages.length > 0) {
+    return registry2.verificationStages;
+  }
+  return registry2.stages.filter((stage) => stage.group === "verification").map((stage) => stage.id);
+}
+function getArtifactsDir(repoPath) {
+  return readStageRegistry(repoPath).artifactsDir ?? "artifacts";
+}
+
 // src/harness/generator.ts
 var PROFILE_DIRS = {
   default: "har-boilerplate",
@@ -23526,46 +23813,48 @@ var CLI_PRUNE_FILES = [
 ];
 function pruneCliProfile(harnessDir) {
   for (const file of CLI_PRUNE_FILES) {
-    const filePath = path8.join(harnessDir, file);
-    if (fs7.existsSync(filePath)) {
-      fs7.unlinkSync(filePath);
+    const filePath = path11.join(harnessDir, file);
+    if (fs10.existsSync(filePath)) {
+      fs10.unlinkSync(filePath);
     }
   }
 }
 function scaffoldClaudeMd(repoPath, projectName, force) {
   const templatePath = resolveTemplateFile("CLAUDE.md.template");
   if (!templatePath) return;
-  const dest = path8.join(repoPath, "CLAUDE.md");
-  if (fs7.existsSync(dest) && !force) return;
+  const dest = path11.join(repoPath, "CLAUDE.md");
+  if (fs10.existsSync(dest) && !force) return;
   const displayName = projectName.replace(/_/g, " ");
-  const content = fs7.readFileSync(templatePath, "utf8").replace(/__PROJECT_DISPLAY_NAME__/g, displayName);
-  fs7.writeFileSync(dest, content);
+  const content = fs10.readFileSync(templatePath, "utf8").replace(/__PROJECT_DISPLAY_NAME__/g, displayName);
+  fs10.writeFileSync(dest, content);
 }
 function scaffoldHarnessBoilerplate(repoPath, options = {}) {
-  const harnessDir = path8.join(repoPath, DEFAULT_HAR_DIR);
-  const projectName = path8.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const harnessDir = path11.join(repoPath, DEFAULT_HAR_DIR);
+  const projectName = path11.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
   const profile = options.profile ?? "default";
-  const boilerplateDir = path8.join(resolveTemplatesDir(), PROFILE_DIRS[profile]);
-  if (fs7.existsSync(harnessDir) && !options.force) {
+  const boilerplateDir = path11.join(resolveTemplatesDir(), PROFILE_DIRS[profile]);
+  if (fs10.existsSync(harnessDir) && !options.force) {
     throw new Error(
       '.har/ already exists. Use --force to overwrite or run "har env maintain" to update in place.'
     );
   }
-  if (!fs7.existsSync(boilerplateDir)) {
+  if (!fs10.existsSync(boilerplateDir)) {
     throw new Error(`Boilerplate template not found at ${boilerplateDir}`);
   }
-  if (options.force && fs7.existsSync(harnessDir)) {
-    fs7.rmSync(harnessDir, { recursive: true, force: true });
+  if (options.force && fs10.existsSync(harnessDir)) {
+    fs10.rmSync(harnessDir, { recursive: true, force: true });
   }
   copyDirRecursive(boilerplateDir, harnessDir);
+  writeHarnessGitignore(harnessDir, boilerplateDir);
   if (profile === "cli") {
     pruneCliProfile(harnessDir);
   }
-  const harnessEnvPath = path8.join(harnessDir, "harness.env");
-  if (fs7.existsSync(harnessEnvPath)) {
-    let content = fs7.readFileSync(harnessEnvPath, "utf8");
+  syncAgentSlotsToHarnessEnv(repoPath);
+  const harnessEnvPath = path11.join(harnessDir, "harness.env");
+  if (fs10.existsSync(harnessEnvPath)) {
+    let content = fs10.readFileSync(harnessEnvPath, "utf8");
     content = content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
-    fs7.writeFileSync(harnessEnvPath, content);
+    fs10.writeFileSync(harnessEnvPath, content);
   }
   const manifest = createManifest(
     repoPath,
@@ -23588,8 +23877,8 @@ function finalizeHarness(repoPath, adaptationSummary, stack) {
 }
 
 // src/llm/authoring-agent.ts
-var fs11 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 
 // node_modules/@anthropic-ai/sdk/error.mjs
 var error_exports = {};
@@ -23988,13 +24277,13 @@ var MultipartBody = class {
 // node_modules/@anthropic-ai/sdk/_shims/node-runtime.mjs
 var import_web = require("node:stream/web");
 var fileFromPathWarned = false;
-async function fileFromPath3(path47, ...args) {
+async function fileFromPath3(path48, ...args) {
   const { fileFromPath: _fileFromPath } = await Promise.resolve().then(() => (init_fileFromPath(), fileFromPath_exports));
   if (!fileFromPathWarned) {
-    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path47)}) instead`);
+    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path48)}) instead`);
     fileFromPathWarned = true;
   }
-  return await _fileFromPath(path47, ...args);
+  return await _fileFromPath(path48, ...args);
 }
 var defaultHttpAgent = new import_agentkeepalive.default({ keepAlive: true, timeout: 5 * 60 * 1e3 });
 var defaultHttpsAgent = new import_agentkeepalive.default.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1e3 });
@@ -24591,29 +24880,29 @@ var APIClient = class {
   defaultIdempotencyKey() {
     return `stainless-node-retry-${uuid4()}`;
   }
-  get(path47, opts) {
-    return this.methodRequest("get", path47, opts);
+  get(path48, opts) {
+    return this.methodRequest("get", path48, opts);
   }
-  post(path47, opts) {
-    return this.methodRequest("post", path47, opts);
+  post(path48, opts) {
+    return this.methodRequest("post", path48, opts);
   }
-  patch(path47, opts) {
-    return this.methodRequest("patch", path47, opts);
+  patch(path48, opts) {
+    return this.methodRequest("patch", path48, opts);
   }
-  put(path47, opts) {
-    return this.methodRequest("put", path47, opts);
+  put(path48, opts) {
+    return this.methodRequest("put", path48, opts);
   }
-  delete(path47, opts) {
-    return this.methodRequest("delete", path47, opts);
+  delete(path48, opts) {
+    return this.methodRequest("delete", path48, opts);
   }
-  methodRequest(method, path47, opts) {
+  methodRequest(method, path48, opts) {
     return this.request(Promise.resolve(opts).then(async (opts2) => {
       const body = opts2 && isBlobLike(opts2?.body) ? new DataView(await opts2.body.arrayBuffer()) : opts2?.body instanceof DataView ? opts2.body : opts2?.body instanceof ArrayBuffer ? new DataView(opts2.body) : opts2 && ArrayBuffer.isView(opts2?.body) ? new DataView(opts2.body.buffer) : opts2?.body;
-      return { method, path: path47, ...opts2, body };
+      return { method, path: path48, ...opts2, body };
     }));
   }
-  getAPIList(path47, Page, opts) {
-    return this.requestAPIList(Page, { method: "get", path: path47, ...opts });
+  getAPIList(path48, Page, opts) {
+    return this.requestAPIList(Page, { method: "get", path: path48, ...opts });
   }
   calculateContentLength(body) {
     if (typeof body === "string") {
@@ -24631,10 +24920,10 @@ var APIClient = class {
     return null;
   }
   buildRequest(options) {
-    const { method, path: path47, query, headers = {} } = options;
+    const { method, path: path48, query, headers = {} } = options;
     const body = ArrayBuffer.isView(options.body) || options.__binaryRequest && typeof options.body === "string" ? options.body : isMultipartBody(options.body) ? options.body.body : options.body ? JSON.stringify(options.body, null, 2) : null;
     const contentLength = this.calculateContentLength(body);
-    const url = this.buildURL(path47, query);
+    const url = this.buildURL(path48, query);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     const timeout = options.timeout ?? this.timeout;
@@ -24743,8 +25032,8 @@ var APIClient = class {
     const request = this.makeRequest(options, null);
     return new PagePromise(this, request, Page);
   }
-  buildURL(path47, query) {
-    const url = isAbsoluteURL(path47) ? new URL(path47) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path47.startsWith("/") ? path47.slice(1) : path47));
+  buildURL(path48, query) {
+    const url = isAbsoluteURL(path48) ? new URL(path48) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path48.startsWith("/") ? path48.slice(1) : path48));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -26567,34 +26856,34 @@ var { AnthropicError: AnthropicError2, APIError: APIError2, APIConnectionError:
 var sdk_default = Anthropic;
 
 // src/llm/tools.ts
-var fs10 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var readline3 = __toESM(require("readline"));
 
 // src/harness/agent-md.ts
-var fs9 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var readline2 = __toESM(require("readline"));
 var AGENT_MD_PROPOSAL = "AGENT.md.proposed";
 var AGENT_MD_PROPOSAL_META = "AGENT.md.proposed.meta.json";
 function writeAgentMdProposal(repoPath, content, rationale) {
   const harnessDir = getHarnessDir(repoPath);
-  writeFileSafe(path9.join(harnessDir, AGENT_MD_PROPOSAL), content);
+  writeFileSafe(path12.join(harnessDir, AGENT_MD_PROPOSAL), content);
   writeFileSafe(
-    path9.join(harnessDir, AGENT_MD_PROPOSAL_META),
+    path12.join(harnessDir, AGENT_MD_PROPOSAL_META),
     JSON.stringify({ rationale, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
   );
 }
 function readAgentMdProposal(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
-  const proposalPath = path9.join(harnessDir, AGENT_MD_PROPOSAL);
-  const metaPath = path9.join(harnessDir, AGENT_MD_PROPOSAL_META);
-  if (!fs9.existsSync(proposalPath)) return null;
-  const content = fs9.readFileSync(proposalPath, "utf8");
+  const proposalPath = path12.join(harnessDir, AGENT_MD_PROPOSAL);
+  const metaPath = path12.join(harnessDir, AGENT_MD_PROPOSAL_META);
+  if (!fs12.existsSync(proposalPath)) return null;
+  const content = fs12.readFileSync(proposalPath, "utf8");
   let rationale = "";
-  if (fs9.existsSync(metaPath)) {
+  if (fs12.existsSync(metaPath)) {
     try {
-      rationale = JSON.parse(fs9.readFileSync(metaPath, "utf8")).rationale ?? "";
+      rationale = JSON.parse(fs12.readFileSync(metaPath, "utf8")).rationale ?? "";
     } catch {
       rationale = "";
     }
@@ -26602,21 +26891,21 @@ function readAgentMdProposal(repoPath) {
   return {
     content,
     rationale,
-    createdAt: fs9.existsSync(metaPath) ? JSON.parse(fs9.readFileSync(metaPath, "utf8")).createdAt : (/* @__PURE__ */ new Date()).toISOString()
+    createdAt: fs12.existsSync(metaPath) ? JSON.parse(fs12.readFileSync(metaPath, "utf8")).createdAt : (/* @__PURE__ */ new Date()).toISOString()
   };
 }
 function clearAgentMdProposal(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   for (const file of [AGENT_MD_PROPOSAL, AGENT_MD_PROPOSAL_META]) {
-    const p2 = path9.join(harnessDir, file);
-    if (fs9.existsSync(p2)) fs9.unlinkSync(p2);
+    const p2 = path12.join(harnessDir, file);
+    if (fs12.existsSync(p2)) fs12.unlinkSync(p2);
   }
 }
 async function promptApplyAgentMdProposal(repoPath) {
   const proposal = readAgentMdProposal(repoPath);
   if (!proposal) return false;
-  const agentMdPath = path9.join(repoPath, "AGENT.md");
-  const exists = fs9.existsSync(agentMdPath);
+  const agentMdPath = path12.join(repoPath, "AGENT.md");
+  const exists = fs12.existsSync(agentMdPath);
   process.stderr.write("\n");
   process.stderr.write("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
   process.stderr.write("Proposed AGENT.md (repo root)\n");
@@ -26804,13 +27093,13 @@ async function handleAuthoringToolCall(toolName, input, repoPath, harnessDir, ca
 async function executeAuthoringToolCall(toolName, input, repoPath, harnessDir, callbacks) {
   switch (toolName) {
     case "readRepoFile": {
-      const filePath = path10.join(repoPath, input.path);
+      const filePath = path13.join(repoPath, input.path);
       const content = readFile(filePath, input.maxChars ?? 8e3);
       info(`Read repo: ${input.path}`);
       return content;
     }
     case "listRepoDir": {
-      const dirPath = path10.join(repoPath, input.path ?? ".");
+      const dirPath = path13.join(repoPath, input.path ?? ".");
       const entries = listDir(dirPath, input.maxFiles ?? 60);
       info(`List repo: ${input.path} \u2192 ${entries.length} entries`);
       return entries.length > 0 ? entries.join("\n") : "(empty directory)";
@@ -26835,17 +27124,17 @@ async function executeAuthoringToolCall(toolName, input, repoPath, harnessDir, c
       const filePath = resolveSafePath(harnessDir, relPath);
       writeFileSafe(filePath, input.content);
       if (relPath.endsWith(".sh")) {
-        fs10.chmodSync(filePath, 493);
+        fs13.chmodSync(filePath, 493);
       }
       info(`Wrote harness: ${relPath}`);
       return `Written ${relPath} (${input.content.length} bytes)`;
     }
     case "editHarnessFile": {
       const filePath = resolveSafePath(harnessDir, input.path);
-      if (!fs10.existsSync(filePath)) {
+      if (!fs13.existsSync(filePath)) {
         return `Error: file not found: ${input.path}`;
       }
-      const content = fs10.readFileSync(filePath, "utf8");
+      const content = fs13.readFileSync(filePath, "utf8");
       const oldStr = input.old_string;
       const newStr = input.new_string;
       const count = content.split(oldStr).length - 1;
@@ -26862,10 +27151,10 @@ async function executeAuthoringToolCall(toolName, input, repoPath, harnessDir, c
     }
     case "deleteHarnessFile": {
       const filePath = resolveSafePath(harnessDir, input.path);
-      if (!fs10.existsSync(filePath)) {
+      if (!fs13.existsSync(filePath)) {
         return `File not found (already deleted): ${input.path}`;
       }
-      fs10.unlinkSync(filePath);
+      fs13.unlinkSync(filePath);
       info(`Deleted harness: ${input.path}`);
       return `Deleted ${input.path}`;
     }
@@ -26916,29 +27205,29 @@ async function authorHarness(repoPath, apiKey, options = {}) {
   const mode = options.mode ?? "init";
   const systemPromptPath = resolvePromptPath("system-authoring.md");
   const agentMdTemplatePath = resolveTemplateFile("AGENT.md.template");
-  let systemPrompt = fs11.existsSync(systemPromptPath) ? fs11.readFileSync(systemPromptPath, "utf8") : "Adapt the .har/ boilerplate to match the repository. Edit files directly. Call finishAuthoring when done.";
+  let systemPrompt = fs14.existsSync(systemPromptPath) ? fs14.readFileSync(systemPromptPath, "utf8") : "Adapt the .har/ boilerplate to match the repository. Edit files directly. Call finishAuthoring when done.";
   if (agentMdTemplatePath) {
     systemPrompt += `
 
 ## AGENT.md template (starting point for proposeAgentMd)
 
-${fs11.readFileSync(agentMdTemplatePath, "utf8")}`;
+${fs14.readFileSync(agentMdTemplatePath, "utf8")}`;
   }
   const tools = buildAuthoringTools();
   const messages = [];
   let rootListing;
   try {
-    rootListing = fs11.readdirSync(repoPath).slice(0, 50).join("\n");
+    rootListing = fs14.readdirSync(repoPath).slice(0, 50).join("\n");
   } catch {
     throw new Error(`Cannot read repo at path: ${repoPath}`);
   }
   let harnessListing;
   try {
-    harnessListing = fs11.readdirSync(harnessDir).join("\n");
+    harnessListing = fs14.readdirSync(harnessDir).join("\n");
   } catch {
     throw new Error(`Cannot read harness dir at: ${harnessDir}`);
   }
-  const existingAgentMd = fs11.existsSync(path11.join(repoPath, "AGENT.md")) ? "AGENT.md exists at repo root \u2014 read it before proposing changes via proposeAgentMd." : "No AGENT.md at repo root yet \u2014 propose one via proposeAgentMd.";
+  const existingAgentMd = fs14.existsSync(path14.join(repoPath, "AGENT.md")) ? "AGENT.md exists at repo root \u2014 read it before proposing changes via proposeAgentMd." : "No AGENT.md at repo root yet \u2014 propose one via proposeAgentMd.";
   const modeInstructions = mode === "maintain" ? `This is a MAINTENANCE run. .har/ already exists and may have been edited by humans.
 Update it to reflect current repo changes. Prefer editHarnessFile over writeHarnessFile.
 Keep README.md accurate \u2014 it is the index of the harness. ${existingAgentMd}` : `This is an INITIAL setup. A fresh boilerplate has been copied to .har/.
@@ -27018,8 +27307,8 @@ Try running with --verbose to see what the agent is doing.`
 }
 
 // src/harness/validator.ts
-var fs14 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 
 // src/utils/shell.ts
 var import_child_process = require("child_process");
@@ -27087,205 +27376,6 @@ function runShellCommand(command2, options = {}) {
   });
 }
 
-// src/harness/stages.ts
-var fs13 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
-
-// src/harness/env.ts
-var fs12 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
-function readHarnessEnv(repoPath) {
-  const envPath = path12.join(getHarnessDir(repoPath), "harness.env");
-  if (!fs12.existsSync(envPath)) return {};
-  const values = {};
-  for (const line of fs12.readFileSync(envPath, "utf8").split("\n")) {
-    const match = line.match(/^export\s+([A-Z0-9_]+)=(.*)$/);
-    if (!match) continue;
-    values[match[1]] = match[2].replace(/^"|"$/g, "");
-  }
-  return values;
-}
-function parseHarnessEnvInt(env3, key) {
-  const raw = env3[key];
-  if (raw === void 0 || raw === "") return void 0;
-  const value = Number(raw);
-  if (!Number.isInteger(value)) return void 0;
-  return value;
-}
-
-// src/harness/stages.ts
-var STAGE_REGISTRY_FILE = "stages.json";
-var AGENT_REQUIRED_KINDS = /* @__PURE__ */ new Set([
-  "launch",
-  "verify",
-  "test",
-  "inspect",
-  "reset",
-  "teardown",
-  "custom"
-]);
-function getStageRegistryPath(repoPath) {
-  return path13.join(getHarnessDir(repoPath), STAGE_REGISTRY_FILE);
-}
-function synthesizeStageRegistry(repoPath) {
-  const harnessDir = getHarnessDir(repoPath);
-  const stages = [];
-  addStageIfRunnable(stages, harnessDir, {
-    id: "setup-infra",
-    kind: "setup",
-    description: "Start shared harness infrastructure.",
-    command: "./.har/setup-infra.sh",
-    requiresAgentId: false
-  });
-  addStageIfRunnable(stages, harnessDir, {
-    id: "launch",
-    kind: "launch",
-    description: "Launch an isolated agent environment slot.",
-    command: "./.har/launch.sh {agentId}",
-    requiresAgentId: true
-  });
-  addStageIfRunnable(stages, harnessDir, {
-    id: "verify",
-    kind: "verify",
-    description: "Run the project verification pipeline.",
-    command: "./.har/verify.sh {agentId}",
-    requiresAgentId: true,
-    acceptsArgs: ["--full"]
-  });
-  addStageIfRunnable(stages, harnessDir, {
-    id: "status",
-    kind: "inspect",
-    description: "Inspect a running agent environment slot.",
-    command: "./.har/agent-cli.sh {agentId} status",
-    requiresAgentId: true
-  });
-  addStageIfRunnable(stages, harnessDir, {
-    id: "logs",
-    kind: "inspect",
-    description: "Read recent logs for an agent slot.",
-    command: "./.har/agent-cli.sh {agentId} logs",
-    requiresAgentId: true
-  });
-  addStageIfRunnable(stages, harnessDir, {
-    id: "teardown",
-    kind: "teardown",
-    description: "Tear down an isolated agent environment slot.",
-    command: "./.har/teardown.sh {agentId}",
-    requiresAgentId: true
-  });
-  const harnessEnv = readHarnessEnv(repoPath);
-  const agentSlots = readAgentSlotsFromHarnessEnv(harnessEnv);
-  if (!agentSlots) {
-    throw new Error(
-      "Configure agent slot limits in .har/stages.json (agentSlots) or .har/harness.env (HARNESS_AGENT_SLOT_MIN/MAX)"
-    );
-  }
-  return {
-    version: "1",
-    artifactsDir: "artifacts",
-    logsDir: "logs",
-    agentSlots,
-    verificationStages: ["typecheck", "unit-tests", "api-health"],
-    stages
-  };
-}
-function readAgentSlotsFromHarnessEnv(harnessEnv) {
-  const max = parseHarnessEnvInt(harnessEnv, "HARNESS_AGENT_SLOT_MAX");
-  if (max === void 0) return null;
-  const min = parseHarnessEnvInt(harnessEnv, "HARNESS_AGENT_SLOT_MIN") ?? HAR_AGENT_SLOT_MIN;
-  if (max < min) {
-    throw new Error("HARNESS_AGENT_SLOT_MAX must be >= HARNESS_AGENT_SLOT_MIN in harness.env");
-  }
-  return { min, max };
-}
-function stageScriptExists(harnessDir, stage) {
-  if (stage.script) {
-    return fs13.existsSync(path13.join(harnessDir, stage.script));
-  }
-  if (stage.command) {
-    const scriptName = stage.command.split(/\s+/)[0].replace(/^\.\/\.har\//, "").replace(/^\.\//, "");
-    return fs13.existsSync(path13.join(harnessDir, scriptName));
-  }
-  return fs13.existsSync(path13.join(harnessDir, "stages", `${stage.id}.sh`));
-}
-function addStageIfRunnable(stages, harnessDir, stage) {
-  const parsed = HarnessStageSchema.parse(stage);
-  if (stageScriptExists(harnessDir, parsed)) {
-    stages.push(parsed);
-  }
-}
-function readStageRegistry(repoPath) {
-  const registryPath = getStageRegistryPath(repoPath);
-  if (!fs13.existsSync(registryPath)) {
-    return synthesizeStageRegistry(repoPath);
-  }
-  const raw = JSON.parse(fs13.readFileSync(registryPath, "utf8"));
-  const parsed = HarnessStageRegistrySchema.safeParse(raw);
-  if (!parsed.success) {
-    throw new Error(`Invalid .har/${STAGE_REGISTRY_FILE}: ${parsed.error.message}`);
-  }
-  return parsed.data;
-}
-function writeStageRegistry(repoPath, registry2) {
-  const registryPath = getStageRegistryPath(repoPath);
-  const parsed = HarnessStageRegistrySchema.safeParse(registry2);
-  if (!parsed.success) {
-    throw new Error(`Invalid stage registry: ${parsed.error.message}`);
-  }
-  fs13.writeFileSync(registryPath, JSON.stringify(parsed.data, null, 2) + "\n");
-}
-function listStages(repoPath) {
-  return readStageRegistry(repoPath).stages;
-}
-function getAgentSlotRange(repoPath) {
-  const registry2 = readStageRegistry(repoPath);
-  if (registry2.agentSlots) {
-    return registry2.agentSlots;
-  }
-  const fromEnv = readAgentSlotsFromHarnessEnv(readHarnessEnv(repoPath));
-  if (fromEnv) {
-    return fromEnv;
-  }
-  throw new Error(
-    "Configure agent slot limits in .har/stages.json (agentSlots) or .har/harness.env (HARNESS_AGENT_SLOT_MIN/MAX)"
-  );
-}
-function getAgentSlotIds(repoPath) {
-  const { min, max } = getAgentSlotRange(repoPath);
-  const ids = [];
-  for (let id = min; id <= max; id++) ids.push(id);
-  return ids;
-}
-function stageRequiresAgentId(stage) {
-  if (typeof stage.requiresAgentId === "boolean") return stage.requiresAgentId;
-  return AGENT_REQUIRED_KINDS.has(stage.kind);
-}
-function resolveStage(repoPath, options) {
-  if (!options.id && !options.kind) return null;
-  const stages = listStages(repoPath);
-  if (options.id) {
-    return stages.find((stage) => stage.id === options.id) ?? null;
-  }
-  const matches = stages.filter((stage) => stage.kind === options.kind);
-  if (matches.length === 1) return matches[0];
-  if (matches.length > 1) {
-    throw new Error(
-      `Multiple stages with kind "${options.kind}". Specify stage id. Available: ${matches.map((s2) => s2.id).join(", ")}`
-    );
-  }
-  return null;
-}
-function getVerificationStageIds(repoPath) {
-  const registry2 = readStageRegistry(repoPath);
-  if (Array.isArray(registry2.verificationStages) && registry2.verificationStages.length > 0) {
-    return registry2.verificationStages;
-  }
-  return registry2.stages.filter((stage) => stage.group === "verification").map((stage) => stage.id);
-}
-function getArtifactsDir(repoPath) {
-  return readStageRegistry(repoPath).artifactsDir ?? "artifacts";
-}
-
 // src/harness/validator.ts
 var REQUIRED_FILES_DEFAULT = [
   "README.md",
@@ -27338,22 +27428,22 @@ var SHELL_SCRIPTS = [
 function validateHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
-  if (!fs14.existsSync(harnessDir)) {
+  if (!fs15.existsSync(harnessDir)) {
     return {
       pass: false,
       issues: [{ file: ".har", message: "Harness directory not found", severity: "error" }]
     };
   }
   for (const file of getRequiredFiles(repoPath)) {
-    const filePath = path14.join(harnessDir, file);
-    if (!fs14.existsSync(filePath)) {
+    const filePath = path15.join(harnessDir, file);
+    if (!fs15.existsSync(filePath)) {
       issues.push({ file, message: "Required file missing", severity: "error" });
     }
   }
   for (const script of SHELL_SCRIPTS) {
-    const scriptPath = path14.join(harnessDir, script);
-    if (!fs14.existsSync(scriptPath)) continue;
-    const stat = fs14.statSync(scriptPath);
+    const scriptPath = path15.join(harnessDir, script);
+    if (!fs15.existsSync(scriptPath)) continue;
+    const stat = fs15.statSync(scriptPath);
     if (!(stat.mode & 73)) {
       issues.push({ file: script, message: "Script is not executable", severity: "warning" });
     }
@@ -27368,9 +27458,9 @@ function validateHarness(repoPath) {
   }
   const manifest = readManifest(repoPath);
   const profile = manifest?.profile ?? "default";
-  const ecosystemPath = path14.join(harnessDir, "ecosystem.agent.template.cjs");
-  if (profile !== "cli" && fs14.existsSync(ecosystemPath)) {
-    const content = fs14.readFileSync(ecosystemPath, "utf8");
+  const ecosystemPath = path15.join(harnessDir, "ecosystem.agent.template.cjs");
+  if (profile !== "cli" && fs15.existsSync(ecosystemPath)) {
+    const content = fs15.readFileSync(ecosystemPath, "utf8");
     if (!content.includes("module.exports")) {
       issues.push({
         file: "ecosystem.agent.template.cjs",
@@ -27379,9 +27469,9 @@ function validateHarness(repoPath) {
       });
     }
   }
-  const harnessEnvPath = path14.join(harnessDir, "harness.env");
-  if (fs14.existsSync(harnessEnvPath)) {
-    const content = fs14.readFileSync(harnessEnvPath, "utf8");
+  const harnessEnvPath = path15.join(harnessDir, "harness.env");
+  if (fs15.existsSync(harnessEnvPath)) {
+    const content = fs15.readFileSync(harnessEnvPath, "utf8");
     if (content.includes("TODO: set migrate command")) {
       issues.push({ file: "harness.env", message: "Migrate command still has TODO", severity: "warning" });
     }
@@ -27389,17 +27479,17 @@ function validateHarness(repoPath) {
       issues.push({ file: "harness.env", message: "Seed command still has TODO", severity: "warning" });
     }
   }
-  const verifyPath = path14.join(harnessDir, "verify.sh");
-  if (fs14.existsSync(verifyPath)) {
-    const content = fs14.readFileSync(verifyPath, "utf8");
+  const verifyPath = path15.join(harnessDir, "verify.sh");
+  if (fs15.existsSync(verifyPath)) {
+    const content = fs15.readFileSync(verifyPath, "utf8");
     if (content.includes("echo 'TODO:")) {
       issues.push({ file: "verify.sh", message: "Verification steps still have TODO placeholders", severity: "warning" });
     }
   }
-  const stagesPath = path14.join(harnessDir, "stages.json");
-  if (fs14.existsSync(stagesPath)) {
+  const stagesPath = path15.join(harnessDir, "stages.json");
+  if (fs15.existsSync(stagesPath)) {
     try {
-      JSON.parse(fs14.readFileSync(stagesPath, "utf8"));
+      JSON.parse(fs15.readFileSync(stagesPath, "utf8"));
       const registry2 = readStageRegistry(repoPath);
       if (registry2.stages.length === 0) {
         issues.push({ file: "stages.json", message: "No harness stages declared", severity: "warning" });
@@ -27414,9 +27504,9 @@ function validateHarness(repoPath) {
   } else {
     issues.push({ file: "stages.json", message: "Stage registry missing", severity: "warning" });
   }
-  const readmePath = path14.join(harnessDir, "README.md");
-  if (fs14.existsSync(readmePath)) {
-    const content = fs14.readFileSync(readmePath, "utf8");
+  const readmePath = path15.join(harnessDir, "README.md");
+  if (fs15.existsSync(readmePath)) {
+    const content = fs15.readFileSync(readmePath, "utf8");
     if (!content.includes(".har")) {
       issues.push({ file: "README.md", message: "README should document .har/ paths", severity: "warning" });
     }
@@ -27430,8 +27520,8 @@ function validateHarness(repoPath) {
 async function smokeTestHarness(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
   const issues = [];
-  const setupScript = path14.join(harnessDir, "setup-infra.sh");
-  if (fs14.existsSync(setupScript)) {
+  const setupScript = path15.join(harnessDir, "setup-infra.sh");
+  if (fs15.existsSync(setupScript)) {
     const result = run(`bash "${setupScript}"`, { cwd: repoPath });
     if (result.code !== 0) {
       issues.push({
@@ -27446,8 +27536,8 @@ async function smokeTestHarness(repoPath) {
 }
 
 // src/harness/drift.ts
-var fs15 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var PROFILE_DIRS2 = {
   default: "har-boilerplate",
   cli: "har-boilerplate-cli",
@@ -27515,48 +27605,51 @@ function substituteProjectName(content, projectName) {
   return content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
 }
 function listBoilerplateFiles(boilerplateDir) {
-  if (!fs15.existsSync(boilerplateDir)) return [];
-  return fs15.readdirSync(boilerplateDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  if (!fs16.existsSync(boilerplateDir)) return [];
+  return fs16.readdirSync(boilerplateDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
 }
 function compareHarnessToTemplate(repoPath) {
-  const resolved = path15.resolve(repoPath);
+  const resolved = path16.resolve(repoPath);
   const manifest = readManifest(resolved);
   const profile = manifest?.profile ?? "default";
   const harnessDir = getHarnessDir(resolved);
-  const projectName = path15.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
-  const boilerplateDir = path15.join(resolveTemplatesDir(), PROFILE_DIRS2[profile]);
+  const projectName = path16.basename(resolved).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  const boilerplateDir = path16.join(resolveTemplatesDir(), PROFILE_DIRS2[profile]);
   const templateFiles = listBoilerplateFiles(boilerplateDir);
   const missing = [];
   const checksumMismatch = [];
   const extra = [];
   const unchanged = [];
   for (const file of templateFiles) {
-    const templatePath = path15.join(boilerplateDir, file);
-    const harnessPath = path15.join(harnessDir, file);
-    let templateContent = fs15.readFileSync(templatePath, "utf8");
+    const harnessFile = harnessFileForTemplate(file);
+    const templatePath = path16.join(boilerplateDir, file);
+    const harnessPath = path16.join(harnessDir, harnessFile);
+    let templateContent = fs16.readFileSync(templatePath, "utf8");
     if (file === "harness.env") {
       templateContent = substituteProjectName(templateContent, projectName);
     }
-    if (!fs15.existsSync(harnessPath)) {
-      missing.push(file);
+    if (!fs16.existsSync(harnessPath)) {
+      missing.push(harnessFile);
       continue;
     }
-    const harnessChecksum = computeFileChecksum(fs15.readFileSync(harnessPath, "utf8"));
+    const harnessChecksum = computeFileChecksum(fs16.readFileSync(harnessPath, "utf8"));
     const templateChecksum = computeFileChecksum(templateContent);
     if (harnessChecksum === templateChecksum) {
-      unchanged.push(file);
+      unchanged.push(harnessFile);
     } else {
-      checksumMismatch.push(file);
+      checksumMismatch.push(harnessFile);
     }
   }
-  if (fs15.existsSync(harnessDir)) {
-    for (const file of fs15.readdirSync(harnessDir)) {
-      const full = path15.join(harnessDir, file);
-      if (!fs15.statSync(full).isFile()) continue;
+  if (fs16.existsSync(harnessDir)) {
+    for (const file of fs16.readdirSync(harnessDir)) {
+      const full = path16.join(harnessDir, file);
+      if (!fs16.statSync(full).isFile()) continue;
       if (file === "manifest.json" || file.startsWith("ADAPT-PROMPT")) continue;
       if (profile === "cli" && CLI_EXPECTED_ABSENT.has(file)) {
         extra.push(file);
-      } else if (!templateFiles.includes(file)) {
+      } else if (isExpectedHarnessOnlyFile(file, templateFiles)) {
+        continue;
+      } else if (!templateFiles.includes(file) && !templateFiles.includes(templateFileForHarness(file))) {
         extra.push(file);
       }
     }
@@ -27564,6 +27657,7 @@ function compareHarnessToTemplate(repoPath) {
   const installed = manifest?.generatorVersion;
   const harnessEnv = readHarnessEnv(resolved);
   const missingPortVars = missingPortDocumentationVars(profile, harnessEnv);
+  const agentSlotMismatch = detectAgentSlotEnvMismatch(resolved);
   return {
     generatorVersion: {
       installed,
@@ -27574,14 +27668,15 @@ function compareHarnessToTemplate(repoPath) {
     checksumMismatch,
     extra,
     unchanged,
-    missingPortVars
+    missingPortVars,
+    agentSlotMismatch
   };
 }
 
 // src/harness/maintain-bundle.ts
-var fs16 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
-var path16 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 var MAINTAIN_DIR = "maintain";
 var PROFILE_DIRS3 = {
   default: "har-boilerplate",
@@ -27592,14 +27687,14 @@ function substituteProjectName2(content, projectName) {
   return content.replace(/__PROJECT_NAME__/g, projectName).replace(/template___PROJECT_NAME__/g, `template_${projectName}`);
 }
 function projectNameFromRepo(repoPath) {
-  return path16.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
+  return path17.basename(repoPath).toLowerCase().replace(/[^a-z0-9]/g, "_");
 }
 function boilerplateDirForProfile(profile) {
-  return path16.join(resolveTemplatesDir(), PROFILE_DIRS3[profile]);
+  return path17.join(resolveTemplatesDir(), PROFILE_DIRS3[profile]);
 }
 function readBundledTemplateContent(repoPath, profile, file) {
-  const templatePath = path16.join(boilerplateDirForProfile(profile), file);
-  let content = fs16.readFileSync(templatePath, "utf8");
+  const templatePath = path17.join(boilerplateDirForProfile(profile), templateFileForHarness(file));
+  let content = fs17.readFileSync(templatePath, "utf8");
   if (file === "harness.env") {
     content = substituteProjectName2(content, projectNameFromRepo(repoPath));
   }
@@ -27630,12 +27725,12 @@ function actionHint(file, kind2) {
   return `Read maintain/diffs/${file}.diff and merge into .har/${file}.`;
 }
 function createUnifiedDiff(installedContent, templateContent, installedLabel, templateLabel) {
-  const tmpDir = fs16.mkdtempSync(path16.join(os3.tmpdir(), "har-maintain-diff-"));
+  const tmpDir = fs17.mkdtempSync(path17.join(os3.tmpdir(), "har-maintain-diff-"));
   try {
-    const installedPath = path16.join(tmpDir, "installed");
-    const templatePath = path16.join(tmpDir, "template");
-    fs16.writeFileSync(installedPath, installedContent);
-    fs16.writeFileSync(templatePath, templateContent);
+    const installedPath = path17.join(tmpDir, "installed");
+    const templatePath = path17.join(tmpDir, "template");
+    fs17.writeFileSync(installedPath, installedContent);
+    fs17.writeFileSync(templatePath, templateContent);
     const result = run(`diff -u "${installedPath}" "${templatePath}"`);
     const body = result.stdout.trim();
     if (!body) return "";
@@ -27644,7 +27739,7 @@ function createUnifiedDiff(installedContent, templateContent, installedLabel, te
 ${body.split("\n").slice(2).join("\n")}
 `;
   } finally {
-    fs16.rmSync(tmpDir, { recursive: true, force: true });
+    fs17.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function buildActions(repoPath, profile, drift) {
@@ -27659,7 +27754,7 @@ function buildActions(repoPath, profile, drift) {
     });
   }
   for (const file of drift.checksumMismatch) {
-    const installedPath = path16.join(harnessDir, file);
+    const installedPath = path17.join(harnessDir, file);
     const installedRel = `maintain/installed/${file}`;
     const templateRel = `maintain/templates/${file}`;
     const diffRel = `maintain/diffs/${file}.diff`;
@@ -27667,7 +27762,7 @@ function buildActions(repoPath, profile, drift) {
       file,
       kind: "drift",
       template: templateRel,
-      installed: fs16.existsSync(installedPath) ? installedRel : void 0,
+      installed: fs17.existsSync(installedPath) ? installedRel : void 0,
       diff: diffRel,
       hint: actionHint(file, "drift")
     });
@@ -27716,6 +27811,18 @@ function buildReadme(report) {
       lines.push(`- \`${v2}\` \u2014 copy from \`maintain/templates/harness.env\``);
     }
   }
+  if (report.agentSlotMismatch) {
+    lines.push(
+      "",
+      "## Agent slot limit mismatch",
+      "",
+      `- \`stages.json\` agentSlots: ${report.agentSlotMismatch.stages.min}\u2013${report.agentSlotMismatch.stages.max}`,
+      `- \`harness.env\` HARNESS_AGENT_SLOT_*: ${report.agentSlotMismatch.env.min}\u2013${report.agentSlotMismatch.env.max}`,
+      "",
+      "Canonical source is `.har/stages.json`. Run `har env maintain` to sync legacy exports in `harness.env`, or edit `agentSlots` there.",
+      ""
+    );
+  }
   lines.push("", "## Stale files (review)", "");
   if (report.stale.length === 0) {
     lines.push("None detected.");
@@ -27738,28 +27845,28 @@ function buildReadme(report) {
 }
 function writeBundleArtifacts(repoPath, profile, drift, report) {
   const harnessDir = getHarnessDir(repoPath);
-  const bundleDir = path16.join(harnessDir, MAINTAIN_DIR);
-  if (fs16.existsSync(bundleDir)) {
-    fs16.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path17.join(harnessDir, MAINTAIN_DIR);
+  if (fs17.existsSync(bundleDir)) {
+    fs17.rmSync(bundleDir, { recursive: true, force: true });
   }
   const dirs = [
     bundleDir,
-    path16.join(bundleDir, "templates"),
-    path16.join(bundleDir, "installed"),
-    path16.join(bundleDir, "diffs"),
-    path16.join(bundleDir, "stale")
+    path17.join(bundleDir, "templates"),
+    path17.join(bundleDir, "installed"),
+    path17.join(bundleDir, "diffs"),
+    path17.join(bundleDir, "stale")
   ];
   for (const dir of dirs) {
-    fs16.mkdirSync(dir, { recursive: true });
+    fs17.mkdirSync(dir, { recursive: true });
   }
   const affectedFiles = [...drift.missing, ...drift.checksumMismatch];
   for (const file of affectedFiles) {
     const templateContent = readBundledTemplateContent(repoPath, profile, file);
-    writeFileSafe(path16.join(bundleDir, "templates", file), templateContent);
-    const harnessPath = path16.join(harnessDir, file);
-    if (fs16.existsSync(harnessPath)) {
-      const installedContent = fs16.readFileSync(harnessPath, "utf8");
-      writeFileSafe(path16.join(bundleDir, "installed", file), installedContent);
+    writeFileSafe(path17.join(bundleDir, "templates", file), templateContent);
+    const harnessPath = path17.join(harnessDir, file);
+    if (fs17.existsSync(harnessPath)) {
+      const installedContent = fs17.readFileSync(harnessPath, "utf8");
+      writeFileSafe(path17.join(bundleDir, "installed", file), installedContent);
       const diff = createUnifiedDiff(
         installedContent,
         templateContent,
@@ -27767,14 +27874,14 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
         `templates/${file}`
       );
       if (diff) {
-        writeFileSafe(path16.join(bundleDir, "diffs", `${file}.diff`), diff);
+        writeFileSafe(path17.join(bundleDir, "diffs", `${file}.diff`), diff);
       }
     }
   }
-  writeFileSafe(path16.join(bundleDir, "README.md"), buildReadme(report));
-  writeFileSafe(path16.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
+  writeFileSafe(path17.join(bundleDir, "README.md"), buildReadme(report));
+  writeFileSafe(path17.join(bundleDir, "drift-report.json"), JSON.stringify(report, null, 2) + "\n");
   writeFileSafe(
-    path16.join(bundleDir, "validation.json"),
+    path17.join(bundleDir, "validation.json"),
     JSON.stringify(report.validation, null, 2) + "\n"
   );
   if (report.stale.length > 0) {
@@ -27786,7 +27893,7 @@ function writeBundleArtifacts(repoPath, profile, drift, report) {
       ...report.stale.map((s2) => `- **${s2.file}** \u2014 ${s2.hint}`),
       ""
     ];
-    writeFileSafe(path16.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
+    writeFileSafe(path17.join(bundleDir, "stale", "MANIFEST.md"), staleLines.join("\n"));
   }
   return bundleDir;
 }
@@ -27802,6 +27909,7 @@ function buildMaintainBundle(repoPath, validation2, drift) {
     actions: buildActions(repoPath, profile, drift),
     stale: buildStale(drift),
     missingPortVars: drift.missingPortVars,
+    agentSlotMismatch: drift.agentSlotMismatch,
     validation: {
       pass: validation2.pass,
       errors,
@@ -27812,9 +27920,9 @@ function buildMaintainBundle(repoPath, validation2, drift) {
   return { bundleDir, report };
 }
 function removeMaintainBundle(repoPath) {
-  const bundleDir = path16.join(getHarnessDir(repoPath), MAINTAIN_DIR);
-  if (fs16.existsSync(bundleDir)) {
-    fs16.rmSync(bundleDir, { recursive: true, force: true });
+  const bundleDir = path17.join(getHarnessDir(repoPath), MAINTAIN_DIR);
+  if (fs17.existsSync(bundleDir)) {
+    fs17.rmSync(bundleDir, { recursive: true, force: true });
   }
 }
 function formatMaintainBundlePromptSection(report) {
@@ -27855,20 +27963,31 @@ function formatMaintainBundlePromptSection(report) {
     }
     lines.push("");
   }
-  if (report.actions.length === 0 && report.stale.length === 0 && report.missingPortVars.length === 0 && report.validation.errors.length === 0) {
+  if (report.agentSlotMismatch) {
+    lines.push(
+      "### Agent slot limit mismatch",
+      "",
+      `- \`stages.json\` agentSlots: ${report.agentSlotMismatch.stages.min}\u2013${report.agentSlotMismatch.stages.max}`,
+      `- \`harness.env\` HARNESS_AGENT_SLOT_*: ${report.agentSlotMismatch.env.min}\u2013${report.agentSlotMismatch.env.max}`,
+      "",
+      "Canonical source is `.har/stages.json`. `har env maintain --finalize` syncs legacy exports in `harness.env`.",
+      ""
+    );
+  }
+  if (report.actions.length === 0 && report.stale.length === 0 && report.missingPortVars.length === 0 && !report.agentSlotMismatch && report.validation.errors.length === 0) {
     lines.push("No template drift detected. Review repo stack changes manually if needed.", "");
   }
   return lines.join("\n");
 }
 
 // src/harness/stage-templates.ts
-var fs18 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 
 // src/harness/parser.ts
-var fs17 = __toESM(require("fs"));
+var fs18 = __toESM(require("fs"));
 function harnessExists(repoPath) {
-  return fs17.existsSync(`${repoPath}/.har/setup-infra.sh`);
+  return fs18.existsSync(`${repoPath}/.har/setup-infra.sh`);
 }
 
 // src/harness/stage-templates.ts
@@ -27891,16 +28010,16 @@ var StageTemplateManifestSchema = external_exports.object({
   docsPath: external_exports.string().min(1)
 });
 function resolveTemplateDir(templateId) {
-  const dir = path17.join(resolveTemplatesDir(), "stage-templates", templateId);
-  if (!fs18.existsSync(dir)) {
+  const dir = path18.join(resolveTemplatesDir(), "stage-templates", templateId);
+  if (!fs19.existsSync(dir)) {
     throw new Error(`Stage template not found: ${templateId}. Run npm run build.`);
   }
   return dir;
 }
 function readTemplateManifest(templateId) {
-  const manifestPath = path17.join(resolveTemplateDir(templateId), "template.manifest.json");
+  const manifestPath = path18.join(resolveTemplateDir(templateId), "template.manifest.json");
   const parsed = StageTemplateManifestSchema.safeParse(
-    JSON.parse(fs18.readFileSync(manifestPath, "utf8"))
+    JSON.parse(fs19.readFileSync(manifestPath, "utf8"))
   );
   if (!parsed.success) {
     throw new Error(`Invalid template manifest for ${templateId}: ${parsed.error.message}`);
@@ -27911,40 +28030,40 @@ function readTemplateManifest(templateId) {
   return parsed.data;
 }
 function ensureParentDir(filePath) {
-  const parent = path17.dirname(filePath);
-  if (!fs18.existsSync(parent)) {
-    fs18.mkdirSync(parent, { recursive: true });
+  const parent = path18.dirname(filePath);
+  if (!fs19.existsSync(parent)) {
+    fs19.mkdirSync(parent, { recursive: true });
   }
 }
 function copyTemplateFile(templateDir, file, repoPath, force) {
-  const srcPath = path17.join(templateDir, file.src);
-  const destPath = path17.join(repoPath, file.dest);
-  if (!fs18.existsSync(srcPath)) {
+  const srcPath = path18.join(templateDir, file.src);
+  const destPath = path18.join(repoPath, file.dest);
+  if (!fs19.existsSync(srcPath)) {
     throw new Error(`Template file missing: ${file.src}`);
   }
-  if (fs18.existsSync(destPath) && !force) {
+  if (fs19.existsSync(destPath) && !force) {
     throw new Error(
       `File already exists: ${file.dest}. Use --force to overwrite or remove it first.`
     );
   }
   ensureParentDir(destPath);
-  fs18.copyFileSync(srcPath, destPath);
+  fs19.copyFileSync(srcPath, destPath);
   if (file.executable) {
-    fs18.chmodSync(destPath, 493);
+    fs19.chmodSync(destPath, 493);
   }
   return { written: true, path: file.dest };
 }
 function mergePackageJson(repoPath, templateDir, fragmentRelPath, warnings) {
-  const packagePath = path17.join(repoPath, "package.json");
-  if (!fs18.existsSync(packagePath)) {
+  const packagePath = path18.join(repoPath, "package.json");
+  if (!fs19.existsSync(packagePath)) {
     throw new Error("No package.json in repo root. Add one before applying this stage template.");
   }
-  const fragmentPath = path17.join(templateDir, fragmentRelPath);
-  if (!fs18.existsSync(fragmentPath)) {
+  const fragmentPath = path18.join(templateDir, fragmentRelPath);
+  if (!fs19.existsSync(fragmentPath)) {
     throw new Error(`Package fragment missing: ${fragmentRelPath}`);
   }
-  const pkg = JSON.parse(fs18.readFileSync(packagePath, "utf8"));
-  const fragment = JSON.parse(fs18.readFileSync(fragmentPath, "utf8"));
+  const pkg = JSON.parse(fs19.readFileSync(packagePath, "utf8"));
+  const fragment = JSON.parse(fs19.readFileSync(fragmentPath, "utf8"));
   for (const section of ["scripts", "devDependencies"]) {
     const existing = pkg[section] ?? {};
     const incoming = fragment[section] ?? {};
@@ -27957,7 +28076,7 @@ function mergePackageJson(repoPath, templateDir, fragmentRelPath, warnings) {
     }
     pkg[section] = existing;
   }
-  fs18.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
+  fs19.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + "\n");
 }
 function patchStageRegistry(repoPath, manifest, force) {
   const registry2 = readStageRegistry(repoPath);
@@ -27997,8 +28116,8 @@ function assertHarnessPresent(repoPath) {
 }
 function assertStageNotPresent(repoPath, stageId, force) {
   if (force) return;
-  const scriptPath = path17.join(repoPath, ".har", "stages", `${stageId}.sh`);
-  if (fs18.existsSync(scriptPath)) {
+  const scriptPath = path18.join(repoPath, ".har", "stages", `${stageId}.sh`);
+  if (fs19.existsSync(scriptPath)) {
     throw new Error(
       `Stage script already exists: .har/stages/${stageId}.sh. Use --force to overwrite.`
     );
@@ -28011,7 +28130,7 @@ function assertStageNotPresent(repoPath, stageId, force) {
   }
 }
 function applyStageTemplate(repoPath, templateId, options = {}) {
-  const resolved = path17.resolve(repoPath);
+  const resolved = path18.resolve(repoPath);
   const force = options.force ?? false;
   const warnings = [];
   const filesWritten = [];
@@ -28030,7 +28149,7 @@ function applyStageTemplate(repoPath, templateId, options = {}) {
       if (file.skipFlag === "skipCi" && options.skipCi) {
         continue;
       }
-      if (fs18.existsSync(path17.join(resolved, file.dest)) && !force) {
+      if (fs19.existsSync(path18.join(resolved, file.dest)) && !force) {
         warnings.push(`Skipped optional file (exists): ${file.dest}`);
         continue;
       }
@@ -28065,9 +28184,9 @@ function applyStageTemplate(repoPath, templateId, options = {}) {
   };
 }
 function listStageTemplateIds() {
-  const root = path17.join(resolveTemplatesDir(), "stage-templates");
-  if (!fs18.existsSync(root)) return [...STAGE_TEMPLATE_IDS];
-  return fs18.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter(
+  const root = path18.join(resolveTemplatesDir(), "stage-templates");
+  if (!fs19.existsSync(root)) return [...STAGE_TEMPLATE_IDS];
+  return fs19.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter(
     (name) => STAGE_TEMPLATE_IDS.includes(name)
   );
 }
@@ -28094,11 +28213,11 @@ function validateAgentId(id, repoPath) {
 // src/core/harness.ts
 function listHarnessScripts(repoPath) {
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs19.existsSync(harnessDir)) return [];
-  return fs19.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
+  if (!fs20.existsSync(harnessDir)) return [];
+  return fs20.readdirSync(harnessDir).filter((name) => name.endsWith(".sh")).sort();
 }
 function describeProject(repoPath) {
-  const resolved = path18.resolve(repoPath);
+  const resolved = path19.resolve(repoPath);
   const manifest = readManifest(resolved);
   const present = harnessExists(resolved);
   return {
@@ -28118,14 +28237,15 @@ function describeProject(repoPath) {
   };
 }
 async function initHarness(options) {
-  const repoPath = path18.resolve(options.repoPath);
-  if (!fs19.existsSync(repoPath)) {
+  const repoPath = path19.resolve(options.repoPath);
+  if (!fs20.existsSync(repoPath)) {
     throw new Error(`Path not found: ${repoPath}`);
   }
   const scaffold = scaffoldHarnessBoilerplate(repoPath, {
     force: options.force,
     profile: options.profile
   });
+  syncAgentSlotsToHarnessEnv(repoPath);
   let adaptationSummary;
   if (options.auto) {
     const apiKey = requireApiKey();
@@ -28150,9 +28270,9 @@ async function initHarness(options) {
   };
 }
 async function maintainHarness(options) {
-  const repoPath = path18.resolve(options.repoPath);
+  const repoPath = path19.resolve(options.repoPath);
   const harnessDir = getHarnessDir(repoPath);
-  if (!fs19.existsSync(harnessDir)) {
+  if (!fs20.existsSync(harnessDir)) {
     throw new Error('No .har/ found. Run "har env init" first.');
   }
   if (options.auto) {
@@ -28177,6 +28297,7 @@ async function maintainHarness(options) {
     if (!validation2.pass) {
       throw new Error("Cannot finalize: harness validation has errors. Fix them first.");
     }
+    syncAgentSlotsToHarnessEnv(repoPath);
     const existing = readManifest(repoPath);
     finalizeHarness(
       repoPath,
@@ -28203,11 +28324,11 @@ function addStageTemplate(repoPath, templateId, options = {}) {
 }
 
 // src/harness/custom-stage.ts
-var fs20 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var STAGE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 function addCustomStage(repoPath, options) {
-  const resolved = path19.resolve(repoPath);
+  const resolved = path20.resolve(repoPath);
   if (!harnessExists(resolved)) {
     throw new Error('No .har/ harness found. Run "har env init" first.');
   }
@@ -28244,20 +28365,20 @@ function addCustomStage(repoPath, options) {
   if (options.command) {
     stage.command = options.command;
   } else {
-    const scriptRel = path19.join("stages", `${id}.sh`);
-    const scriptAbs = path19.join(resolved, ".har", scriptRel);
-    if (fs20.existsSync(scriptAbs) && !options.force) {
+    const scriptRel = path20.join("stages", `${id}.sh`);
+    const scriptAbs = path20.join(resolved, ".har", scriptRel);
+    if (fs21.existsSync(scriptAbs) && !options.force) {
       throw new Error(`Stage script already exists: .har/${scriptRel}. Use --force to overwrite.`);
     }
-    const skeletonPath = path19.join(
+    const skeletonPath = path20.join(
       resolveTemplatesDir(),
       "stage-templates",
       "custom-stage-skeleton.sh"
     );
-    const skeleton = fs20.readFileSync(skeletonPath, "utf8").replace(/__STAGE_ID__/g, id).replace(/__STAGE_KIND__/g, kind2).replace(/__STAGE_DESCRIPTION__/g, stage.description);
-    fs20.mkdirSync(path19.dirname(scriptAbs), { recursive: true });
-    fs20.writeFileSync(scriptAbs, skeleton);
-    fs20.chmodSync(scriptAbs, 493);
+    const skeleton = fs21.readFileSync(skeletonPath, "utf8").replace(/__STAGE_ID__/g, id).replace(/__STAGE_KIND__/g, kind2).replace(/__STAGE_DESCRIPTION__/g, stage.description);
+    fs21.mkdirSync(path20.dirname(scriptAbs), { recursive: true });
+    fs21.writeFileSync(scriptAbs, skeleton);
+    fs21.chmodSync(scriptAbs, 493);
     filesWritten.push(`.har/${scriptRel}`);
     stage.script = scriptRel;
     stage.artifacts = [
@@ -28305,8 +28426,8 @@ function addCustomStage(repoPath, options) {
 }
 
 // src/harness/adaptation-prompt.ts
-var fs21 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
 var ADAPTATION_PROMPT_FILE = "ADAPT-PROMPT.md";
 var PROFILE_HINTS = {
   default: "Web app profile (SaaS/full-stack) \u2014 Docker Compose for shared infra (HARNESS_INFRA_SERVICES), PM2 for the primary application only, git worktree per agent slot by default. Launch provisions toolchain via harness.env (HARNESS_ECOSYSTEM, HARNESS_INSTALL_CMD) and writes paths to .env.agent.<id>. Identify the primary app agents modify; run supporting services shared.",
@@ -28318,7 +28439,7 @@ function loadTemplate(name) {
   if (!filePath) {
     throw new Error(`Adaptation prompt template not found: ${name}. Run npm run build.`);
   }
-  return fs21.readFileSync(filePath, "utf8");
+  return fs22.readFileSync(filePath, "utf8");
 }
 function applyProfilePlaceholders(content, profile) {
   return content.replace(/\{\{PROFILE\}\}/g, profile).replace(/\{\{PROFILE_HINT\}\}/g, PROFILE_HINTS[profile]);
@@ -28340,7 +28461,7 @@ function buildMaintainAdaptationPrompt(_repoPath, bundleReport) {
 }
 function writeAdaptationPrompt(repoPath, content) {
   const harnessDir = getHarnessDir(repoPath);
-  const filePath = path20.join(harnessDir, ADAPTATION_PROMPT_FILE);
+  const filePath = path21.join(harnessDir, ADAPTATION_PROMPT_FILE);
   writeFileSafe(filePath, content);
   return filePath;
 }
@@ -28359,25 +28480,25 @@ function printAdaptationPrompt(content) {
 }
 
 // src/harness/cursor-rule.ts
-var fs22 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var readline4 = __toESM(require("readline"));
 var CURSOR_RULE_RELATIVE_PATH = ".cursor/rules/har-workflow.mdc";
 function getCursorRulePath(repoPath) {
-  return path21.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
+  return path22.join(repoPath, CURSOR_RULE_RELATIVE_PATH);
 }
 function isCursorWorkspace(repoPath) {
-  return fs22.existsSync(path21.join(repoPath, ".cursor"));
+  return fs23.existsSync(path22.join(repoPath, ".cursor"));
 }
 function cursorRuleExists(repoPath) {
-  return fs22.existsSync(getCursorRulePath(repoPath));
+  return fs23.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 = fs22.readFileSync(templatePath, "utf8");
+  const content = fs23.readFileSync(templatePath, "utf8");
   writeFileSafe(getCursorRulePath(repoPath), content);
 }
 async function handleCursorRule(options) {
@@ -28503,26 +28624,26 @@ function buildStageResult(input) {
 }
 
 // src/core/local-executor.ts
-var fs24 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 
 // src/core/slot-registry.ts
-var fs23 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 function getSlotRegistryDir(repoPath) {
-  return path22.join(getHarnessDir(repoPath), "slots");
+  return path23.join(getHarnessDir(repoPath), "slots");
 }
 function getSlotRegistryPath(repoPath, agentId) {
-  return path22.join(getSlotRegistryDir(repoPath), `agent-${agentId}.json`);
+  return path23.join(getSlotRegistryDir(repoPath), `agent-${agentId}.json`);
 }
 function isSlotResumable(session) {
   return session?.status === "failed" || session?.status === "starting";
 }
 function readSlotRegistry(repoPath, agentId) {
   const file = getSlotRegistryPath(repoPath, agentId);
-  if (!fs23.existsSync(file)) return void 0;
+  if (!fs24.existsSync(file)) return void 0;
   try {
-    const raw = JSON.parse(fs23.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs24.readFileSync(file, "utf8"));
     const result = SlotRegistryEntrySchema.safeParse(raw);
     return result.success ? result.data : void 0;
   } catch {
@@ -28532,7 +28653,7 @@ function readSlotRegistry(repoPath, agentId) {
 
 // src/core/local-executor.ts
 function resolveRepoPath(repoPath) {
-  return path23.resolve(repoPath);
+  return path24.resolve(repoPath);
 }
 function buildPreviewUrlsFromPorts(ports, env3) {
   const urls = {};
@@ -28584,14 +28705,14 @@ function substituteAgentId(value, agentId) {
 function resolveStageScriptPath(repoPath, stage) {
   const harnessDir = getHarnessDir(repoPath);
   if (stage.script) {
-    return path23.join(harnessDir, stage.script);
+    return path24.join(harnessDir, stage.script);
   }
   if (stage.command) {
     const scriptName = stage.command.split(/\s+/)[0].replace(/^\.\/\.har\//, "").replace(/^\.\//, "");
-    return path23.join(harnessDir, scriptName);
+    return path24.join(harnessDir, scriptName);
   }
-  const stageScript = path23.join(harnessDir, "stages", `${stage.id}.sh`);
-  if (fs24.existsSync(stageScript)) {
+  const stageScript = path24.join(harnessDir, "stages", `${stage.id}.sh`);
+  if (fs25.existsSync(stageScript)) {
     return stageScript;
   }
   throw new Error(
@@ -28606,7 +28727,7 @@ function buildExecutionPlan(repoPath, stage, options) {
     ...harnessEnv,
     ...stage.env ?? {}
   };
-  const cwd = stage.cwd ? path23.resolve(resolvedRepo, stage.cwd) : resolvedRepo;
+  const cwd = stage.cwd ? path24.resolve(resolvedRepo, stage.cwd) : resolvedRepo;
   const extraArgs = options.args ?? [];
   const launchFlagArgs = [];
   if (stage.kind === "launch" && options.launchFlags) {
@@ -28683,19 +28804,19 @@ var LocalScriptExecutor = class {
     const repoPath = resolveRepoPath(ctx.repoPath);
     const harnessDir = getHarnessDir(repoPath);
     const artifactsDirName = getArtifactsDir(repoPath);
-    const artifactsDir = path23.join(harnessDir, artifactsDirName);
-    if (!fs24.existsSync(artifactsDir)) return [];
+    const artifactsDir = path24.join(harnessDir, artifactsDirName);
+    if (!fs25.existsSync(artifactsDir)) return [];
     const entries = [];
     const walk = (dir, prefix) => {
-      for (const entry of fs24.readdirSync(dir, { withFileTypes: true })) {
-        const full = path23.join(dir, entry.name);
-        const relative2 = path23.join(prefix, entry.name);
+      for (const entry of fs25.readdirSync(dir, { withFileTypes: true })) {
+        const full = path24.join(dir, entry.name);
+        const relative2 = path24.join(prefix, entry.name);
         if (entry.isDirectory()) {
           walk(full, relative2);
           continue;
         }
         if (filter?.stageId && !relative2.includes(filter.stageId)) continue;
-        const stat = fs24.statSync(full);
+        const stat = fs25.statSync(full);
         entries.push({
           path: full,
           relativePath: relative2,
@@ -28711,7 +28832,7 @@ var LocalScriptExecutor = class {
 var localScriptExecutor = new LocalScriptExecutor();
 
 // src/core/control-sync.ts
-var path37 = __toESM(require("path"));
+var path38 = __toESM(require("path"));
 
 // src/core/control-config.ts
 var DEFAULT_CONTROL_API_URL = "http://localhost:3847";
@@ -28723,32 +28844,32 @@ function isControlEnabled() {
 }
 
 // src/core/control-registry.ts
-var fs25 = __toESM(require("fs"));
+var fs26 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
-var path24 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
 function getRegistryPath() {
   if (process.env.HAR_CONTROL_REGISTRY_PATH) {
-    return path24.resolve(process.env.HAR_CONTROL_REGISTRY_PATH);
+    return path25.resolve(process.env.HAR_CONTROL_REGISTRY_PATH);
   }
-  return path24.join(os4.homedir(), ".har", "repos.json");
+  return path25.join(os4.homedir(), ".har", "repos.json");
 }
 function readRegistry() {
   const registryPath = getRegistryPath();
   try {
-    if (!fs25.existsSync(registryPath)) return { repos: [] };
-    return JSON.parse(fs25.readFileSync(registryPath, "utf8"));
+    if (!fs26.existsSync(registryPath)) return { repos: [] };
+    return JSON.parse(fs26.readFileSync(registryPath, "utf8"));
   } catch {
     return { repos: [] };
   }
 }
 function writeRegistry(registry2) {
   const registryPath = getRegistryPath();
-  fs25.mkdirSync(path24.dirname(registryPath), { recursive: true });
-  fs25.writeFileSync(registryPath, JSON.stringify(registry2, null, 2) + "\n");
+  fs26.mkdirSync(path25.dirname(registryPath), { recursive: true });
+  fs26.writeFileSync(registryPath, JSON.stringify(registry2, null, 2) + "\n");
 }
 function recordRepoForControlSync(repoPath) {
   if (process.env.HAR_CONTROL_DISABLED === "true") return;
-  const resolved = path24.resolve(repoPath);
+  const resolved = path25.resolve(repoPath);
   if (!readManifest(resolved)) return;
   const registry2 = readRegistry();
   if (registry2.repos.includes(resolved)) return;
@@ -28757,7 +28878,7 @@ function recordRepoForControlSync(repoPath) {
 }
 function listRegisteredRepos() {
   const registry2 = readRegistry();
-  const kept = registry2.repos.filter((repoPath) => fs25.existsSync(repoPath) && readManifest(repoPath));
+  const kept = registry2.repos.filter((repoPath) => fs26.existsSync(repoPath) && readManifest(repoPath));
   if (kept.length !== registry2.repos.length) {
     writeRegistry({ repos: kept });
   }
@@ -28765,17 +28886,17 @@ function listRegisteredRepos() {
 }
 
 // src/core/slot-status.ts
-var fs30 = __toESM(require("fs"));
+var fs31 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
-var path30 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 var import_child_process7 = require("child_process");
 
 // src/core/runs.ts
 var crypto2 = __toESM(require("crypto"));
 var import_child_process2 = require("child_process");
-var fs26 = __toESM(require("fs"));
+var fs27 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 var RUNS_DIR = "runs";
 function gitCommonDir(cwd) {
   try {
@@ -28784,7 +28905,7 @@ function gitCommonDir(cwd) {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
-    return out ? path25.resolve(cwd, out) : void 0;
+    return out ? path26.resolve(cwd, out) : void 0;
   } catch {
     return void 0;
   }
@@ -28806,7 +28927,7 @@ function gitPrefix(cwd) {
   }
 }
 function getRunsDir(harnessRoot) {
-  return path25.join(getHarnessDir(harnessRoot), RUNS_DIR);
+  return path26.join(getHarnessDir(harnessRoot), RUNS_DIR);
 }
 function formatLocalDate(d2) {
   const y2 = d2.getFullYear();
@@ -28826,24 +28947,24 @@ function buildRunRelativePath(stageId, agentId, startedAt, runId, runsDir) {
   const timePart = formatLocalTime(started);
   const agentPart = agentId !== void 0 ? `_agent-${agentId}` : "";
   let filename = `${timePart}_${stageId}${agentPart}.json`;
-  const fullPath = path25.join(runsDir, dateFolder, filename);
-  if (fs26.existsSync(fullPath)) {
+  const fullPath = path26.join(runsDir, dateFolder, filename);
+  if (fs27.existsSync(fullPath)) {
     filename = `${timePart}_${stageId}${agentPart}-${runId.slice(0, 8)}.json`;
   }
-  return path25.join(dateFolder, filename);
+  return path26.join(dateFolder, filename);
 }
 function resolveRunFilePath(harnessRoot, run2) {
   if (run2.relativePath) {
-    return path25.join(getRunsDir(harnessRoot), run2.relativePath);
+    return path26.join(getRunsDir(harnessRoot), run2.relativePath);
   }
-  return path25.join(getRunsDir(harnessRoot), `${run2.runId}.json`);
+  return path26.join(getRunsDir(harnessRoot), `${run2.runId}.json`);
 }
 function collectRunFiles(runsDir) {
-  if (!fs26.existsSync(runsDir)) return [];
+  if (!fs27.existsSync(runsDir)) return [];
   const files = [];
   const walk = (dir) => {
-    for (const entry of fs26.readdirSync(dir, { withFileTypes: true })) {
-      const full = path25.join(dir, entry.name);
+    for (const entry of fs27.readdirSync(dir, { withFileTypes: true })) {
+      const full = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.name.endsWith(".json")) {
@@ -28857,30 +28978,30 @@ function collectRunFiles(runsDir) {
 function resolveAgentWorkDir(harnessRoot, agentId) {
   if (agentId === void 0) return void 0;
   const entry = readSlotRegistry(harnessRoot, agentId);
-  if (entry?.workDir && fs26.existsSync(entry.workDir)) return entry.workDir;
+  if (entry?.workDir && fs27.existsSync(entry.workDir)) return entry.workDir;
   const env3 = readHarnessEnv(harnessRoot);
-  const projectName = env3.HARNESS_PROJECT_NAME ?? path25.basename(harnessRoot);
-  const worktreeDir = path25.join(os5.homedir(), "worktrees", `${projectName}-agent-${agentId}`);
+  const projectName = env3.HARNESS_PROJECT_NAME ?? path26.basename(harnessRoot);
+  const worktreeDir = path26.join(os5.homedir(), "worktrees", `${projectName}-agent-${agentId}`);
   const relPrefix = gitPrefix(harnessRoot);
   const sessionEnvFiles = [];
-  const worktreesRoot = path25.join(os5.homedir(), "worktrees");
-  if (fs26.existsSync(worktreesRoot)) {
+  const worktreesRoot = path26.join(os5.homedir(), "worktrees");
+  if (fs27.existsSync(worktreesRoot)) {
     const suffix = `-har-agent-${agentId}-`;
-    for (const entry2 of fs26.readdirSync(worktreesRoot, { withFileTypes: true })) {
+    for (const entry2 of fs27.readdirSync(worktreesRoot, { withFileTypes: true })) {
       if (!entry2.isDirectory() || !entry2.name.includes(suffix)) continue;
-      const sessionDir = path25.join(worktreesRoot, entry2.name);
+      const sessionDir = path26.join(worktreesRoot, entry2.name);
       if (!sameGitCheckout(harnessRoot, sessionDir)) continue;
-      sessionEnvFiles.push(path25.join(sessionDir, relPrefix, `.env.agent.${agentId}`));
+      sessionEnvFiles.push(path26.join(sessionDir, relPrefix, `.env.agent.${agentId}`));
     }
   }
   const candidates = [
-    path25.join(worktreeDir, `.env.agent.${agentId}`),
-    path25.join(harnessRoot, `.env.agent.${agentId}`),
+    path26.join(worktreeDir, `.env.agent.${agentId}`),
+    path26.join(harnessRoot, `.env.agent.${agentId}`),
     ...sessionEnvFiles.sort()
   ];
   for (const envFile of candidates) {
-    if (!fs26.existsSync(envFile)) continue;
-    const content = fs26.readFileSync(envFile, "utf8");
+    if (!fs27.existsSync(envFile)) continue;
+    const content = fs27.readFileSync(envFile, "utf8");
     const match = content.match(/^REPO_ROOT=(.+)$/m);
     if (match) return match[1].trim();
   }
@@ -28892,11 +29013,11 @@ function createRun(ctx, meta) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const runId = crypto2.randomUUID();
   const relativePath = buildRunRelativePath(meta.stageId, meta.agentId, startedAt, runId, runsDir);
-  const runFilePath = path25.join(runsDir, relativePath);
-  fs26.mkdirSync(path25.dirname(runFilePath), { recursive: true });
+  const runFilePath = path26.join(runsDir, relativePath);
+  fs27.mkdirSync(path26.dirname(runFilePath), { recursive: true });
   const run2 = RunRecordSchema.parse({
     runId,
-    repoPath: path25.resolve(ctx.repoPath),
+    repoPath: path26.resolve(ctx.repoPath),
     harnessRoot,
     stageId: meta.stageId,
     kind: meta.kind,
@@ -28907,7 +29028,7 @@ function createRun(ctx, meta) {
     relativePath,
     trigger: ctx.trigger ?? "cli"
   });
-  fs26.writeFileSync(runFilePath, JSON.stringify(run2, null, 2) + "\n");
+  fs27.writeFileSync(runFilePath, JSON.stringify(run2, null, 2) + "\n");
   return run2;
 }
 function finishRun(repoPath, runId, update) {
@@ -28926,13 +29047,13 @@ function finishRun(repoPath, runId, update) {
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const runPath = resolveRunFilePath(harnessRoot, finished);
-  fs26.writeFileSync(runPath, JSON.stringify(finished, null, 2) + "\n");
+  fs27.writeFileSync(runPath, JSON.stringify(finished, null, 2) + "\n");
   return finished;
 }
 function findRunRecord(harnessRoot, runId) {
   const runsDir = getRunsDir(harnessRoot);
   for (const filePath of collectRunFiles(runsDir)) {
-    const parsed = RunRecordSchema.safeParse(JSON.parse(fs26.readFileSync(filePath, "utf8")));
+    const parsed = RunRecordSchema.safeParse(JSON.parse(fs27.readFileSync(filePath, "utf8")));
     if (parsed.success && parsed.data.runId === runId) {
       return parsed.data;
     }
@@ -28944,10 +29065,10 @@ function getRun(repoPath, runId) {
 }
 function listRuns(repoPath, filter = {}) {
   const runsDir = getRunsDir(resolveHarnessRoot(repoPath));
-  if (!fs26.existsSync(runsDir)) return [];
+  if (!fs27.existsSync(runsDir)) return [];
   const runs = [];
   for (const filePath of collectRunFiles(runsDir)) {
-    const parsed = RunRecordSchema.safeParse(JSON.parse(fs26.readFileSync(filePath, "utf8")));
+    const parsed = RunRecordSchema.safeParse(JSON.parse(fs27.readFileSync(filePath, "utf8")));
     if (!parsed.success) continue;
     if (filter.stageId && parsed.data.stageId !== filter.stageId) continue;
     runs.push(parsed.data);
@@ -28960,17 +29081,17 @@ function listRuns(repoPath, filter = {}) {
 }
 
 // src/core/slot-preflight.ts
-var path29 = __toESM(require("path"));
+var path30 = __toESM(require("path"));
 
 // src/core/control-port.ts
 var import_child_process4 = require("child_process");
-var fs28 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
 
 // src/core/slot-ports.ts
 var import_child_process3 = require("child_process");
-var fs27 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 function portStep(env3) {
   return Number(env3.HARNESS_PORT_STEP ?? 10);
 }
@@ -29026,7 +29147,7 @@ function allocateAppPorts(repoPath, agentId) {
 }
 function harnessUsesPm2(repoPath) {
   const harnessRoot = resolveHarnessRoot(repoPath);
-  return fs27.existsSync(path26.join(harnessRoot, ".har", "ecosystem.agent.template.cjs"));
+  return fs28.existsSync(path27.join(harnessRoot, ".har", "ecosystem.agent.template.cjs"));
 }
 
 // src/core/control-port.ts
@@ -29081,13 +29202,13 @@ function controlDefaultPortWarnings(containers, defaultFrontendPort, allocatedFr
   return [formatControlDefaultPortWarning(control.name, defaultFrontendPort, allocatedFrontend)];
 }
 function inspectControlUpReadiness(repoPath) {
-  const resolved = path27.resolve(repoPath);
+  const resolved = path28.resolve(repoPath);
   const port = parseControlHostPort();
   const containers = listDockerContainers();
   const control = controlContainerOnPort(containers, port);
   const warnings = [];
-  const controlHarnessDir = path27.join(resolved, "control", ".har");
-  const harnessSlot1Active = fs28.existsSync(controlHarnessDir) && readSlotRegistry(path27.join(resolved, "control"), 1)?.status === "active";
+  const controlHarnessDir = path28.join(resolved, "control", ".har");
+  const harnessSlot1Active = fs29.existsSync(controlHarnessDir) && readSlotRegistry(path28.join(resolved, "control"), 1)?.status === "active";
   if (control) {
     return {
       warnings,
@@ -29118,9 +29239,9 @@ function inspectControlUpReadiness(repoPath) {
 }
 
 // src/core/slot-launch-guard-occupied.ts
-var fs29 = __toESM(require("fs"));
+var fs30 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path28 = __toESM(require("path"));
+var path29 = __toESM(require("path"));
 var import_child_process5 = require("child_process");
 function runGit(cwd, args) {
   try {
@@ -29139,7 +29260,7 @@ function worktreeDirty(worktreePath) {
 }
 function gitCommonDir2(cwd) {
   const out = runGit(cwd, "rev-parse --git-common-dir");
-  return out ? path28.resolve(cwd, out) : void 0;
+  return out ? path29.resolve(cwd, out) : void 0;
 }
 function sameGitCheckout2(a2, b2) {
   const left2 = gitCommonDir2(a2);
@@ -29148,20 +29269,20 @@ function sameGitCheckout2(a2, b2) {
 }
 function discoverWorktree(harnessRoot, agentId, projectName) {
   const session = readSlotRegistry(harnessRoot, agentId);
-  if (session?.worktreePath && fs29.existsSync(session.worktreePath)) {
+  if (session?.worktreePath && fs30.existsSync(session.worktreePath)) {
     return session.worktreePath;
   }
-  const legacy = path28.join(os6.homedir(), "worktrees", `${projectName}-agent-${agentId}`);
-  if (fs29.existsSync(legacy) && sameGitCheckout2(harnessRoot, legacy)) return legacy;
-  const worktreesRoot = path28.join(os6.homedir(), "worktrees");
-  if (!fs29.existsSync(worktreesRoot)) return void 0;
+  const legacy = path29.join(os6.homedir(), "worktrees", `${projectName}-agent-${agentId}`);
+  if (fs30.existsSync(legacy) && sameGitCheckout2(harnessRoot, legacy)) return legacy;
+  const worktreesRoot = path29.join(os6.homedir(), "worktrees");
+  if (!fs30.existsSync(worktreesRoot)) return void 0;
   const suffix = `-har-agent-${agentId}-`;
   const relPrefix = runGit(harnessRoot, "rev-parse --show-prefix") ?? "";
-  for (const name of fs29.readdirSync(worktreesRoot)) {
+  for (const name of fs30.readdirSync(worktreesRoot)) {
     if (!name.includes(suffix)) continue;
-    const candidate = path28.join(worktreesRoot, name);
+    const candidate = path29.join(worktreesRoot, name);
     if (!sameGitCheckout2(harnessRoot, candidate)) continue;
-    if (!fs29.existsSync(path28.join(candidate, relPrefix, `.env.agent.${agentId}`))) continue;
+    if (!fs30.existsSync(path29.join(candidate, relPrefix, `.env.agent.${agentId}`))) continue;
     return candidate;
   }
   return void 0;
@@ -29169,13 +29290,13 @@ function discoverWorktree(harnessRoot, agentId, projectName) {
 function collectOccupiedSlot(repoPath, agentId) {
   const harnessRoot = resolveHarnessRoot(repoPath);
   const env3 = readHarnessEnv(harnessRoot);
-  const projectName = env3.HARNESS_PROJECT_NAME ?? path28.basename(harnessRoot);
+  const projectName = env3.HARNESS_PROJECT_NAME ?? path29.basename(harnessRoot);
   const session = readSlotRegistry(harnessRoot, agentId);
   const worktreePath = discoverWorktree(harnessRoot, agentId, projectName);
   const workDir = session?.workDir;
-  const envInWorkDir = workDir ? fs29.existsSync(path28.join(workDir, `.env.agent.${agentId}`)) : false;
-  const envInRoot = fs29.existsSync(path28.join(harnessRoot, `.env.agent.${agentId}`));
-  const envInWorktree = worktreePath ? fs29.existsSync(path28.join(worktreePath, `.env.agent.${agentId}`)) : false;
+  const envInWorkDir = workDir ? fs30.existsSync(path29.join(workDir, `.env.agent.${agentId}`)) : false;
+  const envInRoot = fs30.existsSync(path29.join(harnessRoot, `.env.agent.${agentId}`));
+  const envInWorktree = worktreePath ? fs30.existsSync(path29.join(worktreePath, `.env.agent.${agentId}`)) : false;
   const active = session !== void 0 && session.status !== "completed" || envInWorkDir || envInRoot || envInWorktree;
   if (!active) return void 0;
   const dirty = worktreePath ? worktreeDirty(worktreePath) : void 0;
@@ -29328,7 +29449,7 @@ function checkInfraPort(env3, varName, defaultPort, scanStart, scanEnd) {
 function inspectSlotReadiness(repoPath, agentId, options = {}) {
   const harnessRoot = resolveHarnessRoot(repoPath);
   const env3 = readHarnessEnv(harnessRoot);
-  const projectName = env3.HARNESS_PROJECT_NAME ?? path29.basename(harnessRoot);
+  const projectName = env3.HARNESS_PROJECT_NAME ?? path30.basename(harnessRoot);
   const usesPm2 = harnessUsesPm2(repoPath);
   const blockers = [];
   const remediations = [];
@@ -29530,7 +29651,7 @@ function readWorktreeBranch(worktreePath) {
 }
 function gitCommonDir3(cwd) {
   const out = runGit2(cwd, "rev-parse --git-common-dir");
-  return out ? path30.resolve(cwd, out) : void 0;
+  return out ? path31.resolve(cwd, out) : void 0;
 }
 function sameGitCheckout3(a2, b2) {
   const left2 = gitCommonDir3(a2);
@@ -29542,12 +29663,12 @@ function gitPrefix2(cwd) {
   return out ?? "";
 }
 function discoverSessionWorktreePath(harnessRoot, agentId) {
-  const worktreesRoot = path30.join(os7.homedir(), "worktrees");
-  if (!fs30.existsSync(worktreesRoot)) return void 0;
+  const worktreesRoot = path31.join(os7.homedir(), "worktrees");
+  if (!fs31.existsSync(worktreesRoot)) return void 0;
   const suffix = `-har-agent-${agentId}-`;
   const relPrefix = gitPrefix2(harnessRoot);
-  const matches = fs30.readdirSync(worktreesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.includes(suffix)).map((entry) => path30.join(worktreesRoot, entry.name)).filter(
-    (candidate) => sameGitCheckout3(harnessRoot, candidate) && fs30.existsSync(path30.join(candidate, relPrefix, `.env.agent.${agentId}`))
+  const matches = fs31.readdirSync(worktreesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.includes(suffix)).map((entry) => path31.join(worktreesRoot, entry.name)).filter(
+    (candidate) => sameGitCheckout3(harnessRoot, candidate) && fs31.existsSync(path31.join(candidate, relPrefix, `.env.agent.${agentId}`))
   );
   return matches.sort()[0];
 }
@@ -29622,18 +29743,18 @@ function detectPm2Issue(projectName, agentId, session, procs) {
 }
 function collectSlotStatus(harnessRoot, agentId, runs, pm2Procs) {
   const env3 = readHarnessEnv(harnessRoot);
-  const projectName = env3.HARNESS_PROJECT_NAME ?? path30.basename(harnessRoot);
+  const projectName = env3.HARNESS_PROJECT_NAME ?? path31.basename(harnessRoot);
   const session = readSlotRegistry(harnessRoot, agentId);
-  const legacyWorktreePath = path30.join(
+  const legacyWorktreePath = path31.join(
     os7.homedir(),
     "worktrees",
     `${projectName}-agent-${agentId}`
   );
-  const worktreePath = session?.worktreePath && fs30.existsSync(session.worktreePath) ? session.worktreePath : fs30.existsSync(legacyWorktreePath) ? legacyWorktreePath : discoverSessionWorktreePath(harnessRoot, agentId);
+  const worktreePath = session?.worktreePath && fs31.existsSync(session.worktreePath) ? session.worktreePath : fs31.existsSync(legacyWorktreePath) ? legacyWorktreePath : discoverSessionWorktreePath(harnessRoot, agentId);
   const workDir = resolveAgentWorkDir(harnessRoot, agentId);
-  const envInWorkDir = workDir ? fs30.existsSync(path30.join(workDir, `.env.agent.${agentId}`)) : false;
-  const envInRoot = fs30.existsSync(path30.join(harnessRoot, `.env.agent.${agentId}`));
-  const envInWorktree = worktreePath ? fs30.existsSync(path30.join(worktreePath, `.env.agent.${agentId}`)) : false;
+  const envInWorkDir = workDir ? fs31.existsSync(path31.join(workDir, `.env.agent.${agentId}`)) : false;
+  const envInRoot = fs31.existsSync(path31.join(harnessRoot, `.env.agent.${agentId}`));
+  const envInWorktree = worktreePath ? fs31.existsSync(path31.join(worktreePath, `.env.agent.${agentId}`)) : false;
   const active = session !== void 0 && session.status !== "completed" || envInWorkDir || envInRoot || envInWorktree;
   const latest = latestRunForAgent(runs, agentId);
   const verifyRun = runs.find((r2) => r2.agentId === agentId && r2.stageId === "verify");
@@ -29686,7 +29807,7 @@ function collectEnvironmentStatus(repoPath) {
   const slotIds = getAgentSlotIds(harnessRoot);
   const pm2Procs = listPm2Processes2();
   return {
-    repoPath: path30.resolve(repoPath),
+    repoPath: path31.resolve(repoPath),
     harnessRoot,
     gitRemote: readGitRemote(harnessRoot),
     profile: manifest?.profile,
@@ -29697,13 +29818,13 @@ function collectEnvironmentStatus(repoPath) {
 
 // src/core/validations.ts
 var crypto3 = __toESM(require("crypto"));
-var fs32 = __toESM(require("fs"));
-var path32 = __toESM(require("path"));
+var fs33 = __toESM(require("fs"));
+var path33 = __toESM(require("path"));
 
 // src/core/change-batch.ts
-var fs31 = __toESM(require("fs"));
+var fs32 = __toESM(require("fs"));
 var os8 = __toESM(require("os"));
-var path31 = __toESM(require("path"));
+var path32 = __toESM(require("path"));
 function git(checkoutDir, args, env3) {
   const result = run(`git ${args}`, { cwd: checkoutDir, env: env3 });
   if (result.code !== 0) {
@@ -29719,7 +29840,7 @@ function isCheckoutRoot(checkoutDir) {
   const toplevel = tryGit(checkoutDir, "rev-parse --show-toplevel");
   if (!toplevel) return false;
   try {
-    return fs31.realpathSync(toplevel) === fs31.realpathSync(checkoutDir);
+    return fs32.realpathSync(toplevel) === fs32.realpathSync(checkoutDir);
   } catch {
     return false;
   }
@@ -29741,7 +29862,7 @@ function isMergeOrRebaseInProgress(checkoutDir) {
   if (tryGit(checkoutDir, "rev-parse -q --verify MERGE_HEAD") !== void 0) return true;
   for (const dir of ["rebase-merge", "rebase-apply"]) {
     const gitPath = tryGit(checkoutDir, `rev-parse --git-path ${dir}`);
-    if (gitPath && fs31.existsSync(path31.resolve(checkoutDir, gitPath))) return true;
+    if (gitPath && fs32.existsSync(path32.resolve(checkoutDir, gitPath))) return true;
   }
   return false;
 }
@@ -29764,8 +29885,8 @@ function parseNameStatus(output) {
   return files;
 }
 function computeWorktreeSnapshot(checkoutDir) {
-  const tmpDir = fs31.mkdtempSync(path31.join(os8.tmpdir(), "har-idx-"));
-  const tmpIndex = path31.join(tmpDir, "index");
+  const tmpDir = fs32.mkdtempSync(path32.join(os8.tmpdir(), "har-idx-"));
+  const tmpIndex = path32.join(tmpDir, "index");
   const env3 = { GIT_INDEX_FILE: tmpIndex };
   try {
     const headTree = getHeadTree(checkoutDir);
@@ -29788,35 +29909,35 @@ function computeWorktreeSnapshot(checkoutDir) {
       changedFiles: parseNameStatus(diffOutput)
     };
   } finally {
-    fs31.rmSync(tmpDir, { recursive: true, force: true });
+    fs32.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 
 // src/core/validations.ts
 var VALIDATIONS_DIR = "validations";
 function getValidationsDir(checkoutDir) {
-  return path32.join(checkoutDir, ".har", VALIDATIONS_DIR);
+  return path33.join(checkoutDir, ".har", VALIDATIONS_DIR);
 }
 function validationPath(checkoutDir, treeHash) {
-  return path32.join(getValidationsDir(checkoutDir), `${treeHash}.json`);
+  return path33.join(getValidationsDir(checkoutDir), `${treeHash}.json`);
 }
 function writeRecord(checkoutDir, record2) {
   const dir = getValidationsDir(checkoutDir);
-  fs32.mkdirSync(dir, { recursive: true });
-  fs32.writeFileSync(
+  fs33.mkdirSync(dir, { recursive: true });
+  fs33.writeFileSync(
     validationPath(checkoutDir, record2.treeHash),
     `${JSON.stringify(record2, null, 2)}
 `
   );
 }
 function ensureValidationsIgnored(checkoutDir) {
-  const harDir = path32.join(checkoutDir, ".har");
-  if (!fs32.existsSync(harDir)) return;
-  const gitignorePath = path32.join(harDir, ".gitignore");
-  const content = fs32.existsSync(gitignorePath) ? fs32.readFileSync(gitignorePath, "utf8") : "";
+  const harDir = path33.join(checkoutDir, ".har");
+  if (!fs33.existsSync(harDir)) return;
+  const gitignorePath = path33.join(harDir, ".gitignore");
+  const content = fs33.existsSync(gitignorePath) ? fs33.readFileSync(gitignorePath, "utf8") : "";
   if (content.split("\n").some((line) => line.trim() === `${VALIDATIONS_DIR}/`)) return;
   const suffix = content.length === 0 || content.endsWith("\n") ? "" : "\n";
-  fs32.writeFileSync(gitignorePath, `${content}${suffix}${VALIDATIONS_DIR}/
+  fs33.writeFileSync(gitignorePath, `${content}${suffix}${VALIDATIONS_DIR}/
 `);
 }
 function recordValidation(input) {
@@ -29833,8 +29954,8 @@ function recordValidation(input) {
     treeHash: snapshot.treeHash,
     headSha: snapshot.headSha,
     branch: snapshot.branch,
-    workDir: path32.resolve(input.checkoutDir),
-    harnessRoot: path32.resolve(input.harnessRoot),
+    workDir: path33.resolve(input.checkoutDir),
+    harnessRoot: path33.resolve(input.harnessRoot),
     agentId: input.agentId,
     status: input.status,
     full: input.full,
@@ -29846,16 +29967,16 @@ function recordValidation(input) {
     committedAt: existing?.committedAt
   });
   writeRecord(input.checkoutDir, record2);
-  if (path32.resolve(input.harnessRoot) !== path32.resolve(input.checkoutDir)) {
+  if (path33.resolve(input.harnessRoot) !== path33.resolve(input.checkoutDir)) {
     writeRecord(input.harnessRoot, record2);
   }
   return record2;
 }
 function findValidation(checkoutDir, treeHash) {
   const file = validationPath(checkoutDir, treeHash);
-  if (!fs32.existsSync(file)) return void 0;
+  if (!fs33.existsSync(file)) return void 0;
   try {
-    return ValidationRecordSchema.parse(JSON.parse(fs32.readFileSync(file, "utf8")));
+    return ValidationRecordSchema.parse(JSON.parse(fs33.readFileSync(file, "utf8")));
   } catch {
     return void 0;
   }
@@ -29870,19 +29991,19 @@ function attachCommit(checkoutDir, treeHash, commitSha) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeRecord(checkoutDir, updated);
-  if (record2.harnessRoot && path32.resolve(record2.harnessRoot) !== path32.resolve(checkoutDir) && fs32.existsSync(path32.join(record2.harnessRoot, ".har"))) {
+  if (record2.harnessRoot && path33.resolve(record2.harnessRoot) !== path33.resolve(checkoutDir) && fs33.existsSync(path33.join(record2.harnessRoot, ".har"))) {
     writeRecord(record2.harnessRoot, updated);
   }
   return updated;
 }
 function listValidations(harnessRoot) {
   const dir = getValidationsDir(harnessRoot);
-  if (!fs32.existsSync(dir)) return [];
+  if (!fs33.existsSync(dir)) return [];
   const records = [];
-  for (const entry of fs32.readdirSync(dir)) {
+  for (const entry of fs33.readdirSync(dir)) {
     if (!entry.endsWith(".json")) continue;
     try {
-      records.push(ValidationRecordSchema.parse(JSON.parse(fs32.readFileSync(path32.join(dir, entry), "utf8"))));
+      records.push(ValidationRecordSchema.parse(JSON.parse(fs33.readFileSync(path33.join(dir, entry), "utf8"))));
     } catch {
     }
   }
@@ -29912,14 +30033,26 @@ function createRemoteExecutor(apiUrl, apiKey) {
 }
 
 // src/core/telemetry-config.ts
-var fs33 = __toESM(require("fs"));
+var fs34 = __toESM(require("fs"));
 var os9 = __toESM(require("os"));
-var path33 = __toESM(require("path"));
+var path34 = __toESM(require("path"));
+var DEFAULT_SIGNALS_ON = {
+  metrics: true,
+  logs: true,
+  prompts: false,
+  traces: false
+};
+var DEFAULT_SIGNALS_OFF = {
+  metrics: false,
+  logs: false,
+  prompts: false,
+  traces: false
+};
 function getPreferencePath() {
   if (process.env.HAR_TELEMETRY_CONFIG_PATH) {
-    return path33.resolve(process.env.HAR_TELEMETRY_CONFIG_PATH);
+    return path34.resolve(process.env.HAR_TELEMETRY_CONFIG_PATH);
   }
-  return path33.join(os9.homedir(), ".har", "telemetry.json");
+  return path34.join(os9.homedir(), ".har", "telemetry.json");
 }
 function parseEnvOverride(raw) {
   if (raw === void 0 || raw === "") return void 0;
@@ -29928,29 +30061,46 @@ function parseEnvOverride(raw) {
   if (["1", "true", "on", "yes", "enabled"].includes(normalized)) return true;
   return void 0;
 }
+function normalizeSignals(enabled, raw) {
+  if (!enabled) return { ...DEFAULT_SIGNALS_OFF };
+  return {
+    metrics: raw?.metrics !== false,
+    logs: raw?.logs !== false,
+    prompts: raw?.prompts === true,
+    traces: raw?.traces === true
+  };
+}
 function readTelemetryPreference() {
   const preferencePath = getPreferencePath();
   try {
-    if (!fs33.existsSync(preferencePath)) {
-      return { enabled: true };
+    if (!fs34.existsSync(preferencePath)) {
+      return { enabled: true, signals: { ...DEFAULT_SIGNALS_ON } };
     }
-    const parsed = JSON.parse(fs33.readFileSync(preferencePath, "utf8"));
+    const parsed = JSON.parse(fs34.readFileSync(preferencePath, "utf8"));
+    const enabled = parsed.enabled !== false;
     return {
-      enabled: parsed.enabled !== false,
+      enabled,
+      signals: normalizeSignals(enabled, parsed.signals),
       updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : void 0
     };
   } catch {
-    return { enabled: true };
+    return { enabled: true, signals: { ...DEFAULT_SIGNALS_ON } };
   }
 }
-function writeTelemetryPreference(enabled) {
+function writeTelemetryPreference(enabled, signals) {
+  const current = readTelemetryPreference();
+  const nextSignals = normalizeSignals(enabled, {
+    ...current.signals,
+    ...signals
+  });
   const preference = {
     enabled,
+    signals: enabled ? nextSignals : { ...DEFAULT_SIGNALS_OFF },
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const preferencePath = getPreferencePath();
-  fs33.mkdirSync(path33.dirname(preferencePath), { recursive: true });
-  fs33.writeFileSync(preferencePath, JSON.stringify(preference, null, 2) + "\n");
+  fs34.mkdirSync(path34.dirname(preferencePath), { recursive: true });
+  fs34.writeFileSync(preferencePath, JSON.stringify(preference, null, 2) + "\n");
   return preference;
 }
 function isTelemetryEnabled() {
@@ -29958,23 +30108,29 @@ function isTelemetryEnabled() {
   if (envOverride !== void 0) return envOverride;
   return readTelemetryPreference().enabled;
 }
+function getTelemetrySignals() {
+  if (!isTelemetryEnabled()) return { ...DEFAULT_SIGNALS_OFF };
+  return readTelemetryPreference().signals;
+}
 function getTelemetryPreferencePath() {
   return getPreferencePath();
 }
 var TELEMETRY_SIGNALS = [
-  "Claude Code: tokens (input/output/cache) and estimated USD cost via OTEL metrics",
-  "Codex CLI: token usage via OTEL metrics (no native USD; harvest fills gaps)",
+  "Metrics (default): tokens and estimated USD cost via OTEL metrics",
+  "Logs/events (default): session events (tool calls, api_request) without prompt bodies",
+  "Prompts (opt-in): user/assistant text via OTEL_LOG_USER_PROMPTS \u2014 har telemetry on --prompts",
+  "Traces (opt-in): thin span ingest when CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1",
   "Fallback: har control sync harvests local Claude/Codex session files when OTEL is missing"
 ];
 
 // src/core/usage-harvest/claude.ts
-var fs35 = __toESM(require("fs"));
+var fs36 = __toESM(require("fs"));
 var os10 = __toESM(require("os"));
-var path35 = __toESM(require("path"));
+var path36 = __toESM(require("path"));
 
 // src/core/telemetry-env.ts
-var fs34 = __toESM(require("fs"));
-var path34 = __toESM(require("path"));
+var fs35 = __toESM(require("fs"));
+var path35 = __toESM(require("path"));
 function escapeAttrValue(value) {
   return value.replace(/[,=]/g, "_");
 }
@@ -30006,13 +30162,31 @@ function buildTelemetryEnvBlock(attrs, options) {
   ];
   const injectOtel = isTelemetryEnabled() && options?.otelReady !== false;
   if (injectOtel) {
+    const signals = getTelemetrySignals();
     lines.push(
       "# HAR telemetry \u2192 Mission Control OTLP (disable: har telemetry off)",
       "CLAUDE_CODE_ENABLE_TELEMETRY=1",
-      "OTEL_METRICS_EXPORTER=otlp",
       "OTEL_EXPORTER_OTLP_PROTOCOL=http/json",
       `OTEL_EXPORTER_OTLP_ENDPOINT=${apiUrl}/api/otel`
     );
+    if (signals.metrics) {
+      lines.push("OTEL_METRICS_EXPORTER=otlp");
+    }
+    if (signals.logs) {
+      lines.push("OTEL_LOGS_EXPORTER=otlp");
+    }
+    if (signals.prompts) {
+      lines.push(
+        "OTEL_LOG_USER_PROMPTS=1",
+        "OTEL_LOG_ASSISTANT_RESPONSES=1"
+      );
+    }
+    if (signals.traces) {
+      lines.push(
+        "OTEL_TRACES_EXPORTER=otlp",
+        "CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1"
+      );
+    }
   }
   return lines.join("\n") + "\n";
 }
@@ -30023,8 +30197,8 @@ function appendTelemetryEnvToFile(envFilePath, attrs, options) {
 ${TELEMETRY_MARKER_END}
 `;
   let existing = "";
-  if (fs34.existsSync(envFilePath)) {
-    existing = fs34.readFileSync(envFilePath, "utf8");
+  if (fs35.existsSync(envFilePath)) {
+    existing = fs35.readFileSync(envFilePath, "utf8");
     const start = existing.indexOf(TELEMETRY_MARKER_START);
     if (start >= 0) {
       const end = existing.indexOf(TELEMETRY_MARKER_END, start);
@@ -30035,9 +30209,9 @@ ${TELEMETRY_MARKER_END}
       }
     }
   }
-  fs34.mkdirSync(path34.dirname(envFilePath), { recursive: true });
+  fs35.mkdirSync(path35.dirname(envFilePath), { recursive: true });
   const combined = (existing.replace(/\n+$/, "\n") + block).replace(/^\n+/, "");
-  fs34.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
+  fs35.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
 }
 function buildCodexOtelSnippet(attrs) {
   const apiUrl = getControlApiUrl().replace(/\/$/, "");
@@ -30058,21 +30232,21 @@ metrics_exporter = "otlp-http"
 
 // src/core/usage-harvest/claude.ts
 function pathsMatch(candidate, targets) {
-  const norm = path35.resolve(candidate);
+  const norm = path36.resolve(candidate);
   return targets.some((t2) => {
-    const target = path35.resolve(t2);
-    return norm === target || norm.startsWith(target + path35.sep) || target.startsWith(norm + path35.sep);
+    const target = path36.resolve(t2);
+    return norm === target || norm.startsWith(target + path36.sep) || target.startsWith(norm + path36.sep);
   });
 }
 function claudeProjectsRoot() {
-  return process.env.HAR_CLAUDE_PROJECTS_DIR ? path35.resolve(process.env.HAR_CLAUDE_PROJECTS_DIR) : path35.join(os10.homedir(), ".claude", "projects");
+  return process.env.HAR_CLAUDE_PROJECTS_DIR ? path36.resolve(process.env.HAR_CLAUDE_PROJECTS_DIR) : path36.join(os10.homedir(), ".claude", "projects");
 }
 function encodeClaudeProjectDir(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function readJsonlRecords(filePath) {
-  if (!fs35.existsSync(filePath)) return [];
-  const lines = fs35.readFileSync(filePath, "utf8").split(/\r?\n/);
+  if (!fs36.existsSync(filePath)) return [];
+  const lines = fs36.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines) {
     const trimmed = line.trim();
@@ -30111,27 +30285,20 @@ function extractClaudeUsageFromRecords(records) {
   }
   return { tokensInput, tokensOutput, tokensCacheRead, tokensCacheCreation, costUsd };
 }
-function harvestClaudeUsage(slot) {
+function findMatchingClaudeTranscripts(slot) {
   const targets = [slot.workDir, slot.worktreePath].filter(Boolean);
-  if (targets.length === 0) return null;
+  if (targets.length === 0) return [];
   const root = claudeProjectsRoot();
-  if (!fs35.existsSync(root)) return null;
-  const sessionKey = buildSessionKey({
-    branch: slot.branch,
-    agentId: slot.agentId,
-    suffix: slot.suffix,
-    createdAt: slot.sessionCreatedAt
-  });
-  let best = null;
-  let bestMtime = 0;
-  for (const entry of fs35.readdirSync(root, { withFileTypes: true })) {
+  if (!fs36.existsSync(root)) return [];
+  const matches = [];
+  for (const entry of fs36.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const projectDir = path35.join(root, entry.name);
+    const projectDir = path36.join(root, entry.name);
     const encodedHit = targets.some((t2) => entry.name.includes(encodeClaudeProjectDir(t2).slice(0, 40)));
-    for (const file of fs35.readdirSync(projectDir)) {
+    for (const file of fs36.readdirSync(projectDir)) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = path35.join(projectDir, file);
-      const stat = fs35.statSync(filePath);
+      const filePath = path36.join(projectDir, file);
+      const stat = fs36.statSync(filePath);
       const records = readJsonlRecords(filePath);
       let cwdHit = encodedHit;
       for (const record2 of records) {
@@ -30143,16 +30310,70 @@ function harvestClaudeUsage(slot) {
         }
       }
       if (!cwdHit) continue;
-      const usage2 = extractClaudeUsageFromRecords(records);
-      if (usage2.tokensInput + usage2.tokensOutput + usage2.tokensCacheRead === 0 && (usage2.costUsd == null || usage2.costUsd === 0)) {
-        continue;
-      }
-      if (stat.mtimeMs >= bestMtime) {
-        bestMtime = stat.mtimeMs;
-        best = usage2;
-      }
+      matches.push({ filePath, records, mtimeMs: stat.mtimeMs });
     }
   }
+  return matches.sort((a2, b2) => b2.mtimeMs - a2.mtimeMs);
+}
+function extractPromptEvents(records, sessionKey, slot) {
+  const events = [];
+  let sequence = 0;
+  for (const record2 of records) {
+    if (!record2 || typeof record2 !== "object") continue;
+    const payload = record2;
+    const typ = String(payload.type ?? "");
+    const message = payload.message;
+    const role = String(message?.role ?? payload.role ?? "");
+    let text = null;
+    const content = message?.content ?? payload.content;
+    if (typeof content === "string") text = content;
+    else if (Array.isArray(content)) {
+      text = content.map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && typeof part.text === "string") {
+          return part.text;
+        }
+        return "";
+      }).filter(Boolean).join("\n");
+    }
+    if (!text || text.trim().length === 0) continue;
+    const isUser = typ === "user" || role === "user" || typ === "human" || Boolean(payload.userType);
+    const isAssistant = typ === "assistant" || role === "assistant";
+    if (!isUser && !isAssistant) continue;
+    sequence += 1;
+    const timestamp = typeof payload.timestamp === "string" ? payload.timestamp : typeof payload.ts === "string" ? payload.ts : (/* @__PURE__ */ new Date()).toISOString();
+    events.push({
+      sessionKey,
+      agentId: slot.agentId,
+      agentTool: "claude_code",
+      eventName: isUser ? "claude_code.user_prompt" : "claude_code.assistant_response",
+      sequence,
+      timestamp,
+      promptText: isUser ? text.slice(0, 8e3) : null,
+      responseText: isAssistant ? text.slice(0, 8e3) : null,
+      rawTruncated: text.slice(0, 4e3),
+      source: "harvest"
+    });
+  }
+  return events;
+}
+function harvestClaudeUsage(slot) {
+  const matches = findMatchingClaudeTranscripts(slot);
+  const sessionKey = buildSessionKey({
+    branch: slot.branch,
+    agentId: slot.agentId,
+    suffix: slot.suffix,
+    createdAt: slot.sessionCreatedAt
+  });
+  let best = null;
+  for (const match of matches) {
+    const usage2 = extractClaudeUsageFromRecords(match.records);
+    if (usage2.tokensInput + usage2.tokensOutput + usage2.tokensCacheRead === 0 && (usage2.costUsd == null || usage2.costUsd === 0)) {
+      continue;
+    }
+    best = usage2;
+    break;
+  }
   if (!best) return null;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const tokensTotal = best.tokensInput + best.tokensOutput + best.tokensCacheRead + best.tokensCacheCreation;
@@ -30174,32 +30395,44 @@ function harvestClaudeUsage(slot) {
     lastSeenAt: now
   };
 }
+function harvestClaudeEvents(slot) {
+  if (!getTelemetrySignals().prompts) return [];
+  const matches = findMatchingClaudeTranscripts(slot);
+  if (matches.length === 0) return [];
+  const sessionKey = buildSessionKey({
+    branch: slot.branch,
+    agentId: slot.agentId,
+    suffix: slot.suffix,
+    createdAt: slot.sessionCreatedAt
+  });
+  return extractPromptEvents(matches[0].records, sessionKey, slot).slice(-40);
+}
 
 // src/core/usage-harvest/codex.ts
-var fs36 = __toESM(require("fs"));
+var fs37 = __toESM(require("fs"));
 var os11 = __toESM(require("os"));
-var path36 = __toESM(require("path"));
+var path37 = __toESM(require("path"));
 function pathsMatch2(candidate, targets) {
-  const norm = path36.resolve(candidate);
+  const norm = path37.resolve(candidate);
   return targets.some((t2) => {
-    const target = path36.resolve(t2);
-    return norm === target || norm.startsWith(target + path36.sep) || target.startsWith(norm + path36.sep);
+    const target = path37.resolve(t2);
+    return norm === target || norm.startsWith(target + path37.sep) || target.startsWith(norm + path37.sep);
   });
 }
 function codexSessionsRoot() {
-  return process.env.HAR_CODEX_SESSIONS_DIR ? path36.resolve(process.env.HAR_CODEX_SESSIONS_DIR) : path36.join(os11.homedir(), ".codex", "sessions");
+  return process.env.HAR_CODEX_SESSIONS_DIR ? path37.resolve(process.env.HAR_CODEX_SESSIONS_DIR) : path37.join(os11.homedir(), ".codex", "sessions");
 }
 function walkJsonlFiles(dir, out = []) {
-  if (!fs36.existsSync(dir)) return out;
-  for (const entry of fs36.readdirSync(dir, { withFileTypes: true })) {
-    const full = path36.join(dir, entry.name);
+  if (!fs37.existsSync(dir)) return out;
+  for (const entry of fs37.readdirSync(dir, { withFileTypes: true })) {
+    const full = path37.join(dir, entry.name);
     if (entry.isDirectory()) walkJsonlFiles(full, out);
     else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(full);
   }
   return out;
 }
 function readJsonl(filePath) {
-  const lines = fs36.readFileSync(filePath, "utf8").split(/\r?\n/);
+  const lines = fs37.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines) {
     const trimmed = line.trim();
@@ -30263,7 +30496,7 @@ function harvestCodexUsage(slot) {
     const extracted = extractCodexTokens(records);
     if (!extracted.cwd || !pathsMatch2(extracted.cwd, targets)) continue;
     if (extracted.tokensInput + extracted.tokensOutput + extracted.tokensCacheRead === 0) continue;
-    const mtime = fs36.statSync(file).mtimeMs;
+    const mtime = fs37.statSync(file).mtimeMs;
     if (mtime >= bestMtime) {
       bestMtime = mtime;
       best = extracted;
@@ -30300,6 +30533,9 @@ function harvestUsageForSlot(slot) {
   if (codex) out.push(codex);
   return out;
 }
+function harvestEventsForSlot(slot) {
+  return harvestClaudeEvents(slot);
+}
 
 // src/core/control-sync.ts
 async function postJson(url, body, dryRun) {
@@ -30342,7 +30578,7 @@ async function syncAllKnownReposWithControl(options) {
   }
   const repoPaths = new Set(listRegisteredRepos());
   if (options?.cwd) {
-    const cwd = path37.resolve(options.cwd);
+    const cwd = path38.resolve(options.cwd);
     if (readManifest(cwd)) repoPaths.add(cwd);
   }
   try {
@@ -30350,7 +30586,7 @@ async function syncAllKnownReposWithControl(options) {
     if (listResponse.ok) {
       const repos = await listResponse.json();
       for (const repo of repos) {
-        const resolved = path37.resolve(repo.path);
+        const resolved = path38.resolve(repo.path);
         if (readManifest(resolved)) repoPaths.add(resolved);
       }
     }
@@ -30369,7 +30605,7 @@ async function syncAllKnownReposWithControl(options) {
   return { synced, failed };
 }
 async function registerRepoWithControl(options) {
-  const repoPath = path37.resolve(options.repoPath);
+  const repoPath = path38.resolve(options.repoPath);
   const apiUrl = options.apiUrl ?? getControlApiUrl();
   const manifest = readManifest(repoPath);
   const stagesRegistry = readStageRegistry(repoPath);
@@ -30382,7 +30618,7 @@ async function registerRepoWithControl(options) {
   return postJson(`${apiUrl}/api/repos`, body, options.dryRun);
 }
 async function syncRepoWithControl(options) {
-  const repoPath = path37.resolve(options.repoPath);
+  const repoPath = path38.resolve(options.repoPath);
   const apiUrl = options.apiUrl ?? getControlApiUrl();
   if (options.cloud) {
     const remote = createRemoteExecutor();
@@ -30410,7 +30646,7 @@ async function syncRepoWithControl(options) {
     const listResponse = await fetch(`${apiUrl}/api/repos`);
     if (!listResponse.ok) throw new Error("Failed to list repos from Control API");
     const repos = await listResponse.json();
-    const existing = repos.find((r2) => path37.resolve(r2.path) === repoPath);
+    const existing = repos.find((r2) => path38.resolve(r2.path) === repoPath);
     if (!existing) throw new Error(`Repo not registered: ${repoPath}`);
     await syncRepoRunsAndSlots(apiUrl, existing.id, repoPath, options.dryRun);
     return;
@@ -30454,6 +30690,21 @@ async function syncRepoRunsAndSlots(apiUrl, repoId, repoPath, dryRun) {
         const usageBody = SyncUsageInputSchema.parse({ usage: usage2 });
         await postJson(`${apiUrl}/api/repos/${repoId}/usage`, usageBody, dryRun);
       }
+      const events = status.slots.flatMap(
+        (slot) => harvestEventsForSlot({
+          agentId: slot.agentId,
+          workDir: slot.workDir,
+          worktreePath: slot.worktreePath,
+          branch: slot.branch,
+          suffix: slot.suffix,
+          sessionCreatedAt: slot.sessionCreatedAt,
+          repoPath
+        })
+      );
+      if (events.length > 0) {
+        const eventsBody = SyncSessionEventsInputSchema.parse({ events });
+        await postJson(`${apiUrl}/api/repos/${repoId}/events`, eventsBody, dryRun);
+      }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       process.stderr.write(`[har control] usage harvest skipped: ${message}
@@ -30514,7 +30765,7 @@ function checkLaunchGuard2(repoPath, agentId, options = {}) {
 
 // src/core/control-lifecycle.ts
 var import_child_process8 = require("child_process");
-var path38 = __toESM(require("path"));
+var path39 = __toESM(require("path"));
 
 // src/core/control-image.ts
 var DEFAULT_CONTROL_IMAGE = "theosfactory/har-control";
@@ -30537,10 +30788,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 path38.resolve(__dirname, "..", "control");
+  return path39.resolve(__dirname, "..", "control");
 }
 function resolveControlBuildContext() {
-  return path38.resolve(resolveControlDir(), "..");
+  return path39.resolve(resolveControlDir(), "..");
 }
 function buildDockerRunArgs(options) {
   const name = options.containerName ?? CONTROL_CONTAINER_NAME;
@@ -30596,7 +30847,7 @@ async function startMissionControl(options) {
       "-t",
       imageRef,
       "-f",
-      path38.join(resolveControlDir(), "Dockerfile"),
+      path39.join(resolveControlDir(), "Dockerfile"),
       resolveControlBuildContext()
     ]);
     if (buildCode !== 0) {
@@ -30738,7 +30989,7 @@ async function ensureTelemetryInfrastructure(options) {
 }
 
 // src/core/run-service.ts
-var path39 = __toESM(require("path"));
+var path40 = __toESM(require("path"));
 function extractShellOutput(result) {
   const stdout = result.logs?.find((log) => log.stream === "stdout")?.content ?? result.logs?.find((log) => !log.stream)?.content ?? "";
   const stderr = result.logs?.find((log) => log.stream === "stderr")?.content ?? "";
@@ -30902,14 +31153,14 @@ Usage from Claude Code / Codex will appear under Worktrees. Disable: har telemet
           suffix: session.suffix,
           createdAt: session.createdAt
         });
-        const envFile = path39.join(session.workDir, `.env.agent.${options.agentId}`);
+        const envFile = path40.join(session.workDir, `.env.agent.${options.agentId}`);
         try {
           appendTelemetryEnvToFile(
             envFile,
             {
               sessionKey,
               agentId: options.agentId,
-              repoPath: path39.resolve(options.repoPath),
+              repoPath: path40.resolve(options.repoPath),
               workDir: session.workDir,
               branch: session.branch,
               suffix: session.suffix,
@@ -31275,7 +31526,7 @@ var envCommand = {
   }
 };
 async function handleInit(argv) {
-  const repoPath = path40.resolve(argv.repo);
+  const repoPath = path41.resolve(argv.repo);
   header("har env init");
   info(`Repository: ${repoPath}`);
   try {
@@ -31333,7 +31584,7 @@ async function handleInit(argv) {
   }
 }
 async function handleMaintain(argv) {
-  const repoPath = path40.resolve(argv.repo);
+  const repoPath = path41.resolve(argv.repo);
   header("har env maintain");
   info(`Repository: ${repoPath}`);
   try {
@@ -31431,7 +31682,7 @@ async function handleAgentMdProposal(repoPath, autoYes) {
   if (autoYes) {
     const proposal = readAgentMdProposal(repoPath);
     if (proposal) {
-      writeFileSafe(path40.join(repoPath, "AGENT.md"), proposal.content);
+      writeFileSafe(path41.join(repoPath, "AGENT.md"), proposal.content);
       clearAgentMdProposal(repoPath);
       info("Applied AGENT.md proposal (--yes)");
     }
@@ -31440,7 +31691,7 @@ async function handleAgentMdProposal(repoPath, autoYes) {
   await promptApplyAgentMdProposal(repoPath);
 }
 async function handleAddStage(argv) {
-  const repoPath = path40.resolve(argv.repo);
+  const repoPath = path41.resolve(argv.repo);
   const available = listStageTemplateIds();
   if (argv.list) {
     for (const id of available) {
@@ -31517,7 +31768,7 @@ async function handleAddStage(argv) {
   }
 }
 async function handlePreflight(argv) {
-  const repo = path40.resolve(argv.repo);
+  const repo = path41.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await preflightEnvironment({
     repoPath: repo,
@@ -31535,7 +31786,7 @@ async function handlePreflight(argv) {
   process.exit(result.code);
 }
 async function handleLaunch(argv) {
-  const repo = path40.resolve(argv.repo);
+  const repo = path41.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   let confirmReplace = argv.replace;
   let force = argv.force;
@@ -31619,7 +31870,7 @@ async function handleRecover(argv) {
   });
 }
 async function handleVerify(argv) {
-  const repo = path40.resolve(argv.repo);
+  const repo = path41.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await runVerification({
     repoPath: repo,
@@ -31631,7 +31882,7 @@ async function handleVerify(argv) {
   process.exit(result.code);
 }
 async function handleTeardown(argv) {
-  const repo = path40.resolve(argv.repo);
+  const repo = path41.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await teardownEnvironment({
     repoPath: repo,
@@ -31642,7 +31893,7 @@ async function handleTeardown(argv) {
   process.exit(result.code);
 }
 async function handleComplete(argv) {
-  const repo = path40.resolve(argv.repo);
+  const repo = path41.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await completeEnvironment({
     repoPath: repo,
@@ -31663,7 +31914,7 @@ async function handleComplete(argv) {
   process.exit(result.code);
 }
 async function handleStatus(argv) {
-  const repoPath = path40.resolve(argv.repo);
+  const repoPath = path41.resolve(argv.repo);
   if (argv.json) {
     const status = collectEnvironmentStatus(repoPath);
     const output = EnvironmentStatusSchema.parse(status);
@@ -31676,7 +31927,7 @@ async function handleStatus(argv) {
   });
 }
 async function handleRunsList(argv) {
-  const repoPath = path40.resolve(argv.repo);
+  const repoPath = path41.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");
@@ -31693,7 +31944,7 @@ async function handleRunsList(argv) {
   }
 }
 async function handleRunsGet(argv) {
-  const run2 = getRun(path40.resolve(argv.repo), argv.runId);
+  const run2 = getRun(path41.resolve(argv.repo), argv.runId);
   if (!run2) {
     error(`Run not found: ${argv.runId}`);
     process.exit(1);
@@ -31734,7 +31985,13 @@ function printDrift(drift) {
     );
     warn("  See maintain/templates/harness.env in the maintenance bundle.");
   }
-  if (!drift.generatorVersion.outdated && drift.checksumMismatch.length === 0 && drift.missing.length === 0 && drift.extra.length === 0 && drift.missingPortVars.length === 0) {
+  if (drift.agentSlotMismatch) {
+    warn(
+      `  Agent slot limits disagree: stages.json ${drift.agentSlotMismatch.stages.min}\u2013${drift.agentSlotMismatch.stages.max}, harness.env ${drift.agentSlotMismatch.env.min}\u2013${drift.agentSlotMismatch.env.max}`
+    );
+    warn("  Canonical source is .har/stages.json \u2014 har env maintain --finalize syncs harness.env.");
+  }
+  if (!drift.generatorVersion.outdated && drift.checksumMismatch.length === 0 && drift.missing.length === 0 && drift.extra.length === 0 && drift.missingPortVars.length === 0 && !drift.agentSlotMismatch) {
     success("  Harness matches bundled templates");
   }
 }
@@ -31766,7 +32023,7 @@ function printNextSteps(auto2) {
 }
 
 // src/cli/commands/control.ts
-var path41 = __toESM(require("path"));
+var path42 = __toESM(require("path"));
 var controlCommand = {
   command: "control <subcommand>",
   describe: "Mission Control dashboard (local)",
@@ -31869,7 +32126,7 @@ async function handleDown() {
   process.exit(code);
 }
 async function handleRegister(argv) {
-  const repoPath = path41.resolve(argv.repo);
+  const repoPath = path42.resolve(argv.repo);
   header("har control register");
   info(`Repository: ${repoPath}`);
   try {
@@ -31889,7 +32146,7 @@ async function handleRegister(argv) {
   }
 }
 async function handleSync(argv) {
-  const repoPath = path41.resolve(argv.repo);
+  const repoPath = path42.resolve(argv.repo);
   try {
     await syncRepoWithControl({
       repoPath,
@@ -31928,7 +32185,7 @@ async function handleWatch(argv) {
   };
   const tick = async () => {
     if (argv.repo) {
-      await syncOne(path41.resolve(argv.repo));
+      await syncOne(path42.resolve(argv.repo));
       return;
     }
     try {
@@ -31959,12 +32216,12 @@ async function handleLogin(argv) {
 }
 
 // src/cli/commands/hooks.ts
-var path44 = __toESM(require("path"));
+var path45 = __toESM(require("path"));
 
 // src/core/hooks.ts
-var fs37 = __toESM(require("fs"));
+var fs38 = __toESM(require("fs"));
 var os12 = __toESM(require("os"));
-var path42 = __toESM(require("path"));
+var path43 = __toESM(require("path"));
 var MARKER_START = "# >>> har commit gate (managed by `har hooks`) >>>";
 var MARKER_END = "# <<< har commit gate <<<";
 var PRE_COMMIT_BLOCK = [
@@ -31989,7 +32246,7 @@ function resolveCheckoutRoot(cwd) {
 function resolveHooksDir(checkoutDir) {
   const hooksPath = tryGit2(checkoutDir, "rev-parse --git-path hooks");
   if (!hooksPath) throw new Error(`Not a git checkout: ${checkoutDir}`);
-  return path42.resolve(checkoutDir, hooksPath);
+  return path43.resolve(checkoutDir, hooksPath);
 }
 function getConfiguredHooksPath(checkoutDir) {
   return tryGit2(checkoutDir, "config core.hooksPath") || void 0;
@@ -31997,9 +32254,9 @@ function getConfiguredHooksPath(checkoutDir) {
 function defaultHarInvocation() {
   const entry = process.argv[1];
   if (entry && entry.endsWith(".js")) {
-    return `"${process.execPath}" "${path42.resolve(entry)}"`;
+    return `"${process.execPath}" "${path43.resolve(entry)}"`;
   }
-  if (entry) return `"${path42.resolve(entry)}"`;
+  if (entry) return `"${path43.resolve(entry)}"`;
   return "har";
 }
 function buildHookScript(harInvocation, subcommand, failOpenNotice) {
@@ -32020,40 +32277,40 @@ exit 0
 `;
 }
 function upsertMarkedBlock(filePath, block) {
-  if (!fs37.existsSync(filePath)) {
-    fs37.writeFileSync(filePath, `#!/bin/sh
+  if (!fs38.existsSync(filePath)) {
+    fs38.writeFileSync(filePath, `#!/bin/sh
 ${block}
 `, { mode: 493 });
     return "created";
   }
-  const content = fs37.readFileSync(filePath, "utf8");
+  const content = fs38.readFileSync(filePath, "utf8");
   if (content.includes(MARKER_START)) {
     const pattern = new RegExp(
       `${escapeRegExp(MARKER_START)}[\\s\\S]*?${escapeRegExp(MARKER_END)}`
     );
-    fs37.writeFileSync(filePath, content.replace(pattern, block));
-    fs37.chmodSync(filePath, 493);
+    fs38.writeFileSync(filePath, content.replace(pattern, block));
+    fs38.chmodSync(filePath, 493);
     return "updated";
   }
   const suffix = content.endsWith("\n") ? "" : "\n";
-  fs37.writeFileSync(filePath, `${content}${suffix}
+  fs38.writeFileSync(filePath, `${content}${suffix}
 ${block}
 `);
-  fs37.chmodSync(filePath, 493);
+  fs38.chmodSync(filePath, 493);
   return "appended";
 }
 function removeMarkedBlock(filePath) {
-  if (!fs37.existsSync(filePath)) return false;
-  const content = fs37.readFileSync(filePath, "utf8");
+  if (!fs38.existsSync(filePath)) return false;
+  const content = fs38.readFileSync(filePath, "utf8");
   if (!content.includes(MARKER_START)) return false;
   const pattern = new RegExp(
     `\\n?${escapeRegExp(MARKER_START)}[\\s\\S]*?${escapeRegExp(MARKER_END)}\\n?`
   );
   const stripped = content.replace(pattern, "\n");
   if (stripped.replace(/^#!\/bin\/sh\n?/, "").trim() === "") {
-    fs37.rmSync(filePath);
+    fs38.rmSync(filePath);
   } else {
-    fs37.writeFileSync(filePath, stripped);
+    fs38.writeFileSync(filePath, stripped);
   }
   return true;
 }
@@ -32075,20 +32332,20 @@ Or re-run with --force to write into that directory anyway.`
     );
   }
   const hooksDir = resolveHooksDir(checkout);
-  fs37.mkdirSync(hooksDir, { recursive: true });
+  fs38.mkdirSync(hooksDir, { recursive: true });
   const invocation = options.harInvocation ?? defaultHarInvocation();
-  fs37.writeFileSync(
-    path42.join(hooksDir, "har-pre-commit"),
+  fs38.writeFileSync(
+    path43.join(hooksDir, "har-pre-commit"),
     buildHookScript(invocation, "check", "har: binary not found; skipping commit gate (reinstall with har hooks install)"),
     { mode: 493 }
   );
-  fs37.writeFileSync(
-    path42.join(hooksDir, "har-post-commit"),
+  fs38.writeFileSync(
+    path43.join(hooksDir, "har-post-commit"),
     buildHookScript(invocation, "record-commit", "har: binary not found; skipping commit association"),
     { mode: 493 }
   );
-  const preCommit = upsertMarkedBlock(path42.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
-  const postCommit = upsertMarkedBlock(path42.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
+  const preCommit = upsertMarkedBlock(path43.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
+  const postCommit = upsertMarkedBlock(path43.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
   ensureValidationsIgnored(checkout);
   return { hooksDir, preCommit, postCommit };
 }
@@ -32097,12 +32354,12 @@ function uninstallHooks(repoPath) {
   if (!checkout) throw new Error(`Not a git repository: ${repoPath}`);
   const hooksDir = resolveHooksDir(checkout);
   let removed = false;
-  removed = removeMarkedBlock(path42.join(hooksDir, "pre-commit")) || removed;
-  removed = removeMarkedBlock(path42.join(hooksDir, "post-commit")) || removed;
+  removed = removeMarkedBlock(path43.join(hooksDir, "pre-commit")) || removed;
+  removed = removeMarkedBlock(path43.join(hooksDir, "post-commit")) || removed;
   for (const file of ["har-pre-commit", "har-post-commit"]) {
-    const full = path42.join(hooksDir, file);
-    if (fs37.existsSync(full)) {
-      fs37.rmSync(full);
+    const full = path43.join(hooksDir, file);
+    if (fs38.existsSync(full)) {
+      fs38.rmSync(full);
       removed = true;
     }
   }
@@ -32119,9 +32376,9 @@ function getCommitGateConfig(checkoutDir) {
 function isAgentWorktree(checkoutDir) {
   const branch = getCurrentBranch(checkoutDir);
   if (branch && /^har-agent-\d+$/.test(branch)) return true;
-  const worktreesRoot = path42.join(os12.homedir(), "worktrees");
-  const resolved = path42.resolve(checkoutDir);
-  return resolved.startsWith(`${worktreesRoot}${path42.sep}`) && /-agent-\d+$/.test(path42.basename(resolved));
+  const worktreesRoot = path43.join(os12.homedir(), "worktrees");
+  const resolved = path43.resolve(checkoutDir);
+  return resolved.startsWith(`${worktreesRoot}${path43.sep}`) && /-agent-\d+$/.test(path43.basename(resolved));
 }
 function resolveEffectiveMode(checkoutDir, gate) {
   if (!gate.enabled) return "off";
@@ -32134,15 +32391,15 @@ function getHooksStatus(repoPath) {
   const hooksDir = resolveHooksDir(checkout);
   const gate = getCommitGateConfig(checkout);
   const hasBlock = (name) => {
-    const file = path42.join(hooksDir, name);
-    return fs37.existsSync(file) && fs37.readFileSync(file, "utf8").includes(MARKER_START);
+    const file = path43.join(hooksDir, name);
+    return fs38.existsSync(file) && fs38.readFileSync(file, "utf8").includes(MARKER_START);
   };
   return {
     checkout,
     hooksDir,
     configuredHooksPath: getConfiguredHooksPath(checkout),
-    preCommitInstalled: hasBlock("pre-commit") && fs37.existsSync(path42.join(hooksDir, "har-pre-commit")),
-    postCommitInstalled: hasBlock("post-commit") && fs37.existsSync(path42.join(hooksDir, "har-post-commit")),
+    preCommitInstalled: hasBlock("pre-commit") && fs38.existsSync(path43.join(hooksDir, "har-pre-commit")),
+    postCommitInstalled: hasBlock("post-commit") && fs38.existsSync(path43.join(hooksDir, "har-post-commit")),
     gate,
     effectiveMode: resolveEffectiveMode(checkout, gate)
   };
@@ -32153,7 +32410,7 @@ function checkCommitGate(cwd) {
   }
   const checkout = resolveCheckoutRoot(cwd);
   if (!checkout) return { exitCode: 0, messages: [] };
-  if (!fs37.existsSync(path42.join(checkout, ".har", "stages.json"))) {
+  if (!fs38.existsSync(path43.join(checkout, ".har", "stages.json"))) {
     return { exitCode: 0, messages: [] };
   }
   const gate = getCommitGateConfig(checkout);
@@ -32224,8 +32481,8 @@ async function recordCommitAssociation(cwd) {
 }
 
 // src/core/claude-hooks.ts
-var fs38 = __toESM(require("fs"));
-var path43 = __toESM(require("path"));
+var fs39 = __toESM(require("fs"));
+var path44 = __toESM(require("path"));
 var CLAUDE_GUARD_RELATIVE_PATH = ".har/hooks/claude-worktree-guard.sh";
 var CLAUDE_SETTINGS_RELATIVE_PATH = ".claude/settings.json";
 var GUARD_MATCHER = "Edit|Write|MultiEdit|NotebookEdit";
@@ -32236,8 +32493,8 @@ function isHarGuardEntry(entry) {
   );
 }
 function readSettings(settingsPath) {
-  if (!fs38.existsSync(settingsPath)) return {};
-  const raw = fs38.readFileSync(settingsPath, "utf8").trim();
+  if (!fs39.existsSync(settingsPath)) return {};
+  const raw = fs39.readFileSync(settingsPath, "utf8").trim();
   if (raw === "") return {};
   const parsed = JSON.parse(raw);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -32246,19 +32503,19 @@ function readSettings(settingsPath) {
   return parsed;
 }
 function writeSettings(settingsPath, settings) {
-  fs38.mkdirSync(path43.dirname(settingsPath), { recursive: true });
-  fs38.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs39.mkdirSync(path44.dirname(settingsPath), { recursive: true });
+  fs39.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 = path43.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  fs38.mkdirSync(path43.dirname(guardScript), { recursive: true });
-  fs38.copyFileSync(templatePath, guardScript);
-  fs38.chmodSync(guardScript, 493);
-  const settingsPath = path43.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  const guardScript = path44.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  fs39.mkdirSync(path44.dirname(guardScript), { recursive: true });
+  fs39.copyFileSync(templatePath, guardScript);
+  fs39.chmodSync(guardScript, 493);
+  const settingsPath = path44.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
   const settings = readSettings(settingsPath);
   const hooks = settings.hooks ?? {};
   const preToolUse = (hooks.PreToolUse ?? []).filter((entry) => !isHarGuardEntry(entry));
@@ -32272,15 +32529,15 @@ function installClaudeGuard(repoPath) {
 }
 function uninstallClaudeGuard(repoPath) {
   let removed = false;
-  const guardScript = path43.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  if (fs38.existsSync(guardScript)) {
-    fs38.rmSync(guardScript);
+  const guardScript = path44.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  if (fs39.existsSync(guardScript)) {
+    fs39.rmSync(guardScript);
     removed = true;
-    const parent = path43.dirname(guardScript);
-    if (fs38.existsSync(parent) && fs38.readdirSync(parent).length === 0) fs38.rmdirSync(parent);
+    const parent = path44.dirname(guardScript);
+    if (fs39.existsSync(parent) && fs39.readdirSync(parent).length === 0) fs39.rmdirSync(parent);
   }
-  const settingsPath = path43.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (fs38.existsSync(settingsPath)) {
+  const settingsPath = path44.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (fs39.existsSync(settingsPath)) {
     const settings = readSettings(settingsPath);
     const preToolUse = settings.hooks?.PreToolUse;
     if (preToolUse) {
@@ -32305,8 +32562,8 @@ function uninstallClaudeGuard(repoPath) {
   return { removed };
 }
 function claudeGuardInstalled(repoPath) {
-  const settingsPath = path43.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (!fs38.existsSync(settingsPath)) return false;
+  const settingsPath = path44.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (!fs39.existsSync(settingsPath)) return false;
   try {
     const settings = readSettings(settingsPath);
     return (settings.hooks?.PreToolUse ?? []).some(isHarGuardEntry);
@@ -32322,7 +32579,7 @@ function repoOption(y2) {
 function handleInstall2(argv) {
   try {
     if (argv.claude) {
-      const result2 = installClaudeGuard(path44.resolve(argv.repo));
+      const result2 = installClaudeGuard(path45.resolve(argv.repo));
       success("Claude Code worktree guard installed.");
       info(`Guard script:  ${result2.guardScript}`);
       info(`Settings:      ${result2.settingsPath} (PreToolUse: Edit|Write|MultiEdit|NotebookEdit)`);
@@ -32330,7 +32587,7 @@ function handleInstall2(argv) {
       info("Commit both files so the guard travels with the repo.");
       return;
     }
-    const result = installHooks({ repoPath: path44.resolve(argv.repo), force: argv.force });
+    const result = installHooks({ repoPath: path45.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.");
@@ -32343,7 +32600,7 @@ function handleInstall2(argv) {
 function handleUninstall(argv) {
   try {
     if (argv.claude) {
-      const result2 = uninstallClaudeGuard(path44.resolve(argv.repo));
+      const result2 = uninstallClaudeGuard(path45.resolve(argv.repo));
       if (result2.removed) {
         success("Claude Code worktree guard removed.");
       } else {
@@ -32351,7 +32608,7 @@ function handleUninstall(argv) {
       }
       return;
     }
-    const result = uninstallHooks(path44.resolve(argv.repo));
+    const result = uninstallHooks(path45.resolve(argv.repo));
     if (result.removed) {
       success(`Commit gate removed from ${result.hooksDir}`);
     } else {
@@ -32364,7 +32621,7 @@ function handleUninstall(argv) {
 }
 function handleStatus2(argv) {
   try {
-    const status = getHooksStatus(path44.resolve(argv.repo));
+    const status = getHooksStatus(path45.resolve(argv.repo));
     if (argv.json) {
       process.stdout.write(`${JSON.stringify(status, null, 2)}
 `);
@@ -32382,7 +32639,7 @@ function handleStatus2(argv) {
     );
     info(`Effective:     ${status.effectiveMode} (in this checkout)`);
     info(
-      `Claude guard:  ${claudeGuardInstalled(path44.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
+      `Claude guard:  ${claudeGuardInstalled(path45.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
     );
   } catch (err) {
     error(err instanceof Error ? err.message : String(err));
@@ -32643,10 +32900,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path47) {
-  if (!path47)
+function getElementAtPath(obj, path48) {
+  if (!path48)
     return obj;
-  return path47.reduce((acc, key) => acc?.[key], obj);
+  return path48.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -32966,11 +33223,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path47, issues) {
+function prefixIssues(path48, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path47);
+    iss.path.unshift(path48);
     return iss;
   });
 }
@@ -39444,7 +39701,7 @@ var Server = class extends Protocol {
 };
 
 // src/mcp/server.ts
-var path45 = __toESM(require("path"));
+var path46 = __toESM(require("path"));
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var import_node_process2 = __toESM(require("node:process"), 1);
@@ -40076,7 +40333,7 @@ async function handleMcpToolCall(toolName, args, defaultRepo = ".") {
       const input = ControlUpInputSchema.parse({ ...args, repo });
       const result = await startControlAndSync({
         detach: input.detach,
-        cwd: path45.resolve(input.repo)
+        cwd: path46.resolve(input.repo)
       });
       if (result.code !== 0) {
         return {
@@ -40139,8 +40396,8 @@ var mcpCommand = {
 };
 
 // src/cli/commands/telemetry.ts
-var fs39 = __toESM(require("fs"));
-var path46 = __toESM(require("path"));
+var fs40 = __toESM(require("fs"));
+var path47 = __toESM(require("path"));
 function printSignals() {
   info("Collected when enabled (local Mission Control only):");
   for (const signal of TELEMETRY_SIGNALS) {
@@ -40151,18 +40408,20 @@ function printSignals() {
 async function handleStatus3(argv) {
   const preference = readTelemetryPreference();
   const enabled = isTelemetryEnabled();
+  const signals = getTelemetrySignals();
   const apiUrl = getControlApiUrl();
   const reachable = enabled ? await isControlApiReachable(apiUrl) : false;
   const payload = {
     enabled,
     preferenceEnabled: preference.enabled,
+    signals,
     preferencePath: getTelemetryPreferencePath(),
     updatedAt: preference.updatedAt ?? null,
     envOverride: process.env.HAR_TELEMETRY ?? null,
     controlApiUrl: apiUrl,
     controlReachable: reachable,
     otelEndpoint: `${apiUrl.replace(/\/$/, "")}/api/otel`,
-    signals: [...TELEMETRY_SIGNALS]
+    signalDescriptions: [...TELEMETRY_SIGNALS]
   };
   if (argv.json) {
     process.stdout.write(`${JSON.stringify(payload, null, 2)}
@@ -40172,21 +40431,33 @@ async function handleStatus3(argv) {
   header("har telemetry status");
   info(`Enabled:       ${enabled ? "yes" : "no"}${process.env.HAR_TELEMETRY ? " (HAR_TELEMETRY override)" : ""}`);
   info(`Preference:    ${getTelemetryPreferencePath()}${preference.updatedAt ? ` (updated ${preference.updatedAt})` : " (default on)"}`);
+  info(
+    `Signals:       metrics=${signals.metrics} logs=${signals.logs} prompts=${signals.prompts} traces=${signals.traces}`
+  );
   info(`Mission Control: ${apiUrl} (${reachable ? "reachable" : "not reachable"})`);
   info(`OTLP endpoint: ${payload.otelEndpoint}`);
   printSignals();
 }
-async function handleOn() {
+async function handleOn(argv) {
   header("har telemetry on");
-  writeTelemetryPreference(true);
+  const preference = writeTelemetryPreference(true, {
+    prompts: argv.prompts === true ? true : void 0,
+    traces: argv.traces === true ? true : void 0
+  });
   success("Telemetry enabled (opt-out). Agent usage will be stored in local Mission Control.");
+  info(
+    `Signals: metrics=${preference.signals.metrics} logs=${preference.signals.logs} prompts=${preference.signals.prompts} traces=${preference.signals.traces}`
+  );
+  if (preference.signals.prompts) {
+    warn("Prompt/response text will leave the agent machine for local Mission Control storage.");
+  }
   printSignals();
   const result = await ensureTelemetryInfrastructure({ startIfNeeded: true });
   if (result.message) success(result.message);
   if (result.warning) warn(result.warning);
   if (result.otelReady) {
     info(`OTLP ingest: ${result.apiUrl.replace(/\/$/, "")}/api/otel`);
-    info("Usage appears under Mission Control \u2192 Worktrees. Disable: har telemetry off");
+    info("Usage appears under Mission Control \u2192 Worktrees / Usage. Disable: har telemetry off");
   }
 }
 async function handleOff() {
@@ -40197,7 +40468,7 @@ async function handleOff() {
   info("Existing usage rows in Mission Control are kept. Historical data is not deleted.");
 }
 async function handleWriteEnv(argv) {
-  const repoPath = path46.resolve(argv.repo);
+  const repoPath = path47.resolve(argv.repo);
   const harnessRoot = resolveHarnessRoot(repoPath);
   const session = readSlotRegistry(harnessRoot, argv.agentId);
   const workDir = argv.workDir ?? session?.workDir ?? repoPath;
@@ -40210,7 +40481,7 @@ async function handleWriteEnv(argv) {
     suffix,
     createdAt: session?.createdAt
   });
-  const envFile = argv.envFile ?? path46.join(workDir, `.env.agent.${argv.agentId}`);
+  const envFile = argv.envFile ?? path47.join(workDir, `.env.agent.${argv.agentId}`);
   let otelReady = argv.otelReady;
   if (otelReady === void 0 && isTelemetryEnabled()) {
     const ensured = await ensureTelemetryInfrastructure({ startIfNeeded: false });
@@ -40229,7 +40500,7 @@ async function handleWriteEnv(argv) {
   success(`Wrote telemetry env to ${envFile}`);
 }
 function handlePrintEnv(argv) {
-  const repoPath = path46.resolve(argv.repo);
+  const repoPath = path47.resolve(argv.repo);
   const workDir = argv.workDir ?? repoPath;
   const sessionKey = buildSessionKey({
     branch: argv.branch,
@@ -40251,7 +40522,7 @@ function handlePrintEnv(argv) {
   );
 }
 function handleCodexSnippet(argv) {
-  const repoPath = path46.resolve(argv.repo);
+  const repoPath = path47.resolve(argv.repo);
   const harnessRoot = resolveHarnessRoot(repoPath);
   const session = readSlotRegistry(harnessRoot, argv.agentId);
   const workDir = argv.workDir ?? session?.workDir ?? repoPath;
@@ -40273,10 +40544,10 @@ function handleCodexSnippet(argv) {
     purpose: session?.purpose
   });
   if (argv.write) {
-    const outDir = path46.join(harnessRoot, ".har", "telemetry");
-    fs39.mkdirSync(outDir, { recursive: true });
-    const outPath = path46.join(outDir, "codex.otel.toml.snippet");
-    fs39.writeFileSync(outPath, snippet);
+    const outDir = path47.join(harnessRoot, ".har", "telemetry");
+    fs40.mkdirSync(outDir, { recursive: true });
+    const outPath = path47.join(outDir, "codex.otel.toml.snippet");
+    fs40.writeFileSync(outPath, snippet);
     success(`Wrote ${outPath}`);
     info("Merge the [otel] table into ~/.codex/config.toml manually.");
     return;
@@ -40296,10 +40567,20 @@ var telemetryCommand = {
   ).command(
     "on",
     "Enable telemetry (default) and ensure Mission Control is running",
-    () => {
-    },
-    () => {
-      void handleOn();
+    (y2) => y2.option("prompts", {
+      type: "boolean",
+      default: false,
+      describe: "Opt in to shipping user/assistant prompt text to Mission Control"
+    }).option("traces", {
+      type: "boolean",
+      default: false,
+      describe: "Opt in to thin OTEL traces ingest (Claude beta)"
+    }),
+    (argv) => {
+      void handleOn({
+        prompts: argv.prompts,
+        traces: argv.traces
+      });
     }
   ).command(
     "off",