@fitlab-ai/agent-infra 0.10.0 → 0.11.0

package/dist/lib/task/artifact-repair-intent.js

@@ -37,22 +37,28 @@ export function isArtifactRecoveryIntent(value) {
         return false;
     const intent = value;
     return exactKeys(intent, [
-        'artifact', 'authorityDigest', 'baselineSemanticDigest', 'baselineSha256', 'candidateSha256',
+        'activeGenerationSemanticDigest', 'activeGenerationSha256', 'artifact', 'authorityDigest', 'baselineSemanticDigest', 'baselineSha256', 'candidateSha256',
         'createdAt', 'errorCode', 'errorMessage', 'family', 'finalArtifactSha256', 'finalSemanticDigest',
-        'phase', 'recoveryOperationId', 'requestId', 'round', 'stagingId', 'state', 'taskId', 'updatedAt',
+        'pendingGenerationSemanticDigest', 'pendingGenerationSha256', 'phase', 'preflightArtifactSha256', 'preflightSemanticDigest', 'recoveryOperationId', 'requestId', 'round', 'stagingId', 'state', 'taskId', 'updatedAt',
         'version'
     ])
-        && intent.version === 3
+        && intent.version === 4
         && validTaskId(intent.taskId)
         && typeof intent.family === 'string'
         && ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'].includes(intent.family)
         && Number.isSafeInteger(intent.round) && intent.round > 0
         && validArtifact(intent.artifact, intent.family, intent.round)
-        && ['awaiting-recovery', 'finalize-ready', 'commit-started', 'passed', 'consumed', 'aborted'].includes(String(intent.state))
+        && ['awaiting-preflight-recovery', 'preflight-ready', 'preflight-commit-started', 'preflight-passed', 'full-finalizer-ready', 'commit-started', 'passed', 'consumption-started', 'consumed', 'aborted'].includes(String(intent.state))
         && validDigest(intent.baselineSha256)
         && validDigest(intent.baselineSemanticDigest)
         && validRecoveryId(intent.stagingId)
         && (intent.candidateSha256 === null || validDigest(intent.candidateSha256))
+        && (intent.preflightArtifactSha256 === null || validDigest(intent.preflightArtifactSha256))
+        && (intent.preflightSemanticDigest === null || validDigest(intent.preflightSemanticDigest))
+        && (intent.activeGenerationSha256 === null || validDigest(intent.activeGenerationSha256))
+        && (intent.activeGenerationSemanticDigest === null || validDigest(intent.activeGenerationSemanticDigest))
+        && (intent.pendingGenerationSha256 === null || validDigest(intent.pendingGenerationSha256))
+        && (intent.pendingGenerationSemanticDigest === null || validDigest(intent.pendingGenerationSemanticDigest))
         && (intent.finalArtifactSha256 === null || validDigest(intent.finalArtifactSha256))
         && (intent.finalSemanticDigest === null || validDigest(intent.finalSemanticDigest))
         && validRecoveryId(intent.recoveryOperationId)
@@ -64,11 +70,22 @@ export function isArtifactRecoveryIntent(value) {
         && (intent.errorMessage === null || validToken(intent.errorMessage))
         && Number.isSafeInteger(intent.createdAt)
         && Number.isSafeInteger(intent.updatedAt)
-        && (intent.state === 'awaiting-recovery'
-            ? intent.finalArtifactSha256 === null && intent.finalSemanticDigest === null
+        && (intent.state === 'awaiting-preflight-recovery'
+            ? intent.preflightArtifactSha256 === null && intent.preflightSemanticDigest === null
+                && intent.activeGenerationSha256 === null && intent.activeGenerationSemanticDigest === null
+                && intent.pendingGenerationSha256 === null && intent.pendingGenerationSemanticDigest === null
+                && intent.finalArtifactSha256 === null && intent.finalSemanticDigest === null
             : true)
-        && (intent.state === 'finalize-ready' || intent.state === 'commit-started' || intent.state === 'passed' || intent.state === 'consumed'
-            ? validDigest(intent.candidateSha256) && validDigest(intent.finalArtifactSha256) && validDigest(intent.finalSemanticDigest)
+        && (intent.state === 'preflight-ready' || intent.state === 'preflight-commit-started' || intent.state === 'preflight-passed' || intent.state === 'full-finalizer-ready' || intent.state === 'commit-started' || intent.state === 'passed' || intent.state === 'consumed'
+            ? validDigest(intent.candidateSha256) && validDigest(intent.preflightArtifactSha256) && validDigest(intent.preflightSemanticDigest)
+                && validDigest(intent.activeGenerationSha256) && validDigest(intent.activeGenerationSemanticDigest)
+            : true)
+        && (intent.state === 'full-finalizer-ready' || intent.state === 'commit-started'
+            ? validDigest(intent.pendingGenerationSha256) && validDigest(intent.pendingGenerationSemanticDigest)
+                && validDigest(intent.finalArtifactSha256) && validDigest(intent.finalSemanticDigest)
+            : true)
+        && (intent.state === 'passed' || intent.state === 'consumption-started' || intent.state === 'consumed'
+            ? validDigest(intent.finalArtifactSha256) && validDigest(intent.finalSemanticDigest)
             : true)
         && (intent.state === 'aborted' ? intent.errorCode !== null && intent.errorMessage !== null : true);
 }

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

@@ -266,7 +266,7 @@ function lifecycleRecoveryIntentMatches(intent, selector) {
     return intent.taskId === selector.taskId
         && intent.family === selector.family
         && intent.artifact === selector.artifact
-        && (intent.state === 'commit-started' || intent.state === 'consumed');
+        && (intent.state === 'commit-started' || intent.state === 'consumption-started' || intent.state === 'consumed');
 }
 /**
  * Completes only the durable tail of a committed task event after a process

package/dist/lib/task/events.js

@@ -334,7 +334,7 @@ function reconcileReviewCompletionReplay(repoRoot, taskDir, taskId, family, arti
             }
             intent = reconciled.intent;
         }
-        if (!['passed', 'consumed'].includes(intent.state)) {
+        if (!['passed', 'consumption-started', 'consumed'].includes(intent.state)) {
             return {
                 code: 'EVENT_ARTIFACT_CONFLICT',
                 message: `review finalizer provenance is incomplete for ${artifact}`
@@ -355,7 +355,7 @@ function reconcileReviewCompletionReplay(repoRoot, taskDir, taskId, family, arti
                 message: `review finalizer provenance does not match ${artifact}`
             };
         }
-        if (intent.state === 'passed') {
+        if (intent.state === 'passed' || intent.state === 'consumption-started') {
             const consumed = { ...intent, state: 'consumed', updatedAt: Date.now() };
             writeArtifactRecoveryIntent(repoRoot, consumed, { expected: intent });
         }
@@ -935,7 +935,7 @@ function applyTaskEventUnlocked(request, options = {}) {
                 if (reconciled.status === 'passed' || reconciled.status === 'consumed')
                     reviewFinalizationIntent = reconciled.intent;
             }
-            if (!reviewFinalizationIntent || !['passed', 'consumed'].includes(reviewFinalizationIntent.state)) {
+            if (!reviewFinalizationIntent || !['passed', 'consumption-started', 'consumed'].includes(reviewFinalizationIntent.state)) {
                 return failed(normalized, {
                     code: 'EVENT_ARTIFACT_CONFLICT',
                     message: `review finalizer provenance is missing or incomplete for ${completedArtifact.name}`
@@ -1106,7 +1106,7 @@ function applyTaskEventUnlocked(request, options = {}) {
                 const expectedIntent = localFinalizationIntent;
                 localFinalizationIntent = {
                     ...localFinalizationIntent,
-                    state: 'commit-started',
+                    state: 'consumption-started',
                     phase: 'task-event.completed',
                     authorityDigest: lifecycleRecoveryAttestationDigest(lifecycleAuthority),
                     requestId: lifecycleAuthority.lifecycleRequestId,
@@ -1138,7 +1138,7 @@ function applyTaskEventUnlocked(request, options = {}) {
             const expectedIntent = reviewFinalizationIntent;
             reviewFinalizationIntent = {
                 ...reviewFinalizationIntent,
-                state: 'commit-started',
+                state: 'consumption-started',
                 phase: 'task-event.completed',
                 updatedAt: Date.now()
             };
@@ -1179,7 +1179,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     }
     if (!normalized.dryRun && reviewFinalizationIntent && completedArtifact) {
         try {
-            if (reviewFinalizationIntent.state === 'commit-started') {
+            if (reviewFinalizationIntent.state === 'consumption-started') {
                 const consumed = { ...reviewFinalizationIntent, state: 'consumed', updatedAt: Date.now() };
                 writeArtifactRecoveryIntent(resolved.repoRoot, consumed, { expected: reviewFinalizationIntent });
             }

package/dist/lib/task/intermediate-cleanup.js

@@ -292,12 +292,37 @@ function cleanupConsumedRecoveryFiles(repoRoot, task, candidate) {
         return false;
     }
     for (const entry of entries) {
-        if (entry.isSymbolicLink() || !entry.isFile() || !['baseline.md', 'candidate.md', 'final.md', 'publish.md'].includes(entry.name))
+        if (entry.isSymbolicLink())
+            return false;
+        if (entry.isFile()) {
+            if (!['baseline.md', 'candidate.md', 'final.md', 'publish.md'].includes(entry.name))
+                return false;
+            continue;
+        }
+        if (!entry.isDirectory() || entry.name !== 'generations')
+            return false;
+        let generations;
+        try {
+            generations = fs.readdirSync(path.join(recovery, entry.name), { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        if (generations.some((generation) => generation.isSymbolicLink()
+            || !generation.isFile() || !/^[a-f0-9]{64}\.md$/u.test(generation.name)))
             return false;
     }
     try {
-        for (const entry of entries)
-            fs.unlinkSync(path.join(recovery, entry.name));
+        for (const entry of entries) {
+            const target = path.join(recovery, entry.name);
+            if (entry.isFile())
+                fs.unlinkSync(target);
+            else {
+                for (const generation of fs.readdirSync(target, { withFileTypes: true }))
+                    fs.unlinkSync(path.join(target, generation.name));
+                fs.rmdirSync(target);
+            }
+        }
         fs.rmdirSync(recovery);
         const recoveryRoot = path.dirname(recovery);
         if (fs.readdirSync(recoveryRoot).length === 0)

package/dist/lib/task/local-artifact-finalization.js

@@ -8,7 +8,7 @@ import { expectedQualificationRelations, validateQualificationAudit } from './qu
 import { canonicalSemanticDigest, inspectArtifactPatterns, inspectArtifactStructure, sha256Content } from './artifact-operations.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { readArtifactRecoveryIntent } from './artifact-repair-intent.js';
-import { beginArtifactRecovery, commitArtifactRecovery, consumeArtifactRecovery, prepareArtifactRecoveryCommit, recordArtifactRecoveryPassed, recoveryContextFromIntent, stageArtifactCandidate } from './artifact-recovery.js';
+import { beginArtifactRecovery, commitArtifactRecovery, consumeArtifactRecovery, prepareArtifactRecoveryFinal, prepareArtifactRecoveryCommit, recordArtifactRecoveryPassed, reconcileArtifactRecovery, recoveryContextFromIntent, stageArtifactCandidate } from './artifact-recovery.js';
 import { consumeLifecycleRecoveryAttestation, lifecycleRecoveryAttestationDigest, validateLifecycleRecoveryAttestation } from './control-authority.js';
 const LOCAL_ARTIFACT_REQUIRED_SECTIONS = {
     analysis: getArtifactSchema('analysis').sections.map((section) => section.headings.zh),
@@ -136,7 +136,7 @@ function tupleFor(request, taskId, authority) {
         authorityDigest: authority ? authorityDigest(authority) : null
     };
 }
-function prepareLocalArtifact(request, candidate, authority) {
+function prepareLocalArtifact(request, candidate, authority, preflightOnly = false) {
     const failed = (code, message, extra = {}) => ({
         result: failedFinalization(request, { code, message }, extra), content: candidate ?? ''
     });
@@ -152,14 +152,16 @@ function prepareLocalArtifact(request, candidate, authority) {
     let taskContent;
     let content;
     let recovery;
+    let recoveryState;
     try {
         taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
         if (request.recoveryId) {
             const intent = readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, request.family, request.artifact);
             if (!intent || intent.recoveryOperationId !== request.recoveryId)
                 return failed('LOCAL_RECOVERY_PROVENANCE_CONFLICT', 'recovery id does not match the artifact journal');
-            if (!['awaiting-recovery', 'finalize-ready', 'commit-started'].includes(intent.state))
+            if (!['awaiting-preflight-recovery', 'preflight-ready', 'preflight-commit-started', 'preflight-passed', 'full-finalizer-ready', 'commit-started'].includes(intent.state))
                 return failed('LOCAL_RECOVERY_PROVENANCE_CONFLICT', `recovery journal is in '${intent.state}' state`);
+            recoveryState = intent.state;
             recovery = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, intent);
             content = fs.existsSync(recovery.stagingPath)
                 ? fs.readFileSync(recovery.stagingPath, 'utf8')
@@ -192,24 +194,63 @@ function prepareLocalArtifact(request, candidate, authority) {
     if (request.recoveryId) {
         if (!validation.ok)
             return { result, content, repoRoot: resolved.repoRoot, recovery, authority, lockAlreadyHeld: request.lockAlreadyHeld };
+        if (preflightOnly && recovery && recoveryState === 'awaiting-preflight-recovery') {
+            const staged = stageArtifactCandidate(recovery, Buffer.from(content, 'utf8'), { lockAlreadyHeld: request.lockAlreadyHeld });
+            prepareArtifactRecoveryCommit(recovery, staged.candidateSha256, staged.semanticDigest, { lockAlreadyHeld: request.lockAlreadyHeld });
+        }
         return {
-            result: { ...result, status: 'passed', error: null, recovery: recoveryInfo(recovery) },
+            result: { ...result, status: 'passed', changed: false, error: null, recovery: recoveryInfo(recovery) },
             content, repoRoot: resolved.repoRoot, recovery, authority, lockAlreadyHeld: request.lockAlreadyHeld
         };
     }
     const existing = readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, request.family, request.artifact);
     if (existing?.state === 'passed' || existing?.state === 'consumed') {
-        if (existing.finalArtifactSha256 !== artifactSha256 || existing.finalSemanticDigest !== validation.semanticDigest) {
+        if (existing.state === 'consumed' && (existing.finalArtifactSha256 !== artifactSha256 || existing.finalSemanticDigest !== validation.semanticDigest)) {
             return { ...failed('LOCAL_RECOVERY_PROVENANCE_CONFLICT', 'formal artifact does not match its completed recovery journal'), content, repoRoot: resolved.repoRoot, authority, lockAlreadyHeld: request.lockAlreadyHeld };
         }
+        if (existing.finalArtifactSha256 === artifactSha256 && existing.finalSemanticDigest === validation.semanticDigest) {
+            const context = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, existing);
+            return {
+                result: { ...result, status: 'passed', error: null, recovery: recoveryInfo(context) },
+                content, repoRoot: resolved.repoRoot, recovery: context, authority, lockAlreadyHeld: request.lockAlreadyHeld
+            };
+        }
+    }
+    if (existing && ['preflight-ready', 'preflight-commit-started', 'preflight-passed', 'full-finalizer-ready'].includes(existing.state)) {
+        const context = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, existing);
+        return {
+            result: { ...result, status: 'passed', changed: false, error: null, recovery: recoveryInfo(context) },
+            content, repoRoot: resolved.repoRoot, recovery: context, authority, lockAlreadyHeld: request.lockAlreadyHeld
+        };
+    }
+    if (existing?.state === 'commit-started') {
+        if (existing.finalArtifactSha256 !== artifactSha256 || existing.finalSemanticDigest !== validation.semanticDigest) {
+            return { ...failed('LOCAL_RECOVERY_PROVENANCE_CONFLICT', 'formal artifact does not match the interrupted recovery journal'), content, repoRoot: resolved.repoRoot, authority, lockAlreadyHeld: request.lockAlreadyHeld };
+        }
         const context = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, existing);
+        const reconciled = reconcileArtifactRecovery(context, {
+            lockAlreadyHeld: request.lockAlreadyHeld,
+            validateFinal: () => validation.semanticDigest === existing.finalSemanticDigest
+        });
+        if (reconciled.status !== 'passed') {
+            return { ...failed('LOCAL_RECOVERY_PROVENANCE_CONFLICT', `interrupted recovery could not be reconciled: ${reconciled.status}`), content, repoRoot: resolved.repoRoot, recovery: context, authority, lockAlreadyHeld: request.lockAlreadyHeld };
+        }
         return {
-            result: { ...result, status: 'passed', error: null, recovery: recoveryInfo(context) },
+            result: { ...result, status: 'passed', changed: false, error: null, recovery: recoveryInfo(context) },
             content, repoRoot: resolved.repoRoot, recovery: context, authority, lockAlreadyHeld: request.lockAlreadyHeld
         };
     }
     try {
         if (validation.ok) {
+            if (preflightOnly) {
+                const context = beginArtifactRecovery(tupleFor(request, resolved.taskId, authority), Buffer.from(content, 'utf8'), {
+                    repoRoot: resolved.repoRoot, taskDir: resolved.taskDir,
+                    ...(authority ? { recoveryId: authority.operationId } : {}), lockAlreadyHeld: request.lockAlreadyHeld
+                });
+                const staged = stageArtifactCandidate(context, Buffer.from(content, 'utf8'), { lockAlreadyHeld: request.lockAlreadyHeld });
+                prepareArtifactRecoveryCommit(context, staged.candidateSha256, staged.semanticDigest, { lockAlreadyHeld: request.lockAlreadyHeld });
+                return { result: { ...result, status: 'passed', error: null, recovery: recoveryInfo(context) }, content, repoRoot: resolved.repoRoot, recovery: context, authority, lockAlreadyHeld: request.lockAlreadyHeld };
+            }
             const context = recordArtifactRecoveryPassed(tupleFor(request, resolved.taskId, authority), {
                 repoRoot: resolved.repoRoot,
                 taskDir: resolved.taskDir,
@@ -219,7 +260,7 @@ function prepareLocalArtifact(request, candidate, authority) {
                 lockAlreadyHeld: request.lockAlreadyHeld
             });
             recovery = context;
-            return { result: { ...result, status: 'passed', error: null, recovery: recoveryInfo(context) }, content, repoRoot: resolved.repoRoot, recovery, authority, lockAlreadyHeld: request.lockAlreadyHeld };
+            return { result: { ...result, status: 'passed', changed: false, error: null, recovery: recoveryInfo(context) }, content, repoRoot: resolved.repoRoot, recovery, authority, lockAlreadyHeld: request.lockAlreadyHeld };
         }
         const context = beginArtifactRecovery(tupleFor(request, resolved.taskId, authority), Buffer.from(content, 'utf8'), {
             repoRoot: resolved.repoRoot,
@@ -237,7 +278,7 @@ function prepareLocalArtifact(request, candidate, authority) {
         return { ...failed('LOCAL_RECOVERY_PROVENANCE_CONFLICT', String(error)), content, repoRoot: resolved.repoRoot, authority, lockAlreadyHeld: request.lockAlreadyHeld };
     }
 }
-function commitLocalArtifactProvenance(prepared) {
+function commitLocalArtifactProvenance(prepared, options = {}) {
     if (!prepared.recovery || !prepared.repoRoot || prepared.result.status === 'failed' && !prepared.result.recovery)
         return prepared.result;
     if (prepared.result.status === 'failed')
@@ -250,30 +291,48 @@ function commitLocalArtifactProvenance(prepared) {
         if (intent.state === 'passed' || intent.state === 'consumed') {
             return {
                 ...prepared.result,
+                changed: false,
                 artifactSha256: intent.finalArtifactSha256,
                 semanticDigest: intent.finalSemanticDigest,
                 error: null
             };
         }
-        else if (intent.state === 'finalize-ready' || intent.state === 'commit-started') {
-            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld });
+        else if (intent.state === 'commit-started') {
+            const reconciled = reconcileArtifactRecovery(prepared.recovery, {
+                lockAlreadyHeld: prepared.lockAlreadyHeld,
+                afterPublish: options.afterPublish
+            });
+            committed = reconciled.intent;
         }
-        else {
+        else if (intent.state === 'awaiting-preflight-recovery') {
             const staged = stageArtifactCandidate(prepared.recovery, Buffer.from(prepared.content, 'utf8'), { lockAlreadyHeld: prepared.lockAlreadyHeld });
             prepareArtifactRecoveryCommit(prepared.recovery, staged.candidateSha256, staged.semanticDigest, { lockAlreadyHeld: prepared.lockAlreadyHeld });
             committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld });
         }
-        if (committed.state !== 'passed')
-            throw new Error(`ARTIFACT_RECOVERY_STATE_INVALID: commit ended in '${committed.state}'`);
+        if (intent.state === 'preflight-ready' || intent.state === 'preflight-commit-started') {
+            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld });
+        }
+        if (committed?.state === 'preflight-passed' || intent.state === 'preflight-passed') {
+            prepareArtifactRecoveryFinal(prepared.recovery, Buffer.from(prepared.content, 'utf8'), { lockAlreadyHeld: prepared.lockAlreadyHeld });
+            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld, afterPublish: options.afterPublish });
+        }
+        else if (intent.state === 'full-finalizer-ready') {
+            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld, afterPublish: options.afterPublish });
+        }
+        if (!committed || committed.state !== 'passed')
+            throw new Error(`ARTIFACT_RECOVERY_STATE_INVALID: commit ended in '${committed?.state ?? intent.state}'`);
         return {
             ...prepared.result,
             status: 'passed',
+            changed: false,
             artifactSha256: committed.finalArtifactSha256,
             semanticDigest: committed.finalSemanticDigest,
             error: null
         };
     }
     catch (error) {
+        if (error instanceof Error && error.message.startsWith('TASK_WORKFLOW_FAULT_INJECTED:'))
+            throw error;
         return { ...prepared.result, status: 'failed', error: {
                 code: 'LOCAL_RECOVERY_COMMIT_FAILED', message: String(error)
             } };
@@ -295,5 +354,10 @@ function finalizeLocalArtifact(request, authority, options = {}) {
     }
     return result;
 }
-export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, consumeLocalArtifactFinalizationIntent, finalizeLocalArtifact, prepareLocalArtifact, commitLocalArtifactProvenance, readArtifactRecoveryIntent as readLocalArtifactFinalizationIntent, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
+/** Validate and seal an immutable preflight generation without publishing the formal artifact. */
+function preflightLocalArtifact(request, authority) {
+    const prepared = prepareLocalArtifact(request, undefined, authority, true);
+    return prepared.result;
+}
+export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, consumeLocalArtifactFinalizationIntent, finalizeLocalArtifact, preflightLocalArtifact, prepareLocalArtifact, commitLocalArtifactProvenance, readArtifactRecoveryIntent as readLocalArtifactFinalizationIntent, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
 //# sourceMappingURL=local-artifact-finalization.js.map

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

@@ -1,6 +1,6 @@
 export function parseReviewCommand(args) {
-    if (!args[0] || args[1] !== 'finalize-summary')
-        throw new Error('task ref and finalize-summary are required');
+    if (!args[0] || !['preflight', 'finalize-summary'].includes(args[1] ?? ''))
+        throw new Error('task ref and a supported review operation are required');
     const values = {};
     const flags = {
         '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun',