@fitlab-ai/agent-infra 0.9.7 → 0.9.9

package/dist/lib/task/codex-orchestration.js

@@ -1,18 +1,34 @@
-import fs from 'node:fs';
 import { preflightCodexLifecycleEvidence, resolveCodexSpawnedChild, resolveCodexTerminal, resolveCodexThread } from '../agent-clients/adapters/codex-lifecycle/app-server.js';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.js';
-import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
+import { createCodexCapabilityStore, isCodexCapabilityProvenanceDetail } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
 import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
 import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
+import { verifyCodexSandboxControllerContext as verifyControllerContextFile } from '../agent-clients/adapters/codex-lifecycle/controller-context.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
+import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
 function coreOptions(options) {
     return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
-function bridgeFailure(code, message) {
+function bridgeFailure(code, message, detail) {
     return {
         status: 'failed', changed: false, taskId: null, run: null, next: null,
-        error: { code, message }
+        error: { code, message, ...(detail ? { detail } : {}) }
+    };
+}
+function capabilityFailure(error) {
+    const detailValue = error instanceof Error
+        ? error.detail
+        : undefined;
+    return {
+        code: error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
+            ? error.name
+            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
+        message: error instanceof Error ? error.message : String(error),
+        ...(error instanceof Error
+            && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
+            && isCodexCapabilityProvenanceDetail(detailValue)
+            ? { detail: detailValue }
+            : {})
     };
 }
 function pauseBridge(code, message, options) {
@@ -26,11 +42,50 @@ function requiredStore(options) {
         throw new Error('Codex lifecycle store is required for orchestration bridge events');
     return options.store;
 }
-function controllerContext(taskId, repoRoot) {
+function controllerContext(repoRoot, brokerController) {
     const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-    return contextPath
-        ? verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot })
-        : null;
+    if (!contextPath)
+        return null;
+    if (brokerController) {
+        return verifyControllerContextFile(contextPath, {
+            repoRoot,
+            generation: process.env.AGENT_INFRA_CONTROL_GENERATION ?? brokerController.controlGeneration
+        });
+    }
+    return verifyCodexSandboxControllerContext(contextPath, { repoRoot });
+}
+function brokerBindingConflictsWithContext(repoRoot, brokerController) {
+    const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+    if (!contextPath || !brokerController)
+        return false;
+    const context = verifyControllerContextFile(contextPath, {
+        repoRoot,
+        generation: process.env.AGENT_INFRA_CONTROL_GENERATION ?? brokerController.controlGeneration
+    });
+    return context.controllerInstanceDigest !== brokerController.instanceDigest
+        || context.controlGeneration !== brokerController.controlGeneration;
+}
+function brokerControllerBinding() {
+    const raw = process.env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING;
+    if (!raw)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
+    }
+    const binding = value;
+    if (Object.keys(binding).sort().join(',') !== 'controlGeneration,instanceDigest'
+        || typeof binding.instanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(binding.instanceDigest)
+        || typeof binding.controlGeneration !== 'string' || binding.controlGeneration.length === 0) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
+    }
+    return binding;
 }
 async function prepareCodexOrchestrationDelegation(taskRef, input, options = {}) {
     if (input.client !== 'codex')
@@ -45,35 +100,96 @@ async function prepareCodexOrchestrationDelegation(taskRef, input, options = {})
             return bridgeFailure('ORCHESTRATION_CODEX_CAPABILITY_REQUIRED', 'Codex prepare requires a current-session capability token');
         }
         const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
-        const controller = controllerContext(resolved.taskId, repoRoot);
+        const brokerController = brokerControllerBinding();
+        if (brokerBindingConflictsWithContext(repoRoot, brokerController)) {
+            return bridgeFailure('CODEX_SANDBOX_CONTROLLER_BINDING_MISMATCH', 'broker and local controller bindings do not match');
+        }
+        const localController = controllerContext(repoRoot, brokerController);
+        if (localController && brokerController
+            && (localController.controllerInstanceDigest !== brokerController.instanceDigest
+                || localController.controlGeneration !== brokerController.controlGeneration)) {
+            return bridgeFailure('CODEX_SANDBOX_CONTROLLER_BINDING_MISMATCH', 'broker and local controller bindings do not match');
+        }
+        const controller = brokerController ?? (localController ? {
+            instanceDigest: localController.controllerInstanceDigest,
+            controlGeneration: localController.controlGeneration
+        } : null);
         const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
