@fitlab-ai/agent-infra 0.11.15 → 0.12.0

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

@@ -234,8 +234,7 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
         ...(summary.manualValidation ? { manualValidation: summary.manualValidation } : {}),
         primaryResult: 'no_op',
         strict: true,
-        skipQueue: true,
-        lockAlreadyHeld: true
+        skipQueue: true
     });
     if ((replayed.status === 'applied' || replayed.status === 'no-op') && !replayed.error && replayed.warnings.length === 0) {
         return platformResult(replayed.status, { changed: replayed.changed });

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()) {

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

@@ -8,7 +8,6 @@ import { finalizeReviewSummaryContent } from './review-artifacts.js';
 import { inspectDecisionDetailDuplicates } from './decision-details.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { validateQualificationAudit } from './qualification-audit.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
@@ -47,7 +46,7 @@ function preflightFailed(request, code, message, taskId = null, extra = {}) {
     };
 }
 /** Validate the current review draft before any finding-ledger write. */
-function preflightReviewSummaryUnlocked(request, options = {}) {
+function preflightReviewSummary(request, options = {}) {
     const stage = request.stage;
     const spec = STAGES[stage];
     if (!spec)
@@ -106,21 +105,6 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
         status: 'passed', changed: false, error: null
     };
 }
-function preflightReviewSummary(request, options = {}) {
-    if (request.dryRun || options.lockAlreadyHeld)
-        return preflightReviewSummaryUnlocked(request, options);
-    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return preflightReviewSummaryUnlocked(request, options);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.preflight', () => preflightReviewSummaryUnlocked(request, { ...options, lockAlreadyHeld: true }));
-    }
-    catch (error) {
-        if (!(error instanceof TaskExecutionLockError))
-            throw error;
-        return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', `${error.code}: ${error.message}`, resolved.taskId);
-    }
-}
 /** Prepare domain validation, summary bytes and provenance before any publication. */
 function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     let taskId = null;
@@ -208,7 +192,6 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
             operations: transformed.changed ? [{ kind: 'artifact', artifact: request.artifact, operation: 'update' }] : [],
             error: null
         },
-        lockAlreadyHeld: options.lockAlreadyHeld
     };
 }
 function commitReviewSummaryProvenance(prepared, repoRoot, options = {}) {
@@ -230,7 +213,7 @@ function replaceCurrentArtifactAtomically(file, content) {
         }
     }
 }
-function finalizeReviewSummaryUnlocked(request, options = {}) {
+function finalizeReviewSummary(request, options = {}) {
     const spec = STAGES[request.stage];
     if (!spec || !request.taskRef || !request.artifact)
         return prepareReviewSummaryCandidate(request, '', options).result;
@@ -267,21 +250,5 @@ function finalizeReviewSummaryUnlocked(request, options = {}) {
         return failed(request, 'REVIEW_RECOVERY_COMMIT_FAILED', `cannot update current review artifact: ${error instanceof Error ? error.message : String(error)}`, resolved.taskId);
     }
 }
-function finalizeReviewSummary(request, options = {}) {
-    const effectiveOptions = options;
-    if (request.dryRun || options.lockAlreadyHeld)
-        return finalizeReviewSummaryUnlocked(request, effectiveOptions);
-    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return finalizeReviewSummaryUnlocked(request, effectiveOptions);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', () => finalizeReviewSummaryUnlocked(request, { ...effectiveOptions, lockAlreadyHeld: true }));
-    }
-    catch (error) {
-        if (!(error instanceof TaskExecutionLockError))
-            throw error;
-        return failed(request, 'REVIEW_PROVENANCE_INVALID', `${error.code}: ${error.message}`, resolved.taskId);
-    }
-}
 export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate, commitReviewSummaryProvenance };
 //# sourceMappingURL=review-finalization.js.map

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

