@gluecharm-lab/easyspecs-cli 0.0.3 → 0.0.5

package/dist/main.cjs

@@ -2251,8 +2251,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize) {
-      if (normalize !== false)
+    function getFullPath(resolver, id = "", normalize4) {
+      if (normalize4 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -3000,7 +3000,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve14.call(this, root, ref);
+      let _sch = resolve15.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3027,7 +3027,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve14(root, ref) {
+    function resolve15(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3592,7 +3592,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize(uri, options) {
+    function normalize4(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         serialize(parse(uri, options), options);
@@ -3602,55 +3602,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve14(baseURI, relativeURI, options) {
+    function resolve15(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative11, options, skipNormalization) {
+    function resolveComponent(base, relative12, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse(serialize(base, options), options);
-        relative11 = parse(serialize(relative11, options), options);
+        relative12 = parse(serialize(relative12, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative11.scheme) {
-        target.scheme = relative11.scheme;
-        target.userinfo = relative11.userinfo;
-        target.host = relative11.host;
-        target.port = relative11.port;
-        target.path = removeDotSegments(relative11.path || "");
-        target.query = relative11.query;
+      if (!options.tolerant && relative12.scheme) {
+        target.scheme = relative12.scheme;
+        target.userinfo = relative12.userinfo;
+        target.host = relative12.host;
+        target.port = relative12.port;
+        target.path = removeDotSegments(relative12.path || "");
+        target.query = relative12.query;
       } else {
-        if (relative11.userinfo !== void 0 || relative11.host !== void 0 || relative11.port !== void 0) {
-          target.userinfo = relative11.userinfo;
-          target.host = relative11.host;
-          target.port = relative11.port;
-          target.path = removeDotSegments(relative11.path || "");
-          target.query = relative11.query;
+        if (relative12.userinfo !== void 0 || relative12.host !== void 0 || relative12.port !== void 0) {
+          target.userinfo = relative12.userinfo;
+          target.host = relative12.host;
+          target.port = relative12.port;
+          target.path = removeDotSegments(relative12.path || "");
+          target.query = relative12.query;
         } else {
-          if (!relative11.path) {
+          if (!relative12.path) {
             target.path = base.path;
-            if (relative11.query !== void 0) {
-              target.query = relative11.query;
+            if (relative12.query !== void 0) {
+              target.query = relative12.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative11.path[0] === "/") {
-              target.path = removeDotSegments(relative11.path);
+            if (relative12.path[0] === "/") {
+              target.path = removeDotSegments(relative12.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative11.path;
+                target.path = "/" + relative12.path;
               } else if (!base.path) {
-                target.path = relative11.path;
+                target.path = relative12.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative11.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative12.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative11.query;
+            target.query = relative12.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3658,7 +3658,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative11.fragment;
+      target.fragment = relative12.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -3828,8 +3828,8 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize,
-      resolve: resolve14,
+      normalize: normalize4,
+      resolve: resolve15,
       resolveComponent,
       equal,
       serialize,
@@ -7082,7 +7082,14 @@ var path43 = __toESM(require("node:path"));
 
 // src/cli/argv.ts
 function isGlobalFlag(s) {
-  return s === "--cwd" || s === "--ci" || s === "--json" || s === "--verbose" || s === "--config" || s === "--api-base-url" || s === "--promote" || s === "--no-promote" || s === "--help" || s === "-h" || s === "--version" || s === "-V";
+  return s === "--cwd" || s === "--ci" || s === "--json" || s === "--verbose" || s === "--config" || s === "--api-base-url" || s === "--session-path" || s === "--environment" || s === "--env" || s === "--promote" || s === "--no-promote" || s === "--help" || s === "-h" || s === "--version" || s === "-V";
+}
+function parseEnvironmentToken(raw) {
+  const t = raw?.trim().toLowerCase();
+  if (t === "production" || t === "staging") {
+    return t;
+  }
+  throw new Error(`Invalid --environment: ${raw ?? "(missing)"} (expected production or staging)`);
 }
 function parseArgv(argv) {
   const flags = {
@@ -7115,6 +7122,16 @@ function parseArgv(argv) {
       i += 1;
       continue;
     }
+    if (a === "--session-path" && argv[i + 1]) {
+      flags.sessionPath = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if ((a === "--environment" || a === "--env") && argv[i + 1]) {
+      flags.environment = parseEnvironmentToken(argv[i + 1]);
+      i += 1;
+      continue;
+    }
     if (a === "--ci") {
       flags.ci = true;
       continue;
@@ -7147,9 +7164,6 @@ function parseArgv(argv) {
       throw new Error(`Unknown flag: ${a}`);
     }
   }
-  if (process.env.EASYSPECS_CI === "1" || process.env.EASYSPECS_CI === "true") {
-    flags.ci = true;
-  }
   return { flags, positionals };
 }
 
@@ -7173,8 +7187,8 @@ function printJsonLine(envelope) {
 }
 
 // src/cli/cliContext.ts
-var fs4 = __toESM(require("node:fs"));
-var path4 = __toESM(require("path"));
+var fs2 = __toESM(require("node:fs"));
+var path2 = __toESM(require("path"));
 
 // src/repositoryProvenance.ts
 var import_node_child_process = require("node:child_process");
@@ -7343,98 +7357,115 @@ function attachRepositoryProvenance(doc, contextDir2, opts) {
 }
 
 // src/apiBaseUrlResolve.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
 var vscode = __toESM(require_vscode_stub());
-
-// src/envDotEnvParse.ts
-function parseDotEnvContent(content) {
-  const out = {};
-  for (const line of content.split(/\r?\n/)) {
-    const t = line.trim();
-    if (t.length === 0 || t.startsWith("#")) {
-      continue;
-    }
-    const eq = t.indexOf("=");
-    if (eq <= 0) {
-      continue;
-    }
-    const key = t.slice(0, eq).trim();
-    let val = t.slice(eq + 1).trim();
-    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
-      val = val.slice(1, -1);
-    }
-    out[key] = val;
-  }
-  return out;
-}
-
-// src/apiBaseUrlResolve.ts
-var ENV_KEYS = ["VITE_SYSTEM_MANAGER_API_URL", "VITE_API_BASE_URL"];
 var extensionRoot;
 var cachedExtensionDotEnv = null;
 function setApiBaseUrlExtensionRoot(extensionFsPath) {
   extensionRoot = extensionFsPath;
   cachedExtensionDotEnv = null;
 }
+
+// src/easyspecsBuiltInApiUrls.ts
+var PRODUCTION_SYSTEM_MANAGER_URL = "https://api.easyspecs.ai";
+var STAGING_SYSTEM_MANAGER_URL = "https://system-manager-api.staging.gluecharm.info:8092";
+
+// src/easyspecsApiBaseUrlCli.ts
 function stripTrailingSlash(url) {
   return url.replace(/\/$/, "");
 }
-function pickFromMap(map) {
-  if (!map) {
-    return "";
+function resolveEasyspecsApiBaseUrlForCli(input) {
+  const fromFlag = input.flagApiBaseUrl?.trim();
+  if (fromFlag) {
+    return stripTrailingSlash(fromFlag);
   }
-  for (const key of ENV_KEYS) {
-    const v = map[key]?.trim();
-    if (v) {
-      return stripTrailingSlash(v);
-    }
+  const fromFile = input.config.easyspecs?.apiBaseUrl?.trim();
+  if (fromFile) {
+    return stripTrailingSlash(fromFile);
   }
-  return "";
+  const eff = input.flagEnvironment ?? input.config.easyspecs?.deploymentEnvironment ?? "production";
+  return eff === "staging" ? STAGING_SYSTEM_MANAGER_URL : PRODUCTION_SYSTEM_MANAGER_URL;
 }
-function readDotEnvFile(filePath) {
-  try {
-    if (!fs2.existsSync(filePath)) {
-      return void 0;
-    }
-    const content = fs2.readFileSync(filePath, "utf8");
-    return parseDotEnvContent(content);
-  } catch {
-    return void 0;
+
+// src/cli/cliContext.ts
+function thisDir() {
+  return __dirname;
+}
+function resolveRepoRoot(flags) {
+  const abs = path2.resolve(flags.cwd);
+  const git = findGitRepoRoot(abs);
+  return git ?? abs;
+}
+function resolveExtensionRoot() {
+  const env = process.env.EASYSPECS_EXTENSION_ROOT?.trim();
+  if (env) {
+    return path2.resolve(env);
+  }
+  const here = thisDir();
+  if (here.includes(`${path2.sep}packages${path2.sep}cli${path2.sep}dist`)) {
+    return path2.resolve(here, "..", "..", "..");
   }
+  return path2.resolve(here, "..", "..");
 }
-function resolveApiBaseUrlHeadless(input) {
-  const fromSettings = input.settingsApiBaseUrl?.trim() ?? "";
-  if (fromSettings.length > 0) {
-    return stripTrailingSlash(fromSettings);
+function resolveOpenCodeAgentsDir() {
+  const resEnv = process.env.EASYSPECS_CLI_RESOURCES?.trim();
+  if (resEnv) {
+    return path2.join(path2.resolve(resEnv), "opencode-agents");
   }
-  const easyspecsEnv = process.env.EASYSPECS_API_BASE_URL?.trim();
-  if (easyspecsEnv) {
-    return stripTrailingSlash(easyspecsEnv);
+  const here = thisDir();
+  if (here.includes(`${path2.sep}packages${path2.sep}cli${path2.sep}dist`)) {
+    return path2.join(here, "..", "resources", "opencode-agents");
   }
-  for (const key of ENV_KEYS) {
-    const v = process.env[key]?.trim();
-    if (v) {
-      return stripTrailingSlash(v);
-    }
+  return path2.join(resolveExtensionRoot(), "resources", "opencode-agents");
+}
+function initApiBaseUrlForCli(repoRoot, flags, config) {
+  const extensionRoot2 = resolveExtensionRoot();
+  setApiBaseUrlExtensionRoot(extensionRoot2);
+  return resolveEasyspecsApiBaseUrlForCli({
+    flagApiBaseUrl: flags.apiBaseUrl,
+    flagEnvironment: flags.environment,
+    config
+  });
+}
+function assertAgentsDirExists(agentsDir) {
+  if (!fs2.existsSync(agentsDir)) {
+    throw new Error(
+      `OpenCode agents directory missing: ${agentsDir}. Set EASYSPECS_EXTENSION_ROOT or EASYSPECS_CLI_RESOURCES, or run \`npm run build:cli\` to copy resources.`
+    );
   }
-  const extMap = input.extensionDotEnv ?? (input.extensionRoot ? readDotEnvFile(path2.join(input.extensionRoot, ".env")) : void 0);
-  const fromExt = pickFromMap(extMap);
-  if (fromExt) {
-    return fromExt;
+}
+
+// src/config/openCodeProviderEnv.ts
+var path3 = __toESM(require("node:path"));
+var PROVIDER_TO_ENV = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  google: "GOOGLE_API_KEY",
+  opencode: "OPENCODE_API_KEY"
+};
+function buildOpenCodeProviderEnvFromConfig(cfg, repoRoot) {
+  const out = {};
+  const prov = cfg.easyspecs?.openCodeRuntime?.providers;
+  if (prov) {
+    for (const id of Object.keys(PROVIDER_TO_ENV)) {
+      const envName = PROVIDER_TO_ENV[id];
+      const key = prov[id]?.apiKey?.trim();
+      if (key) {
+        out[envName] = key;
+      }
+    }
   }
-  if (input.workspaceFolderPath) {
-    const fromWs = pickFromMap(readDotEnvFile(path2.join(input.workspaceFolderPath, ".env")));
-    if (fromWs) {
-      return fromWs;
+  const raw = cfg.easyspecs?.openCodeRuntime?.credentialsPath;
+  if (repoRoot && typeof raw === "string") {
+    const t = raw.trim();
+    if (t.length > 0) {
+      out.OPENCODE_AUTH_PATH = path3.isAbsolute(t) ? path3.normalize(t) : path3.resolve(repoRoot, t);
     }
   }
-  return "";
+  return out;
 }
 
 // src/cli/cliSettings.ts
-var fs3 = __toESM(require("node:fs"));
-var path3 = __toESM(require("node:path"));
 var DEFAULT_OPEN_CODE_TEST_ARGV = [
   "run",
   "--agent",
@@ -7444,72 +7475,23 @@ var DEFAULT_OPEN_CODE_TEST_ARGV = [
   "{promptFile}"
 ];
 var CI_DEFAULT_MAX_OUTER = 3;
-function readCliJson(repoRoot) {
-  const f = path3.join(repoRoot, ".easyspecs", "cli.json");
-  try {
-    if (!fs3.existsSync(f)) {
-      return void 0;
-    }
-    const raw = fs3.readFileSync(f, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-}
-function numEnv(name, fallback) {
-  const v = process.env[name]?.trim();
-  if (!v) {
-    return fallback;
-  }
-  const n = Number(v);
-  return Number.isFinite(n) ? n : fallback;
-}
-function boolEnv(name, fallback) {
-  const v = process.env[name]?.trim().toLowerCase();
-  if (v === "1" || v === "true" || v === "yes") {
-    return true;
-  }
-  if (v === "0" || v === "false" || v === "no") {
-    return false;
-  }
-  return fallback;
-}
-function mergeCliSettings(repoRoot, overrides = {}) {
-  const file = readCliJson(repoRoot);
-  const es = file?.easyspecs ?? {};
+function mergeEasyspecsCliSettings(cfg, overrides = {}) {
+  const es = cfg.easyspecs ?? {};
   const analysis = es.analysis ?? {};
   const orch = es.orchestration ?? {};
-  const ci = overrides.ci === true || boolEnv("EASYSPECS_CI", false);
-  const apiBaseUrl = overrides.apiBaseUrl?.trim() || process.env.EASYSPECS_API_BASE_URL?.trim() || file?.apiBaseUrl?.trim() || es.apiBaseUrl?.trim() || "";
-  const openCodeExecutable = overrides.openCodeExecutable?.trim() || es.openCode?.executable?.trim() || process.env.EASYSPECS_OPENCODE_EXECUTABLE?.trim() || "opencode";
-  const openCodeSkipCredentialsCheck = es.openCode?.skipCredentialsCheck === true || boolEnv("EASYSPECS_OPENCODE_SKIP_CREDENTIALS_CHECK", false);
-  let argvTemplate = overrides.argvTemplate ?? (Array.isArray(analysis.openCodeTestArgv) && analysis.openCodeTestArgv.length > 0 && analysis.openCodeTestArgv.every((x) => typeof x === "string") ? analysis.openCodeTestArgv : [...DEFAULT_OPEN_CODE_TEST_ARGV]);
-  const argvJson = process.env.EASYSPECS_OPEN_CODE_TEST_ARGV_JSON?.trim();
-  if (argvJson) {
-    try {
-      const parsed = JSON.parse(argvJson);
-      if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((x) => typeof x === "string")) {
-        argvTemplate = parsed;
-      }
-    } catch {
-    }
-  }
-  const timeoutMs = overrides.timeoutMs ?? numEnv("EASYSPECS_ANALYSIS_TIMEOUT_MS", analysis.openCodeTestTimeoutMs ?? 6e5);
-  const listJsonSchemaRepairAttempts = numEnv(
-    "EASYSPECS_LIST_JSON_SCHEMA_REPAIR_ATTEMPTS",
-    analysis.listJsonSchemaRepairAttempts ?? 1
-  );
-  const markdownEvidenceRepairAttempts = numEnv(
-    "EASYSPECS_MARKDOWN_EVIDENCE_REPAIR_ATTEMPTS",
-    analysis.markdownEvidenceRepairAttempts ?? 2
-  );
-  const markdownOpenQuestionIterations = numEnv(
-    "EASYSPECS_MARKDOWN_OPEN_QUESTION_ITERATIONS",
-    analysis.markdownOpenQuestionIterations ?? 5
-  );
-  const maxConcurrentOpenCodeAgents = overrides.maxConcurrentOpenCodeAgents ?? numEnv("EASYSPECS_MAX_CONCURRENT_AGENTS", analysis.maxConcurrentOpenCodeAgents ?? 30);
+  const rt = es.openCodeRuntime;
+  const ci = overrides.ci === true;
+  const apiBaseUrl = overrides.apiBaseUrl?.trim() || (typeof es.apiBaseUrl === "string" ? es.apiBaseUrl.trim() : "") || "";
+  const openCodeExecutable = overrides.openCodeExecutable?.trim() || es.openCode?.executable?.trim() || rt?.executable?.trim() || "opencode";
+  const openCodeSkipCredentialsCheck = es.openCode?.skipCredentialsCheck === true || rt?.skipCredentialsCheck === true;
+  let argvTemplate = overrides.argvTemplate ?? (rt?.run?.argvTemplate && rt.run.argvTemplate.length > 0 && rt.run.argvTemplate.every((x) => typeof x === "string") ? [...rt.run.argvTemplate] : void 0) ?? (Array.isArray(analysis.openCodeTestArgv) && analysis.openCodeTestArgv.length > 0 && analysis.openCodeTestArgv.every((x) => typeof x === "string") ? analysis.openCodeTestArgv : [...DEFAULT_OPEN_CODE_TEST_ARGV]);
+  const timeoutMs = overrides.timeoutMs ?? rt?.run?.timeoutMs ?? analysis.openCodeTestTimeoutMs ?? 6e5;
+  const listJsonSchemaRepairAttempts = rt?.coordinationRepairs?.listJsonSchemaRepairAttempts ?? analysis.listJsonSchemaRepairAttempts ?? 1;
+  const markdownEvidenceRepairAttempts = rt?.coordinationRepairs?.markdownEvidenceRepairAttempts ?? analysis.markdownEvidenceRepairAttempts ?? 2;
+  const markdownOpenQuestionIterations = rt?.coordinationRepairs?.markdownOpenQuestionIterations ?? analysis.markdownOpenQuestionIterations ?? 5;
+  const maxConcurrentOpenCodeAgents = overrides.maxConcurrentOpenCodeAgents ?? rt?.pool?.maxConcurrentAgents ?? analysis.maxConcurrentOpenCodeAgents ?? 30;
   const promoteContextToWorkspace = overrides.promote === false ? false : overrides.promote === true ? true : analysis.promoteContextToWorkspace !== false;
-  let maxOuter = overrides.maxOuterIterationsPerPhase ?? orch.maxOuterIterationsPerPhase ?? numEnv("EASYSPECS_MAX_OUTER_ITERATIONS_PER_PHASE", 0);
+  let maxOuter = overrides.maxOuterIterationsPerPhase ?? orch.maxOuterIterationsPerPhase ?? 0;
   if (ci && maxOuter === 0) {
     maxOuter = CI_DEFAULT_MAX_OUTER;
   }
@@ -7521,12 +7503,15 @@ function mergeCliSettings(repoRoot, overrides = {}) {
     maxMacroPingPongCycles: orch.maxMacroPingPongCycles ?? 5,
     synthesisRemediationShareBackoff: orch.synthesisRemediationShareBackoff !== false
   };
+  const openCodeChildEnv = buildOpenCodeProviderEnvFromConfig(cfg, overrides.repoRoot);
+  const projectConfigOverlay = cfg.easyspecs?.openCodeRuntime?.projectConfigOverlay;
   return {
     apiBaseUrl,
     openCodeExecutable,
     openCodeSkipCredentialsCheck,
     promoteContextToWorkspace,
     ci,
+    openCodeChildEnv,
     pipelineOpenCode: {
       executable: openCodeExecutable,
       argvTemplate,
@@ -7534,85 +7519,420 @@ function mergeCliSettings(repoRoot, overrides = {}) {
       listJsonSchemaRepairAttempts,
       markdownEvidenceRepairAttempts,
       markdownOpenQuestionIterations,
-      maxConcurrentOpenCodeAgents
+      maxConcurrentOpenCodeAgents,
+      openCodeChildEnv,
+      projectConfigOverlay
     },
     macroOrchestration
   };
 }
 
-// src/cli/cliContext.ts
-function thisDir() {
-  return __dirname;
+// src/cli/cliSettingsDump.ts
+function redactMergedCliSettingsForDump(merged) {
+  const child = merged.openCodeChildEnv;
+  const childRedacted = child && Object.keys(child).length > 0 ? Object.fromEntries(Object.keys(child).map((k) => [k, "(redacted)"])) : {};
+  return {
+    ...merged,
+    apiBaseUrl: merged.apiBaseUrl ? "(set)" : "",
+    openCodeChildEnv: childRedacted,
+    pipelineOpenCode: {
+      ...merged.pipelineOpenCode,
+      openCodeChildEnv: childRedacted
+    }
+  };
 }
-function resolveRepoRoot(flags) {
-  const abs = path4.resolve(flags.cwd);
-  const git = findGitRepoRoot(abs);
-  return git ?? abs;
+
+// src/config/easyspecsConfigFile.ts
+var fs5 = __toESM(require("node:fs"));
+var path6 = __toESM(require("node:path"));
+
+// src/easySpecsWorkspaceSettingsCore.ts
+var fs4 = __toESM(require("node:fs"));
+var path5 = __toESM(require("node:path"));
+
+// src/analysis/easySpecsWorktreeMarker.ts
+var fs3 = __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 });
+  const payload = {
+    kind: MARKER_KIND,
+    repositoryRoot: path4.resolve(repositoryRoot)
+  };
+  fs3.writeFileSync(path4.join(dir, "analysis-worktree.json"), `${JSON.stringify(payload)}
+`, "utf-8");
 }
-function resolveExtensionRoot() {
-  const env = process.env.EASYSPECS_EXTENSION_ROOT?.trim();
-  if (env) {
-    return path4.resolve(env);
+
+// src/easySpecsWorkspaceSettingsCore.ts
+var EASYSPECS_WORKSPACE_DIR = EASYSPECS_LOCAL_DIR;
+var EASYSPECS_SETTINGS_JSON = "settings.json";
+var EASYSPECS_SETTINGS_ACE_KEY = "easyspecs.analysis.ace.enabled";
+var EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY = "easyspecs.analysis.ace.offlineLearnAfterSameSessionTrace";
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function readAceEnabledFromEasySpecsSettingsFile(workspaceRootFsPath) {
+  const filePath = path5.join(workspaceRootFsPath, EASYSPECS_WORKSPACE_DIR, EASYSPECS_SETTINGS_JSON);
+  let raw;
+  try {
+    raw = fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return void 0;
   }
-  const here = thisDir();
-  if (here.includes(`${path4.sep}packages${path4.sep}cli${path4.sep}dist`)) {
-    return path4.resolve(here, "..", "..", "..");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed) || !Object.prototype.hasOwnProperty.call(parsed, EASYSPECS_SETTINGS_ACE_KEY)) {
+    return void 0;
   }
-  return path4.resolve(here, "..", "..");
+  const v = parsed[EASYSPECS_SETTINGS_ACE_KEY];
+  return typeof v === "boolean" ? v : void 0;
 }
-function resolveOpenCodeAgentsDir() {
-  const resEnv = process.env.EASYSPECS_CLI_RESOURCES?.trim();
-  if (resEnv) {
-    return path4.join(path4.resolve(resEnv), "opencode-agents");
+function readAceOfflineLearnAfterSameSessionTraceFromEasySpecsSettingsFile(workspaceRootFsPath) {
+  const filePath = path5.join(workspaceRootFsPath, EASYSPECS_WORKSPACE_DIR, EASYSPECS_SETTINGS_JSON);
+  let raw;
+  try {
+    raw = fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return void 0;
   }
-  const here = thisDir();
-  if (here.includes(`${path4.sep}packages${path4.sep}cli${path4.sep}dist`)) {
-    return path4.join(here, "..", "resources", "opencode-agents");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
   }
-  return path4.join(resolveExtensionRoot(), "resources", "opencode-agents");
+  if (!isRecord(parsed) || !Object.prototype.hasOwnProperty.call(parsed, EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY)) {
+    return void 0;
+  }
+  const v = parsed[EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY];
+  return typeof v === "boolean" ? v : void 0;
 }
-function initApiBaseUrlForCli(repoRoot, flags) {
-  const extensionRoot2 = resolveExtensionRoot();
-  setApiBaseUrlExtensionRoot(extensionRoot2);
-  const merged = mergeCliSettings(repoRoot, {
-    ci: flags.ci,
-    apiBaseUrl: flags.apiBaseUrl,
-    promote: flags.promote
-  });
-  return resolveApiBaseUrlHeadless({
-    settingsApiBaseUrl: merged.apiBaseUrl,
-    extensionRoot: extensionRoot2,
-    workspaceFolderPath: repoRoot
-  });
+
+// src/config/easyspecsConfigJson.ts
+function mergeEasyspecsConfigDefaults(defaults, partial) {
+  if (!partial) {
+    return defaults;
+  }
+  const esInRaw = partial.easyspecs ?? {};
+  const legacyProjectId = esInRaw.applicationId;
+  const { applicationId: _omitLegacyApplicationIdKey, ...esIn } = esInRaw;
+  void _omitLegacyApplicationIdKey;
+  const defEs = defaults.easyspecs;
+  const mergedEs = {
+    ...defEs,
+    ...esIn,
+    deploymentEnvironment: esIn.deploymentEnvironment ?? defEs.deploymentEnvironment,
+    apiBaseUrl: esIn.apiBaseUrl ?? defEs.apiBaseUrl,
+    easyspecsProjectId: esIn.easyspecsProjectId !== void 0 ? esIn.easyspecsProjectId : legacyProjectId !== void 0 ? legacyProjectId : defEs.easyspecsProjectId,
+    defaultGitRemoteUrl: esIn.defaultGitRemoteUrl !== void 0 ? esIn.defaultGitRemoteUrl : defEs.defaultGitRemoteUrl,
+    cliSessionPath: esIn.cliSessionPath !== void 0 ? esIn.cliSessionPath : defEs.cliSessionPath,
+    openCode: { ...defEs.openCode, ...esIn.openCode },
+    analysis: mergeAnalysisBlock(
+      defEs.analysis ?? { promoteContextToWorkspace: true },
+      esIn.analysis
+    ),
+    orchestration: { ...defEs.orchestration, ...esIn.orchestration },
+    openCodeRuntime: mergeOpenCodeRuntime(defEs.openCodeRuntime, esIn.openCodeRuntime)
+  };
+  return {
+    schemaVersion: partial.schemaVersion ?? defaults.schemaVersion,
+    easyspecs: mergedEs
+  };
 }
-function assertAgentsDirExists(agentsDir) {
-  if (!fs4.existsSync(agentsDir)) {
-    throw new Error(
-      `OpenCode agents directory missing: ${agentsDir}. Set EASYSPECS_EXTENSION_ROOT or EASYSPECS_CLI_RESOURCES, or run \`npm run build:cli\` to copy resources.`
-    );
+function mergeAnalysisBlock(base, over) {
+  if (!over || Object.keys(over).length === 0) {
+    return { ...base };
+  }
+  const merged = {
+    ...base,
+    ...over
+  };
+  if (base.ace || over.ace) {
+    merged.ace = { ...base.ace, ...over.ace };
+  }
+  return merged;
+}
+function mergeOpenCodeRuntime(base, over) {
+  if (!over && !base) {
+    return void 0;
   }
+  const b = base ?? {};
+  const o = over ?? {};
+  return {
+    ...b,
+    ...o,
+    executable: o.executable ?? b.executable,
+    skipCredentialsCheck: o.skipCredentialsCheck ?? b.skipCredentialsCheck,
+    credentialsPath: o.credentialsPath !== void 0 ? o.credentialsPath : b.credentialsPath,
+    providers: { ...b.providers, ...o.providers },
+    run: { ...b.run, ...o.run },
+    coordinationRepairs: { ...b.coordinationRepairs, ...o.coordinationRepairs },
+    pool: { ...b.pool, ...o.pool },
+    projectConfigOverlay: b.projectConfigOverlay || o.projectConfigOverlay ? { ...b.projectConfigOverlay ?? {}, ...o.projectConfigOverlay ?? {} } : void 0
+  };
+}
+function getDefaultEasyspecsConfig() {
+  const openCodeRuntime = {
+    executable: "opencode",
+    skipCredentialsCheck: false,
+    credentialsPath: ".opencode/auth.json",
+    providers: {},
+    run: {
+      argvTemplate: [
+        "run",
+        "--agent",
+        "{agentId}",
+        "Execute the task described in the attached EasySpecs prompt file.",
+        "-f",
+        "{promptFile}"
+      ],
+      timeoutMs: 6e5
+    },
+    coordinationRepairs: {
+      listJsonSchemaRepairAttempts: 1,
+      markdownEvidenceRepairAttempts: 2,
+      markdownOpenQuestionIterations: 5
+    },
+    pool: {
+      maxConcurrentAgents: 30
+    },
+    projectConfigOverlay: {}
+  };
+  return {
+    schemaVersion: 1,
+    easyspecs: {
+      deploymentEnvironment: "production",
+      apiBaseUrl: PRODUCTION_SYSTEM_MANAGER_URL,
+      easyspecsProjectId: "",
+      defaultGitRemoteUrl: "",
+      cliSessionPath: "",
+      openCode: {
+        executable: "opencode",
+        skipCredentialsCheck: false
+      },
+      analysis: {
+        promoteContextToWorkspace: true
+      },
+      orchestration: {},
+      openCodeRuntime
+    }
+  };
+}
+
+// src/config/easyspecsConfigFile.ts
+var DIRNAME = ".easyspecs";
+var CONFIG_BASENAME = "config.json";
+var LEGACY_CLI_JSON = "cli.json";
+var LEGACY_SETTINGS_JSON = "settings.json";
+function easyspecsConfigPath(repoRoot) {
+  return path6.join(repoRoot, DIRNAME, CONFIG_BASENAME);
+}
+function easyspecsLegacyCliJsonPath(repoRoot) {
+  return path6.join(repoRoot, DIRNAME, LEGACY_CLI_JSON);
+}
+function easyspecsLegacySettingsJsonPath(repoRoot) {
+  return path6.join(repoRoot, DIRNAME, LEGACY_SETTINGS_JSON);
+}
+var EasyspecsConfigInvalidJsonError = class extends Error {
+  constructor(filePath, cause) {
+    super(`Invalid JSON in ${filePath}${cause instanceof Error ? `: ${cause.message}` : ""}`);
+    this.filePath = filePath;
+    this.cause = cause;
+    this.name = "EasyspecsConfigInvalidJsonError";
+  }
+};
+function parseEasyspecsConfigJson(raw, filePath) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new EasyspecsConfigInvalidJsonError(filePath);
+    }
+    return mergeEasyspecsConfigDefaults(getDefaultEasyspecsConfig(), parsed);
+  } catch (e) {
+    if (e instanceof EasyspecsConfigInvalidJsonError) {
+      throw e;
+    }
+    throw new EasyspecsConfigInvalidJsonError(filePath, e);
+  }
+}
+function readEasyspecsConfig(repoRoot) {
+  const p = easyspecsConfigPath(repoRoot);
+  const raw = fs5.readFileSync(p, "utf8");
+  return parseEasyspecsConfigJson(raw, p);
+}
+function cliJsonFileToConfigPartial(legacy) {
+  const es = legacy.easyspecs ?? {};
+  const analysis = es.analysis ?? {};
+  const orch = es.orchestration ?? {};
+  const partial = {
+    easyspecs: {
+      apiBaseUrl: legacy.apiBaseUrl ?? es.apiBaseUrl ?? "",
+      openCode: es.openCode,
+      analysis: {
+        openCodeTestArgv: analysis.openCodeTestArgv,
+        openCodeTestTimeoutMs: analysis.openCodeTestTimeoutMs,
+        listJsonSchemaRepairAttempts: analysis.listJsonSchemaRepairAttempts,
+        markdownEvidenceRepairAttempts: analysis.markdownEvidenceRepairAttempts,
+        markdownOpenQuestionIterations: analysis.markdownOpenQuestionIterations,
+        maxConcurrentOpenCodeAgents: analysis.maxConcurrentOpenCodeAgents,
+        promoteContextToWorkspace: analysis.promoteContextToWorkspace
+      },
+      orchestration: {
+        initialDelayMs: orch.initialDelayMs,
+        backoffMultiplier: orch.backoffMultiplier,
+        maxDelayMs: orch.maxDelayMs,
+        maxOuterIterationsPerPhase: orch.maxOuterIterationsPerPhase,
+        maxMacroPingPongCycles: orch.maxMacroPingPongCycles,
+        synthesisRemediationShareBackoff: orch.synthesisRemediationShareBackoff
+      }
+    }
+  };
+  return partial;
+}
+function atomicWriteFile(targetPath, contents) {
+  const dir = path6.dirname(targetPath);
+  fs5.mkdirSync(dir, { recursive: true });
+  const tmp = path6.join(dir, `.${path6.basename(targetPath)}.${process.pid}.${Date.now()}.tmp`);
+  fs5.writeFileSync(tmp, contents, "utf8");
+  fs5.renameSync(tmp, targetPath);
+}
+function buildFreshEasyspecsConfigFromLegacy(repoRoot, warnMigration) {
+  let base = getDefaultEasyspecsConfig();
+  const legacyPath = easyspecsLegacyCliJsonPath(repoRoot);
+  if (fs5.existsSync(legacyPath)) {
+    try {
+      const rawLegacy = fs5.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).`);
+    } catch (e) {
+      warnMigration?.(`Could not import ${LEGACY_CLI_JSON}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  const settingsLegacyPath = easyspecsLegacySettingsJsonPath(repoRoot);
+  if (fs5.existsSync(settingsLegacyPath)) {
+    try {
+      const rawS = fs5.readFileSync(settingsLegacyPath, "utf8");
+      const leg = JSON.parse(rawS);
+      const ace = {};
+      if (Object.prototype.hasOwnProperty.call(leg, EASYSPECS_SETTINGS_ACE_KEY)) {
+        const v = leg[EASYSPECS_SETTINGS_ACE_KEY];
+        if (typeof v === "boolean") {
+          ace.enabled = v;
+        }
+      }
+      if (Object.prototype.hasOwnProperty.call(leg, EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY)) {
+        const v = leg[EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY];
+        if (typeof v === "boolean") {
+          ace.offlineLearnAfterSameSessionTrace = v;
+        }
+      }
+      if (Object.keys(ace).length > 0) {
+        base = mergeEasyspecsConfigDefaults(base, { easyspecs: { analysis: { ace } } });
+        warnMigration?.(`Imported ACE toggles from ${LEGACY_SETTINGS_JSON} into ${CONFIG_BASENAME}.`);
+      }
+    } catch (e) {
+      warnMigration?.(
+        `Could not import ${LEGACY_SETTINGS_JSON}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  return base;
+}
+function initEasyspecsConfigFile(repoRoot, opts) {
+  const configPath = easyspecsConfigPath(repoRoot);
+  const existed = fs5.existsSync(configPath);
+  if (existed && !opts.overwrite) {
+    return { outcome: "unchanged", path: configPath, config: readEasyspecsConfig(repoRoot) };
+  }
+  const base = buildFreshEasyspecsConfigFromLegacy(repoRoot, opts.warnMigration);
+  atomicWriteFile(configPath, `${JSON.stringify(base, null, 2)}
+`);
+  return {
+    outcome: existed ? "overwritten" : "created",
+    path: configPath,
+    config: readEasyspecsConfig(repoRoot)
+  };
+}
+function ensureEasyspecsConfig(repoRoot, opts) {
+  const configPath = easyspecsConfigPath(repoRoot);
+  const legacyPath = easyspecsLegacyCliJsonPath(repoRoot);
+  if (fs5.existsSync(configPath)) {
+    if (fs5.existsSync(legacyPath)) {
+      opts.warnMigration?.(
+        `${legacyPath} is deprecated alongside ${configPath}; prefer editing ${CONFIG_BASENAME} only.`
+      );
+    }
+    const settingsLegacy = easyspecsLegacySettingsJsonPath(repoRoot);
+    if (fs5.existsSync(settingsLegacy)) {
+      opts.warnMigration?.(
+        `${settingsLegacy} is deprecated; use easyspecs.analysis.ace in ${CONFIG_BASENAME} (see USER-MANUAL-SRS-35).`
+      );
+    }
+    return readEasyspecsConfig(repoRoot);
+  }
+  const base = buildFreshEasyspecsConfigFromLegacy(repoRoot, opts.warnMigration);
+  if (!opts.allowCreate) {
+    return base;
+  }
+  const body = `${JSON.stringify(base, null, 2)}
+`;
+  atomicWriteFile(configPath, body);
+  return readEasyspecsConfig(repoRoot);
+}
+function updateEasyspecsConfig(repoRoot, patch, opts) {
+  const configPath = easyspecsConfigPath(repoRoot);
+  const base = fs5.existsSync(configPath) ? readEasyspecsConfig(repoRoot) : buildFreshEasyspecsConfigFromLegacy(repoRoot, opts?.warnMigration);
+  const merged = mergeEasyspecsConfigDefaults(base, patch);
+  atomicWriteFile(configPath, `${JSON.stringify(merged, null, 2)}
+`);
+  return merged;
+}
+
+// src/config/easyspecsConfigRedact.ts
+function redactEasyspecsConfigRootForDump(cfg) {
+  const o = JSON.parse(JSON.stringify(cfg));
+  const es = o.easyspecs;
+  const rt = es?.openCodeRuntime;
+  const prov = rt?.providers;
+  if (prov && typeof prov === "object") {
+    for (const p of Object.values(prov)) {
+      if (p && typeof p === "object" && "apiKey" in p) {
+        p.apiKey = "(redacted)";
+      }
+    }
+  }
+  return o;
 }
 
 // src/cli/cliFileWorkspaceState.ts
-var fs5 = __toESM(require("node:fs"));
-var path5 = __toESM(require("node:path"));
+var fs6 = __toESM(require("node:fs"));
+var path7 = __toESM(require("node:path"));
 function createFileBackedWorkspaceState(repoRoot) {
-  const dir = path5.join(repoRoot, ".gluecharm", "logs");
-  const file = path5.join(dir, "easyspecs-cli-workspace-state.json");
-  fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.join(repoRoot, ".gluecharm", "logs");
+  const file = path7.join(dir, "easyspecs-cli-workspace-state.json");
+  fs6.mkdirSync(dir, { recursive: true });
   const load = () => {
     try {
-      if (!fs5.existsSync(file)) {
+      if (!fs6.existsSync(file)) {
         return {};
       }
-      const j = JSON.parse(fs5.readFileSync(file, "utf8"));
+      const j = JSON.parse(fs6.readFileSync(file, "utf8"));
       return typeof j === "object" && j !== null && !Array.isArray(j) ? j : {};
     } catch {
       return {};
     }
   };
   const save = (m) => {
-    fs5.writeFileSync(file, `${JSON.stringify(m, null, 2)}
+    fs6.writeFileSync(file, `${JSON.stringify(m, null, 2)}
 `, "utf8");
   };
   const workspaceState = {
@@ -7638,8 +7958,8 @@ var fs27 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
 
 // src/analysis/analysisDynamicTestSteps.ts
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var FE_CODE = /^FE-\d+$/;
 var UC_CODE = /^UC-\d+$/;
 var DM_CODE = /^DM-\d+$/;
@@ -7648,7 +7968,7 @@ function stripUtf8Bom(s) {
 }
 function readJson(filePath) {
   try {
-    const raw = stripUtf8Bom(fs6.readFileSync(filePath, "utf-8"));
+    const raw = stripUtf8Bom(fs7.readFileSync(filePath, "utf-8"));
     return JSON.parse(raw);
   } catch {
     return null;
@@ -7681,7 +8001,7 @@ function slugOrFallbackCoord(row2) {
   return null;
 }
 function discoverExperienceTreeRows(contextDir2) {
-  const expPath = path6.join(contextDir2, "experiences-list.json");
+  const expPath = path8.join(contextDir2, "experiences-list.json");
   const exp = readJson(expPath);
   const views = Array.isArray(exp?.views) ? exp.views : [];
   const out = [];
@@ -7714,7 +8034,7 @@ function discoverExperienceTreeRows(contextDir2) {
   return out;
 }
 function discoverServiceTreeRows(contextDir2) {
-  const svcPath = path6.join(contextDir2, "services-list.json");
+  const svcPath = path8.join(contextDir2, "services-list.json");
   const svcFile = readJson(svcPath);
   const svcs = Array.isArray(svcFile?.services) ? svcFile.services : [];
   const out = [];
@@ -7747,7 +8067,7 @@ function discoverServiceTreeRows(contextDir2) {
   return out;
 }
 function discoverTechStackToolRows(contextDir2) {
-  const tsPath = path6.join(contextDir2, "tech-stack-list.json");
+  const tsPath = path8.join(contextDir2, "tech-stack-list.json");
   const tsFile = readJson(tsPath);
   const tools = Array.isArray(tsFile?.tools) ? tsFile.tools : [];
   const out = [];
@@ -7770,7 +8090,7 @@ function safeFeatureName(v) {
 }
 function nonEmptyContextFile(absolutePath) {
   try {
-    const st = fs6.statSync(absolutePath);
+    const st = fs7.statSync(absolutePath);
     return st.isFile() && st.size > 0;
   } catch {
     return false;
@@ -7787,17 +8107,17 @@ var ANALYSIS_STATIC_CONTEXT_OUTPUTS = [
   "tech-stack-list.json"
 ];
 function discoverDynamicAnalysisTestSteps(contextDir2) {
-  const staticOutputs = ANALYSIS_STATIC_CONTEXT_OUTPUTS.map((basename11) => ({
-    basename: basename11,
-    exists: nonEmptyContextFile(path6.join(contextDir2, basename11))
+  const staticOutputs = ANALYSIS_STATIC_CONTEXT_OUTPUTS.map((basename12) => ({
+    basename: basename12,
+    exists: nonEmptyContextFile(path8.join(contextDir2, basename12))
   }));
-  const featuresPath = path6.join(contextDir2, "features-list.json");
+  const featuresPath = path8.join(contextDir2, "features-list.json");
   const featuresData = readJson(featuresPath);
   const rawFeatures = Array.isArray(featuresData?.features) ? featuresData.features : [];
   const entityFieldsRuns = [];
   const useCaseRuns = [];
   const scenarioRuns = [];
-  const dmPath = path6.join(contextDir2, "data-model-list.json");
+  const dmPath = path8.join(contextDir2, "data-model-list.json");
   const dmData = readJson(dmPath);
   const rawEntities = Array.isArray(dmData?.entities) ? dmData.entities : [];
   for (const erow of rawEntities) {
@@ -7806,7 +8126,7 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
       continue;
     }
     const ename = safeFeatureName(erow.name);
-    const fieldsListPath = path6.join(contextDir2, `${dm}-fields-list.json`);
+    const fieldsListPath = path8.join(contextDir2, `${dm}-fields-list.json`);
     entityFieldsRuns.push({
       entityCode: dm,
       entityName: ename,
@@ -7819,7 +8139,7 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
       continue;
     }
     const name = safeFeatureName(row2.name);
-    const useCasesListPath = path6.join(contextDir2, `${code}-use-cases-list.json`);
+    const useCasesListPath = path8.join(contextDir2, `${code}-use-cases-list.json`);
     useCaseRuns.push({
       featureCode: code,
       featureName: name,
@@ -7839,54 +8159,54 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
         useCaseCode: ucc,
         useCaseName: ucName,
         featureName: name,
-        scenariosListExists: nonEmptyContextFile(path6.join(contextDir2, scenariosBasename))
+        scenariosListExists: nonEmptyContextFile(path8.join(contextDir2, scenariosBasename))
       });
     }
   }
-  const entityFieldsEmptyHint = !fs6.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 = path6.join(contextDir2, "experiences-list.json");
+  const entityFieldsEmptyHint = !fs7.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 = path8.join(contextDir2, "experiences-list.json");
   const expFileData = readJson(expPath);
   const expTreeRows = discoverExperienceTreeRows(contextDir2);
   const experienceViewRuns = expTreeRows.map((row2) => ({
     code: row2.code,
     name: row2.name,
     slug: row2.slug,
-    viewDetailExists: nonEmptyContextFile(path6.join(contextDir2, `${row2.code}-${row2.slug}.md`)),
+    viewDetailExists: nonEmptyContextFile(path8.join(contextDir2, `${row2.code}-${row2.slug}.md`)),
     interactions: row2.interactions.map((ix) => ({
       code: ix.code,
       name: ix.name,
       slug: ix.slug,
-      detailExists: nonEmptyContextFile(path6.join(contextDir2, `${row2.code}_${ix.code}-${ix.slug}.md`))
+      detailExists: nonEmptyContextFile(path8.join(contextDir2, `${row2.code}_${ix.code}-${ix.slug}.md`))
     }))
   }));
-  const experienceEmptyHint = !fs6.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 = path6.join(contextDir2, "services-list.json");
+  const experienceEmptyHint = !fs7.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 = path8.join(contextDir2, "services-list.json");
   const svcFileData = readJson(svcPath);
   const svcTreeRows = discoverServiceTreeRows(contextDir2);
   const serviceRuns = svcTreeRows.map((row2) => ({
     code: row2.code,
     name: row2.name,
     slug: row2.slug,
-    serviceDetailExists: nonEmptyContextFile(path6.join(contextDir2, `${row2.code}-${row2.slug}.md`)),
+    serviceDetailExists: nonEmptyContextFile(path8.join(contextDir2, `${row2.code}-${row2.slug}.md`)),
     methods: row2.methods.map((m) => ({
       code: m.code,
       name: m.name,
       slug: m.slug,
-      detailExists: nonEmptyContextFile(path6.join(contextDir2, `${row2.code}_${m.code}-${m.slug}.md`))
+      detailExists: nonEmptyContextFile(path8.join(contextDir2, `${row2.code}_${m.code}-${m.slug}.md`))
     }))
   }));
-  const servicesEmptyHint = !fs6.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 = path6.join(contextDir2, "tech-stack-list.json");
+  const servicesEmptyHint = !fs7.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 = path8.join(contextDir2, "tech-stack-list.json");
   const tsListFileData = readJson(tsListPath);
   const toolTreeRows = discoverTechStackToolRows(contextDir2);
   const techStackToolRuns = toolTreeRows.map((row2) => ({
     code: row2.code,
     name: row2.name,
     slug: row2.slug,
-    toolDetailExists: nonEmptyContextFile(path6.join(contextDir2, `${row2.code}-${row2.slug}.md`))
+    toolDetailExists: nonEmptyContextFile(path8.join(contextDir2, `${row2.code}-${row2.slug}.md`))
   }));
-  const techStackEmptyHint = !fs6.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 = !fs6.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 = !fs7.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 = !fs7.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,
@@ -7906,15 +8226,15 @@ function discoverDynamicAnalysisTestSteps(contextDir2) {
 }
 
 // src/analysis/materializeOpenCodeAgents.ts
-var fs9 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 
 // src/analysis/applyAceMaterializedAgents.ts
-var fs8 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 
 // src/analysis/acePaths.ts
-var path7 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 var ACE_LEARNINGS_DIR = "learnings";
 var ACE_OVERLAYS_SUBDIR = "overlays";
 var ACE_TRACES_SUBDIR = "traces";
@@ -7927,10 +8247,10 @@ var ACE_SCHEMA_TRACE = "ace-generator-trace.schema.json";
 var ACE_SCHEMA_REFLECTOR = "ace-reflector-lessons.schema.json";
 var ACE_SCHEMA_CURATOR = "ace-curator-delta.schema.json";
 function gluecharmContextDir(worktreeRoot) {
-  return path7.join(worktreeRoot, ".gluecharm", "context");
+  return path9.join(worktreeRoot, ".gluecharm", "context");
 }
 function aceLearningsRoot(contextDir2) {
-  return path7.join(contextDir2, ACE_LEARNINGS_DIR);
+  return path9.join(contextDir2, ACE_LEARNINGS_DIR);
 }
 function sanitizeAcePathSegment(s) {
   return s.replace(/[^a-zA-Z0-9_.-]+/g, "_").slice(0, 200) || "id";
@@ -7943,29 +8263,29 @@ function aceTraceFileRunStem(artefactRunId, openCodeSessionId) {
   return joined.length <= 240 ? joined : joined.slice(0, 240);
 }
 function acePlaybookPath(contextDir2, agentStem) {
-  return path7.join(aceLearningsRoot(contextDir2), `${agentStem}.json`);
+  return path9.join(aceLearningsRoot(contextDir2), `${agentStem}.json`);
 }
 function aceOverlayPath(contextDir2, agentStem) {
-  return path7.join(aceLearningsRoot(contextDir2), ACE_OVERLAYS_SUBDIR, `${agentStem}.json`);
+  return path9.join(aceLearningsRoot(contextDir2), ACE_OVERLAYS_SUBDIR, `${agentStem}.json`);
 }
 function aceTracePath(contextDir2, agentStem, runId) {
-  return path7.join(aceLearningsRoot(contextDir2), ACE_TRACES_SUBDIR, agentStem, `${runId}-trace.json`);
+  return path9.join(aceLearningsRoot(contextDir2), ACE_TRACES_SUBDIR, agentStem, `${runId}-trace.json`);
 }
 function aceReflectionPath(contextDir2, agentStem, runId) {
-  return path7.join(aceLearningsRoot(contextDir2), ACE_REFLECTIONS_SUBDIR, agentStem, `${runId}-lessons.json`);
+  return path9.join(aceLearningsRoot(contextDir2), ACE_REFLECTIONS_SUBDIR, agentStem, `${runId}-lessons.json`);
 }
 function aceCurationPath(contextDir2, agentStem, runId) {
-  return path7.join(aceLearningsRoot(contextDir2), ACE_CURATIONS_SUBDIR, agentStem, `${runId}-delta.json`);
+  return path9.join(aceLearningsRoot(contextDir2), ACE_CURATIONS_SUBDIR, agentStem, `${runId}-delta.json`);
 }
 function aceConsolidatedSessionsJsonlPath(contextDir2) {
-  return path7.join(aceLearningsRoot(contextDir2), ACE_CONSOLIDATED_SESSIONS_JSONL);
+  return path9.join(aceLearningsRoot(contextDir2), ACE_CONSOLIDATED_SESSIONS_JSONL);
 }
-function opencodeAceSchemaPath(worktreeRoot, basename11) {
-  return path7.join(worktreeRoot, ".opencode", "schemas", "ace", basename11);
+function opencodeAceSchemaPath(worktreeRoot, basename12) {
+  return path9.join(worktreeRoot, ".opencode", "schemas", "ace", basename12);
 }
 
 // src/analysis/aceJsonValidate.ts
-var fs7 = __toESM(require("fs"));
+var fs8 = __toESM(require("fs"));
 var import__ = __toESM(require__());
 function stripUtf8Bom2(s) {
   return s.length > 0 && s.charCodeAt(0) === 65279 ? s.slice(1) : s;
@@ -7983,7 +8303,7 @@ function formatAjvErrors(errors) {
 function validateAceJsonFile(jsonAbsolutePath, schemaAbsolutePath) {
   let raw;
   try {
-    raw = stripUtf8Bom2(fs7.readFileSync(jsonAbsolutePath, "utf-8"));
+    raw = stripUtf8Bom2(fs8.readFileSync(jsonAbsolutePath, "utf-8"));
   } catch (e) {
     return { ok: false, kind: "read", message: e instanceof Error ? e.message : String(e) };
   }
@@ -8071,7 +8391,7 @@ function balancedJsonObjectFrom(s, start) {
 function validateAceJsonValue(data, schemaAbsolutePath) {
   let schemaRaw;
   try {
-    schemaRaw = stripUtf8Bom2(fs7.readFileSync(schemaAbsolutePath, "utf-8"));
+    schemaRaw = stripUtf8Bom2(fs8.readFileSync(schemaAbsolutePath, "utf-8"));
   } catch (e) {
     return { ok: false, kind: "read", message: `Schema read failed: ${e instanceof Error ? e.message : String(e)}` };
   }
@@ -8165,26 +8485,26 @@ function applyAceToMaterializedAgents(worktreeRoot, options) {
   if (!options.enabled) {
     return;
   }
-  const agentsDir = path8.join(worktreeRoot, ".opencode", "agents");
-  if (!fs8.existsSync(agentsDir) || !fs8.statSync(agentsDir).isDirectory()) {
+  const agentsDir = path10.join(worktreeRoot, ".opencode", "agents");
+  if (!fs9.existsSync(agentsDir) || !fs9.statSync(agentsDir).isDirectory()) {
     log(`[ace] skip apply \u2014 missing agents dir: ${agentsDir}`);
     return;
   }
   const contextDir2 = gluecharmContextDir(worktreeRoot);
   const learningsRoot = aceLearningsRoot(contextDir2);
-  fs8.mkdirSync(learningsRoot, { recursive: true });
+  fs9.mkdirSync(learningsRoot, { recursive: true });
   const playbookSchema = opencodeAceSchemaPath(worktreeRoot, ACE_SCHEMA_PLAYBOOK);
   const overlaySchema = opencodeAceSchemaPath(worktreeRoot, ACE_SCHEMA_OVERLAY);
-  const entries = fs8.readdirSync(agentsDir, { withFileTypes: true });
+  const entries = fs9.readdirSync(agentsDir, { withFileTypes: true });
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".md") || e.name === "README.md") {
       continue;
     }
     const stem = e.name.replace(/\.md$/i, "");
-    const agentPath = path8.join(agentsDir, e.name);
+    const agentPath = path10.join(agentsDir, e.name);
     let raw;
     try {
-      raw = fs8.readFileSync(agentPath, "utf-8");
+      raw = fs9.readFileSync(agentPath, "utf-8");
     } catch (err) {
       log(`[ace] skip ${stem} \u2014 read failed: ${err instanceof Error ? err.message : String(err)}`);
       continue;
@@ -8197,7 +8517,7 @@ function applyAceToMaterializedAgents(worktreeRoot, options) {
     const pbPath = acePlaybookPath(contextDir2, stem);
     const ovPath = aceOverlayPath(contextDir2, stem);
     let playbookDoc;
-    if (fs8.existsSync(pbPath)) {
+    if (fs9.existsSync(pbPath)) {
       const v = validateAceJsonFile(pbPath, playbookSchema);
       if (v.ok) {
         const d = v.data;
@@ -8212,7 +8532,7 @@ ${v.errorsText.slice(0, 500)}` : ""}`
       }
     }
     let overlayDoc;
-    if (fs8.existsSync(ovPath)) {
+    if (fs9.existsSync(ovPath)) {
       const v = validateAceJsonFile(ovPath, overlaySchema);
       if (v.ok) {
         overlayDoc = v.data;
@@ -8243,14 +8563,14 @@ ${extra}
 
 ${extra}
 `;
-    fs8.writeFileSync(agentPath, out, "utf-8");
+    fs9.writeFileSync(agentPath, out, "utf-8");
     log(`[ace] merged playbook/overlay into materialized agent: ${e.name}`);
   }
 }
 
 // src/analysis/materializeOpenCodeAgents.ts
 function posixFsPath(absPath) {
-  return path9.resolve(absPath).split(path9.sep).join("/");
+  return path11.resolve(absPath).split(path11.sep).join("/");
 }
 function mergeStringKeyedObject(permission, key, additions) {
   const cur = permission[key];
@@ -8270,10 +8590,22 @@ function ensurePathToolAllows(permission, tool, rules) {
   }
   mergeStringKeyedObject(permission, tool, rules);
 }
-function ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot) {
-  const root = path9.resolve(analysisCheckoutRoot);
+function mergeDeepUnknown(base, over) {
+  const out = { ...base };
+  for (const [k, v] of Object.entries(over)) {
+    const cur = out[k];
+    if (v && typeof v === "object" && !Array.isArray(v) && cur && typeof cur === "object" && !Array.isArray(cur)) {
+      out[k] = mergeDeepUnknown(cur, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot, projectConfigOverlay) {
+  const root = path11.resolve(analysisCheckoutRoot);
   const r = posixFsPath(root);
-  const contextDir2 = posixFsPath(path9.join(root, ".gluecharm", "context"));
+  const contextDir2 = posixFsPath(path11.join(root, ".gluecharm", "context"));
   const externalAllows = {
     [`${r}/**`]: "allow",
     [`${r}/.gluecharm/**`]: "allow",
@@ -8291,11 +8623,11 @@ function ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot) {
     [`${r}/**`]: "allow",
     [`${r}/*`]: "allow"
   };
-  const configPath = path9.join(root, "opencode.json");
+  const configPath = path11.join(root, "opencode.json");
   let cfg = {};
-  if (fs9.existsSync(configPath)) {
+  if (fs10.existsSync(configPath)) {
     try {
-      const raw = fs9.readFileSync(configPath, "utf-8");
+      const raw = fs10.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         cfg = { ...parsed };
@@ -8315,55 +8647,58 @@ function ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot) {
   if (cfg.$schema === void 0) {
     cfg.$schema = "https://opencode.ai/config.json";
   }
-  fs9.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+  if (projectConfigOverlay && Object.keys(projectConfigOverlay).length > 0) {
+    cfg = mergeDeepUnknown(cfg, projectConfigOverlay);
+  }
+  fs10.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `, "utf-8");
 }
 function copyRecursive(src, dest) {
-  fs9.mkdirSync(dest, { recursive: true });
-  const entries = fs9.readdirSync(src, { withFileTypes: true });
+  fs10.mkdirSync(dest, { recursive: true });
+  const entries = fs10.readdirSync(src, { withFileTypes: true });
   for (const e of entries) {
-    const s = path9.join(src, e.name);
-    const d = path9.join(dest, e.name);
+    const s = path11.join(src, e.name);
+    const d = path11.join(dest, e.name);
     if (e.isDirectory()) {
       copyRecursive(s, d);
     } else {
-      fs9.copyFileSync(s, d);
+      fs10.copyFileSync(s, d);
     }
   }
 }
-function materializeOpenCodeAgents(extensionResourcesAgents, analysisCheckoutRoot) {
-  const dest = path9.join(analysisCheckoutRoot, ".opencode", "agents");
-  if (!fs9.existsSync(extensionResourcesAgents)) {
-    fs9.mkdirSync(dest, { recursive: true });
-    fs9.writeFileSync(
-      path9.join(dest, "README.md"),
+function materializeOpenCodeAgents(extensionResourcesAgents, analysisCheckoutRoot, projectConfigOverlay) {
+  const dest = path11.join(analysisCheckoutRoot, ".opencode", "agents");
+  if (!fs10.existsSync(extensionResourcesAgents)) {
+    fs10.mkdirSync(dest, { recursive: true });
+    fs10.writeFileSync(
+      path11.join(dest, "README.md"),
       "# OpenCode agents\n\nPlaceholder: add agent configs here. Bundled folder was missing at materialize time.\n",
       "utf-8"
     );
-    ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot);
+    ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot, projectConfigOverlay);
     return;
   }
   copyRecursive(extensionResourcesAgents, dest);
-  const schemasSrc = path9.join(path9.dirname(extensionResourcesAgents), "schemas", "context-lists");
-  if (fs9.existsSync(schemasSrc)) {
-    const schemasDest = path9.join(analysisCheckoutRoot, ".opencode", "schemas", "context-lists");
+  const schemasSrc = path11.join(path11.dirname(extensionResourcesAgents), "schemas", "context-lists");
+  if (fs10.existsSync(schemasSrc)) {
+    const schemasDest = path11.join(analysisCheckoutRoot, ".opencode", "schemas", "context-lists");
     copyRecursive(schemasSrc, schemasDest);
   }
-  const aceSchemasSrc = path9.join(path9.dirname(extensionResourcesAgents), "schemas", "ace");
-  if (fs9.existsSync(aceSchemasSrc)) {
-    const aceSchemasDest = path9.join(analysisCheckoutRoot, ".opencode", "schemas", "ace");
+  const aceSchemasSrc = path11.join(path11.dirname(extensionResourcesAgents), "schemas", "ace");
+  if (fs10.existsSync(aceSchemasSrc)) {
+    const aceSchemasDest = path11.join(analysisCheckoutRoot, ".opencode", "schemas", "ace");
     copyRecursive(aceSchemasSrc, aceSchemasDest);
   }
-  ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot);
+  ensureAnalysisOpenCodePermissionsConfig(analysisCheckoutRoot, projectConfigOverlay);
 }
 function materializeOpenCodeAgentsWithAce(extensionResourcesAgents, analysisCheckoutRoot, ace) {
-  materializeOpenCodeAgents(extensionResourcesAgents, analysisCheckoutRoot);
+  materializeOpenCodeAgents(extensionResourcesAgents, analysisCheckoutRoot, ace.projectConfigOverlay);
   applyAceToMaterializedAgents(analysisCheckoutRoot, ace);
 }
 
 // src/analysis/openCodeTestAgent.ts
-var fs19 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 
 // src/analysis/promptTemplates.ts
 function fillMarkdownPrompt(p) {
@@ -8514,8 +8849,8 @@ function synthesisStepLabel(step, ctx) {
 }
 
 // src/analysis/aceTracePhase.ts
-var fs14 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 
 // src/opencodeCli.ts
 var import_child_process = require("child_process");
@@ -8648,19 +8983,21 @@ function resolveExecutable(executable) {
   const t = executable?.trim();
   return t && t.length > 0 ? t : "opencode";
 }
-function spawnCliSync(executable, args, cwd, timeoutMs) {
+function spawnCliSync(executable, args, cwd, timeoutMs, env) {
+  const mergedEnv = env ? { ...process.env, ...env } : process.env;
   return (0, import_child_process.spawnSync)(executable, args, {
     encoding: "utf-8",
     cwd,
     shell: USE_SHELL,
     timeout: timeoutMs,
-    env: process.env
+    env: mergedEnv
   });
 }
-function isOpenCodeOnPath(executable = "opencode") {
+function isOpenCodeOnPath(executable = "opencode", probeEnv) {
   const cmd = resolveExecutable(executable);
+  const extra = probeEnv ? { ...probeEnv } : void 0;
   for (const args of [["--version"], ["-h"], ["help"]]) {
-    const r = spawnCliSync(cmd, args, void 0, 12e3);
+    const r = spawnCliSync(cmd, args, void 0, 12e3, extra);
     if (r.status === 0) {
       return true;
     }
@@ -8684,10 +9021,11 @@ function hasProviderEnvConfigured() {
   return false;
 }
 var CREDENTIAL_PROBE_ARG_SETS = [["auth", "status"], ["whoami"], ["auth", "whoami"]];
-function isOpenCodeCredentialsReady(executable = "opencode") {
+function isOpenCodeCredentialsReady(executable = "opencode", options) {
   const cmd = resolveExecutable(executable);
+  const mergedEnv = options?.mergedEnv ? { ...process.env, ...options.mergedEnv } : void 0;
   for (const args of CREDENTIAL_PROBE_ARG_SETS) {
-    const r = spawnCliSync(cmd, args, void 0, 15e3);
+    const r = spawnCliSync(cmd, args, void 0, 15e3, mergedEnv);
     if (r.status === 0) {
       return true;
     }
@@ -8700,18 +9038,31 @@ ${r.stderr ?? ""}`.toLowerCase();
   if (hasProviderEnvConfigured()) {
     return true;
   }
+  if (mergedEnv) {
+    for (const k of PROVIDER_ENV_KEYS) {
+      const v = mergedEnv[k];
+      if (typeof v === "string" && v.trim().length > 0) {
+        return true;
+      }
+    }
+  }
   return false;
 }
 function getOpenCodeReadiness(options) {
   const exe = resolveExecutable(options?.executable);
-  const installed = isOpenCodeOnPath(exe);
+  const probeEnv = options?.providerEnvFromConfig;
+  const mergedProbe = probeEnv && Object.keys(probeEnv).length > 0 ? { ...probeEnv } : void 0;
+  const installed = isOpenCodeOnPath(exe, probeEnv);
   if (!installed) {
     return { installed: false, credentialsReady: false };
   }
   if (options?.skipCredentialsCheck) {
     return { installed: true, credentialsReady: true };
   }
-  return { installed: true, credentialsReady: isOpenCodeCredentialsReady(exe) };
+  return {
+    installed: true,
+    credentialsReady: isOpenCodeCredentialsReady(exe, { mergedEnv: mergedProbe })
+  };
 }
 var DIAG_STDERR_MAX = 16384;
 var DIAG_STDOUT_MAX = 12288;
@@ -8744,15 +9095,16 @@ function runOpenCodeAgent(cwd, args, options) {
   log?.(`[OpenCode] command: ${formatCliCommandForLog(cmd, args)}`);
   log?.(`[OpenCode] cwd: ${JSON.stringify(cwd)}`);
   log?.(`[OpenCode] argv: ${JSON.stringify(args)}`);
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     if (sig?.aborted) {
-      resolve14({ ok: false, message: "Stopped by user.", cancelled: true });
+      resolve15({ ok: false, message: "Stopped by user.", cancelled: true });
       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, {
       cwd,
       shell: USE_SHELL,
-      env: process.env,
+      env: spawnEnv,
       stdio: ["ignore", "pipe", "pipe"]
     });
     options?.onAgentLaunched?.();
@@ -8815,7 +9167,7 @@ ${truncateForDiag(outBody, DIAG_STDOUT_MAX)}`);
       if (diag) {
         finishDiag(diag.label, diag.code, diag.dumpStreams);
       }
-      resolve14(result);
+      resolve15(result);
     };
     let onAbort;
     const clearAbortHandler = () => {
@@ -8890,7 +9242,7 @@ ${truncateForDiag(outBody, DIAG_STDOUT_MAX)}`);
 }
 
 // src/analysis/aceTraceNormalize.ts
-var fs10 = __toESM(require("fs"));
+var fs11 = __toESM(require("fs"));
 var ACE_VERSION = "1.0.0-draft";
 var REASONING_PHASES = /* @__PURE__ */ new Set([
   "explore",
@@ -8900,7 +9252,7 @@ var REASONING_PHASES = /* @__PURE__ */ new Set([
   "repair",
   "finalize"
 ]);
-function isRecord(v) {
+function isRecord2(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
 function sanitizeReasoningSteps(input, legacyTopLevelDecisions) {
@@ -8908,7 +9260,7 @@ function sanitizeReasoningSteps(input, legacyTopLevelDecisions) {
     input = [];
   }
   const steps = input.map((item, idx) => {
-    if (!isRecord(item)) {
+    if (!isRecord2(item)) {
       return { stepId: `auto-${idx}`, phase: "explore", summary: "(invalid reasoningSteps entry)" };
     }
     const stepId = typeof item.stepId === "string" && item.stepId.trim() ? item.stepId : typeof item.step === "string" ? `legacy-${idx}` : `s${idx}`;
@@ -8955,7 +9307,7 @@ function sanitizeDecisions(input) {
     return [];
   }
   return input.map((item, idx) => {
-    if (!isRecord(item)) {
+    if (!isRecord2(item)) {
       return {
         decisionId: `d${idx}`,
         topic: "",
@@ -8979,7 +9331,7 @@ function sanitizeFailures(input) {
     return [];
   }
   return input.map((item, idx) => {
-    if (!isRecord(item)) {
+    if (!isRecord2(item)) {
       return { failureId: `f${idx}`, description: "(invalid failuresAndRetries entry)" };
     }
     const failureId = typeof item.failureId === "string" && item.failureId.trim() ? item.failureId : `f${idx}`;
@@ -8997,7 +9349,7 @@ function sanitizeEvidenceIndex(input) {
   }
   const out = [];
   for (const item of input) {
-    if (!isRecord(item)) {
+    if (!isRecord2(item)) {
       continue;
     }
     const pathStr = typeof item.path === "string" ? item.path : typeof item.filePath === "string" ? item.filePath : "";
@@ -9020,7 +9372,7 @@ function sanitizePlaybookHooks(input) {
   const effects = /* @__PURE__ */ new Set(["applied", "violated", "absent"]);
   const out = [];
   for (const item of input) {
-    if (!isRecord(item)) {
+    if (!isRecord2(item)) {
       continue;
     }
     const ruleRef = typeof item.ruleRef === "string" ? item.ruleRef : "";
@@ -9035,7 +9387,7 @@ function sanitizePlaybookHooks(input) {
 function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical, diagnosticLog) {
   let raw;
   try {
-    raw = fs10.readFileSync(traceAbsolutePath, "utf-8");
+    raw = fs11.readFileSync(traceAbsolutePath, "utf-8");
   } catch (e) {
     diagnosticLog?.(`[ace] trace normalize read failed: ${e instanceof Error ? e.message : String(e)}`);
     return false;
@@ -9047,7 +9399,7 @@ function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical,
     diagnosticLog?.(`[ace] trace normalize JSON.parse failed: ${e instanceof Error ? e.message : String(e)}`);
     return false;
   }
-  const prev = isRecord(parsed) ? parsed : {};
+  const prev = isRecord2(parsed) ? parsed : {};
   const sessionMeta = {
     openCodeSessionId: canonical.openCodeSessionId,
     runId: canonical.runId,
@@ -9055,7 +9407,7 @@ function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical,
     startedAt: canonical.startedAt
   };
   const prevSm = prev.sessionMeta;
-  if (isRecord(prevSm)) {
+  if (isRecord2(prevSm)) {
     if (typeof prevSm.sessionTitle === "string") {
       sessionMeta.sessionTitle = prevSm.sessionTitle;
     }
@@ -9080,7 +9432,7 @@ function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical,
     doc.playbookHooks = hooks;
   }
   try {
-    fs10.writeFileSync(traceAbsolutePath, `${JSON.stringify(doc, null, 2)}
+    fs11.writeFileSync(traceAbsolutePath, `${JSON.stringify(doc, null, 2)}
 `, "utf-8");
   } catch (e) {
     diagnosticLog?.(`[ace] trace normalize write failed: ${e instanceof Error ? e.message : String(e)}`);
@@ -9091,15 +9443,15 @@ function rewriteAceTraceFileWithCanonicalEnvelope(traceAbsolutePath, canonical,
 }
 
 // src/analysis/aceOfflineLearn.ts
-var fs13 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 
 // src/analysis/aceCuratorApplier.ts
-var fs11 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 function writeJson(pathAbs, obj) {
-  fs11.mkdirSync(path10.dirname(pathAbs), { recursive: true });
-  fs11.writeFileSync(pathAbs, `${JSON.stringify(obj, null, 2)}
+  fs12.mkdirSync(path12.dirname(pathAbs), { recursive: true });
+  fs12.writeFileSync(pathAbs, `${JSON.stringify(obj, null, 2)}
 `, "utf-8");
 }
 function emptyPlaybook(agentStem) {
@@ -9125,7 +9477,7 @@ function applyAceCuratorDeltaFile(worktreeRoot, deltaAbsolutePath, log) {
   const pbPath = acePlaybookPath(contextDir2, agentStem);
   const ovPath = aceOverlayPath(contextDir2, agentStem);
   let playbook;
-  if (fs11.existsSync(pbPath)) {
+  if (fs12.existsSync(pbPath)) {
     const pv = validateAceJsonFile(pbPath, playbookSchema);
     if (!pv.ok) {
       return { ok: false, message: `Existing playbook invalid: ${pv.message}` };
@@ -9135,7 +9487,7 @@ function applyAceCuratorDeltaFile(worktreeRoot, deltaAbsolutePath, log) {
     playbook = emptyPlaybook(agentStem);
   }
   let overlay;
-  if (fs11.existsSync(ovPath)) {
+  if (fs12.existsSync(ovPath)) {
     const ov = validateAceJsonFile(ovPath, overlaySchema);
     if (!ov.ok) {
       return { ok: false, message: `Existing overlay invalid: ${ov.message}` };
@@ -9208,13 +9560,13 @@ function applyAceCuratorDeltaFile(worktreeRoot, deltaAbsolutePath, log) {
   }
   writeJson(pbPath, playbook);
   writeJson(ovPath, overlay);
-  log?.(`[ace] curator applier wrote ${path10.relative(contextDir2, pbPath)} and overlay`);
+  log?.(`[ace] curator applier wrote ${path12.relative(contextDir2, pbPath)} and overlay`);
   return { ok: true, message: "Applied curator delta" };
 }
 
 // src/analysis/aceOfflineLearnFallbacks.ts
-var fs12 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var ACE_VERSION2 = "1.0.0-draft";
 function buildEmptyReflectorLessons(traceRelativePath, sessionRunId) {
   return {
@@ -9237,9 +9589,9 @@ function buildEmptyCuratorDelta(agentStem, lessonsRelativePath) {
 }
 function appendAceConsolidatedSessionRecord(contextDir2, record, diagnosticLog) {
   const abs = aceConsolidatedSessionsJsonlPath(contextDir2);
-  const rel = path11.relative(contextDir2, abs).split(path11.sep).join("/");
-  fs12.mkdirSync(aceLearningsRoot(contextDir2), { recursive: true });
-  fs12.appendFileSync(abs, `${JSON.stringify(record)}
+  const rel = path13.relative(contextDir2, abs).split(path13.sep).join("/");
+  fs13.mkdirSync(aceLearningsRoot(contextDir2), { recursive: true });
+  fs13.appendFileSync(abs, `${JSON.stringify(record)}
 `, "utf-8");
   diagnosticLog?.(`[ace] consolidated session record appended \u2014 ${rel}`);
 }
@@ -9261,7 +9613,7 @@ function safeRunIdSegment(runId) {
 }
 function readHead(p, max) {
   try {
-    const raw = fs13.readFileSync(p, "utf-8");
+    const raw = fs14.readFileSync(p, "utf-8");
     return raw.length <= max ? raw : `${raw.slice(0, max)}
 \u2026 (truncated)`;
   } catch {
@@ -9269,14 +9621,14 @@ function readHead(p, max) {
   }
 }
 function listAceTraceFiles(contextDir2) {
-  const root = path12.join(aceLearningsRoot(contextDir2), "traces");
-  if (!fs13.existsSync(root)) {
+  const root = path14.join(aceLearningsRoot(contextDir2), "traces");
+  if (!fs14.existsSync(root)) {
     return [];
   }
   const out = [];
   const walk = (dir) => {
-    for (const e of fs13.readdirSync(dir, { withFileTypes: true })) {
-      const full = path12.join(dir, e.name);
+    for (const e of fs14.readdirSync(dir, { withFileTypes: true })) {
+      const full = path14.join(dir, e.name);
       if (e.isDirectory()) {
         walk(full);
       } else if (e.isFile() && e.name.endsWith(".json")) {
@@ -9297,20 +9649,20 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     return { ok: false, message: `Trace invalid: ${tv.message}` };
   }
   const traceData = tv.data;
-  const runId = opts.artefactRunId ?? (typeof traceData.sessionMeta?.runId === "string" ? traceData.sessionMeta.runId : void 0) ?? path12.basename(traceAbsolutePath).replace(/-trace\.json$/i, "") ?? "unknown";
-  const agentStem = opts.agentStemOverride ?? (typeof traceData.sessionMeta?.agentStem === "string" ? traceData.sessionMeta.agentStem : path12.basename(path12.dirname(traceAbsolutePath)));
+  const runId = opts.artefactRunId ?? (typeof traceData.sessionMeta?.runId === "string" ? traceData.sessionMeta.runId : void 0) ?? path14.basename(traceAbsolutePath).replace(/-trace\.json$/i, "") ?? "unknown";
+  const agentStem = opts.agentStemOverride ?? (typeof traceData.sessionMeta?.agentStem === "string" ? traceData.sessionMeta.agentStem : path14.basename(path14.dirname(traceAbsolutePath)));
   const safeId = safeRunIdSegment(runId);
-  const traceRel = path12.relative(contextDir2, traceAbsolutePath).split(path12.sep).join("/");
+  const traceRel = path14.relative(contextDir2, traceAbsolutePath).split(path14.sep).join("/");
   const lessonsAbs = aceReflectionPath(contextDir2, agentStem, safeId);
   const deltaAbs = aceCurationPath(contextDir2, agentStem, safeId);
-  fs13.mkdirSync(path12.dirname(lessonsAbs), { recursive: true });
-  fs13.mkdirSync(path12.dirname(deltaAbs), { recursive: true });
-  const pbPath = path12.join(aceLearningsRoot(contextDir2), `${agentStem}.json`);
-  const ovPath = path12.join(aceLearningsRoot(contextDir2), "overlays", `${agentStem}.json`);
-  const pbExcerpt = fs13.existsSync(pbPath) ? readHead(pbPath, 6e3) : "(no playbook yet)";
-  const ovExcerpt = fs13.existsSync(ovPath) ? readHead(ovPath, 4e3) : "(no overlay yet)";
-  const runDir = path12.join(opts.worktreeRoot, ".opencode", "_run");
-  fs13.mkdirSync(runDir, { recursive: true });
+  fs14.mkdirSync(path14.dirname(lessonsAbs), { recursive: true });
+  fs14.mkdirSync(path14.dirname(deltaAbs), { recursive: true });
+  const pbPath = path14.join(aceLearningsRoot(contextDir2), `${agentStem}.json`);
+  const ovPath = path14.join(aceLearningsRoot(contextDir2), "overlays", `${agentStem}.json`);
+  const pbExcerpt = fs14.existsSync(pbPath) ? readHead(pbPath, 6e3) : "(no playbook yet)";
+  const ovExcerpt = fs14.existsSync(ovPath) ? readHead(ovPath, 4e3) : "(no overlay yet)";
+  const runDir = path14.join(opts.worktreeRoot, ".opencode", "_run");
+  fs14.mkdirSync(runDir, { recursive: true });
   let reflectorUsedEmptyFallback = false;
   let curatorUsedEmptyFallback = false;
   const reflectPrompt = [
@@ -9328,8 +9680,8 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     "",
     "Schema: `aceSchemaVersion` **1.0.0-draft**, `sourceTrace`, `lessons` (see ace-reflector-lessons schema)."
   ].join("\n");
-  const reflectPromptPath = path12.join(runDir, `ace-reflect-${safeId}-${Date.now()}.prompt.txt`);
-  fs13.writeFileSync(reflectPromptPath, reflectPrompt, "utf-8");
+  const reflectPromptPath = path14.join(runDir, `ace-reflect-${safeId}-${Date.now()}.prompt.txt`);
+  fs14.writeFileSync(reflectPromptPath, reflectPrompt, "utf-8");
   const reflectVars = {
     promptFile: reflectPromptPath,
     agentId: ACE_REFLECTOR_AGENT_STEM,
@@ -9351,7 +9703,8 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     onAgentLaunched: opts.onAgentLaunched,
     signal: opts.abortSignal,
     /** Keep raw stdout in `message` so we can recover lessons JSON if the model prints it instead of writing the file. */
-    parseOpenCodeSessionFromJsonStdout: false
+    parseOpenCodeSessionFromJsonStdout: false,
+    ...opts.openCodeChildEnv ? { childEnv: opts.openCodeChildEnv } : {}
   });
   if (rCli.cancelled || opts.abortSignal?.aborted) {
     return { ok: false, message: "[ace] reflector cancelled" };
@@ -9359,11 +9712,11 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   if (!rCli.ok) {
     return { ok: false, message: `[ace] reflector OpenCode failed: ${rCli.message}` };
   }
-  if (!fs13.existsSync(lessonsAbs)) {
+  if (!fs14.existsSync(lessonsAbs)) {
     const recovered = extractJsonObjectWithTopLevelKeys(rCli.message, ["aceSchemaVersion", "sourceTrace", "lessons"]);
     if (recovered) {
       try {
-        fs13.writeFileSync(lessonsAbs, `${recovered}
+        fs14.writeFileSync(lessonsAbs, `${recovered}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] reflector recovered from OpenCode stdout/stderr \u2192 ${lessonsAbs}`);
       } catch (e) {
@@ -9373,7 +9726,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
       }
     }
   }
-  if (!fs13.existsSync(lessonsAbs)) {
+  if (!fs14.existsSync(lessonsAbs)) {
     return { ok: false, message: `[ace] reflector output missing: ${lessonsAbs}` };
   }
   let lv = validateAceJsonFile(lessonsAbs, reflectorSchema);
@@ -9385,7 +9738,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     ]);
     if (recoveredAgain) {
       try {
-        fs13.writeFileSync(lessonsAbs, `${recoveredAgain}
+        fs14.writeFileSync(lessonsAbs, `${recoveredAgain}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] reflector re-recovered from CLI output after schema failure \u2192 ${lessonsAbs}`);
         lv = validateAceJsonFile(lessonsAbs, reflectorSchema);
@@ -9399,7 +9752,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}`);
-    fs13.writeFileSync(
+    fs14.writeFileSync(
       lessonsAbs,
       `${JSON.stringify(buildEmptyReflectorLessons(traceRel, runId), null, 2)}
 `,
@@ -9411,7 +9764,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   if (!lv.ok) {
     return { ok: false, message: `[ace] lessons invalid after empty fallback: ${lv.message}` };
   }
-  const lessonsRel = path12.relative(contextDir2, lessonsAbs).split(path12.sep).join("/");
+  const lessonsRel = path14.relative(contextDir2, lessonsAbs).split(path14.sep).join("/");
   const curPrompt = [
     "# ACE Curator (offline)",
     "",
@@ -9445,8 +9798,8 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     "",
     "Schema: `aceSchemaVersion` **1.0.0-draft**, `agentStem`, `sourceLessons`, `operations` (see ace-curator-delta schema)."
   ].join("\n");
-  const curPromptPath = path12.join(runDir, `ace-curate-${safeId}-${Date.now()}.prompt.txt`);
-  fs13.writeFileSync(curPromptPath, curPrompt, "utf-8");
+  const curPromptPath = path14.join(runDir, `ace-curate-${safeId}-${Date.now()}.prompt.txt`);
+  fs14.writeFileSync(curPromptPath, curPrompt, "utf-8");
   const curVars = {
     promptFile: curPromptPath,
     agentId: ACE_CURATOR_AGENT_STEM,
@@ -9467,7 +9820,8 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     diagnosticLog: opts.diagnosticLog,
     onAgentLaunched: opts.onAgentLaunched,
     signal: opts.abortSignal,
-    parseOpenCodeSessionFromJsonStdout: false
+    parseOpenCodeSessionFromJsonStdout: false,
+    ...opts.openCodeChildEnv ? { childEnv: opts.openCodeChildEnv } : {}
   });
   if (cCli.cancelled || opts.abortSignal?.aborted) {
     return { ok: false, message: "[ace] curator cancelled" };
@@ -9475,7 +9829,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   if (!cCli.ok) {
     return { ok: false, message: `[ace] curator OpenCode failed: ${cCli.message}` };
   }
-  if (!fs13.existsSync(deltaAbs)) {
+  if (!fs14.existsSync(deltaAbs)) {
     const recovered = extractJsonObjectWithTopLevelKeys(cCli.message, [
       "aceSchemaVersion",
       "agentStem",
@@ -9484,7 +9838,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     ]);
     if (recovered) {
       try {
-        fs13.writeFileSync(deltaAbs, `${recovered}
+        fs14.writeFileSync(deltaAbs, `${recovered}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] curator recovered from OpenCode stdout/stderr \u2192 ${deltaAbs}`);
       } catch (e) {
@@ -9494,7 +9848,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
       }
     }
   }
-  if (!fs13.existsSync(deltaAbs)) {
+  if (!fs14.existsSync(deltaAbs)) {
     return { ok: false, message: `[ace] curator output missing: ${deltaAbs}` };
   }
   let dv = validateAceJsonFile(deltaAbs, curatorSchema);
@@ -9507,7 +9861,7 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
     ]);
     if (recoveredCur) {
       try {
-        fs13.writeFileSync(deltaAbs, `${recoveredCur}
+        fs14.writeFileSync(deltaAbs, `${recoveredCur}
 `, "utf-8");
         opts.diagnosticLog?.(`[ace] curator re-recovered from CLI output after schema failure \u2192 ${deltaAbs}`);
         dv = validateAceJsonFile(deltaAbs, curatorSchema);
@@ -9521,7 +9875,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}`);
-    fs13.writeFileSync(
+    fs14.writeFileSync(
       deltaAbs,
       `${JSON.stringify(buildEmptyCuratorDelta(agentStem, lessonsRel), null, 2)}
 `,
@@ -9540,13 +9894,13 @@ async function runAceOfflineLearnFromTrace(traceAbsolutePath, opts) {
   let lessonCount = 0;
   let curatorOperationCount = 0;
   try {
-    const lessonsDoc = JSON.parse(fs13.readFileSync(lessonsAbs, "utf-8"));
+    const lessonsDoc = JSON.parse(fs14.readFileSync(lessonsAbs, "utf-8"));
     lessonCount = Array.isArray(lessonsDoc.lessons) ? lessonsDoc.lessons.length : 0;
-    const deltaDoc = JSON.parse(fs13.readFileSync(deltaAbs, "utf-8"));
+    const deltaDoc = JSON.parse(fs14.readFileSync(deltaAbs, "utf-8"));
     curatorOperationCount = Array.isArray(deltaDoc.operations) ? deltaDoc.operations.length : 0;
   } catch {
   }
-  const deltaRel = path12.relative(contextDir2, deltaAbs).split(path12.sep).join("/");
+  const deltaRel = path14.relative(contextDir2, deltaAbs).split(path14.sep).join("/");
   appendAceConsolidatedSessionRecord(
     contextDir2,
     {
@@ -9601,15 +9955,15 @@ async function runAceTracePhase(params) {
   const contextDir2 = gluecharmContextDir(params.worktreeRoot);
   const traceStem = aceTraceFileRunStem(params.artefactRunId, params.followUpSessionId);
   const traceAbs = aceTracePath(contextDir2, params.producerAgentStem, traceStem);
-  fs14.mkdirSync(path13.dirname(traceAbs), { recursive: true });
+  fs15.mkdirSync(path15.dirname(traceAbs), { recursive: true });
   const schemaAbs = opencodeAceSchemaPath(params.worktreeRoot, ACE_SCHEMA_TRACE);
-  if (!fs14.existsSync(schemaAbs)) {
+  if (!fs15.existsSync(schemaAbs)) {
     const msg = `[ace] trace skipped \u2014 schema missing: ${schemaAbs}`;
     params.diagnosticLog?.(msg);
     return { ok: false, message: msg };
   }
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const primaryAbs = path13.join(contextDir2, params.primaryRelativePathUnderContext.split("/").join(path13.sep));
+  const primaryAbs = path15.join(contextDir2, params.primaryRelativePathUnderContext.split("/").join(path15.sep));
   const promptBody = [
     `# ACE trace (same session)`,
     ``,
@@ -9651,10 +10005,10 @@ async function runAceTracePhase(params) {
     `sessionMeta must include \`openCodeSessionId\` = the session id above, \`runId\` = **exactly** \`${traceStem}\`, \`agentStem\` = producer stem, \`startedAt\` = \`${startedAt}\`.`,
     `Use only evidence from this session's transcript and tool history.`
   ].join("\n");
-  const runDir = path13.join(params.worktreeRoot, ".opencode", "_run");
-  fs14.mkdirSync(runDir, { recursive: true });
-  const promptPath = path13.join(runDir, `ace-trace-${traceStem}-${Date.now()}.prompt.txt`);
-  fs14.writeFileSync(promptPath, promptBody, "utf-8");
+  const runDir = path15.join(params.worktreeRoot, ".opencode", "_run");
+  fs15.mkdirSync(runDir, { recursive: true });
+  const promptPath = path15.join(runDir, `ace-trace-${traceStem}-${Date.now()}.prompt.txt`);
+  fs15.writeFileSync(promptPath, promptBody, "utf-8");
   const vars = {
     promptFile: promptPath,
     agentId: ACE_TRACE_RECORDER_AGENT_STEM,
@@ -9677,7 +10031,7 @@ async function runAceTracePhase(params) {
   if (!cli.ok) {
     return { ok: false, message: `[ace] trace OpenCode failed: ${cli.message}` };
   }
-  if (!fs14.existsSync(traceAbs)) {
+  if (!fs15.existsSync(traceAbs)) {
     const recovered = extractJsonObjectWithTopLevelKeys(cli.message, [
       "aceSchemaVersion",
       "sessionMeta",
@@ -9685,7 +10039,7 @@ async function runAceTracePhase(params) {
     ]);
     if (recovered) {
       try {
-        fs14.writeFileSync(traceAbs, `${recovered}
+        fs15.writeFileSync(traceAbs, `${recovered}
 `, "utf-8");
         params.diagnosticLog?.(`[ace] trace recovered from OpenCode stdout/stderr \u2192 ${traceAbs}`);
       } catch (e) {
@@ -9695,7 +10049,7 @@ async function runAceTracePhase(params) {
       }
     }
   }
-  if (!fs14.existsSync(traceAbs)) {
+  if (!fs15.existsSync(traceAbs)) {
     const msg = `[ace] trace file missing after run: ${traceAbs}`;
     params.diagnosticLog?.(msg);
     return { ok: false, message: msg };
@@ -9727,7 +10081,7 @@ async function runAceTracePhase(params) {
     return { ok: false, message: msg };
   }
   try {
-    const rawAlign = fs14.readFileSync(traceAbs, "utf-8");
+    const rawAlign = fs15.readFileSync(traceAbs, "utf-8");
     const docAlign = JSON.parse(rawAlign);
     const smRun = docAlign.sessionMeta?.runId;
     if (typeof smRun !== "string" || smRun !== traceStem) {
@@ -9776,14 +10130,14 @@ async function runAceTracePhase(params) {
     }
   } else {
     params.diagnosticLog?.(
-      '[ace] Reflector/Curator not run automatically. Set easyspecs.analysis.ace.offlineLearnAfterSameSessionTrace=true (or the same key in .easyspecs/settings.json), or Command Palette: "EasySpecs: ACE \u2014 Learn from traces".'
+      '[ace] Reflector/Curator not run automatically. Set easyspecs.analysis.ace.offlineLearnAfterSameSessionTrace in .easyspecs/config.json (or legacy .easyspecs/settings.json), or Command Palette: "EasySpecs: ACE \u2014 Learn from traces".'
     );
   }
   return { ok: true, message: "ACE trace OK", traceAbsolutePath: traceAbs };
 }
 
 // src/analysis/coordinationListJsonValidate.ts
-var fs15 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 var import__2 = __toESM(require__());
 function stripUtf8Bom3(s) {
   return s.length > 0 && s.charCodeAt(0) === 65279 ? s.slice(1) : s;
@@ -9847,7 +10201,7 @@ function formatAjvErrors2(errors) {
 function validateCoordinationListJson(jsonAbsolutePath, schemaAbsolutePath) {
   let raw;
   try {
-    raw = stripUtf8Bom3(fs15.readFileSync(jsonAbsolutePath, "utf-8"));
+    raw = stripUtf8Bom3(fs16.readFileSync(jsonAbsolutePath, "utf-8"));
   } catch (e) {
     return {
       ok: false,
@@ -9863,7 +10217,7 @@ function validateCoordinationListJson(jsonAbsolutePath, schemaAbsolutePath) {
   }
   let schemaRaw;
   try {
-    schemaRaw = stripUtf8Bom3(fs15.readFileSync(schemaAbsolutePath, "utf-8"));
+    schemaRaw = stripUtf8Bom3(fs16.readFileSync(schemaAbsolutePath, "utf-8"));
   } catch (e) {
     return {
       ok: false,
@@ -9924,7 +10278,7 @@ function validateCoordinationListJson(jsonAbsolutePath, schemaAbsolutePath) {
 var FILE_PREVIEW_MAX = 4e3;
 function readCoordinationJsonPreview(jsonAbsolutePath) {
   try {
-    const raw = stripUtf8Bom3(fs15.readFileSync(jsonAbsolutePath, "utf-8"));
+    const raw = stripUtf8Bom3(fs16.readFileSync(jsonAbsolutePath, "utf-8"));
     return raw.length <= FILE_PREVIEW_MAX ? raw : `${raw.slice(0, FILE_PREVIEW_MAX)}
 
 \u2026 (truncated)`;
@@ -10000,7 +10354,7 @@ function formatCoordinationJsonRepairAppendix(outputBasename, failure, rawFilePr
 }
 
 // src/analysis/markdownEvidenceIndexValidate.ts
-var fs16 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var EVIDENCE_HEADING = "## Evidence index";
 function evidenceIndexMentionsReadmeMd(body) {
   const re = /README\.md/gi;
@@ -10128,7 +10482,7 @@ function markdownEvidenceValidationPasses(content) {
 function validateMarkdownEvidenceIndexFile(absolutePath) {
   let text;
   try {
-    const buf = fs16.readFileSync(absolutePath);
+    const buf = fs17.readFileSync(absolutePath);
     const decoder = new TextDecoder("utf-8", { fatal: true });
     text = decoder.decode(buf);
   } catch (e) {
@@ -10169,11 +10523,11 @@ function formatMarkdownEvidenceRepairAppendix(outputFileAbsolute, kind = "empty"
 }
 
 // src/analysis/openQuestionResolution.ts
-var fs17 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var OPEN_QUESTION_RESOLUTION_JSON_BASENAME = "open-question-resolution.json";
 function openQuestionResolutionJsonAbsolute(worktreeRoot) {
-  return path14.join(worktreeRoot, ".opencode", "_run", OPEN_QUESTION_RESOLUTION_JSON_BASENAME);
+  return path16.join(worktreeRoot, ".opencode", "_run", OPEN_QUESTION_RESOLUTION_JSON_BASENAME);
 }
 function asTrimmedString(v) {
   if (typeof v !== "string") {
@@ -10208,10 +10562,10 @@ function parseOpenQuestionResolutionJsonText(raw) {
 function readOpenQuestionResolutionFile(worktreeRoot) {
   const p = openQuestionResolutionJsonAbsolute(worktreeRoot);
   try {
-    if (!fs17.existsSync(p)) {
+    if (!fs18.existsSync(p)) {
       return { ok: false, error: `Missing resolution file: ${p}` };
     }
-    const raw = fs17.readFileSync(p, "utf-8");
+    const raw = fs18.readFileSync(p, "utf-8");
     return parseOpenQuestionResolutionJsonText(raw);
   } catch (e) {
     const m = e instanceof Error ? e.message : String(e);
@@ -10221,16 +10575,16 @@ function readOpenQuestionResolutionFile(worktreeRoot) {
 function deleteOpenQuestionResolutionFile(worktreeRoot) {
   try {
     const p = openQuestionResolutionJsonAbsolute(worktreeRoot);
-    if (fs17.existsSync(p)) {
-      fs17.unlinkSync(p);
+    if (fs18.existsSync(p)) {
+      fs18.unlinkSync(p);
     }
   } catch {
   }
 }
 
 // src/analysis/openQuestionsSectionValidate.ts
-var fs18 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 var CANONICAL_NORMALIZED = "open questions";
 function normalizeOpenQuestionsHeadingTitle(raw) {
   const t = raw.trim().replace(/\s+/gu, " ");
@@ -10347,9 +10701,9 @@ function parseOpenQuestionsSection(content) {
   return { kind: "hasResidualQuestions", questions, startLine1Based };
 }
 function isContextMarkdownPathForOpenQuestions(worktreeRoot, absolutePath) {
-  const ctx = path15.join(path15.resolve(worktreeRoot), ".gluecharm", "context");
-  const abs = path15.resolve(absolutePath);
-  const ctxNorm = ctx + path15.sep;
+  const ctx = path17.join(path17.resolve(worktreeRoot), ".gluecharm", "context");
+  const abs = path17.resolve(absolutePath);
+  const ctxNorm = ctx + path17.sep;
   return abs === ctx || abs.startsWith(ctxNorm);
 }
 function validateOpenQuestionsSectionFile(absolutePath, scope) {
@@ -10362,7 +10716,7 @@ function validateOpenQuestionsSectionFile(absolutePath, scope) {
   }
   let text;
   try {
-    const buf = fs18.readFileSync(absolutePath);
+    const buf = fs19.readFileSync(absolutePath);
     const decoder = new TextDecoder("utf-8", { fatal: true });
     text = decoder.decode(buf);
   } catch (e) {
@@ -10398,10 +10752,10 @@ function formatOpenQuestionsProducerRepairAppendix(outputFileAbsolute, stepLabel
 // src/analysis/openCodeTestAgent.ts
 var CITATION_EXAMPLE = "`src/example.ts:42` or `src/example.ts:10-25`";
 function contextDir(worktreeRoot) {
-  return path16.join(worktreeRoot, ".gluecharm", "context");
+  return path18.join(worktreeRoot, ".gluecharm", "context");
 }
 function schemaRef(worktreeRoot, schemaBasename) {
-  return path16.join(worktreeRoot, ".opencode", "schemas", "context-lists", schemaBasename);
+  return path18.join(worktreeRoot, ".opencode", "schemas", "context-lists", schemaBasename);
 }
 function expandArgvTemplate3(template, vars) {
   return template.map((part) => {
@@ -10829,7 +11183,7 @@ function clampMarkdownOpenQuestionIterations(raw) {
 }
 function getExpectedOutputArtefactStatus(absolutePath) {
   try {
-    const st = fs19.statSync(absolutePath);
+    const st = fs20.statSync(absolutePath);
     if (!st.isFile()) {
       return { generated: false, reason: "not_a_file" };
     }
@@ -10845,46 +11199,46 @@ function outputPaths(step, worktreeRoot, listTarget) {
   const ctx = contextDir(worktreeRoot);
   switch (step) {
     case "docsProject":
-      return { absolute: path16.join(contextDir(worktreeRoot), "project.md"), basename: "project.md" };
+      return { absolute: path18.join(contextDir(worktreeRoot), "project.md"), basename: "project.md" };
     case "architecture":
-      return { absolute: path16.join(ctx, "architecture.md"), basename: "architecture.md" };
+      return { absolute: path18.join(ctx, "architecture.md"), basename: "architecture.md" };
     case "listFeatures":
-      return { absolute: path16.join(ctx, "features-list.json"), basename: "features-list.json" };
+      return { absolute: path18.join(ctx, "features-list.json"), basename: "features-list.json" };
     case "reviewFeaturesList":
-      return { absolute: path16.join(ctx, "features-list.json"), basename: "features-list.json" };
+      return { absolute: path18.join(ctx, "features-list.json"), basename: "features-list.json" };
     case "listRepoSurface":
-      return { absolute: path16.join(ctx, "repo-surface-scan.json"), basename: "repo-surface-scan.json" };
+      return { absolute: path18.join(ctx, "repo-surface-scan.json"), basename: "repo-surface-scan.json" };
     case "listExperiences":
-      return { absolute: path16.join(ctx, "experiences-list.json"), basename: "experiences-list.json" };
+      return { absolute: path18.join(ctx, "experiences-list.json"), basename: "experiences-list.json" };
     case "reviewExperiencesList":
-      return { absolute: path16.join(ctx, "experiences-list.json"), basename: "experiences-list.json" };
+      return { absolute: path18.join(ctx, "experiences-list.json"), basename: "experiences-list.json" };
     case "listServices":
-      return { absolute: path16.join(ctx, "services-list.json"), basename: "services-list.json" };
+      return { absolute: path18.join(ctx, "services-list.json"), basename: "services-list.json" };
     case "reviewServicesList":
-      return { absolute: path16.join(ctx, "services-list.json"), basename: "services-list.json" };
+      return { absolute: path18.join(ctx, "services-list.json"), basename: "services-list.json" };
     case "listDataModel":
-      return { absolute: path16.join(ctx, "data-model-list.json"), basename: "data-model-list.json" };
+      return { absolute: path18.join(ctx, "data-model-list.json"), basename: "data-model-list.json" };
     case "reviewDataModelList":
-      return { absolute: path16.join(ctx, "data-model-list.json"), basename: "data-model-list.json" };
+      return { absolute: path18.join(ctx, "data-model-list.json"), basename: "data-model-list.json" };
     case "listTechStack":
-      return { absolute: path16.join(ctx, "tech-stack-list.json"), basename: "tech-stack-list.json" };
+      return { absolute: path18.join(ctx, "tech-stack-list.json"), basename: "tech-stack-list.json" };
     case "reviewTechStackList":
-      return { absolute: path16.join(ctx, "tech-stack-list.json"), basename: "tech-stack-list.json" };
+      return { absolute: path18.join(ctx, "tech-stack-list.json"), basename: "tech-stack-list.json" };
     case "listUseCases": {
       const fe = listTarget?.featureCode;
       if (!fe) {
         throw new Error("listUseCases requires listTarget.featureCode");
       }
-      const basename11 = `${fe}-use-cases-list.json`;
-      return { absolute: path16.join(ctx, basename11), basename: basename11 };
+      const basename12 = `${fe}-use-cases-list.json`;
+      return { absolute: path18.join(ctx, basename12), basename: basename12 };
     }
     case "reviewUseCasesList": {
       const fe = listTarget?.featureCode;
       if (!fe) {
         throw new Error("reviewUseCasesList requires listTarget.featureCode");
       }
-      const basename11 = `${fe}-use-cases-list.json`;
-      return { absolute: path16.join(ctx, basename11), basename: basename11 };
+      const basename12 = `${fe}-use-cases-list.json`;
+      return { absolute: path18.join(ctx, basename12), basename: basename12 };
     }
     case "listScenarios": {
       const fe = listTarget?.featureCode;
@@ -10892,8 +11246,8 @@ function outputPaths(step, worktreeRoot, listTarget) {
       if (!fe || !uc) {
         throw new Error("listScenarios requires listTarget.featureCode and useCaseCode");
       }
-      const basename11 = `${fe}_${uc}-scenarios-list.json`;
-      return { absolute: path16.join(ctx, basename11), basename: basename11 };
+      const basename12 = `${fe}_${uc}-scenarios-list.json`;
+      return { absolute: path18.join(ctx, basename12), basename: basename12 };
     }
     case "reviewScenariosList": {
       const fe = listTarget?.featureCode;
@@ -10901,24 +11255,24 @@ function outputPaths(step, worktreeRoot, listTarget) {
       if (!fe || !uc) {
         throw new Error("reviewScenariosList requires listTarget.featureCode and useCaseCode");
       }
-      const basename11 = `${fe}_${uc}-scenarios-list.json`;
-      return { absolute: path16.join(ctx, basename11), basename: basename11 };
+      const basename12 = `${fe}_${uc}-scenarios-list.json`;
+      return { absolute: path18.join(ctx, basename12), basename: basename12 };
     }
     case "listEntityFields": {
       const dm = listTarget?.entityCode;
       if (!dm) {
         throw new Error("listEntityFields requires listTarget.entityCode");
       }
-      const basename11 = `${dm}-fields-list.json`;
-      return { absolute: path16.join(ctx, basename11), basename: basename11 };
+      const basename12 = `${dm}-fields-list.json`;
+      return { absolute: path18.join(ctx, basename12), basename: basename12 };
     }
     case "reviewEntityFieldsList": {
       const dm = listTarget?.entityCode;
       if (!dm) {
         throw new Error("reviewEntityFieldsList requires listTarget.entityCode");
       }
-      const basename11 = `${dm}-fields-list.json`;
-      return { absolute: path16.join(ctx, basename11), basename: basename11 };
+      const basename12 = `${dm}-fields-list.json`;
+      return { absolute: path18.join(ctx, basename12), basename: basename12 };
     }
     default: {
       const _u = step;
@@ -10927,8 +11281,8 @@ function outputPaths(step, worktreeRoot, listTarget) {
   }
 }
 async function runOpenCodeResolveOpenQuestionStep(opts) {
-  const runDir = path16.join(opts.worktreeRoot, ".opencode", "_run");
-  fs19.mkdirSync(runDir, { recursive: true });
+  const runDir = path18.join(opts.worktreeRoot, ".opencode", "_run");
+  fs20.mkdirSync(runDir, { recursive: true });
   const resolutionJsonAbsolute = openQuestionResolutionJsonAbsolute(opts.worktreeRoot);
   const body = fillResolveOpenQuestionPrompt({
     worktreeRoot: opts.worktreeRoot,
@@ -10937,8 +11291,8 @@ async function runOpenCodeResolveOpenQuestionStep(opts) {
     questionText: opts.questionText,
     resolutionJsonAbsolute
   });
-  const promptPath = path16.join(runDir, `resolve-open-question-${Date.now()}.prompt.txt`);
-  fs19.writeFileSync(promptPath, body, "utf-8");
+  const promptPath = path18.join(runDir, `resolve-open-question-${Date.now()}.prompt.txt`);
+  fs20.writeFileSync(promptPath, body, "utf-8");
   const vars = {
     promptFile: promptPath,
     agentId: RESOLVE_OPEN_QUESTION_AGENT_STEM,
@@ -10965,7 +11319,8 @@ async function runOpenCodeResolveOpenQuestionStep(opts) {
     diagnosticLog: opts.diagnosticLog,
     onAgentLaunched: opts.onAgentLaunched,
     signal: opts.abortSignal,
-    parseOpenCodeSessionFromJsonStdout: opts.followUpOpenCodeSessionId === void 0
+    parseOpenCodeSessionFromJsonStdout: opts.followUpOpenCodeSessionId === void 0,
+    childEnv: opts.openCodeChildEnv
   });
   opts.onRemediationPhase?.("validating");
   if (cli.cancelled || opts.abortSignal?.aborted) {
@@ -11000,8 +11355,8 @@ ${cli.message}`,
 }
 async function runSynthesisMarkdownRemediationChain(common, step, workspaceLabel, initialMarkdownAppendix) {
   const totalMarkdownRuns = 1 + common.maxMarkdownEvidenceRepairs;
-  const runDir = path16.join(common.worktreeRoot, ".opencode", "_run");
-  fs19.mkdirSync(runDir, { recursive: true });
+  const runDir = path18.join(common.worktreeRoot, ".opencode", "_run");
+  fs20.mkdirSync(runDir, { recursive: true });
   let markdownEvidenceRepairAppendix = initialMarkdownAppendix;
   let lastPromptPath = "";
   let lastCliMessage = "";
@@ -11019,9 +11374,9 @@ async function runSynthesisMarkdownRemediationChain(common, step, workspaceLabel
       void 0,
       markdownEvidenceRepairAppendix
     );
-    const promptPath = path16.join(runDir, `${step}-oqrem-a${attempt}-${Date.now()}.prompt.txt`);
+    const promptPath = path18.join(runDir, `${step}-oqrem-a${attempt}-${Date.now()}.prompt.txt`);
     lastPromptPath = promptPath;
-    fs19.writeFileSync(promptPath, body, "utf-8");
+    fs20.writeFileSync(promptPath, body, "utf-8");
     const vars = {
       promptFile: promptPath,
       agentId: STEP_OPEN_CODE_AGENT_IDS[step],
@@ -11043,7 +11398,8 @@ async function runSynthesisMarkdownRemediationChain(common, step, workspaceLabel
       diagnosticLog: common.diagnosticLog,
       onAgentLaunched: common.onAgentLaunched,
       signal: common.abortSignal,
-      parseOpenCodeSessionFromJsonStdout: common.producerOpenCodeSessionId === void 0
+      parseOpenCodeSessionFromJsonStdout: common.producerOpenCodeSessionId === void 0,
+      childEnv: common.openCodeChildEnv
     });
     common.onRemediationPhase?.("validating");
     lastCliMessage = cli.message;
@@ -11119,8 +11475,8 @@ ${common.outputFileAbsolute}`,
 }
 async function runDetailMarkdownRemediationChain(common, target, initialMarkdownAppendix) {
   const totalMarkdownRuns = 1 + common.maxMarkdownEvidenceRepairs;
-  const runDir = path16.join(common.worktreeRoot, ".opencode", "_run");
-  fs19.mkdirSync(runDir, { recursive: true });
+  const runDir = path18.join(common.worktreeRoot, ".opencode", "_run");
+  fs20.mkdirSync(runDir, { recursive: true });
   const safeStem = target.outputBasename.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 120);
   let markdownEvidenceRepairAppendix = initialMarkdownAppendix;
   let lastPromptPath = "";
@@ -11139,12 +11495,12 @@ async function runDetailMarkdownRemediationChain(common, target, initialMarkdown
       citationFormatExample: CITATION_EXAMPLE,
       repairAppendix: markdownEvidenceRepairAppendix
     });
-    const promptPath = path16.join(
+    const promptPath = path18.join(
       runDir,
       `markdownDetail-${target.openCodeAgentStem}-${safeStem}-oqrem-a${attempt}-${Date.now()}.prompt.txt`
     );
     lastPromptPath = promptPath;
-    fs19.writeFileSync(promptPath, body, "utf-8");
+    fs20.writeFileSync(promptPath, body, "utf-8");
     const vars = {
       promptFile: promptPath,
       agentId: target.openCodeAgentStem,
@@ -11166,7 +11522,8 @@ async function runDetailMarkdownRemediationChain(common, target, initialMarkdown
       diagnosticLog: common.diagnosticLog,
       onAgentLaunched: common.onAgentLaunched,
       signal: common.abortSignal,
-      parseOpenCodeSessionFromJsonStdout: common.producerOpenCodeSessionId === void 0
+      parseOpenCodeSessionFromJsonStdout: common.producerOpenCodeSessionId === void 0,
+      childEnv: common.openCodeChildEnv
     });
     common.onRemediationPhase?.("validating");
     lastCliMessage = cli.message;
@@ -11240,7 +11597,7 @@ ${common.outputFileAbsolute}`,
     promptPath: lastPromptPath
   };
 }
-async function remediateOpenQuestionsForContextMarkdown(mode, producerStepLabel, outputFileAbsolute, outputBasename, worktreeRoot, markdownOpenQuestionIterations, markdownEvidenceRepairAttempts, executable, argvTemplate, timeoutMs, diagnosticLog, abortSignal, onRemediationPhase, onAgentLaunched, stewardship) {
+async function remediateOpenQuestionsForContextMarkdown(mode, producerStepLabel, outputFileAbsolute, outputBasename, worktreeRoot, markdownOpenQuestionIterations, markdownEvidenceRepairAttempts, executable, argvTemplate, timeoutMs, diagnosticLog, abortSignal, onRemediationPhase, onAgentLaunched, stewardship, openCodeChildEnv) {
   const maxOq = clampMarkdownOpenQuestionIterations(markdownOpenQuestionIterations);
   let maxMdEv = markdownEvidenceRepairAttempts === void 0 ? 2 : Math.floor(Number(markdownEvidenceRepairAttempts));
   if (!Number.isFinite(maxMdEv)) {
@@ -11264,7 +11621,8 @@ async function remediateOpenQuestionsForContextMarkdown(mode, producerStepLabel,
     artefactRunId: runId,
     artefactWorkItemId: workItemId,
     stewardshipStepLabel: `${producerStepLabel}|open-questions-chain`,
-    producerOpenCodeSessionId: stewardship?.producerOpenCodeSessionId
+    producerOpenCodeSessionId: stewardship?.producerOpenCodeSessionId,
+    openCodeChildEnv
   };
   const first = validateOpenQuestionsSectionFile(outputFileAbsolute, { worktreeRoot });
   if (!first.ok) {
@@ -11320,7 +11678,8 @@ async function remediateOpenQuestionsForContextMarkdown(mode, producerStepLabel,
       followUpOpenCodeSessionId: stewardship?.producerOpenCodeSessionId,
       artefactRunId: runId,
       artefactWorkItemId: workItemId,
-      stewardshipStepLabel: `${producerStepLabel}|resolve-oq`
+      stewardshipStepLabel: `${producerStepLabel}|resolve-oq`,
+      openCodeChildEnv
     });
     if (resolveRes.cancelled || abortSignal?.aborted) {
       return { ok: false, cancelled: true, message: resolveRes.message };
@@ -11463,7 +11822,7 @@ async function runOpenCodeTestAgentStep(opts) {
   let schemaAbsoluteForList;
   if (effectiveListSchemaFile) {
     schemaAbsoluteForList = schemaRef(opts.worktreeRoot, effectiveListSchemaFile);
-    if (!fs19.existsSync(schemaAbsoluteForList)) {
+    if (!fs20.existsSync(schemaAbsoluteForList)) {
       return {
         ok: false,
         message: `JSON Schema not found: ${schemaAbsoluteForList}
@@ -11476,11 +11835,11 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
   }
   if (opts.step === "reviewExperiencesList" && effectiveListSchemaFile) {
     const schemaAbs = schemaRef(opts.worktreeRoot, effectiveListSchemaFile);
-    if (fs19.existsSync(outputFileAbsolute)) {
+    if (fs20.existsSync(outputFileAbsolute)) {
       const v = validateCoordinationListJson(outputFileAbsolute, schemaAbs);
       if (v.ok) {
         try {
-          const raw = fs19.readFileSync(outputFileAbsolute, "utf-8");
+          const raw = fs20.readFileSync(outputFileAbsolute, "utf-8");
           const data = JSON.parse(raw);
           if (Array.isArray(data.views) && data.views.length === 0) {
             return {
@@ -11496,9 +11855,9 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
       }
     }
   }
-  fs19.mkdirSync(path16.dirname(outputFileAbsolute), { recursive: true });
-  const runDir = path16.join(opts.worktreeRoot, ".opencode", "_run");
-  fs19.mkdirSync(runDir, { recursive: true });
+  fs20.mkdirSync(path18.dirname(outputFileAbsolute), { recursive: true });
+  const runDir = path18.join(opts.worktreeRoot, ".opencode", "_run");
+  fs20.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));
@@ -11549,9 +11908,9 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
       effectiveListSchemaFile ? repairAppendix : void 0,
       effectiveListSchemaFile ? void 0 : markdownEvidenceRepairAppendix
     );
-    const promptPath = path16.join(runDir, `${opts.step}${scopeSuffix}-a${attempt}-${Date.now()}.prompt.txt`);
+    const promptPath = path18.join(runDir, `${opts.step}${scopeSuffix}-a${attempt}-${Date.now()}.prompt.txt`);
     lastPromptPath = promptPath;
-    fs19.writeFileSync(promptPath, body, "utf-8");
+    fs20.writeFileSync(promptPath, body, "utf-8");
     const vars = {
       promptFile: promptPath,
       agentId: STEP_OPEN_CODE_AGENT_IDS[opts.step],
@@ -11576,7 +11935,8 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
       diagnosticLog: opts.diagnosticLog,
       onAgentLaunched: opts.onAgentLaunched,
       signal: opts.abortSignal,
-      parseOpenCodeSessionFromJsonStdout: !isFollowUpSpawn
+      parseOpenCodeSessionFromJsonStdout: !isFollowUpSpawn,
+      childEnv: opts.openCodeChildEnv
     });
     if (cli.cancelled || opts.abortSignal?.aborted) {
       return {
@@ -11660,7 +12020,8 @@ Run **Materialize agents** first (copies list schemas into this folder\u2019s \`
             artefactRunId: stewardshipRunId,
             artefactWorkItemId: stewardshipWorkItemId,
             producerOpenCodeSessionId: capturedOpenCodeSessionId
-          }
+          },
+          opts.openCodeChildEnv
         );
         if (oqRes.cancelled) {
           return {
@@ -11789,7 +12150,7 @@ Expected output: ${outputFileAbsolute}`;
     const orderSet = new Set(CONTEXT_SYNTHESIS_TEST_STEP_ORDER);
     if (orderSet.has(opts.step)) {
       const ctx = contextDir(opts.worktreeRoot);
-      const rel = path16.relative(ctx, outputFileAbsolute).split(path16.sep).join("/");
+      const rel = path18.relative(ctx, outputFileAbsolute).split(path18.sep).join("/");
       opts.onRemediationPhase?.("aceTracing");
       try {
         await runAceTracePhase({
@@ -11836,7 +12197,7 @@ Expected output: ${outputFileAbsolute}`;
 var MARKDOWN_DETAIL_RUN_STEP = "markdownDetail";
 async function runOpenCodeMarkdownDetailStep(opts) {
   const ctx = contextDir(opts.worktreeRoot);
-  const outputFileAbsolute = path16.join(ctx, opts.target.outputBasename);
+  const outputFileAbsolute = path18.join(ctx, opts.target.outputBasename);
   const outputBasename = opts.target.outputBasename;
   const rawMdEv = opts.markdownEvidenceRepairAttempts;
   let maxMarkdownEvidenceRepairs = rawMdEv === void 0 ? 2 : Math.floor(Number(rawMdEv));
@@ -11845,9 +12206,9 @@ async function runOpenCodeMarkdownDetailStep(opts) {
   }
   maxMarkdownEvidenceRepairs = Math.min(5, Math.max(0, maxMarkdownEvidenceRepairs));
   const totalMarkdownRuns = 1 + maxMarkdownEvidenceRepairs;
-  fs19.mkdirSync(path16.dirname(outputFileAbsolute), { recursive: true });
-  const runDir = path16.join(opts.worktreeRoot, ".opencode", "_run");
-  fs19.mkdirSync(runDir, { recursive: true });
+  fs20.mkdirSync(path18.dirname(outputFileAbsolute), { recursive: true });
+  const runDir = path18.join(opts.worktreeRoot, ".opencode", "_run");
+  fs20.mkdirSync(runDir, { recursive: true });
   const safeStem = opts.target.outputBasename.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 120);
   let markdownEvidenceRepairAppendix;
   let lastPromptPath = "";
@@ -11882,12 +12243,12 @@ async function runOpenCodeMarkdownDetailStep(opts) {
       citationFormatExample: CITATION_EXAMPLE,
       repairAppendix: markdownEvidenceRepairAppendix
     });
-    const promptPath = path16.join(
+    const promptPath = path18.join(
       runDir,
       `markdownDetail-${opts.target.openCodeAgentStem}-${safeStem}-a${attempt}-${Date.now()}.prompt.txt`
     );
     lastPromptPath = promptPath;
-    fs19.writeFileSync(promptPath, body, "utf-8");
+    fs20.writeFileSync(promptPath, body, "utf-8");
     const vars = {
       promptFile: promptPath,
       agentId: opts.target.openCodeAgentStem,
@@ -11912,7 +12273,8 @@ async function runOpenCodeMarkdownDetailStep(opts) {
       diagnosticLog: opts.diagnosticLog,
       onAgentLaunched: opts.onAgentLaunched,
       signal: opts.abortSignal,
-      parseOpenCodeSessionFromJsonStdout: !isFollowUpSpawn
+      parseOpenCodeSessionFromJsonStdout: !isFollowUpSpawn,
+      childEnv: opts.openCodeChildEnv
     });
     if (cli.cancelled || opts.abortSignal?.aborted) {
       return {
@@ -11979,7 +12341,8 @@ async function runOpenCodeMarkdownDetailStep(opts) {
           artefactRunId: mdRunId,
           artefactWorkItemId: mdWorkItemId,
           producerOpenCodeSessionId: capturedOpenCodeSessionId
-        }
+        },
+        opts.openCodeChildEnv
       );
       if (oqRes.cancelled) {
         return {
@@ -12071,7 +12434,7 @@ Expected output: ${outputFileAbsolute}`;
   }
   const ok = cliProcessOk && artefactOk && validationOk;
   if (ok && opts.aceEnabled && sessionIdForAceTrace) {
-    const rel = path16.relative(ctx, outputFileAbsolute).split(path16.sep).join("/");
+    const rel = path18.relative(ctx, outputFileAbsolute).split(path18.sep).join("/");
     opts.onRemediationPhase?.("aceTracing");
     try {
       await runAceTracePhase({
@@ -12106,39 +12469,20 @@ Expected output: ${outputFileAbsolute}`;
     message,
     outputPath: outputFileAbsolute,
     promptPath: lastPromptPath,
-    step: MARKDOWN_DETAIL_RUN_STEP,
-    ...capturedOpenCodeSessionId ? {
-      openCodeSessionId: capturedOpenCodeSessionId,
-      openCodeSessionTitle: mdTitleForStore,
-      openCodeSessionCapturedAtIso: (/* @__PURE__ */ new Date()).toISOString()
-    } : {}
-  };
-}
-
-// src/analysis/worktreeManager.ts
-var import_child_process2 = require("child_process");
-var fs21 = __toESM(require("fs"));
-var os = __toESM(require("os"));
-var path18 = __toESM(require("path"));
-
-// src/analysis/easySpecsWorktreeMarker.ts
-var fs20 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
-var EASYSPECS_LOCAL_DIR = ".easyspecs";
-var EASYSPECS_WORKTREE_MARKER_REL = path17.join(EASYSPECS_LOCAL_DIR, "analysis-worktree.json");
-var MARKER_KIND = "easyspecs-analysis-worktree";
-function writeAnalysisWorktreeMarker(worktreeRoot, repositoryRoot) {
-  const dir = path17.join(worktreeRoot, EASYSPECS_LOCAL_DIR);
-  fs20.mkdirSync(dir, { recursive: true });
-  const payload = {
-    kind: MARKER_KIND,
-    repositoryRoot: path17.resolve(repositoryRoot)
+    step: MARKDOWN_DETAIL_RUN_STEP,
+    ...capturedOpenCodeSessionId ? {
+      openCodeSessionId: capturedOpenCodeSessionId,
+      openCodeSessionTitle: mdTitleForStore,
+      openCodeSessionCapturedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+    } : {}
   };
-  fs20.writeFileSync(path17.join(dir, "analysis-worktree.json"), `${JSON.stringify(payload)}
-`, "utf-8");
 }
 
 // src/analysis/worktreeManager.ts
+var import_child_process2 = require("child_process");
+var fs21 = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path19 = __toESM(require("path"));
 var EASYSPECS_WT_DIR_RE = /^easyspecs-(\d+)$/;
 function maxEasyspecsWorktreeIndex(parentDir) {
   let max = 0;
@@ -12171,7 +12515,7 @@ function allocateEasyspecsWorktreePath(parentDir) {
   const start = maxEasyspecsWorktreeIndex(parentDir);
   for (let i = start + 1; i < start + 1e4; i++) {
     const name = formatEasyspecsWorktreeFolderName(i);
-    const wt = path18.join(parentDir, name);
+    const wt = path19.join(parentDir, name);
     if (!fs21.existsSync(wt)) {
       return wt;
     }
@@ -12191,8 +12535,8 @@ function readHeadBranchShort(repoRoot) {
   return b.length > 0 ? b : void 0;
 }
 function attachWorktreeHandle(worktreePath, repositoryRoot) {
-  const wt = path18.resolve(worktreePath);
-  const repo = path18.resolve(repositoryRoot);
+  const wt = path19.resolve(worktreePath);
+  const repo = path19.resolve(repositoryRoot);
   return {
     path: wt,
     repoRoot: repo,
@@ -12210,7 +12554,7 @@ function attachWorktreeHandle(worktreePath, repositoryRoot) {
   };
 }
 function createAnalysisWorktree(repoRoot) {
-  const parent = path18.join(os.tmpdir(), "easyspecs-analysis");
+  const parent = path19.join(os.tmpdir(), "easyspecs-analysis");
   const wt = allocateEasyspecsWorktreePath(parent);
   if (!wt) {
     return {
@@ -12247,12 +12591,12 @@ var STORAGE_KEY = "easyspecs.analysis.artefactRun.v1";
 function randomRunId() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
-function isRecord2(v) {
+function isRecord3(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
 function readArtefactRunSnapshot(context) {
   const raw = context.workspaceState.get(STORAGE_KEY);
-  if (!raw || !isRecord2(raw)) {
+  if (!raw || !isRecord3(raw)) {
     return void 0;
   }
   const runId = raw.runId;
@@ -12261,7 +12605,7 @@ function readArtefactRunSnapshot(context) {
   const startedAtIso = raw.startedAtIso;
   const overallStatus = raw.overallStatus;
   const items = raw.items;
-  if (typeof runId !== "string" || typeof repositoryRoot !== "string" || typeof analysisRoot !== "string" || typeof startedAtIso !== "string" || overallStatus !== "idle" && overallStatus !== "running" && overallStatus !== "complete" && overallStatus !== "failed" || !isRecord2(items)) {
+  if (typeof runId !== "string" || typeof repositoryRoot !== "string" || typeof analysisRoot !== "string" || typeof startedAtIso !== "string" || overallStatus !== "idle" && overallStatus !== "running" && overallStatus !== "complete" && overallStatus !== "failed" || !isRecord3(items)) {
     return void 0;
   }
   const fin = raw.finishedAtIso;
@@ -12325,7 +12669,7 @@ function noteOpenCodeAgentLaunched() {
 
 // src/contextIndexAssembler.ts
 var fs24 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 
 // src/srsModel.ts
 var APPLICATION_CONTEXT_KIND = "easyspecs.application-context";
@@ -12333,26 +12677,26 @@ var APPLICATION_CONTEXT_KIND = "easyspecs.application-context";
 // src/indexApplicationContextValidate.ts
 var import__3 = __toESM(require__());
 var fs23 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 
 // src/shared/repoResourcesRoot.ts
 var fs22 = __toESM(require("node:fs"));
-var path19 = __toESM(require("node:path"));
-var CONTEXT_LIST_MARKER = path19.join("schemas", "context-lists", "zero-reference-classifier-record.schema.json");
+var path20 = __toESM(require("node:path"));
+var CONTEXT_LIST_MARKER = path20.join("schemas", "context-lists", "zero-reference-classifier-record.schema.json");
 function hasMarker(resourcesRoot) {
-  return fs22.existsSync(path19.join(resourcesRoot, CONTEXT_LIST_MARKER));
+  return fs22.existsSync(path20.join(resourcesRoot, CONTEXT_LIST_MARKER));
 }
 function resolveRepoResourcesRoot() {
   const env = process.env.EASYSPECS_EXTENSION_ROOT?.trim();
   if (env) {
-    const r = path19.join(path19.resolve(env), "resources");
+    const r = path20.join(path20.resolve(env), "resources");
     if (hasMarker(r)) {
       return r;
     }
   }
-  const candidates = [path19.join(__dirname, "..", "resources"), path19.join(__dirname, "..", "..", "resources")];
+  const candidates = [path20.join(__dirname, "..", "resources"), path20.join(__dirname, "..", "..", "resources")];
   for (const c of candidates) {
-    const abs = path19.resolve(c);
+    const abs = path20.resolve(c);
     if (hasMarker(abs)) {
       return abs;
     }
@@ -12362,10 +12706,10 @@ function resolveRepoResourcesRoot() {
   );
 }
 function resolveContextListSchemasDir() {
-  return path19.join(resolveRepoResourcesRoot(), "schemas", "context-lists");
+  return path20.join(resolveRepoResourcesRoot(), "schemas", "context-lists");
 }
 function resolveIndexApplicationContextSchemaPath() {
-  return path19.join(resolveRepoResourcesRoot(), "schemas", "index-application-context.schema.json");
+  return path20.join(resolveRepoResourcesRoot(), "schemas", "index-application-context.schema.json");
 }
 
 // src/indexApplicationContextValidate.ts
@@ -12374,7 +12718,7 @@ function getDefaultIndexSchemaPath() {
   return resolveIndexApplicationContextSchemaPath();
 }
 function getValidator(schemaPath) {
-  const abs = path20.resolve(schemaPath);
+  const abs = path21.resolve(schemaPath);
   let v = validators.get(abs);
   if (!v) {
     const raw = fs23.readFileSync(abs, "utf-8");
@@ -12430,7 +12774,7 @@ function tryAttachMarkdown(node, contextDir2, relativePath) {
   if (!norm || norm.includes("..")) {
     return false;
   }
-  const full = path21.join(contextDir2, norm);
+  const full = path22.join(contextDir2, norm);
   try {
     if (!fs24.existsSync(full) || !fs24.statSync(full).isFile()) {
       return false;
@@ -12488,7 +12832,7 @@ function mergePersistedIndexUploadMetadata(previous, next) {
   walkScopes3(next, apply);
 }
 function tryReadExistingIndexForMerge(contextDir2) {
-  const p = path21.join(contextDir2, "index-application-context.json");
+  const p = path22.join(contextDir2, "index-application-context.json");
   try {
     if (!fs24.existsSync(p)) {
       return null;
@@ -12547,7 +12891,7 @@ function applyDetailMarkdownToDocument(doc, contextDir2) {
       }
     }
   }
-  const exp = readJson2(path21.join(contextDir2, "experiences-list.json"));
+  const exp = readJson2(path22.join(contextDir2, "experiences-list.json"));
   if (doc.scopes.Experience?.nodes && exp?.views) {
     for (const vNode of doc.scopes.Experience.nodes) {
       if (vNode.type !== "View" || !vNode.code) {
@@ -12573,7 +12917,7 @@ function applyDetailMarkdownToDocument(doc, contextDir2) {
       }
     }
   }
-  const svcData = readJson2(path21.join(contextDir2, "services-list.json"));
+  const svcData = readJson2(path22.join(contextDir2, "services-list.json"));
   if (doc.scopes.Service?.nodes && svcData?.services) {
     for (const sNode of doc.scopes.Service.nodes) {
       if (sNode.type !== "Service" || !sNode.code) {
@@ -12599,7 +12943,7 @@ function applyDetailMarkdownToDocument(doc, contextDir2) {
       }
     }
   }
-  const dmData = readJson2(path21.join(contextDir2, "data-model-list.json"));
+  const dmData = readJson2(path22.join(contextDir2, "data-model-list.json"));
   if (doc.scopes.DataModel?.nodes && dmData?.entities) {
     for (const eNode of doc.scopes.DataModel.nodes) {
       if (eNode.type !== "Entity" || !eNode.code) {
@@ -12631,7 +12975,7 @@ function applyDetailMarkdownToDocument(doc, contextDir2) {
       }
     }
   }
-  const tsData = readJson2(path21.join(contextDir2, "tech-stack-list.json"));
+  const tsData = readJson2(path22.join(contextDir2, "tech-stack-list.json"));
   if (doc.scopes.TechStack?.nodes && tsData?.tools) {
     for (const tNode of doc.scopes.TechStack.nodes) {
       if (tNode.type !== "Tool" || !tNode.code) {
@@ -12655,7 +12999,7 @@ function readJson2(filePath) {
   }
 }
 function safeReadFeaturesList(contextDir2) {
-  const p = path21.join(contextDir2, "features-list.json");
+  const p = path22.join(contextDir2, "features-list.json");
   const data = readJson2(p);
   if (!data?.features?.length) {
     return null;
@@ -12663,7 +13007,7 @@ function safeReadFeaturesList(contextDir2) {
   return data;
 }
 function safeReadUseCasesList(contextDir2, feCode) {
-  const p = path21.join(contextDir2, `${feCode}-use-cases-list.json`);
+  const p = path22.join(contextDir2, `${feCode}-use-cases-list.json`);
   const data = readJson2(p);
   if (!data?.useCases?.length) {
     return null;
@@ -12671,7 +13015,7 @@ function safeReadUseCasesList(contextDir2, feCode) {
   return data;
 }
 function scenariosListPath(contextDir2, feCode, ucCode) {
-  return path21.join(contextDir2, `${feCode}_${ucCode}-scenarios-list.json`);
+  return path22.join(contextDir2, `${feCode}_${ucCode}-scenarios-list.json`);
 }
 function buildFeatureScope(contextDir2) {
   const fl = safeReadFeaturesList(contextDir2);
@@ -12708,7 +13052,7 @@ function buildFeatureScope(contextDir2) {
   return nodes;
 }
 function buildExperienceScope(contextDir2) {
-  const data = readJson2(path21.join(contextDir2, "experiences-list.json"));
+  const data = readJson2(path22.join(contextDir2, "experiences-list.json"));
   if (!data?.views?.length) {
     return [];
   }
@@ -12720,7 +13064,7 @@ function buildExperienceScope(contextDir2) {
   }));
 }
 function buildServiceScope(contextDir2) {
-  const data = readJson2(path21.join(contextDir2, "services-list.json"));
+  const data = readJson2(path22.join(contextDir2, "services-list.json"));
   if (!data?.services?.length) {
     return [];
   }
@@ -12732,13 +13076,13 @@ function buildServiceScope(contextDir2) {
   }));
 }
 function readEntityFieldsList(contextDir2, dmCode) {
-  const p = path21.join(contextDir2, `${dmCode}-fields-list.json`);
+  const p = path22.join(contextDir2, `${dmCode}-fields-list.json`);
   const file = readJson2(p);
   const rows = Array.isArray(file?.fields) ? file.fields : [];
   return rows.filter((f) => Boolean(f?.code && f?.name));
 }
 function buildDataModelScope(contextDir2) {
-  const data = readJson2(path21.join(contextDir2, "data-model-list.json"));
+  const data = readJson2(path22.join(contextDir2, "data-model-list.json"));
   if (!data?.entities?.length) {
     return [];
   }
@@ -12756,7 +13100,7 @@ function buildDataModelScope(contextDir2) {
   });
 }
 function buildTechStackScope(contextDir2) {
-  const data = readJson2(path21.join(contextDir2, "tech-stack-list.json"));
+  const data = readJson2(path22.join(contextDir2, "tech-stack-list.json"));
   if (!data?.tools?.length) {
     return [];
   }
@@ -12825,7 +13169,7 @@ function writeIndexApplicationContext(contextDir2, title, options) {
   if (!validation.ok) {
     throw new Error(`index-application-context.json schema validation failed: ${validation.errors.join("; ")}`);
   }
-  const target = path21.join(contextDir2, "index-application-context.json");
+  const target = path22.join(contextDir2, "index-application-context.json");
   const tmp = `${target}.${process.pid}.tmp`;
   try {
     fs24.writeFileSync(tmp, JSON.stringify(doc, null, 2), "utf-8");
@@ -12844,54 +13188,67 @@ function writeIndexApplicationContext(contextDir2, title, options) {
 var path23 = __toESM(require("node:path"));
 var vscode2 = __toESM(require_vscode_stub());
 
-// src/easySpecsWorkspaceSettingsCore.ts
+// src/config/easyspecsAceConfigRead.ts
 var fs25 = __toESM(require("node:fs"));
-var path22 = __toESM(require("node:path"));
-var EASYSPECS_WORKSPACE_DIR = EASYSPECS_LOCAL_DIR;
-var EASYSPECS_SETTINGS_JSON = "settings.json";
-var EASYSPECS_SETTINGS_ACE_KEY = "easyspecs.analysis.ace.enabled";
-var EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY = "easyspecs.analysis.ace.offlineLearnAfterSameSessionTrace";
-function isRecord3(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function readAceEnabledFromEasySpecsSettingsFile(workspaceRootFsPath) {
-  const filePath = path22.join(workspaceRootFsPath, EASYSPECS_WORKSPACE_DIR, EASYSPECS_SETTINGS_JSON);
+function readRawConfigJson(repoRoot) {
+  const p = easyspecsConfigPath(repoRoot);
+  if (!fs25.existsSync(p)) {
+    return void 0;
+  }
   let raw;
   try {
-    raw = fs25.readFileSync(filePath, "utf8");
+    raw = fs25.readFileSync(p, "utf8");
   } catch {
     return void 0;
   }
-  let parsed;
   try {
-    parsed = JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return void 0;
+    }
+    return parsed;
   } catch {
     return void 0;
   }
-  if (!isRecord3(parsed) || !Object.prototype.hasOwnProperty.call(parsed, EASYSPECS_SETTINGS_ACE_KEY)) {
+}
+function readAceEnabledFromEasyspecsConfigFile(repoRoot) {
+  const parsed = readRawConfigJson(repoRoot);
+  const es = parsed?.easyspecs;
+  if (!es || typeof es !== "object" || Array.isArray(es)) {
     return void 0;
   }
-  const v = parsed[EASYSPECS_SETTINGS_ACE_KEY];
+  const analysis = es.analysis;
+  if (!analysis || typeof analysis !== "object" || Array.isArray(analysis)) {
+    return void 0;
+  }
+  const ace = analysis.ace;
+  if (!ace || typeof ace !== "object" || Array.isArray(ace)) {
+    return void 0;
+  }
+  if (!Object.prototype.hasOwnProperty.call(ace, "enabled")) {
+    return void 0;
+  }
+  const v = ace.enabled;
   return typeof v === "boolean" ? v : void 0;
 }
-function readAceOfflineLearnAfterSameSessionTraceFromEasySpecsSettingsFile(workspaceRootFsPath) {
-  const filePath = path22.join(workspaceRootFsPath, EASYSPECS_WORKSPACE_DIR, EASYSPECS_SETTINGS_JSON);
-  let raw;
-  try {
-    raw = fs25.readFileSync(filePath, "utf8");
-  } catch {
+function readAceOfflineLearnAfterSameSessionTraceFromEasyspecsConfigFile(repoRoot) {
+  const parsed = readRawConfigJson(repoRoot);
+  const es = parsed?.easyspecs;
+  if (!es || typeof es !== "object" || Array.isArray(es)) {
     return void 0;
   }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
+  const analysis = es.analysis;
+  if (!analysis || typeof analysis !== "object" || Array.isArray(analysis)) {
     return void 0;
   }
-  if (!isRecord3(parsed) || !Object.prototype.hasOwnProperty.call(parsed, EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY)) {
+  const ace = analysis.ace;
+  if (!ace || typeof ace !== "object" || Array.isArray(ace)) {
     return void 0;
   }
-  const v = parsed[EASYSPECS_SETTINGS_ACE_OFFLINE_AFTER_TRACE_KEY];
+  if (!Object.prototype.hasOwnProperty.call(ace, "offlineLearnAfterSameSessionTrace")) {
+    return void 0;
+  }
+  const v = ace.offlineLearnAfterSameSessionTrace;
   return typeof v === "boolean" ? v : void 0;
 }
 
@@ -12927,9 +13284,13 @@ function getAceAnalysisEnabledForCheckout(analysisCheckoutRoot) {
   push(cliWorkspaceRootOverride);
   push(vscode2.workspace.workspaceFolders?.[0]?.uri.fsPath);
   for (const root of roots) {
-    const fromFile = readAceEnabledFromEasySpecsSettingsFile(root);
-    if (fromFile !== void 0) {
-      return fromFile;
+    const fromConfig = readAceEnabledFromEasyspecsConfigFile(root);
+    if (fromConfig !== void 0) {
+      return fromConfig;
+    }
+    const fromLegacy = readAceEnabledFromEasySpecsSettingsFile(root);
+    if (fromLegacy !== void 0) {
+      return fromLegacy;
     }
   }
   if (cliHeadlessMode) {
@@ -12956,9 +13317,13 @@ function getAceOfflineLearnAfterSameSessionTrace(analysisCheckoutRoot) {
   push(cliWorkspaceRootOverride);
   push(vscode2.workspace.workspaceFolders?.[0]?.uri.fsPath);
   for (const root of roots) {
-    const fromFile = readAceOfflineLearnAfterSameSessionTraceFromEasySpecsSettingsFile(root);
-    if (fromFile !== void 0) {
-      return fromFile;
+    const fromConfig = readAceOfflineLearnAfterSameSessionTraceFromEasyspecsConfigFile(root);
+    if (fromConfig !== void 0) {
+      return fromConfig;
+    }
+    const fromLegacy = readAceOfflineLearnAfterSameSessionTraceFromEasySpecsSettingsFile(root);
+    if (fromLegacy !== void 0) {
+      return fromLegacy;
     }
   }
   if (cliHeadlessMode) {
@@ -13115,91 +13480,91 @@ function mdItem(id, parentIds, t) {
   };
 }
 function featureDetailTarget(contextDir2, code, name, slug) {
-  const basename11 = `${code}-${slug}.md`;
+  const basename12 = `${code}-${slug}.md`;
   return {
     openCodeAgentStem: "agent-md-feature-detail",
     agentId: "ctx-md-feature-detail",
     displayName: "Feature detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     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: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function viewDetailTarget(row2, contextDir2) {
-  const basename11 = `${row2.code}-${row2.slug}.md`;
+  const basename12 = `${row2.code}-${row2.slug}.md`;
   return {
     openCodeAgentStem: "agent-md-view-detail",
     agentId: "ctx-md-view-detail",
     displayName: "View detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     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: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function interactionDetailTarget(viewCode, ix, contextDir2) {
-  const basename11 = `${viewCode}_${ix.code}-${ix.slug}.md`;
+  const basename12 = `${viewCode}_${ix.code}-${ix.slug}.md`;
   return {
     openCodeAgentStem: "agent-md-interaction-detail",
     agentId: "ctx-md-interaction-detail",
     displayName: "Interaction detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     taskDescription: `Document interaction **${ix.code}** (**${ix.name}**) on view **${viewCode}** per \`.gluecharm/context/experiences-list.json\`.`,
-    exists: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function serviceDetailTarget(row2, contextDir2) {
-  const basename11 = `${row2.code}-${row2.slug}.md`;
+  const basename12 = `${row2.code}-${row2.slug}.md`;
   return {
     openCodeAgentStem: "agent-md-service-detail",
     agentId: "ctx-md-service-detail",
     displayName: "Service detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     taskDescription: `Describe service **${row2.code}** (**${row2.name}**, slug **${row2.slug}**) per \`.gluecharm/context/services-list.json\`: responsibilities, consumers, errors, integration points.`,
-    exists: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function methodDetailTarget(svc, m, contextDir2) {
-  const basename11 = `${svc.code}_${m.code}-${m.slug}.md`;
+  const basename12 = `${svc.code}_${m.code}-${m.slug}.md`;
   return {
     openCodeAgentStem: "agent-md-method-detail",
     agentId: "ctx-md-method-detail",
     displayName: "Method detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     taskDescription: `Document method **${m.code}** (**${m.name}**) on service **${svc.code}** per \`.gluecharm/context/services-list.json\`.`,
-    exists: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function entityDetailTarget(dmCode, ename, slug, contextDir2) {
-  const basename11 = `${dmCode}-${slug}.md`;
+  const basename12 = `${dmCode}-${slug}.md`;
   return {
     openCodeAgentStem: "agent-md-entity-detail",
     agentId: "ctx-md-entity-detail",
     displayName: "Entity detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     taskDescription: `Describe entity **${dmCode}** (**${ename}**, slug **${slug}**) per \`.gluecharm/context/data-model-list.json\`: lifecycle, invariants, storage, ORM/schema mapping.`,
-    exists: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function fieldDetailTarget(dmCode, fdCode, fname, fSlug, contextDir2) {
-  const basename11 = `${dmCode}_${fdCode}-${fSlug}.md`;
+  const basename12 = `${dmCode}_${fdCode}-${fSlug}.md`;
   return {
     openCodeAgentStem: "agent-md-field-detail",
     agentId: "ctx-md-field-detail",
     displayName: "Field detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     taskDescription: `Document field **${fdCode}** (**${fname}**) on entity **${dmCode}** per \`.gluecharm/context/${dmCode}-fields-list.json\`. Cite types and constraints with file and line.`,
-    exists: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function toolDetailTarget(row2, contextDir2) {
-  const basename11 = `${row2.code}-${row2.slug}.md`;
+  const basename12 = `${row2.code}-${row2.slug}.md`;
   return {
     openCodeAgentStem: "agent-md-tool-detail",
     agentId: "ctx-md-tool-detail",
     displayName: "Tool detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     taskDescription: `Describe tool **${row2.code}** (**${row2.name}**, slug **${row2.slug}**) per \`.gluecharm/context/tech-stack-list.json\`: role, version hints, configuration, boundaries.`,
-    exists: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function useCaseDetailTarget(feCode, ucCode, ucName, ucSlug, contextDir2) {
@@ -13216,14 +13581,14 @@ Follow bundled agent **agent-md-use-case-detail**: include **## Data inputs and
   };
 }
 function scenarioDetailTarget(feCode, ucCode, scCode, scName, contextDir2) {
-  const basename11 = `${feCode}_${ucCode}_${scCode}.md`;
+  const basename12 = `${feCode}_${ucCode}_${scCode}.md`;
   return {
     openCodeAgentStem: "agent-md-scenario-detail",
     agentId: "ctx-md-scenario-detail",
     displayName: "Scenario detail",
-    outputBasename: basename11,
+    outputBasename: basename12,
     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: fs27.existsSync(path25.join(contextDir2, basename11)) && fs27.statSync(path25.join(contextDir2, basename11)).size > 0
+    exists: fs27.existsSync(path25.join(contextDir2, basename12)) && fs27.statSync(path25.join(contextDir2, basename12)).size > 0
   };
 }
 function parentsDone(item, byId) {
@@ -13449,15 +13814,15 @@ function expandAfterSuccess(completed, contextDir2, byId, fifo) {
     return;
   }
   if (completed.kind === "markdown") {
-    const basename11 = completed.payload.outputBasename;
+    const basename12 = completed.payload.outputBasename;
     const mdId = completed.id;
-    const feFromFeatureMd = basename11.match(/^(FE-\d+)-[^/]+\.md$/);
+    const feFromFeatureMd = basename12.match(/^(FE-\d+)-[^/]+\.md$/);
     if (feFromFeatureMd) {
       const fe = feFromFeatureMd[1];
       add(coordItem(`coord:uc:${fe}`, [mdId], "listUseCases", { featureCode: fe }));
       return;
     }
-    const xpFromView = basename11.match(/^(XP-\d+)-[^/]+\.md$/);
+    const xpFromView = basename12.match(/^(XP-\d+)-[^/]+\.md$/);
     if (xpFromView) {
       const xp = xpFromView[1];
       const row2 = discoverExperienceTreeRows(contextDir2).find((r) => r.code === xp);
@@ -13469,7 +13834,7 @@ function expandAfterSuccess(completed, contextDir2, byId, fifo) {
       }
       return;
     }
-    const svFromSvc = basename11.match(/^(SV-\d+)-[^/]+\.md$/);
+    const svFromSvc = basename12.match(/^(SV-\d+)-[^/]+\.md$/);
     if (svFromSvc) {
       const sv = svFromSvc[1];
       const srow = discoverServiceTreeRows(contextDir2).find((r) => r.code === sv);
@@ -13481,7 +13846,7 @@ function expandAfterSuccess(completed, contextDir2, byId, fifo) {
       }
       return;
     }
-    const dmFromEnt = basename11.match(/^(DM-\d+)-[^/]+\.md$/);
+    const dmFromEnt = basename12.match(/^(DM-\d+)-[^/]+\.md$/);
     if (dmFromEnt) {
       const dm = dmFromEnt[1];
       add(coordItem(`coord:ef:${dm}`, [mdId], "listEntityFields", { entityCode: dm }));
@@ -13520,7 +13885,8 @@ async function runArtefactWorkItemOpenCode(item, worktreeRoot, workspaceLabel, o
     artefactRunId,
     artefactWorkItemId: item.id,
     aceEnabled: oc.aceEnabled === true,
-    offlineLearnAfterSameSessionTrace: oc.offlineLearnAfterSameSessionTrace === true
+    offlineLearnAfterSameSessionTrace: oc.offlineLearnAfterSameSessionTrace === true,
+    openCodeChildEnv: oc.openCodeChildEnv
   };
   if (item.kind === "coord") {
     const { step, listTarget } = item.payload;
@@ -13577,6 +13943,7 @@ async function runArtefactWorkItemOpenCode(item, worktreeRoot, workspaceLabel, o
     artefactWorkItemId: item.id,
     aceEnabled: oc.aceEnabled === true,
     offlineLearnAfterSameSessionTrace: oc.offlineLearnAfterSameSessionTrace === true,
+    openCodeChildEnv: oc.openCodeChildEnv,
     target: {
       openCodeAgentStem: p.openCodeAgentStem,
       agentId: p.agentId,
@@ -13645,8 +14012,8 @@ async function drainArtefactWorkPool(p) {
   const artefactRunId = readArtefactRunSnapshot(storageContext)?.runId ?? "unknown-run";
   let active = 0;
   let wake;
-  const waitTurn = () => new Promise((resolve14) => {
-    wake = resolve14;
+  const waitTurn = () => new Promise((resolve15) => {
+    wake = resolve15;
   });
   const persist = async () => {
     const items = {};
@@ -13886,7 +14253,8 @@ async function runContextArtefactPipelineAsync(storageContext, repoRoot, workspa
   try {
     materializeOpenCodeAgentsWithAce(extensionAgentsDirFs, handle.path, {
       enabled: aceEnabled,
-      diagnosticLog: log
+      diagnosticLog: log,
+      projectConfigOverlay: oc.projectConfigOverlay
     });
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -13973,7 +14341,7 @@ function macroSleep(ms, signal) {
   if (signal.aborted) {
     return Promise.reject(new DOMException("The operation was aborted.", "AbortError"));
   }
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     const onAbort = () => {
       clearTimeout(t);
       signal.removeEventListener("abort", onAbort);
@@ -13981,7 +14349,7 @@ function macroSleep(ms, signal) {
     };
     const t = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve14();
+      resolve15();
     }, ms);
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -14174,7 +14542,7 @@ async function runMacroAnalysisOrchestration(deps) {
       setRowTimed("synthesis_convergence", "succeeded", "No missing artefacts.");
       await post();
       if (config.synthesisOnly) {
-        return { ok: true, message: "Synthesis-only macro complete.", totalElapsedMs: macroEnd() };
+        return { ok: true, message: "Synthesis-only analysis complete.", totalElapsedMs: macroEnd() };
       }
       if (isAborted(signal)) {
         setRowTimed("reference_coverage", "cancelled");
@@ -14341,7 +14709,7 @@ async function runMacroAnalysisOrchestration(deps) {
     }
     setRowTimed("backend_context_sync", "succeeded", up.message);
     await post();
-    return { ok: true, message: "Full pipeline macro complete.", totalElapsedMs: macroEnd() };
+    return { ok: true, message: "Analysis complete.", totalElapsedMs: macroEnd() };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return fail(msg);
@@ -14516,8 +14884,8 @@ function expectedFeatureDetailBasenameFromRow(row2) {
   }
   return `${code}-${slug}.md`;
 }
-function ctxPath(contextDir2, basename11) {
-  return path27.join(contextDir2, basename11);
+function ctxPath(contextDir2, basename12) {
+  return path27.join(contextDir2, basename12);
 }
 function pushTarget(targets, stem, outputBasename, taskDescription, contextDir2) {
   const meta = STEM_TO_AGENT[stem];
@@ -14546,11 +14914,11 @@ function discoverDetailMarkdownGroups(contextDir2) {
       continue;
     }
     const name = safeStr3(row2.name) || code;
-    const basename11 = `${code}-${slug}.md`;
+    const basename12 = `${code}-${slug}.md`;
     pushTarget(
       featureTargets,
       "agent-md-feature-detail",
-      basename11,
+      basename12,
       `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).`,
       contextDir2
     );
@@ -15738,8 +16106,8 @@ function formatAjvErrors5(errors) {
   });
 }
 var ajv = new import__5.default({ allErrors: true, strict: false });
-function compileSchema(basename11) {
-  const schemaPath = path32.join(schemasDir(), basename11);
+function compileSchema(basename12) {
+  const schemaPath = path32.join(schemasDir(), basename12);
   const schemaRaw = stripUtf8Bom5(fs33.readFileSync(schemaPath, "utf-8"));
   const schema = JSON.parse(schemaRaw);
   return ajv.compile(schema);
@@ -16346,7 +16714,8 @@ async function runClassifierAgent(common, contextDirAbs, targetFilePathPosix, wo
       executable: common.executable,
       diagnosticLog: common.diagnosticLog,
       onAgentLaunched: common.onAgentLaunched,
-      signal: common.abortSignal
+      signal: common.abortSignal,
+      ...common.openCodeChildEnv ? { childEnv: common.openCodeChildEnv } : {}
     });
     if (cli.cancelled || common.abortSignal?.aborted) {
       return { ok: false, message: "Stopped.", stagingPath: outAbs, cancelled: true };
@@ -16492,7 +16861,8 @@ async function runMarkdownReferenceAgent(common, contextDirAbs, targetFilePathPo
     executable: common.executable,
     diagnosticLog: common.diagnosticLog,
     onAgentLaunched: common.onAgentLaunched,
-    signal: common.abortSignal
+    signal: common.abortSignal,
+    ...common.openCodeChildEnv ? { childEnv: common.openCodeChildEnv } : {}
   });
   if (cli.cancelled || common.abortSignal?.aborted) {
     return { ok: false, message: "Stopped.", cancelled: true };
@@ -16553,7 +16923,8 @@ async function runCoordinationTriageAgent(common, contextDirAbs, targetFilePathP
       executable: common.executable,
       diagnosticLog: common.diagnosticLog,
       onAgentLaunched: common.onAgentLaunched,
-      signal: common.abortSignal
+      signal: common.abortSignal,
+      ...common.openCodeChildEnv ? { childEnv: common.openCodeChildEnv } : {}
     });
     if (cli.cancelled || common.abortSignal?.aborted) {
       return { ok: false, message: "Stopped.", stagingPath: outAbs, cancelled: true };
@@ -17596,18 +17967,18 @@ async function runParallelSinglesIntoAccum(requestJson, applicationId, paths, on
   const recentWaveMs = [];
   let idx = 0;
   const runOne = async (absPath) => {
-    const basename11 = path37.basename(absPath);
+    const basename12 = path37.basename(absPath);
     let content;
     try {
       content = fs38.readFileSync(absPath, "utf8");
     } catch (e) {
       const msg = errorMessage(e);
-      logSrs13Failure(log, `read file file=${basename11}`, msg);
+      logSrs13Failure(log, `read file file=${basename12}`, msg);
       accum.failed.push({ path: absPath, message: msg });
       return;
     }
     const existingId = resolveExistingId(absPath);
-    const payload = buildSrsDiscoverySavePayload(applicationId, basename11, content, existingId);
+    const payload = buildSrsDiscoverySavePayload(applicationId, basename12, content, existingId);
     try {
       await postSingleCreate(requestJson, payload, log);
       accum.succeeded.push(absPath);
@@ -17621,7 +17992,7 @@ async function runParallelSinglesIntoAccum(requestJson, applicationId, paths, on
         throw e;
       }
       const msg = errorMessage(e);
-      logSrs13Failure(log, `POST /api/content/srs_discovery file=${basename11}`, msg);
+      logSrs13Failure(log, `POST /api/content/srs_discovery file=${basename12}`, msg);
       accum.failed.push({ path: absPath, message: msg });
     }
   };
@@ -17703,18 +18074,18 @@ async function executeContextSrsDiscoveryUploadPhase(filePaths, phaseOpts, accum
     const items = [];
     const chunkPaths = [];
     for (const absPath of chunk) {
-      const basename11 = path37.basename(absPath);
+      const basename12 = path37.basename(absPath);
       let content;
       try {
         content = fs38.readFileSync(absPath, "utf8");
       } catch (e) {
         const msg = errorMessage(e);
-        logSrs13Failure(log, `read file file=${basename11}`, msg);
+        logSrs13Failure(log, `read file file=${basename12}`, msg);
         accum.failed.push({ path: absPath, message: msg });
         continue;
       }
       const existingId = resolveExistingId(absPath);
-      items.push(buildSrsDiscoverySavePayloadForBatch(applicationId, basename11, content, existingId));
+      items.push(buildSrsDiscoverySavePayloadForBatch(applicationId, basename12, content, existingId));
       chunkPaths.push(absPath);
     }
     if (items.length === 0) {
@@ -18207,14 +18578,14 @@ var RE_MD_SV = /^SV-\d+-.+\.md$/i;
 var RE_MD_DM_FD = /^DM-\d+_FD-\d+-.+\.md$/i;
 var RE_MD_DM = /^DM-\d+-.+\.md$/i;
 var RE_MD_TS = /^TS-\d+-.+\.md$/i;
-function looksLikeCoordinationDetailMarkdownBasename(basename11) {
-  if (!basename11 || basename11 !== path39.basename(basename11) || !/\.md$/i.test(basename11)) {
+function looksLikeCoordinationDetailMarkdownBasename(basename12) {
+  if (!basename12 || basename12 !== path39.basename(basename12) || !/\.md$/i.test(basename12)) {
     return false;
   }
-  if (STAPLE_CONTEXT_MARKDOWN_BASENAMES.has(basename11)) {
+  if (STAPLE_CONTEXT_MARKDOWN_BASENAMES.has(basename12)) {
     return false;
   }
-  return RE_MD_FE_UC_SC.test(basename11) || RE_MD_FE_UC_SLUG.test(basename11) || RE_MD_FE_UC_PLAIN.test(basename11) || RE_MD_FE_FEATURE.test(basename11) || RE_MD_XP_BH.test(basename11) || RE_MD_XP_VIEW.test(basename11) || RE_MD_SV_ME.test(basename11) || RE_MD_SV.test(basename11) || RE_MD_DM_FD.test(basename11) || RE_MD_DM.test(basename11) || RE_MD_TS.test(basename11);
+  return RE_MD_FE_UC_SC.test(basename12) || RE_MD_FE_UC_SLUG.test(basename12) || RE_MD_FE_UC_PLAIN.test(basename12) || RE_MD_FE_FEATURE.test(basename12) || RE_MD_XP_BH.test(basename12) || RE_MD_XP_VIEW.test(basename12) || RE_MD_SV_ME.test(basename12) || RE_MD_SV.test(basename12) || RE_MD_DM_FD.test(basename12) || RE_MD_DM.test(basename12) || RE_MD_TS.test(basename12);
 }
 function loadRawFeatureRows(contextDirAbs) {
   const p = path39.join(contextDirAbs, "features-list.json");
@@ -18229,8 +18600,8 @@ function loadRawFeatureRows(contextDirAbs) {
     return [];
   }
 }
-function hintForOrphanFeatureMarkdown(basename11, featureRows) {
-  const m = /^FE-(\d+)-(.+)\.md$/i.exec(basename11);
+function hintForOrphanFeatureMarkdown(basename12, featureRows) {
+  const m = /^FE-(\d+)-(.+)\.md$/i.exec(basename12);
   if (!m) {
     return void 0;
   }
@@ -18242,8 +18613,8 @@ function hintForOrphanFeatureMarkdown(basename11, featureRows) {
       continue;
     }
     const expected = expectedFeatureDetailBasenameFromRow(row2);
-    if (expected && expected !== basename11) {
-      return `features-list row ${code} currently implies detail file ${expected} (slug/name changed \u2014 ${basename11} may be stale).`;
+    if (expected && expected !== basename12) {
+      return `features-list row ${code} currently implies detail file ${expected} (slug/name changed \u2014 ${basename12} may be stale).`;
     }
     if (!expected) {
       return `features-list row ${code} has no resolvable slug for a detail markdown basename.`;
@@ -18678,6 +19049,13 @@ async function refreshTokenWithApi(apiBaseUrl, fetchImpl, refreshToken) {
   const tokens = normalizeTokens(payload);
   return { accessToken: tokens.accessToken, refreshToken: tokens.refreshToken };
 }
+function toFetchErrorMessage(e) {
+  if (e && typeof e === "object" && "status" in e && "message" in e) {
+    return e;
+  }
+  const msg = e instanceof Error ? e.message : String(e);
+  return { status: 0, message: msg };
+}
 
 // src/auth/gluecharmContentNegotiation.ts
 var GLUECHARM_WS_LEGACY_JSON = "application/vnd.gluecharm.v1.ws-legacy+json";
@@ -18783,9 +19161,41 @@ var path40 = __toESM(require("node:path"));
 function defaultSessionPath() {
   return path40.join(os2.homedir(), ".easyspecs", "cli-session.json");
 }
+var configSessionPath;
+function setCliSessionPathFromConfig(absPath) {
+  configSessionPath = absPath?.trim() ? path40.resolve(absPath) : void 0;
+}
+function applyCliSessionPathFromRepoConfig(repoRoot, cfg) {
+  const raw = cfg.easyspecs?.cliSessionPath?.trim();
+  if (!raw) {
+    setCliSessionPathFromConfig(void 0);
+    return;
+  }
+  const abs = path40.isAbsolute(raw) ? raw : path40.join(repoRoot, raw);
+  setCliSessionPathFromConfig(abs);
+}
+function normalizeCliSessionPathForConfig(repoRoot, raw) {
+  const t = raw.trim();
+  if (!t) {
+    return "";
+  }
+  const resolvedRepo = path40.resolve(repoRoot);
+  const abs = path40.isAbsolute(t) ? path40.normalize(t) : path40.resolve(resolvedRepo, t);
+  const rel = path40.relative(resolvedRepo, abs);
+  if (rel === "") {
+    return abs;
+  }
+  const underRepo = !rel.startsWith("..") && !path40.isAbsolute(rel);
+  if (underRepo) {
+    return rel.split(path40.sep).join("/");
+  }
+  return abs;
+}
 function effectiveCliSessionPath() {
-  const f = process.env.EASYSPECS_CLI_SESSION_FILE?.trim();
-  return f ? path40.resolve(f) : defaultSessionPath();
+  if (configSessionPath) {
+    return configSessionPath;
+  }
+  return defaultSessionPath();
 }
 function readCliSession() {
   const p = effectiveCliSessionPath();
@@ -18900,8 +19310,8 @@ async function runAceAutoLearnPool(p) {
   const fifo = [...p.traceAbsolutePaths];
   let active = 0;
   let wake;
-  const waitTurn = () => new Promise((resolve14) => {
-    wake = resolve14;
+  const waitTurn = () => new Promise((resolve15) => {
+    wake = resolve15;
   });
   const pump = () => {
     wake?.();
@@ -18992,8 +19402,82 @@ function parseTailFlags(tail) {
   return { rootKind, worktree };
 }
 
+// src/cli/parseDoctorFlags.ts
+var ALLOWED = /* @__PURE__ */ new Set(["--readiness", "--inspect-config"]);
+function parseDoctorFlags(tail) {
+  for (const t of tail) {
+    if (!ALLOWED.has(t)) {
+      throw new Error(`Unknown doctor flag: ${t}`);
+    }
+  }
+  if (tail.length === 0) {
+    return { readiness: true, inspectConfig: false };
+  }
+  return {
+    readiness: tail.includes("--readiness"),
+    inspectConfig: tail.includes("--inspect-config")
+  };
+}
+
+// src/cli/parseAuthLoginTail.ts
+function extractAuthLoginSessionPathFromTail(tail) {
+  const rest = [];
+  let sessionPath;
+  for (let i = 0; i < tail.length; i += 1) {
+    const a = tail[i] ?? "";
+    if (a === "--session-path") {
+      const v = tail[i + 1];
+      if (v === void 0 || v.startsWith("-")) {
+        throw new Error("--session-path requires a value");
+      }
+      sessionPath = v;
+      i += 1;
+      continue;
+    }
+    rest.push(a);
+  }
+  return { rest, sessionPath };
+}
+function stripCiFlag(tail) {
+  return tail.filter((t) => t !== "--ci");
+}
+function parseAuthLoginTail(tail) {
+  const tokens = stripCiFlag(tail);
+  let email;
+  let password;
+  for (let i = 0; i < tokens.length; i += 1) {
+    const a = tokens[i] ?? "";
+    if (a === "--email") {
+      const v = tokens[i + 1];
+      if (v === void 0 || v.startsWith("-")) {
+        return { ok: false, error: "--email requires a value" };
+      }
+      email = v;
+      i += 1;
+      continue;
+    }
+    if (a === "--password") {
+      const v = tokens[i + 1];
+      if (v === void 0) {
+        return { ok: false, error: "--password requires a value" };
+      }
+      password = v;
+      i += 1;
+      continue;
+    }
+    return { ok: false, error: `Unexpected argument: ${a}` };
+  }
+  if (!email?.trim()) {
+    return { ok: false, error: "Missing --email (or use --ci with EASYSPECS_EMAIL / EASYSPECS_PASSWORD)" };
+  }
+  if (password === void 0) {
+    return { ok: false, error: "Missing --password (or use --ci with EASYSPECS_EMAIL / EASYSPECS_PASSWORD)" };
+  }
+  return { ok: true, creds: { email: email.trim(), password } };
+}
+
 // src/cli/main.ts
-var PKG_VERSION = "0.0.3";
+var PKG_VERSION = "0.0.5";
 function logErr(flags, ...a) {
   if (!flags.json) {
     console.error(...a);
@@ -19001,6 +19485,12 @@ function logErr(flags, ...a) {
     console.error(...a);
   }
 }
+function buildDoctorInspectPayload(merged, repoConfig) {
+  return {
+    merged: redactMergedCliSettingsForDump(merged),
+    easyspecsConfig: redactEasyspecsConfigRootForDump(repoConfig)
+  };
+}
 function formatCommand(positionals) {
   return positionals.join(" ").trim() || "help";
 }
@@ -19015,18 +19505,21 @@ Global options:
   --ci                  Non-interactive; fail fast if configuration is missing
   --json                Print one JSON summary line on stdout
   --verbose             Extra stderr logging
-  --api-base-url <url>  System Manager API origin
-  --promote / --no-promote  Copy generated context into workspace after analyze (default: promote)
+  --api-base-url <url>  System Manager API origin (overrides config)
+  --session-path <file>  Session JSON for this run (overrides easyspecs.cliSessionPath; e.g. extension delegate)
+  --environment production|staging  Effective deployment (alias: --env); overrides easyspecs.deploymentEnvironment
+  --promote / --no-promote  Copy generated context into workspace after run synthesis (default: promote)
 
 Commands:
   help | --help
   version
-  doctor
-  auth login | logout | status
-  analyze | analyze run
-  analyze resume-missing [--worktree <path>]
-  analyze resume-synthesis [--worktree <path>]
-  pipeline macro [--synthesis-only] [--upload] [--skip-upload]
+  doctor [--readiness] [--inspect-config]
+  auth login --email <email> --password <password> [--session-path <path>]
+  auth logout | status
+  run synthesis
+  run synthesis resume-missing [--worktree <path>]
+  run synthesis resume-synthesis [--worktree <path>]
+  analysis [--synthesis-only] [--upload] [--skip-upload]
   diagnose reference-coverage --root workspace|worktree [--worktree <path>]
   diagnose coordination-duplicates --root workspace|worktree [--worktree <path>]
   diagnose coverage-report --root workspace|worktree [--worktree <path>]
@@ -19034,7 +19527,9 @@ Commands:
   diagnose zero-reference [--worktree <path>]
   upload context | upload republish
   ace clear | ace learn | ace auto-learn [--worktree <path>]
-  config dump
+  config init [--overwrite]
+  config set-project-id <easyspecsProjectId>
+  config set-git-remote <url>
 `);
 }
 function parseWorktreeFlag(rest) {
@@ -19069,18 +19564,23 @@ function resolveAdHocCheckoutRoot(_repoRoot, storage, worktreeFlag) {
   if (p && fs43.existsSync(path43.join(p, ".git"))) {
     return p;
   }
-  throw new Error("No analysis checkout: run `easyspecs-cli analyze` first or pass `--worktree <path>`.");
+  throw new Error("No analysis checkout: run `easyspecs-cli run synthesis` first or pass `--worktree <path>`.");
 }
 function requireOpenCode(merged, flags) {
   const readiness = getOpenCodeReadiness({
     executable: merged.openCodeExecutable,
-    skipCredentialsCheck: merged.openCodeSkipCredentialsCheck
+    skipCredentialsCheck: merged.openCodeSkipCredentialsCheck,
+    providerEnvFromConfig: merged.openCodeChildEnv
   });
   if (!readiness.installed) {
-    throw new Error("OpenCode not on PATH (set EASYSPECS_OPENCODE_EXECUTABLE or install opencode).");
+    throw new Error(
+      "OpenCode not on PATH (set `easyspecs.openCode.executable` or `easyspecs.openCodeRuntime.executable` in `.easyspecs/config.json`, or install `opencode`)."
+    );
   }
   if (!readiness.credentialsReady) {
-    throw new Error("OpenCode credentials not ready.");
+    throw new Error(
+      "OpenCode credentials not ready: configure provider `apiKey` values under `easyspecs.openCodeRuntime.providers` in `.easyspecs/config.json`, or sign in with OpenCode using your usual shell."
+    );
   }
   return readiness;
 }
@@ -19142,11 +19642,136 @@ async function main() {
   const repoRoot = resolveRepoRoot(flags);
   setAceCliHeadlessMode(true);
   setAceCliWorkspaceRoot(repoRoot);
-  const apiResolved = initApiBaseUrlForCli(repoRoot, flags);
-  const merged = mergeCliSettings(repoRoot, {
+  if (positionals[0] === "config" && positionals[1] === "init") {
+    const tail = positionals.slice(2);
+    const overwrite = tail.includes("--overwrite");
+    const unknown = tail.filter((t) => t !== "--overwrite");
+    if (unknown.length > 0) {
+      logErr(flags, `Unknown arguments for config init: ${unknown.join(", ")}`);
+      process.exit(ExitCode.usage);
+    }
+    try {
+      const r = initEasyspecsConfigFile(repoRoot, {
+        overwrite,
+        warnMigration: (m) => logErr(flags, `[EasySpecs] ${m}`)
+      });
+      if (flags.json) {
+        printJsonLine({
+          command: "config init",
+          durationMs: Date.now() - t0,
+          ok: true,
+          outcome: r.outcome,
+          path: r.path
+        });
+      } else {
+        const msg = r.outcome === "created" ? `Wrote ${r.path}` : r.outcome === "overwritten" ? `Overwrote ${r.path} with defaults (merged legacy cli.json / settings.json when present).` : `Already exists \u2014 ${r.path} (use --overwrite to replace with defaults).`;
+        console.log(msg);
+      }
+      process.exit(ExitCode.ok);
+    } catch (e) {
+      if (e instanceof EasyspecsConfigInvalidJsonError) {
+        console.error(e.message);
+        process.exit(ExitCode.misconfiguration);
+      }
+      throw e;
+    }
+  }
+  if (positionals[0] === "config" && positionals[1] === "set-project-id") {
+    const rest = positionals.slice(2);
+    const id = rest[0]?.trim();
+    const extra = rest.slice(1).filter((t) => t.length > 0);
+    if (!id || extra.length > 0) {
+      logErr(flags, "Usage: easyspecs-cli config set-project-id <easyspecsProjectId>");
+      process.exit(ExitCode.usage);
+    }
+    try {
+      const cfg = updateEasyspecsConfig(
+        repoRoot,
+        { easyspecs: { easyspecsProjectId: id } },
+        { warnMigration: (m) => logErr(flags, `[EasySpecs] ${m}`) }
+      );
+      const path44 = easyspecsConfigPath(repoRoot);
+      if (flags.json) {
+        printJsonLine({
+          command: "config set-project-id",
+          durationMs: Date.now() - t0,
+          ok: true,
+          path: path44,
+          easyspecsProjectId: cfg.easyspecs?.easyspecsProjectId ?? ""
+        });
+      } else {
+        console.log(`Updated ${path44} \u2014 easyspecs.easyspecsProjectId`);
+      }
+      process.exit(ExitCode.ok);
+    } catch (e) {
+      if (e instanceof EasyspecsConfigInvalidJsonError) {
+        console.error(e.message);
+        process.exit(ExitCode.misconfiguration);
+      }
+      throw e;
+    }
+  }
+  if (positionals[0] === "config" && positionals[1] === "set-git-remote") {
+    const rest = positionals.slice(2);
+    const url = rest[0]?.trim();
+    const extra = rest.slice(1).filter((t) => t.length > 0);
+    if (!url || extra.length > 0) {
+      logErr(flags, "Usage: easyspecs-cli config set-git-remote <url>");
+      process.exit(ExitCode.usage);
+    }
+    try {
+      const cfg = updateEasyspecsConfig(
+        repoRoot,
+        { easyspecs: { defaultGitRemoteUrl: url } },
+        { warnMigration: (m) => logErr(flags, `[EasySpecs] ${m}`) }
+      );
+      const path44 = easyspecsConfigPath(repoRoot);
+      if (flags.json) {
+        printJsonLine({
+          command: "config set-git-remote",
+          durationMs: Date.now() - t0,
+          ok: true,
+          path: path44,
+          defaultGitRemoteUrl: cfg.easyspecs?.defaultGitRemoteUrl ?? ""
+        });
+      } else {
+        console.log(`Updated ${path44} \u2014 easyspecs.defaultGitRemoteUrl`);
+      }
+      process.exit(ExitCode.ok);
+    } catch (e) {
+      if (e instanceof EasyspecsConfigInvalidJsonError) {
+        console.error(e.message);
+        process.exit(ExitCode.misconfiguration);
+      }
+      throw e;
+    }
+  }
+  const allowCreateConfig = positionals[0] !== "doctor";
+  let repoConfig;
+  try {
+    repoConfig = ensureEasyspecsConfig(repoRoot, {
+      allowCreate: allowCreateConfig,
+      warnMigration: (m) => logErr(flags, `[EasySpecs] ${m}`)
+    });
+  } catch (e) {
+    if (e instanceof EasyspecsConfigInvalidJsonError) {
+      console.error(e.message);
+      process.exit(ExitCode.misconfiguration);
+    }
+    throw e;
+  }
+  applyCliSessionPathFromRepoConfig(repoRoot, repoConfig);
+  if (flags.sessionPath?.trim()) {
+    const sp = flags.sessionPath.trim();
+    const abs = path43.isAbsolute(sp) ? path43.normalize(sp) : path43.resolve(repoRoot, sp);
+    setCliSessionPathFromConfig(abs);
+  }
+  const apiResolved = initApiBaseUrlForCli(repoRoot, flags, repoConfig);
+  const merged = mergeEasyspecsCliSettings(repoConfig, {
     ci: flags.ci,
     apiBaseUrl: flags.apiBaseUrl,
-    promote: flags.promote
+    promote: flags.promote,
+    repoRoot
   });
   const finish = (code, envelope) => {
     if (flags.json) {
@@ -19162,11 +19787,20 @@ async function main() {
   const pos = positionals;
   try {
     if (pos[0] === "doctor") {
+      let modes;
+      try {
+        modes = parseDoctorFlags(pos.slice(1));
+      } catch (e) {
+        logErr(flags, e instanceof Error ? e.message : String(e));
+        logErr(flags, "Usage: easyspecs-cli doctor [--readiness] [--inspect-config]");
+        process.exit(ExitCode.usage);
+      }
       const agentsDir = resolveOpenCodeAgentsDir();
       const agentsOk = fs43.existsSync(agentsDir);
       const oc = getOpenCodeReadiness({
         executable: merged.openCodeExecutable,
-        skipCredentialsCheck: merged.openCodeSkipCredentialsCheck
+        skipCredentialsCheck: merged.openCodeSkipCredentialsCheck,
+        providerEnvFromConfig: merged.openCodeChildEnv
       });
       const lines = [
         `repoRoot=${repoRoot}`,
@@ -19174,13 +19808,29 @@ async function main() {
         `opencode installed=${String(oc.installed)} credentialsReady=${String(oc.credentialsReady)}`,
         `agentsDir=${agentsDir} exists=${String(agentsOk)}`
       ];
+      const inspectPayload = buildDoctorInspectPayload(merged, repoConfig);
       if (!flags.json) {
-        console.log(lines.join("\n"));
+        const parts = [];
+        if (modes.readiness) {
+          parts.push(lines.join("\n"));
+        }
+        if (modes.inspectConfig) {
+          parts.push(JSON.stringify(inspectPayload, null, 2));
+        }
+        console.log(parts.join(parts.length === 2 ? "\n\n" : ""));
+      }
+      const envelope = { ok: true };
+      if (modes.readiness) {
+        envelope.lines = lines;
       }
-      finish(ExitCode.ok, { ok: true, lines });
+      if (modes.inspectConfig) {
+        envelope.config = inspectPayload;
+      }
+      finish(ExitCode.ok, envelope);
     }
     if (pos[0] === "config" && pos[1] === "dump") {
-      const redacted = { ...merged, apiBaseUrl: merged.apiBaseUrl ? "(set)" : "" };
+      logErr(flags, "[EasySpecs] `config dump` is deprecated; use `easyspecs-cli doctor --inspect-config`.");
+      const redacted = buildDoctorInspectPayload(merged, repoConfig);
       if (!flags.json) {
         console.log(JSON.stringify(redacted, null, 2));
       }
@@ -19198,33 +19848,121 @@ async function main() {
       finish(ExitCode.ok, { ok: true, authenticated: Boolean(s) });
     }
     if (pos[0] === "auth" && pos[1] === "login") {
-      if (flags.ci) {
-        const email = process.env.EASYSPECS_EMAIL?.trim();
-        const password = process.env.EASYSPECS_PASSWORD?.trim();
-        if (!email || !password) {
-          finish(ExitCode.misconfiguration, {
-            ok: false,
-            error: "CI auth: set EASYSPECS_EMAIL and EASYSPECS_PASSWORD"
-          });
-        }
-        const base = apiResolved;
-        if (!base) {
-          finish(ExitCode.misconfiguration, { ok: false, error: "apiBaseUrl missing" });
+      const tailFull = pos.slice(2);
+      let sessionPathRaw;
+      let tailForCreds;
+      try {
+        const extracted = extractAuthLoginSessionPathFromTail(tailFull);
+        tailForCreds = extracted.rest;
+        sessionPathRaw = extracted.sessionPath;
+      } catch (e) {
+        logErr(flags, e instanceof Error ? e.message : String(e));
+        process.exit(ExitCode.usage);
+      }
+      const parsedCli = parseAuthLoginTail(tailForCreds);
+      const envEmail = process.env.EASYSPECS_EMAIL?.trim();
+      const envPassword = process.env.EASYSPECS_PASSWORD?.trim();
+      const useLegacyCiEnv = !parsedCli.ok && (flags.ci || tailFull.includes("--ci")) && Boolean(envEmail) && Boolean(envPassword);
+      let email;
+      let password;
+      if (parsedCli.ok) {
+        email = parsedCli.creds.email;
+        password = parsedCli.creds.password;
+      } else if (useLegacyCiEnv) {
+        email = envEmail;
+        password = envPassword;
+      } else {
+        logErr(flags, parsedCli.error);
+        logErr(
+          flags,
+          "Usage: easyspecs-cli auth login --email <email> --password <password> [--session-path <path>]"
+        );
+        logErr(
+          flags,
+          "Legacy: easyspecs-cli --ci auth login  (requires EASYSPECS_EMAIL and EASYSPECS_PASSWORD)"
+        );
+        process.exit(ExitCode.usage);
+      }
+      if (sessionPathRaw !== void 0) {
+        const stored = normalizeCliSessionPathForConfig(repoRoot, sessionPathRaw);
+        const updatedCfg = updateEasyspecsConfig(
+          repoRoot,
+          { easyspecs: { cliSessionPath: stored } },
+          { warnMigration: (m) => logErr(flags, `[EasySpecs] ${m}`) }
+        );
+        applyCliSessionPathFromRepoConfig(repoRoot, updatedCfg);
+      }
+      const base = apiResolved;
+      if (!base) {
+        if (!flags.json) {
+          console.error("KO: apiBaseUrl missing (set easyspecs.apiBaseUrl or use --api-base-url / --environment)");
         }
+        finish(ExitCode.misconfiguration, {
+          ok: false,
+          error: "apiBaseUrl missing",
+          outcome: "KO"
+        });
+      }
+      try {
         const tokens = await loginWithApi(base, fetch, email, password);
         writeCliSession({
           apiBaseUrl: base,
           accessToken: tokens.accessToken,
           refreshToken: tokens.refreshToken
         });
-        finish(ExitCode.ok, { ok: true, message: "Logged in." });
+        if (!flags.json) {
+          console.log("OK");
+        }
+        finish(ExitCode.ok, { ok: true, outcome: "OK", message: "Logged in." });
+      } catch (e) {
+        const err = toFetchErrorMessage(e);
+        const detail = err.message || "Login failed.";
+        if (!flags.json) {
+          console.error(`KO: ${detail}`);
+        }
+        finish(ExitCode.auth, {
+          ok: false,
+          outcome: "KO",
+          error: detail,
+          status: err.status
+        });
       }
-      finish(ExitCode.misconfiguration, {
-        ok: false,
-        error: "Interactive auth not implemented; use --ci with EASYSPECS_EMAIL / EASYSPECS_PASSWORD"
-      });
     }
-    if (pos[0] === "analyze" && (pos.length === 1 || pos[1] === "run")) {
+    if (pos[0] === "run" && pos[1] === "synthesis" && pos[2] === "resume-missing") {
+      const storage = createFileBackedWorkspaceState(repoRoot);
+      const { worktree } = parseWorktreeFlag(pos.slice(3));
+      const analysisRoot = resolveAdHocCheckoutRoot(repoRoot, storage, worktree);
+      const poolRes = await runResumeRemediationPool(storage, repoRoot, analysisRoot, merged, flags);
+      if (poolRes.cancelled) {
+        finish(ExitCode.cancelled, { ok: false, error: "Remediation cancelled.", analysisWorktreePath: analysisRoot });
+      }
+      if (!poolRes.indexOk) {
+        finish(ExitCode.validation, {
+          ok: false,
+          error: poolRes.indexError ?? "Index failed after remediation.",
+          analysisWorktreePath: analysisRoot
+        });
+      }
+      finish(ExitCode.ok, { ok: true, analysisWorktreePath: analysisRoot });
+    }
+    if (pos[0] === "run" && pos[1] === "synthesis" && pos[2] === "resume-synthesis") {
+      const storage = createFileBackedWorkspaceState(repoRoot);
+      const { worktree } = parseWorktreeFlag(pos.slice(3));
+      const analysisRoot = resolveAdHocCheckoutRoot(repoRoot, storage, worktree);
+      const poolRes = await runResumeRemediationPool(storage, repoRoot, analysisRoot, merged, flags);
+      if (poolRes.cancelled) {
+        finish(ExitCode.cancelled, { ok: false, error: "Remediation cancelled.", analysisWorktreePath: analysisRoot });
+      }
+      if (!poolRes.indexOk) {
+        finish(ExitCode.validation, {
+          ok: false,
+          error: poolRes.indexError ?? "Index failed after remediation.",
+          analysisWorktreePath: analysisRoot
+        });
+      }
+      finish(ExitCode.ok, { ok: true, analysisWorktreePath: analysisRoot });
+    }
+    if (pos[0] === "run" && pos[1] === "synthesis" && pos.length === 2) {
       requireOpenCode(merged, flags);
       const agentsDir = resolveOpenCodeAgentsDir();
       assertAgentsDirExists(agentsDir);
@@ -19271,7 +20009,7 @@ async function main() {
         }
         finish(result.cancelled ? ExitCode.cancelled : ExitCode.validation, {
           ok: false,
-          error: result.error ?? "analyze failed",
+          error: result.error ?? "run synthesis failed",
           cancelled: result.cancelled === true,
           analysisWorktreePath: result.retainedWorktree?.path,
           adHocRepositoryRoot: result.retainedWorktree?.repoRoot
@@ -19400,7 +20138,7 @@ async function main() {
       }
       finish(ExitCode.usage, { ok: false, error: `Unknown diagnose subcommand: ${sub ?? ""}` });
     }
-    if (pos[0] === "pipeline" && pos[1] === "macro") {
+    if (pos[0] === "analysis") {
       requireOpenCode(merged, flags);
       const synthesisOnly = positionals.includes("--synthesis-only");
       const wantsUpload = positionals.includes("--upload");
@@ -19408,7 +20146,7 @@ async function main() {
       if (wantsUpload && !uploadSession) {
         finish(ExitCode.auth, {
           ok: false,
-          error: "pipeline macro --upload requires `easyspecs-cli auth login` (CI: EASYSPECS_EMAIL/PASSWORD)."
+          error: "analysis --upload requires `easyspecs-cli auth login --email \u2026 --password \u2026` (or legacy `--ci` + EASYSPECS_EMAIL/PASSWORD)."
         });
       }
       const skipBackendSync = !wantsUpload;
@@ -19424,9 +20162,12 @@ async function main() {
           return { ok: false, message: "No worktree context to upload." };
         }
         const target = readUploadTargetFile(wtContextDir) ?? readUploadTargetFile(wsContextDir);
-        const appId = target?.application_id?.trim() || process.env.EASYSPECS_APPLICATION_ID?.trim();
+        const appId = target?.application_id?.trim() || repoConfig.easyspecs?.easyspecsProjectId?.trim() || process.env.EASYSPECS_APPLICATION_ID?.trim();
         if (!appId) {
-          return { ok: false, message: "Missing application_id in easyspecs-upload-target.json" };
+          return {
+            ok: false,
+            message: "Missing application_id in easyspecs-upload-target.json or easyspecs.easyspecsProjectId in .easyspecs/config.json"
+          };
         }
         let access = s.accessToken;
         const refresh = s.refreshToken;
@@ -19486,7 +20227,10 @@ async function main() {
     if (pos[0] === "upload" && (pos[1] === "context" || pos[1] === "republish")) {
       const sessRaw = readCliSession();
       if (sessRaw === void 0) {
-        finish(ExitCode.auth, { ok: false, error: "auth login first (--ci with EASYSPECS_EMAIL/PASSWORD)" });
+        finish(ExitCode.auth, {
+          ok: false,
+          error: "auth login first (`auth login --email \u2026 --password \u2026`, or legacy `--ci` + env)"
+        });
       }
       const sess = sessRaw;
       let ctxDir = path43.join(repoRoot, ".gluecharm", "context");
@@ -19501,16 +20245,19 @@ async function main() {
           if (!wt) {
             finish(ExitCode.misconfiguration, {
               ok: false,
-              error: "upload republish requires an analysis worktree with .gluecharm/context (run analyze first), or set EASYSPECS_UPLOAD_CONTEXT_DIR."
+              error: "upload republish requires an analysis worktree with .gluecharm/context (`easyspecs-cli run synthesis` first), or set EASYSPECS_UPLOAD_CONTEXT_DIR."
             });
           }
           ctxDir = wt;
         }
       }
       const target = readUploadTargetFile(ctxDir);
-      const appIdRaw = target?.application_id?.trim() || process.env.EASYSPECS_APPLICATION_ID?.trim();
+      const appIdRaw = target?.application_id?.trim() || repoConfig.easyspecs?.easyspecsProjectId?.trim() || process.env.EASYSPECS_APPLICATION_ID?.trim();
       if (!appIdRaw) {
-        finish(ExitCode.misconfiguration, { ok: false, error: "Missing application_id in easyspecs-upload-target.json" });
+        finish(ExitCode.misconfiguration, {
+          ok: false,
+          error: "Missing application_id in easyspecs-upload-target.json or easyspecs.easyspecsProjectId in .easyspecs/config.json"
+        });
       }
       const applicationId = appIdRaw;
       let access = sess.accessToken;
@@ -19617,40 +20364,6 @@ async function main() {
         cancelled: pool.cancelled
       });
     }
-    if (pos[0] === "analyze" && pos[1] === "resume-missing") {
-      const storage = createFileBackedWorkspaceState(repoRoot);
-      const { worktree } = parseWorktreeFlag(pos.slice(2));
-      const analysisRoot = resolveAdHocCheckoutRoot(repoRoot, storage, worktree);
-      const poolRes = await runResumeRemediationPool(storage, repoRoot, analysisRoot, merged, flags);
-      if (poolRes.cancelled) {
-        finish(ExitCode.cancelled, { ok: false, error: "Remediation cancelled.", analysisWorktreePath: analysisRoot });
-      }
-      if (!poolRes.indexOk) {
-        finish(ExitCode.validation, {
-          ok: false,
-          error: poolRes.indexError ?? "Index failed after remediation.",
-          analysisWorktreePath: analysisRoot
-        });
-      }
-      finish(ExitCode.ok, { ok: true, analysisWorktreePath: analysisRoot });
-    }
-    if (pos[0] === "analyze" && pos[1] === "resume-synthesis") {
-      const storage = createFileBackedWorkspaceState(repoRoot);
-      const { worktree } = parseWorktreeFlag(pos.slice(2));
-      const analysisRoot = resolveAdHocCheckoutRoot(repoRoot, storage, worktree);
-      const poolRes = await runResumeRemediationPool(storage, repoRoot, analysisRoot, merged, flags);
-      if (poolRes.cancelled) {
-        finish(ExitCode.cancelled, { ok: false, error: "Remediation cancelled.", analysisWorktreePath: analysisRoot });
-      }
-      if (!poolRes.indexOk) {
-        finish(ExitCode.validation, {
-          ok: false,
-          error: poolRes.indexError ?? "Index failed after remediation.",
-          analysisWorktreePath: analysisRoot
-        });
-      }
-      finish(ExitCode.ok, { ok: true, analysisWorktreePath: analysisRoot });
-    }
     printHelp();
     finish(ExitCode.usage, { ok: false, error: `unknown command: ${cmd}` });
   } catch (e) {