@fitlab-ai/agent-infra 0.9.4 → 0.9.6

package/README.md

@@ -176,7 +176,7 @@ The most-used lifecycle commands, in delivery order. The command prefix varies b
 | Command | Purpose |
 |---------|---------|
 | `create-task` / `import-issue` | Start a task from a description or a GitHub Issue |
-| `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; current built-in clients, including Claude Code and Codex, fail closed before delegation because their native start events do not expose all required evidence |
+| `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; Codex now has an experimental Hooks + App Server evidence channel, but orchestration remains disabled until that channel is connected to delegation receipts |
 | `analyze-task` → `review-analysis` | Capture scope and risks, then review the analysis |
 | `plan-task` → `review-plan` | Design the approach, then review the plan |
 | `code-task` → `review-code` | Implement and test, then run a structured code review |

package/README.zh-CN.md

@@ -175,7 +175,7 @@ ai agent-client configure
 | 命令 | 用途 |
 |------|------|
 | `create-task` / `import-issue` | 从描述或 GitHub Issue 创建任务 |
-| `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；当前内建客户端（含 Claude Code 与 Codex）因原生 start 事件未暴露全部必需证据，会在委派前失败关闭 |
+| `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；Codex 现已具备实验性的 Hooks + App Server 证据通道，但在该通道接入 delegation receipt 前仍不会启用 orchestration |
 | `analyze-task` → `review-analysis` | 明确范围与风险，再审查分析 |
 | `plan-task` → `review-plan` | 设计实现路径，再审查方案 |
 | `code-task` → `review-code` | 实现并测试，再执行结构化代码审查 |

package/dist/bin/internal-cli.js