@@ -23,7 +23,9 @@ export function inspectReviewIdentity(taskDir, reportContent, repositoryRoot) {
     }
     try {
         const metadata = parseTypedTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
-        const taskRepositoryRoot = git(taskDir, ['rev-parse', '--show-toplevel']);
+        const taskRepositoryRoot = repositoryRoot
+            ? fs.realpathSync.native(repositoryRoot)
+            : git(taskDir, ['rev-parse', '--show-toplevel']);
         const branch = String(metadata.branch ?? '').trim();
         const gitRoot = branch ? resolveBranchWorktree(taskRepositoryRoot, branch) : taskRepositoryRoot;
         if (!gitRoot)

package/dist/lib/task/short-id.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 const REGISTRY_NAME = '.short-ids.json';
 const LOCK_NAME = '.short-ids.json.lock';
 function normalizeShortIdInput(input, opts) {
@@ -42,7 +43,7 @@ function resolveShortIdReadOnly(input, repoRoot, opts) {
         return shortIdFailure('SHORT_ID_NOT_FOUND', `short id '${input}' not found in active task registry`);
     }
     const key = normalized.value;
-    const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', REGISTRY_NAME);
+    const registryPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', REGISTRY_NAME);
     if (!fs.existsSync(registryPath)) {
         return shortIdFailure('SHORT_ID_REGISTRY_NOT_FOUND', `short id '${key}' not found; active task registry is empty.`);
     }
@@ -95,8 +96,9 @@ function resolveShortIdReadOnly(input, repoRoot, opts) {
             : `short id '${key}' not found in task short-id registry.`;
         return shortIdFailure('SHORT_ID_NOT_FOUND', message);
     }
-    const activeTask = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
-    const completedTask = path.join(repoRoot, '.agents', 'workspace', 'completed', taskId, 'task.md');
+    const workspaceRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
+    const activeTask = path.join(workspaceRoot, 'active', taskId, 'task.md');
+    const completedTask = path.join(workspaceRoot, 'completed', taskId, 'task.md');
     let isValidCompletedTask = false;
     try {
         const task = parseTypedTaskFrontmatter(fs.readFileSync(completedTask, 'utf8'));
@@ -210,7 +212,7 @@ function writeRegistry(registryPath, registry) {
     }
 }
 function mutateShortIdRegistry(repoRoot, taskId, requested) {
-    const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+    const activeDir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active');
     return mutateShortIdRegistryAt(activeDir, configuredShortIdLength(repoRoot), taskId, requested);
 }
 function mutateShortIdRegistryAt(activeDir, width, taskId, requested, onlyReleaseWhenInactive = false, pruneOrphans = true) {
@@ -267,7 +269,7 @@ function mutateShortIdRegistryAt(activeDir, width, taskId, requested, onlyReleas
     });
 }
 function releaseStaleShortIdRegistry(repoRoot, taskId) {
-    const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+    const activeDir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active');
     return mutateShortIdRegistryAt(activeDir, configuredShortIdLength(repoRoot), taskId, 'release', true, false);
 }
 function executeShortIdCommand(request) {
@@ -327,7 +329,7 @@ function executeShortIdCommand(request) {
     }
 }
 function readRegistry(repoRoot) {
-    const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', REGISTRY_NAME);
+    const registryPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', REGISTRY_NAME);
     if (!fs.existsSync(registryPath))
         return null;
     try {
@@ -342,7 +344,7 @@ function readRegistry(repoRoot) {
     }
 }
 function readBranchFromTaskMd(repoRoot, taskId) {
-    const taskMdPath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
+    const taskMdPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId, 'task.md');
     if (!fs.existsSync(taskMdPath))
         return null;
     const content = fs.readFileSync(taskMdPath, 'utf8');
@@ -362,7 +364,7 @@ function loadShortIdByTaskId(repoRoot) {
     return map;
 }
 function inspectShortIdRegistry(repoRoot, shortIdLength = configuredShortIdLength(repoRoot)) {
-    const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', REGISTRY_NAME);
+    const registryPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', REGISTRY_NAME);
     if (!fs.existsSync(registryPath)) {
         return {
             status: 'missing',

package/dist/lib/task/verification-engine.js

@@ -54,9 +54,7 @@ const DEFAULT_REQUIRED_FIELDS = [
     "assigned_to"
 ];
 const DATE_TIME_PATTERN = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[+-]\d{2}:\d{2})?$/;
-// Start markers (action suffixed with ` [started]`) are excluded from the
-// "latest action" / freshness computation so a step's in-flight marker never
-// satisfies a skill's expected_action_pattern; the matching done entry does.
+// Started rows do not represent completed lifecycle actions.
 const ACTIVITY_LOG_STARTED_RE = /\s*\[started\]\s*$/;
 const BRANCH_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 // Review disagreement ledger (see .agents/rules/review-handshake.md).
@@ -322,15 +320,9 @@ function checkTaskMeta({ taskDir, config, repositoryRoot, skillName, artifactFil
     if (expectedStep && metadata.current_step !== expectedStep) {
         let validLifecycleArtifact = false;
         if (currentTask) {
-            const activityConfig = loadVerificationConfig(repositoryRoot, skillName).checks?.["activity-log"];
             const { section, invalidEntries } = inspectActivityLog(task.content);
-            if (activityConfig && section && invalidEntries.length === 0) {
-                let latestAction = "";
-                for (const entry of section.entries) {
-                    if (!ACTIVITY_LOG_STARTED_RE.test(entry.step))
-                        latestAction = entry.step;
-                }
-                validLifecycleArtifact = checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, activityConfig, task, section.entries, latestAction)?.status === "pass";
+            if (section && invalidEntries.length === 0) {
+                validLifecycleArtifact = checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, task, section.entries)?.status === "pass";
             }
         }
         if (!validLifecycleArtifact) {
@@ -634,14 +626,14 @@ function checkImplementationInput({ taskDir, artifactFile }) {
     return passResult("implementation-input", `${actionDecision} matches Activity Log, report, and task table`);
 }
 const ARTIFACT_ACTIVITY_STAGES = {
-    "analyze-task": { family: "analysis", event: "analyze.completed" },
-    "plan-task": { family: "plan", event: "plan.completed" },
-    "review-analysis": { family: "review-analysis", event: "review-analysis.completed" },
-    "review-plan": { family: "review-plan", event: "review-plan.completed" },
-    "code-task": { family: "code", event: "code.completed" },
-    "review-code": { family: "review-code", event: "review-code.completed" }
+    "analyze-task": { family: "analysis", event: "analyze.completed", action: "Analyze Task" },
+    "plan-task": { family: "plan", event: "plan.completed", action: "Plan Task" },
+    "review-analysis": { family: "review-analysis", event: "review-analysis.completed", action: "Review Analysis" },
+    "review-plan": { family: "review-plan", event: "review-plan.completed", action: "Review Plan" },
+    "code-task": { family: "code", event: "code.completed", action: "Code Task" },
+    "review-code": { family: "review-code", event: "review-code.completed", action: "Review Code" }
 };
-function checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, config, task, entries, latestAction) {
+function checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, task, entries) {
     const stage = ARTIFACT_ACTIVITY_STAGES[skillName];
     if (!stage)
         return null;
@@ -680,26 +672,18 @@ function checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, con
             return failResult("activity-log", `Input '${input.name}' changed or is no longer current; rerun ${skillName} to refresh '${output}'`);
         }
     }
-    const expectedAction = new RegExp(config.expected_action_pattern);
+    const roundActionPattern = new RegExp(`^${stage.action} \\(Round ${identity.round}(?:, [^)]+)?\\)$`);
     const roundAction = entries.find((entry) => {
-        if (ACTIVITY_LOG_STARTED_RE.test(entry.step))
-            return false;
-        if (!expectedAction.test(entry.step))
-            return false;
-        expectedAction.lastIndex = 0;
-        const actionRound = /\(Round (\d+)/.exec(entry.step)?.[1];
-        return actionRound === String(identity.round) && entry.note.includes(`→ ${output}`);
+        return !ACTIVITY_LOG_STARTED_RE.test(entry.step)
+            && roundActionPattern.test(entry.step)
+            && entry.note.includes(`→ ${output}`);
     });
     if (!roundAction) {
         return failResult("activity-log", `No completed Activity Log row records '${output}' for ${skillName} Round ${identity.round}`);
     }
-    if (skillName === "plan-task" && /^(?:Human Decision|Decision)\b/.test(latestAction)
-        && expectedAction.test(latestAction)) {
-        return passResult("activity-log", `Plan completion '${output}' is current; latest action '${latestAction}' is a human decision`);
-    }
     return passResult("activity-log", `Current ${stage.family} completion '${output}' is valid for Round ${identity.round}`);
 }
-function checkActivityLog({ taskDir, config, skillName, artifactFile }) {
+function checkActivityLog({ taskDir, skillName, artifactFile }) {
     const task = loadTask(taskDir);
     if (!task.ok) {
         return failResult("activity-log", task.message);
@@ -712,37 +696,14 @@ function checkActivityLog({ taskDir, config, skillName, artifactFile }) {
     const entries = section.entries;
     if (entries.length === 0)
         return failResult("activity-log", "Activity Log has no entries");
-    let latestAction = "";
-    let latestTimestamp = "";
-    const doneActions = [];
     for (const entry of entries) {
         if (!entry.note.trim())
             return failResult("activity-log", "Activity Log entry note is required");
-        const { time: timestamp, step: action } = entry;
-        // A `[started]` marker is not a terminal action: keep latestAction/latestTimestamp
-        // on the most recent done entry so expected_action_pattern sees it.
-        if (!ACTIVITY_LOG_STARTED_RE.test(action)) {
-            latestTimestamp = timestamp;
-            latestAction = action;
-            doneActions.push(action);
-        }
     }
-    const artifactLifecycleResult = checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, config, task, entries, latestAction);
+    const artifactLifecycleResult = checkArtifactLifecycleActivityLog(taskDir, artifactFile, skillName, task, entries);
     if (artifactLifecycleResult)
         return artifactLifecycleResult;
-    if (config.expected_action_pattern && !new RegExp(config.expected_action_pattern).test(latestAction)) {
-        const expected = new RegExp(config.expected_action_pattern);
-        let index = doneActions.length - 1;
-        while (index >= 0 && doneActions[index] === 'Commit' && !expected.test(doneActions[index]))
-            index -= 1;
-        if (index >= 0 && expected.test(doneActions[index])) {
-            latestAction = doneActions[index];
-        }
-    }
-    if (config.expected_action_pattern && !new RegExp(config.expected_action_pattern).test(latestAction)) {
-        return failResult("activity-log", `Latest action '${latestAction}' does not match '${config.expected_action_pattern}'`);
-    }
-    return passResult("activity-log", `Latest entry '${latestAction}' at ${latestTimestamp}`);
+    return passResult("activity-log", "Activity Log is valid");
 }
 function checkCompletionChecklist({ taskDir, config }) {
     const task = loadTask(taskDir);
@@ -932,10 +893,10 @@ async function checkPostReviewCommit({ taskDir, config, repositoryRoot }) {
     }
     let gitRoot;
     try {
-        gitRoot = execFileSync("git", ["-C", taskDir, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+        gitRoot = execFileSync("git", ["-C", repositoryRoot, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
     }
     catch {
-        return blockedResult("post-review-commit", "git unavailable or task directory is not inside a git repository");
+        return blockedResult("post-review-commit", "git unavailable or repository root is not inside a git repository");
     }
     const task = loadTask(taskDir);
     if (!task.ok)