@fitlab-ai/agent-infra 0.11.2 → 0.11.4

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <strong>From issue to merged PR in 11 commands.</strong> Define a requirement, let AI handle analysis, planning, coding, and three-stage review — you only step in when it matters.
+  <strong>From issue to merged PR through a risk-selected lifecycle.</strong> Every task starts with analysis, and every implementation receives an independent code review.
 </p>
 
 <p align="center">
@@ -51,14 +51,22 @@ Once initialized, open the project in your AI TUI and install the latest skills:
 
 > AI reads `.agents/.airc.json`, auto-locates the installed template root, and syncs the latest skill manifests, managed files, and registry deterministically via `sync-templates.js`.
 
-**Scenario**: Issue #42 reports *"Login API returns 500 when email contains a plus sign"*. Here is the full fix lifecycle — AI does the heavy lifting, you stay in control:
+**Scenario**: Issue #42 reports *"Login API returns 500 when email contains a plus sign"*. Every task starts with analysis, which records one canonical path from observable facts:
+
+| Path | Stages | Use when |
+|------|--------|----------|
+| Streamlined | `analyze → code → review-code` | Scope and acceptance are clear, with no separate design or document-audit decision |
+| Standard | `analyze → plan → code → review-code` | The implementation needs an explicit cross-module contract, data flow, or test strategy |
+| Full | `analyze → review-analysis → plan → review-plan → code → review-code` | Concrete acceptance disputes, costly interface/schema/migration choices, or real external/security boundaries require independent review |
+
+File count, module count, or a merely possible risk does not select the full path. A later finding can return work to analysis, planning, or code when new evidence justifies it; independent `review-code` remains part of every path.
+
+Suppose the analysis selects the **standard path** because the application-layer boundary needs an explicit plan:
 
 ```bash
 /import-issue 42           # AI reads the issue, creates a task, extracts requirements
-/analyze-task --task <task-id>    # AI scans the codebase, finds the root cause, writes analysis.md
-/review-analysis --task <task-id> # An isolated reviewer checks the analysis
+/analyze-task --task <task-id>    # AI scans the codebase, records the selected path, writes analysis.md
 /plan-task --task <task-id>       # AI proposes a fix plan
-/review-plan --task <task-id>     # A fresh isolated reviewer checks the plan
 ```
 
 > **You review the plan and reply in natural language:**
@@ -79,7 +87,7 @@ Just fix it at the application layer in LoginService.
 /complete-task --task <task-id>   # task archived
 ```
 
-**11 commands. 1 natural-language correction. From issue to merged PR.** That is the entire SOP — programming can have a standard operating procedure too.
+**One analysis-selected path, one natural-language correction, and an independent code review.** The lifecycle keeps the evidence and review depth proportional to the task.
 
 Every command above works the same way in Claude Code, Codex, Antigravity CLI, and OpenCode. Switch tools mid-task — the workflow state follows. For what each skill does under the hood, see [Built-in AI Skills](./docs/en/skills.md).
 
@@ -193,8 +201,9 @@ The most-used lifecycle commands, in delivery order. The command prefix varies b
 |---------|---------|
 | `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; 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 |
+| `analyze-task` | Capture scope and risks, then select the streamlined, standard, or full path |
+| `review-analysis` | Review the analysis when the selected full path requires an independent requirement checkpoint |
+| `plan-task` / `review-plan` | Design the approach on standard/full paths; independently review it only on the full path |
 | `code-task` → `review-code` | Implement and test; `code-task` creates a local checkpoint, then a structured review checks that checkpoint |
 | `create-pr` → `complete-task` | Publish the approved checkpoint to the task-bound target branch, then archive after merge and final gates |
 

package/README.zh-CN.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <strong>从 Issue 到合并 PR，只需 11 条命令。</strong> 定义需求，让 AI 完成分析、方案设计、编码与三阶段审查 —— 你只需在关键节点介入。
+  <strong>从 Issue 到合并 PR，由风险选择相称的生命周期。</strong> 每个任务都先分析，每份实现都接受独立代码审查。
 </p>
 
 <p align="center">
