agentic-workflow-manager 9.11.12 → 9.12.0

package/dist/src/core/model-policy/native-claude-transcript.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNativeClaudeTranscriptObservation = isNativeClaudeTranscriptObservation;
+exports.readClaudeSubagentTranscript = readClaudeSubagentTranscript;
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const native_bridge_1 = require("../secure-fs/native-bridge");
+const MAX_BYTES = 16 * 1024 * 1024;
+const ASSISTANT_LINE = /"type"\s*:\s*"assistant"/;
+const observedTranscripts = new WeakMap();
+function isNativeClaudeTranscriptObservation(value) {
+    return !!value && typeof value === 'object' && observedTranscripts.get(value) === JSON.stringify(value);
+}
+/** Private JSONL format: any format change or mixed-model trace fails closed.
+ * Usage is deliberately unknown because repeated assistant chunks can duplicate
+ * the provider usage object. No prompt or transcript text is returned. */
+function readClaudeSubagentTranscript(input) {
+    if (!input || typeof input !== 'object' || typeof input.configDir !== 'string' || typeof input.file !== 'string'
+        || !path_1.default.isAbsolute(input.configDir) || !path_1.default.isAbsolute(input.file) || path_1.default.normalize(input.configDir) !== input.configDir
+        || path_1.default.normalize(input.file) !== input.file || input.configDir.includes('\0') || input.file.includes('\0')
+        || typeof input.agentId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(input.agentId))
+        throw new Error('Claude transcript identity or paths are invalid');
+    const relative = path_1.default.relative(input.configDir, input.file);
+    const segments = relative.split(path_1.default.sep);
+    if (segments.length < 5 || segments[0] !== 'projects' || segments[segments.length - 2] !== 'subagents'
+        || segments[segments.length - 1] !== `agent-${input.agentId}.jsonl`
+        || segments.some(segment => segment === '..' || segment === ''))
+        throw new Error('Claude transcript is outside the native subagents tree');
+    for (let dir = path_1.default.dirname(input.file);; dir = path_1.default.dirname(dir)) {
+        const stat = fs_1.default.lstatSync(dir);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error('Claude transcript has an unsafe or symlinked ancestor');
+        if (dir === input.configDir)
+            break;
+        if (dir === path_1.default.dirname(dir))
+            throw new Error('Claude config root is invalid');
+    }
+    const stat = fs_1.default.lstatSync(input.file);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error('Claude transcript is unsafe or symlinked');
+    const bytes = native_bridge_1.secureFs.readRegularFile(input.file, MAX_BYTES).bytes;
+    const lines = new TextDecoder('utf-8', { fatal: true }).decode(bytes).split('\n');
+    let actualModel;
+    let observedAt;
+    let count = 0;
+    for (const line of lines) {
+        if (!ASSISTANT_LINE.test(line))
+            continue;
+        if (line.length > 256 * 1024 || ++count > 10000)
+            throw new Error('Claude transcript assistant metadata exceeds limit');
+        const event = JSON.parse(line);
+        if (!event || typeof event !== 'object' || Array.isArray(event))
+            throw new Error('Claude transcript assistant event is invalid');
+        const item = event;
+        if (item.type !== 'assistant' || !item.message || typeof item.message !== 'object' || Array.isArray(item.message))
+            throw new Error('Claude transcript assistant event is invalid');
+        const model = item.message.model;
+        if (typeof model !== 'string' || model.length === 0 || model.length > 128 || /[\u0000-\u001f\u007f-\u009f]/.test(model))
+            throw new Error('Claude transcript model is invalid');
+        if (actualModel !== undefined && actualModel !== model)
+            throw new Error('Claude transcript contains mixed or multiple models');
+        if (typeof item.timestamp !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(item.timestamp)
+            || !Number.isFinite(Date.parse(item.timestamp)))
+            throw new Error('Claude transcript timestamp is invalid');
+        actualModel = model;
+        const time = new Date(item.timestamp).toISOString();
+        if (!observedAt || time > observedAt)
+            observedAt = time;
+    }
+    if (!actualModel || !observedAt)
+        throw new Error('Claude transcript has no assistant model evidence');
+    const result = { provenance: 'claude-subagent-transcript', agentId: input.agentId, actualModel, observedAt,
+        evidenceDigest: (0, crypto_1.createHash)('sha256').update(bytes).digest('hex'), tokenUsage: 'unknown' };
+    observedTranscripts.set(result, JSON.stringify(result));
+    return result;
+}

