@fitlab-ai/agent-infra 0.11.14 → 0.12.0

package/lib/task/orchestration.ts

@@ -9,6 +9,7 @@ import { parseReviewSummary } from './review-artifacts.ts';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
 import type { LedgerDocument } from './ledger.ts';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 import {
   activateDelegation,
   abortActivatedDelegation,
@@ -48,14 +49,13 @@ import {
 import type { RepositorySnapshot } from './workspace-snapshot.ts';
 import type { WorkspaceSnapshotContext } from './workspace-snapshot.ts';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.ts';
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.ts';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.ts';
 import { hasOpenLifecycleExecution } from './activity-log.ts';
 import type { LifecycleAction, LifecycleFacts } from './capabilities.ts';
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
-import { resolveArtifactContext } from './artifact-lifecycle.ts';
+import { resolveArtifactContextForResolvedTask } from './artifact-lifecycle.ts';
 
 type OrchestrationStatus = 'running' | 'paused' | 'completed';
 type ModelPolicySource = Readonly<{
@@ -441,19 +441,7 @@ function mutateDelegationAdapterEvidence(
 ): unknown {
   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);
-}
-
-function mutateDelegationAdapterEvidenceWithinTaskLock(
-  taskRef: string,
-  receiptId: string,
-  adapterId: AgentClientId,
-  mutate: (current: unknown) => unknown,
-  options: OrchestrationOptions = {}
-): unknown {
-  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);
+  return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options);
 }
 
 function mutateDelegationAdapterEvidenceAtResolved(
@@ -461,8 +449,7 @@ function mutateDelegationAdapterEvidenceAtResolved(
   receiptId: string,
   adapterId: AgentClientId,
   mutate: (current: unknown) => unknown,
-  options: OrchestrationOptions,
-  taskLockHeld: boolean
+  options: OrchestrationOptions
 ): unknown {
   const update = () => {
     try {
@@ -494,9 +481,7 @@ function mutateDelegationAdapterEvidenceAtResolved(
     }
   };
   let mutationError: unknown;
-  const result = taskLockHeld
-    ? update()
-    : withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `agent-adapter.${adapterId}.evidence`, update);
+  const result = update();
   if (mutationError) throw mutationError;
   return result;
 }
@@ -733,9 +718,13 @@ function routeFromFacts(facts: LifecycleFacts): Omit<OrchestrationNext, 'request
   return { action: command, role, stage: action };
 }
 
-function routeOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
-  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-  if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
+type ResolvedTaskRef = Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>;
+
+function routeResolvedTask(
+  taskRef: string,
+  resolved: ResolvedTaskRef,
+  options: OrchestrationOptions
+): OrchestrationResult {
   let gitRoot: string;
   try {
     gitRoot = gitRootFor(resolved.repoRoot, options);
@@ -772,7 +761,8 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
     resolved.taskDir,
     content,
     resolved.state,
-    hasOpenLifecycleExecution(content) || Boolean(run?.pendingDelegation)
+    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);
@@ -864,7 +854,7 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
   }
   const action = routed.stage as LifecycleAction;
   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) {
@@ -898,6 +888,12 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
   return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
 }
 