@@ -8,13 +8,18 @@ const command = process.argv[2] || '';
 if (process.env.AGENT_INFRA_CONTROL_TOKEN
     && (command === 'task-lifecycle' || command === 'task-orchestration')) {
     const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
-    sandboxControl(['client', command, ...process.argv.slice(3)]);
+    await sandboxControl(['client', command, ...process.argv.slice(3)]);
 }
 else
     switch (command) {
+        case 'task-create': {
+            const { taskCreate } = await import('../lib/internal/task-create.js');
+            taskCreate(process.argv.slice(3));
+            break;
+        }
         case 'sandbox-control': {
             const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
-            sandboxControl(process.argv.slice(3));
+            await sandboxControl(process.argv.slice(3));
             break;
         }
         case 'agent-client': {
@@ -22,6 +27,11 @@ else
             agentClient(process.argv.slice(3));
             break;
         }
+        case 'codex-lifecycle': {
+            const { codexLifecycle } = await import('../lib/internal/codex-lifecycle.js');
+            await codexLifecycle(process.argv.slice(3));
+            break;
+        }
         case 'git-workflow': {
             const { gitWorkflow } = await import('../lib/internal/git-workflow.js');
             gitWorkflow(process.argv.slice(3));
@@ -99,7 +109,7 @@ else
         }
         case 'task-orchestration': {
             const { taskOrchestration } = await import('../lib/internal/task-orchestration.js');
-            taskOrchestration(process.argv.slice(3));
+            await taskOrchestration(process.argv.slice(3));
             break;
         }
         case 'task-review': {

package/dist/lib/agent-clients/adapter.js

@@ -190,8 +190,8 @@ function defineAgentClientAdapter(candidate) {
     }
     const evidence = candidate.delegationEvidence;
     if (!evidence
-        || !['host-event', 'unavailable'].includes(evidence.actualModel)
-        || !['host-event', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)) {
+        || !['host-event', 'app-server', 'unavailable'].includes(evidence.actualModel)
+        || !['host-event', 'app-server', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)) {
         throw new Error(`Agent Client '${candidate.id}' has invalid delegation evidence`);
     }
     if (typeof candidate.project !== 'object'

package/dist/lib/agent-clients/adapters/codex-lifecycle/app-server.js

@@ -0,0 +1,492 @@
+import { spawn, spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import semver from 'semver';
+const LIFECYCLE_HOOKS = Object.freeze([
+    Object.freeze({ event: 'PreToolUse', matcher: '^collaborationspawn_agent$', phase: 'pre-tool' }),
+    Object.freeze({ event: 'PostToolUse', matcher: '', phase: 'post-tool' }),
+    Object.freeze({ event: 'SubagentStart', matcher: '', phase: 'subagent-start' }),
+    Object.freeze({ event: 'SubagentStop', matcher: '', phase: 'subagent-stop' })
+]);
+const DEFAULT_ROLLOUT_READ_ATTEMPTS = 81;
+const DEFAULT_ROLLOUT_RETRY_MS = 100;
+function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function resolveCodexSpawnedChild(transcriptPath, expected) {
+    const name = path.basename(transcriptPath);
+    if (!transcriptPath || (!name.endsWith(`-${expected.sessionId}.jsonl`) && name !== `${expected.sessionId}.jsonl`)) {
+        throw new Error('Codex parent rollout path is invalid');
+    }
+    const stat = fs.lstatSync(transcriptPath);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error('Codex parent rollout is not a regular file');
+    const maxBytes = 8 * 1024 * 1024;
+    const offset = Math.max(0, stat.size - maxBytes);
+    const buffer = Buffer.alloc(stat.size - offset);
+    const descriptor = fs.openSync(transcriptPath, 'r');
+    try {
+        fs.readSync(descriptor, buffer, 0, buffer.length, offset);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+    let text = buffer.toString('utf8');
+    if (offset)
+        text = text.slice(text.indexOf('\n') + 1);
+    const records = text.split(/\r?\n/).filter(Boolean).map((line) => object(JSON.parse(line))).filter(Boolean);
+    const calls = records.filter((record) => {
+        const payload = object(record?.payload);
+        return record?.type === 'response_item'
+            && payload?.type === 'function_call'
+            && payload.call_id === expected.toolUseId
+            && payload.namespace === 'collaboration'
+            && payload.name === 'spawn_agent';
+    });
+    if (calls.length !== 1)
+        throw new Error('Codex parent rollout spawn call was not found uniquely');
+    const call = object(calls[0]?.payload);
+    const args = object(JSON.parse(nonEmpty(call?.arguments) ?? '{}'));
+    if (args?.agent_type !== expected.nativeAgent
+        || args.task_name !== expected.taskName
+        || (expected.requestedModel && args.model !== expected.requestedModel)
+        || (expected.requestedReasoningEffort && args.reasoning_effort !== expected.requestedReasoningEffort))
+        throw new Error('Codex parent rollout spawn identity does not match the hook event');
+    const activities = records.filter((record) => {
+        const payload = object(record?.payload);
+        return record?.type === 'event_msg'
+            && payload?.type === 'sub_agent_activity'
+            && payload.event_id === expected.toolUseId
+            && payload.kind === 'started'
+            && payload.agent_path === `/root/${expected.taskName}`
+            && nonEmpty(payload.agent_thread_id);
+    });
+    if (activities.length !== 1)
+        throw new Error('Codex parent rollout child activity was not found uniquely');
+    return nonEmpty(object(activities[0]?.payload)?.agent_thread_id);
+}
+function validateCodexLifecycleHookConfig(value) {
+    const hooks = object(object(value)?.hooks);
+    const valid = hooks && LIFECYCLE_HOOKS.every(({ event, matcher, phase }) => {
+        const entries = hooks[event];
+        if (!Array.isArray(entries))
+            return false;
+        return entries.some((entryValue) => {
+            const entry = object(entryValue);
+            if (entry?.matcher !== matcher || !Array.isArray(entry.hooks))
+                return false;
+            return entry.hooks.some((hookValue) => {
+                const hook = object(hookValue);
+                return hook?.type === 'command'
+                    && hook.timeout === 15
+                    && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`;
+            });
+        });
+    });
+    if (!valid)
+        throw new Error('CODEX_PREFLIGHT_HOOKS_INVALID: lifecycle hooks are invalid');
+}
+function parseCodexHooksList(value, repoRoot) {
+    const root = object(value);
+    const entries = Array.isArray(root?.data) ? root.data : [];
+    const entry = entries.map(object).find((candidate) => candidate?.cwd === repoRoot);
+    const errors = Array.isArray(entry?.errors) ? entry.errors : [];
+    if (errors.length)
+        throw new Error(`CODEX_PREFLIGHT_HOOK_DISCOVERY_FAILED: ${errors.map(String).join('; ')}`);
+    const hooks = (Array.isArray(entry?.hooks) ? entry.hooks : [])
+        .map(object)
+        .filter((hook) => hook !== null)
+        .map((hook) => Object.freeze({
+        eventName: String(hook.eventName ?? ''),
+        matcher: typeof hook.matcher === 'string' ? hook.matcher : null,
+        command: String(hook.command ?? ''),
+        enabled: hook.enabled === true
+    }));
+    const valid = LIFECYCLE_HOOKS.every(({ event, matcher, phase }) => hooks.some((hook) => hook.eventName === event.replace(/^./, (character) => character.toLowerCase())
+        && hook.matcher === matcher
+        && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`
+        && hook.enabled));
+    if (!valid)
+        throw new Error('CODEX_PREFLIGHT_HOOKS_NOT_LOADED: lifecycle hooks are not loaded for this workspace');
+    return Object.freeze(hooks);
+}
+function hasCodexRuntimeLiveness(runtimeRoot, hookDefinitionHash, identity) {
+    if (!identity || !fs.existsSync(runtimeRoot))
+        return false;
+    return fs.readdirSync(runtimeRoot)
+        .filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
+        .some((name) => {
+        try {
+            const record = object(JSON.parse(fs.readFileSync(path.join(runtimeRoot, name), 'utf8')));
+            const state = object(record?.state);
+            const spawnEvent = object(state?.spawn);
+            return !['invalid', 'expired'].includes(String(state?.status))
+                && spawnEvent?.hookDefinitionHash === hookDefinitionHash
+                && spawnEvent.sessionId === identity.sessionId
+                && spawnEvent.turnId === identity.turnId
+                && spawnEvent.toolUseId === identity.toolUseId;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function parseCodexThreadResolution(readValue, rolloutRecords) {
+    const readRoot = object(readValue);
+    const thread = object(readRoot?.thread);
+    const source = object(thread?.source);
+    const subAgent = object(source?.subAgent);
+    const threadSpawn = object(subAgent?.thread_spawn);
+    const sessionMeta = rolloutRecords
+        .map(object)
+        .find((record) => record?.type === 'session_meta');
+    const sessionPayload = object(sessionMeta?.payload);
+    const turnContext = rolloutRecords
+        .map(object)
+        .filter((record) => record?.type === 'turn_context')
+        .at(-1);
+    const turnPayload = object(turnContext?.payload);
+    const childThreadId = nonEmpty(thread?.id);
+    const parentThreadId = nonEmpty(thread?.parentThreadId);
+    const sourceParentThreadId = nonEmpty(threadSpawn?.parent_thread_id);
+    const rolloutChildThreadId = nonEmpty(sessionPayload?.id);
+    const rolloutParentThreadId = nonEmpty(sessionPayload?.parent_thread_id);
+    const agentRole = nonEmpty(sessionPayload?.agent_role);
+    const model = nonEmpty(turnPayload?.model);
+    const reasoningEffort = nonEmpty(turnPayload?.effort);
+    const forkedFromId = thread?.forkedFromId;
+    if (!childThreadId
+        || rolloutChildThreadId !== childThreadId
+        || !parentThreadId
+        || !sourceParentThreadId
+        || rolloutParentThreadId !== parentThreadId
+        || rolloutParentThreadId !== sourceParentThreadId
+        || !/^agent-infra-lifecycle-(executor|reviewer)$/.test(agentRole ?? '')
+        || !model
+        || !reasoningEffort
+        || (forkedFromId !== null && typeof forkedFromId !== 'string')) {
+        throw new Error('Codex App Server thread resolution is invalid');
+    }
+    return Object.freeze({
+        thread: Object.freeze({
+            type: 'app-thread',
+            childThreadId,
+            parentThreadId,
+            forkedFromId,
+            sourceParentThreadId,
+            nativeAgent: agentRole
+        }),
+        settings: Object.freeze({
+            type: 'app-settings',
+            childThreadId,
+            model,
+            reasoningEffort
+        })
+    });
+}
+function readCodexRolloutRecords(readValue, childThreadId) {
+    const thread = object(object(readValue)?.thread);
+    const rolloutPath = nonEmpty(thread?.path);
+    const rolloutName = rolloutPath ? path.basename(rolloutPath) : '';
+    if (!rolloutPath || (rolloutName !== `${childThreadId}.jsonl` && !rolloutName.endsWith(`-${childThreadId}.jsonl`))) {
+        throw new Error('Codex App Server rollout path is invalid');
+    }
+    const stat = fs.statSync(rolloutPath);
+    if (!stat.isFile())
+        throw new Error('Codex App Server rollout path is not a regular file');
+    const maxBytes = 1024 * 1024;
+    const bytes = Math.min(stat.size, maxBytes);
+    const descriptor = fs.openSync(rolloutPath, 'r');
+    try {
+        const buffer = Buffer.alloc(bytes);
+        fs.readSync(descriptor, buffer, 0, bytes, 0);
+        const text = buffer.toString('utf8');
+        const completeText = stat.size <= maxBytes ? text : text.slice(0, text.lastIndexOf('\n'));
+        return Object.freeze(completeText.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line)));
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+async function resolveCodexRolloutRecords(readValue, childThreadId, attempts, retryMs) {
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            const records = readCodexRolloutRecords(readValue, childThreadId);
+            parseCodexThreadResolution(readValue, records);
+            return records;
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt + 1 < attempts)
+                await new Promise((resolve) => setTimeout(resolve, retryMs));
+        }
+    }
+    throw lastError;
+}
+function parseCodexTurnCompleted(value) {
+    const root = object(value);
+    const turn = object(root?.turn);
+    const childThreadId = nonEmpty(root?.threadId);
+    const turnId = nonEmpty(turn?.id);
+    const status = turn?.status;
+    if (!childThreadId || !turnId || !['completed', 'interrupted', 'failed'].includes(String(status))) {
+        throw new Error('Codex App Server turn completion is invalid');
+    }
+    return Object.freeze({
+        type: 'app-terminal',
+        childThreadId,
+        turnId,
+        status: status
+    });
+}
+function parseCodexModelReroute(value) {
+    const root = object(value);
+    const childThreadId = nonEmpty(root?.threadId);
+    const turnId = nonEmpty(root?.turnId);
+    const fromModel = nonEmpty(root?.fromModel);
+    const toModel = nonEmpty(root?.toModel);
+    const reasonValue = root?.reason;
+    const reason = nonEmpty(reasonValue) ?? (object(reasonValue) ? JSON.stringify(reasonValue) : null);
+    if (!childThreadId || !turnId || !fromModel || !toModel || !reason) {
+        throw new Error('Codex App Server model reroute is invalid');
+    }
+    return Object.freeze({ type: 'app-reroute', childThreadId, turnId, fromModel, toModel, reason });
+}
+class CodexAppServerTransport {
+    #options;
+    #child = null;
+    #buffer = '';
+    #stderr = '';
+    #nextId = 1;
+    #pending = new Map();
+    #notifications = [];
+    constructor(options = {}) {
+        this.#options = {
+            ...options,
+            command: options.command ?? 'codex',
+            args: options.args ?? ['app-server', '--stdio'],
+            timeoutMs: options.timeoutMs ?? 5_000
+        };
+    }
+    get diagnostics() {
+        return Object.freeze(this.#stderr.split(/\r?\n/).filter(Boolean));
+    }
+    get notifications() {
+        return Object.freeze([...this.#notifications]);
+    }
+    start() {
+        if (this.#child)
+            throw new Error('Codex App Server transport is already started');
+        const child = spawn(this.#options.command, [...this.#options.args], {
+            cwd: this.#options.cwd,
+            env: this.#options.env,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        this.#child = child;
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.#onData(chunk));
+        child.stderr.on('data', (chunk) => {
+            this.#stderr = `${this.#stderr}${chunk}`.slice(-32 * 1024);
+        });
+        child.on('error', (error) => this.#rejectAll(error));
+        child.on('exit', (code, signal) => {
+            if (this.#pending.size) {
+                this.#rejectAll(new Error(`Codex App Server exited before responding (code=${code}, signal=${signal})`));
+            }
+        });
+    }
+    #onData(chunk) {
+        this.#buffer += chunk;
+        for (;;) {
+            const newline = this.#buffer.indexOf('\n');
+            if (newline < 0)
+                return;
+            const line = this.#buffer.slice(0, newline).trim();
+            this.#buffer = this.#buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                const parsed = object(JSON.parse(line));
+                if (!parsed)
+                    throw new Error('message is not an object');
+                message = parsed;
+            }
+            catch (error) {
+                this.#rejectAll(new Error(`Codex App Server returned invalid JSON: ${String(error)}`));
+                continue;
+            }
+            if (typeof message.id === 'number') {
+                const pending = this.#pending.get(message.id);
+                if (!pending)
+                    continue;
+                clearTimeout(pending.timer);
+                this.#pending.delete(message.id);
+                if (message.error)
+                    pending.reject(new Error(`Codex App Server request failed: ${JSON.stringify(message.error)}`));
+                else
+                    pending.resolve(message.result);
+            }
+            else if (typeof message.method === 'string') {
+                this.#notifications.push(Object.freeze({ method: message.method, params: message.params }));
+            }
+        }
+    }
+    #rejectAll(error) {
+        for (const [id, pending] of this.#pending) {
+            clearTimeout(pending.timer);
+            this.#pending.delete(id);
+            pending.reject(error);
+        }
+    }
+    request(method, params) {
+        if (!this.#child || !this.#child.stdin.writable) {
+            return Promise.reject(new Error('Codex App Server transport is not running'));
+        }
+        const id = this.#nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.#pending.delete(id);
+                reject(new Error(`Codex App Server request '${method}' timed out`));
+            }, this.#options.timeoutMs);
+            this.#pending.set(id, { resolve, reject, timer });
+            this.#child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+        });
+    }
+    notify(method, params = {}) {
+        if (!this.#child || !this.#child.stdin.writable)
+            throw new Error('Codex App Server transport is not running');
+        this.#child.stdin.write(`${JSON.stringify({ method, params })}\n`);
+    }
+    async initialize() {
+        const result = await this.request('initialize', {
+            clientInfo: { name: 'agent-infra', title: 'agent-infra', version: '0.9.5' },
+            capabilities: null
+        });
+        this.notify('initialized');
+        return result;
+    }
+    close() {
+        if (!this.#child)
+            return;
+        this.#child.stdin.end();
+        this.#child.kill();
+        this.#child = null;
+    }
+}
+async function resolveCodexThread(childThreadId, options = {}) {
+    if (!nonEmpty(childThreadId))
+        throw new Error('Codex child thread id is required');
+    const transport = new CodexAppServerTransport(options);
+    transport.start();
+    try {
+        await transport.initialize();
+        const readResult = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: false }));
+        const readThread = object(readResult?.thread);
+        if (nonEmpty(readThread?.id) !== childThreadId)
+            throw new Error('Codex App Server returned the wrong child thread');
+        let resolution;
+        try {
+            const rolloutRecords = await resolveCodexRolloutRecords(readResult, childThreadId, options.rolloutReadAttempts ?? DEFAULT_ROLLOUT_READ_ATTEMPTS, options.rolloutRetryMs ?? DEFAULT_ROLLOUT_RETRY_MS);
+            resolution = parseCodexThreadResolution(readResult, rolloutRecords);
+        }
+        catch {
+            throw new Error('Codex App Server rollout metadata is unavailable');
+        }
+        const reroutes = transport.notifications
+            .filter((entry) => entry.method === 'model/rerouted')
+            .map((entry) => parseCodexModelReroute(entry.params))
+            .filter((event) => event.childThreadId === childThreadId);
+        return Object.freeze({ resolution, reroutes: Object.freeze(reroutes), diagnostics: transport.diagnostics });
+    }
+    finally {
+        try {
+            await transport.request('thread/unsubscribe', { threadId: childThreadId });
+        }
+        catch {
+            // Closing the short-lived transport still removes the subscription.
+        }
+        transport.close();
+    }
+}
+async function resolveCodexTerminal(childThreadId, options = {}) {
+    const transport = new CodexAppServerTransport(options);
+    transport.start();
+    try {
+        await transport.initialize();
+        const result = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: true }));
+        const thread = object(result?.thread);
+        if (nonEmpty(thread?.id) !== childThreadId)
+            throw new Error('Codex App Server returned the wrong child thread');
+        const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+        const turn = turns.at(-1);
+        const turnValue = object(turn);
+        if (!turnValue || turnValue.status === 'inProgress')
+            throw new Error('CODEX_TURN_NOT_TERMINAL');
+        return parseCodexTurnCompleted({ threadId: childThreadId, turn });
+    }
+    finally {
+        transport.close();
+    }
+}
+async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtimeIdentity) {
+    const versionRun = spawnSync('codex', ['--version'], { encoding: 'utf8' });
+    const match = /codex-cli\s+(\d+\.\d+\.\d+)/.exec(versionRun.stdout ?? '');
+    if (versionRun.status !== 0 || !match?.[1] || !semver.gte(match[1], '0.147.0')) {
+        throw new Error('CODEX_PREFLIGHT_VERSION_UNSUPPORTED');
+    }
+    const featuresRun = spawnSync('codex', ['features', 'list'], { encoding: 'utf8' });
+    if (featuresRun.status !== 0
+        || !/^hooks\s+\S+\s+true$/m.test(featuresRun.stdout)
+        || !/^multi_agent\s+\S+\s+true$/m.test(featuresRun.stdout))
+        throw new Error('CODEX_PREFLIGHT_FEATURE_DISABLED');
+    const hooksPath = path.join(repoRoot, '.codex', 'hooks.json');
+    const hooksRaw = fs.readFileSync(hooksPath, 'utf8');
+    validateCodexLifecycleHookConfig(JSON.parse(hooksRaw));
+    const schemaDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-codex-schema-'));
+    try {
+        const schemaRun = spawnSync('codex', ['app-server', 'generate-json-schema', '--out', schemaDir], { encoding: 'utf8' });
+        if (schemaRun.status !== 0)
+            throw new Error('CODEX_PREFLIGHT_SCHEMA_UNAVAILABLE');
+        const schema = fs.readFileSync(path.join(schemaDir, 'codex_app_server_protocol.v2.schemas.json'), 'utf8');
+        for (const field of ['parentThreadId', 'forkedFromId', 'ThreadSettings', 'turn/completed', 'model/rerouted']) {
+            if (!schema.includes(field))
+                throw new Error(`CODEX_PREFLIGHT_SCHEMA_MISSING:${field}`);
+        }
+    }
+    finally {
+        fs.rmSync(schemaDir, { recursive: true, force: true });
+    }
+    const hookDefinitionHash = crypto.createHash('sha256').update(hooksRaw).digest('hex');
+    const runtimeRoot = path.join(repoRoot, '.agents', 'workspace', '.runtime', 'codex-lifecycle');
+    const runtimeLiveness = hasCodexRuntimeLiveness(runtimeRoot, hookDefinitionHash, runtimeIdentity);
+    const transport = new CodexAppServerTransport();
+    transport.start();
+    let discoveredHooks;
+    try {
+        await transport.initialize();
+        discoveredHooks = parseCodexHooksList(await transport.request('hooks/list', { cwds: [repoRoot] }), repoRoot);
+    }
+    finally {
+        transport.close();
+    }
+    return Object.freeze({
+        cliVersion: match[1],
+        hookDefinitionHash,
+        staticReady: true,
+        discoveredHooks,
+        runtimeLiveness,
+        diagnostics: transport.diagnostics
+    });
+}
+export { CodexAppServerTransport, hasCodexRuntimeLiveness, parseCodexModelReroute, parseCodexHooksList, parseCodexThreadResolution, parseCodexTurnCompleted, resolveCodexSpawnedChild, preflightCodexLifecycleEvidence, resolveCodexTerminal, resolveCodexThread, validateCodexLifecycleHookConfig };
+//# sourceMappingURL=app-server.js.map