package/dist/src/core/model-policy/native-claude.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNativeClaudeSubagentLifecycle = isNativeClaudeSubagentLifecycle;
+exports.normalizeClaudeSubagentLifecycle = normalizeClaudeSubagentLifecycle;
+const observedLifecycles = new WeakMap();
+function isNativeClaudeSubagentLifecycle(value) {
+    return !!value && typeof value === 'object' && observedLifecycles.get(value) === JSON.stringify(value);
+}
+function record(value, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${name} must be an object`);
+    return value;
+}
+function boundedText(value, name, max = 128) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > max || /[\u0000-\u001f\u007f-\u009f]/.test(value))
+        throw new Error(`${name} is invalid`);
+    return value;
+}
+/** A matching native hook pair proves lifecycle, not the effective model.
+ * Call only on payloads captured by the installed Claude Code hooks. */
+function normalizeClaudeSubagentLifecycle(startValue, stopValue) {
+    const start = record(startValue, 'Claude SubagentStart hook');
+    const stop = record(stopValue, 'Claude SubagentStop hook');
+    if (start.hook_event_name !== 'SubagentStart' || stop.hook_event_name !== 'SubagentStop')
+        throw new Error('Claude subagent hook event kind is invalid');
+    const sessionId = boundedText(start.session_id, 'Claude session id');
+    const agentId = boundedText(start.agent_id, 'Claude agent id');
+    const agentType = boundedText(start.agent_type, 'Claude agent type');
+    const stopSessionId = boundedText(stop.session_id, 'Claude stop session id');
+    const stopAgentId = boundedText(stop.agent_id, 'Claude stop agent id');
+    const stopAgentType = boundedText(stop.agent_type, 'Claude stop agent type');
+    boundedText(stop.agent_transcript_path, 'Claude agent transcript path', 4096);
+    if (typeof stop.stop_hook_active !== 'boolean')
+        throw new Error('Claude stop hook active flag is invalid');
+    if (sessionId !== stopSessionId || agentId !== stopAgentId || agentType !== stopAgentType)
+        throw new Error('Claude subagent lifecycle identity mismatch');
+    const lifecycle = { provenance: 'claude-code-subagent-hooks', sessionId, agentId, agentType,
+        nativeDispatchVerified: true, acceptedSelectionVerified: false, actualModelVerified: false, tokenUsage: 'unknown' };
+    observedLifecycles.set(lifecycle, JSON.stringify(lifecycle));
+    return lifecycle;
+}

package/dist/src/core/model-policy/native-codex-machine.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryCodexMachineFacts = queryCodexMachineFacts;
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+function record(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    return value;
+}
+function canonical(value, depth = 0) {
+    if (depth > 32)
+        throw new Error('Codex configuration nesting exceeds limit');
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(item => canonical(item, depth + 1)).join(',')}]`;
+    const item = record(value, 'Codex configuration value');
+    return `{${Object.keys(item).sort().map(key => `${JSON.stringify(key)}:${canonical(item[key], depth + 1)}`).join(',')}}`;
+}
+function digest(key, value) { return (0, crypto_1.createHmac)('sha256', key).update(value, 'utf8').digest('hex'); }
+/** Explicit no-inference query. HMAC prevents offline guessing of email and
+ * configuration values; the caller owns one stable per-machine key. */
+function queryCodexMachineFacts(input) {
+    if (!input || typeof input !== 'object' || typeof input.command !== 'string' || input.command.length === 0 || input.command.length > 4096
+        || !Array.isArray(input.args) || input.args.length > 16 || input.args.some(arg => typeof arg !== 'string' || arg.length > 65536)
+        || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 30000
+        || typeof input.cwd !== 'string' || !path_1.default.isAbsolute(input.cwd) || !Buffer.isBuffer(input.key) || input.key.length !== 32)
+        throw new Error('Codex machine query is invalid');
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(input.command, input.args, { stdio: ['pipe', 'pipe', 'pipe'], shell: false, cwd: input.cwd });
+        let settled = false;
+        let buffer = '';
+        let expectedId = 1;
+        let configDigest;
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const send = (request) => { if (!settled)
+            child.stdin.write(`${JSON.stringify(request)}\n`); };
+        const timer = setTimeout(() => finish(new Error('Codex machine query timed out')), input.timeoutMs);
+        child.on('error', () => finish(new Error('Codex app-server could not be started')));
+        child.stdin.on('error', () => finish(new Error('Codex app-server input failed')));
+        child.on('exit', () => finish(new Error('Codex app-server exited before machine response')));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            if (settled)
+                return;
+            buffer += chunk;
+            if (buffer.length > 2 * 1024 * 1024)
+                return finish(new Error('Codex machine response exceeds 2 MiB'));
+            for (;;) {
+                const end = buffer.indexOf('\n');
+                if (end < 0 || settled)
+                    break;
+                const line = buffer.slice(0, end).trim();
+                buffer = buffer.slice(end + 1);
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = record(JSON.parse(line), 'Codex protocol response');
+                }
+                catch {
+                    return finish(new Error('Codex protocol returned invalid JSON'));
+                }
+                if (message.id === undefined)
+                    continue;
+                if (message.id !== expectedId)
+                    return finish(new Error('Codex protocol response id mismatch'));
+                if (message.error !== undefined)
+                    return finish(new Error('Codex app-server rejected machine query'));
+                try {
+                    const result = record(message.result, 'Codex machine result');
+                    if (expectedId === 1) {
+                        expectedId = 2;
+                        send({ method: 'initialized' });
+                        send({ id: expectedId, method: 'config/read', params: { cwd: input.cwd, includeLayers: false } });
+                    }
+                    else if (expectedId === 2) {
+                        configDigest = digest(input.key, canonical(record(result.config, 'Codex effective config')));
+                        expectedId = 3;
+                        send({ id: expectedId, method: 'account/read', params: { refreshToken: false } });
+                    }
+                    else {
+                        if (typeof result.requiresOpenaiAuth !== 'boolean')
+                            throw new Error('Codex account response is invalid');
+                        const account = result.account === null ? null : record(result.account, 'Codex account');
+                        let accountScopeDigest = null;
+                        if (account?.type === 'chatgpt' && typeof account.email === 'string' && account.email.length > 0 && account.email.length <= 320 && typeof account.planType === 'string') {
+                            accountScopeDigest = digest(input.key, `chatgpt\0${account.email}\0${account.planType}`);
+                        }
+                        finish(undefined, { provenance: 'codex-app-server-config-account', configDigest: configDigest,
+                            accountState: accountScopeDigest ? 'identified' : 'unverified', accountScopeDigest, inferenceDispatched: false });
+                    }
+                }
+                catch {
+                    finish(new Error('Codex machine response is invalid'));
+                }
+            }
+        });
+        send({ id: 1, method: 'initialize', params: { clientInfo: { name: 'awm', title: 'AWM machine discovery', version: '1.0.0' } } });
+    });
+}

