@aiwg/cli 2026.10.3 → 2026.10.4

package/dist/src/mcp/tools/worker-shell-control.mjs

@@ -1,4 +1,6 @@
+import { signalChild } from '../../process/signal-child.mjs';
 import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { promisify } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
 import path from 'node:path';
@@ -29,7 +31,7 @@ async function execCanonicalSystemctl(exec, args, options) {
 
 /** Parse only explicit stop proof. Missing/unknown properties are observation
  * failures, never evidence of termination. A collected unit has no exit result. */
-export function parseShellUnitStatus(stdout) {
+export function parseShellUnitStatus(stdout, { stopAccepted = false } = {}) {
   const fields = Object.fromEntries(String(stdout).split('\n').filter(line => line.includes('='))
     .map(line => { const at = line.indexOf('='); return [line.slice(0, at), line.slice(at + 1)]; }));
   if (fields.LoadState === 'not-found' && fields.ActiveState === 'inactive' && fields.MainPID === '0') {
@@ -42,17 +44,31 @@ export function parseShellUnitStatus(stdout) {
     throw new Error('worker status unavailable: missing or invalid systemd properties');
   }
   if (!['inactive', 'failed'].includes(fields.ActiveState) || fields.MainPID !== '0') return uncertain();
+  // An inactive unit may still have a queued start. Only an accepted stop
+  // followed by this fresh observation can prove a never-executed unit ended.
+  if (fields.ExecMainCode === '0' && stopAccepted) {
+    return { termination: 'confirmed', exitCode: null, neverExecuted: true };
+  }
+  if (!['1', '2', '3'].includes(fields.ExecMainCode)) return uncertain();
   const signaled = ['2', '3'].includes(fields.ExecMainCode);
-  return { termination: 'confirmed', exitCode: fields.Result === 'success' && !signaled
+  return { termination: 'confirmed', nativeResult: fields.Result, exitCode: fields.Result === 'success' && !signaled
     ? Number(fields.ExecMainStatus) : Number(fields.ExecMainStatus) || 1,
   ...(signaled ? { signalCode: Number(fields.ExecMainStatus) } : {}) };
 }
 
+function boundedDeadline(deadlineMs, deadlineAtMs, now) {
+  if (deadlineAtMs !== undefined && (!Number.isFinite(deadlineAtMs)
+    || (deadlineAtMs >= 1e12) !== (now >= 1e12))) {
+    throw new RangeError('Worker deadlineAtMs must use the same clock as nowMs (or clock); supply the matching clock');
+  }
+  return Math.min(deadlineAtMs ?? Infinity, now + deadlineMs);
+}
+
 export async function waitForUnitTermination(unit, deadlineMs, { signal, pollIntervalMs = 2000,
   exec = execFileAsync, sleep = (ms, abortSignal) => delay(ms, undefined, { signal: abortSignal }),
-  clock = Date.now } = {}) {
+  clock = () => performance.now(), deadlineAtMs, stopAccepted = false } = {}) {
   if (typeof unit !== 'string' || !/^[A-Za-z0-9:_.@-]+$/.test(unit)) throw new Error('Worker isolation requires a unit-safe unit name');
-  const deadline = clock() + deadlineMs;
+  const deadline = boundedDeadline(deadlineMs, deadlineAtMs, clock());
   while (!signal?.aborted && clock() < deadline) {
     try {
       const { stdout } = await execCanonicalSystemctl(exec,
@@ -61,7 +77,7 @@ export async function waitForUnitTermination(unit, deadlineMs, { signal, pollInt
         // overall grace/deadline even when a probe is still in flight.
         { timeout: Math.max(1000, Math.min(10000, deadline - clock())), signal });
       if (signal?.aborted) return uncertain();
-      const outcome = parseShellUnitStatus(stdout);
+      const outcome = parseShellUnitStatus(stdout, { stopAccepted });
       if (outcome.termination === 'confirmed') return outcome;
     } catch (error) {
       // systemctl may return nonzero for a collected unit while still showing
@@ -86,7 +102,8 @@ export async function waitForUnitTermination(unit, deadlineMs, { signal, pollInt
  * after leader reap to limit (not eliminate) the PGID reuse race. */
 export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermination,
   stopUnit = defaultStopShellUnit, killUnit = defaultKillShellUnit, graceMs,
-  onConfirmed, platform = process.platform, recheckMaxAttempts = 6, recheckDelayMs = 250 }) {
+  onConfirmed, platform = process.platform, recheckMaxAttempts = 6, recheckDelayMs = 250,
+  nowMs = () => performance.now() }) {
   let closed = false;
   let exitCode = null;
   let signalCode = null;
@@ -94,6 +111,7 @@ export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermina
   let stopTask;
   let delivery;
   let stopped = false;
+  let stopAccepted = false;
   let recheckTimer;
   let rechecks = 0;
   let disposed = false;
@@ -101,11 +119,21 @@ export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermina
   let resolveClose;
   const probes = new Set();
   const child = launch.child;
-  const ownedGroup = platform !== 'win32' && launch.ownedGroup && child?.pid;
+  const ownedGroup = platform !== 'win32' && launch.ownedGroup;
   const closeProof = new Promise(resolve => { resolveClose = resolve; });
 
+  function safeGroupTarget() {
+    if (!Number.isSafeInteger(child?.pid) || child.pid <= 1 || child.pid === process.pid) return false;
+    if (platform !== 'linux') return true;
+    try {
+      const stat = readFileSync('/proc/self/stat', 'utf8');
+      const pgid = Number(stat.slice(stat.lastIndexOf(')') + 2).split(/\s+/)[2]);
+      return Number.isSafeInteger(pgid) && child.pid !== pgid;
+    } catch { return false; }
+  }
   function groupGone() {
     if (!ownedGroup) return true;
+    if (!safeGroupTarget()) return false;
     try { process.kill(-child.pid, 0); return false; } catch (error) { return error.code === 'ESRCH'; }
   }
   function confirm(outcome) {
@@ -128,10 +156,10 @@ export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermina
     if (groupGone()) confirm({ termination: 'confirmed', exitCode, signalCode });
     else void control.stop(); // descendants outlived their leader
   }
-  function onError() {
+  function onError(error) {
     // A pid-bearing child error is an observation failure, not a deadline.
     // ENOENT has no pid and cannot have started a worker.
-    if (!child?.pid && launch.mode !== 'systemd-unit') confirm({ termination: 'confirmed', exitCode: null });
+    if (!child?.pid && launch.mode !== 'systemd-unit') confirm({ termination: 'confirmed', exitCode: null, errorCode: error?.code ?? 'SPAWN_ERROR' });
   }
   child?.once('close', onClose);
   child?.on('error', onError);
@@ -155,10 +183,11 @@ export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermina
       abort.abort(); // cancel a losing poll or execFile, including its sleep
     }
   }
-  async function waitStopped(ms) {
+  async function waitStopped(ms, deadline) {
     if (confirmed) return confirmed;
     if (launch.mode === 'systemd-unit') {
-      const outcome = await bounded(signal => waitForUnit(launch.unit, ms, { signal }), ms);
+      const outcome = await bounded(signal => waitForUnit(launch.unit, ms, { signal, stopAccepted,
+        ...(deadline ? { deadlineAtMs: deadline.at, clock: deadline.now } : {}) }), ms);
       return outcome.termination === 'confirmed' ? confirm(outcome) : outcome;
     }
     if (closed && groupGone()) return confirm({ termination: 'confirmed', exitCode, signalCode });
@@ -181,15 +210,17 @@ export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermina
       if (launch.mode === 'systemd-unit') {
         const result = await bounded(abortSignal => (signalName === 'SIGTERM' ? stopUnit : killUnit)(launch.unit,
           { signal: abortSignal, timeout: Math.max(1, budgetMs) }), budgetMs);
+        if (signalName === 'SIGTERM' && result.ok) stopAccepted = true;
         return !!result.ok;
       }
       if (ownedGroup) {
+        if (!safeGroupTarget()) return false;
         if ((closed || child.exitCode != null || child.signalCode != null) && groupSwept) return false;
         if (signalName === 'SIGKILL') groupSwept = true;
         process.kill(-child.pid, signalName);
         return true;
       }
-      return !closed && !!child?.kill(signalName);
+      return !closed && !!signalChild(child, signalName);
     } catch { return false; }
   }
   const control = {
@@ -205,15 +236,15 @@ export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermina
       if (stopTask) return delivery;
       stopped = true;
       const phaseMs = launch.mode === 'systemd-unit' ? Math.max(1000, graceMs) : graceMs;
-      let phaseEnd = Date.now() + phaseMs;
+      let phaseEnd = nowMs() + phaseMs;
       delivery = signal('SIGTERM', phaseMs);
       stopTask = (async () => {
         await delivery;
-        let outcome = await waitStopped(Math.max(0, phaseEnd - Date.now()));
+        let outcome = await waitStopped(Math.max(0, phaseEnd - nowMs()));
         if (outcome.termination !== 'confirmed') {
-          phaseEnd = Date.now() + phaseMs;
+          phaseEnd = nowMs() + phaseMs;
           await signal('SIGKILL', phaseMs);
-          outcome = await waitStopped(Math.max(0, phaseEnd - Date.now()));
+          outcome = await waitStopped(Math.max(0, phaseEnd - nowMs()));
         }
         if (outcome.termination !== 'confirmed') recheck();
         return outcome;
@@ -224,16 +255,16 @@ export function buildShellStopControl(launch, { waitForUnit = waitForUnitTermina
       await control.stop();
       return confirmed ?? (stopTask ? await stopTask : uncertain());
     },
-    wait: async deadlineMs => {
-      const deadline = Date.now() + deadlineMs;
+    wait: async (deadlineMs, { deadlineAtMs, nowMs: waitNow = nowMs } = {}) => {
+      const deadline = boundedDeadline(deadlineMs, deadlineAtMs, waitNow());
       let outcome;
       do {
-        outcome = await waitStopped(Math.max(0, deadline - Date.now()));
+        outcome = await waitStopped(Math.max(0, deadline - waitNow()), { at: deadline, now: waitNow });
         if (confirmed) return confirmed;
         // Observation failure alone never mandates a stop. Avoid a hot loop
         // when an injected/failed observer returns immediately.
-        if (!outcome.timedOut) await Promise.race([closeProof, delay(Math.min(50, Math.max(0, deadline - Date.now())))]);
-      } while (!disposed && !outcome.timedOut && Date.now() < deadline);
+        if (!outcome.timedOut) await Promise.race([closeProof, delay(Math.min(50, Math.max(0, deadline - waitNow())))]);
+      } while (!disposed && !outcome.timedOut && waitNow() < deadline);
       if (disposed) return uncertain();
       return { ...await control.stopAndConfirm(), timedOut: true };
     },

package/dist/src/mcp/tools/worker-stdin-runtime.mjs

@@ -10,7 +10,7 @@ export async function sweepWorkerStdin(root = tmpdir(), { staleMs = 86400000, no
   try {
     for (const name of await readdir(root)) {
       const match = /^aiwg-worker-stdin-(\d+)-[A-Za-z0-9]+$/.exec(name);
-      if (!match || isAlive(Number(match[1]))) continue;
+      if (!match || !Number.isSafeInteger(Number(match[1])) || Number(match[1]) <= 0 || isAlive(Number(match[1]))) continue;
       const directory = path.join(root, name);
       try {
         const stat = await lstat(directory);
@@ -40,7 +40,7 @@ export async function prepareWorkerStdin(bytes, root = tmpdir()) {
 }
 
 export async function launchPreparedShellWorker(invocation, { allowDegraded, config, name, live, readers, thresholdOverlay,
-  memoryMaxGb, driver, servedRoot, isolation, spawn, spawnAsync, stdinRuntimeRoot },
+  memoryMaxGb, driver, servedRoot, isolation, spawn, spawnAsync, stdinRuntimeRoot, admission, invocationId, dispatchGuard },
   { loadRalphExternal, readBoundedFile, importImpl, describeGateFailures }) {
   let attempt;
   let cleanup = () => Promise.resolve();
@@ -58,7 +58,7 @@ export async function launchPreparedShellWorker(invocation, { allowDegraded, con
       ({ stdinPath, cleanup } = await prepareWorkerStdin(bytes, stdinRuntimeRoot));
     }
     const launch = await planDirectWorkerLaunch({ invocation, config, allowDegraded, name, live, readers,
-      thresholdOverlay, memoryMaxGb, stdinPath, ownedGroup: true, isolation,
+      thresholdOverlay, memoryMaxGb, stdinPath, ownedGroup: true, isolation, admission, invocationId, dispatchGuard,
       spawn, spawnAsync, onSpawnAttempt: value => {
         attempt = value;
         value.child?.once('close', (exitCode, signalCode) => { Object.assign(value, { closed: true, exitCode, signalCode }); });

package/dist/src/mission-protocol/codecs.js

@@ -410,6 +410,14 @@ export function assertWorkerTerminal(observation) {
         throw new WorkerContractError('OG_CONTRACT_INVALID', 'Worker terminal evidence is missing, erroneous or uncertain; exit zero alone is insufficient.');
     }
 }
+export function assertWorkerAttemptTerminal(observation) {
+    if (!observation || !['shell', 'mcp'].includes(observation.transport)
+        || observation.status !== 'completed' || observation.attemptOutcome !== 'succeeded'
+        || (observation.transport === 'shell' ? observation.exitCode !== 0 : observation.exitCode !== null && observation.exitCode !== 0)
+        || (observation.isError !== undefined && observation.isError !== false)) {
+        throw new WorkerContractError('OG_CONTRACT_INVALID', 'Worker attempt evidence is missing, erroneous or uncertain; exit zero alone is insufficient.');
+    }
+}
 /**
  * Assemble detached, immutable evidence from separately attributed producers.
  * artifactBytes are read by the conductor from the exact artifact (or protected

package/dist/src/models/config-loader.js

@@ -6,9 +6,11 @@
  * @architecture @.aiwg/architecture/enhanced-model-selection-design.md
  */
 import { readFile } from 'fs/promises';
-import { resolve } from 'path';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'node:url';
 import { homedir } from 'os';
 import { existsSync } from 'fs';
+import { findPackageRoot } from '../cli/find-package-root.js';
 import { workerConfigDigest, validateWorkerGroupReferences } from '../config/aiwg-config.js';
 import { DEFAULT_WORKER_SELECTION, mergeWorkerSelection, WorkerSelectionPolicySchema, validateUserProjectModelConfig } from './provider-policy.js';
 /**
@@ -20,7 +22,10 @@ export class ConfigLoader {
     inputDigests = null;
     locations;
     constructor(projectPath, options) {
-        const aiwgHome = options?.aiwgHome || process.env.AIWG_HOME || resolve(homedir(), '.local/share/ai-writing-guide');
+        const aiwgHome = options?.aiwgHome || process.env.AIWG_HOME
+            || findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+        if (!aiwgHome)
+            throw new Error('Failed to load AIWG default config: could not locate the running AIWG package root');
         const userConfigDir = process.env.AIWG_CONFIG || resolve(homedir(), '.config/aiwg');
         this.locations = {
             aiwgDefault: resolve(aiwgHome, 'agentic/code/frameworks/sdlc-complete/config/models-v2.json'),

package/dist/src/models/model-capabilities.v1.json

@@ -208,6 +208,28 @@
       }
     },
     "claude": {
+      "sessionEnvAllowlist": [
+        "ANTHROPIC_API_KEY",
+        "ANTHROPIC_AUTH_TOKEN",
+        "ANTHROPIC_BASE_URL",
+        "ANTHROPIC_MODEL",
+        "CLAUDE_CONFIG_DIR",
+        "CLAUDE_CODE_OAUTH_TOKEN",
+        "CLAUDE_CODE_DISABLE_1M_CONTEXT",
+        "CLAUDE_CODE_USE_BEDROCK",
+        "CLAUDE_CODE_USE_VERTEX",
+        "AWS_PROFILE",
+        "AWS_REGION",
+        "AWS_DEFAULT_REGION",
+        "AWS_ACCESS_KEY_ID",
+        "AWS_SECRET_ACCESS_KEY",
+        "AWS_SESSION_TOKEN",
+        "AWS_CONFIG_FILE",
+        "AWS_SHARED_CREDENTIALS_FILE",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+        "ANTHROPIC_VERTEX_PROJECT_ID",
+        "CLOUD_ML_REGION"
+      ],
       "agent": "native",
       "skill": "native",
       "globalChild": "inherited",
@@ -429,6 +451,14 @@
       }
     },
     "codex": {
+      "sessionEnvAllowlist": [
+        "OPENAI_API_KEY",
+        "CODEX_API_KEY",
+        "OPENAI_BASE_URL",
+        "OPENAI_ORG_ID",
+        "OPENAI_PROJECT_ID",
+        "CODEX_HOME"
+      ],
       "agent": "native",
       "skill": "unsupported",
       "globalChild": "inherited",
@@ -452,7 +482,7 @@
         "id": "codex",
         "provider": "codex",
         "adapterVersion": "1",
-        "supportedVersions": "0.161.0",
+        "supportedVersions": ">=0.161.0 <0.200.0",
         "runtimeDriver": "installed:codex",
         "catalogAdapter": {
           "kind": "file",
@@ -513,7 +543,7 @@
         "invocationProfiles": {
           "direct-shell": {
             "transport": "shell",
-            "supportedVersions": "0.161.0",
+            "supportedVersions": ">=0.161.0 <0.200.0",
             "controls": {
               "model": {
                 "support": "unqualified",
@@ -640,6 +670,12 @@
       }
     },
     "copilot": {
+      "sessionEnvAllowlist": [
+        "COPILOT_GITHUB_TOKEN",
+        "GH_TOKEN",
+        "GITHUB_TOKEN",
+        "COPILOT_HOME"
+      ],
       "agent": "native",
       "skill": "unsupported",
       "globalChild": "inherited",
@@ -1025,6 +1061,9 @@
       }
     },
     "factory": {
+      "sessionEnvAllowlist": [
+        "FACTORY_API_KEY"
+      ],
       "agent": "native",
       "skill": "informational",
       "globalChild": "native",
@@ -1220,6 +1259,23 @@
       }
     },
     "opencode": {
+      "sessionEnvAllowlist": [
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "OPENROUTER_API_KEY",
+        "GROQ_API_KEY",
+        "MISTRAL_API_KEY",
+        "XAI_API_KEY",
+        "DEEPSEEK_API_KEY",
+        "OPENCODE_API_KEY",
+        "OPENCODE_CONFIG",
+        "OPENCODE_CONFIG_DIR",
+        "OPENCODE_CONFIG_CONTENT",
+        "OPENCODE_SERVER_USERNAME",
+        "OPENCODE_SERVER_PASSWORD"
+      ],
       "agent": "native",
       "skill": "unsupported",
       "globalChild": "inherited",
@@ -1596,6 +1652,19 @@
       }
     },
     "omp": {
+      "sessionEnvAllowlist": [
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "OPENROUTER_API_KEY",
+        "GROQ_API_KEY",
+        "MISTRAL_API_KEY",
+        "XAI_API_KEY",
+        "DEEPSEEK_API_KEY",
+        "PI_CONFIG_DIR",
+        "PI_CODING_AGENT_DIR"
+      ],
       "agent": "native",
       "skill": "inherited",
       "globalChild": "native",
@@ -1796,6 +1865,21 @@
       }
     },
     "pi": {
+      "sessionEnvAllowlist": [
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "OPENROUTER_API_KEY",
+        "GROQ_API_KEY",
+        "MISTRAL_API_KEY",
+        "XAI_API_KEY",
+        "DEEPSEEK_API_KEY",
+        "PI_CODING_AGENT_DIR",
+        "PI_CODING_AGENT_SESSION_DIR",
+        "AIWG_PI_STUB_SCENARIO",
+        "AIWG_PI_STUB_RECEIPT"
+      ],
       "agent": "native",
       "skill": "inherited",
       "globalChild": "native",
@@ -1992,6 +2076,10 @@
       }
     },
     "deepseek-harness": {
+      "sessionEnvAllowlist": [
+        "DEEPSEEK_API_KEY",
+        "DSH_HOME"
+      ],
       "agent": "native",
       "skill": "inherited",
       "globalChild": "native",
@@ -3001,6 +3089,10 @@
       }
     },
     "muse": {
+      "sessionEnvAllowlist": [
+        "AIWG_MUSE_STUB_SCENARIO",
+        "AIWG_MUSE_STUB_RECEIPT"
+      ],
       "agent": "unsupported",
       "skill": "unsupported",
       "globalChild": "informational",
@@ -3027,7 +3119,7 @@
         "id": "muse",
         "provider": "muse",
         "adapterVersion": "1",
-        "supportedVersions": "1.4.4-R5419.1",
+        "supportedVersions": ">=1.4.4-R5419.1 <2.0.0",
         "runtimeDriver": "tools/ralph-external/lib/muse-adapter.mjs",
         "catalogAdapter": {
           "kind": "file",
@@ -3087,7 +3179,7 @@
         "invocationProfiles": {
           "direct-shell": {
             "transport": "shell",
-            "supportedVersions": "1.4.4-R5419.1",
+            "supportedVersions": ">=1.4.4-R5419.1 <2.0.0",
             "controls": {
               "model": {
                 "support": "unqualified",

package/dist/src/models/model-discovery.js

@@ -1,3 +1,4 @@
+import { signalChild } from '../process/signal-child.mjs';
 import { hasSelectionRelevantConflicts, validateWorkerCatalogDiscovery } from './provider-policy.js';
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
@@ -6,6 +7,7 @@ import { lstat, mkdir, open, readFile, readdir, realpath, rename, writeFile } fr
 import { dirname, join, relative } from 'node:path';
 import { constants } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
+import { stripVTControlCharacters } from 'node:util';
 export const PROVIDER_DISCOVERY_DECISIONS = {
     claude: {
         provider: 'claude',
@@ -125,6 +127,12 @@ export const PROVIDER_DISCOVERY_DECISIONS = {
 };
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 export function classifyDiscoveryError(message) {
+    message = stripVTControlCharacters(message);
+    if (/\b(?:EROFS|EACCES|EPERM)\b|read-only file system/i.test(message)
+        || (/FileSystem\.open|permission denied|operation not permitted/i.test(message)
+            && /[\\/]opencode[\\/]log[\\/]|[\\/]\.pi[\\/]agent(?:[\\/]|$)/i.test(message))) {
+        return 'environment';
+    }
     if (/(?:401|403|unauth|forbidden|credential|login|required auth)/i.test(message)) {
         return 'authentication';
     }
@@ -138,7 +146,7 @@ const SECRET_ASSIGNMENT = /((?:api[_-]?key|authorization|token|secret|password|c
 const BEARER_SECRET = /(bearer\s+)[A-Za-z0-9._~+/=-]+/gi;
 /** Keep native diagnostics useful without ever echoing credential material. */
 export function redactModelDiscoveryText(value) {
-    return value
+    return stripVTControlCharacters(value)
         .replace(SECRET_ASSIGNMENT, '$1[REDACTED]')
         .replace(BEARER_SECRET, '$1[REDACTED]')
         .slice(0, 4096);
@@ -162,7 +170,7 @@ export const runModelDiscoveryCommand = (command, args, options = {}) => new Pro
     child.stdout.on('data', chunk => { stdout += String(chunk); if (Buffer.byteLength(stdout) > 8 * 1024 * 1024) {
         stdout = '';
         stderr = 'Model catalog exceeded 8 MiB limit';
-        child.kill('SIGKILL');
+        signalChild(child, 'SIGKILL');
         finish(1);
     } });
     child.stderr.on('data', chunk => { stderr = (stderr + String(chunk)).slice(-4096); });
@@ -173,7 +181,7 @@ export const runModelDiscoveryCommand = (command, args, options = {}) => new Pro
     child.on('close', code => finish(code ?? 1));
     const timer = setTimeout(() => {
         stderr = `${stderr}${stderr ? '\n' : ''}${command} timed out`;
-        child.kill();
+        signalChild(child);
         finish(124);
     }, options.timeoutMs ?? 10_000);
 });
@@ -450,7 +458,7 @@ export async function discoverCodexModels(command = 'codex', timeoutMs = 10_000,
             settled = true;
             clearTimeout(timer);
             lines.close();
-            child.kill();
+            signalChild(child);
             resolveDiscovery(result);
         };
         child.stderr.on('data', chunk => { stderr = (stderr + String(chunk)).slice(-4096); });
@@ -656,6 +664,8 @@ export async function resolveDynamicModelCatalog(options) {
                 };
             }
             const next = providerDiscovery[provider];
+            if (next.error)
+                next.error = stripVTControlCharacters(next.error);
             const instanceId = discoveryInstanceId(next);
             const prior = cached?.discovery?.instances?.[instanceId]
                 ?? cached?.discovery?.providers[provider];
@@ -967,6 +977,30 @@ function validTimestamp(value) {
     return typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/i.test(value)
         && validDate(value.slice(0, 10)) && Number.isFinite(Date.parse(value));
 }
+/** Use the active window, capped by the reported maximum, with native headroom. */
+function codexContextTokens(row) {
+    const window = normalizePositiveInt(row.context_window);
+    const maximum = normalizePositiveInt(row.max_context_window);
+    const percent = row.effective_context_window_percent;
+    // A malformed supplied limit must not silently enlarge the qualified window.
+    if (window === null || row.max_context_window != null && maximum === null
+        || percent != null && (typeof percent !== 'number' || !Number.isFinite(percent) || percent <= 0 || percent > 100))
+        return null;
+    return normalizePositiveInt(Math.floor(Math.min(window, maximum ?? window) * (typeof percent === 'number' ? percent : 100) / 100));
+}
+function catalogEfforts(ids, raw) {
+    return ids.map(id => {
+        const entry = Array.isArray(raw) ? raw.find(value => value && typeof value === 'object'
+            && (value.effort ?? value.tier) === id) : undefined;
+        // Conductor-verified Codex/Muse catalog rule (#3083): only ultra is
+        // "Maximum reasoning with automatic task delegation". Prefer that explicit
+        // description when present; other listed levels do not self-delegate.
+        // multi_agent_reasoning_effort/version describe child execution, not which
+        // selected effort activates delegation (e.g. xhigh is not self-delegating).
+        return { id, selfDelegates: id === 'ultra'
+                || typeof entry?.description === 'string' && /automatic task delegation/i.test(entry.description) };
+    });
+}
 function normalizeObservationRows(rows, options, cli) {
     const diagnostics = [];
     const models = [];
@@ -987,12 +1021,17 @@ function normalizeObservationRows(rows, options, cli) {
             continue;
         }
         const times = observationTimestamps(sourceOptions);
-        for (const field of [cli === 'muse' ? 'context_limit' : 'context_window', 'output_limit']) {
+        for (const field of [...(cli === 'muse' ? ['context_limit'] : ['context_window', 'max_context_window']), 'output_limit']) {
             if (row[field] != null && (typeof row[field] !== 'number' || !Number.isSafeInteger(row[field]) || row[field] < 1)) {
                 diagnostics.push(`${source}: malformed ${field} for ${id}; retained as unknown`);
                 // Do not round or coerce malformed evidence into a valid observation.
             }
         }
+        if (cli === 'codex' && row.effective_context_window_percent != null
+            && (typeof row.effective_context_window_percent !== 'number' || !Number.isFinite(row.effective_context_window_percent)
+                || row.effective_context_window_percent <= 0 || row.effective_context_window_percent > 100)) {
+            diagnostics.push(`${source}: malformed effective_context_window_percent for ${id}; context retained as unknown`);
+        }
         for (const field of ['is_default', 'is_current', 'retired', 'deprecated']) {
             if (row[field] != null && typeof row[field] !== 'boolean')
                 diagnostics.push(`${source}: malformed ${field} for ${id}`);
@@ -1040,8 +1079,16 @@ function normalizeObservationRows(rows, options, cli) {
         }
         const efforts = cli === 'muse' ? museEfforts(row) : [...new Set([...stringList(row.supported_reasoning_levels),
                 ...(typeof row.default_reasoning_level === 'string' && row.default_reasoning_level ? [row.default_reasoning_level] : [])])];
+        // Codex's registry provider and catalogAdapter contain no inference-provider
+        // identity. Its providerless native catalog is OpenAI; never infer from a slug.
+        // Muse's real local catalogs use provider_id, not provider.
+        const llmProvider = typeof row.provider === 'string' && row.provider ? row.provider
+            : cli === 'muse' && typeof row.provider_id === 'string' && row.provider_id ? row.provider_id
+                : cli === 'codex' ? 'openai' : undefined;
         const model = {
-            id, ...(visibility === 'unknown' ? {} : { hidden: visibility === 'hidden' }),
+            id, apiModelId: typeof row.api_model_id === 'string' ? row.api_model_id : id,
+            ...(llmProvider ? { llmProvider } : {}),
+            ...(visibility === 'unknown' ? {} : { hidden: visibility === 'hidden' }),
             ...(cli === 'muse' ? { isDefault: row.is_default === true } : {}),
             ...(efforts.length ? { reasoningEfforts: efforts } : {}),
             worker: buildWorkerObservation(sourceOptions, {
@@ -1049,18 +1096,25 @@ function normalizeObservationRows(rows, options, cli) {
                 visibility, ...lifecycle, releaseDate,
                 availability: lifecycle.lifecycle === 'retired' ? 'unavailable'
                     : cli === 'muse' ? (row.is_current === true ? 'accessible' : 'unknown') : 'accessible',
-                contextTokens: normalizePositiveInt(cli === 'muse' ? row.context_limit : row.context_window),
+                contextTokens: cli === 'muse' ? normalizePositiveInt(row.context_limit) : codexContextTokens(row),
                 maxOutputTokens: normalizePositiveInt(row.output_limit),
-                efforts: efforts.map(id => ({ id, selfDelegates: null })),
+                efforts: catalogEfforts(efforts, rawEfforts),
+                // The native renderer passes model_reasoning_effort (Muse: --reasoning-effort).
                 effortSupport: efforts.length ? 'explicit' : 'unknown',
                 ...(cli === 'muse' ? { dataUseNote: 'contributor policy is config-scoped' } : {}),
                 provenanceFields: cli === 'muse'
-                    ? ['/id:model_id', '/isDefault:is_default', '/availability:is_current', '/efforts:reasoning_effort_variants[].tier', '/contextTokens:context_limit', '/maxOutputTokens:output_limit', '/releaseDate:release_date']
-                    : ['/id:slug', '/efforts:supported_reasoning_levels+default_reasoning_level', '/contextTokens:context_window'],
+                    ? ['/id:model_id', '/isDefault:is_default', '/availability:is_current', '/efforts:reasoning_effort_variants[].tier',
+                        '/efforts/selfDelegates:catalog-description+verified-ultra-rule', '/contextTokens:context_limit', '/maxOutputTokens:output_limit', '/releaseDate:release_date']
+                    : ['/id:slug', '/efforts:supported_reasoning_levels+default_reasoning_level',
+                        '/efforts/selfDelegates:catalog-description+verified-ultra-rule',
+                        '/contextTokens:context_window+max_context_window+effective_context_window_percent'],
             }),
         };
         // Bind compatibility-row values without including unrelated credential-bearing row keys.
-        const compatibility = { id: model.id, hidden: model.hidden, isDefault: model.isDefault, reasoningEfforts: model.reasoningEfforts };
+        model.worker.provenance[0].fields.push('/apiModelId');
+        if (model.llmProvider)
+            model.worker.provenance[0].fields.push('/llmProvider', `/llmProvider:${typeof row.provider === 'string' && row.provider ? 'provider' : cli === 'muse' ? 'provider_id' : 'codex-openai-default'}`);
+        const compatibility = { id: model.id, apiModelId: model.apiModelId, llmProvider: model.llmProvider, hidden: model.hidden, isDefault: model.isDefault, reasoningEfforts: model.reasoningEfforts };
         model.worker.evidenceDigest = discoveryDigest(JSON.stringify({
             workerDigest: model.worker.evidenceDigest, ...compatibility,
         }));
@@ -1132,6 +1186,17 @@ function reconcileDuplicateObservations(models, diagnostics, sourcePointers) {
                     break;
             }
         }
+        // Provider/API identity is selection evidence too. Conflicting rows must
+        // not acquire a qualified route merely because one row appeared first.
+        for (const field of ['apiModelId', 'llmProvider']) {
+            if (new Set(group.map(row => row[field])).size < 2)
+                continue;
+            conflicts.push({ field: `/${field}`, evidence: group.map(row => ({ value: row[field] ?? null,
+                    source: row.worker.provenance[0].source, pointer: field === 'apiModelId' ? '/api_model_id' : '/provider',
+                    observedAt: row.worker.observedAt, digest: row.worker.provenance[0].digest })) });
+            diagnostics.push(`${model.id}: conflicting ${field}`);
+            delete model[field];
+        }
         // Compatibility defaults also remain evidence rather than silently keeping the first.
         if (new Set(group.map(m => m.isDefault)).size > 1) {
             diagnostics.push(`${model.id}: conflicting isDefault values from ${group.map(m => m.worker.provenance[0].source).join(', ')}`);