@fitlab-ai/agent-infra 0.11.12 → 0.11.14

package/dist/lib/task/orchestration.js

@@ -6,7 +6,7 @@ import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 import { parseReviewSummary } from './review-artifacts.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
-import { resolveTaskRef } from './resolve-ref.js';
+import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { activateDelegation, abortActivatedDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
 import { normalizeAgentClients } from '../agent-clients/config.js';
 import { getAgentClientAdapter, getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
@@ -77,7 +77,7 @@ function isModelPolicy(value) {
 }
 const RECOVERY_GUARD_KEYS = [
     'stepCount', 'nextStage', 'baselineEmpty', 'receiptCount', 'pendingDelegation',
-    'commitAuthorizationUnused', 'completionEvidenceAbsent'
+    'completionEvidenceAbsent'
 ];
 function isRecovery(value) {
     if (!hasExactKeys(value, [
@@ -97,7 +97,6 @@ function isRecovery(value) {
         && guards.baselineEmpty === true
         && guards.receiptCount === 0
         && guards.pendingDelegation === false
-        && guards.commitAuthorizationUnused === true
         && guards.completionEvidenceAbsent === true
         && value.resultingStatus === 'running';
 }
@@ -117,7 +116,7 @@ export function isCompletionEvidence(value) {
 const ORCHESTRATION_RUN_KEYS = [
     'taskId', 'runId', 'status', 'nextStage', 'stepCount', 'maxSteps', 'modelPolicy',
     'modelPolicySource', 'recoveryHistory', 'baseline', 'pendingDelegation', 'receipts',
-    'pause', 'commitAuthorization', 'completionEvidence', 'createdAt', 'updatedAt'
+    'pause', 'completionEvidence', 'createdAt', 'updatedAt'
 ];
 function orchestrationStateReasonCodes(value) {
     if (!hasExactKeys(value, ORCHESTRATION_RUN_KEYS))
@@ -151,15 +150,6 @@ function orchestrationStateReasonCodes(value) {
         reasons.push('receipts');
     if (!(record.pause === null || isPause(record.pause)))
         reasons.push('pause');
-    if (!hasExactKeys(record.commitAuthorization, ['issuedAt', 'consumedAt'])) {
-        reasons.push('commitAuthorization');
-    }
-    else {
-        if (!nullableText(record.commitAuthorization.issuedAt))
-            reasons.push('commitAuthorization.issuedAt');
-        if (!nullableText(record.commitAuthorization.consumedAt))
-            reasons.push('commitAuthorization.consumedAt');
-    }
     if (!(record.completionEvidence === null || isCompletionEvidence(record.completionEvidence)))
         reasons.push('completionEvidence');
     if (!exactText(record.createdAt))
@@ -392,8 +382,6 @@ function canRecoverUnsupportedClientPause(run) {
         && run.baseline === ''
         && run.pendingDelegation === null
         && run.receipts.length === 0
-        && run.commitAuthorization?.issuedAt === null
-        && run.commitAuthorization?.consumedAt === null
         && run.completionEvidence == null
         && run.recoveryHistory.length === 0;
 }
@@ -443,7 +431,6 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
                     baselineEmpty: true,
                     receiptCount: 0,
                     pendingDelegation: false,
-                    commitAuthorizationUnused: true,
                     completionEvidenceAbsent: true
                 },
                 resultingStatus: 'running'
@@ -497,7 +484,6 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
         pendingDelegation: null,
         receipts: [],
         pause: null,
-        commitAuthorization: { issuedAt: null, consumedAt: null },
         completionEvidence: null,
         createdAt: now,
         updatedAt: now
@@ -858,72 +844,40 @@ function dispatchOrchestrationDelegation(taskRef, options = {}) {
     }
 }
 function matchingDelegations(predicate, options) {
+    const taskId = options.taskId;
+    if (taskId === undefined || taskId === '') {
+        return { ok: false, error: failed('ORCHESTRATION_TASK_ID_REQUIRED', 'taskId is required for lifecycle matching') };
+    }
+    if (typeof taskId !== 'string' || !TASK_ID_RE.test(taskId)) {
+        return { ok: false, error: failed('ORCHESTRATION_TASK_ID_INVALID', 'taskId must be a canonical TASK-id') };
+    }
     const repoRoot = options.repoRoot ?? process.cwd();
-    if (options.taskId) {
-        const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', options.taskId);
-        const run = readRun(taskDir, options);
-        return run && run.status === 'running' && run.pendingDelegation && predicate(run.pendingDelegation)
-            ? [{ taskId: options.taskId, run }]
-            : [];
-    }
-    const activeRoot = path.join(repoRoot, '.agents', 'workspace', 'active');
-    if (!fs.existsSync(activeRoot))
-        return [];
-    emitDiagnostic(options, 'orchestration-active-scan-start', {
-        activeRoot
-    });
-    const matches = fs.readdirSync(activeRoot, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .flatMap((entry) => {
-        const candidateTaskId = entry.name;
-        const candidateTaskDir = path.join(activeRoot, candidateTaskId);
-        emitDiagnostic(options, 'orchestration-active-scan-candidate', {
-            candidateTaskId,
-            candidateTaskDir,
-            orchestrationPath: orchestrationPath(candidateTaskDir)
-        });
-        let run;
-        try {
-            run = readRun(candidateTaskDir, options);
-        }
-        catch (error) {
-            emitDiagnostic(options, 'orchestration-active-scan-candidate-failed', {
-                candidateTaskId,
-                candidateTaskDir,
-                errorType: error instanceof Error ? error.name : typeof error,
-                reasonCodes: error instanceof OrchestrationStateError ? error.reasonCodes.join(',') : null
-            });
-            throw error;
-        }
-        if (!run || run.status !== 'running' || !run.pendingDelegation)
-            return [];
-        const receipt = run.pendingDelegation;
-        return predicate(receipt)
-            ? [{ taskId: candidateTaskId, run }]
-            : [];
-    });
-    emitDiagnostic(options, 'orchestration-active-scan-finished', {
-        activeRoot,
-        matchingDelegations: matches.length
-    });
-    return matches;
+    const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const run = readRun(taskDir, options);
+    const matches = run && run.status === 'running' && run.pendingDelegation && predicate(run.pendingDelegation)
+        ? [{ taskId, run }]
+        : [];
+    return { ok: true, matches };
 }
 function uniqueMatchingDelegation(client, predicate, options) {
-    const matches = matchingDelegations((receipt) => receipt.client === client && predicate(receipt), options);
+    const lookup = matchingDelegations((receipt) => receipt.client === client && predicate(receipt), options);
+    if (!lookup.ok)
+        return lookup.error;
+    const matches = lookup.matches;
     if (matches.length === 0)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'no matching lifecycle delegation exists');
-    if (matches.length > 1)
-        return failed('ORCHESTRATION_DELEGATION_AMBIGUOUS', 'multiple lifecycle delegations match the native hook event');
     return matches[0];
 }
 function hasActivatableOrchestrationDelegation(client, childId, options = {}) {
-    return matchingDelegations((receipt) => receipt.client === client && (receipt.status === 'prepared'
-        || (receipt.childId === childId && ['activated', 'stage-completed'].includes(receipt.status))), options).length > 0;
+    const lookup = matchingDelegations((receipt) => receipt.client === client && (receipt.status === 'prepared'
+        || (receipt.childId === childId && ['activated', 'stage-completed'].includes(receipt.status))), options);
+    return lookup.ok && lookup.matches.length > 0;
 }
 function hasSealableOrchestrationDelegation(client, childId, options = {}) {
-    return matchingDelegations((receipt) => receipt.client === client
+    const lookup = matchingDelegations((receipt) => receipt.client === client
         && receipt.childId === childId
-        && ['stage-completed', 'sealed'].includes(receipt.status), options).length > 0;
+        && ['stage-completed', 'sealed'].includes(receipt.status), options);
+    return lookup.ok && lookup.matches.length > 0;
 }
 function activateMatchingOrchestrationDelegation(client, event, options = {}) {
     const role = managedDelegationRole(event.nativeAgent);

package/dist/lib/task/short-id.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
 const REGISTRY_NAME = '.short-ids.json';
 const LOCK_NAME = '.short-ids.json.lock';
 function normalizeShortIdInput(input, opts) {
@@ -90,20 +91,33 @@ function resolveShortIdReadOnly(input, repoRoot, opts) {
     const taskId = ids[key];
     if (!taskId) {
         const message = Object.keys(ids).length === 0
-            ? `short id '${key}' not found; active task registry is empty.`
-            : `short id '${key}' not found in active task registry (it may have been cleaned up after archival; check 'task-short-id.js list').`;
+            ? `short id '${key}' not found; task short-id registry is empty.`
+            : `short id '${key}' not found in task short-id registry.`;
         return shortIdFailure('SHORT_ID_NOT_FOUND', message);
     }
-    const taskMdPath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
-    if (!fs.existsSync(taskMdPath)) {
-        const remainingActiveEntries = Object.values(ids).filter((candidateTaskId) => fs.existsSync(path.join(repoRoot, '.agents', 'workspace', 'active', candidateTaskId, 'task.md')));
-        const message = remainingActiveEntries.length === 0
-            ? `short id '${key}' not found; active task registry is empty.`
-            : `short id '${key}' not found in active task registry (it may have been cleaned up after archival; check 'task-short-id.js list').`;
-        return shortIdFailure('SHORT_ID_STALE', message, taskId);
+    const activeTask = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
+    const completedTask = path.join(repoRoot, '.agents', 'workspace', 'completed', taskId, 'task.md');
+    let isValidCompletedTask = false;
+    try {
+        const task = parseTypedTaskFrontmatter(fs.readFileSync(completedTask, 'utf8'));
+        isValidCompletedTask = task.id === taskId && task.status === 'completed';
+    }
+    catch { /* a mapping is valid only while its task content is present */ }
+    if (!fs.existsSync(activeTask) && !isValidCompletedTask) {
+        return shortIdFailure('SHORT_ID_STALE', `short id '${key}' points to no active or completed task content.`, taskId);
     }
     return { ok: true, taskId };
 }
+function hasRetainedCompletedTask(activeDir, taskId) {
+    try {
+        const taskPath = path.join(path.dirname(activeDir), 'completed', taskId, 'task.md');
+        const task = parseTypedTaskFrontmatter(fs.readFileSync(taskPath, 'utf8'));
+        return task.id === taskId && task.status === 'completed';
+    }
+    catch {
+        return false;
+    }
+}
 function configuredShortIdLength(repoRoot) {
     try {
         const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
@@ -206,7 +220,8 @@ function mutateShortIdRegistryAt(activeDir, width, taskId, requested, onlyReleas
         const original = JSON.stringify(registry.ids);
         if (pruneOrphans) {
             for (const [key, candidate] of Object.entries(registry.ids)) {
-                if (candidate !== taskId && !fs.existsSync(path.join(activeDir, candidate, 'task.md')))
+                if (candidate !== taskId && !fs.existsSync(path.join(activeDir, candidate, 'task.md'))
+                    && !hasRetainedCompletedTask(activeDir, candidate))
                     delete registry.ids[key];
             }
         }
@@ -277,34 +292,29 @@ function executeShortIdCommand(request) {
             if (normalized.kind !== 'shortId') {
                 throw Object.assign(new Error(`invalid short id format '${request.argument}'`), { code: 'SHORT_ID_FORMAT_INVALID' });
             }
-            return withRegistryLock(request.activeDir, () => {
-                const registry = readRegistryStrict(registryPath, request.shortIdLength);
-                let changed = false;
-                for (const [key, taskId] of Object.entries(registry.ids)) {
-                    if (!fs.existsSync(path.join(request.activeDir, taskId, 'task.md'))) {
-                        delete registry.ids[key];
-                        changed = true;
-                    }
-                }
-                if (changed)
-                    writeRegistry(registryPath, registry);
-                const taskId = registry.ids[normalized.value];
-                if (!taskId)
-                    throw Object.assign(new Error(`short id '${normalized.value}' not found in active task registry`), { code: 'SHORT_ID_NOT_FOUND' });
-                return { status: changed ? 'applied' : 'no-op', changed, output: taskId, error: null };
-            });
+            const registry = readRegistryStrict(registryPath, request.shortIdLength);
+            const taskId = registry.ids[normalized.value];
+            if (!taskId)
+                throw Object.assign(new Error(`short id '${normalized.value}' not found in task short-id registry`), { code: 'SHORT_ID_NOT_FOUND' });
+            if (!fs.existsSync(path.join(request.activeDir, taskId, 'task.md'))
+                && !hasRetainedCompletedTask(request.activeDir, taskId)) {
+                throw Object.assign(new Error(`short id '${normalized.value}' points to a task without active or completed task content`), { code: 'SHORT_ID_STALE' });
+            }
+            return { status: 'no-op', changed: false, output: taskId, error: null };
         }
         const registry = readRegistryStrict(registryPath, request.shortIdLength);
         if (request.verify) {
             const active = fs.existsSync(request.activeDir)
                 ? fs.readdirSync(request.activeDir).filter((entry) => /^TASK-\d{8}-\d{6}$/.test(entry) && fs.existsSync(path.join(request.activeDir, entry, 'task.md')))
                 : [];
+            const retained = Object.values(registry.ids).filter((taskId) => hasRetainedCompletedTask(request.activeDir, taskId));
+            const validTasks = new Set([...active, ...retained]);
             const registered = new Map();
             for (const [key, taskId] of Object.entries(registry.ids))
                 registered.set(taskId, [...(registered.get(taskId) ?? []), key]);
             const diff = {
                 missing_in_registry: active.filter((taskId) => !registered.has(taskId)).map((taskId) => ({ taskId })),
-                orphans_in_registry: Object.entries(registry.ids).filter(([, taskId]) => !active.includes(taskId)).map(([key, taskId]) => ({ key, taskId })),
+                orphans_in_registry: Object.entries(registry.ids).filter(([, taskId]) => !validTasks.has(taskId)).map(([key, taskId]) => ({ key, taskId })),
                 duplicate_registry_keys: [...registered.entries()].filter(([, keys]) => keys.length > 1).map(([taskId, keys]) => ({ taskId, keys }))
             };
             const clean = Object.values(diff).every((items) => items.length === 0);

package/dist/lib/task/verification-engine.js

@@ -147,14 +147,9 @@ function checkOrchestrationState({ taskDir }) {
         return failResult('orchestration-state', 'Paused run requires a stable pause code and message');
     }
     if (run.status === 'completed') {
-        if (run.completionEvidence != null) {
-            const evidenceError = validateCleanCompletionEvidence(run);
-            if (evidenceError)
-                return failResult('orchestration-state', evidenceError);
-        }
-        else if (run.pendingDelegation !== null || !run.commitAuthorization?.consumedAt) {
-            return failResult('orchestration-state', 'Completed run must consume commit authorization and clear pending delegation');
-        }
+        const evidenceError = validateCleanCompletionEvidence(run);
+        if (evidenceError)
+            return failResult('orchestration-state', evidenceError);
     }
     else if (run.completionEvidence != null) {
         return failResult('orchestration-state', 'Clean completion evidence requires a completed run');
@@ -186,10 +181,8 @@ function validateCleanCompletionEvidence(run) {
     }
     if (run.status !== 'completed'
         || run.pendingDelegation !== null
-        || run.commitAuthorization?.issuedAt !== null
-        || run.commitAuthorization?.consumedAt !== null
         || run.receipts.some((receipt) => receipt.stage === 'commit')) {
-        return 'Clean completion evidence conflicts with commit delegation state';
+        return 'Clean completion evidence conflicts with pending delegation or commit receipt state';
     }
     return null;
 }

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.12",
-  "sourceInputHash": "9d9be72538afb23d15312d9d5eeac8e0a9fb79b4b9b4f8715f0f0218c3f7cfdd",
-  "internalExecutableBuildHash": "6f21c8843c158d538c95d789a9e048df47bb25080e7f935d00cf60bcb85163db"
+  "packageVersion": "0.11.14",
+  "sourceInputHash": "24a7d69b687f9ea8fdee5f47f7e59d1b53e13452a7f4f8edd9ca5b494cb5a0d4",
+  "internalExecutableBuildHash": "9825f6d7ca5d82e4c5f774b94f0d5e94e1b312583406eeb89a74d717ad757c4a"
 }

package/lib/agent-clients/adapter.ts

@@ -23,28 +23,6 @@ import type {
   SandboxTool,
   SandboxToolContext
 } from '../sandbox/tool-types.ts';
-import type { SandboxControlManifest } from '../sandbox/control/protocol.ts';
-
-type AgentClientSandboxControlOperation = Readonly<{
-  validate: (params: Readonly<{
-    operation: string;
-    payload: Record<string, unknown>;
-    manifest: SandboxControlManifest;
-  }>) => void;
-  execute: (params: Readonly<{
-    operation: string;
-    payload: Record<string, unknown>;
-    manifest: SandboxControlManifest;
-    manifestPath: string;
-  }>) => Promise<Readonly<{ exitCode: number; stdout: string; stderr: string }>>;
-  recover?: (params: Readonly<{
-    operation: string;
-    manifest: SandboxControlManifest;
-    manifestPath: string;
-    stdout: string | null;
-  }>) => Readonly<Record<string, unknown>>;
-}>;
-
 type AgentClientCapabilities = AgentClientCapabilityMap;
 
 type AgentClientModelSelectionContext =
@@ -147,7 +125,6 @@ type AgentClientAdapter = Readonly<{
   modelSelection: AgentClientModelSelectionContext;
   delegationEvidence: AgentClientDelegationEvidence;
   orchestrationAdapter?: AgentClientOrchestrationAdapter;
-  sandboxControlOperation?: AgentClientSandboxControlOperation;
   project: AgentClientProjectDescriptor;
   sandbox: AgentClientSandboxDescriptor;
 }>;
@@ -728,9 +705,6 @@ function defineAgentClientAdapter(
     ...(candidate.orchestrationAdapter === undefined
       ? {}
       : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
-    ...(candidate.sandboxControlOperation === undefined
-      ? {}
-      : { sandboxControlOperation: Object.freeze({ ...candidate.sandboxControlOperation }) }),
     project: Object.freeze({
       ownedPathPrefixes: Object.freeze(paths),
       ...projectAssets,
@@ -753,7 +727,6 @@ export type {
   AgentClientCapabilities,
   AgentClientCustomCommandDescriptor,
   AgentClientDelegationEvidence,
-  AgentClientSandboxControlOperation,
   AgentClientLifecycleRecoveryRequest,
   AgentClientLifecycleRecoveryResult,
   AgentClientOrchestrationAdapter,

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

@@ -170,8 +170,7 @@ function validateCodexLifecycleHookConfig(value: unknown): void {
 
 function parseCodexHooksList(
   value: unknown,
-  repoRoot: string,
-  expectedSource: 'direct-host' | 'isolated-user' = 'direct-host'
+  repoRoot: string
 ): readonly DiscoveredHook[] {
   const root = object(value);
   const entries = Array.isArray(root?.data) ? root.data : [];
@@ -203,10 +202,8 @@ function parseCodexHooksList(
     && hook.currentHash.length > 0
     && hook.sourcePathDigest.length === 64
     && hook.pluginId === null
-    && (expectedSource === 'isolated-user'
-      ? hook.source === 'user' && hook.trustStatus !== 'modified'
-      : (hook.source === 'project' && hook.trustStatus === 'trusted')
-        || hook.isManaged && hook.trustStatus === 'managed')
+    && (hook.source === 'project' && hook.trustStatus === 'trusted'
+      || hook.isManaged && hook.trustStatus === 'managed')
   ));
   if (!valid) throw new Error('CODEX_PREFLIGHT_HOOKS_NOT_LOADED: lifecycle hooks are not loaded for this workspace');
   return Object.freeze(hooks);
@@ -628,7 +625,7 @@ function validateStaticCodexPreflight(repoRoot: string): Readonly<{ cliVersion:
 async function discoverLifecycleHooks(repoRoot: string): Promise<Readonly<{
   discoveredHooks: readonly DiscoveredHook[];
   hookProvenance: Readonly<{
-    hookSource: 'isolated-user' | 'managed' | 'project';
+    hookSource: 'managed' | 'project';
     hookSourcePathDigest: string;
     hookSourceHash: string;
   }>;
@@ -641,8 +638,7 @@ async function discoverLifecycleHooks(repoRoot: string): Promise<Readonly<{
     await transport.initialize();
     discoveredHooks = parseCodexHooksList(
       await transport.request('hooks/list', { cwds: [repoRoot] }),
-      repoRoot,
-      process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT ? 'isolated-user' : 'direct-host'
+      repoRoot
     );
   } finally { transport.close(); }
   const lifecycleHooks = LIFECYCLE_HOOKS.map(({ event, matcher, phase }) => discoveredHooks.filter((hook) =>
@@ -660,9 +656,7 @@ async function discoverLifecycleHooks(repoRoot: string): Promise<Readonly<{
     throw new Error('CODEX_PREFLIGHT_HOOK_SOURCE_AMBIGUOUS: lifecycle hooks do not share one exact source');
   }
   const source = [...sources][0];
-  const hookSource = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT
-    ? 'isolated-user'
-    : source === 'managed' ? 'managed' : 'project';
+  const hookSource = source === 'managed' ? 'managed' : 'project';
   return {
     discoveredHooks,
     hookProvenance: Object.freeze({

package/lib/agent-clients/adapters/codex-lifecycle/cli.ts

@@ -9,7 +9,6 @@ import {
   resolveCodexThread
 } from './app-server.ts';
 import { createCodexLifecycleStore } from './store.ts';
-import { verifyCodexSandboxControllerContextWithWarnings } from './sandbox-controller.ts';
 import type { CodexLifecycleEvent } from './evidence.ts';
 import { resolveTaskRef } from '../../../task/resolve-ref.ts';
 import { resolveTaskContext } from '../../../task/resolve-ref.ts';
@@ -103,10 +102,7 @@ function hookDefinitionHash(): string {
 }
 
 function resolveLifecycleTaskContext() {
-  const controllerPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-  const taskId = controllerPath
-    ? verifyCodexSandboxControllerContextWithWarnings(controllerPath, { repoRoot: process.cwd() }).context.taskId
-    : process.env.AGENT_INFRA_TASK_ID;
+  const taskId = process.env.AGENT_INFRA_TASK_ID;
   const context = taskId
     ? resolveTaskRef(taskId, { repoRoot: process.cwd() })
     : resolveTaskContext(undefined, { repoRoot: process.cwd() });

package/lib/agent-clients/adapters/codex-lifecycle/manifest-files.json

@@ -2,25 +2,18 @@
   "executableFiles": [
     "bin/internal-cli.ts",
     "lib/agent-clients/adapters/codex-lifecycle/cli.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/sandbox-controller-cli.ts",
     "lib/internal/sandbox-control.ts",
     "lib/internal/task-orchestration.ts",
     "lib/agent-clients/adapters/codex-orchestration.ts",
     "lib/task/delegation-receipts.ts",
     "lib/task/orchestration.ts",
     "lib/agent-clients/adapters/codex-lifecycle/build-identity.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-client.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-operation.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-context.ts",
     "lib/agent-clients/adapters/codex-lifecycle/app-server.ts",
     "lib/agent-clients/adapters/codex-lifecycle/binding.ts",
     "lib/agent-clients/adapters/codex-lifecycle/evidence.ts",
     "lib/agent-clients/adapters/codex-lifecycle/store.ts",
     "lib/agent-clients/adapters/codex-lifecycle/manifest-files.json",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-registration.ts",
     "lib/sandbox/control/protocol.ts",
-    "lib/sandbox/control/agent-operation.ts",
     "lib/sandbox/control/client.ts",
     "lib/sandbox/control/executor.ts",
     "lib/server/process-state.ts",

package/lib/agent-clients/adapters/codex-lifecycle/recovery.ts

@@ -216,15 +216,11 @@ function hostEvidenceMatches(
     && host.spawnToolUseId === start.spawnToolUseId
     && Boolean(host.spawnObservedAt)
     && host.spawnObservedAt === record.spawnObservedAt
-    && typeof host.controllerInstanceDigest === 'string'
-    && typeof host.controlGeneration === 'string'
     && hostRevisionMatches(record, receipt, host);
 }
 
 function hostRevisionMatches(record: StoredCodexLifecycle, receipt: DelegationReceipt, host: CodexLifecycleActivationEvidence): boolean {
-  return typeof host.controllerInstanceDigest === 'string'
-    && typeof host.controlGeneration === 'string'
-    && host.startRevision >= 1
+  return host.startRevision >= 1
     && record.revision > host.startRevision
     && record.state.child?.childThreadId === receipt.childId
     && record.state.stop?.childThreadId === receipt.childId;

package/lib/agent-clients/adapters/codex-lifecycle/store.ts

@@ -35,16 +35,13 @@ type CodexLifecycleActivationEvidence = Readonly<{
   packageVersion?: string;
   internalExecutableBuildHash?: string;
   lifecycleContractHash?: string;
-  hookSource?: 'project' | 'managed' | 'isolated-user';
+  hookSource?: 'project' | 'managed';
   hookSourcePathDigest?: string;
   hookSourceHash?: string;
   capabilitySessionId?: string;
   capabilityTurnId?: string;
-  capabilityToolUseId?: string;
   spawnToolUseId?: string;
   spawnObservedAt?: string;
-  controllerInstanceDigest?: string | null;
-  controlGeneration?: string | null;
 }>;
 
 type CodexAdapterState = Readonly<{
@@ -307,18 +304,23 @@ function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
     return matches[0]!;
   }
 
-  function consume(
+  function consumeWithLockMode(
     childThreadId: string,
     consumer: string,
-    expectedHookDefinitionHash?: string,
-    expectedTaskBinding?: CodexLifecycleTaskBinding
+    expectedHookDefinitionHash: string | undefined,
+    expectedTaskBinding: CodexLifecycleTaskBinding | undefined,
+    taskLockHeld: boolean
   ): StoredCodexLifecycle {
     if (!consumer.trim()) throw new Error('Codex lifecycle consumer is required');
     const current = read(childThreadId);
     const binding = expectedTaskBinding ?? current.taskBinding;
     if (!binding) throw new Error('Codex lifecycle task receipt binding is missing');
     const spawn = current.state.spawn;
-    if (!spawn) throw new Error('Codex lifecycle spawn evidence is missing');
+    if (!spawn) {
+      throw new Error(taskLockHeld
+        ? 'Codex lifecycle task receipt binding is missing'
+        : 'Codex lifecycle spawn evidence is missing');
+    }
     const key = recordKey(spawn.sessionId, spawn.turnId, spawn.toolUseId);
     return update(binding, key, (latest) => {
       if (!latest || expectedTaskBinding && JSON.stringify(latest.taskBinding) !== JSON.stringify(expectedTaskBinding)) {
@@ -333,7 +335,16 @@ function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
       }
       if (latest.consumer) return latest;
       return Object.freeze({ ...latest, revision: latest.revision + 1, consumer, consumedAt: now(), updatedAt: now() });
-    });
+    }, taskLockHeld);
+  }
+
+  function consume(
+    childThreadId: string,
+    consumer: string,
+    expectedHookDefinitionHash?: string,
+    expectedTaskBinding?: CodexLifecycleTaskBinding
+  ): StoredCodexLifecycle {
+    return consumeWithLockMode(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding, false);
   }
 
   function consumeWithinTaskLock(
@@ -342,24 +353,7 @@ function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
     expectedHookDefinitionHash?: string,
     expectedTaskBinding?: CodexLifecycleTaskBinding
   ): StoredCodexLifecycle {
-    if (!consumer.trim()) throw new Error('Codex lifecycle consumer is required');
-    const current = read(childThreadId);
-    const binding = expectedTaskBinding ?? current.taskBinding;
-    if (!binding || !current.state.spawn) throw new Error('Codex lifecycle task receipt binding is missing');
-    const key = recordKey(current.state.spawn.sessionId, current.state.spawn.turnId, current.state.spawn.toolUseId);
-    return update(binding, key, (latest) => {
-      if (!latest || expectedTaskBinding && JSON.stringify(latest.taskBinding) !== JSON.stringify(expectedTaskBinding)) {
-        throw new Error('Codex lifecycle task binding does not match the expected receipt');
-      }
-      if (latest.consumer && latest.consumer !== consumer) {
-        throw new Error(`Codex lifecycle evidence was already consumed by '${latest.consumer}'`);
-      }
-      if (latest.state.status !== 'stop-ready') throw new Error('Codex lifecycle evidence is not stop-ready');
-      if (expectedHookDefinitionHash && latest.state.startEvidence?.hookDefinitionHash !== expectedHookDefinitionHash) {
-        throw new Error('Codex lifecycle hook definition hash is stale');
-      }
-      return latest.consumer ? latest : Object.freeze({ ...latest, revision: latest.revision + 1, consumer, consumedAt: now(), updatedAt: now() });
-    }, true);
+    return consumeWithLockMode(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding, true);
   }
 
   function expireBefore(cutoff: string): number {

package/lib/agent-clients/adapters/codex-orchestration.ts

@@ -327,9 +327,7 @@ async function activateCodexOrchestrationDelegation(
         capabilitySessionId: evidence.parentThreadId,
         capabilityTurnId: evidence.parentTurnId,
         spawnToolUseId: evidence.spawnToolUseId,
-        spawnObservedAt: record.spawnObservedAt ?? undefined,
-        controllerInstanceDigest: null,
-        controlGeneration: null
+        spawnObservedAt: record.spawnObservedAt ?? undefined
         }
       }
     }, coreOptions(options));

package/lib/agent-clients/adapters/codex.ts

@@ -6,7 +6,6 @@ import {
 } from './codex-sandbox.ts';
 import { parseCodexLifecycleBinding } from './codex-lifecycle/binding.ts';
 import { isCodexDelegationReceiptEvidence, isCodexLifecycleActivationEvidence } from './codex-lifecycle/evidence.ts';
-import { codexControllerOperation } from './codex-lifecycle/controller-operation.ts';
 
 function codexCarrierError(code: string): Error {
   const error = new Error(code);
@@ -80,7 +79,6 @@ const codexAdapter = defineAgentClientAdapter({
       return recoverStartedLifecycleFromAdapter(...args);
     }
   },
-  sandboxControlOperation: codexControllerOperation,
   project: {
     ownedPathPrefixes: ['.codex/'],
     managed: ['.codex/hooks.json', '.codex/agents/'],

package/lib/internal/cli-route-inventory.ts

@@ -38,7 +38,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'sandbox-control': ['serve', 'execute', 'recover', 'client'],
   'agent-client': ['next-steps', 'model-selection', 'launch-carrier'],
   'codex-lifecycle': ['preflight', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
-  'codex-sandbox-controller': ['verify-context', 'run'],
   'git-workflow': ['inspect', 'preview-tree', 'snapshot', 'compare-trees', 'commit', 'push-rebased'],
   'task-delivery': ['deliver'],
   'release-workflow': ['inspect', 'prepare', 'publish', 'post-prepare', 'post-publish'],