-        const consumed = capabilityStore.consume(input.capabilityToken, {
+        const attested = capabilityStore.inspect(input.capabilityToken);
+        const lifecycleProvenance = {
+            ...attested.buildIdentity,
+            hookDefinitionHash: preflight.hookDefinitionHash,
+            ...preflight.hookProvenance,
+            capabilitySessionId: attested.sessionId,
+            capabilityTurnId: attested.turnId,
+            capabilityToolUseId: attested.toolUseId,
+            controllerInstanceDigest: controller?.instanceDigest ?? null,
+            controlGeneration: controller?.controlGeneration ?? null
+        };
+        const capabilityExpected = {
             taskId: resolved.taskId,
             hookDefinitionHash: preflight.hookDefinitionHash,
             buildIdentity,
             ...(controller ? { controller: {
-                    instanceDigest: controller.controllerInstanceDigest,
+                    instanceDigest: controller.instanceDigest,
                     controlGeneration: controller.controlGeneration
                 } } : {})
-        });
+        };
         return prepareOrchestrationDelegation(taskRef, {
             ...input,
-            lifecycleProvenance: {
-                ...consumed.buildIdentity,
-                hookDefinitionHash: preflight.hookDefinitionHash,
-                ...preflight.hookProvenance,
-                capabilitySessionId: consumed.sessionId,
-                capabilityTurnId: consumed.turnId,
-                capabilityToolUseId: consumed.toolUseId,
-                controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
-                controlGeneration: controller?.controlGeneration ?? null
+            lifecycleProvenance
+        }, {
+            ...coreOptions(options),
+            validateLifecycleCapability: () => {
+                try {
+                    const validated = capabilityStore.validate(input.capabilityToken, capabilityExpected);
+                    if (validated.sessionId !== attested.sessionId
+                        || validated.turnId !== attested.turnId
+                        || validated.toolUseId !== attested.toolUseId) {
+                        return {
+                            code: 'CODEX_CAPABILITY_IDENTITY_CHANGED',
+                            message: 'capability identity changed during validation'
+                        };
+                    }
+                    return null;
+                }
+                catch (error) {
+                    return capabilityFailure(error);
+                }
+            },
+            consumeLifecycleCapability: () => {
+                try {
+                    const consumed = capabilityStore.consume(input.capabilityToken, capabilityExpected);
+                    if (consumed.sessionId !== attested.sessionId
+                        || consumed.turnId !== attested.turnId
+                        || consumed.toolUseId !== attested.toolUseId) {
+                        return {
+                            code: 'CODEX_CAPABILITY_IDENTITY_CHANGED',
+                            message: 'capability identity changed during consumption'
+                        };
+                    }
+                    return null;
+                }
+                catch (error) {
+                    return capabilityFailure(error);
+                }
             }
-        }, coreOptions(options));
+        });
     }
     catch (error) {
+        if (error instanceof OrchestrationStateError)
+            return bridgeFailure(error.code, error.message);
+        const detailValue = error instanceof Error
+            ? error.detail
+            : undefined;
+        const detail = error instanceof Error
+            && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
+            && isCodexCapabilityProvenanceDetail(detailValue)
+            ? detailValue
+            : undefined;
         return bridgeFailure(error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
             ? error.name
-            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error));
+            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error), detail);
     }
 }
 async function activateCodexOrchestrationDelegation(childThreadId, options = {}) {
@@ -100,14 +216,8 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
         });
         const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
         const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-        const contextTaskId = contextPath
-            ? JSON.parse(fs.readFileSync(contextPath, 'utf8')).taskId
-            : null;
-        if (contextPath && typeof contextTaskId !== 'string') {
-            throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-        }
         const controller = contextPath
