@fitlab-ai/agent-infra 0.11.2 → 0.11.3

package/dist/lib/sandbox/control/server.js

@@ -1,5 +1,4 @@
 import { finalizationTerminalResponse } from './finalization-response.js';
-import { isDeepStrictEqual } from 'node:util';
 import { completedReentryView } from './completed-reentry.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -13,10 +12,6 @@ import { validateSandboxControlRequest } from './protocol.js';
 import { requestAuditFields, resultAuditFields, appendCriticalAudit, appendDiagnosticAudit, createSandboxControlAuditContext, writeSandboxControlTransition, readSandboxControlTransition } from './audit.js';
 import { parseTaskControlOperation } from '../../task/control-authority.js';
 import { parseControlOutput, classifySandboxControlRecovery, findSandboxControlRecoveryOperation, operationRecoveryBinding, SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES } from '../../task/control-recovery.js';
-import { readRun } from '../../task/orchestration.js';
-import { readLifecycleRecoveryDomainEvidence } from '../../task/lifecycle-recovery.js';
-import { captureRepositorySnapshot } from '../../task/workspace-snapshot.js';
-import { parseTypedTaskFrontmatter } from '../../task/frontmatter.js';
 import { readLifecycleJournalEvidence } from '../../task/lifecycle.js';
 import { resolveTaskRef } from '../../task/resolve-ref.js';
 import { loadShortIdByTaskId } from '../../task/short-id.js';
@@ -28,94 +23,32 @@ import { readCodexControllerRegistration } from './controller-registration.js';
 import { validateSandboxControlIdentity } from './identity-sentinel.js';
 import { mergeSandboxTaskView, taskViewAfterFinalization, taskViewForManifest } from './task-view.js';
 import { taskCreateOutputUnavailableResult } from '../../task/create-service.js';
-import { consumeLifecycleRecoveryAttestation, issueLifecycleRecoveryAttestation, recoverLifecycleRecoveryOperation } from '../../task/control-authority.js';
-import { createCodexCapabilityStore } from '../../agent-clients/adapters/codex-lifecycle/capability-store.js';
-import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.js';
-function consumeLifecycleAuthorityForResult(manifest, execution) {
-    const authority = execution.lifecycleAuthority?.attestation;
-    if (!authority || execution.result?.exitCode !== 0)
-        return true;
-    try {
-        consumeLifecycleRecoveryAttestation(authority);
-        return true;
-    }
-    catch (error) {
-        appendBrokerAudit(manifest, 'lifecycle-authority-consume-retry', {
-            ...requestAuditFields(manifest, execution.request),
-            errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_CONSUME_FAILED'
-        });
-        return false;
-    }
-}
-function lifecycleAuthorityForRequest(manifest, manifestPath, request) {
-    const selector = request.family === 'task-workflow' || request.family === 'task-orchestration'
-        ? request.authority
-        : undefined;
-    if (!selector)
-        return undefined;
-    let controllerBinding = null;
-    try {
-        const registration = readCodexControllerRegistration(manifestPath);
-        controllerBinding = {
-            instanceDigest: registration.controllerInstanceDigest,
-            controlGeneration: registration.controlGeneration
-        };
-    }
-    catch {
-        // The issuer reports the stable unavailable result; the broker never trusts
-        // a controller binding supplied by the request.
-    }
-    return issueLifecycleRecoveryAttestation(selector, {
-        controllerBinding,
-        capabilityStore: createCodexCapabilityStore(),
-        buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot)
-    });
-}
 function appendBrokerAudit(manifest, event, fields = {}) {
     appendDiagnosticAudit(manifest, event, { source: 'broker', ...fields });
 }
-function operationKey(request, output) {
+function operationKey(request) {
     if (request.family === 'task-finalization')
         return request.operation;
     if (request.family === 'task-create')
         return 'create';
     if (request.family === 'codex-controller')
         return request.command;
-    if (request.family === 'task-workflow')
-        return request.workflow.operation;
-    if (request.family !== 'task-lifecycle' && request.family !== 'task-orchestration')
+    if (request.family !== 'task-lifecycle')
         return null;
-    if (request.family === 'task-orchestration' && request.args[1] === 'route') {
-        if (!output)
-            return 'route';
-        const result = parseControlOutput(output);
-        return result?.changed === true && result.status === 'completed' ? 'route.clean-completion' : 'route.read';
-    }
     try {
         const operation = parseTaskControlOperation(request.family, request.args);
-        return operation.family === 'task-orchestration' ? operation.intent : operation.request.intent;
+        return operation.family === 'task-lifecycle' ? operation.request.intent : null;
     }
     catch {
         return null;
     }
 }
-function recoveryOperationKey(request, terminalResult, output) {
-    const operation = operationKey(request, output);
-    if (operation !== 'route')
-        return operation;
-    const digest = terminalResult?.intentDigest;
-    for (const candidate of ['route.read', 'route.clean-completion']) {
-        const expected = operationRecoveryBinding(request.id, request.generation, null, request.family, candidate).intentDigest;
-        if (digest === expected)
-            return candidate;
-    }
-    return null;
+function recoveryOperationKey(request) {
+    return operationKey(request);
 }
 function terminalResultMatchesRequest(request, terminalResult) {
     const operation = operationKey(request);
-    const candidates = operation === 'route'
-        ? ['route.read', 'route.clean-completion']
-        : operation ? [operation] : [];
+    const candidates = operation ? [operation] : [];
     return candidates.some((candidate) => createHash('sha256').update(`${request.family}\0${candidate}`, 'utf8').digest('hex') === terminalResult.intentDigest);
 }
 function criticalRequestPhase(manifest, request, phase, outcome, reference) {
@@ -257,7 +190,7 @@ function outputMatchesEvidence(output, bytes, sha256) {
     return Buffer.byteLength(output, 'utf8') === bytes
         && createHash('sha256').update(output, 'utf8').digest('hex') === sha256;
 }
-export function genericRecoveryResponse(request, exitCode, payload, cause = 'recovery', warning = null) {
+export function genericRecoveryResponse(request, exitCode, payload, cause = 'recovery') {
     const outputUnavailable = request.family === 'task-create' && !payload;
     return {
         version: 2,
@@ -265,11 +198,9 @@ export function genericRecoveryResponse(request, exitCode, payload, cause = 'rec
         phase: 'completed',
         exitCode,
         stdout: outputUnavailable ? `${JSON.stringify(taskCreateOutputUnavailableResult(request.id))}\n` : '',
-        stderr: payload ? '' : warning
-            ? `${warning.code}: ${warning.message}\nAction: ${warning.action}\n`
-            : cause === 'publish'
-                ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
-                : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
+        stderr: payload ? '' : cause === 'publish'
+            ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
+            : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
         error: null,
         outputState: payload ? 'available' : 'unavailable',
         payload: payload ? payloadReference(payload) : null
@@ -335,32 +266,10 @@ function controllerDomainEvidence(manifest, manifestPath, request, output) {
                 && output?.status === 'closed' && typeof output.changed === 'boolean' };
     }
 }
-function orchestrationDomainEvidence(operation, terminalResult, output, run) {
-    if (!operation || !output)
-        return { consistent: false };
-    const outputRun = output.run && typeof output.run === 'object' && !Array.isArray(output.run)
-        ? output.run : null;
-    const runMatches = outputRun === null ? run === null : run !== null && JSON.stringify(run) === JSON.stringify(outputRun);
-    if (operation.class === 'read-only') {
-        return {
-            consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
-            snapshotValid: true,
-            status: run?.status ?? terminalResult.status,
-            pendingDelegation: run?.pendingDelegation ?? null
-        };
-    }
-    if (!run || !outputRun)
-        return { consistent: false };
-    return {
-        consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
-        status: run.status,
-        pendingDelegation: run.pendingDelegation
-    };
-}
-function readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payloadOutput) {
+async function readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payloadOutput) {
     if (!operation)
         return { domain: null };
-    const taskRef = request.family === 'task-finalization' || request.family === 'task-workflow'
+    const taskRef = request.family === 'task-finalization'
         ? manifest.taskId
         : 'args' in request ? request.args[0] ?? null : manifest.taskId;
     const output = parseControlOutput(payloadOutput);
@@ -369,21 +278,7 @@ function readRecoveryDomain(manifest, manifestPath, request, operation, terminal
     }
     if (operation.family === 'task-lifecycle') {
         if (operation.intent === 'recover-started') {
-            try {
-                if (!('args' in request))
-                    return { domain: null };
-                const parsed = parseTaskControlOperation('task-lifecycle', request.args);
-                if (parsed.family !== 'task-lifecycle' || parsed.request.intent !== 'recover-started') {
-                    return { domain: null };
-                }
-                return {
-                    domain: readLifecycleRecoveryDomainEvidence(manifest.repoRoot, parsed.request, terminalResult),
-                    journal: readLifecycleJournalEvidence(manifest.repoRoot, taskRef)
-                };
-            }
-            catch {
-                return { domain: null };
-            }
+            return { domain: null };
         }
         if (!taskRef || !terminalResult.targetState)
             return { domain: null };
@@ -403,51 +298,12 @@ function readRecoveryDomain(manifest, manifestPath, request, operation, terminal
             return { domain: { consistent: false }, journal };
         }
     }
-    if (operation.family === 'task-orchestration') {
-        if (!taskRef)
-            return { domain: null };
-        try {
-            const resolved = resolveTaskRef(taskRef, { repoRoot: manifest.repoRoot });
-            if (!resolved.ok)
-                return { domain: { consistent: false } };
-            const run = readRun(resolved.taskDir);
-            if (!run && operation.class !== 'read-only')
-                return { domain: { consistent: false } };
-            if (operation.class === 'route.clean-completion') {
-                const snapshot = captureRepositorySnapshot(manifest.repoRoot);
-                const metadata = parseTypedTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
-                const completion = run?.completionEvidence ?? null;
-                const consistent = run !== null && completion !== null
-                    && terminalResult.completionEvidence !== null
-                    && isDeepStrictEqual(completion, terminalResult.completionEvidence);
-                return {
-                    domain: {
-                        consistent,
-                        status: run?.status ?? null,
-                        pendingDelegation: run?.pendingDelegation ?? null,
-                        completionEvidence: completion,
-                        snapshot,
-                        lastReviewedCommit: metadata.last_reviewed_commit
-                    }
-                };
-            }
-            return { domain: orchestrationDomainEvidence(operation, terminalResult, output, run) };
-        }
-        catch {
-            return { domain: { consistent: false } };
-        }
-    }
     if (operation.family === 'task-create') {
         return { domain: taskCreateDomainEvidence(manifest, output) };
     }
     if (operation.family === 'codex-controller') {
         return { domain: controllerDomainEvidence(manifest, manifestPath, request, output) };
     }
-    if (operation.family === 'task-workflow') {
-        return {
-            domain: { consistent: output?.status === terminalResult.status && output.changed === terminalResult.changed, snapshotValid: true }
-        };
-    }
     return { domain: null };
 }
 function readCommittedCriticalPhases(manifest, requestId) {
@@ -461,8 +317,8 @@ function readCommittedCriticalPhases(manifest, requestId) {
         }
     });
 }
-export function recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult) {
-    const operationName = recoveryOperationKey(request, terminalResult, payload?.stdout);
+export async function recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult) {
+    const operationName = recoveryOperationKey(request);
     const operation = operationName ? findSandboxControlRecoveryOperation(request.family, operationName) : null;
     if (!operation)
         return null;
@@ -476,32 +332,9 @@ export function recoveryResponse(manifest, manifestPath, request, evidence, payl
     const finalization = request.family === 'task-finalization' ? finalizationRecoveryResponse(manifest, request.id, 0) : null;
     if (evidence.exitCode === 0 && finalization?.status === 'deferred')
         return null;
-    if (evidence.exitCode === 0 && request.family === 'task-workflow' && request.authority?.phase === 'task-event.completed') {
-        try {
-            const registration = readCodexControllerRegistration(manifestPath);
-            const recovered = recoverLifecycleRecoveryOperation(request.authority, {
-                repoRoot: manifest.repoRoot,
-                capabilityStore: createCodexCapabilityStore(),
-                buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot),
-                controllerBinding: {
-                    instanceDigest: registration.controllerInstanceDigest,
-                    controlGeneration: registration.controlGeneration
-                }
-            });
-            if (recovered.status !== 'committed')
-                return null;
-        }
-        catch (error) {
-            appendBrokerAudit(manifest, 'lifecycle-authority-recovery-failed', {
-                ...requestAuditFields(manifest, request),
-                errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_RECOVERY_FAILED'
-            });
-            return null;
-        }
-    }
     const recovery = finalization
         ? { domain: { consistent: finalization.status === 'matched' } }
-        : readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
+        : await readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
     const binding = operationRecoveryBinding(request.id, manifest.generation, manifest.taskId, request.family, operationName);
     const decision = classifySandboxControlRecovery({
         operation,
@@ -523,13 +356,13 @@ export function recoveryResponse(manifest, manifestPath, request, evidence, payl
             return null;
         return finalization.response ?? null;
     }
-    return genericRecoveryResponse(request, evidence.exitCode, payload, 'recovery', terminalResult.warning ?? null);
+    return genericRecoveryResponse(request, evidence.exitCode, payload);
 }
-function terminalMatchesEvidence(manifest, manifestPath, request, response, evidence, payload, payloadInvalid, terminalResult) {
+async function terminalMatchesEvidence(manifest, manifestPath, request, response, evidence, payload, payloadInvalid, terminalResult) {
     if (request.family === 'task-finalization' && evidence.exitCode === 0) {
         if (!terminalResult)
             return { valid: false, payloadReferenced: false };
-        const expected = recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult);
+        const expected = await recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult);
         return {
             valid: expected !== null && JSON.stringify(response) === JSON.stringify(expected),
             payloadReferenced: false
@@ -558,7 +391,7 @@ function terminalMatchesEvidence(manifest, manifestPath, request, response, evid
     if (response.outputState === 'unavailable') {
         const causes = ['recovery', 'publish'];
         const valid = causes.some((cause) => JSON.stringify(response)
-            === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause, terminalResult?.warning ?? null)));
+            === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause)));
         return { valid, payloadReferenced: false };
     }
     return {
@@ -573,7 +406,7 @@ function publishExecutionResult(manifest, request, result, broker, brokerOwns) {
     const terminalResult = writeSandboxControlTerminalResult(manifest, {
         id: request.id,
         family: request.family,
-        operation: operationKey(request, normalized.stdout)
+        operation: operationKey(request)
     }, normalized.stdout);
     if (fs.existsSync(path.join(manifest.processingDir, request.id, 'transitions'))) {
         criticalRequestPhase(manifest, request, 'completed', normalized.exitCode === 0 ? 'success' : 'failure');
@@ -610,7 +443,7 @@ function publishExecutionResult(manifest, request, result, broker, brokerOwns) {
             catch {
                 payload = null;
             }
-            terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish', terminalResult.warning ?? null);
+            terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish');
         }
     }
     if (!brokerOwns())
@@ -697,7 +530,7 @@ function assertCurrentSandboxControlIdentity(manifest, manifestPath) {
         throw new Error(`SANDBOX_CONTROL_IDENTITY_${result.state.replaceAll('-', '_').toUpperCase()}`);
     }
 }
-function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
+async function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
     for (const entry of fs.readdirSync(manifest.processingDir, { withFileTypes: true })) {
         if (!entry.isDirectory() || !/^[a-f0-9-]{16,64}$/.test(entry.name))
             continue;
@@ -819,7 +652,7 @@ function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
             if (terminal && request && resultEvidence) {
                 if (!terminalResult && request.family !== 'task-create')
                     continue;
-                const reconciliation = terminalMatchesEvidence(manifest, manifestPath, request, existingTerminalResponse, resultEvidence, payload, payloadInvalid, terminalResult);
+                const reconciliation = await terminalMatchesEvidence(manifest, manifestPath, request, existingTerminalResponse, resultEvidence, payload, payloadInvalid, terminalResult);
                 if (!reconciliation.valid)
                     continue;
                 terminalReconciled = true;
@@ -852,7 +685,7 @@ function recoverProcessing(manifest, manifestPath, broker, brokerOwns) {
                     return false;
                 if (!resultEvidence || !request || payloadInvalid)
                     continue;
-                const recovered = recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult);
+                const recovered = await recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult);
                 if (!recovered)
                     continue;
                 if (request.family === 'task-finalization' && resultEvidence.exitCode === 0) {
@@ -1008,7 +841,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
             pid: broker.pid,
             brokerId: broker.brokerId
         });
-        if (!recoverProcessing(manifest, manifestPath, broker, brokerOwns))
+        if (!await recoverProcessing(manifest, manifestPath, broker, brokerOwns))
             return;
         try {
             const published = readSandboxControlStatus(manifest.publicStatusDir);
@@ -1150,10 +983,6 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                     break;
                 let terminalCommitted = false;
                 if (settledExecution.result && settledExecution.resultEvidenceWritten) {
-                    if (!consumeLifecycleAuthorityForResult(manifest, settledExecution)) {
-                        active = settledExecution;
-                        continue;
-                    }
                     terminalCommitted = publishExecutionResult(manifest, settledExecution.request, settledExecution.result, broker, brokerOwns);
                     if (terminalCommitted && settledExecution.request.family === 'task-finalization') {
                         try {
@@ -1247,14 +1076,9 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                         executorCwd: manifest.repoRoot,
                         executorEntry: options.internalCliPath ?? process.argv[1] ?? null
                     });
-                    const lifecycleAuthority = lifecycleAuthorityForRequest(manifest, manifestPath, request);
-                    if (lifecycleAuthority?.status === 'rejected') {
-                        throw Object.assign(new Error(lifecycleAuthority.error?.message ?? 'lifecycle authority was rejected'), { code: lifecycleAuthority.error?.code ?? 'LIFECYCLE_AUTHORITY_REJECTED' });
-                    }
                     prepared = await prepareExecution({
                         manifest, manifestPath, request, requestPath: claimed,
-                        internalCliPath: options.internalCliPath ?? process.argv[1],
-                        ...(lifecycleAuthority ? { lifecycleAuthority } : {})
+                        internalCliPath: options.internalCliPath ?? process.argv[1]
                     });
                     const preparedExecution = prepared;
                     if (!preparedExecution)
@@ -1270,7 +1094,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                         executionPath: executionPath(manifest, request.id)
                     });
                     const execution = {
-                        request, prepared: preparedExecution, lifecycleAuthority, result: null,
+                        request, prepared: preparedExecution, result: null,
                         resultEvidenceWritten: false, failure: null, settled: false
                     };
                     active = execution;
@@ -1431,8 +1255,7 @@ export async function serveSandboxControl(manifestPath, signal = new AbortContro
                 }
             }
             if (owned && active.result && active.resultEvidenceWritten) {
-                if (consumeLifecycleAuthorityForResult(manifest, active)
-                    && publishExecutionResult(manifest, active.request, active.result, broker, brokerOwns)) {
+                if (publishExecutionResult(manifest, active.request, active.result, broker, brokerOwns)) {
                     if (brokerOwns()) {
                         removeAcceptedResponse(manifest, active.request.id);
                         fs.rmSync(path.join(manifest.processingDir, active.request.id), { recursive: true, force: true });

package/dist/lib/sandbox/control/state.js

@@ -1,6 +1,5 @@
 import { isCompletionEvidence } from '../../task/orchestration.js';
 import { parseControlOutput } from '../../task/control-recovery.js';
-import { isRecoveryWarning } from '../../task/recovery-warning.js';
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -84,7 +83,6 @@ export function createSandboxControlTerminalResult(manifest, request, output) {
         ? nested.run : null;
     const rawCompletion = nested.completionEvidence ?? run?.completionEvidence;
     const operation = request.operation ?? (typeof nested.intent === 'string' ? nested.intent : null) ?? '';
-    const warning = isRecoveryWarning(nested.warning) ? nested.warning : null;
     return {
         version: 1,
         requestId: request.id,
@@ -94,8 +92,7 @@ export function createSandboxControlTerminalResult(manifest, request, output) {
         targetState: typeof nested.targetState === 'string' ? nested.targetState : null,
         status: typeof nested.status === 'string' ? nested.status : 'completed',
         changed: typeof nested.changed === 'boolean' ? nested.changed : null,
-        completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null,
-        ...(warning ? { warning } : {})
+        completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null
     };
 }
 export function writeSandboxControlTerminalResult(manifest, request, output) {
@@ -126,9 +123,6 @@ export function readSandboxControlTerminalResult(filePath) {
     if (value.completionEvidence !== null && !isCompletionEvidence(value.completionEvidence)) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }
-    if (value.warning !== undefined && value.warning !== null && !isRecoveryWarning(value.warning)) {
-        throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
-    }
     if (value.changed === undefined) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }

package/dist/lib/sandbox/control/task-view.js

@@ -13,11 +13,10 @@ function receiptIdentity(value, generation, requestId) {
     if (!binding || typeof binding !== 'object' || Array.isArray(binding))
         return null;
     const controlBinding = binding;
-    if (receipt.version !== 3 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
+    if (receipt.version !== 4 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
         || !Number.isSafeInteger(receipt.revision) || receipt.revision < 0
         || receipt.lifecycle !== 'done'
         || !['pending', 'done', 'skipped'].includes(String(receipt.summary))
-        || !['pending', 'done', 'skipped'].includes(String(receipt.postSummaryVerification))
         || controlBinding.generation !== generation
         || typeof controlBinding.requestId !== 'string'
         || !/^[a-f0-9-]{16,64}$/u.test(controlBinding.requestId)

package/dist/lib/task/control-authority.js

@@ -3,12 +3,11 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { isAgentClientId } from '../agent-clients/types.js';
+import { getAgentClientAdapter } from '../agent-clients/registry.js';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from './human-override.js';
 import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, prepareOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from './orchestration.js';
-import { prepareCodexOrchestrationDelegation } from './codex-orchestration.js';
 import { applyTaskFinalization } from './finalization.js';
 import { applyTaskLifecycle, taskLifecycleFailure } from './lifecycle.js';
-import { recoverStartedLifecycleUnderLock, recoveryFailure } from './lifecycle-recovery.js';
 import { locateActivityLog } from './activity-log.js';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
@@ -407,7 +406,6 @@ export function createSandboxExecutorExecutionContext(params) {
         generation: params.generation,
         manifestPath: absolute('manifestPath', params.manifestPath),
         requestId: params.requestId,
-        ...(params.diagnosticLog === undefined ? {} : { diagnosticLog: params.diagnosticLog }),
         ...(params.controllerBinding === undefined ? {} : { controllerBinding: binding(params.controllerBinding) }),
         ...(params.lifecycleRecoveryAttestation === undefined ? {} : {
             lifecycleRecoveryAttestation: params.lifecycleRecoveryAttestation === null
@@ -450,11 +448,7 @@ function operationTaskId(context, taskRef) {
 function domainOptions(context, options) {
     return {
         ...options,
-        repoRoot: context.repoRoot,
-        ...(context.source === 'sandbox-executor' && context.diagnosticLog !== undefined
-            ? { diagnosticLog: context.diagnosticLog }
-            : {}),
-        ...(context.source === 'sandbox-executor' ? { gitWorktreeRoot: context.worktreeRoot } : {})
+        repoRoot: context.repoRoot
     };
 }
 function lifecycleTaskId(request, repoRoot) {
@@ -475,7 +469,17 @@ async function applyLifecycleWithAuthority(context, request) {
     }
     const execute = async () => {
         if (request.intent === 'recover-started') {
-            return recoverStartedLifecycleUnderLock(request, { repoRoot: context.repoRoot });
+            const adapter = isAgentClientId(request.agent)
+                ? getAgentClientAdapter(request.agent).orchestrationAdapter
+                : undefined;
+            if (!adapter?.recoverStarted) {
+                return {
+                    status: 'no-op', changed: false, targetState: 'active',
+                    requestRef: request.taskRef, intent: 'recover-started', taskId: null,
+                    receiptId: null, childId: null, error: null
+                };
+            }
+            return adapter.recoverStarted(request, { repoRoot: context.repoRoot });
         }
         const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
         if (lifecycleResult.status !== 'failed' || !request.overrideTicket)
@@ -511,7 +515,12 @@ async function applyLifecycleWithAuthority(context, request) {
         if (!(error instanceof TaskExecutionLockError))
             throw error;
         if (request.intent === 'recover-started') {
-            return recoveryFailure(request, 'owner-unknown', error.code, error.message);
+            return {
+                status: 'owner-unknown', changed: false, targetState: 'active',
+                requestRef: request.taskRef, intent: 'recover-started', taskId,
+                receiptId: null, childId: null,
+                error: { code: error.code, message: error.message }
+            };
         }
         return taskLifecycleFailure(request, { code: error.code, message: error.message }, taskId);
     }
@@ -536,8 +545,10 @@ function orchestration(context, operation) {
                 requestedModel: input.requestedModel,
                 requestedReasoningEffort: input.requestedReasoningEffort,
             };
-            if (prepareInput.client === 'codex') {
-                return prepareCodexOrchestrationDelegation(operation.taskRef, prepareInput, {
+            const prepareDelegation = getAgentClientAdapter(prepareInput.client)
+                .orchestrationAdapter?.prepareDelegation;
+            if (prepareDelegation) {
+                return prepareDelegation(operation.taskRef, prepareInput, {
                     repoRoot: context.repoRoot,
                     orchestrationOptions: options,
                 });
@@ -617,7 +628,7 @@ function operationInvalid(message) {
 }
 const LIFECYCLE_FLAGS = new Set([
     '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-    '--stage', '--round', '--artifact', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
+    '--auto', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
 ]);
 const FINALIZATION_FLAGS = new Set(['--agent']);
 const ORCHESTRATION_FLAGS = new Set([
@@ -626,13 +637,13 @@ const ORCHESTRATION_FLAGS = new Set([
     '--parent-id', '--before-fingerprint', '--stage', '--round', '--artifact', '--role',
     '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
     '--model-fallback-reason', '--reasoning-effort-fallback-reason', '--exit-code', '--after-fingerprint',
-    '--changed-paths', '--code', '--message', '--recoverable', '--git-worktree-root'
+    '--changed-paths', '--code', '--message', '--recoverable'
 ]);
 function parseValues(args, start, flags) {
     const values = {};
     for (let index = start; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--dry-run') {
+        if (flag === '--dry-run' || flag === '--auto') {
             if (!flags.has(flag))
                 operationInvalid(`unknown option '${flag}'`);
             if (values[flag] !== undefined)
@@ -693,31 +704,21 @@ export function parseTaskControlOperation(family, args) {
             ...(value(values, '--override-scope') ? { overrideScope: value(values, '--override-scope') } : {}),
             ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
             ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
-            ...(value(values, '--stage') ? { stage: value(values, '--stage') } : {}),
-            ...(value(values, '--round') ? { round: Number(value(values, '--round')) } : {}),
-            ...(value(values, '--artifact') ? { artifact: value(values, '--artifact') } : {}),
+            ...(values['--auto'] === true ? { auto: true } : {}),
             ...(values['--dry-run'] === true ? { dryRun: true } : {})
         };
         if (intent === 'recover-started') {
-            const recoveryFlags = new Set(['--agent', '--stage', '--round', '--artifact', '--reason']);
+            const recoveryFlags = new Set(['--agent', '--auto']);
             for (const flag of Object.keys(values)) {
                 if (!recoveryFlags.has(flag))
                     operationInvalid(`option '${flag}' is not supported for recover-started`);
             }
-            required(values, ['--stage', '--round', '--artifact', '--reason']);
-            const stage = value(values, '--stage');
-            if (!['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'].includes(stage ?? '')) {
-                operationInvalid('--stage must be a supported lifecycle stage');
-            }
-            const round = Number(value(values, '--round'));
-            if (!Number.isSafeInteger(round) || round < 1)
-                operationInvalid('--round must be a positive integer');
-            if (value(values, '--reason').includes('\n') || value(values, '--reason').includes('\r')) {
-                operationInvalid('--reason must be a single line');
-            }
+            if (values['--auto'] !== true)
+                operationInvalid('--auto is required for recover-started');
+            return { family, request: input };
         }
-        else if (values['--stage'] !== undefined || values['--round'] !== undefined || values['--artifact'] !== undefined) {
-            operationInvalid('--stage, --round, and --artifact are only supported for recover-started');
+        else if (values['--auto'] !== undefined) {
+            operationInvalid('--auto is only supported for recover-started');
         }
         return { family, request: input };
     }
@@ -820,9 +821,6 @@ export function parseTaskControlOperation(family, args) {
         input.message = value(values, '--message');
         input.recoverable = recoverable === 'true';
     }
-    const options = value(values, '--git-worktree-root') === undefined
-        ? undefined
-        : { gitWorktreeRoot: value(values, '--git-worktree-root') };
-    return { family, taskRef, intent: parsedIntent, input, ...(options ? { options } : {}) };
+    return { family, taskRef, intent: parsedIntent, input };
 }
 //# sourceMappingURL=control-authority.js.map