package/dist/src/core/model-policy/native-codex-rollout.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCodexRolloutSelection = normalizeCodexRolloutSelection;
+exports.readCodexRolloutSelection = readCodexRolloutSelection;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const native_bridge_1 = require("../secure-fs/native-bridge");
+function record(value, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${name} must be an object`);
+    return value;
+}
+function boundedText(value, name) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 128 || /[\u0000-\u001f\u007f-\u009f]/.test(value))
+        throw new Error(`${name} is invalid`);
+    return value;
+}
+/** Normalize only the two metadata records from a locally verified Codex
+ * rollout. The private format is version-sensitive; unknown shapes remain
+ * UNTESTED rather than being promoted from thread configuration. */
+function normalizeCodexRolloutSelection(events, expected) {
+    if (!expected || typeof expected !== 'object')
+        throw new Error('Codex rollout identity is required');
+    const parentThreadId = boundedText(expected.parentThreadId, 'Codex parent thread id');
+    const childThreadId = boundedText(expected.childThreadId, 'Codex child thread id');
+    const turnId = boundedText(expected.turnId, 'Codex turn id');
+    if (!Array.isArray(events) || events.length === 0 || events.length > 10000)
+        throw new Error('Codex rollout events are invalid');
+    let cliVersion;
+    let selection;
+    let observedAt;
+    for (const raw of events) {
+        const event = record(raw, 'Codex rollout event');
+        if (event.type === 'session_meta') {
+            if (cliVersion !== undefined)
+                throw new Error('Codex rollout has duplicate session metadata');
+            const payload = record(event.payload, 'Codex session metadata');
+            if (boundedText(payload.id, 'Codex metadata child id') !== childThreadId)
+                throw new Error('Codex rollout child id mismatch');
+            const source = record(payload.source, 'Codex session source');
+            const subagent = record(source.subagent, 'Codex subagent source');
+            const spawn = record(subagent.thread_spawn, 'Codex thread spawn source');
+            if (boundedText(spawn.parent_thread_id, 'Codex metadata parent id') !== parentThreadId)
+                throw new Error('Codex rollout parent id mismatch');
+            cliVersion = boundedText(payload.cli_version, 'Codex rollout CLI version');
+            if (!/^\d+\.\d+\.\d+$/.test(cliVersion))
+                throw new Error('Codex rollout CLI version is invalid');
+        }
+        if (event.type === 'turn_context') {
+            const payload = record(event.payload, 'Codex turn context');
+            if (boundedText(payload.turn_id, 'Codex turn context id') !== turnId)
+                continue;
+            if (selection !== undefined)
+                throw new Error('Codex rollout has duplicate turn context');
+            if (typeof event.timestamp !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(event.timestamp)
+                || !Number.isFinite(Date.parse(event.timestamp)))
+                throw new Error('Codex turn timestamp is invalid');
+            observedAt = new Date(event.timestamp).toISOString();
+            selection = { selector: { kind: 'model', id: boundedText(payload.model, 'Codex turn model') },
+                effort: { kind: 'explicit', value: boundedText(payload.effort, 'Codex turn effort') } };
+        }
+    }
+    if (cliVersion === undefined)
+        throw new Error('Codex rollout session metadata is missing');
+    if (selection === undefined || observedAt === undefined)
+        throw new Error('Codex rollout turn context is missing');
+    return { provenance: 'codex-rollout-turn-context', cliVersion, observedAt, configuredSelection: selection, actualModelVerified: false };
+}
+const MAX_ROLLOUT_BYTES = 16 * 1024 * 1024;
+const METADATA_LINE = /"type"\s*:\s*"(?:session_meta|turn_context)"/;
+/** Read only the validated local Codex sessions tree; return no transcript or
+ * account data. A private-format change fails closed as UNTESTED to callers. */
+function readCodexRolloutSelection(input) {
+    if (!input || typeof input !== 'object' || typeof input.codexHome !== 'string' || typeof input.file !== 'string'
+        || !path_1.default.isAbsolute(input.codexHome) || !path_1.default.isAbsolute(input.file)
+        || path_1.default.normalize(input.codexHome) !== input.codexHome || path_1.default.normalize(input.file) !== input.file
+        || input.codexHome.includes('\0') || input.file.includes('\0'))
+        throw new Error('Codex rollout paths are invalid');
+    const sessions = path_1.default.join(input.codexHome, 'sessions');
+    const relative = path_1.default.relative(sessions, input.file);
+    if (!relative || relative === '..' || relative.startsWith(`..${path_1.default.sep}`) || path_1.default.isAbsolute(relative))
+        throw new Error('Codex rollout is outside sessions');
+    for (let candidate = path_1.default.dirname(input.file);; candidate = path_1.default.dirname(candidate)) {
+        const stat = fs_1.default.lstatSync(candidate);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error('Codex rollout has an unsafe or symlinked ancestor');
+        if (candidate === input.codexHome)
+            break;
+        if (candidate === path_1.default.dirname(candidate))
+            throw new Error('Codex rollout root is invalid');
+    }
+    const stat = fs_1.default.lstatSync(input.file);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error('Codex rollout is unsafe or symlinked');
+    const bytes = native_bridge_1.secureFs.readRegularFile(input.file, MAX_ROLLOUT_BYTES).bytes;
+    const text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    const events = [];
+    for (const line of text.split('\n')) {
+        if (!METADATA_LINE.test(line))
+            continue;
+        if (line.length > 256 * 1024)
+            throw new Error('Codex rollout metadata line exceeds 256 KiB');
+        events.push(JSON.parse(line));
+        if (events.length > 10000)
+            throw new Error('Codex rollout has too many metadata events');
+    }
+    return normalizeCodexRolloutSelection(events, input.expected);
+}

package/dist/src/core/model-policy/native-codex.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCodexRolloutSelection = void 0;
+exports.isNativeCodexChildObservation = isNativeCodexChildObservation;
+exports.normalizeCodexChildThreadObservation = normalizeCodexChildThreadObservation;
+exports.normalizeCodexModelCatalog = normalizeCodexModelCatalog;
+exports.queryCodexChildThreadObservation = queryCodexChildThreadObservation;
+exports.queryCodexModelCatalog = queryCodexModelCatalog;
+const child_process_1 = require("child_process");
+const native_codex_rollout_1 = require("./native-codex-rollout");
+var native_codex_rollout_2 = require("./native-codex-rollout");
+Object.defineProperty(exports, "normalizeCodexRolloutSelection", { enumerable: true, get: function () { return native_codex_rollout_2.normalizeCodexRolloutSelection; } });
+const nativeChildObservations = new WeakMap();
+function isNativeCodexChildObservation(value) {
+    return !!value && typeof value === 'object' && nativeChildObservations.get(value) === JSON.stringify(value);
+}
+function record(value, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${name} must be an object`);
+    return value;
+}
+function boundedText(value, name) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 128 || /[\u0000-\u001f\u007f-\u009f]/.test(value))
+        throw new Error(`${name} is invalid`);
+    return value;
+}
+/** Only call on a result obtained from native `thread/read` with includeTurns.
+ * A child with a completed turn proves native child execution and exposes its
+ * persisted configuration, but not the accepted per-turn or backend model. */
+function normalizeCodexChildThreadObservation(value, expectedParentThreadId) {
+    const parent = boundedText(expectedParentThreadId, 'expected parent thread id');
+    const response = record(value, 'Codex thread/read response');
+    const thread = record(response.thread, 'Codex child thread');
+    const childThreadId = boundedText(thread.id, 'Codex child thread id');
+    const parentThreadId = boundedText(thread.parentThreadId, 'Codex parent thread id');
+    if (parentThreadId !== parent || childThreadId === parent)
+        throw new Error('Codex child parent thread mismatch');
+    const model = boundedText(thread.model, 'Codex child configured model');
+    const effort = boundedText(thread.reasoningEffort, 'Codex child configured effort');
+    if (!Array.isArray(thread.turns) || thread.turns.length === 0 || thread.turns.length > 256)
+        throw new Error('Codex child turns are invalid');
+    const completed = thread.turns.find((raw) => {
+        const turn = record(raw, 'Codex child turn');
+        boundedText(turn.id, 'Codex child turn id');
+        if (!Array.isArray(turn.items) || turn.items.length > 4096)
+            throw new Error('Codex child turn items are invalid');
+        if (typeof turn.status !== 'string')
+            throw new Error('Codex child turn status is invalid');
+        return turn.status === 'completed';
+    });
+    if (!completed)
+        throw new Error('Codex child has no completed turn');
+    return { provenance: 'codex-app-server-thread-read', parentThreadId, childThreadId, turnId: completed.id,
+        nativeDispatchVerified: true, configuredSelection: { selector: { kind: 'model', id: model }, effort: { kind: 'explicit', value: effort } },
+        acceptedSelectionVerified: false, actualModelVerified: false, tokenUsage: 'unknown' };
+}
+/** Normalize only the provider's catalog. This cannot attest dispatch or actual backend identity. */
+function normalizeCodexModelCatalog(value) {
+    const response = record(value, 'Codex model/list response');
+    if (!Array.isArray(response.data) || response.data.length > 256)
+        throw new Error('Codex model catalog is invalid');
+    const selections = [];
+    const modelIds = new Set();
+    const selectionKeys = new Set();
+    for (const [index, raw] of response.data.entries()) {
+        const model = record(raw, `Codex model[${index}]`);
+        const catalogId = boundedText(model.id, `Codex model[${index}].id`);
+        const slug = boundedText(model.model, `Codex model[${index}].model`);
+        if (modelIds.has(catalogId))
+            throw new Error(`Codex catalog contains duplicate model id ${catalogId}`);
+        modelIds.add(catalogId);
+        if (typeof model.hidden !== 'boolean')
+            throw new Error(`Codex model[${index}].hidden is invalid`);
+        if (!Array.isArray(model.supportedReasoningEfforts) || model.supportedReasoningEfforts.length > 20)
+            throw new Error(`Codex model[${index}] supported efforts are invalid`);
+        if (model.hidden)
+            continue;
+        for (const [effortIndex, rawEffort] of model.supportedReasoningEfforts.entries()) {
+            const option = record(rawEffort, `Codex model[${index}] effort[${effortIndex}]`);
+            const effort = boundedText(option.reasoningEffort, `Codex model[${index}] effort[${effortIndex}]`);
+            boundedText(option.description, `Codex model[${index}] effort description`);
+            const key = `${slug}\0${effort}`;
+            if (selectionKeys.has(key))
+                throw new Error(`Codex catalog contains duplicate selection ${slug}/${effort}`);
+            selectionKeys.add(key);
+            selections.push({ selector: { kind: 'model', id: slug }, effort: { kind: 'explicit', value: effort } });
+        }
+    }
+    return { provenance: 'native-catalog', selections, nativeDispatchVerified: false, actualModelVerified: false };
+}
+/** Explicit, read-only native observation of an existing child. It never starts
+ * a thread or turn, and only returns the bounded normalized fields. */
+function queryCodexChildThreadObservation(input) {
+    if (!input || typeof input !== 'object' || typeof input.command !== 'string' || input.command.length === 0 || input.command.length > 4096
+        || !Array.isArray(input.args) || input.args.length > 16 || input.args.some(arg => typeof arg !== 'string' || arg.length > 65536)
+        || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 30000)
+        throw new Error('Codex child thread query is invalid');
+    const parentThreadId = boundedText(input.parentThreadId, 'parent thread id');
+    const childThreadId = boundedText(input.childThreadId, 'child thread id');
+    if (parentThreadId === childThreadId)
+        throw new Error('Codex child and parent thread ids must differ');
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(input.command, input.args, { stdio: ['pipe', 'pipe', 'pipe'], shell: false });
+        let settled = false;
+        let buffer = '';
+        let expectedId = 1;
+        const finish = (error, observed) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else {
+                nativeChildObservations.set(observed, JSON.stringify(observed));
+                resolve(observed);
+            }
+        };
+        const send = (request) => { if (!settled)
+            child.stdin.write(`${JSON.stringify(request)}\n`); };
+        const timer = setTimeout(() => finish(new Error('Codex child thread query timed out')), input.timeoutMs);
+        child.on('error', () => finish(new Error('Codex app-server could not be started')));
+        child.stdin.on('error', () => finish(new Error('Codex app-server input failed')));
+        child.on('exit', () => finish(new Error('Codex app-server exited before thread/read response')));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            if (settled)
+                return;
+            buffer += chunk;
+            if (buffer.length > 2 * 1024 * 1024)
+                return finish(new Error('Codex thread/read response exceeds 2 MiB'));
+            for (;;) {
+                const end = buffer.indexOf('\n');
+                if (end < 0 || settled)
+                    break;
+                const line = buffer.slice(0, end).trim();
+                buffer = buffer.slice(end + 1);
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = record(JSON.parse(line), 'Codex protocol response');
+                }
+                catch {
+                    return finish(new Error('Codex protocol returned invalid JSON'));
+                }
+                if (message.id === undefined)
+                    continue;
+                if (message.id !== expectedId)
+                    return finish(new Error('Codex protocol response id mismatch'));
+                if (message.error !== undefined)
+                    return finish(new Error('Codex app-server rejected thread/read request'));
+                if (expectedId === 1) {
+                    try {
+                        record(message.result, 'Codex initialize result');
+                    }
+                    catch {
+                        return finish(new Error('Codex protocol initialize response is invalid'));
+                    }
+                    send({ method: 'initialized' });
+                    expectedId = 2;
+                    send({ id: expectedId, method: 'thread/read', params: { threadId: childThreadId, includeTurns: true } });
+                    continue;
+                }
+                try {
+                    const result = normalizeCodexChildThreadObservation(message.result, parentThreadId);
+                    if (result.childThreadId !== childThreadId)
+                        throw new Error('Codex child thread id mismatch');
+                    if (input.codexHome === undefined) {
+                        finish(undefined, result);
+                        continue;
+                    }
+                    const response = record(message.result, 'Codex thread/read result');
+                    const thread = record(response.thread, 'Codex child thread');
+                    if (typeof thread.path !== 'string')
+                        throw new Error('Codex child rollout path is unavailable');
+                    const turn = (0, native_codex_rollout_1.readCodexRolloutSelection)({ codexHome: input.codexHome, file: thread.path,
+                        expected: { parentThreadId, childThreadId, turnId: result.turnId } });
+                    if (turn.configuredSelection.selector.id !== result.configuredSelection.selector.id
+                        || turn.configuredSelection.effort.kind !== result.configuredSelection.effort.kind
+                        || (turn.configuredSelection.effort.kind === 'explicit' && result.configuredSelection.effort.kind === 'explicit'
+                            && turn.configuredSelection.effort.value !== result.configuredSelection.effort.value))
+                        throw new Error('Codex child selection changed after the observed turn');
+                    finish(undefined, { ...result, configuredSelection: turn.configuredSelection, acceptedSelectionVerified: true, childRuntimeVersion: turn.cliVersion, observedAt: turn.observedAt });
+                }
+                catch (error) {
+                    finish(error);
+                }
+            }
+        });
+        send({ id: 1, method: 'initialize', params: { clientInfo: { name: 'awm', title: 'AWM native observation', version: '1.0.0' } } });
+    });
+}
+/** Explicit no-inference App Server discovery. Never invoked by doctor/preflight. */
+function queryCodexModelCatalog(input) {
+    if (!input || typeof input !== 'object'
+        || typeof input.command !== 'string' || input.command.length === 0 || input.command.length > 4096
+        || !Array.isArray(input.args) || input.args.length > 16
+        || input.args.some(arg => typeof arg !== 'string' || arg.length > 65536)
+        || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 30000) {
+        throw new Error('Codex catalog query is invalid');
+    }
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(input.command, input.args, { stdio: ['pipe', 'pipe', 'pipe'], shell: false });
+        let settled = false;
+        let buffer = '';
+        let nextRequestId = 2;
+        let pendingRequestId = 1;
+        let pages = 0;
+        const models = [];
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const send = (message) => {
+            if (settled)
+                return;
+            child.stdin.write(`${JSON.stringify(message)}\n`);
+        };
+        const timer = setTimeout(() => finish(new Error('Codex catalog query timed out')), input.timeoutMs);
+        child.on('error', () => finish(new Error('Codex app-server could not be started')));
+        child.stdin.on('error', () => finish(new Error('Codex app-server input failed')));
+        child.on('exit', () => finish(new Error('Codex app-server exited before catalog response')));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            if (settled)
+                return;
+            buffer += chunk;
+            if (buffer.length > 2 * 1024 * 1024)
+                return finish(new Error('Codex protocol response exceeds 2 MiB'));
+            for (;;) {
+                const end = buffer.indexOf('\n');
+                if (end < 0 || settled)
+                    break;
+                const line = buffer.slice(0, end).trim();
+                buffer = buffer.slice(end + 1);
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = record(JSON.parse(line), 'Codex protocol response');
+                }
+                catch {
+                    return finish(new Error('Codex protocol returned invalid JSON'));
+                }
+                if (message.id === undefined)
+                    continue; // asynchronous notification
+                if (message.id !== pendingRequestId)
+                    return finish(new Error('Codex protocol response id mismatch'));
+                if (message.error !== undefined)
+                    return finish(new Error('Codex app-server rejected catalog request'));
+                if (pendingRequestId === 1) {
+                    try {
+                        record(message.result, 'Codex initialize result');
+                    }
+                    catch {
+                        return finish(new Error('Codex protocol initialize response is invalid'));
+                    }
+                    send({ method: 'initialized' });
+                    pendingRequestId = nextRequestId++;
+                    send({ id: pendingRequestId, method: 'model/list', params: { includeHidden: false, limit: 100 } });
+                    continue;
+                }
+                let page;
+                try {
+                    page = record(message.result, 'Codex model/list result');
+                }
+                catch {
+                    return finish(new Error('Codex protocol model/list response is invalid'));
+                }
+                if (!Array.isArray(page.data))
+                    return finish(new Error('Codex protocol model/list data is invalid'));
+                models.push(...page.data);
+                pages += 1;
+                if (models.length > 256 || pages > 8)
+                    return finish(new Error('Codex model catalog exceeds discovery limit'));
+                if (page.nextCursor === null || page.nextCursor === undefined) {
+                    try {
+                        finish(undefined, normalizeCodexModelCatalog({ data: models }));
+                    }
+                    catch (error) {
+                        finish(error);
+                    }
+                    continue;
+                }
+                if (typeof page.nextCursor !== 'string' || page.nextCursor.length === 0 || page.nextCursor.length > 1024)
+                    return finish(new Error('Codex protocol cursor is invalid'));
+                pendingRequestId = nextRequestId++;
+                send({ id: pendingRequestId, method: 'model/list', params: { includeHidden: false, limit: 100, cursor: page.nextCursor } });
+            }
+        });
+        send({ id: 1, method: 'initialize', params: { clientInfo: { name: 'awm', title: 'AWM discovery', version: '1.0.0' } } });
+    });
+}