@@ -50,14 +50,22 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 
 > AI 读取 `.agents/.airc.json`，自动定位已安装的模板根目录，并通过 `sync-templates.js` 确定性地同步最新的 skill 清单、managed 文件和注册表。
 
-**场景**：Issue #42 报告 *"登录接口在邮箱包含加号时返回 500"*。以下是完整的修复流程 —— AI 执行主要工作，你掌控方向：
+**场景**：Issue #42 报告 *"登录接口在邮箱包含加号时返回 500"*。每个任务都从分析开始，并由分析根据可观察事实记录一条规范路径：
+
+| 路径 | 阶段 | 适用条件 |
+|------|------|----------|
+| 精简路径 | `analyze → code → review-code` | 范围和验收明确，不需要独立设计或文档审计决策 |
+| 标准路径 | `analyze → plan → code → review-code` | 实现需要明确跨模块契约、数据流或测试策略 |
+| 完整路径 | `analyze → review-analysis → plan → review-plan → code → review-code` | 存在具体的验收争议、高代价接口/schema/迁移选择，或真实外部/安全边界，需要独立审查 |
+
+文件数量、模块数量或可能存在的风险不能单独触发完整路径。后续 finding 只有在新证据成立时才会把工作返回分析、方案或实现阶段；每条路径都保留独立 `review-code`。
+
+假设分析认为应用层边界需要明确方案，因此选择**标准路径**：
 
 ```bash
 /import-issue 42           # AI 读取 Issue，创建任务，提取需求
-/analyze-task --task <task-id>    # AI 扫描代码库，定位根因，输出 analysis.md
-/review-analysis --task <task-id> # 隔离 reviewer 审查分析产物
+/analyze-task --task <task-id>    # AI 扫描代码库、记录所选路径，输出 analysis.md
 /plan-task --task <task-id>       # AI 提出修复方案
-/review-plan --task <task-id>     # fresh 隔离 reviewer 审查方案
 ```
 
 > **你审查方案后用自然语言回复：**
@@ -78,7 +86,7 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 /complete-task --task <task-id>   # 任务归档
 ```
 
-**11 条命令，1 次自然语言纠正，从 Issue 到合并 PR。** 这就是完整的 SOP —— 编程也可以有标准作业流程。
+**一条由分析选择的路径、一次自然语言纠正和一次独立代码审查。** 生命周期会让证据与审查深度和任务风险相称。
 
 以上每条命令在 Claude Code、Codex、Antigravity CLI、OpenCode 中完全通用。任务进行到一半切换工具，工作流状态照常延续。每个 skill 背后做了什么，见 [内置 AI Skills](./docs/zh-CN/skills.md)。
 
@@ -192,8 +200,9 @@ ai agent-client configure
 |------|------|
 | `create-task` / `import-issue` | 从描述或 GitHub Issue 创建任务 |
 | `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；Codex 现已具备实验性的 Hooks + App Server 证据通道，但在该通道接入 delegation receipt 前仍不会启用 orchestration |
-| `analyze-task` → `review-analysis` | 明确范围与风险，再审查分析 |
-| `plan-task` → `review-plan` | 设计实现路径，再审查方案 |
+| `analyze-task` | 明确范围与风险，再选择精简、标准或完整路径 |
+| `review-analysis` | 仅在完整路径需要独立需求检查点时审查分析 |
+| `plan-task` / `review-plan` | 标准和完整路径需要设计方案；只有完整路径独立审查方案 |
 | `code-task` → `review-code` | 实现并测试；`code-task` 创建本地 checkpoint，再由结构化审查检视该 checkpoint |
 | `create-pr` → `complete-task` | 将已通过审查的 checkpoint 发布到任务绑定目标分支，并在合并和最终门禁通过后归档 |
 

package/dist/bin/internal-cli.js

