@fitlab-ai/agent-infra 0.11.15 → 0.12.1

package/dist/lib/task/orchestration.js

@@ -7,19 +7,19 @@ import { validateCurrentTaskContract } from './current-contract.js';
 import { parseReviewSummary } from './review-artifacts.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 import { activateDelegation, abortActivatedDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
 import { normalizeAgentClients } from '../agent-clients/config.js';
 import { getAgentClientAdapter, getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots } from './workspace-snapshot.js';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.js';
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js';
 import { hasOpenLifecycleExecution } from './activity-log.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
-import { resolveArtifactContext } from './artifact-lifecycle.js';
+import { resolveArtifactContextForResolvedTask } from './artifact-lifecycle.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -274,15 +274,9 @@ function mutateDelegationAdapterEvidence(taskRef, receiptId, adapterId, mutate,
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         throw new Error(`${resolved.code}: ${resolved.message}`);
-    return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, false);
+    return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options);
 }
-function mutateDelegationAdapterEvidenceWithinTaskLock(taskRef, receiptId, adapterId, mutate, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, true);
-}
-function mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, taskLockHeld) {
+function mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options) {
     const update = () => {
         try {
             const run = readRun(resolved.taskDir, options);
@@ -316,9 +310,7 @@ function mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterI
         }
     };
     let mutationError;
-    const result = taskLockHeld
-        ? update()
-        : withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `agent-adapter.${adapterId}.evidence`, update);
+    const result = update();
     if (mutationError)
         throw mutationError;
     return result;
@@ -542,10 +534,7 @@ function routeFromFacts(facts) {
     const role = action.startsWith('review-') ? 'reviewer' : 'executor';
     return { action: command, role, stage: action };
 }
-function routeOrchestration(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failed(resolved.code, resolved.message, resolved.taskId);
+function routeResolvedTask(taskRef, resolved, options) {
     let gitRoot;
     try {
         gitRoot = gitRootFor(resolved.repoRoot, options);
@@ -584,7 +573,7 @@ function routeOrchestration(taskRef, options = {}) {
     catch (error) {
         return failed('ORCHESTRATION_STATE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
-    const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state, hasOpenLifecycleExecution(content) || Boolean(run?.pendingDelegation));
+    const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state, hasOpenLifecycleExecution(content) || Boolean(run?.pendingDelegation), resolved.repoRoot);
     if (!facts.ok)
         return failed('ORCHESTRATION_CAPABILITY_FACTS_INVALID', facts.message, resolved.taskId);
     const routed = routeFromFacts(facts.facts);
@@ -674,7 +663,7 @@ function routeOrchestration(taskRef, options = {}) {
     }
     const action = routed.stage;
     const family = action === 'analysis' ? 'analysis' : action;
-    const artifactContext = resolveArtifactContext(taskRef, family, {
+    const artifactContext = resolveArtifactContextForResolvedTask(resolved, family, {
         repoRoot: resolved.repoRoot
     });
     if (artifactContext.status !== 'ready' || !artifactContext.selection) {
@@ -700,6 +689,12 @@ function routeOrchestration(taskRef, options = {}) {
     };
     return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
 }
+function routeOrchestration(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    return routeResolvedTask(taskRef, resolved, options);
+}
 function statusOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -743,7 +738,7 @@ function validateDelegationRun(taskRef, taskId, run, options) {
     }
     return null;
 }
-function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
+function prepareOrchestrationDelegation(taskRef, input, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
@@ -763,7 +758,7 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     if (runFailure)
         return runFailure;
     const activeRun = run;
-    const routed = routeOrchestration(taskRef, options);
+    const routed = routeResolvedTask(taskRef, resolved, options);
     if (!routed.next)
         return routed;
     const next = routed.next;
@@ -797,20 +792,7 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next, error: null };
 }
-function prepareOrchestrationDelegation(taskRef, input, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failed(resolved.code, resolved.message, resolved.taskId);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.prepare.task', () => prepareOrchestrationDelegationUnlocked(taskRef, input, options));
-    }
-    catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            return failed(error.code, error.message, resolved.taskId);
-        throw error;
-    }
-}
-function dispatchOrchestrationDelegationUnlocked(taskRef, options = {}) {
+function dispatchOrchestrationDelegation(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
@@ -830,19 +812,6 @@ function dispatchOrchestrationDelegationUnlocked(taskRef, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
-function dispatchOrchestrationDelegation(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failed(resolved.code, resolved.message, resolved.taskId);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.dispatch.task', () => dispatchOrchestrationDelegationUnlocked(taskRef, options));
-    }
-    catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            return failed(error.code, error.message, resolved.taskId);
-        throw error;
-    }
-}
 function matchingDelegations(predicate, options) {
     const taskId = options.taskId;
     if (taskId === undefined || taskId === '') {
@@ -852,7 +821,7 @@ function matchingDelegations(predicate, options) {
         return { ok: false, error: failed('ORCHESTRATION_TASK_ID_INVALID', 'taskId must be a canonical TASK-id') };
     }
     const repoRoot = options.repoRoot ?? process.cwd();
-    const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const taskDir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId);
     const run = readRun(taskDir, options);
     const matches = run && run.status === 'running' && run.pendingDelegation && predicate(run.pendingDelegation)
         ? [{ taskId, run }]
@@ -1033,7 +1002,7 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
     try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.recover-prepared', () => {
+        return (() => {
             const run = readRun(resolved.taskDir, options);
             const receipt = run?.pendingDelegation;
             if (!run || !receipt) {
@@ -1073,11 +1042,9 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
             }, options.now);
             saveRun(resolved.taskDir, updated);
             return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
-        });
+        })();
     }
     catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            return failed(error.code, error.message, resolved.taskId);
         return failed('ORCHESTRATION_PREPARED_RECOVERY_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
 }