+function routeOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
+  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: string, options: OrchestrationOptions = {}): OrchestrationResult {
   const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
@@ -952,7 +948,7 @@ function validateDelegationRun(
   return null;
 }
 
-function prepareOrchestrationDelegationUnlocked(
+function prepareOrchestrationDelegation(
   taskRef: string,
   input: Readonly<{
     client: AgentClientId;
@@ -978,7 +974,7 @@ function prepareOrchestrationDelegationUnlocked(
   const runFailure = validateDelegationRun(taskRef, resolved.taskId, run, 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;
   const policyFailure = validatePreparedModelPolicy(resolved.taskId, activeRun, next, input);
@@ -1010,31 +1006,7 @@ function prepareOrchestrationDelegationUnlocked(
   return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next, error: null };
 }
 
-function prepareOrchestrationDelegation(
-  taskRef: string,
-  input: Readonly<{
-    client: AgentClientId;
-    requestedModel?: string;
-    requestedReasoningEffort?: string;
-  }>,
-  options: OrchestrationOptions = {}
-): OrchestrationResult {
-  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(
+function dispatchOrchestrationDelegation(
   taskRef: string,
   options: OrchestrationOptions = {}
 ): OrchestrationResult {
@@ -1055,25 +1027,6 @@ function dispatchOrchestrationDelegationUnlocked(
   return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
 
-function dispatchOrchestrationDelegation(
-  taskRef: string,
-  options: OrchestrationOptions = {}
-): OrchestrationResult {
-  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;
-  }
-}
-
 type MatchingDelegationsResult =
   | Readonly<{ ok: true; matches: readonly { taskId: string; run: OrchestrationRun }[] }>
   | Readonly<{ ok: false; error: OrchestrationResult }>;
@@ -1090,7 +1043,7 @@ function matchingDelegations(
     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 }]
@@ -1385,7 +1338,7 @@ function recoverPreparedOrchestrationDelegation(
   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.recover-prepared', () => {
+    return (() => {
       const run = readRun(resolved.taskDir, options);
       const receipt = run?.pendingDelegation;
       if (!run || !receipt) {
@@ -1430,9 +1383,8 @@ function recoverPreparedOrchestrationDelegation(
       }, 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),
@@ -1462,7 +1414,7 @@ function recoveryReceiptMatches(
     && normalizeAgentToken(event.startedAgent) === normalizeAgentToken(receipt.client);
 }
 
-function recoverActivatedOrchestrationDelegationUnderLock(
+function recoverActivatedOrchestrationDelegation(
   taskRef: string,
   event: ActivatedRecoveryEvent,
   options: OrchestrationOptions = {}
@@ -1598,7 +1550,7 @@ function sealOrchestrationDelegation(
   const orchestrationOptions = options;
   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);
     if (expected && (run.runId !== expected.runId || run.pendingDelegation.id !== expected.receiptId)) {
@@ -1616,7 +1568,7 @@ function sealOrchestrationDelegation(
     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: string, options: OrchestrationOptions = {}): OrchestrationResult {
@@ -1672,7 +1624,6 @@ export {
   orchestrationPath,
   readDelegationAdapterEvidence,
   mutateDelegationAdapterEvidence,
-  mutateDelegationAdapterEvidenceWithinTaskLock,
   pauseMatchingOrchestrationDelegation,
   pauseOrchestration,
   planOrchestrationStageCompletion,
@@ -1680,7 +1631,7 @@ export {
   readRun,
   reconcileMatchingOrchestrationDelegation,
   recoverPreparedOrchestrationDelegation,
-  recoverActivatedOrchestrationDelegationUnderLock,
+  recoverActivatedOrchestrationDelegation,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
   sealOrchestrationDelegation,

package/lib/task/platform-operation-recovery.ts

@@ -222,8 +222,7 @@ async function replayPullRequestSummary(taskId: string, operation: ReturnType<ty
     ...(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/lib/task/resolve-ref.ts

@@ -3,12 +3,15 @@ import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { normalizeShortIdInput, resolveShortIdReadOnly } from './short-id.ts';
 import { parseTaskFrontmatter } from './frontmatter.ts';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 
 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'] as const;
 
+function taskRoot(repoRoot: string): string { return resolveProjectTaskWorkspaceRoot(repoRoot); }
+
 type ResolveRefResult =
   | {
       ok: true;
@@ -80,12 +83,12 @@ function listSortedNumeric(dir: string, width: number): string[] {
     .reverse();
 }
 
-function findInArchive(repoRoot: string, taskId: string): string | null {
-  // archive-tasks stores local material at .agents/workspace/archive/YYYY/MM/DD/{taskId}/local/task.md
+function findInArchive(workspaceRoot: string, taskId: string): string | null {
+  // 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)) {
@@ -100,14 +103,14 @@ function findInArchive(repoRoot: string, taskId: string): string | null {
 }
 
 function findTaskMd(
-  repoRoot: string,
+  workspaceRoot: string,
   taskId: string
 ): { taskMdPath: string; state: TaskWorkspaceState } | null {
   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;
 }
 
@@ -119,8 +122,9 @@ function findTaskMd(
  */
 function enumerateTaskDirs(repoRoot: string): { taskId: string; taskDir: string }[] {
   const out: { taskId: string; taskDir: string }[] = [];
+  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()) {
       if (!TASK_ID_RE.test(entry)) continue;
@@ -139,6 +143,7 @@ function enumerateTaskDirs(repoRoot: string): { taskId: string; taskDir: string
  */
 function enumerateAllTaskDirs(repoRoot: string): { taskId: string; taskDir: string; state: TaskWorkspaceState }[] {
   const out: { taskId: string; taskDir: string; state: TaskWorkspaceState }[] = [];
+  const workspaceRoot = taskRoot(repoRoot);
   const seen = new Map<string, string>();
   const add = (taskId: string, taskDir: string, state: TaskWorkspaceState) => {
     if (!TASK_ID_RE.test(taskId)) return;
@@ -155,12 +160,12 @@ function enumerateAllTaskDirs(repoRoot: string): { taskId: string; taskDir: stri
   };
 
   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()) {
@@ -178,8 +183,9 @@ function locateHotTaskDirs(
   repoRoot: string,
   taskId: string
 ): { taskId: string; taskDir: string; taskMdPath: string; state: Exclude<TaskWorkspaceState, 'archive'> }[] {
+  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 }] : [];
   });
@@ -244,7 +250,7 @@ function resolveTaskRef(arg: string, options: ResolveTaskRefOptions = {}): Resol
     }
     taskId = shortResult.taskId;
   }
-  const located = findTaskMd(repoRoot, taskId);
+  const located = findTaskMd(taskRoot(repoRoot), taskId);
   if (!located) {
     return {
       ok: false,
@@ -300,7 +306,7 @@ function resolveTaskContext(
     };
   }
 
-  const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+  const activeDir = path.join(taskRoot(repoRoot), 'active');
   const matches: { taskId: string; taskDir: string; taskMdPath: string }[] = [];
   if (fs.existsSync(activeDir)) {
     for (const entry of fs.readdirSync(activeDir).sort()) {

package/lib/task/review-finalization.ts

@@ -10,7 +10,6 @@ import { finalizeReviewSummaryContent } from './review-artifacts.ts';
 import { inspectDecisionDetailDuplicates } from './decision-details.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { validateLifecycleExecution } from './lifecycle-execution.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import type { ResolveTaskRefErrorCode } from './resolve-ref.ts';
 import { getArtifactSchema } from './artifact-schema.ts';
 import { validateQualificationAudit } from './qualification-audit.ts';
@@ -69,7 +68,6 @@ type ReviewFileSystem = {
 type ReviewFinalizationOptions = {
   repoRoot?: string;
   fileSystem?: Partial<ReviewFileSystem>;
-  lockAlreadyHeld?: boolean;
 };
 
 const STAGES: Record<ReviewStage, { family: 'review-analysis' | 'review-plan' | 'review-code' }> = {
@@ -123,7 +121,7 @@ function preflightFailed(
 }
 
 /** Validate the current review draft before any finding-ledger write. */
-function preflightReviewSummaryUnlocked(
+function preflightReviewSummary(
   request: ReviewFinalizationRequest,
   options: ReviewFinalizationOptions = {}
 ): ReviewPreflightResult {
@@ -178,30 +176,9 @@ function preflightReviewSummaryUnlocked(
   };
 }
 
-function preflightReviewSummary(
-  request: ReviewFinalizationRequest,
-  options: ReviewFinalizationOptions = {}
-): ReviewPreflightResult {
-  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);
-  }
-}
-
 type ReviewSummaryCandidatePreparation = Readonly<{
   result: ReviewFinalizationResult;
   content: string;
-  lockAlreadyHeld?: boolean;
 }>;
 
 /** Prepare domain validation, summary bytes and provenance before any publication. */
@@ -279,7 +256,6 @@ function prepareReviewSummaryCandidate(
       operations: transformed.changed ? [{ kind: 'artifact', artifact: request.artifact, operation: 'update' }] : [],
       error: null
     },
-    lockAlreadyHeld: options.lockAlreadyHeld
   };
 }
 
@@ -303,7 +279,7 @@ function replaceCurrentArtifactAtomically(file: string, content: string): void {
   }
 }
 
-function finalizeReviewSummaryUnlocked(
+function finalizeReviewSummary(
   request: ReviewFinalizationRequest,
   options: ReviewFinalizationOptions = {}
 ): ReviewFinalizationResult {
@@ -340,32 +316,6 @@ function finalizeReviewSummaryUnlocked(
   }
 }
 
-function finalizeReviewSummary(
-  request: ReviewFinalizationRequest,
-  options: ReviewFinalizationOptions = {}
-): ReviewFinalizationResult {
-  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 };
 export type {
   ReviewFinalizationError,

package/lib/task/review-identity.ts

@@ -45,7 +45,9 @@ export function inspectReviewIdentity(taskDir: string, reportContent: string, re
   }
   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) return result('indeterminate', `Task branch '${branch}' is not checked out in a registered worktree`, reviewedHead);

package/lib/task/short-id.ts

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 
 const REGISTRY_NAME = '.short-ids.json';
 const LOCK_NAME = '.short-ids.json.lock';
@@ -85,7 +86,7 @@ function resolveShortIdReadOnly(
   }
 
   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',
@@ -164,8 +165,9 @@ function resolveShortIdReadOnly(
       : `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'));
@@ -300,7 +302,7 @@ function mutateShortIdRegistry(
   taskId: string,
   requested: ShortIdMutationEffect
 ): ShortIdMutationResult {
-  const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+  const activeDir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active');
   return mutateShortIdRegistryAt(activeDir, configuredShortIdLength(repoRoot), taskId, requested);
 }
 
@@ -369,7 +371,7 @@ function mutateShortIdRegistryAt(
 }
 
 function releaseStaleShortIdRegistry(repoRoot: string, taskId: string): ShortIdMutationResult {
-  const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+  const activeDir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active');
   return mutateShortIdRegistryAt(
     activeDir,
     configuredShortIdLength(repoRoot),
@@ -433,7 +435,7 @@ function executeShortIdCommand(request: ShortIdCommandRequest): ShortIdCommandRe
 }
 
 function readRegistry(repoRoot: string): RegistrySchema | null {
-  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 {
     const raw = fs.readFileSync(registryPath, 'utf8');
@@ -446,7 +448,7 @@ function readRegistry(repoRoot: string): RegistrySchema | null {
 }
 
 function readBranchFromTaskMd(repoRoot: string, taskId: string): string | null {
-  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');
   const m = content.match(/^branch:\s*(.+)$/m);
@@ -464,8 +466,11 @@ function loadShortIdByTaskId(repoRoot: string): Map<string, string> {
   return map;
 }
 
-function inspectShortIdRegistry(repoRoot: string): ShortIdRegistryInspection {
-  const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', REGISTRY_NAME);
+function inspectShortIdRegistry(
+  repoRoot: string,
+  shortIdLength = configuredShortIdLength(repoRoot)
+): ShortIdRegistryInspection {
+  const registryPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', REGISTRY_NAME);
   if (!fs.existsSync(registryPath)) {
     return {
       status: 'missing',
@@ -503,7 +508,7 @@ function inspectShortIdRegistry(repoRoot: string): ShortIdRegistryInspection {
   }
 
   try {
-    const registry = validateRegistry(parsed, registryPath, configuredShortIdLength(repoRoot));
+    const registry = validateRegistry(parsed, registryPath, shortIdLength);
     const shortIds = new Map<string, string>();
     for (const [key, taskId] of Object.entries(registry.ids)) shortIds.set(taskId, key);
     return { status: 'valid', shortIds };