@@ -49,7 +49,9 @@ function taskControlTransportFailure(message, code = 'TASK_CONTROL_TRANSPORT_INV
 }
 let controlRouted = false;
 if (!taskViewGuardFailed && !markerlessHelp && (taskControlCommand || taskWorkflowCommand || manualValidationWorkflowCommand)) {
-    const transport = resolveSandboxControlTransport(process.env);
+    const transport = resolveSandboxControlTransport(process.env, {
+        localWorkflow: command === 'task-orchestration' || command === 'task-finalization' || taskWorkflowCommand || manualValidationWorkflowCommand
+    });
     switch (transport.kind) {
         case 'fail-closed': {
             const reason = transport.reasonCode ?? 'TASK_CONTROL_TRANSPORT_INVALID';
@@ -60,9 +62,12 @@ if (!taskViewGuardFailed && !markerlessHelp && (taskControlCommand || taskWorkfl
             // The host CLI is the direct-host authority. Domain handlers retain their
             // task locks, atomic writes, and operation-specific recovery facts.
             break;
+        case 'sandbox-local': {
+            break;
+        }
         case 'broker-client': {
             const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
-            await sandboxControl(['client', ...(taskControlCommand ? [command] : ['task-workflow', command]), ...process.argv.slice(3)]);
+            await sandboxControl(['client', command, ...process.argv.slice(3)]);
             break;
         }
     }

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

@@ -408,6 +408,9 @@ function defineAgentClientAdapter(candidate) {
         capabilities: Object.freeze(capabilities),
         modelSelection: frozenModelSelection,
         delegationEvidence: Object.freeze({ ...evidence }),
+        ...(candidate.orchestrationAdapter === undefined
+            ? {}
+            : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
         project: Object.freeze({
             ownedPathPrefixes: Object.freeze(paths),
             ...projectAssets,

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

@@ -0,0 +1,234 @@
+import fs from 'node:fs';
+import { createCodexLifecycleStore } from './store.js';
+import { managedDelegationRole } from '../../../task/delegation-receipts.js';
+import { normalizeAgentToken } from '../../tokens.js';
+import { locateActivityLog, pairEntries, appendActivityEntry } from '../../../task/activity-log.js';
+import { captureTaskWriteMetadata, writeTask } from '../../../task/write.js';
+import { parseTypedTaskFrontmatter } from '../../../task/frontmatter.js';
+import { resolveTaskRef } from '../../../task/resolve-ref.js';
+import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js';
+import { recoverActivatedOrchestrationDelegationUnderLock, readRun } from '../../../task/orchestration.js';
+const ACTIONS = {
+    analysis: 'Analyze Task',
+    'review-analysis': 'Review Analysis',
+    plan: 'Plan Task',
+    'review-plan': 'Review Plan',
+    code: 'Code Task',
+    'review-code': 'Review Code'
+};
+function result(request, status, extra = {}) {
+    return {
+        status,
+        changed: status === 'applied',
+        targetState: 'active',
+        requestRef: request.taskRef,
+        intent: 'recover-started',
+        taskId: null,
+        receiptId: null,
+        childId: null,
+        error: null,
+        ...extra
+    };
+}
+function failure(request, status, code, message, extra = {}) {
+    return result(request, status, { error: { code, message }, ...extra });
+}
+function actionPattern(receipt) {
+    const action = ACTIONS[receipt.stage];
+    if (!action)
+        return null;
+    const escaped = action.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return new RegExp(`^${escaped} \\(Round ${receipt.round}(?:, (?:fix for review-code(?:-r[2-9]|-r[1-9]\\d+)?.md|decision II-[1-9]\\d*))?\\)$`, 'u');
+}
+function openRows(section) {
+    return pairEntries([...section.entries]).filter((row) => row.started !== '' && row.done === '');
+}
+function rowForReceipt(rows, receipt) {
+    const pattern = actionPattern(receipt);
+    return pattern ? rows.filter((row) => pattern.test(row.step)) : [];
+}
+function readLifecycleStore(options, repoRoot) {
+    return options.lifecycleStore ?? createCodexLifecycleStore({
+        root: resolveAgentRuntimeStoreRoot({ repoRoot, store: 'lifecycle' }),
+        cliVersion: 'recovery',
+        now: options.now
+    });
+}
+function readStoredEvidence(store, childId) {
+    try {
+        return store.read(childId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('was not found uniquely'))
+            return { missing: true };
+        return { error: error instanceof Error ? error : new Error(message) };
+    }
+}
+function validateStopRecord(record, receipt) {
+    const start = record.state.startEvidence;
+    const stop = record.state.stopEvidence;
+    const provenance = receipt.lifecycleProvenance;
+    const host = receipt.hostEvidence;
+    if (receipt.client !== 'codex'
+        || !provenance
+        || host?.kind !== 'codex-lifecycle-v2'
+        || !start
+        || !stop
+        || record.state.status !== 'stop-ready'
+        || stop.terminalStatus !== 'completed'
+        || stop.hookStopObserved !== true
+        || start.childThreadId !== receipt.childId
+        || start.parentThreadId !== receipt.parentId
+        || managedDelegationRole(start.nativeAgent) !== receipt.role
+        || start.hookDefinitionHash !== provenance.hookDefinitionHash
+        || host.hookDefinitionHash !== provenance.hookDefinitionHash
+        || host.capabilitySessionId !== provenance.capabilitySessionId
+        || host.capabilityTurnId !== provenance.capabilityTurnId
+        || host.capabilityToolUseId !== provenance.capabilityToolUseId
+        || host.spawnToolUseId !== start.spawnToolUseId
+        || !host.spawnObservedAt
+        || host.spawnObservedAt !== record.spawnObservedAt
+        || host.controllerInstanceDigest !== provenance.controllerInstanceDigest
+        || host.controlGeneration !== provenance.controlGeneration
+        || typeof host.controllerInstanceDigest !== 'string'
+        || typeof host.controlGeneration !== 'string'
+        || host.startRevision < 1
+        || record.revision <= host.startRevision
+        || record.state.child?.childThreadId !== receipt.childId
+        || record.state.stop?.childThreadId !== receipt.childId) {
+        return { ok: false, code: 'RECOVERY_STOP_EVIDENCE_INVALID', message: 'Codex stop evidence does not match the activated receipt' };
+    }
+    if (record.consumer !== null && record.consumer !== receipt.id) {
+        return { ok: false, code: 'RECOVERY_CONSUMER_CONFLICT', message: `Codex lifecycle evidence was consumed by '${record.consumer}'` };
+    }
+    return { ok: true };
+}
+function abortedCandidates(run, rows) {
+    const candidates = run.receipts.flatMap((receipt) => {
+        if (receipt.status !== 'aborted' || receipt.activatedAt === null || receipt.client !== 'codex')
+            return [];
+        const matches = rowForReceipt(rows, receipt);
+        return matches.length === 1 ? [{ receipt, row: matches[0] }] : [];
+    });
+    return candidates;
+}
+function appendRecoveryLog(request, taskId, section, candidate, repoRoot, writer) {
+    const metadata = captureTaskWriteMetadata();
+    const body = appendActivityEntry(section, {
+        time: metadata.timestamp,
+        step: `${candidate.row.step} [aborted]`,
+        agent: request.agent,
+        note: `terminated Codex delegation; receipt=${candidate.receipt.id}; child=${candidate.receipt.childId}`
+    });
+    const written = writer({
+        taskRef: taskId,
+        expectedState: 'active',
+        mutations: [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body }]
+    }, { repoRoot, metadataProvider: () => metadata });
+    if (written.status === 'failed') {
+        return failure(request, 'owner-unknown', 'RECOVERY_LOG_WRITE_FAILED', written.error.message, {
+            taskId, receiptId: candidate.receipt.id, childId: candidate.receipt.childId
+        });
+    }
+    return result(request, 'applied', {
+        taskId, receiptId: candidate.receipt.id, childId: candidate.receipt.childId
+    });
+}
+function recoverStartedLifecycleUnderLock(request, options = {}) {
+    if (!request || request.intent !== 'recover-started' || request.auto !== true || normalizeAgentToken(request.agent) !== 'codex') {
+        return failure(request, 'conflict', 'RECOVERY_PAYLOAD_INVALID', 'automatic recovery requires a task and the Codex agent');
+    }
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failure(request, 'conflict', resolved.code, resolved.message);
+    const taskId = resolved.taskId;
+    let content;
+    try {
+        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+        parseTypedTaskFrontmatter(content);
+    }
+    catch (error) {
+        return failure(request, 'conflict', 'RECOVERY_TASK_INVALID', error instanceof Error ? error.message : String(error), { taskId });
+    }
+    const section = locateActivityLog(content);
+    if (!section)
+        return failure(request, 'conflict', 'RECOVERY_LOG_INVALID', 'task has no unique Activity Log section', { taskId });
+    let run;
+    try {
+        run = readRun(resolved.taskDir, options.orchestration);
+    }
+    catch (error) {
+        return failure(request, 'owner-unknown', 'RECOVERY_ORCHESTRATION_UNKNOWN', error instanceof Error ? error.message : String(error), { taskId });
+    }
+    if (!run)
+        return result(request, 'no-op', { taskId });
+    const rows = openRows(section);
+    const pending = run.pendingDelegation;
+    if (!pending) {
+        const candidates = abortedCandidates(run, rows);
+        if (candidates.length === 0)
+            return result(request, 'no-op', { taskId });
+        if (candidates.length > 1) {
+            return failure(request, 'conflict', 'RECOVERY_CANDIDATE_AMBIGUOUS', 'more than one aborted delegation has an open lifecycle row', { taskId });
+        }
+        return appendRecoveryLog(request, taskId, section, candidates[0], resolved.repoRoot, options.writeTask ?? writeTask);
+    }
+    if (pending.status !== 'activated')
+        return result(request, 'no-op', { taskId });
+    if (pending.client !== 'codex' || run.status !== 'running' || run.pause !== null) {
+        return failure(request, 'conflict', 'RECOVERY_ORCHESTRATION_INVALID', 'activated recovery requires one running Codex delegation', {
+            taskId, receiptId: pending.id, childId: pending.childId
+        });
+    }
+    const matchingRows = rowForReceipt(rows, pending);
+    if (matchingRows.length !== 1 || normalizeAgentToken(matchingRows[0].agent) !== 'codex' || matchingRows[0].note !== 'started') {
+        return failure(request, 'conflict', 'RECOVERY_LOG_CONFLICT', 'activated delegation does not have one matching open lifecycle row', {
+            taskId, receiptId: pending.id, childId: pending.childId
+        });
+    }
+    if (!pending.childId) {
+        return failure(request, 'conflict', 'RECOVERY_DELEGATION_INVALID', 'activated delegation has no child identity', { taskId, receiptId: pending.id });
+    }
+    const store = readLifecycleStore(options, resolved.repoRoot);
+    const stored = readStoredEvidence(store, pending.childId);
+    if ('error' in stored)
+        return failure(request, 'owner-unknown', 'RECOVERY_STORE_UNKNOWN', stored.error.message, { taskId, receiptId: pending.id, childId: pending.childId });
+    if ('missing' in stored)
+        return failure(request, 'owner-unknown', 'RECOVERY_STOP_EVIDENCE_MISSING', 'matching Codex lifecycle stop evidence is missing', { taskId, receiptId: pending.id, childId: pending.childId });
+    const evidence = validateStopRecord(stored, pending);
+    if (!evidence.ok)
+        return failure(request, evidence.code === 'RECOVERY_CONSUMER_CONFLICT' ? 'conflict' : 'owner-unknown', evidence.code, evidence.message, { taskId, receiptId: pending.id, childId: pending.childId });
+    let consumed = stored;
+    if (stored.consumer === null) {
+        try {
+            consumed = store.consume(pending.childId, pending.id, pending.hostEvidence?.hookDefinitionHash);
+        }
+        catch (error) {
+            return failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_CONSUME_FAILED', error instanceof Error ? error.message : String(error), { taskId, receiptId: pending.id, childId: pending.childId });
+        }
+    }
+    if (!consumed.consumedAt) {
+        return failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_INVALID', 'consumed stop evidence has no timestamp', { taskId, receiptId: pending.id, childId: pending.childId });
+    }
+    const recovered = recoverActivatedOrchestrationDelegationUnderLock(taskId, {
+        receiptId: pending.id,
+        stage: pending.stage,
+        round: pending.round,
+        artifact: pending.artifact,
+        startedAgent: request.agent,
+        childId: pending.childId,
+        stopRevision: consumed.revision,
+        consumer: pending.id,
+        consumedAt: consumed.consumedAt
+    }, { ...options.orchestration, repoRoot: resolved.repoRoot, now: options.now });
+    if (recovered.status === 'failed' || !recovered.run) {
+        return failure(request, 'owner-unknown', recovered.error?.code ?? 'RECOVERY_ORCHESTRATION_FAILED', recovered.error?.message ?? 'orchestration recovery failed', { taskId, receiptId: pending.id, childId: pending.childId });
+    }
+    return appendRecoveryLog(request, taskId, section, { receipt: recovered.run.receipts.at(-1), row: matchingRows[0] }, resolved.repoRoot, options.writeTask ?? writeTask);
+}
+function recoverStartedLifecycleFromAdapter(request, options = {}) {
+    return recoverStartedLifecycleUnderLock(request, options);
+}
+export { recoverStartedLifecycleFromAdapter, recoverStartedLifecycleUnderLock };
+//# sourceMappingURL=recovery.js.map

package/dist/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.js

@@ -5,8 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import semver from 'semver';
 import * as toml from 'smol-toml';
-import { requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify, requestSandboxControl } from '../../../sandbox/control/client.js';
-import { readSandboxControlStatus } from '../../../sandbox/control/state.js';
+import { requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify } from '../../../sandbox/control/client.js';
 import { getProcessStartTime } from '../../../server/process-state.js';
 import { LIFECYCLE_PROTOCOL_VERSION } from './build-identity.js';
 import { contextFromControllerLease, controllerProofFromContext, verifyCodexSandboxControllerContextWithWarnings as verifyContextFileWithWarnings, writeCodexSandboxControllerContext } from './controller-context.js';
@@ -56,44 +55,18 @@ function verifyRuntime(runtimeDir) {
         fs.rmSync(probe, { force: true });
     }
 }
-function verifyControl(taskId, control) {
+function verifyControllerBinding(context, control, requestControllerVerify) {
     verifyRuntime(control.runtimeDir);
-    let status = null;
-    let lastError = null;
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-        try {
-            status = readSandboxControlStatus(control.statusDir);
-            break;
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt < 4)
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
-        }
-    }
-    if (!status) {
-        throw new Error(`CODEX_SANDBOX_CONTROLLER_CONTROL_UNAVAILABLE: ${String(lastError)}`);
-    }
-    if (status.generation !== control.generation
-        || status.state !== 'healthy'
-        || Date.now() - status.updatedAt > 1_500) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTROL_UNAVAILABLE');
-    }
-    const response = requestSandboxControl({
-        family: 'task-orchestration',
-        args: [taskId, 'status'],
+    const verified = requestControllerVerify({
+        controllerProof: controllerProofFromContext(context),
         ...control,
         timeoutMs: 30_000
     });
-    let payload = {};
-    try {
-        payload = JSON.parse(response.stdout);
-    }
-    catch {
+    if (verified.binding.taskId !== context.taskId
+        || verified.binding.controlGeneration !== context.controlGeneration
+        || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
         throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
     }
-    if (payload.taskId !== taskId)
-        throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
 }
 function verifyCodexSandboxControllerContextWithWarnings(contextPath, options = {}) {
     const control = options.control ?? controlFromEnvironment();
@@ -272,7 +245,7 @@ function prepareCodexSandboxController(input, options = {}) {
             || opened.lease.controllerProcess.startTime !== parentStartTime) {
             throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
         }
-        (options.verifyTaskBinding ?? verifyControl)(taskId, control);
+        verifyControllerBinding(context, control, options.verifyController ?? requestCodexControllerVerify);
         const contextPath = path.join(home, 'controller-context.json');
         writeCodexSandboxControllerContext(contextPath, context);
         const shimDir = path.join(home, 'bin');

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

@@ -6,19 +6,9 @@ import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js'
 const LOCK_RETRY_MS = 10;
 const LOCK_TIMEOUT_MS = 1_000;
 const LOCK_STALE_MS = 30_000;
-const RECOVERY_CONSUMER_RE = /^lifecycle-recovery:([^:\r\n]+):([^:\r\n]+)$/u;
 function digest(value) {
     return crypto.createHash('sha256').update(value).digest('hex');
 }
-function isRecoveryConsumer(value) {
-    return RECOVERY_CONSUMER_RE.test(value);
-}
-function recoveryConsumer(taskId, receiptId) {
-    if (!/^[^:\r\n]+$/u.test(taskId) || !/^[^:\r\n]+$/u.test(receiptId)) {
-        throw new Error('Codex lifecycle recovery claim identity is invalid');
-    }
-    return `lifecycle-recovery:${taskId}:${receiptId}`;
-}
 function readRecord(file) {
     const value = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (value.schemaVersion !== 1
@@ -255,29 +245,8 @@ function createCodexLifecycleStore(options) {
     function consume(childThreadId, consumer, expectedHookDefinitionHash) {
         if (!consumer.trim())
             throw new Error('Codex lifecycle consumer is required');
-        if (consumer.startsWith('lifecycle-recovery:')) {
-            throw new Error('Codex lifecycle recovery claims require claimRecovery');
-        }
         return consumeInternal(childThreadId, consumer, expectedHookDefinitionHash);
     }
-    function claimRecovery(childThreadId, taskId, receiptId, expectedHookDefinitionHash) {
-        return consumeInternal(childThreadId, recoveryConsumer(taskId, receiptId), expectedHookDefinitionHash);
-    }
-    function releaseRecovery(childThreadId, consumer) {
-        if (!/^lifecycle-recovery:[^:\r\n]+:[^:\r\n]+$/.test(consumer))
-            return false;
-        return withWriteLock(() => {
-            const matches = findByChild(childThreadId);
-            if (matches.length !== 1)
-                return false;
-            const file = matches[0];
-            const current = readRecord(file);
-            if (current.state.status !== 'stop-ready' || current.consumer !== consumer || !current.consumedAt)
-                return false;
-            fs.unlinkSync(file);
-            return true;
-        });
-    }
     function expireBefore(cutoff) {
         return withWriteLock(() => {
             let changed = 0;
@@ -285,8 +254,6 @@ function createCodexLifecycleStore(options) {
                 const current = readRecord(file);
                 if (current.updatedAt >= cutoff)
                     continue;
-                if (current.consumer && isRecoveryConsumer(current.consumer))
-                    continue;
                 if (current.consumer || ['invalid', 'expired', 'stop-ready'].includes(current.state.status)) {
                     fs.unlinkSync(file);
                     changed += 1;
@@ -306,7 +273,7 @@ function createCodexLifecycleStore(options) {
             return changed;
         });
     }
-    return Object.freeze({ root, apply, applyToSpawn, consume, claimRecovery, releaseRecovery, expireBefore, findByParent, read });
+    return Object.freeze({ root, apply, applyToSpawn, consume, expireBefore, findByParent, read });
 }
 export { createCodexLifecycleStore, hasActiveCodexLifecycleEvidence };
 //# sourceMappingURL=store.js.map

package/dist/lib/agent-clients/adapters/codex.js

@@ -24,6 +24,16 @@ const codexAdapter = defineAgentClientAdapter({
         actualModel: 'app-server',
         actualReasoningEffort: 'app-server'
     },
+    orchestrationAdapter: {
+        prepareDelegation: async (...args) => {
+            const { prepareCodexOrchestrationDelegation } = await import('../../task/codex-orchestration.js');
+            return prepareCodexOrchestrationDelegation(...args);
+        },
+        recoverStarted: async (...args) => {
+            const { recoverStartedLifecycleFromAdapter } = await import('./codex-lifecycle/recovery.js');
+            return recoverStartedLifecycleFromAdapter(...args);
+        }
+    },
     project: {
         ownedPathPrefixes: ['.codex/'],
         managed: ['.codex/hooks.json', '.codex/agents/'],

package/dist/lib/internal/cli-route-inventory.js

@@ -50,7 +50,7 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
     'pr-review-grade': ['decide', 'resolve-host', 'verify-artifact'],
     'platform-checks': ['inspect', 'watch', 'resolve-run', 'logs'],
     'task-context': ['resolve'],
-    'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert'],
+    'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert', 'rework-intent-rebuild'],
     'task-warning': ['list', 'add', 'set-status'],
     'task-activity': ['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate'],
     'task-artifact': ['inspect', 'init', 'preflight', 'finalize-local'],