@fitlab-ai/agent-infra 0.11.9 → 0.11.11

package/dist/lib/task/frontmatter.js

@@ -47,12 +47,35 @@ function serializeScalar(value) {
     }
     if (value === '')
         return '';
-    const serialized = stringify(value).trimEnd();
+    const serialized = stringify(value, { lineWidth: 0 }).trimEnd();
     if (serialized.includes('\n') || serialized.includes('\r')) {
         throw new FrontmatterError('MUTATION_INVALID', 'frontmatter values must be scalar');
     }
     return serialized;
 }
+function stripInlineComment(value) {
+    const first = value.search(/\S/u);
+    let activeQuote = first >= 0 && (value[first] === '"' || value[first] === "'") ? value[first] : null;
+    for (let index = activeQuote ? first + 1 : Math.max(first, 0); index < value.length; index += 1) {
+        const character = value[index];
+        if (activeQuote === '"' && character === '\\') {
+            index += 1;
+            continue;
+        }
+        if (activeQuote && character === activeQuote) {
+            if (activeQuote === "'" && value[index + 1] === "'") {
+                index += 1;
+                continue;
+            }
+            activeQuote = null;
+            continue;
+        }
+        if (!activeQuote && character === '#' && (index === 0 || /\s/u.test(value[index - 1]))) {
+            return value.slice(0, index).trimEnd();
+        }
+    }
+    return value;
+}
 function parseTaskFrontmatter(content) {
     const result = {};
     if (!content.startsWith('---'))
@@ -69,7 +92,7 @@ function parseTaskFrontmatter(content) {
         if (colon === -1)
             continue;
         const key = line.slice(0, colon).trim();
-        const value = line.slice(colon + 1).trim();
+        const value = stripInlineComment(line.slice(colon + 1).trim());
         if (key)
             result[key] = value;
     }

package/dist/lib/task/ledger-intents.js

@@ -10,6 +10,7 @@ import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkInten
 import { extractSection, extractSubSection } from './sections.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { scanVisibleMarkdown } from './markdown.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
 const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
 const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
@@ -61,9 +62,8 @@ function findingEvidence(reviewContent, evidence) {
     return semanticFindingEvidence(reviewContent, heading, next?.start ?? reviewContent.length);
 }
 function taskFactDigest(taskDir, content) {
-    const analysisNames = fs.readdirSync(taskDir).filter((name) => /^analysis(?:-r\d+)?\.md$/.test(name));
-    const latest = analysisNames.map((name) => ({ name, round: parseArtifactName(name)?.round ?? 0 })).sort((a, b) => b.round - a.round)[0];
-    const flow = latest ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, latest.name), 'utf8')) : null;
+    const latest = inspectArtifactDirectory(taskDir, 'analysis').latest;
+    const flow = latest ? parseLifecyclePathDecision(fs.readFileSync(latest.path, 'utf8'), latest.name) : null;
     return semanticDigest(JSON.stringify({
         taskInput: normalizedTaskFact(extractSection(content, ['任务输入', 'Task Input'])),
         requirements: normalizedTaskFact(extractSection(content, ['需求', 'Requirements'])),
@@ -220,10 +220,7 @@ function applyLedgerIntent(intent, options = {}) {
             }
             const sourceIdentity = parseArtifactName(intent.sourceArtifact);
             const expectedFamily = `review-${finding.stage}`;
-            const latestSource = fs.readdirSync(resolved.taskDir)
-                .map((name) => parseArtifactName(name))
-                .filter((identity) => identity?.family === expectedFamily)
-                .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0];
+            const latestSource = inspectArtifactDirectory(resolved.taskDir, expectedFamily).latest;
             if (!sourceIdentity || sourceIdentity.family !== expectedFamily || latestSource?.name !== sourceIdentity.name) {
                 return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild source artifact is not the latest review for the finding stage', resolved.taskId);
             }
@@ -339,7 +336,8 @@ function applyLedgerIntent(intent, options = {}) {
                         ? new Set(['confirmed', 'open', 'needs-human-decision'])
                         : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set();
                 const sameRoundMinorClose = before.status === 'open' && before.severity === 'minor' && intent.status === 'closed';
-                if (!sameRoundMinorClose && !allowed.has(intent.status)) {
+                const refreshOpenEvidence = before.status === 'open' && intent.status === 'open';
+                if (!sameRoundMinorClose && !refreshOpenEvidence && !allowed.has(intent.status)) {
                     return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot transition from ${before.status} to ${intent.status}`, resolved.taskId, intent.id);
                 }
                 after = { ...before, status: intent.status, evidence };

package/dist/lib/task/orchestration.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
-import { artifactName, maxArtifactRound } from './artifact-name.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 import { parseReviewSummary } from './review-artifacts.js';
@@ -20,7 +20,6 @@ import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead,
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js';
 import { hasOpenLifecycleExecution } from './activity-log.js';
-import { reconcileTaskInvalidation } from './invalidation-command.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { resolveArtifactContext } from './artifact-lifecycle.js';
 function supportsLifecycleDelegation(client) {
@@ -441,8 +440,11 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
     return { status: 'running', changed: true, taskId: resolved.taskId, run, next: null, error: null };
 }
 function validateSavedCurrentDiffBase(repoRoot, metadata, taskDir, reviewedHead) {
-    const reviewRound = maxArtifactRound(fs.readdirSync(taskDir), 'review-code');
-    const reviewContent = fs.readFileSync(path.join(taskDir, artifactName('review-code', reviewRound)), 'utf8');
+    const reviewInventory = inspectArtifactDirectory(taskDir, 'review-code');
+    if (reviewInventory.status !== 'ready' || !reviewInventory.latest) {
+        return { code: 'ORCHESTRATION_REVIEW_INVALID', message: 'latest completed review-code artifact is unavailable' };
+    }
+    const reviewContent = fs.readFileSync(reviewInventory.latest.path, 'utf8');
     const savedTargetHead = extractReviewTargetHead(reviewContent);
     const savedDiffBase = extractReviewDiffBase(reviewContent);
     const savedReviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
@@ -540,8 +542,11 @@ function routeOrchestration(taskRef, options = {}) {
         if (facts.facts.executionBusy && !run?.pendingDelegation) {
             return failed('ORCHESTRATION_EXECUTION_BUSY', 'clean completion requires no open lifecycle execution', resolved.taskId);
         }
-        const reviewRound = maxArtifactRound(fs.readdirSync(resolved.taskDir), 'review-code');
-        const review = parseReviewSummary(fs.readFileSync(path.join(resolved.taskDir, artifactName('review-code', reviewRound)), 'utf8'));
+        const reviewInventory = inspectArtifactDirectory(resolved.taskDir, 'review-code');
+        if (reviewInventory.status !== 'ready' || !reviewInventory.latest) {
+            return failed('ORCHESTRATION_REVIEW_INVALID', 'latest completed review-code artifact is unavailable', resolved.taskId);
+        }
+        const review = parseReviewSummary(fs.readFileSync(reviewInventory.latest.path, 'utf8'));
         if (!review.ok || review.summary.manualValidation === null) {
             return failed('ORCHESTRATION_REVIEW_INVALID', 'latest code review has no numeric manual-validation count', resolved.taskId);
         }
@@ -678,10 +683,6 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     }
     if (run.stepCount >= run.maxSteps)
         return pauseOrchestration(taskRef, 'ORCHESTRATION_MAX_STEPS', 'maximum orchestration steps reached', true, options);
-    const invalidation = reconcileTaskInvalidation(taskRef, { repoRoot: resolved.repoRoot });
-    if (invalidation.status === 'failed') {
-        return failed('ORCHESTRATION_INVALIDATION_RECONCILE_FAILED', `${invalidation.error?.code ?? 'UNKNOWN'}: ${invalidation.error?.message ?? ''}`, resolved.taskId);
-    }
     const routed = routeOrchestration(taskRef, options);
     if (!routed.next)
         return routed;

package/dist/lib/task/platform-operation-journal.js

@@ -4,7 +4,6 @@ import { createHash, randomUUID } from 'node:crypto';
 import { isResourceIdentity } from '../platform/resource-identity.js';
 import { resolveTaskRef } from './resolve-ref.js';
 const JOURNAL_FILE = '.platform-operations.json';
-const MAX_ATTEMPTS = 3;
 function operationId(input) {
     return createHash('sha256')
         .update(`${input.kind}\0${input.target}\0${input.expectedDigest}`)
@@ -36,8 +35,7 @@ function parseJournal(file, taskId) {
             || !/^[a-f0-9]{64}$/u.test(item.expectedDigest)
             || !['deferred', 'required'].includes(item.dependency)
             || !['queued', 'pending', 'unknown', 'succeeded', 'failed'].includes(item.state)
-            || !Number.isSafeInteger(item.attempts) || item.attempts < 0 || item.attempts > MAX_ATTEMPTS
-            || item.maxAttempts !== MAX_ATTEMPTS
+            || !Number.isSafeInteger(item.attempts) || item.attempts < 0
             || !(item.lastCode === null || typeof item.lastCode === 'string')
             || (item.kind === 'issue-metadata'
                 ? !item.issueMetadata || typeof item.issueMetadata.requirements !== 'boolean'
@@ -71,6 +69,18 @@ function parseJournal(file, taskId) {
                 ? !item.pullRequestSummary || typeof item.pullRequestSummary.body !== 'string'
                     || !item.pullRequestSummary.body.trim() || typeof item.pullRequestSummary.changeReportFile !== 'string'
                     || !item.pullRequestSummary.changeReportFile.trim()
+                    || (item.pullRequestSummary.manualValidation !== undefined && (!item.pullRequestSummary.manualValidation
+                        || typeof item.pullRequestSummary.manualValidation !== 'object'
+                        || Array.isArray(item.pullRequestSummary.manualValidation)
+                        || !['pending', 'final'].includes(item.pullRequestSummary.manualValidation.phase)
+                        || typeof item.pullRequestSummary.manualValidation.transactionId !== 'string'
+                        || !item.pullRequestSummary.manualValidation.transactionId.trim()
+                        || (item.pullRequestSummary.manualValidation.receiptDigest !== undefined && !/^[a-f0-9]{64}$/u.test(item.pullRequestSummary.manualValidation.receiptDigest))
+                        || (item.pullRequestSummary.manualValidation.prHeadSha !== undefined && !/^[a-f0-9]{40}$/u.test(item.pullRequestSummary.manualValidation.prHeadSha))
+                        || (item.pullRequestSummary.manualValidation.authority !== undefined && item.pullRequestSummary.manualValidation.authority !== 'coordinator')
+                        || (item.pullRequestSummary.manualValidation.phase === 'final' && (!/^[a-f0-9]{64}$/u.test(item.pullRequestSummary.manualValidation.receiptDigest ?? '')
+                            || !/^[a-f0-9]{40}$/u.test(item.pullRequestSummary.manualValidation.prHeadSha ?? '')
+                            || item.pullRequestSummary.manualValidation.authority !== 'coordinator'))))
                 : item.pullRequestSummary !== undefined)
             || (item.kind === 'pull-request-review'
                 ? !item.pullRequestReview || typeof item.pullRequestReview.prNumber !== 'string'
@@ -120,7 +130,13 @@ function recordPlatformOperation(input) {
     const { taskId, file } = resolveJournal(input.taskRef, input.cwd);
     const journal = parseJournal(file, taskId);
     const id = operationId(input);
-    const previous = journal.operations.find((item) => item.id === id);
+    const targetIndex = journal.operations.findIndex((item) => item.id === id);
+    const replacementIndex = input.replaceOperationId
+        ? journal.operations.findIndex((item) => item.id === input.replaceOperationId)
+        : -1;
+    const target = targetIndex >= 0 ? journal.operations[targetIndex] : undefined;
+    const replacement = replacementIndex >= 0 ? journal.operations[replacementIndex] : undefined;
+    const previousAttempts = Math.max(target?.attempts ?? 0, replacement?.attempts ?? 0);
     const next = {
         id,
         kind: input.kind,
@@ -128,8 +144,7 @@ function recordPlatformOperation(input) {
         expectedDigest: input.expectedDigest,
         dependency: input.dependency,
         state: input.state,
-        attempts: Math.min(MAX_ATTEMPTS, (previous?.attempts ?? 0) + (input.state === 'pending' ? 1 : 0)),
-        maxAttempts: MAX_ATTEMPTS,
+        attempts: previousAttempts + (input.state === 'pending' ? 1 : 0),
         lastCode: input.lastCode ?? null,
         ...(input.issueMetadata ? { issueMetadata: input.issueMetadata } : {}),
         ...(input.issueCreate ? { issueCreate: input.issueCreate } : {}),
@@ -138,9 +153,13 @@ function recordPlatformOperation(input) {
         ...(input.pullRequestReview ? { pullRequestReview: input.pullRequestReview } : {}),
         updatedAt: new Date().toISOString()
     };
-    const operations = previous
-        ? journal.operations.map((item) => item.id === id ? next : item)
-        : [...journal.operations, next];
+    const operations = replacementIndex >= 0
+        ? journal.operations.flatMap((item, index) => index === replacementIndex
+            ? [next]
+            : index === targetIndex ? [] : [item])
+        : targetIndex >= 0
+            ? journal.operations.map((item, index) => index === targetIndex ? next : item)
+            : [...journal.operations, next];
     writeJournal(file, { version: 1, taskId, operations });
     return next;
 }
@@ -148,5 +167,5 @@ function readPlatformOperationJournal(taskRef, cwd) {
     const { taskId, file } = resolveJournal(taskRef, cwd);
     return parseJournal(file, taskId);
 }
-export { JOURNAL_FILE as PLATFORM_OPERATION_JOURNAL_FILE, MAX_ATTEMPTS as PLATFORM_OPERATION_MAX_ATTEMPTS, operationId, recordPlatformOperation, readPlatformOperationJournal };
+export { JOURNAL_FILE as PLATFORM_OPERATION_JOURNAL_FILE, operationId, recordPlatformOperation, readPlatformOperationJournal };
 //# sourceMappingURL=platform-operation-journal.js.map

package/dist/lib/task/platform-operation-recovery.js

@@ -18,6 +18,8 @@ import { canonicalizeSummaryBody } from '../platform/comment-safety.js';
 import { platformResult } from '../platform/types.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { readPlatformOperationJournal, recordPlatformOperation } from './platform-operation-journal.js';
+import { providerErrorRetryable } from '../platform/provider-validation.js';
+const DEFAULT_RECOVERY_ATTEMPTS = 3;
 function labelsMatchOwnedPrefix(actual, expected, prefix) {
     return actual.filter((label) => label.startsWith(prefix)).sort().join('\0')
         === expected.filter((label) => label.startsWith(prefix)).sort().join('\0');
@@ -26,7 +28,7 @@ function fieldsMatchExpected(actual, expected) {
     return Object.entries(expected).every(([name, value]) => actual[name] === value);
 }
 function result(status, recovered, pending, error = null) {
-    return { status, changed: recovered.length > 0, recovered, pending, error };
+    return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null };
 }
 function summaryPayload(taskDir, taskId) {
     const file = path.join(taskDir, '.delivery-summary.json');
@@ -191,6 +193,16 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
     catch {
         return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Queued pull-request summary identity is invalid', retryable: false } });
     }
+    const summary = operation.pullRequestSummary;
+    if (!summary)
+        return platformResult('blocked', { error: {
+                code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Pull-request summary recovery content is missing', retryable: false
+            } });
+    const manualValidationHeading = /^###\s+(?:⏳\s+(?:Manual Validation Pending|人工验证待收尾)|✅\s+(?:Manual Validation Passed|人工验证已通过))\s*$/mu.test(summary.body);
+    if (manualValidationHeading && !summary.manualValidation)
+        return platformResult('blocked', { error: {
+                code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'Queued manual-validation summary has no persisted transaction context', retryable: false
+            } });
     const resolved = await resolvePlatformProviderContext({ cwd, client });
     if (!resolved.ok)
         return resolved.context;
@@ -198,20 +210,16 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
         ? await resolved.value.provider.comments.list({ context: providerOperationContext(resolved.value), parent: identity })
         : unsupportedProviderOperation(resolved.value.provider, 'comments.list');
     if (!listed.ok)
-        return platformResult(listed.error.retryable ? 'blocked' : 'failed', { error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') });
+        return platformResult(providerErrorRetryable(listed.error.code) ? 'blocked' : 'failed', { error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') });
     const marker = `<!-- sync-pr:${taskId}:summary -->`;
     const summaries = listed.value.filter((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] === marker);
     if (summaries.length > 1)
         return platformResult('blocked', { error: {
                 code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple pull-request comments contain the queued summary marker', retryable: false
             } });
-    if (summaries.length === 1 && createHash('sha256').update(normalizeCommentContent(summaries[0].body)).digest('hex') === operation.expectedDigest) {
+    if (!summary.manualValidation && summaries.length === 1 && createHash('sha256').update(normalizeCommentContent(summaries[0].body)).digest('hex') === operation.expectedDigest) {
         return platformResult('no-op');
     }
-    if (!operation.pullRequestSummary)
-        return platformResult('blocked', { error: {
-                code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Pull-request summary recovery content is missing', retryable: false
-            } });
     const bound = await inspectPlatformPullRequest(taskId, { cwd, client });
     if (!bound.pullRequest || !resourceIdentityEquals(bound.pullRequest.identity, identity))
         return platformResult('blocked', { error: bound.error ?? {
@@ -221,8 +229,9 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
         agent,
         cwd,
         client,
-        body: operation.pullRequestSummary.body,
-        changeReportFile: operation.pullRequestSummary.changeReportFile,
+        body: summary.body,
+        changeReportFile: summary.changeReportFile,
+        ...(summary.manualValidation ? { manualValidation: summary.manualValidation } : {}),
         primaryResult: 'no_op',
         strict: true,
         skipQueue: true,
@@ -293,7 +302,7 @@ async function replayPullRequest(taskId, operation, agent, cwd) {
     }
     return recoverCreatedPullRequest(taskId, { agent, cwd, base: intent.baseRef || '', head: intent.headRef || '', skipQueue: true });
 }
-async function recoverPlatformOperations(taskRef, selection, options) {
+async function recoverPlatformOperationsOnce(taskRef, selection, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return result('failed', [], [], { code: resolved.code, message: resolved.message, retryable: false });
@@ -307,34 +316,23 @@ async function recoverPlatformOperations(taskRef, selection, options) {
     }
     const candidates = journal.operations.filter((operation) => operation.id !== options.excludeId
         && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
-            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED')))
-        .filter((operation) => selection === 'all' || operation.dependency === selection)
-        .sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
+            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED')));
     if (!candidates.length)
         return result('no-op', [], []);
+    const head = candidates[0];
+    if (selection !== 'all' && head.dependency !== selection) {
+        return result('blocked', [], candidates.map((operation) => operation.id), {
+            code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
+            message: 'The first unresolved platform operation belongs to another recovery selection',
+            retryable: true
+        });
+    }
     const limit = options.limit === undefined ? candidates.length : Math.max(1, options.limit);
     const recovered = [];
     const pending = [];
     const selected = candidates.slice(0, limit);
     for (const [index, operation] of selected.entries()) {
-        if (operation.state === 'failed') {
-            pending.push(operation.id);
-            return result('blocked', recovered, pending, {
-                code: operation.lastCode || 'PLATFORM_OPERATION_FAILED',
-                message: 'A previous platform operation failed permanently; later writes remain queued',
-                retryable: false
-            });
-        }
-        if (operation.attempts >= operation.maxAttempts) {
-            pending.push(operation.id, ...selected.slice(index + 1).map((next) => next.id));
-            pending.push(...candidates.slice(limit).map((next) => next.id));
-            return result('blocked', recovered, pending, {
-                code: operation.lastCode || 'PLATFORM_OPERATION_RETRY_LIMIT_REACHED',
-                message: 'A previous platform operation exhausted its recovery attempts; later writes remain queued',
-                retryable: false
-            });
-        }
-        if (operation.kind !== 'issue-create') {
+        {
             try {
                 recordPlatformOperation({
                     taskRef: resolved.taskId, cwd: resolved.repoRoot, kind: operation.kind,
@@ -368,8 +366,8 @@ async function recoverPlatformOperations(taskRef, selection, options) {
             if (current.id !== operation.id) {
                 try {
                     recordPlatformOperation({ taskRef: resolved.taskId, cwd: resolved.repoRoot, kind: operation.kind, target: operation.target,
-                        expectedDigest: operation.expectedDigest, issueMetadata: operation.issueMetadata, dependency: operation.dependency,
-                        state: 'failed', lastCode: 'PLATFORM_OPERATION_SUPERSEDED' });
+                        expectedDigest: current.expectedDigest, issueMetadata: current.issueMetadata, dependency: operation.dependency,
+                        state: 'queued', replaceOperationId: operation.id });
                     targetOperation = { ...operation, expectedDigest: current.expectedDigest, issueMetadata: current.issueMetadata, id: current.id };
                 }
                 catch (error) {
@@ -396,7 +394,7 @@ async function recoverPlatformOperations(taskRef, selection, options) {
             if (current.id !== operation.id) {
                 try {
                     recordPlatformOperation({ taskRef: resolved.taskId, cwd: resolved.repoRoot, kind: operation.kind, target: operation.target,
-                        expectedDigest: operation.expectedDigest, dependency: operation.dependency, state: 'failed', lastCode: 'PLATFORM_OPERATION_SUPERSEDED' });
+                        expectedDigest: current.expectedDigest, dependency: operation.dependency, state: 'queued', replaceOperationId: operation.id });
                     targetOperation = { ...operation, expectedDigest: current.expectedDigest, id: current.id };
                 }
                 catch (error) {
@@ -437,7 +435,7 @@ async function recoverPlatformOperations(taskRef, selection, options) {
                 ...(operation.pullRequestSummary ? { pullRequestSummary: operation.pullRequestSummary } : {}),
                 ...(operation.pullRequestReview ? { pullRequestReview: operation.pullRequestReview } : {}),
                 dependency: operation.dependency,
-                state: succeeded ? 'succeeded' : remote.status === 'failed' && remote.error?.retryable === false ? 'failed' : 'unknown',
+                state: succeeded ? 'succeeded' : 'unknown',
                 lastCode: remote.error?.code ?? null
             });
         }
@@ -455,5 +453,81 @@ async function recoverPlatformOperations(taskRef, selection, options) {
     pending.push(...remaining);
     return result(pending.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, pending, pending.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain pending after the recovery budget', retryable: true } : null);
 }
+async function recoverPlatformOperations(taskRef, selection, options) {
+    const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+    if (!resolved.ok)
+        return result('failed', [], [], { code: resolved.code, message: resolved.message, retryable: false });
+    let initial;
+    try {
+        initial = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot);
+    }
+    catch (error) {
+        const value = error;
+        return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
+    }
+    const eligible = (operation) => operation.id !== options.excludeId
+        && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
+            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED'));
+    const first = initial.operations.filter(eligible);
+    if (!first.length)
+        return result('no-op', [], []);
+    const operationLimit = options.limit === undefined ? first.length : Math.max(1, options.limit);
+    const attemptLimit = options.attempts ?? DEFAULT_RECOVERY_ATTEMPTS;
+    if (!Number.isSafeInteger(attemptLimit) || attemptLimit <= 0) {
+        return result('failed', [], [], { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'Recovery attempts must be a positive safe integer', retryable: false });
+    }
+    const recovered = [];
+    for (let operationIndex = 0; operationIndex < operationLimit; operationIndex += 1) {
+        let latest;
+        try {
+            latest = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot);
+        }
+        catch (error) {
+            const value = error;
+            return result('failed', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
+        }
+        const head = latest.operations.find(eligible);
+        if (!head)
+            break;
+        if (selection !== 'all' && head.dependency !== selection) {
+            const pending = latest.operations.filter(eligible).map((operation) => operation.id);
+            return result('blocked', recovered, pending, {
+                code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
+                message: 'The first unresolved platform operation belongs to another recovery selection',
+                retryable: true
+            });
+        }
+        let last = null;
+        for (let attempt = 0; attempt < attemptLimit; attempt += 1) {
+            last = await recoverPlatformOperationsOnce(taskRef, selection, { ...options, limit: 1 });
+            recovered.push(...last.recovered.filter((id) => !recovered.includes(id)));
+            if (last.recovered.length > 0 || last.status === 'applied' || last.status === 'no-op')
+                break;
+        }
+        if (!last || (last.recovered.length === 0 && last.status !== 'applied' && last.status !== 'no-op')) {
+            let current;
+            try {
+                current = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot);
+            }
+            catch {
+                return result('blocked', recovered, [head.id], last?.error ?? null);
+            }
+            const pending = current.operations.filter(eligible).map((operation) => operation.id);
+            return result(last?.status === 'failed' ? 'failed' : 'blocked', recovered, pending, last?.error ?? {
+                code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
+                message: 'The first queued platform operation remains unresolved after this recovery run',
+                retryable: true
+            });
+        }
+    }
+    let remaining;
+    try {
+        remaining = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.filter(eligible).map((operation) => operation.id);
+    }
+    catch {
+        remaining = [];
+    }
+    return result(remaining.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, remaining, remaining.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain queued after this recovery run', retryable: true } : null);
+}
 export { fieldsMatchExpected, labelsMatchOwnedPrefix, recoverPlatformOperations };
 //# sourceMappingURL=platform-operation-recovery.js.map

package/dist/lib/task/resolve-ref.js

@@ -98,16 +98,21 @@ function enumerateTaskDirs(repoRoot) {
  */
 function enumerateAllTaskDirs(repoRoot) {
     const out = [];
-    const seen = new Set();
+    const seen = new Map();
     const add = (taskId, taskDir, state) => {
         if (!TASK_ID_RE.test(taskId))
             return;
         const stat = fs.lstatSync(taskDir);
         if (!stat.isDirectory() || stat.isSymbolicLink() || !fs.existsSync(path.join(taskDir, 'task.md')))
             return;
-        if (seen.has(taskId))
+        const canonicalDir = fs.realpathSync.native(taskDir);
+        const previousDir = seen.get(taskId);
+        if (previousDir !== undefined) {
+            if (previousDir === canonicalDir)
+                return;
             throw new Error(`duplicate task identity: ${taskId}`);
-        seen.add(taskId);
+        }
+        seen.set(taskId, canonicalDir);
         out.push({ taskId, taskDir, state });
     };
     for (const state of FLAT_WORKSPACE_DIRS) {

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

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { artifactName, maxArtifactRound } from "./artifact-name.js";
-import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from "./invalidation.js";
+import { inspectArtifactDirectory } from "./artifact-lifecycle.js";
 const REVIEWED_TREE_RE = /^[a-f0-9]{40,64}$/;
 export function parseReviewedGitTree(value) {
     return REVIEWED_TREE_RE.test(value) ? value : null;
@@ -28,32 +27,11 @@ export function resolvePostReviewGlobs(config = {}, reviewConfig = {}) {
     return [":/", ...excludes.map((p) => `:(top,exclude)${p}`)];
 }
 export function findAuthoritativeReviewCodeArtifact(taskDir) {
-    const entries = fs.existsSync(taskDir) ? fs.readdirSync(taskDir) : [];
-    const round = maxArtifactRound(entries, "review-code");
-    if (round === 0) {
+    const inventory = inspectArtifactDirectory(taskDir, 'review-code');
+    if (inventory.status !== 'ready' || !inventory.latest) {
         return { ok: false, round: 0, fileName: null, path: null, error: null };
     }
-    const fileName = artifactName("review-code", round);
-    let taskContent;
-    try {
-        taskContent = fs.readFileSync(path.join(taskDir, "task.md"), "utf8");
-    }
-    catch (error) {
-        return {
-            ok: false, round, fileName, path: null,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    const invalidation = parseInvalidationDocument(taskContent);
-    if (!invalidation.ok) {
-        return { ok: false, round, fileName, path: null, error: invalidation.message };
-    }
-    if (invalidationBlocks(invalidation.document)) {
-        return { ok: false, round, fileName, path: null, error: "artifact invalidation is incomplete; reconcile task.md before using review-code" };
-    }
-    if (isArtifactInvalidated(invalidation.document, "review-code", fileName)) {
-        return { ok: false, round, fileName, path: null, error: `${fileName} is invalidated; re-run review-code` };
-    }
+    const { round, name: fileName } = inventory.latest;
     return {
         ok: true,
         round,