-            ? verifyCodexSandboxControllerContext(contextPath, contextTaskId, { repoRoot })
+            ? verifyCodexSandboxControllerContext(contextPath, { repoRoot })
             : null;
         return activateMatchingOrchestrationDelegation('codex', {
             nativeAgent: evidence.nativeAgent,
@@ -136,6 +246,8 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
         }, coreOptions(options));
     }
     catch (error) {
+        if (error instanceof OrchestrationStateError)
+            return bridgeFailure(error.code, error.message);
         return pauseBridge('ORCHESTRATION_CODEX_START_FAILED', error instanceof Error ? error.message : String(error), options);
     }
 }
@@ -160,6 +272,8 @@ async function activateCodexSpawnDelegation(spawn, options = {}) {
         });
     }
     catch (error) {
+        if (error instanceof OrchestrationStateError)
+            return bridgeFailure(error.code, error.message);
         return pauseBridge('ORCHESTRATION_CODEX_START_FAILED', error instanceof Error ? error.message : String(error), options);
     }
 }
@@ -171,7 +285,11 @@ async function sealCodexOrchestrationDelegation(childThreadId, options = {}) {
         const store = requiredStore(options);
         const existing = store.read(childThreadId);
         if (!existing.consumer) {
-            store.apply(await (options.resolveTerminal ?? resolveCodexTerminal)(childThreadId));
+            const stopTurnId = existing.state.stop?.turnId;
+            if (!stopTurnId) {
+                return pauseBridge('ORCHESTRATION_CODEX_STOP_EVIDENCE_INVALID', 'Codex lifecycle stop hook is not available', options);
+            }
+            store.apply(await (options.resolveTerminal ?? resolveCodexTerminal)(childThreadId, stopTurnId));
         }
         const record = store.read(childThreadId);
         const evidence = record.state.stopEvidence;
@@ -188,6 +306,8 @@ async function sealCodexOrchestrationDelegation(childThreadId, options = {}) {
         }, coreOptions(options));
     }
     catch (error) {
+        if (error instanceof OrchestrationStateError)
+            return bridgeFailure(error.code, error.message);
         return pauseBridge('ORCHESTRATION_CODEX_STOP_FAILED', error instanceof Error ? error.message : String(error), options);
     }
 }
@@ -208,7 +328,10 @@ async function sealCodexParentDelegation(parentThreadId, options = {}) {
         const start = active.state.startEvidence;
         const child = active.state.child;
         if (!active.state.terminal) {
-            store.apply(await (options.resolveTerminal ?? resolveCodexTerminal)(start.childThreadId));
+            const resolveTerminal = options.resolveTerminal ?? resolveCodexTerminal;
+            store.apply(active.state.stop
+                ? await resolveTerminal(start.childThreadId, active.state.stop.turnId)
+                : await resolveTerminal(start.childThreadId));
         }
         if (!store.read(start.childThreadId).state.stop) {
             store.apply({
@@ -223,6 +346,8 @@ async function sealCodexParentDelegation(parentThreadId, options = {}) {
         return sealCodexOrchestrationDelegation(start.childThreadId, options);
     }
     catch (error) {
+        if (error instanceof OrchestrationStateError)
+            return bridgeFailure(error.code, error.message);
         if (error instanceof Error && error.message === 'CODEX_TURN_NOT_TERMINAL') {
             return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'The matching Codex child has not completed');
         }

package/dist/lib/task/commands/status.js

@@ -9,6 +9,7 @@ import { parseTaskFrontmatter, extractTitle } from '../frontmatter.js';
 import { loadShortIdByTaskId } from '../short-id.js';
 import { getOpenWorkflowWarnings, formatWorkflowWarningSummary } from '../workflow-warnings.js';
 import { parseActivityLog, pairEntries } from '../activity-log.js';
+import { readRun } from '../orchestration.js';
 import { statusCard } from '../../server/display.js';
 const USAGE = `Usage: ai task status [<N | TASK-id> | --task <ref> | -t <ref>]
 
@@ -262,6 +263,38 @@ function collectRuntime(taskDir, workflow, run) {
         log: record.log_file
     };
 }
+function pendingDelegationInfo(receipt) {
+    if (!receipt)
+        return null;
+    return {
+        id: receipt.id,
+        role: receipt.role,
+        stage: receipt.stage,
+        round: receipt.round,
+        artifact: receipt.artifact,
+        client: receipt.client,
+        status: receipt.status
+    };
+}
+function collectOrchestration(taskDir) {
+    const run = readRun(taskDir);
+    if (!run) {
+        return {
+            status: 'absent',
+            runId: DASH,
+            nextStage: DASH,
+            pause: null,
+            pendingDelegation: null
+        };
+    }
+    return {
+        status: run.status,
+        runId: run.runId,
+        nextStage: run.nextStage ?? DASH,
+        pause: run.pause,
+        pendingDelegation: pendingDelegationInfo(run.pendingDelegation)
+    };
+}
 // Indent each label/value pair by two spaces and pad labels to a common width so
 // every section reads as an aligned "key   value" block.
 function renderPairs(rows) {
@@ -284,6 +317,21 @@ function renderStatus(model) {
     else {
         lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
     }
+    lines.push('', 'Orchestration', ...renderPairs([
+        ['status', model.orchestration.status],
+        ['run_id', model.orchestration.runId],
+        ['next_stage', model.orchestration.nextStage],
+        ['pause_code', model.orchestration.pause?.code ?? DASH],
+        ['pause_message', model.orchestration.pause?.message ?? DASH],
+        ['recoverable', model.orchestration.pause ? String(model.orchestration.pause.recoverable) : DASH],
+        ['pending_id', model.orchestration.pendingDelegation?.id ?? DASH],
+        ['pending_role', model.orchestration.pendingDelegation?.role ?? DASH],
+        ['pending_stage', model.orchestration.pendingDelegation?.stage ?? DASH],
+        ['pending_round', model.orchestration.pendingDelegation ? String(model.orchestration.pendingDelegation.round) : DASH],
+        ['pending_artifact', model.orchestration.pendingDelegation?.artifact ?? DASH],
+        ['pending_client', model.orchestration.pendingDelegation?.client ?? DASH],
+        ['pending_status', model.orchestration.pendingDelegation?.status ?? DASH]
+    ]));
     lines.push('', 'Workflow', ...renderPairs([
         ['state', model.workflow.state],
         ['step', model.workflow.step],
@@ -313,6 +361,12 @@ function renderStatus(model) {
     return lines;
 }
 function modelTone(model) {
+    if (model.orchestration.status === 'paused')
+        return 'warning';
+    if (model.orchestration.status === 'running')
+        return 'running';
+    if (model.orchestration.status === 'completed')
+        return 'success';
     if (model.workflow.state === 'in-progress')
         return model.workflow.stale === 'yes' ? 'warning' : 'running';
     if (model.metadata.some(([key, value]) => key === 'status' && value === 'completed'))
@@ -337,6 +391,7 @@ function buildFromResolved(input) {
         artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
         workflow,
         runtime: collectRuntime(input.taskDir, workflow, run),
+        orchestration: collectOrchestration(input.taskDir),
         git: collectGit(fm.branch ?? '', run)
     };
 }
@@ -359,6 +414,9 @@ function buildStatusModel(refOrInput, options = {}) {
 }
 function statusModelToDisplay(model) {
     return statusCard(`Task ${model.taskId} (${model.shortId})`, modelTone(model), [
+        ['orchestration', model.orchestration.status],
+        ['run', model.orchestration.runId],
+        ['next', model.orchestration.nextStage],
         ['workflow', model.workflow.state],
         ['step', model.workflow.step],
         ['runtime', model.runtime.status],
@@ -393,5 +451,5 @@ function status(args = []) {
         process.stdout.write(`${line}\n`);
     }
 }
-export { status, makeRunner, buildStatusModel, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, renderStatus, statusModelToDisplay, METADATA_KEYS };
+export { status, makeRunner, buildStatusModel, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, collectOrchestration, renderStatus, statusModelToDisplay, METADATA_KEYS };
 //# sourceMappingURL=status.js.map