@@ -1088,7 +1055,7 @@ function recoveryReceiptMatches(receipt, event) {
         && receipt.childId === event.childId
         && normalizeAgentToken(event.startedAgent) === normalizeAgentToken(receipt.client);
 }
-function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, options = {}) {
+function recoverActivatedOrchestrationDelegation(taskRef, event, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
@@ -1204,7 +1171,7 @@ function sealOrchestrationDelegation(taskRef, event, expected, options = {}, bef
     const resolved = resolveTaskRef(taskRef, { repoRoot: orchestrationOptions.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
-    return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.seal', () => {
+    return (() => {
         const run = readRun(resolved.taskDir, orchestrationOptions);
         if (!run?.pendingDelegation)
             return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
@@ -1226,7 +1193,7 @@ function sealOrchestrationDelegation(taskRef, event, expected, options = {}, bef
         const updated = withUpdatedRun(current, { pendingDelegation: result.receipt });
         saveRun(resolved.taskDir, updated);
         return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
-    });
+    })();
 }
 function advanceOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
@@ -1262,5 +1229,5 @@ function pauseOrchestration(taskRef, code, message, recoverable, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'paused', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
-export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, awaitOrchestrationDelegationActivation, advanceOrchestration, beginOrResumeOrchestration, commitOrchestrationStageCompletion, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, orchestrationPath, readDelegationAdapterEvidence, mutateDelegationAdapterEvidence, mutateDelegationAdapterEvidenceWithinTaskLock, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverPreparedOrchestrationDelegation, recoverActivatedOrchestrationDelegationUnderLock, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration, };
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, awaitOrchestrationDelegationActivation, advanceOrchestration, beginOrResumeOrchestration, commitOrchestrationStageCompletion, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, orchestrationPath, readDelegationAdapterEvidence, mutateDelegationAdapterEvidence, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverPreparedOrchestrationDelegation, recoverActivatedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration, };
 //# sourceMappingURL=orchestration.js.map

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

@@ -2,13 +2,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
-import { inspectPlatformCommentOperation, normalizeCommentContent, syncPlatformComment } from '../platform/issue-comments.js';
+import { inspectPlatformCommentOperation, syncPlatformComment } from '../platform/issue-comments.js';
+import { parseDeliverySummaryContent, renderDeliverySummaryContent, parseCancelSummaryContent, renderCancelSummaryContent } from '../platform/issue-summary-content.js';
+import { enumerateArtifacts } from './artifacts.js';
 import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { resolvePlatformProviderContext } from '../platform/context.js';
 import { providerOperationContext, providerError, unsupportedProviderOperation } from '../platform/provider-bridge.js';
 import { inLabelMappingDigest } from '../platform/in-label-sync.js';
-import { bindPlatformPullRequest, inspectPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
-import { syncPullRequestSummary } from '../platform/pr-summary.js';
+import { bindPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
+import { replayPullRequestSummary } from '../platform/pr-summary.js';
 import { publishPrReview, readReviewBodyFile } from '../platform/pr-review.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { taskIssueIdentity } from '../platform/task-identities.js';
@@ -35,32 +37,70 @@ function summaryPayload(taskDir, taskId) {
     if (!fs.existsSync(file))
         return null;
     const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-    const canonical = typeof data.body === 'string' ? canonicalizeSummaryBody(data.body) : null;
-    if (data.taskId !== taskId || typeof data.body !== 'string' || typeof data.sha256 !== 'string'
-        || !canonical?.ok || canonical.value !== data.body
-        || createHash('sha256').update(data.body).digest('hex') !== data.sha256) {
+    let content;
+    try {
+        content = parseDeliverySummaryContent(data.content);
+    }
+    catch {
+        content = null;
+    }
+    if (data.taskId !== taskId || !content || content.taskId !== taskId || typeof data.contentSha256 !== 'string'
+        || createHash('sha256').update(JSON.stringify(content)).digest('hex') !== data.contentSha256) {
         throw Object.assign(new Error('delivery summary staging record is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
     }
-    return { body: data.body, sha256: data.sha256 };
+    const canonical = canonicalizeSummaryBody(renderDeliverySummaryContent(content));
+    if (!canonical?.ok)
+        throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
+    return { body: canonical.value, sha256: createHash('sha256').update(canonical.value).digest('hex') };
+}
+function cancellationPayload(taskDir, taskId) {
+    const taskPath = path.join(taskDir, 'task.md');
+    if (!fs.existsSync(taskPath))
+        return null;
+    const taskContent = fs.readFileSync(taskPath, 'utf8');
+    const frontmatter = parseTaskFrontmatter(taskContent);
+    const title = /^#\s+(.+)$/mu.exec(taskContent)?.[1]?.trim() || taskId;
+    const artifacts = enumerateArtifacts(taskDir).filter((artifact) => artifact.name !== 'task.md').map((artifact) => artifact.name);
+    const content = parseCancelSummaryContent({
+        taskId,
+        title,
+        outcome: 'cancelled',
+        reason: frontmatter.cancel_reason,
+        cancelledAt: frontmatter.cancelled_at,
+        lastCompletedArtifact: artifacts.at(-1) ?? null
+    });
+    return renderCancelSummaryContent(content);
 }
 async function replayComment(taskId, taskDir, operation, agent, cwd, client) {
     if (operation.kind === 'task-comment') {
-        return syncPlatformComment(taskId, { kind: 'task', agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+        return syncPlatformComment(taskId, { kind: 'task', agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
     }
     if (operation.kind === 'artifact-comment') {
-        return syncPlatformComment(taskId, { kind: 'artifact', artifact: operation.target, agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+        return syncPlatformComment(taskId, { kind: 'artifact', artifact: operation.target, agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
     }
     if (operation.kind === 'summary-comment') {
-        const summary = summaryPayload(taskDir, taskId);
+        let summary;
+        try {
+            summary = summaryPayload(taskDir, taskId);
+        }
+        catch (error) {
+            return platformResult('failed', { error: { code: 'SUMMARY_STAGING_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } });
+        }
         if (!summary)
-            return platformResult('failed', { error: { code: 'SUMMARY_STAGING_MISSING', message: 'delivery summary staging record is unavailable', retryable: false } });
-        return syncPlatformComment(taskId, {
-            kind: 'summary', body: summary.body, agent, cwd,
-            summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency, client, skipQueue: true
-        });
+            return platformResult('blocked', { error: { code: 'SUMMARY_STAGING_MISSING', message: 'delivery summary staging record is unavailable', retryable: true } });
+        return syncPlatformComment(taskId, { kind: 'summary', body: summary.body, agent, cwd, client, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency, queuedOperation: operation });
     }
     if (operation.kind === 'cancel-comment') {
-        return syncPlatformComment(taskId, { kind: 'cancel', agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+        let body;
+        try {
+            body = cancellationPayload(taskDir, taskId);
+        }
+        catch (error) {
+            return platformResult('failed', { error: { code: 'CANCEL_SUMMARY_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } });
+        }
+        if (!body)
+            return platformResult('blocked', { error: { code: 'CANCEL_SUMMARY_INVALID', message: 'Cancellation facts are unavailable for recovery', retryable: true } });
+        return syncPlatformComment(taskId, { kind: 'cancel', body, agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
     }
     return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_UNSUPPORTED', message: `operation kind '${operation.kind}' has no registered recovery handler`, retryable: false } });
 }
@@ -185,65 +225,6 @@ async function verifyIssueCreate(taskId, operation, cwd, client) {
             } });
     return platformResult('no-op');
 }
-async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
-    let identity;
-    try {
-        identity = parseResourceIdentity(JSON.parse(operation.target), 'queued pull-request summary identity');
-    }
-    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;
-    const listed = resolved.value.provider.comments?.list
-        ? await resolved.value.provider.comments.list({ context: providerOperationContext(resolved.value), parent: identity })
-        : unsupportedProviderOperation(resolved.value.provider, 'comments.list');
-    if (!listed.ok)
-        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 (!summary.manualValidation && summaries.length === 1 && createHash('sha256').update(normalizeCommentContent(summaries[0].body)).digest('hex') === operation.expectedDigest) {
-        return platformResult('no-op');
-    }
-    const bound = await inspectPlatformPullRequest(taskId, { cwd, client });
-    if (!bound.pullRequest || !resourceIdentityEquals(bound.pullRequest.identity, identity))
-        return platformResult('blocked', { error: bound.error ?? {
-                code: 'PLATFORM_OPERATION_IDENTITY_MISMATCH', message: 'Bound pull request differs from the queued summary target', retryable: false
-            } });
-    const replayed = await syncPullRequestSummary(taskId, {
-        agent,
-        cwd,
-        client,
-        body: summary.body,
-        changeReportFile: summary.changeReportFile,
-        ...(summary.manualValidation ? { manualValidation: summary.manualValidation } : {}),
-        primaryResult: 'no_op',
-        strict: true,
-        skipQueue: true,
-        lockAlreadyHeld: true
-    });
-    if ((replayed.status === 'applied' || replayed.status === 'no-op') && !replayed.error && replayed.warnings.length === 0) {
-        return platformResult(replayed.status, { changed: replayed.changed });
-    }
-    return platformResult('blocked', { error: replayed.error ?? {
-            code: 'PR_SUMMARY_RECOVERY_UNCONFIRMED', message: 'Pull-request summary replay did not confirm the requested remote state', retryable: true
-        } });
-}
 async function replayPullRequestReview(operation, agent, cwd, client) {
     const intent = operation.pullRequestReview;
     if (!intent)
@@ -302,6 +283,14 @@ async function replayPullRequest(taskId, operation, agent, cwd) {
     }
     return recoverCreatedPullRequest(taskId, { agent, cwd, base: intent.baseRef || '', head: intent.headRef || '', skipQueue: true });
 }
+function isRecoveryEligible(operation, excludeId) {
+    if (operation.id === excludeId)
+        return false;
+    if (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown')
+        return true;
+    return operation.state === 'failed'
+        && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED';
+}
 async function recoverPlatformOperationsOnce(taskRef, selection, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
@@ -314,9 +303,7 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
         const value = error;
         return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
     }
-    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')));
+    const candidates = journal.operations.filter((operation) => isRecoveryEligible(operation, options.excludeId));
     if (!candidates.length)
         return result('no-op', [], []);
     const head = candidates[0];
@@ -383,9 +370,22 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
                 : operation.kind === 'artifact-comment'
                     ? { kind: 'artifact', artifact: operation.target, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency }
                     : operation.kind === 'summary-comment' ? (() => {
-                        const summary = summaryPayload(resolved.taskDir, resolved.taskId);
-                        return summary ? { kind: 'summary', body: summary.body, agent: options.agent, cwd: resolved.repoRoot, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency } : null;
-                    })() : { kind: 'cancel', agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency };
+                        try {
+                            const summary = summaryPayload(resolved.taskDir, resolved.taskId);
+                            return summary ? { kind: 'summary', body: summary.body, agent: options.agent, cwd: resolved.repoRoot, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency } : null;
+                        }
+                        catch {
+                            return null;
+                        }
+                    })() : (() => {
+                        try {
+                            const body = cancellationPayload(resolved.taskDir, resolved.taskId);
+                            return body ? { kind: 'cancel', body, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency } : null;
+                        }
+                        catch {
+                            return null;
+                        }
+                    })();
             const current = commentOptions ? inspectPlatformCommentOperation(resolved.taskId, commentOptions) : null;
             if (!current) {
                 pending.push(operation.id);
@@ -408,20 +408,21 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
             remote = operation.kind === 'issue-create'
                 ? await verifyIssueCreate(resolved.taskId, operation, resolved.repoRoot)
                 : operation.kind === 'pull-request-summary'
-                    ? await replayPullRequestSummary(resolved.taskId, operation, options.agent, resolved.repoRoot, options.client)
+                    ? await replayPullRequestSummary(resolved.taskId, targetOperation, { agent: options.agent, cwd: resolved.repoRoot, client: options.client })
                     : operation.kind === 'pull-request-review'
                         ? await replayPullRequestReview(operation, options.agent, resolved.repoRoot, options.client)
                         : operation.kind === 'issue-metadata'
                             ? await replayIssueMetadata(resolved.taskId, targetOperation, options.agent, resolved.repoRoot)
                             : operation.kind === 'pull-request'
                                 ? await replayPullRequest(resolved.taskId, targetOperation, options.agent, resolved.repoRoot)
-                                : await replayComment(resolved.taskId, resolved.taskDir, operation, options.agent, resolved.repoRoot);
+                                : await replayComment(resolved.taskId, resolved.taskDir, targetOperation, options.agent, resolved.repoRoot, options.client);
         }
         catch (error) {
             const value = error;
             remote = platformResult('blocked', { error: { code: value.code || 'PLATFORM_OPERATION_RECOVERY_FAILED', message: value.message || String(error), retryable: true } });
         }
         const succeeded = (remote.status === 'applied' || remote.status === 'no-op') && !remote.error;
+        const latestOperation = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.find((item) => item.id === operation.id);
         try {
             recordPlatformOperation({
                 taskRef: resolved.taskId,
@@ -436,7 +437,7 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
                 ...(operation.pullRequestReview ? { pullRequestReview: operation.pullRequestReview } : {}),
                 dependency: operation.dependency,
                 state: succeeded ? 'succeeded' : 'unknown',
-                lastCode: remote.error?.code ?? null
+                lastCode: remote.error?.code ?? latestOperation?.lastCode ?? null
             });
         }
         catch (error) {
@@ -465,9 +466,7 @@ async function recoverPlatformOperations(taskRef, selection, options) {
         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 eligible = (operation) => isRecoveryEligible(operation, options.excludeId);
     const first = initial.operations.filter(eligible);
     if (!first.length)
         return result('no-op', [], []);

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

@@ -3,10 +3,12 @@ import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { normalizeShortIdInput, resolveShortIdReadOnly } from './short-id.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 // Flat-structured workspace dirs that hold tasks under `{dir}/{taskId}/task.md`.
 // Note: `archive` uses a three-level YYYY/MM/DD layout and is handled separately.
 const FLAT_WORKSPACE_DIRS = ['active', 'blocked', 'completed'];
+function taskRoot(repoRoot) { return resolveProjectTaskWorkspaceRoot(repoRoot); }
 function detectRepoRoot() {
     try {
         return execFileSync('git', ['rev-parse', '--show-toplevel'], {
@@ -40,12 +42,12 @@ function listSortedNumeric(dir, width) {
         .sort()
         .reverse();
 }
-function findInArchive(repoRoot, taskId) {
-    // archive-tasks stores local material at .agents/workspace/archive/YYYY/MM/DD/{taskId}/local/task.md
+function findInArchive(workspaceRoot, taskId) {
+    // archive-tasks stores local material at the project task workspace archive/YYYY/MM/DD/{taskId}/local/task.md
     // where YYYY/MM/DD comes from completed_at (or updated_at fallback) — NOT from
     // the task id's creation date. So we cannot derive the path from taskId alone;
     // walk the bounded YYYY/MM/DD tree instead. Newest-first to favor recent archives.
-    const archiveDir = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    const archiveDir = path.join(workspaceRoot, 'archive');
     for (const year of listSortedNumeric(archiveDir, 4)) {
         const yearDir = path.join(archiveDir, year);
         for (const month of listSortedNumeric(yearDir, 2)) {
@@ -59,13 +61,13 @@ function findInArchive(repoRoot, taskId) {
     }
     return null;
 }
-function findTaskMd(repoRoot, taskId) {
+function findTaskMd(workspaceRoot, taskId) {
     for (const sub of FLAT_WORKSPACE_DIRS) {
-        const candidate = path.join(repoRoot, '.agents', 'workspace', sub, taskId, 'task.md');
+        const candidate = path.join(workspaceRoot, sub, taskId, 'task.md');
         if (fs.existsSync(candidate))
             return { taskMdPath: candidate, state: sub };
     }
-    const archived = findInArchive(repoRoot, taskId);
+    const archived = findInArchive(workspaceRoot, taskId);
     return archived ? { taskMdPath: archived, state: 'archive' } : null;
 }
 /**
@@ -76,8 +78,9 @@ function findTaskMd(repoRoot, taskId) {
  */
 function enumerateTaskDirs(repoRoot) {
     const out = [];
+    const workspaceRoot = taskRoot(repoRoot);
     for (const sub of FLAT_WORKSPACE_DIRS) {
-        const base = path.join(repoRoot, '.agents', 'workspace', sub);
+        const base = path.join(workspaceRoot, sub);
         if (!fs.existsSync(base))
             continue;
         for (const entry of fs.readdirSync(base).sort()) {
@@ -98,6 +101,7 @@ function enumerateTaskDirs(repoRoot) {
  */
 function enumerateAllTaskDirs(repoRoot) {
     const out = [];
+    const workspaceRoot = taskRoot(repoRoot);
     const seen = new Map();
     const add = (taskId, taskDir, state) => {
         if (!TASK_ID_RE.test(taskId))
@@ -116,13 +120,13 @@ function enumerateAllTaskDirs(repoRoot) {
         out.push({ taskId, taskDir, state });
     };
     for (const state of FLAT_WORKSPACE_DIRS) {
-        const base = path.join(repoRoot, '.agents', 'workspace', state);
+        const base = path.join(workspaceRoot, state);
         if (!fs.existsSync(base))
             continue;
         for (const taskId of fs.readdirSync(base).sort())
             add(taskId, path.join(base, taskId), state);
     }
-    const archive = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    const archive = path.join(workspaceRoot, 'archive');
     for (const year of listSortedNumeric(archive, 4).reverse()) {
         const yearDir = path.join(archive, year);
         for (const month of listSortedNumeric(yearDir, 2).reverse()) {
@@ -137,8 +141,9 @@ function enumerateAllTaskDirs(repoRoot) {
     return out;
 }
 function locateHotTaskDirs(repoRoot, taskId) {
+    const workspaceRoot = taskRoot(repoRoot);
     return FLAT_WORKSPACE_DIRS.flatMap((state) => {
-        const taskDir = path.join(repoRoot, '.agents', 'workspace', state, taskId);
+        const taskDir = path.join(workspaceRoot, state, taskId);
         const taskMdPath = path.join(taskDir, 'task.md');
         return fs.existsSync(taskMdPath) ? [{ taskId, taskDir, taskMdPath, state }] : [];
     });
@@ -203,7 +208,7 @@ function resolveTaskRef(arg, options = {}) {
         }
         taskId = shortResult.taskId;
     }
-    const located = findTaskMd(repoRoot, taskId);
+    const located = findTaskMd(taskRoot(repoRoot), taskId);
     if (!located) {
         return {
             ok: false,
@@ -255,7 +260,7 @@ function resolveTaskContext(taskRef, options = {}) {
             taskId: null
         };
     }
-    const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+    const activeDir = path.join(taskRoot(repoRoot), 'active');
     const matches = [];
     if (fs.existsSync(activeDir)) {
         for (const entry of fs.readdirSync(activeDir).sort()) {