@fitlab-ai/agent-infra 0.11.1 → 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,9 +13,10 @@ function receiptIdentity(value, generation, requestId) {
     if (!binding || typeof binding !== 'object' || Array.isArray(binding))
         return null;
     const controlBinding = binding;
-    if (receipt.version !== 2 || 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))
         || controlBinding.generation !== generation
         || typeof controlBinding.requestId !== 'string'
         || !/^[a-f0-9-]{16,64}$/u.test(controlBinding.requestId)

package/dist/lib/task/artifact-command.js

@@ -15,8 +15,8 @@ export function parseArtifactCommand(args) {
     const allowed = {
         inspect: ['--family'],
         init: ['--family', '--artifact', '--locale'],
-        'preflight': ['--family', '--artifact', '--recovery-id'],
-        'finalize-local': ['--family', '--artifact', '--recovery-id']
+        'preflight': ['--family', '--artifact'],
+        'finalize-local': ['--family', '--artifact']
     }[operation];
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
@@ -38,12 +38,12 @@ export function parseArtifactCommand(args) {
         throw new Error("option '--locale' must be 'zh-CN' or 'en'");
     return {
         taskRef, operation: operation, family: fields['--family'],
-        artifact: fields['--artifact'] ?? '', locale, recoveryId: fields['--recovery-id']
+        artifact: fields['--artifact'] ?? '', locale
     };
 }
 /** Resolve authoritative task metadata separately from a trusted candidate directory. */
 export function executeArtifactCommand(command, options = {}) {
-    const { taskRef, operation, family, artifact, locale, recoveryId } = command;
+    const { taskRef, operation, family, artifact, locale } = command;
     const fail = (code, message) => ({ status: 'failed', changed: false, error: { code, message } });
     if (operation === 'inspect') {
         const result = resolveArtifactContext(taskRef, family, { repoRoot: options.repoRoot });
@@ -76,7 +76,7 @@ export function executeArtifactCommand(command, options = {}) {
         return fail('ARTIFACT_PAYLOAD_INVALID', "preflight and finalize-local only support 'analysis', 'plan', and 'code'");
     }
     if (operation === 'preflight')
-        return { ...preflightLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot, recoveryId }) };
-    return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot, recoveryId }) };
+        return { ...preflightLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
+    return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
 }
 //# sourceMappingURL=artifact-command.js.map