🤖 refactor: the subagent artifact index writes take the workspace FIFO from SessionLocks (#7425)

## Summary

The report, failure, transcript and git patch artifact index writes take
the workspace FIFO from `SessionLocks`. It is PR 14 of phase 4. Lock
keys and order do not change: the Node layer gives today's
`workspaceFileLocks`.

## Order

- PR 13 (#7423), which the plan puts below it, has merged, so the base
is main. PR 18 (the branch-summary marker, landing note 15) stacks on it
in the native stack.
- Phase 5b PR 3 waits for it.

## Implementation

- `subagentFailureArtifacts.ts`, `subagentReportArtifacts.ts`,
`subagentTranscriptArtifacts.ts`, `subagentGitPatchArtifacts.ts`: each
index write takes an optional `locks` (Node default). In
`subagentReportArtifacts.ts`, the helper `workspaceFileLocksOf` holds
the fallback, so the CC of `upsertSubagentReportArtifact` does not grow.
- `workspaceService.ts`: the child-artifact rollup passes
`this.historyService.locks` for the parent's index writes.

Files beyond the plan's list (landing note 14). The plan said that
`taskService.ts`, `gitPatchArtifactService.ts` and
`taskGitPatchEngine.ts` do not change. These changes close the gap of a
production caller that has a service but keeps the Node default:

- `taskService.ts`: the failure and report upserts pass
`this.historyService.locks`, and so does `new
GitPatchArtifactService(config, locks)`.
- `gitPatchArtifactService.ts`: the constructor requires `locks`, so the
type checker proves that no caller is left. Its 4 upserts pass them.
`gitPatchArtifactService.test.ts` passes `nodeSessionLocks` at its 4
call sites. One test now records the locks that the service takes.
- `taskGitPatchEngine.ts`: `TaskGitPatchApplyConfig` picks
`sessionLocks`, and the applied watermark write passes it.
- `common/utils/tools/tools.ts`: the `sessionLocks` comment names the
watermark write. The `task_apply_git_patch` tool gets the locks through
its tool config, which `turnRequestBuilder` already sets.
- `turnRequestBuilder.ts`, `workflows/WorkflowService.ts`,
`cli/workflow.ts`: each workflow patch config sets `sessionLocks` from
its history service. `WorkflowServiceContext` gains `historyService:
Pick<HistoryService, "locks">`. The ORPC context already has it.
`WorkflowService.context.test.ts` adds it to its test context.

The 4 artifact functions keep an optional `locks`: a required one breaks
about 25 test files.

## Validation

On the stack head `c0831c924e` (PR 14 on PR 13's final head
`41aab3e5b4`), every gate passed:

- `make static-check` and `make lint-eslint` pass. `make crap-check`:
PASS, 0 violations, 7 warnings on touched hotspots (total CC of the
changed files 10107 -> 10112: the 4 artifact functions each gain one
`locks ?? nodeSessionLocks` fallback, and `workspaceFileLocksOf` holds
the report one).
- `bun test` of the 4 `subagent*Artifacts.test.ts`,
`historyService.test.ts`, `taskService.agentReports.test.ts`,
`taskService.handoffAndCleanup.test.ts`,
`gitPatchArtifactService.test.ts`, `taskGitPatchEngine.test.ts`,
`workflows/WorkflowService.context.test.ts`,
`workflows/WorkflowTaskServiceAdapter.test.ts` and
`tools/task_apply_git_patch.test.ts`: 589 pass, 0 fail.
- The tripwire (`scripts/perf/loopTestBaseline.ts --runs 3 --base
41aab3e`): 0 trips.
- `make test`: 0 fail in every run.

The head `0ae88d7ef7` is the same 5 commits rebased on main `d1f9d61489`
(after #7423). Its diff against main has the 14 files above. On this
head, `make static-check` passes and the plan tests give 589 pass, 0
fail.

Test: `gitPatchArtifactService.test.ts` gives the service a
`SessionLocks` whose workspace FIFO records each key, and checks that
the parent's index writes take it. Revert proof: with the 4 upserts back
on the Node default, that test fails.

## Mutation check

`make mutate-check` (base `6887934d00`, so PR 13's lines are in scope
too): 167 killed, 128 survived, 4 equivalent, 1 without a test, 682 not
run. No survivor is on a line that this PR changes. I list them in #7326
for PR 17.

- The 4 equivalents are the `locks ?? nodeSessionLocks` fallbacks, each
with a `mutation-equivalent` marker: `locks` is a `SessionLocks` object
or undefined, so `??` and `||` agree.
- The 1 without a test is `cli/workflow.ts`, and the local baseline
reports it as failed. That is a local limit: mutate's worker copies hold
only tracked files, and `cli/workflow.test.ts` runs the built
`dist/cli/index.js`, which they lack. The test passes in the checkout
(10 pass, 0 fail). The PR adds one `sessionLocks` field there, with no
operator to mutate. CI's Quality / Mutation is the check of record.
- Survivors: `GitPatchArtifactService.generate` 29,
`maybeStartGenerationUnlocked` 20,
`taskGitPatchEngine.applyProjectPatch` 31 and `applyPatch` 21,
`upsertSubagentReportArtifact` 7, `upsertSubagentFailureArtifact` 3, and
5 more in the other artifact functions. PR 13's survivors
(`rollbackRefinement` 9, `withTargetMutationLocks` 2,
`acquireRollbackFileLock` 1) repeat and are already listed.

## Risks

- None for behavior: in the app, `historyService.locks` is
`nodeSessionLocks`, which gives the same `workspaceFileLocks` FIFO.

---

_Generated with `xum` • Model: `anthropic:claude-opus-5-5` • Thinking:
`high` • Cost: `$163.55`_

<!-- mux-attribution: model=anthropic:claude-opus-5-5 thinking=high
costs=163.55 -->

Author: ThomasK33

src/cli/workflow.ts

@@ -476,6 +476,7 @@ function createWorkflowService(input: {
           runtimeTempDir: runtime.normalizePath(".xum/tmp", input.ctx.workspacePath),
           workspaceSessionDir,
           trusted: input.ctx.projectTrusted,
+          sessionLocks: input.ctx.services.historyService.locks,
         },
       }),
     resolveWorkflowScript: (scriptPath) =>

src/common/utils/tools/tools.ts

@@ -155,7 +155,7 @@ export interface ToolConfiguration {
   runtime: Runtime;
   /** OS notifications for the notify tool. Absent: the Node layer (configs that tests build by hand). */
   desktopNotifications?: DesktopNotifications;
-  /** Session locks of the todo and review pane writes. Absent: the Node layer (configs that tests build by hand). */
+  /** Session locks of the todo, review pane and patch-applied watermark writes. Absent: the Node layer (configs that tests build by hand). */
   sessionLocks?: SessionLocks;
   /** Session files of the todo and review pane state. Absent: the Node layer (configs that tests build by hand). */
   sessionFiles?: SessionFiles;

src/node/services/gitPatchArtifactService.test.ts

@@ -17,6 +17,8 @@ import {
   upsertSubagentGitPatchArtifact,
 } from "@/node/services/subagentGitPatchArtifacts";
 import { TestTempDir } from "@/node/services/tools/testHelpers";
+import { nodeSessionLocks } from "@/node/services/sessionLocks/nodeSessionLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 
 describe("upsertProjectArtifact", () => {
   it("appends unmatched project artifacts instead of dropping them", () => {
@@ -97,7 +99,7 @@ describe("GitPatchArtifactService coordination", () => {
           totalCommitCount: 0,
         }),
       });
-      const service = new GitPatchArtifactService(config);
+      const service = new GitPatchArtifactService(config, nodeSessionLocks);
       const completed: string[] = [];
       const discovery = spyOn(agentDefinitions, "readAgentDefinition");
       const upsert = spyOn(patchArtifacts, "upsertSubagentGitPatchArtifact");
@@ -152,7 +154,18 @@ describe("GitPatchArtifactService coordination", () => {
       });
       return cfg;
     });
-    const service = new GitPatchArtifactService(config);
+    // The parent's index writes take the injected workspace FIFO, not the Node default.
+    const lockedWorkspaceIds: string[] = [];
+    const locks: SessionLocks = {
+      ...nodeSessionLocks,
+      workspaceFiles: {
+        withLock: <T>(workspaceId: string, operation: () => Promise<T>) => {
+          lockedWorkspaceIds.push(workspaceId);
+          return nodeSessionLocks.workspaceFiles.withLock(workspaceId, operation);
+        },
+      },
+    };
+    const service = new GitPatchArtifactService(config, locks);
     const parentSessionDir = path.join(config.sessionsDir, "parent");
     for (const continuation of [false, true]) {
       if (continuation) {
@@ -178,11 +191,13 @@ describe("GitPatchArtifactService coordination", () => {
       expect(artifact?.projectArtifacts[0]?.headCommitSha).toBe(git("rev-parse", "HEAD"));
       expect(completed).toBe(true);
     }
+    expect(lockedWorkspaceIds.length).toBeGreaterThan(0);
+    expect(new Set(lockedWorkspaceIds)).toEqual(new Set(["parent"]));
   });
 
   it("waits for an in-flight apply operation before refreshing the stable task artifact", async () => {
     using tempDir = new TestTempDir("git-patch-artifact-lock");
-    const service = new GitPatchArtifactService(new Config(tempDir.path));
+    const service = new GitPatchArtifactService(new Config(tempDir.path), nodeSessionLocks);
     let releaseApply: (() => void) | undefined;
     const applyGate = new Promise<void>((resolve) => {
       releaseApply = resolve;
@@ -268,7 +283,7 @@ describe("GitPatchArtifactService coordination", () => {
     });
 
     const snapshot = config.loadConfigOrDefault();
-    const service = new GitPatchArtifactService(config);
+    const service = new GitPatchArtifactService(config, nodeSessionLocks);
     const loadConfigSpy = spyOn(config, "loadConfigOrDefault");
     const completedChildIds: string[] = [];
     let resolveFreshCompletion: (() => void) | undefined;

src/node/services/gitPatchArtifactService.ts

@@ -37,6 +37,7 @@ import { shellQuote } from "@/common/utils/shell";
 import { getErrorMessage } from "@/common/utils/errors";
 import { PlatformPaths } from "@/common/utils/paths";
 import { PlatformPaths as NodePlatformPaths } from "@/node/utils/paths.main";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 import {
   getWorkspaceProjectRepos,
   getWorkspaceProjectStorageKeys,
@@ -321,7 +322,11 @@ export class GitPatchArtifactService {
   private readonly operationLocks = new MutexMap<string>();
   private readonly pendingJobsByTaskId = new Map<string, Promise<void>>();
 
-  constructor(private readonly config: Config) {}
+  constructor(
+    private readonly config: Config,
+    /** The workspace FIFO of the parent's patch artifact index writes (phase 4: SessionLocks). */
+    private readonly locks: SessionLocks
+  ) {}
 
   withOperationLock<T>(childWorkspaceId: string, operation: () => Promise<T>): Promise<T> {
     assert(childWorkspaceId.length > 0, "withOperationLock: childWorkspaceId must be non-empty");
@@ -455,6 +460,7 @@ export class GitPatchArtifactService {
 
     const artifact = await upsertSubagentGitPatchArtifact({
       workspaceId: parentWorkspaceId,
+      locks: this.locks,
       workspaceSessionDir: parentSessionDir,
       childTaskId: childWorkspaceId,
       updater: (existing) => {
@@ -504,6 +510,7 @@ export class GitPatchArtifactService {
           try {
             await upsertSubagentGitPatchArtifact({
               workspaceId: parentWorkspaceId,
+              locks: this.locks,
               workspaceSessionDir: parentSessionDir,
               childTaskId: childWorkspaceId,
               updater: (existing) => {
@@ -538,6 +545,7 @@ export class GitPatchArtifactService {
     } catch (error: unknown) {
       await upsertSubagentGitPatchArtifact({
         workspaceId: parentWorkspaceId,
+        locks: this.locks,
         workspaceSessionDir: parentSessionDir,
         childTaskId: childWorkspaceId,
         updater: (existing) => {
@@ -590,6 +598,7 @@ export class GitPatchArtifactService {
     ): Promise<SubagentGitPatchArtifact> => {
       return await upsertSubagentGitPatchArtifact({
         workspaceId: parentWorkspaceId,
+        locks: this.locks,
         workspaceSessionDir: parentSessionDir,
         childTaskId: childWorkspaceId,
         updater,

src/node/services/subagentFailureArtifacts.ts

@@ -5,7 +5,8 @@ import writeFileAtomic from "@/node/utils/writeFileAtomic";
 
 import { getErrorMessage } from "@/common/utils/errors";
 import { log } from "@/node/services/log";
-import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import { nodeSessionLocks } from "@/node/services/sessionLocks/nodeSessionLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 
 /**
  * Durable terminal-failure artifacts for sub-agent tasks.
@@ -175,8 +176,12 @@ export async function upsertSubagentFailureArtifact(params: {
   workflowOwnedAncestorWorkspaceIds?: string[];
   model?: string;
   nowMs?: number;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<void> {
-  await workspaceFileLocks.withLock(params.workspaceId, async () => {
+  // mutation-equivalent: locks is a SessionLocks object or undefined, so ?? and || agree
+  const fileLocks = (params.locks ?? nodeSessionLocks).workspaceFiles;
+  await fileLocks.withLock(params.workspaceId, async () => {
     const nowMs = params.nowMs ?? Date.now();
 
     const file = await readSubagentFailureArtifactsFile(params.workspaceSessionDir);

src/node/services/subagentGitPatchArtifacts.ts

@@ -8,7 +8,8 @@ import type {
   SubagentGitProjectPatchArtifact,
 } from "@/common/utils/tools/toolDefinitions";
 import { log } from "@/node/services/log";
-import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import { nodeSessionLocks } from "@/node/services/sessionLocks/nodeSessionLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 
 export interface SubagentGitPatchArtifactsFile {
   version: 2;
@@ -348,8 +349,12 @@ export async function updateSubagentGitPatchArtifactsFile(params: {
   workspaceId: string;
   workspaceSessionDir: string;
   update: (file: SubagentGitPatchArtifactsFile) => void;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<SubagentGitPatchArtifactsFile> {
-  return workspaceFileLocks.withLock(params.workspaceId, async () => {
+  // mutation-equivalent: locks is a SessionLocks object or undefined, so ?? and || agree
+  const fileLocks = (params.locks ?? nodeSessionLocks).workspaceFiles;
+  return fileLocks.withLock(params.workspaceId, async () => {
     const file = await readSubagentGitPatchArtifactsFile(params.workspaceSessionDir);
     params.update(file);
     file.version = SUBAGENT_GIT_PATCH_ARTIFACTS_FILE_VERSION;
@@ -375,12 +380,15 @@ export async function upsertSubagentGitPatchArtifact(params: {
   workspaceSessionDir: string;
   childTaskId: string;
   updater: (existing: SubagentGitPatchArtifact | null) => SubagentGitPatchArtifact;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<SubagentGitPatchArtifact> {
   let updated: SubagentGitPatchArtifact | null = null;
 
   await updateSubagentGitPatchArtifactsFile({
     workspaceId: params.workspaceId,
     workspaceSessionDir: params.workspaceSessionDir,
+    locks: params.locks,
     update: (file) => {
       const existing = file.artifactsByChildTaskId[params.childTaskId] ?? null;
       updated = normalizeSubagentGitPatchArtifact(params.updater(existing));
@@ -401,12 +409,15 @@ export async function markSubagentGitPatchArtifactApplied(params: {
   childTaskId: string;
   projectPath: string;
   appliedAtMs: number;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<SubagentGitPatchArtifact | null> {
   let updated: SubagentGitPatchArtifact | null = null;
 
   await updateSubagentGitPatchArtifactsFile({
     workspaceId: params.workspaceId,
     workspaceSessionDir: params.workspaceSessionDir,
+    locks: params.locks,
     update: (file) => {
       const existing = file.artifactsByChildTaskId[params.childTaskId] ?? null;
       if (!existing) {

src/node/services/subagentReportArtifacts.ts

@@ -6,7 +6,8 @@ import writeFileAtomic from "@/node/utils/writeFileAtomic";
 import { coerceThinkingLevel, type ThinkingLevel } from "@/common/types/thinking";
 
 import { log } from "@/node/services/log";
-import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import { nodeSessionLocks } from "@/node/services/sessionLocks/nodeSessionLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 
 export interface SubagentReportArtifactsFile {
   version: 1;
@@ -262,12 +263,21 @@ export async function readSubagentReportArtifactStrict(
   }
 }
 
+/** The workspace FIFO of the index writes: the caller's SessionLocks (phase 4), else the Node layer. */
+function workspaceFileLocksOf(locks: SessionLocks | undefined): SessionLocks["workspaceFiles"] {
+  // mutation-equivalent: locks is a SessionLocks object or undefined, so ?? and || agree
+  return (locks ?? nodeSessionLocks).workspaceFiles;
+}
+
 export async function updateSubagentReportArtifactsFile(params: {
   workspaceId: string;
   workspaceSessionDir: string;
   update: (file: SubagentReportArtifactsFile) => void;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<SubagentReportArtifactsFile> {
-  return workspaceFileLocks.withLock(params.workspaceId, async () => {
+  const fileLocks = workspaceFileLocksOf(params.locks);
+  return fileLocks.withLock(params.workspaceId, async () => {
     const file = await readSubagentReportArtifactsFile(params.workspaceSessionDir);
     params.update(file);
 
@@ -302,10 +312,13 @@ export async function upsertSubagentReportArtifact(params: {
   nowMs?: number;
   /** The reporting attempt (see SubagentReportArtifactIndexEntry.taskAttemptId). */
   taskAttemptId?: string;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<SubagentReportArtifactIndexEntry> {
   let updated: SubagentReportArtifactIndexEntry | null = null;
 
-  await workspaceFileLocks.withLock(params.workspaceId, async () => {
+  const fileLocks = workspaceFileLocksOf(params.locks);
+  await fileLocks.withLock(params.workspaceId, async () => {
     const nowMs = params.nowMs ?? Date.now();
 
     const model =

src/node/services/subagentTranscriptArtifacts.ts

@@ -6,7 +6,8 @@ import writeFileAtomic from "@/node/utils/writeFileAtomic";
 import type { ThinkingLevel } from "@/common/types/thinking";
 
 import { log } from "@/node/services/log";
-import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import { nodeSessionLocks } from "@/node/services/sessionLocks/nodeSessionLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 
 export interface SubagentTranscriptArtifactsFile {
   version: 1;
@@ -112,8 +113,12 @@ export async function updateSubagentTranscriptArtifactsFile(params: {
   workspaceId: string;
   workspaceSessionDir: string;
   update: (file: SubagentTranscriptArtifactsFile) => void;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<SubagentTranscriptArtifactsFile> {
-  return workspaceFileLocks.withLock(params.workspaceId, async () => {
+  // mutation-equivalent: locks is a SessionLocks object or undefined, so ?? and || agree
+  const fileLocks = (params.locks ?? nodeSessionLocks).workspaceFiles;
+  return fileLocks.withLock(params.workspaceId, async () => {
     const file = await readSubagentTranscriptArtifactsFile(params.workspaceSessionDir);
     params.update(file);
 
@@ -137,12 +142,15 @@ export async function upsertSubagentTranscriptArtifactIndexEntry(params: {
   updater: (
     existing: SubagentTranscriptArtifactIndexEntry | null
   ) => SubagentTranscriptArtifactIndexEntry;
+  /** The workspace FIFO (phase 4: SessionLocks). Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<SubagentTranscriptArtifactIndexEntry> {
   let updated: SubagentTranscriptArtifactIndexEntry | null = null;
 
   await updateSubagentTranscriptArtifactsFile({
     workspaceId: params.workspaceId,
     workspaceSessionDir: params.workspaceSessionDir,
+    locks: params.locks,
     update: (file) => {
       const existing = file.artifactsByChildTaskId[params.childTaskId] ?? null;
       updated = params.updater(existing);

src/node/services/taskGitPatchEngine.ts

@@ -30,6 +30,7 @@ import { log } from "@/node/services/log";
 import { Config } from "@/node/config";
 import { coerceNonEmptyString, findWorkspaceEntry } from "@/node/services/taskUtils";
 import { getWorkspaceProjectRepos } from "@/node/services/workspaceProjectRepos";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 
 import { streamToString } from "@/node/runtime/streamUtils";
 import { nodeRuntimeFactory } from "@/node/services/runtimeFactory/nodeRuntimeFactory";
@@ -39,7 +40,13 @@ export type TaskApplyGitPatchResult = z.infer<typeof TaskApplyGitPatchToolResult
 
 export type TaskGitPatchApplyConfig = Pick<
   ToolConfiguration,
-  "workspaceId" | "cwd" | "runtime" | "runtimeTempDir" | "workspaceSessionDir" | "trusted"
+  | "workspaceId"
+  | "cwd"
+  | "runtime"
+  | "runtimeTempDir"
+  | "workspaceSessionDir"
+  | "trusted"
+  | "sessionLocks"
 >;
 
 export interface GitPatchArtifactLookup {
@@ -1248,6 +1255,8 @@ async function applyProjectPatch(params: {
   expectedHeadSha?: string;
   isReplay: boolean;
   abortSignal?: AbortSignal;
+  /** The artifact workspace's FIFO for the applied watermark write. Absent: the Node layer. */
+  locks?: SessionLocks;
 }): Promise<{ success: boolean; projectResult: TaskApplyGitPatchProjectResult }> {
   const taskIdError = validatePatchRuntimePathComponent(params.taskId, "task_id");
   const storageKeyError = validatePatchRuntimePathComponent(
@@ -1668,6 +1677,7 @@ async function applyProjectPatch(params: {
         childTaskId: params.taskId,
         projectPath: params.projectArtifact.projectPath,
         appliedAtMs: Date.now(),
+        locks: params.locks,
       });
     }
 
@@ -1988,6 +1998,7 @@ async function applyPatch(
       expectedHeadSha,
       isReplay,
       abortSignal: options.abortSignal,
+      locks: config.sessionLocks,
     });
     projectResults.push(applyResult.projectResult);
     if (!applyResult.success) {

src/node/services/taskService.ts

@@ -5212,7 +5212,7 @@ export class TaskService implements AgentTaskIntegration {
         (this.parkedPeerSendsByTarget.get(targetId)?.length ?? 0),
     });
     this.terminalAttentionStore = terminalAttentionStore ?? new TerminalAttentionStore(config);
-    this.gitPatchArtifactService = new GitPatchArtifactService(config);
+    this.gitPatchArtifactService = new GitPatchArtifactService(config, historyService.locks);
 
     this.aiService.on("stream-end", (payload: unknown) => {
       if (!isStreamEndEvent(payload)) return;
@@ -19917,6 +19917,7 @@ export class TaskService implements AgentTaskIntegration {
       for (const ancestorWorkspaceId of ancestorWorkspaceIds) {
         try {
           await upsertSubagentFailureArtifact({
+            locks: this.historyService.locks,
             workspaceId: ancestorWorkspaceId,
             workspaceSessionDir: path.join(this.config.sessionsDir, ancestorWorkspaceId),
             childTaskId: workspaceId,
@@ -21400,6 +21401,7 @@ export class TaskService implements AgentTaskIntegration {
       try {
         const ancestorSessionDir = path.join(this.config.sessionsDir, ancestorWorkspaceId);
         await upsertSubagentReportArtifact({
+          locks: this.historyService.locks,
           workspaceId: ancestorWorkspaceId,
           workspaceSessionDir: ancestorSessionDir,
           childTaskId: childWorkspaceId,