@gluecharm-lab/easyspecs-cli 0.0.23 → 0.0.25

package/dist/main.cjs

@@ -960,7 +960,7 @@ var require_command = __commonJS({
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
     var path60 = require("node:path");
-    var fs60 = require("node:fs");
+    var fs62 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1893,10 +1893,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path60.resolve(baseDir, baseName);
-          if (fs60.existsSync(localBin)) return localBin;
+          if (fs62.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path60.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs60.existsSync(`${localBin}${ext}`)
+            (ext) => fs62.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1908,7 +1908,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs60.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs62.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -10622,12 +10622,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats2(ajv2, list, fs60, exportName) {
+    function addFormats2(ajv2, list, fs62, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv2.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv2.addFormat(f, fs60[f]);
+        ajv2.addFormat(f, fs62[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -10636,7 +10636,7 @@ var require_dist = __commonJS({
 });
 
 // src/cli/main.ts
-var fs59 = __toESM(require("node:fs"));
+var fs61 = __toESM(require("node:fs"));
 var path59 = __toESM(require("node:path"));
 
 // src/cli/exitCodes.ts
@@ -10706,6 +10706,8 @@ function createEasyspecsCliProgram() {
   program2.option("--cwd <dir>", "Repository root (default: current directory)").option("--ci", "Non-interactive; fail fast if configuration is missing").option("--json", "Print one JSON summary line on stdout").option("--verbose", "Extra stderr logging").option("--config <path>", "Configuration file path (accepted; currently unused)").option("--api-base-url <url>", "System Manager API origin (overrides config)").option("--session-path <file>", "Session JSON for this run (overrides config)").option("--environment <environment>", "Effective deployment (alias: --env)").option("--env <environment>", "Alias for --environment").option("--promote", "After run synthesis: force context promotion when config would disable it").option("--no-promote", "After run synthesis or analysis: skip copying .gluecharm/context into repo for this run");
   program2.command("help").description("Show help");
   program2.command("version").description("Print CLI version");
+  const workstation = program2.command("workstation").description("Host inventory for AI workstation sizing");
+  workstation.command("info").description("Print CPU, RAM, and SRS-64 N_sys (macOS and Linux only; use global --json)").allowUnknownOption(false);
   program2.command("doctor").description("Check readiness and/or inspect configuration").option("--readiness", "Print readiness summary (default)").option("--inspect-config", "Print redacted merged configuration");
   const auth = program2.command("auth").description("Authentication");
   auth.command("login").description("Log in").option("--email <email>", "Email address").option("--password <password>", "Password").option("--session-path <path>", "Session JSON path override for this run").option("--ci", "Use easyspecs.auth.ciLogin from config when argv credentials are omitted");
@@ -11234,6 +11236,159 @@ function getDefaultEasyspecsConfig() {
   };
 }
 
+// src/config/machineConcurrentAiFromHost.ts
+var fs3 = __toESM(require("node:fs"));
+var os = __toESM(require("node:os"));
+var import_node_child_process2 = require("node:child_process");
+
+// src/config/effectiveMaxConcurrentAi.ts
+var ABSOLUTE_MAX_CONCURRENT_AI = 64;
+
+// src/config/machineConcurrentAiFromHost.ts
+function clampProductConcurrentLimits(n) {
+  if (!Number.isFinite(n)) {
+    return DEFAULT_MAX_CONCURRENT_AI;
+  }
+  return Math.min(ABSOLUTE_MAX_CONCURRENT_AI, Math.max(1, Math.floor(n)));
+}
+function machineConcurrentAiCapFromHost(profile) {
+  const memBytes = Number.isFinite(profile.totalMemBytes) && profile.totalMemBytes > 0 ? profile.totalMemBytes : 0;
+  const rGib = memBytes / 2 ** 30;
+  let p = Math.floor(profile.cpusForCap);
+  if (!Number.isFinite(p) || p < 1) {
+    p = 1;
+  }
+  if (!Number.isFinite(rGib) || rGib <= 0) {
+    return 1;
+  }
+  let nCpuFloat;
+  if (p <= 11) {
+    nCpuFloat = 15 + 8.5 * (p - 1);
+  } else {
+    nCpuFloat = 100 + 8.5 * (p - 11);
+  }
+  const ramFactor = Math.min(1, rGib / (4 * p));
+  const nFloat = nCpuFloat * ramFactor;
+  const rounded = Math.round(nFloat);
+  return Math.max(1, rounded);
+}
+function hostHardMaxFromHost(profile) {
+  const nSys = machineConcurrentAiCapFromHost(profile);
+  return Math.min(64, Math.max(1, nSys));
+}
+function resolveStaticEffectiveMaxConcurrentAi(params) {
+  const requestedSanitized = clampProductConcurrentLimits(Number(params.requested));
+  let nSys;
+  let hostHardMax;
+  if (params.hostHardMaxOverride !== void 0) {
+    hostHardMax = clampProductConcurrentLimits(params.hostHardMaxOverride);
+    nSys = params.hostProfile ? machineConcurrentAiCapFromHost(params.hostProfile) : hostHardMax;
+  } else {
+    const profile = params.hostProfile ?? collectHostMachineProfile();
+    nSys = machineConcurrentAiCapFromHost(profile);
+    hostHardMax = hostHardMaxFromHost(profile);
+  }
+  if (params.applyHostConcurrencyCap === false) {
+    return {
+      staticEffective: requestedSanitized,
+      hostHardMax,
+      nSys,
+      requestedSanitized,
+      cappedByHost: false
+    };
+  }
+  const staticEffective = clampProductConcurrentLimits(Math.min(requestedSanitized, hostHardMax));
+  const cappedByHost = requestedSanitized > hostHardMax;
+  return { staticEffective, hostHardMax, nSys, requestedSanitized, cappedByHost };
+}
+function formatMaxConcurrentAiOverCapWarning(p) {
+  return `[EasySpecs] easyspecs.workstations.maxConcurrentAi (${String(p.requested)}) exceeds this host's hostHardMax (${String(p.hostHardMax)}). Using effective concurrency ${String(p.effective)}.`;
+}
+function tryReadDarwinPhysicalCpus() {
+  if (process.platform !== "darwin") {
+    return void 0;
+  }
+  try {
+    const out = (0, import_node_child_process2.execFileSync)("/usr/sbin/sysctl", ["-n", "hw.physicalcpu"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).trim();
+    const n = parseInt(out, 10);
+    if (Number.isFinite(n) && n > 0) {
+      return n;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function tryReadLinuxPhysicalCpus() {
+  if (process.platform !== "linux") {
+    return void 0;
+  }
+  try {
+    const raw = fs3.readFileSync("/proc/cpuinfo", "utf8");
+    const chunks = raw.split(/\n(?=^processor\s*:)/m);
+    const pairs = /* @__PURE__ */ new Set();
+    for (const chunk of chunks) {
+      if (!/^processor\s*:/m.test(chunk.trim())) {
+        continue;
+      }
+      let physicalId;
+      let coreId;
+      for (const line of chunk.split("\n")) {
+        const t = line.trim();
+        const mPhy = /^physical id\s*:\s*(\d+)\s*$/i.exec(t);
+        if (mPhy) {
+          physicalId = mPhy[1];
+        }
+        const mCore = /^core id\s*:\s*(\d+)\s*$/i.exec(t);
+        if (mCore) {
+          coreId = mCore[1];
+        }
+      }
+      if (physicalId !== void 0 && coreId !== void 0) {
+        pairs.add(`${physicalId}:${coreId}`);
+      }
+    }
+    if (pairs.size > 0) {
+      return pairs.size;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function collectHostMachineProfile() {
+  const platform = process.platform;
+  const totalMemBytes = os.totalmem();
+  const logical = Math.max(1, os.cpus()?.length ?? 1);
+  if (platform === "darwin") {
+    const phy = tryReadDarwinPhysicalCpus();
+    if (phy !== void 0) {
+      return {
+        cpusForCap: phy,
+        cpusForCapSource: "physical",
+        totalMemBytes,
+        platform
+      };
+    }
+    return { cpusForCap: logical, cpusForCapSource: "logical_fallback", totalMemBytes, platform };
+  }
+  if (platform === "linux") {
+    const phy = tryReadLinuxPhysicalCpus();
+    if (phy !== void 0) {
+      return {
+        cpusForCap: phy,
+        cpusForCapSource: "physical",
+        totalMemBytes,
+        platform
+      };
+    }
+    return { cpusForCap: logical, cpusForCapSource: "logical_fallback", totalMemBytes, platform };
+  }
+  return { cpusForCap: logical, cpusForCapSource: "logical_fallback", totalMemBytes, platform };
+}
+
 // src/config/openCodeProviderEnv.ts
 var path3 = __toESM(require("node:path"));
 var PROVIDER_TO_ENV = {
@@ -11340,6 +11495,8 @@ function getEasyspecsMergedConfigValue(es, fullKey) {
       return es.orchestration?.synthesisRemediationShareBackoff;
     case "easyspecs.workstations.maxConcurrentAi":
       return es.workstations?.maxConcurrentAi;
+    case "easyspecs.workstations.applyHostConcurrencyCap":
+      return es.workstations?.applyHostConcurrencyCap;
     case "easyspecs.analysis.maxConcurrentOpenCodeAgents":
       return es.analysis?.maxConcurrentOpenCodeAgents;
     case "easyspecs.workstations.openCodeArgv":
@@ -11409,7 +11566,24 @@ function mergeEasyspecsCliSettings(cfg, overrides = {}) {
   const listJsonSchemaRepairAttempts = rt?.coordinationRepairs?.listJsonSchemaRepairAttempts ?? readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.workstations.coordinationListRepairAttempts") ?? 1;
   const markdownEvidenceRepairAttempts = rt?.coordinationRepairs?.markdownEvidenceRepairAttempts ?? readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.workstations.detailMarkdownRepairAttempts") ?? 2;
   const markdownOpenQuestionIterations = rt?.coordinationRepairs?.markdownOpenQuestionIterations ?? readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.workstations.openQuestionIterations") ?? 5;
-  const maxConcurrentOpenCodeAgents = overrides.maxConcurrentOpenCodeAgents ?? readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.workstations.maxConcurrentAi") ?? rt?.pool?.maxConcurrentAgents ?? DEFAULT_MAX_CONCURRENT_AI;
+  const requestedPool = overrides.maxConcurrentOpenCodeAgents ?? readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.workstations.maxConcurrentAi") ?? rt?.pool?.maxConcurrentAgents ?? DEFAULT_MAX_CONCURRENT_AI;
+  const applyHostCap = readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.workstations.applyHostConcurrencyCap") !== false;
+  const hostProfile = overrides.__testOnlyHostProfile ?? collectHostMachineProfile();
+  const resolved = resolveStaticEffectiveMaxConcurrentAi({
+    requested: requestedPool,
+    applyHostConcurrencyCap: applyHostCap,
+    hostProfile
+  });
+  const maxConcurrentOpenCodeAgents = resolved.staticEffective;
+  if (resolved.cappedByHost) {
+    const msg = formatMaxConcurrentAiOverCapWarning({
+      requested: resolved.requestedSanitized,
+      hostHardMax: resolved.hostHardMax,
+      effective: resolved.staticEffective
+    });
+    process.stderr.write(`${msg}
+`);
+  }
   const promoteContextToWorkspace = overrides.promote === false ? false : overrides.promote === true ? true : analysis.promoteContextToWorkspace !== false;
   let maxOuter = overrides.maxOuterIterationsPerPhase ?? readEasyspecsMergedSetting(cfg.easyspecs, "easyspecs.factory.maxOuterIterationsPerPipeline") ?? orch.maxOuterIterationsPerPhase ?? 0;
   if (ci && maxOuter === 0) {
@@ -11464,27 +11638,27 @@ function redactMergedCliSettingsForDump(merged) {
 }
 
 // src/config/easyspecsConfigFile.ts
-var fs6 = __toESM(require("node:fs"));
+var fs7 = __toESM(require("node:fs"));
 var path7 = __toESM(require("node:path"));
 
 // src/easySpecsWorkspaceSettingsCore.ts
-var fs4 = __toESM(require("node:fs"));
+var fs5 = __toESM(require("node:fs"));
 var path5 = __toESM(require("node:path"));
 
 // src/analysis/easySpecsWorktreeMarker.ts
-var fs3 = __toESM(require("fs"));
+var fs4 = __toESM(require("fs"));
 var path4 = __toESM(require("path"));
 var EASYSPECS_LOCAL_DIR = ".easyspecs";
 var EASYSPECS_WORKTREE_MARKER_REL = path4.join(EASYSPECS_LOCAL_DIR, "analysis-worktree.json");
 var MARKER_KIND = "easyspecs-analysis-worktree";
 function writeAnalysisWorktreeMarker(worktreeRoot, repositoryRoot) {
   const dir = path4.join(worktreeRoot, EASYSPECS_LOCAL_DIR);
-  fs3.mkdirSync(dir, { recursive: true });
+  fs4.mkdirSync(dir, { recursive: true });
   const payload = {
     kind: MARKER_KIND,
     repositoryRoot: path4.resolve(repositoryRoot)
   };
-  fs3.writeFileSync(path4.join(dir, "analysis-worktree.json"), `${JSON.stringify(payload)}
+  fs4.writeFileSync(path4.join(dir, "analysis-worktree.json"), `${JSON.stringify(payload)}
 `, "utf-8");
 }
 
@@ -11500,7 +11674,7 @@ function readAceEnabledFromEasySpecsSettingsFile(workspaceRootFsPath) {
   const filePath = path5.join(workspaceRootFsPath, EASYSPECS_WORKSPACE_DIR, EASYSPECS_SETTINGS_JSON);
   let raw;
   try {
-    raw = fs4.readFileSync(filePath, "utf8");
+    raw = fs5.readFileSync(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -11520,7 +11694,7 @@ function readAceOfflineLearnAfterSameSessionTraceFromEasySpecsSettingsFile(works
   const filePath = path5.join(workspaceRootFsPath, EASYSPECS_WORKSPACE_DIR, EASYSPECS_SETTINGS_JSON);
   let raw;
   try {
-    raw = fs4.readFileSync(filePath, "utf8");
+    raw = fs5.readFileSync(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -11538,7 +11712,7 @@ function readAceOfflineLearnAfterSameSessionTraceFromEasySpecsSettingsFile(works
 }
 
 // src/config/validateEasyspecsConfigSrs46.ts
-var fs5 = __toESM(require("node:fs"));
+var fs6 = __toESM(require("node:fs"));
 var path6 = __toESM(require("node:path"));
 var import__ = __toESM(require__());
 var import_ajv_formats = __toESM(require_dist());
@@ -11553,14 +11727,14 @@ function resolveSrs46ConfigSchemaPath() {
     path6.join(__dirname, "..", "..", "..", SCHEMA_REL_REPO)
   ];
   for (const p of candidates) {
-    if (fs5.existsSync(p)) {
+    if (fs6.existsSync(p)) {
       return path6.normalize(p);
     }
   }
   let dir = __dirname;
   for (let i = 0; i < 14; i += 1) {
     const p = path6.join(dir, SCHEMA_REL_REPO);
-    if (fs5.existsSync(p)) {
+    if (fs6.existsSync(p)) {
       return path6.normalize(p);
     }
     const parent = path6.dirname(dir);
@@ -11575,7 +11749,7 @@ function resolveSrs46ConfigSchemaPath() {
 }
 function loadSchemaObject() {
   const schemaPath = resolveSrs46ConfigSchemaPath();
-  const raw = fs5.readFileSync(schemaPath, "utf8");
+  const raw = fs6.readFileSync(schemaPath, "utf8");
   return JSON.parse(raw);
 }
 var EasyspecsConfigSchemaError = class extends Error {
@@ -11647,7 +11821,7 @@ function parseEasyspecsConfigJson(raw, filePath) {
 }
 function readEasyspecsConfig(repoRoot) {
   const p = easyspecsConfigPath(repoRoot);
-  const raw = fs6.readFileSync(p, "utf8");
+  const raw = fs7.readFileSync(p, "utf8");
   return parseEasyspecsConfigJson(raw, p);
 }
 function cliJsonFileToConfigPartial(legacy) {
@@ -11690,17 +11864,17 @@ function cliJsonFileToConfigPartial(legacy) {
 }
 function atomicWriteFile(targetPath, contents) {
   const dir = path7.dirname(targetPath);
-  fs6.mkdirSync(dir, { recursive: true });
+  fs7.mkdirSync(dir, { recursive: true });
   const tmp = path7.join(dir, `.${path7.basename(targetPath)}.${process.pid}.${Date.now()}.tmp`);
-  fs6.writeFileSync(tmp, contents, "utf8");
-  fs6.renameSync(tmp, targetPath);
+  fs7.writeFileSync(tmp, contents, "utf8");
+  fs7.renameSync(tmp, targetPath);
 }
 function buildFreshEasyspecsConfigFromLegacy(repoRoot, warnMigration) {
   let base = getDefaultEasyspecsConfig();
   const legacyPath = easyspecsLegacyCliJsonPath(repoRoot);
-  if (fs6.existsSync(legacyPath)) {
+  if (fs7.existsSync(legacyPath)) {
     try {
-      const rawLegacy = fs6.readFileSync(legacyPath, "utf8");
+      const rawLegacy = fs7.readFileSync(legacyPath, "utf8");
       const legacyParsed = JSON.parse(rawLegacy);
       base = mergeEasyspecsConfigDefaults(base, cliJsonFileToConfigPartial(legacyParsed));
       warnMigration?.(`Imported settings from ${LEGACY_CLI_JSON} into ${CONFIG_BASENAME} (SRS-43 migration).`);
@@ -11709,9 +11883,9 @@ function buildFreshEasyspecsConfigFromLegacy(repoRoot, warnMigration) {
     }
   }
   const settingsLegacyPath = easyspecsLegacySettingsJsonPath(repoRoot);
-  if (fs6.existsSync(settingsLegacyPath)) {
+  if (fs7.existsSync(settingsLegacyPath)) {
     try {
-      const rawS = fs6.readFileSync(settingsLegacyPath, "utf8");
+      const rawS = fs7.readFileSync(settingsLegacyPath, "utf8");
       const leg = JSON.parse(rawS);
       const ace = {};
       if (Object.prototype.hasOwnProperty.call(leg, EASYSPECS_SETTINGS_ACE_KEY)) {
@@ -11740,7 +11914,7 @@ function buildFreshEasyspecsConfigFromLegacy(repoRoot, warnMigration) {
 }
 function initEasyspecsConfigFile(repoRoot, opts) {
   const configPath = easyspecsConfigPath(repoRoot);
-  const existed = fs6.existsSync(configPath);
+  const existed = fs7.existsSync(configPath);
   if (existed && !opts.overwrite) {
     return { outcome: "unchanged", path: configPath, config: readEasyspecsConfig(repoRoot) };
   }
@@ -11756,14 +11930,14 @@ function initEasyspecsConfigFile(repoRoot, opts) {
 function ensureEasyspecsConfig(repoRoot, opts) {
   const configPath = easyspecsConfigPath(repoRoot);
   const legacyPath = easyspecsLegacyCliJsonPath(repoRoot);
-  if (fs6.existsSync(configPath)) {
-    if (fs6.existsSync(legacyPath)) {
+  if (fs7.existsSync(configPath)) {
+    if (fs7.existsSync(legacyPath)) {
       opts.warnMigration?.(
         `${legacyPath} is deprecated alongside ${configPath}; prefer editing ${CONFIG_BASENAME} only.`
       );
     }
     const settingsLegacy = easyspecsLegacySettingsJsonPath(repoRoot);
-    if (fs6.existsSync(settingsLegacy)) {
+    if (fs7.existsSync(settingsLegacy)) {
       opts.warnMigration?.(
         `${settingsLegacy} is deprecated; use easyspecs.analysis.ace in ${CONFIG_BASENAME} (see USER-MANUAL-SRS-35).`
       );
@@ -11785,7 +11959,7 @@ function syncDefaultGitRemoteUrlIfEmpty(repoRoot, cfg, opts) {
     return cfg;
   }
   const configPath = easyspecsConfigPath(repoRoot);
-  if (!fs6.existsSync(configPath)) {
+  if (!fs7.existsSync(configPath)) {
     return cfg;
   }
   const gitRoot = findGitRepoRoot(repoRoot) ?? repoRoot;
@@ -11797,7 +11971,7 @@ function syncDefaultGitRemoteUrlIfEmpty(repoRoot, cfg, opts) {
 }
 function updateEasyspecsConfig(repoRoot, patch, opts) {
   const configPath = easyspecsConfigPath(repoRoot);
-  const base = fs6.existsSync(configPath) ? readEasyspecsConfig(repoRoot) : buildFreshEasyspecsConfigFromLegacy(repoRoot, opts?.warnMigration);
+  const base = fs7.existsSync(configPath) ? readEasyspecsConfig(repoRoot) : buildFreshEasyspecsConfigFromLegacy(repoRoot, opts?.warnMigration);
   const merged = mergeEasyspecsConfigDefaults(base, patch);
   assertEasyspecsConfigValidatesSrs46Schema(merged, configPath);
   atomicWriteFile(configPath, `${JSON.stringify(merged, null, 2)}
@@ -11806,7 +11980,7 @@ function updateEasyspecsConfig(repoRoot, patch, opts) {
 }
 
 // src/pipelines/upload/uploadPipeline.ts
-var fs11 = __toESM(require("node:fs"));
+var fs12 = __toESM(require("node:fs"));
 var path12 = __toESM(require("node:path"));
 var import_node_crypto = require("node:crypto");
 
@@ -11896,24 +12070,24 @@ function toAuthErrorMessage(error, fallback) {
 }
 
 // src/analysis/contextSrsDiscoveryIdMap.ts
-var fs10 = __toESM(require("node:fs"));
+var fs11 = __toESM(require("node:fs"));
 var path11 = __toESM(require("node:path"));
 
 // src/analysis/indexApplicationContextMergeUploadIds.ts
-var fs9 = __toESM(require("node:fs"));
+var fs10 = __toESM(require("node:fs"));
 var path10 = __toESM(require("node:path"));
 
 // src/indexApplicationContextValidate.ts
 var import__2 = __toESM(require__());
-var fs8 = __toESM(require("fs"));
+var fs9 = __toESM(require("fs"));
 var path9 = __toESM(require("path"));
 
 // src/shared/repoResourcesRoot.ts
-var fs7 = __toESM(require("node:fs"));
+var fs8 = __toESM(require("node:fs"));
 var path8 = __toESM(require("node:path"));
 var CONTEXT_LIST_MARKER = path8.join("schemas", "context-lists", "zero-reference-classifier-record.schema.json");
 function hasMarker(resourcesRoot) {
-  return fs7.existsSync(path8.join(resourcesRoot, CONTEXT_LIST_MARKER));
+  return fs8.existsSync(path8.join(resourcesRoot, CONTEXT_LIST_MARKER));
 }
 function resolveRepoResourcesRoot() {
   const candidates = [path8.join(__dirname, "..", "resources"), path8.join(__dirname, "..", "..", "resources")];
@@ -11943,7 +12117,7 @@ function getValidator(schemaPath) {
   const abs = path9.resolve(schemaPath);
   let v = validators.get(abs);
   if (!v) {
-    const raw = fs8.readFileSync(abs, "utf-8");
+    const raw = fs9.readFileSync(abs, "utf-8");
     const schema = JSON.parse(raw);
     const ajv2 = new import__2.default({ allErrors: true, strict: false });
     v = ajv2.compile(schema);
@@ -12028,12 +12202,12 @@ function mergeUploadIdsIntoIndexDocument(doc, contextDir2, succeededIds) {
 function atomicWriteJson(targetPath, doc) {
   const tmp = `${targetPath}.${process.pid}.tmp`;
   try {
-    fs9.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
+    fs10.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
 `, "utf-8");
-    fs9.renameSync(tmp, targetPath);
+    fs10.renameSync(tmp, targetPath);
   } catch (e) {
     try {
-      fs9.unlinkSync(tmp);
+      fs10.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -12042,12 +12216,12 @@ function atomicWriteJson(targetPath, doc) {
 function mergeUploadIdsIntoIndexOnDisk(contextDir2, succeededIds, options) {
   const schemaPath = options?.schemaPath ?? getDefaultIndexSchemaPath();
   const target = path10.join(contextDir2, INDEX_APPLICATION_CONTEXT_BASENAME);
-  if (!fs9.existsSync(target)) {
+  if (!fs10.existsSync(target)) {
     return { ok: true };
   }
   let raw;
   try {
-    raw = fs9.readFileSync(target, "utf-8");
+    raw = fs10.readFileSync(target, "utf-8");
   } catch (e) {
     return { ok: false, message: e instanceof Error ? e.message : String(e) };
   }
@@ -12096,11 +12270,11 @@ function isRecord2(v) {
   return Boolean(v) && typeof v === "object" && !Array.isArray(v);
 }
 function loadSrsDiscoveryIdMapFromContextDir(contextDir2, log) {
-  if (!contextDir2 || !fs10.existsSync(contextDir2) || !fs10.statSync(contextDir2).isDirectory()) {
+  if (!contextDir2 || !fs11.existsSync(contextDir2) || !fs11.statSync(contextDir2).isDirectory()) {
     return {};
   }
   const indexPath = path11.join(contextDir2, INDEX_APPLICATION_CONTEXT_BASENAME);
-  if (!fs10.existsSync(indexPath)) {
+  if (!fs11.existsSync(indexPath)) {
     log?.(
       `[pipeline:upload] No local ${INDEX_APPLICATION_CONTEXT_BASENAME} \u2014 id map empty; uploads use create (new UUID) until the index exists.`
     );
@@ -12108,7 +12282,7 @@ function loadSrsDiscoveryIdMapFromContextDir(contextDir2, log) {
   }
   let raw;
   try {
-    raw = fs10.readFileSync(indexPath, "utf8");
+    raw = fs11.readFileSync(indexPath, "utf8");
   } catch (e) {
     log?.(`[pipeline:upload] Could not read index file \u2014 ${e instanceof Error ? e.message : String(e)}`);
     return {};
@@ -12322,14 +12496,14 @@ async function fetchApplicationCloudContextAnalysisStatus(requestJson, applicati
   return { contextAnalyzedInCloud: parsed.contextAnalyzedInCloud, contextAnalyzedInCloudAt };
 }
 function listContextFilesForUpload(contextDir2, excludeBasenames = /* @__PURE__ */ new Set()) {
-  if (!fs11.existsSync(contextDir2) || !fs11.statSync(contextDir2).isDirectory()) {
+  if (!fs12.existsSync(contextDir2) || !fs12.statSync(contextDir2).isDirectory()) {
     return [];
   }
   const out = [];
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs11.readdirSync(dir, { withFileTypes: true });
+      entries = fs12.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -12513,7 +12687,7 @@ async function runParallelSinglesIntoAccum(requestJson, applicationId, paths, on
     const basename17 = path12.basename(absPath);
     let content;
     try {
-      content = fs11.readFileSync(absPath, "utf8");
+      content = fs12.readFileSync(absPath, "utf8");
     } catch (e) {
       const msg = errorMessage(e);
       logSrs13Failure(log, `read file file=${basename17}`, msg);
@@ -12620,7 +12794,7 @@ async function executeContextSrsDiscoveryUploadPhase(filePaths, phaseOpts, accum
       const basename17 = path12.basename(absPath);
       let content;
       try {
-        content = fs11.readFileSync(absPath, "utf8");
+        content = fs12.readFileSync(absPath, "utf8");
       } catch (e) {
         const msg = errorMessage(e);
         logSrs13Failure(log, `read file file=${basename17}`, msg);
@@ -12645,7 +12819,7 @@ async function executeContextSrsDiscoveryUploadPhase(filePaths, phaseOpts, accum
       const bn = path12.basename(onlyPath);
       let singleContent;
       try {
-        singleContent = fs11.readFileSync(onlyPath, "utf8");
+        singleContent = fs12.readFileSync(onlyPath, "utf8");
       } catch (e) {
         const msg = errorMessage(e);
         logSrs13Failure(log, `read file file=${bn}`, msg);
@@ -12786,6 +12960,73 @@ async function runUploadPipeline(opts) {
   return { succeeded, failed, succeededIds };
 }
 
+// src/cli/formatCliThrownUnknown.ts
+var MAX_ERROR_MESSAGE_LEN = 1200;
+var MAX_JSON_SNAPSHOT_LEN = 600;
+function isHttpApiErrorLike(e) {
+  if (!e || typeof e !== "object" || Array.isArray(e)) {
+    return false;
+  }
+  const o = e;
+  if (typeof o.message !== "string" || o.message.trim().length === 0) {
+    return false;
+  }
+  if (typeof o.status !== "number" || !Number.isFinite(o.status)) {
+    return false;
+  }
+  return true;
+}
+function formatCliThrownUnknown(e, fallback = "Unknown error") {
+  if (e == null) {
+    return fallback;
+  }
+  if (isHttpApiErrorLike(e)) {
+    return toAuthErrorMessage(e, fallback);
+  }
+  if (e instanceof Error) {
+    const m = e.message.trim();
+    if (m.length === 0) {
+      return fallback;
+    }
+    return m.length > MAX_ERROR_MESSAGE_LEN ? `${m.slice(0, MAX_ERROR_MESSAGE_LEN)}\u2026` : m;
+  }
+  if (typeof e === "string") {
+    const t = e.trim();
+    return t.length > 0 ? t : fallback;
+  }
+  if (typeof e === "number" || typeof e === "boolean" || typeof e === "bigint") {
+    return String(e);
+  }
+  if (typeof e === "object") {
+    try {
+      const s = JSON.stringify(e);
+      if (s.length === 0) {
+        return fallback;
+      }
+      return s.length > MAX_JSON_SNAPSHOT_LEN ? `${s.slice(0, MAX_JSON_SNAPSHOT_LEN - 1)}\u2026` : s;
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+function exitCodeForThrownHttpApiError(e) {
+  if (!isHttpApiErrorLike(e)) {
+    return void 0;
+  }
+  const { status } = e;
+  if (status === 401) {
+    return ExitCode.auth;
+  }
+  if (status === 0) {
+    return ExitCode.misconfiguration;
+  }
+  if (status >= 400 && status <= 599 && status !== 401) {
+    return ExitCode.upload;
+  }
+  return void 0;
+}
+
 // src/cli/cloudContextUploadCli.ts
 function buildUploadPrimaryJsonSrs46(args) {
   const out = {
@@ -12805,7 +13046,7 @@ async function fetchUploadCloudContextStatusWithR8Policy(args) {
       timeoutMs: args.timeoutMs
     });
   } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
+    const msg = formatCliThrownUnknown(e);
     return {
       contextAnalyzedInCloud: false,
       contextAnalyzedInCloudAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12842,7 +13083,7 @@ function redactEasyspecsConfigRootForDump(cfg) {
 }
 
 // src/cli/cliFileWorkspaceState.ts
-var fs12 = __toESM(require("node:fs"));
+var fs13 = __toESM(require("node:fs"));
 var path13 = __toESM(require("node:path"));
 
 // src/srs53PersistedStateMigration.ts
@@ -12912,20 +13153,20 @@ function applySrs53PersistedStateMigrationInPlace(m) {
 function createFileBackedWorkspaceState(repoRoot) {
   const dir = path13.join(repoRoot, ".gluecharm", "logs");
   const file = path13.join(dir, "easyspecs-cli-workspace-state.json");
-  fs12.mkdirSync(dir, { recursive: true });
+  fs13.mkdirSync(dir, { recursive: true });
   const load = () => {
     try {
-      if (!fs12.existsSync(file)) {
+      if (!fs13.existsSync(file)) {
         return {};
       }
-      const j = JSON.parse(fs12.readFileSync(file, "utf8"));
+      const j = JSON.parse(fs13.readFileSync(file, "utf8"));
       return typeof j === "object" && j !== null && !Array.isArray(j) ? j : {};
     } catch {
       return {};
     }
   };
   const save = (m) => {
-    fs12.writeFileSync(file, `${JSON.stringify(m, null, 2)}
+    fs13.writeFileSync(file, `${JSON.stringify(m, null, 2)}
 `, "utf8");
   };
   const m0 = load();
@@ -12951,11 +13192,11 @@ function createFileBackedWorkspaceState(repoRoot) {
 }
 
 // src/pipelines/synthesis/synthesisPipeline.ts
-var fs34 = __toESM(require("fs"));
+var fs36 = __toESM(require("fs"));
 var path32 = __toESM(require("path"));
 
 // src/analysis/analysisDynamicTestSteps.ts
-var fs13 = __toESM(require("fs"));
+var fs14 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
 var FE_CODE = /^FE-\d+$/;
 var UC_CODE = /^UC-\d+$/;
@@ -12965,7 +13206,7 @@ function stripUtf8Bom(s) {
 }
 function readJson(filePath) {
   try {
-    const raw = stripUtf8Bom(fs13.readFileSync(filePath, "utf-8"));
+    const raw = stripUtf8Bom(fs14.readFileSync(filePath, "utf-8"));
     return JSON.parse(raw);
   } catch {
     return null;
@@ -13087,7 +13328,7 @@ function safeFeatureName(v) {
 }
 function nonEmptyContextFile(absolutePath) {
   try {
-    const st = fs13.statSync(absolutePath);
+    const st = fs14.statSync(absolutePath);
     return st.isFile() && st.size > 0;
   } catch {
     return false;
@@ -13160,7 +13401,7 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
       });
     }
   }
-  const entityFieldsEmptyHint = !fs13.existsSync(dmPath) || dmData === null ? "No data-model-list.json yet \u2014 run the data model list step after Materialize agents." : entityFieldsRuns.length === 0 ? "data-model-list.json has no valid DM-nn rows \u2014 run the data model step or edit that file." : "";
+  const entityFieldsEmptyHint = !fs14.existsSync(dmPath) || dmData === null ? "No data-model-list.json yet \u2014 run the data model list step after Materialize agents." : entityFieldsRuns.length === 0 ? "data-model-list.json has no valid DM-nn rows \u2014 run the data model step or edit that file." : "";
   const expPath = path14.join(contextDir2, "experiences-list.json");
   const expFileData = readJson(expPath);
   const expTreeRows = discoverExperienceTreeRows(contextDir2);
@@ -13176,7 +13417,7 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
       detailExists: nonEmptyContextFile(path14.join(contextDir2, `${row2.code}_${ix.code}-${ix.slug}.md`))
     }))
   }));
-  const experienceEmptyHint = !fs13.existsSync(expPath) || expFileData === null ? "No experiences-list.json yet \u2014 run the experiences list step after Materialize agents." : experienceViewRuns.length === 0 ? "experiences-list.json has no valid XP-* views with resolvable URL-safe slugs (check code/slug fields and JSON syntax, including UTF-8 BOM)." : "";
+  const experienceEmptyHint = !fs14.existsSync(expPath) || expFileData === null ? "No experiences-list.json yet \u2014 run the experiences list step after Materialize agents." : experienceViewRuns.length === 0 ? "experiences-list.json has no valid XP-* views with resolvable URL-safe slugs (check code/slug fields and JSON syntax, including UTF-8 BOM)." : "";
   const svcPath = path14.join(contextDir2, "services-list.json");
   const svcFileData = readJson(svcPath);
   const svcTreeRows = discoverServiceTreeRows(contextDir2);
@@ -13192,7 +13433,7 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
       detailExists: nonEmptyContextFile(path14.join(contextDir2, `${row2.code}_${m.code}-${m.slug}.md`))
     }))
   }));
-  const servicesEmptyHint = !fs13.existsSync(svcPath) || svcFileData === null ? "No services-list.json yet \u2014 run the services list step after Materialize agents." : serviceRuns.length === 0 ? "services-list.json has no valid SV-* services with resolvable URL-safe slugs (check code/slug fields and JSON syntax, including UTF-8 BOM)." : "";
+  const servicesEmptyHint = !fs14.existsSync(svcPath) || svcFileData === null ? "No services-list.json yet \u2014 run the services list step after Materialize agents." : serviceRuns.length === 0 ? "services-list.json has no valid SV-* services with resolvable URL-safe slugs (check code/slug fields and JSON syntax, including UTF-8 BOM)." : "";
   const tsListPath = path14.join(contextDir2, "tech-stack-list.json");
   const tsListFileData = readJson(tsListPath);
   const toolTreeRows = discoverTechStackToolRows(contextDir2);
@@ -13202,8 +13443,8 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
     slug: row2.slug,
     toolDetailExists: nonEmptyContextFile(path14.join(contextDir2, `${row2.code}-${row2.slug}.md`))
   }));
-  const techStackEmptyHint = !fs13.existsSync(tsListPath) || tsListFileData === null ? "No tech-stack-list.json yet \u2014 run the tech stack list step after Materialize agents." : techStackToolRuns.length === 0 ? "tech-stack-list.json has no valid TS-* tools with resolvable URL-safe slugs (check code/slug fields and JSON syntax, including UTF-8 BOM)." : "";
-  const useCaseEmptyHint = !fs13.existsSync(featuresPath) || featuresData === null ? "No features-list.json yet \u2014 run step 3 (features list) after Materialize agents." : useCaseRuns.length === 0 ? "features-list.json has no valid FE-nn rows \u2014 run step 3 or edit that file." : "";
+  const techStackEmptyHint = !fs14.existsSync(tsListPath) || tsListFileData === null ? "No tech-stack-list.json yet \u2014 run the tech stack list step after Materialize agents." : techStackToolRuns.length === 0 ? "tech-stack-list.json has no valid TS-* tools with resolvable URL-safe slugs (check code/slug fields and JSON syntax, including UTF-8 BOM)." : "";
+  const useCaseEmptyHint = !fs14.existsSync(featuresPath) || featuresData === null ? "No features-list.json yet \u2014 run step 3 (features list) after Materialize agents." : useCaseRuns.length === 0 ? "features-list.json has no valid FE-nn rows \u2014 run step 3 or edit that file." : "";
   const scenarioEmptyHint = scenarioRuns.length === 0 ? useCaseRuns.length === 0 ? "Scenario runs appear after features exist and per-feature use-case lists define UC rows." : "Run a per-feature use case list (above) or add UC rows to each FE-nn-use-cases-list.json." : "";
   return {
     staticOutputs,
@@ -13223,11 +13464,11 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
 }
 
 // src/analysis/materializeOpenCodeAgents.ts
-var fs16 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var path17 = __toESM(require("path"));
 
 // src/analysis/applyAceMaterializedAgents.ts
-var fs15 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 var path16 = __toESM(require("path"));
 
 // src/analysis/acePaths.ts
@@ -13282,7 +13523,7 @@ function opencodeAceSchemaPath(worktreeRoot, basename17) {
 }
 
 // src/analysis/aceJsonValidate.ts
-var fs14 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var import__3 = __toESM(require__());
 function stripUtf8Bom2(s) {
   return s.length > 0 && s.charCodeAt(0) === 65279 ? s.slice(1) : s;
@@ -13300,7 +13541,7 @@ function formatAjvErrors3(errors) {
 function validateAceJsonFile(jsonAbsolutePath, schemaAbsolutePath) {
   let raw;
   try {
-    raw = stripUtf8Bom2(fs14.readFileSync(jsonAbsolutePath, "utf-8"));
+    raw = stripUtf8Bom2(fs15.readFileSync(jsonAbsolutePath, "utf-8"));
   } catch (e) {
     return { ok: false, kind: "read", message: e instanceof Error ? e.message : String(e) };
   }
@@ -13388,7 +13629,7 @@ function balancedJsonObjectFrom(s, start) {
 function validateAceJsonValue(data, schemaAbsolutePath) {
   let schemaRaw;
   try {
-    schemaRaw = stripUtf8Bom2(fs14.readFileSync(schemaAbsolutePath, "utf-8"));
+    schemaRaw = stripUtf8Bom2(fs15.readFileSync(schemaAbsolutePath, "utf-8"));
   } catch (e) {
     return { ok: false, kind: "read", message: `Schema read failed: ${e instanceof Error ? e.message : String(e)}` };
   }
@@ -13483,16 +13724,16 @@ function applyAceToMaterializedAgents(worktreeRoot, options) {
     return;
   }
   const agentsDir = path16.join(worktreeRoot, ".opencode", "agents");
-  if (!fs15.existsSync(agentsDir) || !fs15.statSync(agentsDir).isDirectory()) {
+  if (!fs16.existsSync(agentsDir) || !fs16.statSync(agentsDir).isDirectory()) {
     log(`[ace] skip apply \u2014 missing agents dir: ${agentsDir}`);
     return;
   }
   const contextDir2 = gluecharmContextDir(worktreeRoot);
   const learningsRoot = aceLearningsRoot(contextDir2);
-  fs15.mkdirSync(learningsRoot, { recursive: true });
+  fs16.mkdirSync(learningsRoot, { recursive: true });
   const playbookSchema = opencodeAceSchemaPath(worktreeRoot, ACE_SCHEMA_PLAYBOOK);
   const overlaySchema = opencodeAceSchemaPath(worktreeRoot, ACE_SCHEMA_OVERLAY);
-  const entries = fs15.readdirSync(agentsDir, { withFileTypes: true });
+  const entries = fs16.readdirSync(agentsDir, { withFileTypes: true });
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".md") || e.name === "README.md") {
       continue;
@@ -13501,7 +13742,7 @@ function applyAceToMaterializedAgents(worktreeRoot, options) {
     const agentPath = path16.join(agentsDir, e.name);
     let raw;
     try {
-      raw = fs15.readFileSync(agentPath, "utf-8");
+      raw = fs16.readFileSync(agentPath, "utf-8");
     } catch (err) {
       log(`[ace] skip ${stem} \u2014 read failed: ${err instanceof Error ? err.message : String(err)}`);
       continue;
@@ -13514,7 +13755,7 @@ function applyAceToMaterializedAgents(worktreeRoot, options) {
     const pbPath = acePlaybookPath(contextDir2, stem);
     const ovPath = aceOverlayPath(contextDir2, stem);
     let playbookDoc;
-    if (fs15.existsSync(pbPath)) {
+    if (fs16.existsSync(pbPath)) {
       const v = validateAceJsonFile(pbPath, playbookSchema);
       if (v.ok) {
         const d = v.data;
@@ -13529,7 +13770,7 @@ ${v.errorsText.slice(0, 500)}` : ""}`
       }
     }
     let overlayDoc;
-    if (fs15.existsSync(ovPath)) {
+    if (fs16.existsSync(ovPath)) {
       const v = validateAceJsonFile(ovPath, overlaySchema);
       if (v.ok) {
         overlayDoc = v.data;
@@ -13560,7 +13801,7 @@ ${extra}
 
 ${extra}
 `;
-    fs15.writeFileSync(agentPath, out, "utf-8");
+    fs16.writeFileSync(agentPath, out, "utf-8");
     log(`[ace] merged playbook/overlay into materialized agent: ${e.name}`);
   }
 }
@@ -13622,9 +13863,9 @@ function ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot, projectCo
   };
   const configPath = path17.join(root, "opencode.json");
   let cfg = {};
-  if (fs16.existsSync(configPath)) {
+  if (fs17.existsSync(configPath)) {
     try {
-      const raw = fs16.readFileSync(configPath, "utf-8");
+      const raw = fs17.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         cfg = { ...parsed };
@@ -13647,27 +13888,27 @@ function ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot, projectCo
   if (projectConfigOverlay && Object.keys(projectConfigOverlay).length > 0) {
     cfg = mergeDeepUnknown(cfg, projectConfigOverlay);
   }
-  fs16.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+  fs17.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `, "utf-8");
 }
 function copyRecursive(src, dest) {
-  fs16.mkdirSync(dest, { recursive: true });
-  const entries = fs16.readdirSync(src, { withFileTypes: true });
+  fs17.mkdirSync(dest, { recursive: true });
+  const entries = fs17.readdirSync(src, { withFileTypes: true });
   for (const e of entries) {
     const s = path17.join(src, e.name);
     const d = path17.join(dest, e.name);
     if (e.isDirectory()) {
       copyRecursive(s, d);
     } else {
-      fs16.copyFileSync(s, d);
+      fs17.copyFileSync(s, d);
     }
   }
 }
 function materializeOpenCodeAgents(extensionResourcesAgents, analysisCheckoutRoot, projectConfigOverlay) {
   const dest = path17.join(analysisCheckoutRoot, ".opencode", "agents");
-  if (!fs16.existsSync(extensionResourcesAgents)) {
-    fs16.mkdirSync(dest, { recursive: true });
-    fs16.writeFileSync(
+  if (!fs17.existsSync(extensionResourcesAgents)) {
+    fs17.mkdirSync(dest, { recursive: true });
+    fs17.writeFileSync(
       path17.join(dest, "README.md"),
       "# OpenCode agents\n\nPlaceholder: add agent configs here. Bundled folder was missing at materialize time.\n",
       "utf-8"
@@ -13677,12 +13918,12 @@ function materializeOpenCodeAgents(extensionResourcesAgents, analysisCheckoutRoo
   }
   copyRecursive(extensionResourcesAgents, dest);
   const schemasSrc = path17.join(path17.dirname(extensionResourcesAgents), "schemas", "context-lists");
-  if (fs16.existsSync(schemasSrc)) {
+  if (fs17.existsSync(schemasSrc)) {
     const schemasDest = path17.join(analysisCheckoutRoot, ".opencode", "schemas", "context-lists");
     copyRecursive(schemasSrc, schemasDest);
   }
   const aceSchemasSrc = path17.join(path17.dirname(extensionResourcesAgents), "schemas", "ace");
-  if (fs16.existsSync(aceSchemasSrc)) {
+  if (fs17.existsSync(aceSchemasSrc)) {
     const aceSchemasDest = path17.join(analysisCheckoutRoot, ".opencode", "schemas", "ace");
     copyRecursive(aceSchemasSrc, aceSchemasDest);
   }
@@ -13694,7 +13935,7 @@ function materializeOpenCodeAgentsWithAce(extensionResourcesAgents, analysisChec
 }
 
 // src/workstations/aiWorkstation.ts
-var fs28 = __toESM(require("fs"));
+var fs30 = __toESM(require("fs"));
 var path26 = __toESM(require("path"));
 
 // src/analysis/promptTemplates.ts
@@ -13846,11 +14087,11 @@ function synthesisStepLabel(step, ctx) {
 }
 
 // src/analysis/aceTracePhase.ts
-var fs21 = __toESM(require("fs"));
+var fs23 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
 
 // src/opencodeCli.ts
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 
 // src/analysis/openCodeSessionStewardship.ts
 var TITLE_MAX_LEN = 80;
@@ -13974,6 +14215,139 @@ function logOpenCodeSessionFollowUpStart(diagnosticLog, p) {
   );
 }
 
+// src/opencodeSpawnDiagnostics.ts
+var import_child_process = require("child_process");
+var fs18 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+function defaultCpusLogical() {
+  const ap = os2.availableParallelism?.();
+  if (typeof ap === "number" && Number.isFinite(ap) && ap >= 1) {
+    return ap;
+  }
+  const n = os2.cpus()?.length ?? 1;
+  return Math.max(1, n);
+}
+function collectHostSnapshot(deps) {
+  const totalmem3 = deps?.totalmem ?? (() => os2.totalmem());
+  const freemem2 = deps?.freemem ?? (() => os2.freemem());
+  const loadavg3 = deps?.loadavg ?? (() => os2.loadavg());
+  const cpusLogicalFn = deps?.cpusLogical ?? defaultCpusLogical;
+  const total = Math.max(0, Math.floor(totalmem3()));
+  const free = Math.max(0, Math.floor(freemem2()));
+  const used = Math.max(0, total - free);
+  const cpusLogical = Math.max(1, Math.floor(cpusLogicalFn()));
+  const la = loadavg3();
+  const raw = Array.isArray(la) && la.length > 0 ? la[0] : NaN;
+  const load1 = Number.isFinite(raw) && raw >= 0 ? raw : null;
+  const load1PerCpu = load1 === null ? null : load1 / cpusLogical;
+  return {
+    hostRamTotalB: total,
+    hostRamFreeB: free,
+    hostRamUsedB: used,
+    load1,
+    cpusLogical,
+    load1PerCpu
+  };
+}
+function formatHostSnapshotLine(procTag, childPid, s) {
+  const load1Str = s.load1 === null ? "unknown" : String(s.load1);
+  const perCpuStr = s.load1PerCpu === null ? "unknown" : String(s.load1PerCpu);
+  return `${procTag} scope=host childPid=${childPid} hostRamTotalB=${s.hostRamTotalB} hostRamFreeB=${s.hostRamFreeB} hostRamUsedB=${s.hostRamUsedB} load1=${load1Str} cpusLogical=${s.cpusLogical} load1PerCpu=${perCpuStr}`;
+}
+function parseVmRssKilobytesFromProcStatus(content) {
+  for (const line of content.split(/\r?\n/)) {
+    const m = /^\s*VmRSS:\s*(\d+)\s*kB/i.exec(line);
+    if (m) {
+      const kb = Number(m[1]);
+      return Number.isFinite(kb) && kb >= 0 ? kb : null;
+    }
+  }
+  return null;
+}
+function parsePsRssDarwinKilobytes(stdout) {
+  const t = stdout.trim();
+  if (!t) {
+    return null;
+  }
+  const first = t.split(/\s+/)[0] ?? "";
+  const n = Number(first);
+  if (!Number.isFinite(n) || n < 0) {
+    return null;
+  }
+  return n;
+}
+function readLinuxPidRssBytes(pid) {
+  const path60 = `/proc/${pid}/status`;
+  try {
+    const content = fs18.readFileSync(path60, "utf8");
+    const kb = parseVmRssKilobytesFromProcStatus(content);
+    if (kb === null) {
+      return { kind: "unknown", reason: "VmRSS_missing" };
+    }
+    return { kind: "ok", bytes: Math.floor(kb * 1024) };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { kind: "unknown", reason: truncateReason(msg) };
+  }
+}
+function readDarwinPidRssBytes(pid) {
+  try {
+    const out = (0, import_child_process.execFileSync)("ps", ["-o", "rss=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 64 * 1024
+    });
+    const kb = parsePsRssDarwinKilobytes(out);
+    if (kb === null) {
+      return { kind: "unknown", reason: "ps_parse" };
+    }
+    return { kind: "ok", bytes: Math.floor(kb * 1024) };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { kind: "unknown", reason: truncateReason(msg) };
+  }
+}
+var MAX_RSS_REASON = 48;
+function truncateReason(s) {
+  const one = s.replace(/\s+/g, " ").trim();
+  if (one.length <= MAX_RSS_REASON) {
+    return one;
+  }
+  return `${one.slice(0, MAX_RSS_REASON - 3)}...`;
+}
+function readProcessRssBytes(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return { kind: "unknown", reason: "bad_pid" };
+  }
+  const plat = process.platform;
+  if (plat === "linux") {
+    return readLinuxPidRssBytes(pid);
+  }
+  if (plat === "darwin") {
+    return readDarwinPidRssBytes(pid);
+  }
+  return { kind: "unknown", reason: "platform" };
+}
+function formatChildResourceLine(procTag, childPid, childCpuMs, rss) {
+  const cpu = Math.max(0, Math.round(childCpuMs));
+  if (rss.kind === "ok") {
+    return `${procTag} scope=child childPid=${childPid} childCpuMs=${cpu} childRssBytes=${rss.bytes}`;
+  }
+  const esc = rss.reason.replace(/\\/g, "\\\\").replace(/\s+/g, " ");
+  return `${procTag} scope=child childPid=${childPid} childCpuMs=${cpu} childRssBytes=unknown rssErr=${esc}`;
+}
+function childCpuTimeMsFromUsageDelta(delta) {
+  const us = Math.max(0, delta.user) + Math.max(0, delta.system);
+  return Math.round(us / 1e3);
+}
+function subprocessCpuUsage(proc, previous) {
+  const p = proc;
+  if (typeof p.cpuUsage !== "function") {
+    return { user: 0, system: 0 };
+  }
+  return previous === void 0 ? p.cpuUsage() : p.cpuUsage(previous);
+}
+
 // src/opencodeCli.ts
 var USE_SHELL = process.platform === "win32";
 function resolveExecutable(executable) {
@@ -13982,7 +14356,7 @@ function resolveExecutable(executable) {
 }
 function spawnCliSync(executable, args, cwd, timeoutMs, env) {
   const mergedEnv = env ? { ...process.env, ...env } : process.env;
-  return (0, import_child_process.spawnSync)(executable, args, {
+  return (0, import_child_process2.spawnSync)(executable, args, {
     encoding: "utf-8",
     cwd,
     shell: USE_SHELL,
@@ -14099,12 +14473,36 @@ function runOpenCodeAgent(cwd, args, options) {
       return;
     }
     const spawnEnv = options?.childEnv && Object.keys(options.childEnv).length > 0 ? { ...process.env, ...options.childEnv } : process.env;
-    const child = (0, import_child_process.spawn)(cmd, args, {
+    const child = (0, import_child_process2.spawn)(cmd, args, {
       cwd,
       shell: USE_SHELL,
       env: spawnEnv,
       stdio: ["ignore", "pipe", "pipe"]
     });
+    let childResourceLogged = false;
+    let cpuBaseline;
+    const tryEmitChildResourceDiag = () => {
+      if (childResourceLogged || !log) {
+        return;
+      }
+      if (typeof child.pid !== "number" || child.pid <= 0 || !cpuBaseline) {
+        return;
+      }
+      childResourceLogged = true;
+      let delta;
+      try {
+        delta = subprocessCpuUsage(child, cpuBaseline);
+      } catch {
+        delta = { user: 0, system: 0 };
+      }
+      const cpuMs = childCpuTimeMsFromUsageDelta(delta);
+      const rss = readProcessRssBytes(child.pid);
+      log(formatChildResourceLine(procTag, child.pid, cpuMs, rss));
+    };
+    if (log && typeof child.pid === "number" && child.pid > 0) {
+      log(formatHostSnapshotLine(procTag, child.pid, collectHostSnapshot()));
+      cpuBaseline = subprocessCpuUsage(child);
+    }
     options?.onAgentLaunched?.();
     let stdout = "";
     let stderr = "";
@@ -14162,6 +14560,7 @@ ${truncateForDiag(outBody, DIAG_STDOUT_MAX)}`);
         return;
       }
       settled = true;
+      tryEmitChildResourceDiag();
       if (diag) {
         finishDiag(diag.label, diag.code, diag.dumpStreams);
       }
@@ -14240,7 +14639,7 @@ ${truncateForDiag(outBody, DIAG_STDOUT_MAX)}`);
 }
 
 // src/analysis/aceTraceNormalize.ts
-var fs17 = __toESM(require("fs"));
+var fs19 = __toESM(require("fs"));
 var ACE_VERSION = "1.0.0-draft";
 var REASONING_PHASES = /* @__PURE__ */ new Set([
   "explore",
@@ -14385,7 +14784,7 @@ function sanitizePlaybookHooks(input) {
 function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical, diagnosticLog) {
   let raw;
   try {
-    raw = fs17.readFileSync(traceAbsolutePath, "utf-8");
+    raw = fs19.readFileSync(traceAbsolutePath, "utf-8");
   } catch (e) {
     diagnosticLog?.(`[ace] trace normalize read failed: ${e instanceof Error ? e.message : String(e)}`);
     return false;
@@ -14430,7 +14829,7 @@ function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical,
     doc.playbookHooks = hooks;
   }
   try {
-    fs17.writeFileSync(traceAbsolutePath, `${JSON.stringify(doc, null, 2)}
+    fs19.writeFileSync(traceAbsolutePath, `${JSON.stringify(doc, null, 2)}
 `, "utf-8");
   } catch (e) {
     diagnosticLog?.(`[ace] trace normalize write failed: ${e instanceof Error ? e.message : String(e)}`);
@@ -14441,15 +14840,15 @@ function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical,
 }
 
 // src/analysis/aceOfflineLearn.ts
-var fs20 = __toESM(require("fs"));
+var fs22 = __toESM(require("fs"));
 var path20 = __toESM(require("path"));
 
 // src/analysis/aceCuratorApplier.ts
-var fs18 = __toESM(require("fs"));
+var fs20 = __toESM(require("fs"));
 var path18 = __toESM(require("path"));
 function writeJson(pathAbs, obj) {
-  fs18.mkdirSync(path18.dirname(pathAbs), { recursive: true });
-  fs18.writeFileSync(pathAbs, `${JSON.stringify(obj, null, 2)}
+  fs20.mkdirSync(path18.dirname(pathAbs), { recursive: true });
+  fs20.writeFileSync(pathAbs, `${JSON.stringify(obj, null, 2)}
 `, "utf-8");
 }
 function emptyPlaybook(agentStem) {
@@ -14475,7 +14874,7 @@ function applyAceCuratorDeltaFile(worktreeRoot, deltaAbsolutePath, log) {
   const pbPath = acePlaybookPath(contextDir2, agentStem);
   const ovPath = aceOverlayPath(contextDir2, agentStem);
   let playbook;
-  if (fs18.existsSync(pbPath)) {
+  if (fs20.existsSync(pbPath)) {
     const pv = validateAceJsonFile(pbPath, playbookSchema);
     if (!pv.ok) {
       return { ok: false, message: `Existing playbook invalid: ${pv.message}` };
@@ -14485,7 +14884,7 @@ function applyAceCuratorDeltaFile(worktreeRoot, deltaAbsolutePath, log) {
     playbook = emptyPlaybook(agentStem);
   }
   let overlay;
-  if (fs18.existsSync(ovPath)) {
+  if (fs20.existsSync(ovPath)) {
     const ov = validateAceJsonFile(ovPath, overlaySchema);
     if (!ov.ok) {
       return { ok: false, message: `Existing overlay invalid: ${ov.message}` };
@@ -14563,7 +14962,7 @@ function applyAceCuratorDeltaFile(worktreeRoot, deltaAbsolutePath, log) {
 }
 
 // src/analysis/aceOfflineLearnFallbacks.ts
-var fs19 = __toESM(require("fs"));
+var fs21 = __toESM(require("fs"));
 var path19 = __toESM(require("path"));
 var ACE_VERSION2 = "1.0.0-draft";
 function buildEmptyReflectorLessons(traceRelativePath, sessionRunId) {
@@ -14588,8 +14987,8 @@ function buildEmptyCuratorDelta(agentStem, lessonsRelativePath) {
 function appendAceConsolidatedSessionRecord(contextDir2, record, diagnosticLog) {
   const abs = aceConsolidatedSessionsJsonlPath(contextDir2);
   const rel = path19.relative(contextDir2, abs).split(path19.sep).join("/");
-  fs19.mkdirSync(aceLearningsRoot(contextDir2), { recursive: true });
-  fs19.appendFileSync(abs, `${JSON.stringify(record)}
+  fs21.mkdirSync(aceLearningsRoot(contextDir2), { recursive: true });
+  fs21.appendFileSync(abs, `${JSON.stringify(record)}
 `, "utf-8");
   diagnosticLog?.(`[ace] consolidated session record appended \u2014 ${rel}`);
 }
@@ -14611,7 +15010,7 @@ function safeRunIdSegment(runId) {
 }
 function readHead(p, max) {
   try {
-    const raw = fs20.readFileSync(p, "utf-8");
+    const raw = fs22.readFileSync(p, "utf-8");
     return raw.length <= max ? raw : `${raw.slice(0, max)}
 \u2026 (truncated)`;
   } catch {
@@ -14620,12 +15019,12 @@ function readHead(p, max) {
 }
 function listAceTraceFiles(contextDir2) {
   const root = path20.join(aceLearningsRoot(contextDir2), "traces");
-  if (!fs20.existsSync(root)) {
+  if (!fs22.existsSync(root)) {
     return [];
   }
   const out = [];
   const walk = (dir) => {
-    for (const e of fs20.readdirSync(dir, { withFileTypes: true })) {
+    for (const e of fs22.readdirSync(dir, { withFileTypes: true })) {
       const full = path20.join(dir, e.name);
       if (e.isDirectory()) {
         walk(full);
@@ -14653,14 +15052,14 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   const traceRel = path20.relative(contextDir2, traceAbsolutePath).split(path20.sep).join("/");
   const lessonsAbs = aceReflectionPath(contextDir2, agentStem, safeId);
   const deltaAbs = aceCurationPath(contextDir2, agentStem, safeId);
-  fs20.mkdirSync(path20.dirname(lessonsAbs), { recursive: true });
-  fs20.mkdirSync(path20.dirname(deltaAbs), { recursive: true });
+  fs22.mkdirSync(path20.dirname(lessonsAbs), { recursive: true });
+  fs22.mkdirSync(path20.dirname(deltaAbs), { recursive: true });
   const pbPath = path20.join(aceLearningsRoot(contextDir2), `${agentStem}.json`);
   const ovPath = path20.join(aceLearningsRoot(contextDir2), "overlays", `${agentStem}.json`);
-  const pbExcerpt = fs20.existsSync(pbPath) ? readHead(pbPath, 6e3) : "(no playbook yet)";
-  const ovExcerpt = fs20.existsSync(ovPath) ? readHead(ovPath, 4e3) : "(no overlay yet)";
+  const pbExcerpt = fs22.existsSync(pbPath) ? readHead(pbPath, 6e3) : "(no playbook yet)";
+  const ovExcerpt = fs22.existsSync(ovPath) ? readHead(ovPath, 4e3) : "(no overlay yet)";
   const runDir = path20.join(opts.worktreeRoot, ".opencode", "_run");
-  fs20.mkdirSync(runDir, { recursive: true });
+  fs22.mkdirSync(runDir, { recursive: true });
   let reflectorUsedEmptyFallback = false;
   let curatorUsedEmptyFallback = false;
   const reflectPrompt = [
@@ -14679,7 +15078,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     "Schema: `aceSchemaVersion` **1.0.0-draft**, `sourceTrace`, `lessons` (see ace-reflector-lessons schema)."
   ].join("\n");
   const reflectPromptPath = path20.join(runDir, `ace-reflect-${safeId}-${Date.now()}.prompt.txt`);
-  fs20.writeFileSync(reflectPromptPath, reflectPrompt, "utf-8");
+  fs22.writeFileSync(reflectPromptPath, reflectPrompt, "utf-8");
   const reflectVars = {
     promptFile: reflectPromptPath,
     agentId: ACE_REFLECTOR_AGENT_STEM,
@@ -14711,11 +15110,11 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   if (!rCli.ok) {
     return { ok: false, message: `[ace] reflector OpenCode failed: ${rCli.message}` };
   }
-  if (!fs20.existsSync(lessonsAbs)) {
+  if (!fs22.existsSync(lessonsAbs)) {
     const recovered = extractJsonObjectWithTopLevelKeys(rCli.message, ["aceSchemaVersion", "sourceTrace", "lessons"]);
     if (recovered) {
       try {
-        fs20.writeFileSync(lessonsAbs, `${recovered}
+        fs22.writeFileSync(lessonsAbs, `${recovered}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] reflector recovered from OpenCode stdout/stderr \u2192 ${lessonsAbs}`);
       } catch (e) {
@@ -14725,7 +15124,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
       }
     }
   }
-  if (!fs20.existsSync(lessonsAbs)) {
+  if (!fs22.existsSync(lessonsAbs)) {
     return { ok: false, message: `[ace] reflector output missing: ${lessonsAbs}` };
   }
   let lv = validateAceJsonFile(lessonsAbs, reflectorSchema);
@@ -14737,7 +15136,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     ]);
     if (recoveredAgain) {
       try {
-        fs20.writeFileSync(lessonsAbs, `${recoveredAgain}
+        fs22.writeFileSync(lessonsAbs, `${recoveredAgain}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] reflector re-recovered from CLI output after schema failure \u2192 ${lessonsAbs}`);
         lv = validateAceJsonFile(lessonsAbs, reflectorSchema);
@@ -14751,7 +15150,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   if (!lv.ok) {
     const hint = lv.message.length > 220 ? `${lv.message.slice(0, 220)}\u2026` : lv.message;
     opts.diagnosticLog?.(`[ace] reflector lessons failed schema \u2014 writing valid empty lessons \u2014 ${hint}`);
-    fs20.writeFileSync(
+    fs22.writeFileSync(
       lessonsAbs,
       `${JSON.stringify(buildEmptyReflectorLessons(traceRel, runId), null, 2)}
 `,
@@ -14798,7 +15197,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     "Schema: `aceSchemaVersion` **1.0.0-draft**, `agentStem`, `sourceLessons`, `operations` (see ace-curator-delta schema)."
   ].join("\n");
   const curPromptPath = path20.join(runDir, `ace-curate-${safeId}-${Date.now()}.prompt.txt`);
-  fs20.writeFileSync(curPromptPath, curPrompt, "utf-8");
+  fs22.writeFileSync(curPromptPath, curPrompt, "utf-8");
   const curVars = {
     promptFile: curPromptPath,
     agentId: ACE_CURATOR_AGENT_STEM,
@@ -14829,7 +15228,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   if (!cCli.ok) {
     return { ok: false, message: `[ace] curator OpenCode failed: ${cCli.message}` };
   }
-  if (!fs20.existsSync(deltaAbs)) {
+  if (!fs22.existsSync(deltaAbs)) {
     const recovered = extractJsonObjectWithTopLevelKeys(cCli.message, [
       "aceSchemaVersion",
       "agentStem",
@@ -14838,7 +15237,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     ]);
     if (recovered) {
       try {
-        fs20.writeFileSync(deltaAbs, `${recovered}
+        fs22.writeFileSync(deltaAbs, `${recovered}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] curator recovered from OpenCode stdout/stderr \u2192 ${deltaAbs}`);
       } catch (e) {
@@ -14848,7 +15247,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
       }
     }
   }
-  if (!fs20.existsSync(deltaAbs)) {
+  if (!fs22.existsSync(deltaAbs)) {
     return { ok: false, message: `[ace] curator output missing: ${deltaAbs}` };
   }
   let dv = validateAceJsonFile(deltaAbs, curatorSchema);
@@ -14861,7 +15260,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     ]);
     if (recoveredCur) {
       try {
-        fs20.writeFileSync(deltaAbs, `${recoveredCur}
+        fs22.writeFileSync(deltaAbs, `${recoveredCur}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] curator re-recovered from CLI output after schema failure \u2192 ${deltaAbs}`);
         dv = validateAceJsonFile(deltaAbs, curatorSchema);
@@ -14875,7 +15274,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   if (!dv.ok) {
     const hint = dv.message.length > 220 ? `${dv.message.slice(0, 220)}\u2026` : dv.message;
     opts.diagnosticLog?.(`[ace] curator delta failed schema \u2014 writing valid empty operations \u2014 ${hint}`);
-    fs20.writeFileSync(
+    fs22.writeFileSync(
       deltaAbs,
       `${JSON.stringify(buildEmptyCuratorDelta(agentStem, lessonsRel), null, 2)}
 `,
@@ -14894,9 +15293,9 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   let lessonCount = 0;
   let curatorOperationCount = 0;
   try {
-    const lessonsDoc = JSON.parse(fs20.readFileSync(lessonsAbs, "utf-8"));
+    const lessonsDoc = JSON.parse(fs22.readFileSync(lessonsAbs, "utf-8"));
     lessonCount = Array.isArray(lessonsDoc.lessons) ? lessonsDoc.lessons.length : 0;
-    const deltaDoc = JSON.parse(fs20.readFileSync(deltaAbs, "utf-8"));
+    const deltaDoc = JSON.parse(fs22.readFileSync(deltaAbs, "utf-8"));
     curatorOperationCount = Array.isArray(deltaDoc.operations) ? deltaDoc.operations.length : 0;
   } catch {
   }
@@ -14955,9 +15354,9 @@ async function runAceTracePhase(params) {
   const contextDir2 = gluecharmContextDir(params.worktreeRoot);
   const traceStem = aceTraceFileRunStem(params.artefactRunId, params.followUpSessionId);
   const traceAbs = aceTracePath(contextDir2, params.producerAgentStem, traceStem);
-  fs21.mkdirSync(path21.dirname(traceAbs), { recursive: true });
+  fs23.mkdirSync(path21.dirname(traceAbs), { recursive: true });
   const schemaAbs = opencodeAceSchemaPath(params.worktreeRoot, ACE_SCHEMA_TRACE);
-  if (!fs21.existsSync(schemaAbs)) {
+  if (!fs23.existsSync(schemaAbs)) {
     const msg = `[ace] trace skipped \u2014 schema missing: ${schemaAbs}`;
     params.diagnosticLog?.(msg);
     return { ok: false, message: msg };
@@ -15006,9 +15405,9 @@ async function runAceTracePhase(params) {
     `Use only evidence from this session's transcript and tool history.`
   ].join("\n");
   const runDir = path21.join(params.worktreeRoot, ".opencode", "_run");
-  fs21.mkdirSync(runDir, { recursive: true });
+  fs23.mkdirSync(runDir, { recursive: true });
   const promptPath = path21.join(runDir, `ace-trace-${traceStem}-${Date.now()}.prompt.txt`);
-  fs21.writeFileSync(promptPath, promptBody, "utf-8");
+  fs23.writeFileSync(promptPath, promptBody, "utf-8");
   const vars = {
     promptFile: promptPath,
     agentId: ACE_TRACE_RECORDER_AGENT_STEM,
@@ -15032,7 +15431,7 @@ async function runAceTracePhase(params) {
   if (!cli.ok) {
     return { ok: false, message: `[ace] trace OpenCode failed: ${cli.message}` };
   }
-  if (!fs21.existsSync(traceAbs)) {
+  if (!fs23.existsSync(traceAbs)) {
     const recovered = extractJsonObjectWithTopLevelKeys(cli.message, [
       "aceSchemaVersion",
       "sessionMeta",
@@ -15040,7 +15439,7 @@ async function runAceTracePhase(params) {
     ]);
     if (recovered) {
       try {
-        fs21.writeFileSync(traceAbs, `${recovered}
+        fs23.writeFileSync(traceAbs, `${recovered}
 `, "utf-8");
         params.diagnosticLog?.(`[ace] trace recovered from OpenCode stdout/stderr \u2192 ${traceAbs}`);
       } catch (e) {
@@ -15050,7 +15449,7 @@ async function runAceTracePhase(params) {
       }
     }
   }
-  if (!fs21.existsSync(traceAbs)) {
+  if (!fs23.existsSync(traceAbs)) {
     const msg = `[ace] trace file missing after run: ${traceAbs}`;
     params.diagnosticLog?.(msg);
     return { ok: false, message: msg };
@@ -15082,7 +15481,7 @@ async function runAceTracePhase(params) {
     return { ok: false, message: msg };
   }
   try {
-    const rawAlign = fs21.readFileSync(traceAbs, "utf-8");
+    const rawAlign = fs23.readFileSync(traceAbs, "utf-8");
     const docAlign = JSON.parse(rawAlign);
     const smRun = docAlign.sessionMeta?.runId;
     if (typeof smRun !== "string" || smRun !== traceStem) {
@@ -15138,7 +15537,7 @@ async function runAceTracePhase(params) {
 }
 
 // src/analysis/coordinationListJsonValidate.ts
-var fs22 = __toESM(require("fs"));
+var fs24 = __toESM(require("fs"));
 var import__4 = __toESM(require__());
 function stripUtf8Bom3(s) {
   return s.length > 0 && s.charCodeAt(0) === 65279 ? s.slice(1) : s;
@@ -15202,7 +15601,7 @@ function formatAjvErrors4(errors) {
 function validateCoordinationListJson(jsonAbsolutePath, schemaAbsolutePath) {
   let raw;
   try {
-    raw = stripUtf8Bom3(fs22.readFileSync(jsonAbsolutePath, "utf-8"));
+    raw = stripUtf8Bom3(fs24.readFileSync(jsonAbsolutePath, "utf-8"));
   } catch (e) {
     return {
       ok: false,
@@ -15218,7 +15617,7 @@ function validateCoordinationListJson(jsonAbsolutePath, schemaAbsolutePath) {
   }
   let schemaRaw;
   try {
-    schemaRaw = stripUtf8Bom3(fs22.readFileSync(schemaAbsolutePath, "utf-8"));
+    schemaRaw = stripUtf8Bom3(fs24.readFileSync(schemaAbsolutePath, "utf-8"));
   } catch (e) {
     return {
       ok: false,
@@ -15279,7 +15678,7 @@ function validateCoordinationListJson(jsonAbsolutePath, schemaAbsolutePath) {
 var FILE_PREVIEW_MAX = 4e3;
 function readCoordinationJsonPreview(jsonAbsolutePath) {
   try {
-    const raw = stripUtf8Bom3(fs22.readFileSync(jsonAbsolutePath, "utf-8"));
+    const raw = stripUtf8Bom3(fs24.readFileSync(jsonAbsolutePath, "utf-8"));
     return raw.length <= FILE_PREVIEW_MAX ? raw : `${raw.slice(0, FILE_PREVIEW_MAX)}
 
 \u2026 (truncated)`;
@@ -15355,12 +15754,12 @@ function formatCoordinationJsonRepairAppendix(outputBasename, failure, rawFilePr
 }
 
 // src/analysis/coordinationListStableWrite.ts
-var fs24 = __toESM(require("fs"));
+var fs26 = __toESM(require("fs"));
 var path23 = __toESM(require("path"));
 
 // src/analysis/coordinationListFileLock.ts
-var fs23 = __toESM(require("fs"));
-var os = __toESM(require("os"));
+var fs25 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
 var path22 = __toESM(require("path"));
 var DEFAULT_COORDINATION_LIST_LOCK_TIMEOUT_MS = 12e4;
 var DEFAULT_COORDINATION_LIST_LOCK_STALE_MS = 30 * 60 * 1e3;
@@ -15380,7 +15779,7 @@ function lockPathForList(listJsonAbsolutePath) {
 }
 function tryReadLockBody(lockAbs) {
   try {
-    const raw = fs23.readFileSync(lockAbs, "utf-8");
+    const raw = fs25.readFileSync(lockAbs, "utf-8");
     const j = JSON.parse(raw);
     if (typeof j.pid === "number" && typeof j.createdAt === "string") {
       return j;
@@ -15392,7 +15791,7 @@ function tryReadLockBody(lockAbs) {
 function tryRemoveStaleLock(lockAbs, staleMs, diagnosticLog) {
   let st;
   try {
-    st = fs23.statSync(lockAbs);
+    st = fs25.statSync(lockAbs);
   } catch {
     return false;
   }
@@ -15407,7 +15806,7 @@ function tryRemoveStaleLock(lockAbs, staleMs, diagnosticLog) {
     return false;
   }
   try {
-    fs23.unlinkSync(lockAbs);
+    fs25.unlinkSync(lockAbs);
     diagnosticLog?.(`[coord-lock] removed stale lock ${lockAbs} (age ${Math.round(age)} ms)`);
     return true;
   } catch {
@@ -15424,11 +15823,11 @@ async function withCoordinationListFileLock(listJsonAbsolutePath, options, fn) {
   while (!acquired && Date.now() < deadline) {
     const body = {
       pid: process.pid,
-      host: os.hostname(),
+      host: os3.hostname(),
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      fs23.writeFileSync(lockAbs, `${JSON.stringify(body, null, 0)}
+      fs25.writeFileSync(lockAbs, `${JSON.stringify(body, null, 0)}
 `, { encoding: "utf-8", flag: "wx" });
       acquired = true;
       diagnosticLog?.(`[coord-lock] acquired ${path22.basename(lockAbs)}`);
@@ -15452,7 +15851,7 @@ async function withCoordinationListFileLock(listJsonAbsolutePath, options, fn) {
     return await fn();
   } finally {
     try {
-      fs23.unlinkSync(lockAbs);
+      fs25.unlinkSync(lockAbs);
       diagnosticLog?.(`[coord-lock] released ${path22.basename(lockAbs)}`);
     } catch {
     }
@@ -15826,13 +16225,13 @@ function buildCascadePathsForDroppedCodes(listBasename, droppedCodes, contextDir
   const paths = [];
   const tryPush = (p) => {
     const abs = path23.join(contextDirAbs, p);
-    if (fs24.existsSync(abs)) {
+    if (fs26.existsSync(abs)) {
       paths.push(abs);
     }
   };
   const listDir = () => {
     try {
-      return fs24.readdirSync(contextDirAbs);
+      return fs26.readdirSync(contextDirAbs);
     } catch {
       return [];
     }
@@ -16033,7 +16432,7 @@ async function finalizeCoordinationListWrite(p) {
       async () => {
         let agentRaw;
         try {
-          agentRaw = fs24.readFileSync(p.listJsonAbsolutePath, "utf-8");
+          agentRaw = fs26.readFileSync(p.listJsonAbsolutePath, "utf-8");
         } catch (e) {
           return { ok: false, message: `SRS-50 re-read failed: ${e instanceof Error ? e.message : String(e)}` };
         }
@@ -16061,7 +16460,7 @@ async function finalizeCoordinationListWrite(p) {
         p.diagnosticLog?.(formatStableWriteDiagnosticLine(p.listBasename, m.diff));
         const tmp = `${p.listJsonAbsolutePath}.tmp.${process.pid}`;
         try {
-          fs24.writeFileSync(tmp, `${JSON.stringify(m.merged, null, 2)}
+          fs26.writeFileSync(tmp, `${JSON.stringify(m.merged, null, 2)}
 `, "utf-8");
         } catch (e) {
           return { ok: false, message: `SRS-50 temp write failed: ${e instanceof Error ? e.message : String(e)}` };
@@ -16069,14 +16468,14 @@ async function finalizeCoordinationListWrite(p) {
         const v = validateCoordinationListJson(tmp, p.schemaAbsolutePath);
         if (!v.ok) {
           try {
-            fs24.unlinkSync(tmp);
+            fs26.unlinkSync(tmp);
           } catch {
           }
           const detail = v.failure.kind === "schema" ? v.failure.errorsText : v.failure.kind === "parse" ? v.failure.message : v.failure.message;
           return { ok: false, message: `SRS-50 merged output failed schema: ${detail}` };
         }
         try {
-          fs24.renameSync(tmp, p.listJsonAbsolutePath);
+          fs26.renameSync(tmp, p.listJsonAbsolutePath);
         } catch (e) {
           return { ok: false, message: `SRS-50 rename failed: ${e instanceof Error ? e.message : String(e)}` };
         }
@@ -16146,7 +16545,7 @@ function allocateNextListRowCode(input) {
   }
   let names = [];
   try {
-    names = fs24.readdirSync(contextDirAbs);
+    names = fs26.readdirSync(contextDirAbs);
   } catch {
     names = [];
   }
@@ -16189,7 +16588,7 @@ function allocateNextListRowCode(input) {
 }
 
 // src/analysis/markdownEvidenceIndexValidate.ts
-var fs25 = __toESM(require("fs"));
+var fs27 = __toESM(require("fs"));
 var EVIDENCE_HEADING = "## Evidence index";
 function evidenceIndexMentionsReadmeMd(body) {
   const re = /README\.md/gi;
@@ -16317,7 +16716,7 @@ function markdownEvidenceValidationPasses(content) {
 function validateMarkdownEvidenceIndexFile(absolutePath) {
   let text;
   try {
-    const buf = fs25.readFileSync(absolutePath);
+    const buf = fs27.readFileSync(absolutePath);
     const decoder = new TextDecoder("utf-8", { fatal: true });
     text = decoder.decode(buf);
   } catch (e) {
@@ -16358,7 +16757,7 @@ function formatMarkdownEvidenceRepairAppendix(outputFileAbsolute, kind = "empty"
 }
 
 // src/analysis/openQuestionResolution.ts
-var fs26 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 var path24 = __toESM(require("path"));
 var OPEN_QUESTION_RESOLUTION_JSON_BASENAME = "open-question-resolution.json";
 function openQuestionResolutionJsonAbsolute(worktreeRoot) {
@@ -16397,10 +16796,10 @@ function parseOpenQuestionResolutionJsonText(raw) {
 function readOpenQuestionResolutionFile(worktreeRoot) {
   const p = openQuestionResolutionJsonAbsolute(worktreeRoot);
   try {
-    if (!fs26.existsSync(p)) {
+    if (!fs28.existsSync(p)) {
       return { ok: false, error: `Missing resolution file: ${p}` };
     }
-    const raw = fs26.readFileSync(p, "utf-8");
+    const raw = fs28.readFileSync(p, "utf-8");
     return parseOpenQuestionResolutionJsonText(raw);
   } catch (e) {
     const m = e instanceof Error ? e.message : String(e);
@@ -16410,15 +16809,15 @@ function readOpenQuestionResolutionFile(worktreeRoot) {
 function deleteOpenQuestionResolutionFile(worktreeRoot) {
   try {
     const p = openQuestionResolutionJsonAbsolute(worktreeRoot);
-    if (fs26.existsSync(p)) {
-      fs26.unlinkSync(p);
+    if (fs28.existsSync(p)) {
+      fs28.unlinkSync(p);
     }
   } catch {
   }
 }
 
 // src/analysis/openQuestionsSectionValidate.ts
-var fs27 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
 var CANONICAL_NORMALIZED = "open questions";
 function normalizeOpenQuestionsHeadingTitle(raw) {
@@ -16551,7 +16950,7 @@ function validateOpenQuestionsSectionFile(absolutePath, scope) {
   }
   let text;
   try {
-    const buf = fs27.readFileSync(absolutePath);
+    const buf = fs29.readFileSync(absolutePath);
     const decoder = new TextDecoder("utf-8", { fatal: true });
     text = decoder.decode(buf);
   } catch (e) {
@@ -17106,7 +17505,7 @@ function clampMarkdownOpenQuestionIterations(raw) {
 }
 function getExpectedOutputArtefactStatus(absolutePath) {
   try {
-    const st = fs28.statSync(absolutePath);
+    const st = fs30.statSync(absolutePath);
     if (!st.isFile()) {
       return { generated: false, reason: "not_a_file" };
     }
@@ -17205,7 +17604,7 @@ function outputPaths(step, worktreeRoot, listTarget) {
 }
 async function runOpenQuestionResolutionWorkstation(opts) {
   const runDir = path26.join(opts.worktreeRoot, ".opencode", "_run");
-  fs28.mkdirSync(runDir, { recursive: true });
+  fs30.mkdirSync(runDir, { recursive: true });
   const resolutionJsonAbsolute = openQuestionResolutionJsonAbsolute(opts.worktreeRoot);
   const body = fillResolveOpenQuestionPrompt({
     worktreeRoot: opts.worktreeRoot,
@@ -17215,7 +17614,7 @@ async function runOpenQuestionResolutionWorkstation(opts) {
     resolutionJsonAbsolute
   });
   const promptPath = path26.join(runDir, `resolve-open-question-${Date.now()}.prompt.txt`);
-  fs28.writeFileSync(promptPath, body, "utf-8");
+  fs30.writeFileSync(promptPath, body, "utf-8");
   const vars = {
     promptFile: promptPath,
     agentId: RESOLVE_OPEN_QUESTION_AGENT_STEM,
@@ -17279,7 +17678,7 @@ ${cli.message}`,
 }
 async function runOpenCodeMarkdownEvidenceRepairLoop(input) {
   const totalMarkdownRuns = 1 + input.maxMarkdownEvidenceRepairs;
-  fs28.mkdirSync(input.runDir, { recursive: true });
+  fs30.mkdirSync(input.runDir, { recursive: true });
   let attemptIndex = 0;
   let capturedProducerSessionId;
   const repair = await runWorkstationRepairLoop({
@@ -17302,7 +17701,7 @@ async function runOpenCodeMarkdownEvidenceRepairLoop(input) {
       const idx = attemptIndex;
       const promptPath = input.promptPathForAttempt(idx);
       attemptIndex += 1;
-      fs28.writeFileSync(promptPath, body, "utf-8");
+      fs30.writeFileSync(promptPath, body, "utf-8");
       const vars = input.argvVarsForPrompt(promptPath);
       const expanded = expandArgvTemplate3(input.argvTemplate, vars);
       const followUpSessionId = input.resolveFollowUpSessionId({
@@ -17794,7 +18193,7 @@ async function runCoordinationListWorkstation(opts) {
   let schemaAbsoluteForList;
   if (effectiveListSchemaFile) {
     schemaAbsoluteForList = schemaRef(opts.worktreeRoot, effectiveListSchemaFile);
-    if (!fs28.existsSync(schemaAbsoluteForList)) {
+    if (!fs30.existsSync(schemaAbsoluteForList)) {
       return {
         ok: false,
         message: `JSON Schema not found: ${schemaAbsoluteForList}
@@ -17807,11 +18206,11 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
   }
   if (opts.step === "reviewExperiencesList" && effectiveListSchemaFile) {
     const schemaAbs = schemaRef(opts.worktreeRoot, effectiveListSchemaFile);
-    if (fs28.existsSync(outputFileAbsolute)) {
+    if (fs30.existsSync(outputFileAbsolute)) {
       const v = validateCoordinationListJson(outputFileAbsolute, schemaAbs);
       if (v.ok) {
         try {
-          const raw = fs28.readFileSync(outputFileAbsolute, "utf-8");
+          const raw = fs30.readFileSync(outputFileAbsolute, "utf-8");
           const data = JSON.parse(raw);
           if (Array.isArray(data.views) && data.views.length === 0) {
             return {
@@ -17827,9 +18226,9 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
       }
     }
   }
-  fs28.mkdirSync(path26.dirname(outputFileAbsolute), { recursive: true });
+  fs30.mkdirSync(path26.dirname(outputFileAbsolute), { recursive: true });
   const runDir = path26.join(opts.worktreeRoot, ".opencode", "_run");
-  fs28.mkdirSync(runDir, { recursive: true });
+  fs30.mkdirSync(runDir, { recursive: true });
   const scopeSuffix = (opts.step === "listUseCases" || opts.step === "reviewUseCasesList") && opts.listTarget?.featureCode ? `-${opts.listTarget.featureCode}` : (opts.step === "listScenarios" || opts.step === "reviewScenariosList") && opts.listTarget?.featureCode && opts.listTarget?.useCaseCode ? `-${opts.listTarget.featureCode}_${opts.listTarget.useCaseCode}` : (opts.step === "listEntityFields" || opts.step === "reviewEntityFieldsList") && opts.listTarget?.entityCode ? `-${opts.listTarget.entityCode}` : "";
   const rawRepair = opts.listJsonSchemaRepairAttempts;
   let maxRepairAttempts = rawRepair === void 0 ? 1 : Math.floor(Number(rawRepair));
@@ -17848,8 +18247,8 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
   let preImageDocForStableWrite = {};
   if (effectiveListSchemaFile && schemaAbsoluteForList && shouldApplyStableMergeForCoordinationBasename(outputBasename)) {
     try {
-      if (fs28.existsSync(outputFileAbsolute)) {
-        preImageDocForStableWrite = JSON.parse(fs28.readFileSync(outputFileAbsolute, "utf-8"));
+      if (fs30.existsSync(outputFileAbsolute)) {
+        preImageDocForStableWrite = JSON.parse(fs30.readFileSync(outputFileAbsolute, "utf-8"));
       }
     } catch {
       preImageDocForStableWrite = {};
@@ -18038,7 +18437,7 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
       );
       const promptPath = path26.join(runDir, `${opts.step}${scopeSuffix}-a${attempt}-${Date.now()}.prompt.txt`);
       lastPromptPath = promptPath;
-      fs28.writeFileSync(promptPath, body, "utf-8");
+      fs30.writeFileSync(promptPath, body, "utf-8");
       const vars = {
         promptFile: promptPath,
         agentId: STEP_OPEN_CODE_AGENT_IDS[opts.step],
@@ -18278,9 +18677,9 @@ async function runDetailMarkdownWorkstation(opts) {
   }
   maxMarkdownEvidenceRepairs = Math.min(5, Math.max(0, maxMarkdownEvidenceRepairs));
   const totalMarkdownRuns = 1 + maxMarkdownEvidenceRepairs;
-  fs28.mkdirSync(path26.dirname(outputFileAbsolute), { recursive: true });
+  fs30.mkdirSync(path26.dirname(outputFileAbsolute), { recursive: true });
   const runDir = path26.join(opts.worktreeRoot, ".opencode", "_run");
-  fs28.mkdirSync(runDir, { recursive: true });
+  fs30.mkdirSync(runDir, { recursive: true });
   const safeStem = opts.target.outputBasename.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 120);
   let lastPromptPath = "";
   let lastCliMessage = "";
@@ -18522,18 +18921,18 @@ Expected output: ${outputFileAbsolute}`;
 }
 
 // src/analysis/worktreeManager.ts
-var import_child_process3 = require("child_process");
-var fs29 = __toESM(require("fs"));
-var os2 = __toESM(require("os"));
+var import_child_process4 = require("child_process");
+var fs31 = __toESM(require("fs"));
+var os4 = __toESM(require("os"));
 var path27 = __toESM(require("path"));
 
 // src/analysis/gitWorktreeStaleRecovery.ts
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 function isMissingRegisteredWorktreeError(combinedStderrStdout) {
   return /missing but already registered worktree/i.test(combinedStderrStdout);
 }
 function gitWorktreePruneSync(repoRoot) {
-  const r = (0, import_child_process2.spawnSync)("git", ["worktree", "prune"], {
+  const r = (0, import_child_process3.spawnSync)("git", ["worktree", "prune"], {
     cwd: repoRoot,
     encoding: "utf-8",
     timeout: 6e4
@@ -18554,7 +18953,7 @@ function maxEasyspecsWorktreeIndex(parentDir) {
   let max = 0;
   let entries;
   try {
-    entries = fs29.readdirSync(parentDir, { withFileTypes: true });
+    entries = fs31.readdirSync(parentDir, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -18577,19 +18976,19 @@ function formatEasyspecsWorktreeFolderName(index) {
   return `easyspecs-${String(index).padStart(3, "0")}`;
 }
 function allocateEasyspecsWorktreePath(parentDir) {
-  fs29.mkdirSync(parentDir, { recursive: true });
+  fs31.mkdirSync(parentDir, { recursive: true });
   const start = maxEasyspecsWorktreeIndex(parentDir);
   for (let i = start + 1; i < start + 1e4; i++) {
     const name = formatEasyspecsWorktreeFolderName(i);
     const wt = path27.join(parentDir, name);
-    if (!fs29.existsSync(wt)) {
+    if (!fs31.existsSync(wt)) {
       return wt;
     }
   }
   return null;
 }
 function readHeadBranchShort(repoRoot) {
-  const r = (0, import_child_process3.spawnSync)("git", ["symbolic-ref", "--short", "-q", "HEAD"], {
+  const r = (0, import_child_process4.spawnSync)("git", ["symbolic-ref", "--short", "-q", "HEAD"], {
     cwd: repoRoot,
     encoding: "utf-8",
     timeout: 3e4
@@ -18607,20 +19006,20 @@ function attachWorktreeHandle(worktreePath, repositoryRoot) {
     path: wt,
     repoRoot: repo,
     remove() {
-      (0, import_child_process3.spawnSync)("git", ["worktree", "remove", "--force", wt], {
+      (0, import_child_process4.spawnSync)("git", ["worktree", "remove", "--force", wt], {
         cwd: repo,
         encoding: "utf-8",
         timeout: 6e4
       });
       try {
-        fs29.rmSync(wt, { recursive: true, force: true });
+        fs31.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
   };
 }
 function createAnalysisWorktree(repoRoot, options) {
-  const parent = path27.join(os2.tmpdir(), "easyspecs-analysis");
+  const parent = path27.join(os4.tmpdir(), "easyspecs-analysis");
   const wt = allocateEasyspecsWorktreePath(parent);
   if (!wt) {
     return {
@@ -18630,7 +19029,7 @@ function createAnalysisWorktree(repoRoot, options) {
   }
   const sourceBranchAtCreation = readHeadBranchShort(repoRoot);
   for (let attempt = 0; attempt < 2; attempt++) {
-    const r = (0, import_child_process3.spawnSync)("git", ["worktree", "add", "--detach", wt, "HEAD"], {
+    const r = (0, import_child_process4.spawnSync)("git", ["worktree", "add", "--detach", wt, "HEAD"], {
       cwd: repoRoot,
       encoding: "utf-8",
       timeout: 12e4
@@ -18748,7 +19147,7 @@ function noteOpenCodeAgentLaunched() {
 }
 
 // src/contextIndexAssembler.ts
-var fs30 = __toESM(require("fs"));
+var fs32 = __toESM(require("fs"));
 var path28 = __toESM(require("path"));
 
 // src/srsModel.ts
@@ -18783,7 +19182,7 @@ function tryAttachMarkdown(node, contextDir2, relativePath) {
   }
   const full = path28.join(contextDir2, norm);
   try {
-    if (!fs30.existsSync(full) || !fs30.statSync(full).isFile()) {
+    if (!fs32.existsSync(full) || !fs32.statSync(full).isFile()) {
       return false;
     }
   } catch {
@@ -18841,10 +19240,10 @@ function mergePersistedIndexUploadMetadata(previous, next) {
 function tryReadExistingIndexForMerge(contextDir2) {
   const p = path28.join(contextDir2, "index-application-context.json");
   try {
-    if (!fs30.existsSync(p)) {
+    if (!fs32.existsSync(p)) {
       return null;
     }
-    const j = JSON.parse(fs30.readFileSync(p, "utf8"));
+    const j = JSON.parse(fs32.readFileSync(p, "utf8"));
     if (j && typeof j === "object" && j.kind === APPLICATION_CONTEXT_KIND) {
       return j;
     }
@@ -18999,7 +19398,7 @@ function applyDetailMarkdownToDocument(doc, contextDir2) {
 }
 function readJson2(filePath) {
   try {
-    const raw = fs30.readFileSync(filePath, "utf-8");
+    const raw = fs32.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -19179,11 +19578,11 @@ function writeIndexApplicationContext(contextDir2, title, options) {
   const target = path28.join(contextDir2, "index-application-context.json");
   const tmp = `${target}.${process.pid}.tmp`;
   try {
-    fs30.writeFileSync(tmp, JSON.stringify(doc, null, 2), "utf-8");
-    fs30.renameSync(tmp, target);
+    fs32.writeFileSync(tmp, JSON.stringify(doc, null, 2), "utf-8");
+    fs32.renameSync(tmp, target);
   } catch (e) {
     try {
-      fs30.unlinkSync(tmp);
+      fs32.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -19192,7 +19591,7 @@ function writeIndexApplicationContext(contextDir2, title, options) {
 }
 
 // src/pipelines/linkMapping/linkMappingPipeline.ts
-var fs31 = __toESM(require("node:fs"));
+var fs33 = __toESM(require("node:fs"));
 var path29 = __toESM(require("node:path"));
 var SLUG2 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function safeStr2(v) {
@@ -19217,7 +19616,7 @@ function slugOrFallback2(row2) {
 }
 function readJson3(filePath) {
   try {
-    const raw = fs31.readFileSync(filePath, "utf-8");
+    const raw = fs33.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -19249,7 +19648,7 @@ function existsContextFile(contextDir2, rel) {
   }
   const full = path29.join(contextDir2, norm);
   try {
-    return fs31.existsSync(full) && fs31.statSync(full).isFile();
+    return fs33.existsSync(full) && fs33.statSync(full).isFile();
   } catch {
     return false;
   }
@@ -19346,7 +19745,7 @@ ${lines.join("\n")}
 function collectMarkdownFilesRecursive(dir, acc) {
   let entries;
   try {
-    entries = fs31.readdirSync(dir, { withFileTypes: true });
+    entries = fs33.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -19367,7 +19766,7 @@ function validateEasyspecsNavLinksInContext(contextDirAbs) {
   for (const abs of mdFiles) {
     let raw;
     try {
-      raw = fs31.readFileSync(abs, "utf8");
+      raw = fs33.readFileSync(abs, "utf8");
     } catch {
       continue;
     }
@@ -19393,7 +19792,7 @@ function validateEasyspecsNavLinksInContext(contextDirAbs) {
         }
         const target = path29.normalize(path29.join(path29.dirname(abs), href));
         try {
-          if (!fs31.existsSync(target) || !fs31.statSync(target).isFile()) {
+          if (!fs33.existsSync(target) || !fs33.statSync(target).isFile()) {
             broken.push(`${path29.relative(contextDirAbs, abs)} \u2192 ${href}`);
           }
         } catch {
@@ -19419,7 +19818,7 @@ function validateEasyspecsNavLinksInContext(contextDirAbs) {
         }
         const target = path29.normalize(path29.join(path29.dirname(abs), href));
         try {
-          if (!fs31.existsSync(target) || !fs31.statSync(target).isFile()) {
+          if (!fs33.existsSync(target) || !fs33.statSync(target).isFile()) {
             broken.push(`${path29.relative(contextDirAbs, abs)} \u2192 ${href}`);
           }
         } catch {
@@ -19627,7 +20026,7 @@ function renderProjectMdSections(contextDir2) {
     }
   }
   const dmListPath = path29.join(contextDir2, "data-model-list.json");
-  if (dmLines.length === 0 && fs31.existsSync(dmListPath)) {
+  if (dmLines.length === 0 && fs33.existsSync(dmListPath)) {
     dmLines.push(bulletLink("Data model registry (JSON)", "./data-model-list.json"));
   }
   chunks.push("### Data model", "", dmLines.length ? dmLines.join("\n") : NONE_LINE, "");
@@ -19635,23 +20034,23 @@ function renderProjectMdSections(contextDir2) {
 }
 function patchOneFile(contextDir2, basename17, innerChildren, innerParents, opts) {
   const abs = path29.join(contextDir2, basename17);
-  if (!fs31.existsSync(abs)) {
+  if (!fs33.existsSync(abs)) {
     return;
   }
   let body;
   try {
-    body = fs31.readFileSync(abs, "utf8");
+    body = fs33.readFileSync(abs, "utf8");
   } catch (e) {
     opts.log?.(`[pipeline:link-mapping] skip read ${basename17}: ${e instanceof Error ? e.message : String(e)}`);
     return;
   }
   let next = replaceOrAppendRegion(body, NAV_CHILDREN_START, NAV_CHILDREN_END, innerChildren);
   next = replaceOrAppendRegion(next, NAV_PARENTS_START, NAV_PARENTS_END, innerParents);
-  fs31.writeFileSync(abs, next, "utf8");
+  fs33.writeFileSync(abs, next, "utf8");
 }
 function runLinkMappingPipeline(contextDirAbs, opts = {}) {
   const contextDir2 = path29.resolve(contextDirAbs);
-  if (!fs31.existsSync(contextDir2) || !fs31.statSync(contextDir2).isDirectory()) {
+  if (!fs33.existsSync(contextDir2) || !fs33.statSync(contextDir2).isDirectory()) {
     return { ok: false, error: `Context directory does not exist: ${contextDir2}` };
   }
   const edges = buildNavEdges(contextDir2);
@@ -19679,7 +20078,7 @@ function runLinkMappingPipeline(contextDirAbs, opts = {}) {
       continue;
     }
     const abs = path29.join(contextDir2, basename17);
-    if (!fs31.existsSync(abs)) {
+    if (!fs33.existsSync(abs)) {
       continue;
     }
     const childRows = edges.children.get(basename17) ?? [];
@@ -19713,15 +20112,15 @@ var path30 = __toESM(require("node:path"));
 var vscode2 = __toESM(require_vscode_stub());
 
 // src/config/easyspecsAceConfigRead.ts
-var fs32 = __toESM(require("node:fs"));
+var fs34 = __toESM(require("node:fs"));
 function readRawConfigJson(repoRoot) {
   const p = easyspecsConfigPath(repoRoot);
-  if (!fs32.existsSync(p)) {
+  if (!fs34.existsSync(p)) {
     return void 0;
   }
   let raw;
   try {
-    raw = fs32.readFileSync(p, "utf8");
+    raw = fs34.readFileSync(p, "utf8");
   } catch {
     return void 0;
   }
@@ -19857,7 +20256,7 @@ function getAceOfflineLearnAfterSameSessionTrace(analysisCheckoutRoot) {
 }
 
 // src/analysis/repoSurfaceAssessment.ts
-var fs33 = __toESM(require("fs"));
+var fs35 = __toESM(require("fs"));
 var path31 = __toESM(require("path"));
 var REPO_SURFACE_SCAN_BASENAME = "repo-surface-scan.json";
 function stripBom(s) {
@@ -19866,7 +20265,7 @@ function stripBom(s) {
 function readRepoSurfaceAssessment(contextDir2) {
   const p = path31.join(contextDir2, REPO_SURFACE_SCAN_BASENAME);
   try {
-    const raw = stripBom(fs33.readFileSync(p, "utf-8"));
+    const raw = stripBom(fs35.readFileSync(p, "utf-8"));
     const data = JSON.parse(raw);
     if (!data || typeof data !== "object") {
       return null;
@@ -19887,8 +20286,8 @@ function readRepoSurfaceAssessment(contextDir2) {
 }
 function writeEmptyExperiencesListJson(contextDir2) {
   const p = path31.join(contextDir2, "experiences-list.json");
-  fs33.mkdirSync(path31.dirname(p), { recursive: true });
-  fs33.writeFileSync(
+  fs35.mkdirSync(path31.dirname(p), { recursive: true });
+  fs35.writeFileSync(
     p,
     `${JSON.stringify(
       {
@@ -19904,6 +20303,31 @@ function writeEmptyExperiencesListJson(contextDir2) {
   );
 }
 
+// src/config/cpuPressureSample.ts
+var os5 = __toESM(require("node:os"));
+function createDefaultCpuPressureSampler() {
+  const n = Math.max(1, os5.cpus()?.length ?? 1);
+  return () => {
+    const [l1] = os5.loadavg();
+    if (!Number.isFinite(l1) || l1 <= 0) {
+      return 0;
+    }
+    return Math.min(1, l1 / n);
+  };
+}
+function nextAdaptiveMaxAfterCpuSample(p) {
+  const threshold = p.threshold ?? 0.96;
+  if (p.activeRunningCount < 1 || !Number.isFinite(p.ratio) || p.ratio <= threshold) {
+    return { adaptiveMax: p.priorAdaptiveMax, changed: false };
+  }
+  const candidate = Math.max(1, p.activeRunningCount - 1);
+  const next = Math.min(p.priorAdaptiveMax, candidate);
+  if (next < p.priorAdaptiveMax) {
+    return { adaptiveMax: next, changed: true };
+  }
+  return { adaptiveMax: p.priorAdaptiveMax, changed: false };
+}
+
 // src/pipelines/synthesis/synthesisPipeline.ts
 var FE = /^FE-\d+$/;
 var UC = /^UC-\d+$/;
@@ -19916,7 +20340,7 @@ function stripBom2(s) {
 }
 function readJson4(filePath) {
   try {
-    const raw = stripBom2(fs34.readFileSync(filePath, "utf-8"));
+    const raw = stripBom2(fs36.readFileSync(filePath, "utf-8"));
     return JSON.parse(raw);
   } catch {
     return null;
@@ -20011,7 +20435,7 @@ function featureDetailTarget(contextDir2, code, name, slug) {
     displayName: "Feature detail",
     outputBasename: basename17,
     taskDescription: `Document feature **${code}** (**${name}**, slug **${slug}**) per \`.gluecharm/context/features-list.json\`: scope, behaviour, main dependencies, entry points, and links to code under the worktree. Write exactly one markdown file at the output path; cite substantive claims with file and line (or range).`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function viewDetailTarget(row2, contextDir2) {
@@ -20022,7 +20446,7 @@ function viewDetailTarget(row2, contextDir2) {
     displayName: "View detail",
     outputBasename: basename17,
     taskDescription: `Describe view **${row2.code}** (**${row2.name}**, slug **${row2.slug}**) per \`.gluecharm/context/experiences-list.json\`: purpose, layout, controls, navigation, data shown; ground in components and routes.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function interactionDetailTarget(viewCode, ix, contextDir2) {
@@ -20033,7 +20457,7 @@ function interactionDetailTarget(viewCode, ix, contextDir2) {
     displayName: "Interaction detail",
     outputBasename: basename17,
     taskDescription: `Document interaction **${ix.code}** (**${ix.name}**) on view **${viewCode}** per \`.gluecharm/context/experiences-list.json\`.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function serviceDetailTarget(row2, contextDir2) {
@@ -20044,7 +20468,7 @@ function serviceDetailTarget(row2, contextDir2) {
     displayName: "Service detail",
     outputBasename: basename17,
     taskDescription: `Describe service **${row2.code}** (**${row2.name}**, slug **${row2.slug}**) per \`.gluecharm/context/services-list.json\`: responsibilities, consumers, errors, integration points.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function methodDetailTarget(svc, m, contextDir2) {
@@ -20055,7 +20479,7 @@ function methodDetailTarget(svc, m, contextDir2) {
     displayName: "Method detail",
     outputBasename: basename17,
     taskDescription: `Document method **${m.code}** (**${m.name}**) on service **${svc.code}** per \`.gluecharm/context/services-list.json\`.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function entityDetailTarget(dmCode, ename, slug, contextDir2) {
@@ -20066,7 +20490,7 @@ function entityDetailTarget(dmCode, ename, slug, contextDir2) {
     displayName: "Entity detail",
     outputBasename: basename17,
     taskDescription: `Describe entity **${dmCode}** (**${ename}**, slug **${slug}**) per \`.gluecharm/context/data-model-list.json\`: lifecycle, invariants, storage, ORM/schema mapping.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function fieldDetailTarget(dmCode, fdCode, fname, fSlug, contextDir2) {
@@ -20077,7 +20501,7 @@ function fieldDetailTarget(dmCode, fdCode, fname, fSlug, contextDir2) {
     displayName: "Field detail",
     outputBasename: basename17,
     taskDescription: `Document field **${fdCode}** (**${fname}**) on entity **${dmCode}** per \`.gluecharm/context/${dmCode}-fields-list.json\`. Cite types and constraints with file and line.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function toolDetailTarget(row2, contextDir2) {
@@ -20088,7 +20512,7 @@ function toolDetailTarget(row2, contextDir2) {
     displayName: "Tool detail",
     outputBasename: basename17,
     taskDescription: `Describe tool **${row2.code}** (**${row2.name}**, slug **${row2.slug}**) per \`.gluecharm/context/tech-stack-list.json\`: role, version hints, configuration, boundaries.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function useCaseDetailTarget(feCode, ucCode, ucName, ucSlug, contextDir2) {
@@ -20101,7 +20525,7 @@ function useCaseDetailTarget(feCode, ucCode, ucName, ucSlug, contextDir2) {
     taskDescription: `Document use case **${ucCode}** (**${ucName}**) under feature **${feCode}** per \`.gluecharm/context/${feCode}-use-cases-list.json\`. Do not change stable codes.
 
 Follow bundled agent **agent-md-use-case-detail**: include **## Data inputs and validation** (concrete fields, mandatory vs optional, rules, failure behaviour). **## Code flow** must trace **implementation order** (entrypoint \u2192 validation \u2192 business rules \u2192 persistence \u2192 response) with **real** symbols and files\u2014not generic \u201Cuser does X\u201D. Add a **Mermaid** fenced diagram under Code flow when there are **two or more** implementation stages. **## Evidence index** must cite **each major stage** (validation, persistence, response), not only the outer entrypoint.`,
-    exists: fs34.existsSync(path32.join(contextDir2, ucBase)) && fs34.statSync(path32.join(contextDir2, ucBase)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, ucBase)) && fs36.statSync(path32.join(contextDir2, ucBase)).size > 0
   };
 }
 function scenarioDetailTarget(feCode, ucCode, scCode, scName, contextDir2) {
@@ -20112,7 +20536,7 @@ function scenarioDetailTarget(feCode, ucCode, scCode, scName, contextDir2) {
     displayName: "Scenario detail",
     outputBasename: basename17,
     taskDescription: `Document scenario **${scCode}** (**${scName}**) for **${feCode}** / **${ucCode}** per \`.gluecharm/context/${feCode}_${ucCode}-scenarios-list.json\`. Cite steps with file and line where possible.`,
-    exists: fs34.existsSync(path32.join(contextDir2, basename17)) && fs34.statSync(path32.join(contextDir2, basename17)).size > 0
+    exists: fs36.existsSync(path32.join(contextDir2, basename17)) && fs36.statSync(path32.join(contextDir2, basename17)).size > 0
   };
 }
 function parentsDone(item, byId) {
@@ -20531,8 +20955,29 @@ async function runWorkstationWithOuterAttempts(item, worktreeRoot, workspaceLabe
   };
 }
 async function drainWorkstationPool(p) {
-  const maxC = clampConcurrency(p.oc.maxConcurrentOpenCodeAgents);
   const { storageContext, worktreeRoot, workspaceLabel, contextDir: contextDir2, byId, fifo, oc, log, abortSignal } = p;
+  const staticMaxC = clampConcurrency(p.oc.maxConcurrentOpenCodeAgents);
+  const throttle = p.enableCpuAdaptiveThrottle !== false;
+  let adaptiveMax = staticMaxC;
+  const sample = p.cpuPressureSampler ?? (throttle ? createDefaultCpuPressureSampler() : () => 0);
+  const applyCpuPressure = () => {
+    if (!throttle || active < 1) {
+      return;
+    }
+    const ratio = sample();
+    const { adaptiveMax: next, changed } = nextAdaptiveMaxAfterCpuSample({
+      ratio,
+      activeRunningCount: active,
+      priorAdaptiveMax: adaptiveMax
+    });
+    if (changed) {
+      adaptiveMax = next;
+      log(
+        `[pool] cpu pressure ratio=${ratio.toFixed(3)} active=${String(active)} adaptiveMaxConcurrentAi=${String(adaptiveMax)}`
+      );
+    }
+  };
+  const currentCap = () => Math.min(staticMaxC, adaptiveMax);
   const artefactRunId = readArtefactRunSnapshot(storageContext)?.runId ?? "unknown-run";
   let active = 0;
   let wake;
@@ -20567,11 +21012,13 @@ async function drainWorkstationPool(p) {
     void persist();
     pump();
   };
+  let poolAbortListenerRegistered = false;
   if (abortSignal) {
     if (abortSignal.aborted) {
       onPipelineAbort();
     } else {
-      abortSignal.addEventListener("abort", onPipelineAbort, { once: true });
+      abortSignal.addEventListener("abort", onPipelineAbort);
+      poolAbortListenerRegistered = true;
     }
   }
   const runOne = async (id) => {
@@ -20586,9 +21033,10 @@ async function drainWorkstationPool(p) {
       pump();
       return;
     }
+    applyCpuPressure();
     item.status = "running";
     await persist();
-    log(`[pool] start ${id} (active ${active}/${maxC})`);
+    log(`[pool] start ${id} (active ${active}/${currentCap()})`);
     const r = await runWorkstationWithOuterAttempts(
       item,
       worktreeRoot,
@@ -20643,29 +21091,43 @@ async function drainWorkstationPool(p) {
     await p.onItemComplete?.(id);
     pump();
   };
-  while (true) {
-    while (fifo.length > 0 && active < maxC && !abortSignal?.aborted) {
-      const id = fifo.shift();
-      const it = byId.get(id);
-      if (!it || it.status !== "pending" || !parentsDone(it, byId)) {
-        continue;
+  let pressureInterval;
+  if (throttle) {
+    const intervalMs = p.__testOnlyCpuPressureIntervalMs ?? 3e4;
+    pressureInterval = setInterval(() => applyCpuPressure(), intervalMs);
+  }
+  try {
+    while (true) {
+      while (fifo.length > 0 && active < currentCap() && !abortSignal?.aborted) {
+        const id = fifo.shift();
+        const it = byId.get(id);
+        if (!it || it.status !== "pending" || !parentsDone(it, byId)) {
+          continue;
+        }
+        active += 1;
+        void runOne(id);
       }
-      active += 1;
-      void runOne(id);
-    }
-    const pendingOrRunning = active > 0 || [...byId.values()].some((v) => v.status === "pending") || fifo.length > 0;
-    if (!pendingOrRunning) {
-      break;
-    }
-    if (abortSignal?.aborted) {
-      if (active === 0) {
+      const pendingOrRunning = active > 0 || [...byId.values()].some((v) => v.status === "pending") || fifo.length > 0;
+      if (!pendingOrRunning) {
         break;
       }
-      await waitTurn();
-      continue;
+      if (abortSignal?.aborted) {
+        if (active === 0) {
+          break;
+        }
+        await waitTurn();
+        continue;
+      }
+      if (fifo.length === 0 || active >= currentCap()) {
+        await waitTurn();
+      }
+    }
+  } finally {
+    if (pressureInterval) {
+      clearInterval(pressureInterval);
     }
-    if (fifo.length === 0 || active >= maxC) {
-      await waitTurn();
+    if (poolAbortListenerRegistered && abortSignal) {
+      abortSignal.removeEventListener("abort", onPipelineAbort);
     }
   }
   return { cancelled: abortSignal?.aborted === true, skippedWorkItemIds };
@@ -20703,7 +21165,7 @@ async function runSynthesisPipelineDrainFromPreparedWorktree(storageContext, rep
     offlineLearnAfterSameSessionTrace: getAceOfflineLearnAfterSameSessionTrace(handle.path)
   };
   const contextDir2 = path32.join(handle.path, ".gluecharm", "context");
-  fs34.mkdirSync(contextDir2, { recursive: true });
+  fs36.mkdirSync(contextDir2, { recursive: true });
   const initialItems = buildRootItems();
   await startArtefactRun(storageContext, repoRoot, handle.path, initialItems);
   await cb.onBootstrapReady?.({ worktreeRoot: handle.path, contextDir: contextDir2 });
@@ -20804,27 +21266,27 @@ async function runSynthesisPipeline(storageContext, repoRoot, workspaceLabel, ex
 }
 
 // src/workspaceContextPromote.ts
-var fs35 = __toESM(require("fs"));
+var fs37 = __toESM(require("fs"));
 var path33 = __toESM(require("path"));
 function promoteContextDirectoryToWorkspaceFs(sourceContextDir, workspaceRootFs) {
   const dest = path33.join(workspaceRootFs, ".gluecharm", "context");
-  fs35.mkdirSync(path33.join(workspaceRootFs, ".gluecharm"), { recursive: true });
-  fs35.mkdirSync(dest, { recursive: true });
+  fs37.mkdirSync(path33.join(workspaceRootFs, ".gluecharm"), { recursive: true });
+  fs37.mkdirSync(dest, { recursive: true });
   let names;
   try {
-    names = fs35.readdirSync(sourceContextDir);
+    names = fs37.readdirSync(sourceContextDir);
   } catch {
     return { filesCopied: 0 };
   }
   let filesCopied = 0;
   for (const name of names) {
     const srcPath = path33.join(sourceContextDir, name);
-    if (!fs35.statSync(srcPath).isFile()) {
+    if (!fs37.statSync(srcPath).isFile()) {
       continue;
     }
-    const buf = fs35.readFileSync(srcPath);
+    const buf = fs37.readFileSync(srcPath);
     const target = path33.join(dest, name);
-    fs35.writeFileSync(target, buf);
+    fs37.writeFileSync(target, buf);
     filesCopied += 1;
   }
   return { filesCopied };
@@ -21484,7 +21946,7 @@ async function runGenerateContextFactory(deps) {
 }
 
 // src/factory/generateContextFactoryHeadlessHost.ts
-var fs44 = __toESM(require("node:fs"));
+var fs46 = __toESM(require("node:fs"));
 var path43 = __toESM(require("node:path"));
 
 // src/stores/pipelineRunStore.ts
@@ -21585,11 +22047,11 @@ async function noteAgentsMaterialized(context) {
 }
 
 // src/pipelines/remediation/missingWorkstations.ts
-var fs37 = __toESM(require("fs"));
+var fs39 = __toESM(require("fs"));
 var path35 = __toESM(require("path"));
 
 // src/analysis/analysisDetailMarkdownDiscovery.ts
-var fs36 = __toESM(require("fs"));
+var fs38 = __toESM(require("fs"));
 var path34 = __toESM(require("path"));
 var SLUG4 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var FE2 = /^FE-\d+$/;
@@ -21611,7 +22073,7 @@ var STEM_TO_AGENT = {
 };
 function readJson5(filePath) {
   try {
-    let raw = fs36.readFileSync(filePath, "utf-8");
+    let raw = fs38.readFileSync(filePath, "utf-8");
     if (raw.length > 0 && raw.charCodeAt(0) === 65279) {
       raw = raw.slice(1);
     }
@@ -21879,7 +22341,7 @@ function fileAndValidationFromKind(kind) {
 function classifyMissingWorkstationOutputFileStatus(row2, contextDir2, worktreeRoot) {
   const abs = path35.join(contextDir2, row2.relativePath);
   try {
-    const st = fs37.statSync(abs);
+    const st = fs39.statSync(abs);
     if (!st.isFile()) {
       return { kind: "absent", detail: "Path exists but is not a regular file." };
     }
@@ -21917,7 +22379,7 @@ function classifyMissingWorkstationOutputFileStatus(row2, contextDir2, worktreeR
     };
   }
   const schemaAbs = path35.join(worktreeRoot, ".opencode", "schemas", "context-lists", schemaBn);
-  if (!fs37.existsSync(schemaAbs)) {
+  if (!fs39.existsSync(schemaAbs)) {
     return {
       kind: "invalid",
       detail: `Schema not found (${schemaBn}). Run **Materialize agents** on this checkout.`
@@ -22153,7 +22615,7 @@ function listMissingWorkstations(contextDir2, worktreeRoot, snapshot) {
       }
     }
   }
-  if (!fs37.existsSync(contextDir2)) {
+  if (!fs39.existsSync(contextDir2)) {
     return [...map.values()].sort((a, b) => a.key.localeCompare(b.key));
   }
   const dynamic = discoverDynamicAnalysisTestSteps(contextDir2);
@@ -22333,12 +22795,12 @@ async function runRemediationPipelineMissingPass(p) {
 }
 
 // src/pipelines/coverage/coveragePipeline.ts
-var import_child_process4 = require("child_process");
-var fs39 = __toESM(require("fs"));
+var import_child_process5 = require("child_process");
+var fs41 = __toESM(require("fs"));
 var path38 = __toESM(require("path"));
 
 // src/analysis/coverageReferenceValidationSchemaValidate.ts
-var fs38 = __toESM(require("fs"));
+var fs40 = __toESM(require("fs"));
 var path37 = __toESM(require("path"));
 var import__5 = __toESM(require__());
 function stripUtf8Bom4(s) {
@@ -22368,7 +22830,7 @@ function getValidate() {
     return compiledValidate;
   }
   const schemaPath = bundledCoverageReferenceValidationSchemaPath();
-  const schemaRaw = stripUtf8Bom4(fs38.readFileSync(schemaPath, "utf-8"));
+  const schemaRaw = stripUtf8Bom4(fs40.readFileSync(schemaPath, "utf-8"));
   const schema = JSON.parse(schemaRaw);
   const ajv2 = new import__5.default({ allErrors: true, strict: false });
   compiledValidate = ajv2.compile(schema);
@@ -22384,7 +22846,7 @@ function validateCoverageReferenceValidationData(data) {
 function readAndValidateCoverageReferenceValidationFile(jsonAbsolutePath) {
   let raw;
   try {
-    raw = stripUtf8Bom4(fs38.readFileSync(jsonAbsolutePath, "utf-8"));
+    raw = stripUtf8Bom4(fs40.readFileSync(jsonAbsolutePath, "utf-8"));
   } catch (e) {
     return {
       ok: false,
@@ -22426,7 +22888,7 @@ var DEFAULT_IGNORE_DIR_BASENAMES = [
 var GIT_LS_FILES_MAX_BUFFER = 64 * 1024 * 1024;
 function tryLoadGitNonIgnoredPathSet(repositoryRootAbs) {
   const root = path38.resolve(repositoryRootAbs);
-  if (!fs39.existsSync(path38.join(root, ".git"))) {
+  if (!fs41.existsSync(path38.join(root, ".git"))) {
     return null;
   }
   const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
@@ -22437,8 +22899,8 @@ function tryLoadGitNonIgnoredPathSet(repositoryRootAbs) {
     env
   };
   try {
-    const tracked = (0, import_child_process4.execFileSync)("git", ["-c", "core.quotepath=false", "ls-files", "-z"], opts);
-    const others = (0, import_child_process4.execFileSync)(
+    const tracked = (0, import_child_process5.execFileSync)("git", ["-c", "core.quotepath=false", "ls-files", "-z"], opts);
+    const others = (0, import_child_process5.execFileSync)(
       "git",
       ["-c", "core.quotepath=false", "ls-files", "-z", "--others", "--exclude-standard"],
       opts
@@ -22581,7 +23043,7 @@ function extractEvidenceIndexPathCitations(body) {
 function listContextFilesRecursive(dir, acc) {
   let entries;
   try {
-    entries = fs39.readdirSync(dir, { withFileTypes: true });
+    entries = fs41.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -22599,7 +23061,7 @@ function walkRepositoryFiles(repoRoot, ignoreBasenames, maxBytes, excludedOut, g
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs39.readdirSync(dir, { withFileTypes: true });
+      entries = fs41.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -22629,7 +23091,7 @@ function walkRepositoryFiles(repoRoot, ignoreBasenames, maxBytes, excludedOut, g
         }
         let st;
         try {
-          st = fs39.statSync(full);
+          st = fs41.statSync(full);
         } catch {
           continue;
         }
@@ -22639,7 +23101,7 @@ function walkRepositoryFiles(repoRoot, ignoreBasenames, maxBytes, excludedOut, g
         }
         let buf;
         try {
-          buf = fs39.readFileSync(full);
+          buf = fs41.readFileSync(full);
         } catch {
           excludedOut.push({ path: rel, reason: "read error" });
           continue;
@@ -22659,7 +23121,7 @@ function walkRepositoryFiles(repoRoot, ignoreBasenames, maxBytes, excludedOut, g
 }
 function collectReferencesFromContext(contextDirAbs, repositoryRootAbs, warnings) {
   const references = [];
-  if (!fs39.existsSync(contextDirAbs)) {
+  if (!fs41.existsSync(contextDirAbs)) {
     warnings.push(`Context directory missing: ${contextDirAbs}`);
     return references;
   }
@@ -22675,7 +23137,7 @@ function collectReferencesFromContext(contextDirAbs, repositoryRootAbs, warnings
       }
       let raw;
       try {
-        raw = fs39.readFileSync(abs, "utf-8");
+        raw = fs41.readFileSync(abs, "utf-8");
       } catch (e) {
         warnings.push(`Skip JSON (read error): ${sourceArtefact} \u2014 ${e instanceof Error ? e.message : String(e)}`);
         continue;
@@ -22706,7 +23168,7 @@ function collectReferencesFromContext(contextDirAbs, repositoryRootAbs, warnings
     if (ext === ".md") {
       let text;
       try {
-        const buf = fs39.readFileSync(abs);
+        const buf = fs41.readFileSync(abs);
         text = decodeBufferForLineCount(buf);
       } catch (e) {
         warnings.push(`Skip markdown (read/decode error): ${sourceArtefact} \u2014 ${e instanceof Error ? e.message : String(e)}`);
@@ -22763,7 +23225,7 @@ function buildCoverageReferenceValidationDocument(repositoryRootAbs, contextDirA
   }
   const excludedFiles = [];
   const gitNonIgnoredPaths = tryLoadGitNonIgnoredPathSet(repoRoot);
-  if (fs39.existsSync(path38.join(repoRoot, ".git")) && gitNonIgnoredPaths === null) {
+  if (fs41.existsSync(path38.join(repoRoot, ".git")) && gitNonIgnoredPaths === null) {
     warnings.push(
       "Repository has .git but git ls-files failed or git is unavailable; .gitignore / exclude-standard not applied."
     );
@@ -22814,10 +23276,10 @@ function buildCoverageReferenceValidationDocument(repositoryRootAbs, contextDirA
 function runCoveragePipeline(opts) {
   const repoRoot = path38.resolve(opts.repositoryRootAbs);
   const contextDir2 = path38.resolve(opts.contextDirAbs);
-  if (!fs39.existsSync(repoRoot)) {
+  if (!fs41.existsSync(repoRoot)) {
     return { ok: false, error: `Repository root does not exist: ${repoRoot}` };
   }
-  if (!fs39.existsSync(contextDir2)) {
+  if (!fs41.existsSync(contextDir2)) {
     return {
       ok: false,
       error: `Missing .gluecharm/context: ${contextDir2}`
@@ -22839,7 +23301,7 @@ ${schemaCheck.errors.join("\n")}`,
   if (opts.write) {
     try {
       const payload = stableStringifyCoverageDocument(document);
-      fs39.writeFileSync(outPath, payload, "utf-8");
+      fs41.writeFileSync(outPath, payload, "utf-8");
     } catch (e) {
       return {
         ok: false,
@@ -22853,11 +23315,11 @@ ${schemaCheck.errors.join("\n")}`,
 
 // src/pipelines/remediation/zeroReferenceWorkstationChain.ts
 var crypto = __toESM(require("crypto"));
-var fs41 = __toESM(require("fs"));
+var fs43 = __toESM(require("fs"));
 var path40 = __toESM(require("path"));
 
 // src/analysis/zeroReferenceRemediationSchemaValidate.ts
-var fs40 = __toESM(require("fs"));
+var fs42 = __toESM(require("fs"));
 var path39 = __toESM(require("path"));
 var import__6 = __toESM(require__());
 function stripUtf8Bom5(s) {
@@ -22879,7 +23341,7 @@ function formatAjvErrors6(errors) {
 var ajv = new import__6.default({ allErrors: true, strict: false });
 function compileSchema(basename17) {
   const schemaPath = path39.join(schemasDir(), basename17);
-  const schemaRaw = stripUtf8Bom5(fs40.readFileSync(schemaPath, "utf-8"));
+  const schemaRaw = stripUtf8Bom5(fs42.readFileSync(schemaPath, "utf-8"));
   const schema = JSON.parse(schemaRaw);
   return ajv.compile(schema);
 }
@@ -22923,7 +23385,7 @@ var ZERO_REF_STAGING_JSON_TOTAL_ATTEMPTS = 5;
 var ZERO_REF_STAGING_FILE_PREVIEW_MAX_CHARS = 6e3;
 function readStagingOutputPreview(outAbs) {
   try {
-    const s = fs41.readFileSync(outAbs, "utf-8");
+    const s = fs43.readFileSync(outAbs, "utf-8");
     if (s.length <= ZERO_REF_STAGING_FILE_PREVIEW_MAX_CHARS) {
       return s;
     }
@@ -23206,14 +23668,14 @@ function readNonReferencedFilesFromRepositoryRoot(repositoryRootAbs) {
   return { ok: true, paths, ...generatedAt ? { generatedAt } : {} };
 }
 function readOrInitRoutingDoc(routingAbs, coverageReferenceGeneratedAt) {
-  if (!fs41.existsSync(routingAbs)) {
+  if (!fs43.existsSync(routingAbs)) {
     return {
       schemaVersion: ROUTING_SCHEMA_VERSION,
       ...coverageReferenceGeneratedAt ? { coverageReferenceGeneratedAt } : {},
       records: {}
     };
   }
-  const raw = fs41.readFileSync(routingAbs, "utf-8");
+  const raw = fs43.readFileSync(routingAbs, "utf-8");
   const data = JSON.parse(raw);
   if (!data.records || typeof data.records !== "object") {
     return {
@@ -23225,10 +23687,10 @@ function readOrInitRoutingDoc(routingAbs, coverageReferenceGeneratedAt) {
   return data;
 }
 function readOrInitTriageDoc(triageAbs) {
-  if (!fs41.existsSync(triageAbs)) {
+  if (!fs43.existsSync(triageAbs)) {
     return { schemaVersion: TRIAGE_SCHEMA_VERSION, records: {} };
   }
-  const raw = fs41.readFileSync(triageAbs, "utf-8");
+  const raw = fs43.readFileSync(triageAbs, "utf-8");
   const data = JSON.parse(raw);
   if (!data.records || typeof data.records !== "object") {
     return { schemaVersion: TRIAGE_SCHEMA_VERSION, records: {} };
@@ -23279,7 +23741,7 @@ function lineCountRepoFile(worktreeRootAbs, relPosix) {
   const abs = path40.join(worktreeRootAbs, ...relPosix.split("/"));
   let buf;
   try {
-    buf = fs41.readFileSync(abs);
+    buf = fs43.readFileSync(abs);
   } catch {
     return 1;
   }
@@ -23333,7 +23795,7 @@ async function applyCoordinationListTriageMerge(input) {
   const cfg = LIST_MERGE_CFG[input.listKind];
   const listPath = path40.join(input.contextDirAbs, cfg.listBasename);
   const schemaPath = path40.join(resolveContextListSchemasDir(), cfg.schemaBasename);
-  if (!fs41.existsSync(listPath)) {
+  if (!fs43.existsSync(listPath)) {
     return {
       ok: false,
       message: `${cfg.listBasename} not found \u2014 run coordination step ${LIST_STEP_HINT[input.listKind]} first.`
@@ -23344,7 +23806,7 @@ async function applyCoordinationListTriageMerge(input) {
     return withCoordinationListFileLock(listPath, {}, async () => {
       let raw;
       try {
-        raw = fs41.readFileSync(listPath, "utf-8");
+        raw = fs43.readFileSync(listPath, "utf-8");
       } catch (e) {
         return { ok: false, message: e instanceof Error ? e.message : String(e) };
       }
@@ -23412,7 +23874,7 @@ async function applyCoordinationListTriageMerge(input) {
       });
       const tmp = `${listPath}.tmp.${process.pid}`;
       try {
-        fs41.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
+        fs43.writeFileSync(tmp, `${JSON.stringify(doc, null, 2)}
 `, "utf-8");
       } catch (e) {
         return { ok: false, message: e instanceof Error ? e.message : String(e) };
@@ -23420,13 +23882,13 @@ async function applyCoordinationListTriageMerge(input) {
       const v = validateCoordinationListJson(tmp, schemaPath);
       if (!v.ok) {
         try {
-          fs41.unlinkSync(tmp);
+          fs43.unlinkSync(tmp);
         } catch {
         }
         return { ok: false, message: `${cfg.listBasename} validation failed: ${JSON.stringify(v.failure)}` };
       }
       try {
-        fs41.renameSync(tmp, listPath);
+        fs43.renameSync(tmp, listPath);
       } catch (e) {
         return { ok: false, message: e instanceof Error ? e.message : String(e) };
       }
@@ -23436,9 +23898,9 @@ async function applyCoordinationListTriageMerge(input) {
 }
 async function runClassifierAgent(common, contextDirAbs, targetFilePathPosix, workspaceLabel) {
   const outAbs = stagingPathForTarget(contextDirAbs, "classifier", targetFilePathPosix);
-  fs41.mkdirSync(path40.dirname(outAbs), { recursive: true });
+  fs43.mkdirSync(path40.dirname(outAbs), { recursive: true });
   const runDir = path40.join(common.worktreeRoot, ".opencode", "_run");
-  fs41.mkdirSync(runDir, { recursive: true });
+  fs43.mkdirSync(runDir, { recursive: true });
   const outputBasename = path40.basename(outAbs);
   const listTaskDescription = [
     `Target file (repo-relative, POSIX): **${targetFilePathPosix}**`,
@@ -23476,7 +23938,7 @@ async function runClassifierAgent(common, contextDirAbs, targetFilePathPosix, wo
       ...repairAppendix ? { repairAppendix } : {}
     });
     const promptPath = path40.join(runDir, `zero-ref-classify-a${attempt}-${Date.now()}.prompt.txt`);
-    fs41.writeFileSync(promptPath, body, "utf-8");
+    fs43.writeFileSync(promptPath, body, "utf-8");
     const argv = expandArgvTemplate4(common.argvTemplate, {
       promptFile: promptPath,
       agentId: ZERO_REF_CLASSIFY_AGENT_STEM,
@@ -23503,7 +23965,7 @@ async function runClassifierAgent(common, contextDirAbs, targetFilePathPosix, wo
     const canRetry = attempt < ZERO_REF_STAGING_JSON_TOTAL_ATTEMPTS - 1;
     let st;
     try {
-      st = fs41.statSync(outAbs);
+      st = fs43.statSync(outAbs);
     } catch {
       st = void 0;
     }
@@ -23525,7 +23987,7 @@ async function runClassifierAgent(common, contextDirAbs, targetFilePathPosix, wo
     }
     let parsed;
     try {
-      parsed = JSON.parse(fs41.readFileSync(outAbs, "utf-8"));
+      parsed = JSON.parse(fs43.readFileSync(outAbs, "utf-8"));
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       lastFailureMessage = `Classifier output not valid JSON: ${msg}`;
@@ -23610,7 +24072,7 @@ async function runMarkdownReferenceAgent(common, contextDirAbs, targetFilePathPo
   const mdAbs = path40.join(contextDirAbs, mdBasename);
   const agentStem = which === "project" ? ZERO_REF_ADD_REF_PROJECT_AGENT_STEM : ZERO_REF_ADD_REF_ARCH_AGENT_STEM;
   const runDir = path40.join(common.worktreeRoot, ".opencode", "_run");
-  fs41.mkdirSync(runDir, { recursive: true });
+  fs43.mkdirSync(runDir, { recursive: true });
   const lines = [
     `# SRS-30 \u2014 Add reference to ${mdBasename}`,
     ``,
@@ -23626,7 +24088,7 @@ async function runMarkdownReferenceAgent(common, contextDirAbs, targetFilePathPo
     `- Do not remove unrelated content; append or extend the most appropriate section.`
   ];
   const promptPath = path40.join(runDir, `zero-ref-md-${which}-${Date.now()}.prompt.txt`);
-  fs41.writeFileSync(promptPath, lines.join("\n"), "utf-8");
+  fs43.writeFileSync(promptPath, lines.join("\n"), "utf-8");
   const argv = expandArgvTemplate4(common.argvTemplate, {
     promptFile: promptPath,
     agentId: agentStem,
@@ -23653,9 +24115,9 @@ async function runMarkdownReferenceAgent(common, contextDirAbs, targetFilePathPo
 async function runCoordinationTriageAgent(common, contextDirAbs, targetFilePathPosix, routingSummary, workspaceLabel, triageScope) {
   const meta = TRIAGE_SCOPE_META[triageScope];
   const outAbs = stagingPathForTarget(contextDirAbs, "triage", targetFilePathPosix);
-  fs41.mkdirSync(path40.dirname(outAbs), { recursive: true });
+  fs43.mkdirSync(path40.dirname(outAbs), { recursive: true });
   const runDir = path40.join(common.worktreeRoot, ".opencode", "_run");
-  fs41.mkdirSync(runDir, { recursive: true });
+  fs43.mkdirSync(runDir, { recursive: true });
   const outputBasename = path40.basename(outAbs);
   const listTaskDescription = [
     `Target file: **${targetFilePathPosix}** (${workspaceLabel})`,
@@ -23687,7 +24149,7 @@ async function runCoordinationTriageAgent(common, contextDirAbs, targetFilePathP
       ...repairAppendix ? { repairAppendix } : {}
     });
     const promptPath = path40.join(runDir, `zero-ref-triage-a${attempt}-${Date.now()}.prompt.txt`);
-    fs41.writeFileSync(promptPath, body, "utf-8");
+    fs43.writeFileSync(promptPath, body, "utf-8");
     const argv = expandArgvTemplate4(common.argvTemplate, {
       promptFile: promptPath,
       agentId: ZERO_REF_TRIAGE_COORD_AGENT_STEM,
@@ -23714,7 +24176,7 @@ async function runCoordinationTriageAgent(common, contextDirAbs, targetFilePathP
     const canRetry = attempt < ZERO_REF_STAGING_JSON_TOTAL_ATTEMPTS - 1;
     let st;
     try {
-      st = fs41.statSync(outAbs);
+      st = fs43.statSync(outAbs);
     } catch {
       st = void 0;
     }
@@ -23736,7 +24198,7 @@ async function runCoordinationTriageAgent(common, contextDirAbs, targetFilePathP
     }
     let parsed;
     try {
-      parsed = JSON.parse(fs41.readFileSync(outAbs, "utf-8"));
+      parsed = JSON.parse(fs43.readFileSync(outAbs, "utf-8"));
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       lastFailureMessage = `Triage output not valid JSON: ${msg}`;
@@ -23792,7 +24254,7 @@ async function runCoordinationTriageAgent(common, contextDirAbs, targetFilePathP
       return { ok: false, message: lastFailureMessage, stagingPath: outAbs };
     }
     try {
-      fs41.writeFileSync(outAbs, `${JSON.stringify(parsed, null, 2)}
+      fs43.writeFileSync(outAbs, `${JSON.stringify(parsed, null, 2)}
 `, "utf-8");
     } catch {
     }
@@ -23810,7 +24272,7 @@ async function runOneUnreferencedFilePipeline(p) {
   }
   let stagingParsed;
   try {
-    stagingParsed = JSON.parse(fs41.readFileSync(cr.stagingPath, "utf-8"));
+    stagingParsed = JSON.parse(fs43.readFileSync(cr.stagingPath, "utf-8"));
   } catch (e) {
     return { ok: false, message: String(e) };
   }
@@ -23826,8 +24288,8 @@ async function runOneUnreferencedFilePipeline(p) {
     if (!s.ok) {
       throw new Error(s.errors.join("; "));
     }
-    fs41.mkdirSync(path40.dirname(routingAbs), { recursive: true });
-    fs41.writeFileSync(routingAbs, s.json, "utf-8");
+    fs43.mkdirSync(path40.dirname(routingAbs), { recursive: true });
+    fs43.writeFileSync(routingAbs, s.json, "utf-8");
   });
   const routing = stagingParsed.routing;
   const routingSummary = typeof stagingParsed.projectRelationSummary === "string" ? stagingParsed.projectRelationSummary : "";
@@ -23858,7 +24320,7 @@ async function runOneUnreferencedFilePipeline(p) {
   }
   let triageParsed;
   try {
-    triageParsed = JSON.parse(fs41.readFileSync(tr.stagingPath, "utf-8"));
+    triageParsed = JSON.parse(fs43.readFileSync(tr.stagingPath, "utf-8"));
   } catch (e) {
     return { ok: false, message: String(e) };
   }
@@ -23875,8 +24337,8 @@ async function runOneUnreferencedFilePipeline(p) {
     if (!s.ok) {
       throw new Error(s.errors.join("; "));
     }
-    fs41.mkdirSync(path40.dirname(triageAbs), { recursive: true });
-    fs41.writeFileSync(triageAbs, s.json, "utf-8");
+    fs43.mkdirSync(path40.dirname(triageAbs), { recursive: true });
+    fs43.writeFileSync(triageAbs, s.json, "utf-8");
   });
   const decision = triageParsed.decision;
   if (decision === "new_item" || decision === "enrich_existing") {
@@ -23964,7 +24426,7 @@ async function runRemediationPipelineZeroRefPass(p) {
 }
 
 // src/pipelines/coverage/coverageExecutionReport.ts
-var fs42 = __toESM(require("fs"));
+var fs44 = __toESM(require("fs"));
 var path41 = __toESM(require("path"));
 var REFERENCE_COVERAGE_EXECUTION_REPORT_BASENAME = "reference-coverage-execution-report.md";
 function inlineMdText(s) {
@@ -24061,7 +24523,7 @@ function collectNoActionRowsFromRoutingDoc(doc) {
   return rows;
 }
 function readRoutingDocFromDisk(routingAbs) {
-  if (!fs42.existsSync(routingAbs)) {
+  if (!fs44.existsSync(routingAbs)) {
     return {
       ok: true,
       doc: { schemaVersion: "1", records: {} }
@@ -24069,7 +24531,7 @@ function readRoutingDocFromDisk(routingAbs) {
   }
   let raw;
   try {
-    raw = fs42.readFileSync(routingAbs, "utf-8");
+    raw = fs44.readFileSync(routingAbs, "utf-8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -24109,20 +24571,20 @@ async function runCoverageExecutionReport(p) {
   }
   let previous;
   try {
-    if (fs42.existsSync(outAbs)) {
-      previous = fs42.readFileSync(outAbs, "utf-8");
+    if (fs44.existsSync(outAbs)) {
+      previous = fs44.readFileSync(outAbs, "utf-8");
     }
   } catch {
     previous = void 0;
   }
   try {
-    fs42.mkdirSync(path41.dirname(outAbs), { recursive: true });
-    fs42.writeFileSync(outAbs, md, "utf-8");
+    fs44.mkdirSync(path41.dirname(outAbs), { recursive: true });
+    fs44.writeFileSync(outAbs, md, "utf-8");
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     if (previous !== void 0) {
       try {
-        fs42.writeFileSync(outAbs, previous, "utf-8");
+        fs44.writeFileSync(outAbs, previous, "utf-8");
       } catch {
       }
     }
@@ -24133,7 +24595,7 @@ async function runCoverageExecutionReport(p) {
 }
 
 // src/gluecharm/minimalGluecharmLayout.ts
-var fs43 = __toESM(require("node:fs"));
+var fs45 = __toESM(require("node:fs"));
 var path42 = __toESM(require("node:path"));
 var MINIMAL_GLUECHARM_RELATIVE_DIRS = [
   [".gluecharm", "docs", "srs"],
@@ -24146,7 +24608,7 @@ function ensureMinimalGluecharmLayoutNode(repoRootAbs) {
   for (const segments of MINIMAL_GLUECHARM_RELATIVE_DIRS) {
     const dir = path42.join(root, ...segments);
     try {
-      fs43.mkdirSync(dir, { recursive: true });
+      fs45.mkdirSync(dir, { recursive: true });
     } catch (e) {
       const err = e;
       const msg = e instanceof Error ? e.message : String(e);
@@ -24528,13 +24990,13 @@ function buildFactoryDepsHeadless(input) {
     },
     runPrepareAnalysisWorktree: async (resume) => {
       if (resume) {
-        if (adHocWorktree && fs44.existsSync(path43.join(adHocWorktree.path, ".git"))) {
+        if (adHocWorktree && fs46.existsSync(path43.join(adHocWorktree.path, ".git"))) {
           return { ok: true };
         }
         const snap = readAnalysisWorkspaceSnapshot(storageContext);
         const wtPath = snap?.adHocWorktreePath?.trim();
         const repo = snap?.adHocRepositoryRoot?.trim() || repoRoot;
-        if (wtPath && fs44.existsSync(path43.join(wtPath, ".git"))) {
+        if (wtPath && fs46.existsSync(path43.join(wtPath, ".git"))) {
           adHocWorktree = attachWorktreeHandle(wtPath, repo);
           macroSourceBranch = snap?.adHocSourceBranchAtCreation;
           macroFinalize = () => {
@@ -24759,7 +25221,7 @@ function stderrLinesForFactoryFailures(failures, exitCode) {
 var path48 = __toESM(require("node:path"));
 
 // src/factory/updateContext/updateContextBaseline.ts
-var fs45 = __toESM(require("node:fs"));
+var fs47 = __toESM(require("node:fs"));
 var path44 = __toESM(require("node:path"));
 function isValidIso(s) {
   const t = Date.parse(s);
@@ -24770,7 +25232,7 @@ function maxMtimeRegularFilesUnderDir(dirAbs) {
   const walk = (d) => {
     let entries;
     try {
-      entries = fs45.readdirSync(d, { withFileTypes: true });
+      entries = fs47.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
@@ -24780,7 +25242,7 @@ function maxMtimeRegularFilesUnderDir(dirAbs) {
         walk(p);
       } else if (e.isFile()) {
         try {
-          const st = fs45.statSync(p);
+          const st = fs47.statSync(p);
           const m = st.mtimeMs;
           if (best === null || m > best) {
             best = m;
@@ -24802,7 +25264,7 @@ function resolveUpdateContextBaseline(repoRootAbs, repoConfig) {
     return { baselineIsoUtc: new Date(last).toISOString(), source: "lastRunAt" };
   }
   const ctxDir = path44.join(repoRootAbs, ".gluecharm", "context");
-  if (!fs45.existsSync(ctxDir)) {
+  if (!fs47.existsSync(ctxDir)) {
     return null;
   }
   const maxMs = maxMtimeRegularFilesUnderDir(ctxDir);
@@ -24824,12 +25286,12 @@ function persistUpdateContextLastRunAt(repoRootAbs, isoUtc) {
 }
 
 // src/factory/updateContext/updateContextGitWindow.ts
-var import_node_child_process2 = require("node:child_process");
-var fs46 = __toESM(require("node:fs"));
+var import_node_child_process3 = require("node:child_process");
+var fs48 = __toESM(require("node:fs"));
 var path45 = __toESM(require("node:path"));
 var GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
 function gitLines(repoRootAbs, args) {
-  const r = (0, import_node_child_process2.execFileSync)("git", ["-c", "core.quotepath=false", ...args], {
+  const r = (0, import_node_child_process3.execFileSync)("git", ["-c", "core.quotepath=false", ...args], {
     cwd: repoRootAbs,
     encoding: "utf-8",
     env: GIT_ENV,
@@ -24851,7 +25313,7 @@ function parseGitLogIso(line) {
 }
 function discoverCommitWindowAndTouchedPaths(repoRootAbs, baselineIsoUtc) {
   const root = path45.resolve(repoRootAbs);
-  if (!fs46.existsSync(path45.join(root, ".git"))) {
+  if (!fs48.existsSync(path45.join(root, ".git"))) {
     return { ok: false, error: "Not a git repository (missing .git)." };
   }
   const baselineMs = Date.parse(baselineIsoUtc);
@@ -24916,7 +25378,7 @@ function filterPathsExistingInWorktree(worktreeRootAbs, pathsPosix) {
     const rel = p.replace(/\\/g, "/");
     const abs = path45.join(root, ...rel.split("/"));
     try {
-      if (fs46.existsSync(abs) && fs46.statSync(abs).isFile()) {
+      if (fs48.existsSync(abs) && fs48.statSync(abs).isFile()) {
         out.push(rel);
       }
     } catch {
@@ -24926,7 +25388,7 @@ function filterPathsExistingInWorktree(worktreeRootAbs, pathsPosix) {
 }
 
 // src/factory/updateContext/updateContextReport.ts
-var fs47 = __toESM(require("node:fs"));
+var fs49 = __toESM(require("node:fs"));
 var path46 = __toESM(require("node:path"));
 var CHANGES_SINCE_DATE_BASENAME = "changes-since-date.md";
 function renderChangesSinceDateMarkdown(p) {
@@ -24968,9 +25430,9 @@ function renderChangesSinceDateMarkdown(p) {
 }
 function writeChangesSinceDateReport(contextDirAbs, body) {
   try {
-    fs47.mkdirSync(contextDirAbs, { recursive: true });
+    fs49.mkdirSync(contextDirAbs, { recursive: true });
     const target = path46.join(contextDirAbs, CHANGES_SINCE_DATE_BASENAME);
-    fs47.writeFileSync(target, body, "utf-8");
+    fs49.writeFileSync(target, body, "utf-8");
     return { ok: true };
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
@@ -24978,13 +25440,13 @@ function writeChangesSinceDateReport(contextDirAbs, body) {
 }
 
 // src/factory/updateContext/updateContextSeedCheck.ts
-var fs48 = __toESM(require("node:fs"));
+var fs50 = __toESM(require("node:fs"));
 var path47 = __toESM(require("node:path"));
 var INDEX_BASENAME = "index-application-context.json";
 var CHANGES_REPORT = "changes-since-date.md";
 function tryParseJsonFile(abs) {
   try {
-    const raw = fs48.readFileSync(abs, "utf-8");
+    const raw = fs50.readFileSync(abs, "utf-8");
     JSON.parse(raw);
     return true;
   } catch {
@@ -24992,16 +25454,16 @@ function tryParseJsonFile(abs) {
   }
 }
 function isWorktreeContextSeeded(contextDirAbs) {
-  if (!fs48.existsSync(contextDirAbs)) {
+  if (!fs50.existsSync(contextDirAbs)) {
     return false;
   }
   const indexAbs = path47.join(contextDirAbs, INDEX_BASENAME);
-  if (fs48.existsSync(indexAbs) && fs48.statSync(indexAbs).isFile() && tryParseJsonFile(indexAbs)) {
+  if (fs50.existsSync(indexAbs) && fs50.statSync(indexAbs).isFile() && tryParseJsonFile(indexAbs)) {
     return true;
   }
   let names;
   try {
-    names = fs48.readdirSync(contextDirAbs);
+    names = fs50.readdirSync(contextDirAbs);
   } catch {
     return false;
   }
@@ -25015,7 +25477,7 @@ function isWorktreeContextSeeded(contextDirAbs) {
     }
     const p = path47.join(contextDirAbs, name);
     try {
-      if (fs48.statSync(p).isFile()) {
+      if (fs50.statSync(p).isFile()) {
         distinct.add(name);
       }
     } catch {
@@ -25317,11 +25779,11 @@ async function runUpdateContextFactory(deps) {
 }
 
 // src/factory/contextDrift/runContextDriftFactory.ts
-var fs54 = __toESM(require("node:fs"));
+var fs56 = __toESM(require("node:fs"));
 var path53 = __toESM(require("node:path"));
 
 // src/factory/contextDrift/contextDriftManifest.ts
-var fs49 = __toESM(require("node:fs"));
+var fs51 = __toESM(require("node:fs"));
 var path49 = __toESM(require("node:path"));
 var MAX_REFERENCE_BYTES = 256 * 1024;
 var MAX_EVIDENCE_FILES = 300;
@@ -25330,7 +25792,7 @@ var MAX_EXCERPT = 4e3;
 function readFileLimited(abs, maxBytes) {
   let buf;
   try {
-    buf = fs49.readFileSync(abs);
+    buf = fs51.readFileSync(abs);
   } catch {
     return { text: "", truncated: false };
   }
@@ -25343,14 +25805,14 @@ function collectEvidencePaths(repoRoot) {
   const roots = ["src", "test", "tests", "packages", ".gluecharm", "scripts"];
   for (const rel of roots) {
     const abs = path49.join(repoRoot, rel);
-    if (!fs49.existsSync(abs)) {
+    if (!fs51.existsSync(abs)) {
       continue;
     }
     walkFiles(abs, repoRoot, out, 0);
   }
   for (const leaf of ["package.json", "tsconfig.json"]) {
     const abs = path49.join(repoRoot, leaf);
-    if (fs49.existsSync(abs) && fs49.statSync(abs).isFile()) {
+    if (fs51.existsSync(abs) && fs51.statSync(abs).isFile()) {
       const r = path49.relative(repoRoot, abs).split(path49.sep).join("/");
       out.push(r);
     }
@@ -25368,7 +25830,7 @@ function walkFiles(dir, repoRoot, out, depth) {
   }
   let entries;
   try {
-    entries = fs49.readdirSync(dir, { withFileTypes: true });
+    entries = fs51.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -25405,7 +25867,7 @@ function buildComparisonManifest(args) {
   const evidenceFiles = [];
   for (const rel of evidencePathsTrimmed) {
     const abs = path49.join(args.worktreeRoot, ...rel.split("/"));
-    const st = fs49.existsSync(abs) ? fs49.statSync(abs) : null;
+    const st = fs51.existsSync(abs) ? fs51.statSync(abs) : null;
     const size = st && st.isFile() ? st.size : 0;
     const { text, truncated } = readFileLimited(abs, MAX_EVIDENCE_READ);
     const excerpt = truncated ? `${text.slice(0, MAX_EXCERPT)}
@@ -25427,7 +25889,7 @@ function buildComparisonManifest(args) {
 }
 
 // src/factory/contextDrift/contextDriftAgent.ts
-var fs50 = __toESM(require("node:fs"));
+var fs52 = __toESM(require("node:fs"));
 var path50 = __toESM(require("node:path"));
 
 // src/factory/contextDrift/contextDriftPayload.ts
@@ -25574,16 +26036,16 @@ function buildDriftPrompt(args) {
 }
 async function runDriftComparisonOpenCode(args) {
   const runDir = path50.join(args.worktreeRoot, ".opencode", "_run");
-  fs50.mkdirSync(runDir, { recursive: true });
+  fs52.mkdirSync(runDir, { recursive: true });
   const manifestPath = path50.join(runDir, "context-drift-manifest.json");
   const outputPath = path50.join(runDir, "context-drift-payload.json");
-  fs50.writeFileSync(manifestPath, `${JSON.stringify(args.manifestObject, null, 2)}
+  fs52.writeFileSync(manifestPath, `${JSON.stringify(args.manifestObject, null, 2)}
 `, "utf8");
-  if (fs50.existsSync(outputPath)) {
-    fs50.unlinkSync(outputPath);
+  if (fs52.existsSync(outputPath)) {
+    fs52.unlinkSync(outputPath);
   }
   const promptPath = path50.join(runDir, `context-drift-${Date.now()}.prompt.txt`);
-  fs50.writeFileSync(
+  fs52.writeFileSync(
     promptPath,
     buildDriftPrompt({
       worktreeRoot: args.worktreeRoot,
@@ -25625,7 +26087,7 @@ async function runDriftComparisonOpenCode(args) {
   }
   let raw;
   try {
-    const txt = fs50.readFileSync(outputPath, "utf8");
+    const txt = fs52.readFileSync(outputPath, "utf8");
     raw = JSON.parse(txt);
   } catch (e) {
     return {
@@ -25642,7 +26104,7 @@ async function runDriftComparisonOpenCode(args) {
 
 // src/factory/contextDrift/contextDriftPaths.ts
 var crypto2 = __toESM(require("node:crypto"));
-var fs51 = __toESM(require("node:fs"));
+var fs53 = __toESM(require("node:fs"));
 var path51 = __toESM(require("node:path"));
 var DRIFT_CONTEXT_SUBDIR = path51.join(".gluecharm", "context", "drift");
 function sanitizeSlug(raw) {
@@ -25681,7 +26143,7 @@ function maybeDedupeSlug(slug, referenceRelPosix) {
 function discoverReferenceBundle(worktreeRoot, referenceAbsInWorktree) {
   let st;
   try {
-    st = fs51.statSync(referenceAbsInWorktree);
+    st = fs53.statSync(referenceAbsInWorktree);
   } catch {
     return { ok: false, error: `Reference path not found in analysis worktree: ${referenceAbsInWorktree}` };
   }
@@ -25702,7 +26164,7 @@ function discoverReferenceBundle(worktreeRoot, referenceAbsInWorktree) {
     }
     let entries;
     try {
-      entries = fs51.readdirSync(dir, { withFileTypes: true });
+      entries = fs53.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -25727,7 +26189,7 @@ function discoverReferenceBundle(worktreeRoot, referenceAbsInWorktree) {
 }
 function pickReferenceRootDocument(args) {
   if (args.indexOverrideAbs) {
-    if (!fs51.existsSync(args.indexOverrideAbs) || !args.indexOverrideAbs.endsWith(".md")) {
+    if (!fs53.existsSync(args.indexOverrideAbs) || !args.indexOverrideAbs.endsWith(".md")) {
       return { ok: false, error: "--index must point to an existing .md file under the repo." };
     }
     return { ok: true, path: args.indexOverrideAbs };
@@ -25738,7 +26200,7 @@ function pickReferenceRootDocument(args) {
   const dir = args.referenceAbsInWorktree;
   for (const name of ["index.md", "README.md"]) {
     const p = path51.join(dir, name);
-    if (fs51.existsSync(p) && fs51.statSync(p).isFile()) {
+    if (fs53.existsSync(p) && fs53.statSync(p).isFile()) {
       return { ok: true, path: p };
     }
   }
@@ -25755,13 +26217,13 @@ function toPosixPath(p) {
 }
 
 // src/factory/contextDrift/contextDriftIndex.ts
-var fs52 = __toESM(require("node:fs"));
+var fs54 = __toESM(require("node:fs"));
 var START = "<!-- easyspecs-drift-links:start -->";
 var END = "<!-- easyspecs-drift-links:end -->";
 function patchReferenceIndexWithDriftLink(args) {
   let body;
   try {
-    body = fs52.readFileSync(args.referenceRootAbsolute, "utf8");
+    body = fs54.readFileSync(args.referenceRootAbsolute, "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -25782,7 +26244,7 @@ ${block}
 `;
   }
   try {
-    fs52.writeFileSync(args.referenceRootAbsolute, next, "utf8");
+    fs54.writeFileSync(args.referenceRootAbsolute, next, "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -25793,13 +26255,13 @@ function escapeRe(s) {
 }
 
 // src/factory/contextDrift/contextDriftPromote.ts
-var fs53 = __toESM(require("node:fs"));
+var fs55 = __toESM(require("node:fs"));
 var path52 = __toESM(require("node:path"));
 function copyWorktreeFileToWorkspace(args) {
   const src = path52.join(args.worktreeRoot, ...args.relativePosix.split("/"));
   const dest = path52.join(args.workspaceRoot, ...args.relativePosix.split("/"));
-  fs53.mkdirSync(path52.dirname(dest), { recursive: true });
-  fs53.copyFileSync(src, dest);
+  fs55.mkdirSync(path52.dirname(dest), { recursive: true });
+  fs55.copyFileSync(src, dest);
 }
 
 // src/factory/contextDrift/runContextDriftFactory.ts
@@ -25818,7 +26280,7 @@ async function runContextDriftFactory(deps) {
     };
   }
   const refAbsWorkspace = resolved.abs;
-  if (!fs54.existsSync(refAbsWorkspace)) {
+  if (!fs56.existsSync(refAbsWorkspace)) {
     return {
       exitOk: false,
       ok: false,
@@ -25831,7 +26293,7 @@ async function runContextDriftFactory(deps) {
   let indexOverrideAbsWorkspace;
   if (deps.indexOverrideArg?.trim()) {
     const ir = resolveInsideRepo(deps.repoRootAbs, deps.indexOverrideArg.trim());
-    if (!ir.ok || !fs54.existsSync(ir.abs)) {
+    if (!ir.ok || !fs56.existsSync(ir.abs)) {
       return {
         exitOk: false,
         ok: false,
@@ -25849,7 +26311,7 @@ async function runContextDriftFactory(deps) {
       ok: true,
       code: "DRY_RUN",
       ...baseMeta,
-      referenceRootDocument: toPosixPath(path53.relative(deps.repoRootAbs, refAbsWorkspace)) + (fs54.statSync(refAbsWorkspace).isDirectory() ? "/" : ""),
+      referenceRootDocument: toPosixPath(path53.relative(deps.repoRootAbs, refAbsWorkspace)) + (fs56.statSync(refAbsWorkspace).isDirectory() ? "/" : ""),
       driftReportPath: null,
       analysisWorktreeRoot: "",
       promoted: false,
@@ -25918,7 +26380,7 @@ async function runContextDriftFactory(deps) {
   }
   const indexWt = indexOverrideAbsWorkspace ? path53.join(wt, ...path53.relative(deps.repoRootAbs, indexOverrideAbsWorkspace).split(path53.sep)) : void 0;
   const rootPick = pickReferenceRootDocument({
-    referencePathIsFile: fs54.statSync(refAbsWt).isFile(),
+    referencePathIsFile: fs56.statSync(refAbsWt).isFile(),
     referenceAbsInWorktree: refAbsWt,
     bundleFiles: bundle.bundleFiles,
     indexOverrideAbs: indexWt
@@ -25945,7 +26407,7 @@ async function runContextDriftFactory(deps) {
   slug = maybeDedupeSlug(slug, refRel);
   const driftBase = driftFilename(slug, runDate);
   const driftDirWt = path53.join(wt, DRIFT_CONTEXT_SUBDIR);
-  fs54.mkdirSync(driftDirWt, { recursive: true });
+  fs56.mkdirSync(driftDirWt, { recursive: true });
   const driftAbsWt = path53.join(driftDirWt, driftBase);
   let payload;
   if (deps.testOnlyFixturePayload) {
@@ -25982,7 +26444,7 @@ async function runContextDriftFactory(deps) {
     manifestTruncation: manifest.truncation
   });
   try {
-    fs54.writeFileSync(driftAbsWt, md, "utf8");
+    fs56.writeFileSync(driftAbsWt, md, "utf8");
   } catch (e) {
     finalizeWt?.();
     return {
@@ -26061,7 +26523,7 @@ async function runContextDriftFactory(deps) {
 }
 
 // src/analysis/coordinationDuplicatesDiagnosis.ts
-var fs55 = __toESM(require("fs"));
+var fs57 = __toESM(require("fs"));
 var path54 = __toESM(require("path"));
 var import__7 = __toESM(require__());
 var COORDINATION_DUPLICATES_REPORT_BASENAME = "coordination-duplicates-report.json";
@@ -26098,11 +26560,11 @@ function looksLikeCoordinationDetailMarkdownBasename(basename17) {
 }
 function loadRawFeatureRows(contextDirAbs) {
   const p = path54.join(contextDirAbs, "features-list.json");
-  if (!fs55.existsSync(p)) {
+  if (!fs57.existsSync(p)) {
     return [];
   }
   try {
-    const raw = stripUtf8Bom6(fs55.readFileSync(p, "utf-8"));
+    const raw = stripUtf8Bom6(fs57.readFileSync(p, "utf-8"));
     const doc = JSON.parse(raw);
     return Array.isArray(doc.features) ? doc.features : [];
   } catch {
@@ -26137,7 +26599,7 @@ function findOrphanCoordinationMarkdown(contextDirAbs) {
   const featureRows = loadRawFeatureRows(contextDirAbs);
   let dirents;
   try {
-    dirents = fs55.readdirSync(contextDirAbs, { withFileTypes: true });
+    dirents = fs57.readdirSync(contextDirAbs, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -26391,13 +26853,13 @@ function buildCoordinationDuplicatesReport(input) {
   const duplicateGroups = [];
   for (const entry of COORDINATION_LIST_SCAN_ENTRIES) {
     const filePath = path54.join(input.contextDirAbsolute, entry.basename);
-    if (!fs55.existsSync(filePath)) {
+    if (!fs57.existsSync(filePath)) {
       lists.push({ basename: entry.basename, status: "missing" });
       continue;
     }
     let raw;
     try {
-      raw = stripUtf8Bom6(fs55.readFileSync(filePath, "utf-8"));
+      raw = stripUtf8Bom6(fs57.readFileSync(filePath, "utf-8"));
     } catch (e) {
       lists.push({
         basename: entry.basename,
@@ -26446,7 +26908,7 @@ function validateReportData(data) {
   if (!validateReportCompiled) {
     const ajv2 = new import__7.default({ allErrors: true, strict: false });
     const schemaPath = path54.join(resolveContextListSchemasDir(), "coordination-duplicates-report.schema.json");
-    const schemaRaw = stripUtf8Bom6(fs55.readFileSync(schemaPath, "utf-8"));
+    const schemaRaw = stripUtf8Bom6(fs57.readFileSync(schemaPath, "utf-8"));
     validateReportCompiled = ajv2.compile(JSON.parse(schemaRaw));
   }
   if (validateReportCompiled(data)) {
@@ -26469,15 +26931,15 @@ function runCoordinationDuplicatesDiagnosis(input) {
 `;
   const tmp = `${outPath}.tmp.${process.pid}`;
   try {
-    fs55.writeFileSync(tmp, payload, "utf-8");
+    fs57.writeFileSync(tmp, payload, "utf-8");
   } catch (e) {
     return { ok: false, message: e instanceof Error ? e.message : String(e) };
   }
   try {
-    fs55.renameSync(tmp, outPath);
+    fs57.renameSync(tmp, outPath);
   } catch (e) {
     try {
-      fs55.unlinkSync(tmp);
+      fs57.unlinkSync(tmp);
     } catch {
     }
     return { ok: false, message: e instanceof Error ? e.message : String(e) };
@@ -26511,7 +26973,7 @@ function runCoordinationDuplicatesDiagnosis(input) {
 }
 
 // src/pipelines/download/downloadPipeline.ts
-var fs56 = __toESM(require("node:fs"));
+var fs58 = __toESM(require("node:fs"));
 var path55 = __toESM(require("node:path"));
 var SRS_DISCOVERY_BATCH_GET_CHUNK_SIZE = 200;
 function isRecord7(v) {
@@ -26617,19 +27079,19 @@ function chunkIds(ids, size) {
   return out;
 }
 function clearContextDirectoryForCloudReplace(contextDirAbs) {
-  if (!fs56.existsSync(contextDirAbs) || !fs56.statSync(contextDirAbs).isDirectory()) {
+  if (!fs58.existsSync(contextDirAbs) || !fs58.statSync(contextDirAbs).isDirectory()) {
     return { filesRemoved: 0 };
   }
   const preserveAbs = path55.resolve(contextDirAbs, UPLOAD_TARGET_FILENAME);
   const preserveSet = /* @__PURE__ */ new Set();
-  if (fs56.existsSync(preserveAbs) && fs56.statSync(preserveAbs).isFile()) {
+  if (fs58.existsSync(preserveAbs) && fs58.statSync(preserveAbs).isFile()) {
     preserveSet.add(preserveAbs);
   }
   let filesRemoved = 0;
   const walkRm = (dir) => {
     let entries;
     try {
-      entries = fs56.readdirSync(dir, { withFileTypes: true });
+      entries = fs58.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -26638,7 +27100,7 @@ function clearContextDirectoryForCloudReplace(contextDirAbs) {
       if (e.isDirectory()) {
         walkRm(full);
         try {
-          fs56.rmdirSync(full);
+          fs58.rmdirSync(full);
         } catch {
         }
       } else if (e.isFile()) {
@@ -26647,7 +27109,7 @@ function clearContextDirectoryForCloudReplace(contextDirAbs) {
           continue;
         }
         try {
-          fs56.unlinkSync(abs);
+          fs58.unlinkSync(abs);
           filesRemoved += 1;
         } catch {
         }
@@ -26726,15 +27188,15 @@ async function runDownloadPipeline(opts) {
       failed.push({ id, name, message: "Unsafe or invalid name for local path." });
       continue;
     }
-    fs56.mkdirSync(path55.dirname(outAbs), { recursive: true });
-    const exists = fs56.existsSync(outAbs);
+    fs58.mkdirSync(path55.dirname(outAbs), { recursive: true });
+    const exists = fs58.existsSync(outAbs);
     if (exists && !opts.force && !opts.replaceFromCloud) {
       skipped += 1;
       log?.(`[pipeline:download] skip existing ${name} (use --force to overwrite).`);
       continue;
     }
     try {
-      fs56.writeFileSync(outAbs, bodyText, "utf8");
+      fs58.writeFileSync(outAbs, bodyText, "utf8");
       downloaded += 1;
       succeededIds[outAbs] = id;
     } catch (e) {
@@ -26905,11 +27367,11 @@ function createAuthenticatedRequestJson(deps) {
 }
 
 // src/cli/cliSession.ts
-var fs57 = __toESM(require("node:fs"));
-var os3 = __toESM(require("node:os"));
+var fs59 = __toESM(require("node:fs"));
+var os6 = __toESM(require("node:os"));
 var path56 = __toESM(require("node:path"));
 function defaultSessionPath() {
-  return path56.join(os3.homedir(), ".easyspecs", "cli-session.json");
+  return path56.join(os6.homedir(), ".easyspecs", "cli-session.json");
 }
 var configSessionPath;
 function setCliSessionPathFromConfig(absPath) {
@@ -26950,10 +27412,10 @@ function effectiveCliSessionPath() {
 function readCliSession() {
   const p = effectiveCliSessionPath();
   try {
-    if (!fs57.existsSync(p)) {
+    if (!fs59.existsSync(p)) {
       return void 0;
     }
-    const j = JSON.parse(fs57.readFileSync(p, "utf8"));
+    const j = JSON.parse(fs59.readFileSync(p, "utf8"));
     const apiBaseUrl = typeof j.apiBaseUrl === "string" ? j.apiBaseUrl.trim() : "";
     const accessToken = typeof j.accessToken === "string" ? j.accessToken : "";
     const refreshToken = typeof j.refreshToken === "string" ? j.refreshToken : "";
@@ -26967,20 +27429,20 @@ function readCliSession() {
 }
 function writeCliSession(s) {
   const p = effectiveCliSessionPath();
-  fs57.mkdirSync(path56.dirname(p), { recursive: true });
-  fs57.writeFileSync(p, `${JSON.stringify(s, null, 2)}
+  fs59.mkdirSync(path56.dirname(p), { recursive: true });
+  fs59.writeFileSync(p, `${JSON.stringify(s, null, 2)}
 `, "utf8");
 }
 function clearCliSession() {
   const p = effectiveCliSessionPath();
   try {
-    fs57.unlinkSync(p);
+    fs59.unlinkSync(p);
   } catch {
   }
 }
 
 // src/analysis/acePendingTraces.ts
-var fs58 = __toESM(require("fs"));
+var fs60 = __toESM(require("fs"));
 var path57 = __toESM(require("path"));
 function normalizeAceTraceRelativePath(rel) {
   return rel.split(/[/\\]/).join("/");
@@ -26988,12 +27450,12 @@ function normalizeAceTraceRelativePath(rel) {
 function readCompletedTraceRelativePaths(contextDir2) {
   const set = /* @__PURE__ */ new Set();
   const jsonlPath = aceConsolidatedSessionsJsonlPath(contextDir2);
-  if (!fs58.existsSync(jsonlPath)) {
+  if (!fs60.existsSync(jsonlPath)) {
     return set;
   }
   let raw;
   try {
-    raw = fs58.readFileSync(jsonlPath, "utf8");
+    raw = fs60.readFileSync(jsonlPath, "utf8");
   } catch {
     return set;
   }
@@ -27024,7 +27486,7 @@ function readCompletedTraceRelativePaths(contextDir2) {
 }
 function listPendingAceTraceFiles(contextDir2, worktreeRoot) {
   const traceSchema = opencodeAceSchemaPath(worktreeRoot, ACE_SCHEMA_TRACE);
-  if (!fs58.existsSync(traceSchema)) {
+  if (!fs60.existsSync(traceSchema)) {
     return [];
   }
   const completed = readCompletedTraceRelativePaths(contextDir2);
@@ -27054,11 +27516,32 @@ function clampConcurrency2(n) {
   return Math.min(64, Math.max(1, Math.floor(n)));
 }
 async function runAceAutoLearnPool(p) {
-  const maxC = clampConcurrency2(p.maxConcurrentOpenCodeAgents);
+  const staticMaxC = clampConcurrency2(p.maxConcurrentOpenCodeAgents);
+  const throttle = p.enableCpuAdaptiveThrottle !== false;
+  let adaptiveMax = staticMaxC;
+  const sample = p.cpuPressureSampler ?? (throttle ? createDefaultCpuPressureSampler() : () => 0);
   const contextDir2 = gluecharmContextDir(p.baseOpts.worktreeRoot);
   const runner = p.runOfflineLearn ?? runAceOfflineLearnFromTrace;
   const fifo = [...p.traceAbsolutePaths];
   let active = 0;
+  const applyCpuPressure = () => {
+    if (!throttle || active < 1) {
+      return;
+    }
+    const ratio = sample();
+    const { adaptiveMax: next, changed } = nextAdaptiveMaxAfterCpuSample({
+      ratio,
+      activeRunningCount: active,
+      priorAdaptiveMax: adaptiveMax
+    });
+    if (changed) {
+      adaptiveMax = next;
+      p.log?.(
+        `[ace] cpu pressure ratio=${ratio.toFixed(3)} active=${String(active)} adaptiveMaxConcurrentAi=${String(adaptiveMax)}`
+      );
+    }
+  };
+  const currentCap = () => Math.min(staticMaxC, adaptiveMax);
   let wake;
   const waitTurn = () => new Promise((resolve20) => {
     wake = resolve20;
@@ -27074,11 +27557,13 @@ async function runAceAutoLearnPool(p) {
     fifo.length = 0;
     pump();
   };
+  let poolAbortListenerRegistered = false;
   if (abortSignal) {
     if (abortSignal.aborted) {
       onPipelineAbort();
     } else {
-      abortSignal.addEventListener("abort", onPipelineAbort, { once: true });
+      abortSignal.addEventListener("abort", onPipelineAbort);
+      poolAbortListenerRegistered = true;
     }
   }
   const traceRel = (abs) => path58.relative(contextDir2, abs).split(path58.sep).join("/");
@@ -27088,8 +27573,9 @@ async function runAceAutoLearnPool(p) {
       pump();
       return;
     }
+    applyCpuPressure();
     const rel = traceRel(traceAbs);
-    p.log?.(`[ace] ace auto-learn: start ${rel} (active ${active}/${maxC})`);
+    p.log?.(`[ace] ace auto-learn: start ${rel} (active ${active}/${currentCap()})`);
     await p.onItemStart?.(rel);
     const r = await runner(traceAbs, { ...p.baseOpts, abortSignal });
     if (r.ok) {
@@ -27103,25 +27589,39 @@ async function runAceAutoLearnPool(p) {
     p.log?.(`[ace] ace auto-learn: finished ${rel} ok=${r.ok}`);
     pump();
   };
-  while (true) {
-    while (fifo.length > 0 && active < maxC && !abortSignal?.aborted) {
-      const traceAbs = fifo.shift();
-      active += 1;
-      void runOne(traceAbs);
-    }
-    const pendingOrRunning = active > 0 || fifo.length > 0;
-    if (!pendingOrRunning) {
-      break;
-    }
-    if (abortSignal?.aborted) {
-      if (active === 0) {
+  let pressureInterval;
+  if (throttle) {
+    const intervalMs = p.__testOnlyCpuPressureIntervalMs ?? 3e4;
+    pressureInterval = setInterval(() => applyCpuPressure(), intervalMs);
+  }
+  try {
+    while (true) {
+      while (fifo.length > 0 && active < currentCap() && !abortSignal?.aborted) {
+        const traceAbs = fifo.shift();
+        active += 1;
+        void runOne(traceAbs);
+      }
+      const pendingOrRunning = active > 0 || fifo.length > 0;
+      if (!pendingOrRunning) {
         break;
       }
-      await waitTurn();
-      continue;
+      if (abortSignal?.aborted) {
+        if (active === 0) {
+          break;
+        }
+        await waitTurn();
+        continue;
+      }
+      if (fifo.length === 0 || active >= currentCap()) {
+        await waitTurn();
+      }
+    }
+  } finally {
+    if (pressureInterval) {
+      clearInterval(pressureInterval);
     }
-    if (fifo.length === 0 || active >= maxC) {
-      await waitTurn();
+    if (poolAbortListenerRegistered && abortSignal) {
+      abortSignal.removeEventListener("abort", onPipelineAbort);
     }
   }
   return { cancelled: abortSignal?.aborted === true, completed, failed };
@@ -27590,7 +28090,7 @@ function formatCliStderrLine(line, useAnsi) {
 }
 
 // src/cli/main.ts
-var PKG_VERSION = "0.0.23";
+var PKG_VERSION = "0.0.25";
 function isNonEmptyFactoryFailureArray(x) {
   if (!Array.isArray(x) || x.length === 0) {
     return false;
@@ -27722,7 +28222,7 @@ function resolveAnalysisRoot(repoRoot, rootKind, worktreePath) {
     return repoRoot;
   }
   const wt = worktreePath?.trim();
-  if (wt && fs59.existsSync(path59.join(wt, ".git"))) {
+  if (wt && fs61.existsSync(path59.join(wt, ".git"))) {
     return path59.resolve(wt);
   }
   throw new Error("worktree mode requires --worktree <path> to an existing analysis checkout.");
@@ -27731,14 +28231,14 @@ function resolveAdHocCheckoutRoot(_repoRoot, storage, worktreeFlag) {
   const w = worktreeFlag?.trim();
   if (w) {
     const abs = path59.resolve(w);
-    if (fs59.existsSync(path59.join(abs, ".git"))) {
+    if (fs61.existsSync(path59.join(abs, ".git"))) {
       return abs;
     }
     throw new Error(`Invalid --worktree (not a git checkout): ${abs}`);
   }
   const snap = readAnalysisWorkspaceSnapshot(storage);
   const p = snap?.adHocWorktreePath?.trim();
-  if (p && fs59.existsSync(path59.join(p, ".git"))) {
+  if (p && fs61.existsSync(path59.join(p, ".git"))) {
     return p;
   }
   throw new Error("No analysis checkout: run `easyspecs-cli run synthesis` first or pass `--worktree <path>`.");
@@ -27803,7 +28303,7 @@ async function main() {
   try {
     parsed = parseCliWithCommander(process.argv.slice(2));
   } catch (e) {
-    console.error(e instanceof Error ? e.message : String(e));
+    console.error(formatCliThrownUnknown(e));
     logExitCodeSummary(ExitCode.usage);
     process.exit(ExitCode.usage);
   }
@@ -27820,6 +28320,58 @@ async function main() {
   const repoRoot = resolveRepoRoot(flags);
   setAceCliHeadlessMode(true);
   setAceCliWorkspaceRoot(repoRoot);
+  if (positionals[0] === "workstation" && positionals[1] === "info") {
+    const tail = positionals.slice(2);
+    const wantJson = flags.json || tail.includes("--json");
+    const unknown = tail.filter((t) => t !== "--json");
+    if (unknown.length > 0) {
+      logErr(flags, "Usage: easyspecs-cli [--json] workstation info");
+      logExitCodeSummary(ExitCode.usage, flags);
+      process.exit(ExitCode.usage);
+    }
+    const plat = process.platform;
+    if (plat !== "darwin" && plat !== "linux") {
+      if (!wantJson) {
+        logErr(
+          flags,
+          `[EasySpecs] workstation info is only supported on macOS and Linux (unsupported platform: ${plat}).`
+        );
+      }
+      logExitCodeSummary(ExitCode.misconfiguration, flags);
+      process.exit(ExitCode.misconfiguration);
+    }
+    const profile = collectHostMachineProfile();
+    const nSys = machineConcurrentAiCapFromHost(profile);
+    const hostHardMaxConcurrentAi = hostHardMaxFromHost(profile);
+    const physicalCpus = profile.cpusForCapSource === "physical" ? profile.cpusForCap : null;
+    const totalMemBytes = Math.max(0, Math.floor(profile.totalMemBytes));
+    if (wantJson) {
+      printJsonLine({
+        command: "workstation info",
+        durationMs: Date.now() - t0,
+        ok: true,
+        platform: profile.platform,
+        totalMemBytes,
+        cpusForCap: profile.cpusForCap,
+        cpusForCapSource: profile.cpusForCapSource,
+        physicalCpus,
+        maxSystemConcurrentAiWorkstations: nSys,
+        hostHardMaxConcurrentAi
+      });
+    } else {
+      const gib = totalMemBytes / 2 ** 30;
+      console.log(
+        [
+          `platform=${profile.platform}`,
+          `cpusForCap=${String(profile.cpusForCap)} (${profile.cpusForCapSource})`,
+          `totalMem=${gib.toFixed(2)} GiB (${String(totalMemBytes)} bytes)`,
+          `N_sys (maxSystemConcurrentAiWorkstations)=${String(nSys)}`,
+          `hostHardMaxConcurrentAi (min(N_sys,64))=${String(hostHardMaxConcurrentAi)}`
+        ].join("\n")
+      );
+    }
+    process.exit(ExitCode.ok);
+  }
   if (positionals[0] === "config" && positionals[1] === "init") {
     const tail = positionals.slice(2);
     const overwrite = tail.includes("--overwrite");
@@ -28003,13 +28555,13 @@ async function main() {
       try {
         modes = parseDoctorFlags(pos.slice(1));
       } catch (e) {
-        logErr(flags, e instanceof Error ? e.message : String(e));
+        logErr(flags, formatCliThrownUnknown(e));
         logErr(flags, "Usage: easyspecs-cli doctor [--readiness] [--inspect-config]");
         logExitCodeSummary(ExitCode.usage, flags);
         process.exit(ExitCode.usage);
       }
       const agentsDir = resolveOpenCodeAgentsDir(repoRoot, repoConfig);
-      const agentsOk = fs59.existsSync(agentsDir);
+      const agentsOk = fs61.existsSync(agentsDir);
       const oc = getOpenCodeReadiness({
         executable: merged.openCodeExecutable,
         skipCredentialsCheck: merged.openCodeSkipCredentialsCheck,
@@ -28069,7 +28621,7 @@ async function main() {
         tailForCreds = extracted.rest;
         sessionPathRaw = extracted.sessionPath;
       } catch (e) {
-        logErr(flags, e instanceof Error ? e.message : String(e));
+        logErr(flags, formatCliThrownUnknown(e));
         logExitCodeSummary(ExitCode.usage, flags);
         process.exit(ExitCode.usage);
       }
@@ -28523,7 +29075,7 @@ async function main() {
         const wt = snap?.adHocWorktreePath?.trim();
         if (wt) {
           const sourceCtx = path59.join(wt, ".gluecharm", "context");
-          if (fs59.existsSync(sourceCtx)) {
+          if (fs61.existsSync(sourceCtx)) {
             const n = promoteContextDirectoryToWorkspaceFs(sourceCtx, repoRoot);
             logErr(flags, `[pipeline:analysis] promoted ${String(n.filesCopied)} file(s) \u2192 ${repoRoot}`);
           } else {
@@ -28675,8 +29227,8 @@ async function main() {
           ...flags.verbose && failCount > 0 ? { failures: result.failed } : {}
         });
       } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        finish(ExitCode.internal, { ok: false, error: msg });
+        const msg = formatCliThrownUnknown(e);
+        finish(exitCodeForThrownHttpApiError(e) ?? ExitCode.internal, { ok: false, error: msg });
       }
     }
     if (pos[0] === "upload" && (pos[1] === "context" || pos[1] === "republish")) {
@@ -28693,12 +29245,12 @@ async function main() {
       if (pos[1] === "republish") {
         const fromCfg = repoConfig.easyspecs?.upload?.contextDirectory?.trim();
         const resolvedOverride = fromCfg && fromCfg.length > 0 ? path59.isAbsolute(fromCfg) ? path59.normalize(fromCfg) : path59.resolve(repoRoot, fromCfg) : "";
-        if (resolvedOverride && fs59.existsSync(path59.join(resolvedOverride, ".."))) {
+        if (resolvedOverride && fs61.existsSync(path59.join(resolvedOverride, ".."))) {
           ctxDir = resolvedOverride;
         } else {
           const storage = createFileBackedWorkspaceState(repoRoot);
           const snap = readAnalysisWorkspaceSnapshot(storage);
-          const wt = snap?.adHocWorktreePath && fs59.existsSync(path59.join(snap.adHocWorktreePath, ".gluecharm", "context")) ? path59.join(snap.adHocWorktreePath, ".gluecharm", "context") : "";
+          const wt = snap?.adHocWorktreePath && fs61.existsSync(path59.join(snap.adHocWorktreePath, ".gluecharm", "context")) ? path59.join(snap.adHocWorktreePath, ".gluecharm", "context") : "";
           if (!wt) {
             finish(ExitCode.misconfiguration, {
               ok: false,
@@ -28816,16 +29368,16 @@ async function main() {
     }
     if (pos[0] === "ace" && pos[1] === "clear") {
       const learnings = path59.join(repoRoot, ".gluecharm", "context", "learnings");
-      if (!fs59.existsSync(learnings)) {
+      if (!fs61.existsSync(learnings)) {
         finish(ExitCode.ok, { ok: true, message: "nothing to clear" });
       }
-      fs59.rmSync(learnings, { recursive: true, force: true });
+      fs61.rmSync(learnings, { recursive: true, force: true });
       finish(ExitCode.ok, { ok: true, message: `cleared ${learnings}` });
     }
     if (pos[0] === "ace" && pos[1] === "learn") {
       requireOpenCode(merged, flags);
       const { worktree } = parseWorktreeFlag(pos.slice(2));
-      const root = worktree && fs59.existsSync(path59.join(worktree, ".opencode", "schemas", "ace")) ? worktree : repoRoot;
+      const root = worktree && fs61.existsSync(path59.join(worktree, ".opencode", "schemas", "ace")) ? worktree : repoRoot;
       const contextDir2 = path59.join(root, ".gluecharm", "context");
       const traces = listAceTraceFiles(contextDir2);
       if (traces.length === 0) {
@@ -28850,7 +29402,7 @@ async function main() {
     if (pos[0] === "ace" && pos[1] === "auto-learn") {
       requireOpenCode(merged, flags);
       const { worktree } = parseWorktreeFlag(pos.slice(2));
-      const root = worktree && fs59.existsSync(path59.join(worktree, ".git")) ? worktree : repoRoot;
+      const root = worktree && fs61.existsSync(path59.join(worktree, ".git")) ? worktree : repoRoot;
       const contextDir2 = path59.join(root, ".gluecharm", "context");
       const pending = listPendingAceTraceFiles(contextDir2, root);
       if (pending.length === 0) {
@@ -28893,9 +29445,10 @@ async function main() {
       }
       process.exit(ExitCode.misconfiguration);
     }
-    const msg = e instanceof Error ? e.message : String(e);
+    const msg = formatCliThrownUnknown(e);
+    const exitFromApi = exitCodeForThrownHttpApiError(e);
     logErr(flags, msg);
-    finish(ExitCode.internal, { ok: false, error: msg });
+    finish(exitFromApi ?? ExitCode.internal, { ok: false, error: msg });
   }
 }
 void main();