🤖 refactor: usage, goal and timing services take the workspace FIFO from SessionLocks (#7379)

## Summary

The session usage, goal and timing services take the workspace FIFO from
`SessionLocks`. It is PR 7 of phase 4. Lock keys and order do not
change: the Node layer gives today's `workspaceFileLocks`.

## Order

- Plan order: PR 7 comes after PR 6, with PR 8 (#7354), and before PR 9.
- Landing order: PR 7 lands on main as its own PR, after PR 9 (#7372),
before PR 8 (#7354) and PR 5 (#7355) (recorded as a phase 4 plan note).
- Why: PR 7 needs PR 9's `historyService.locks`, which has merged. It
uses no code from PR 8 or PR 5.

## Implementation

- `sessionUsageService.ts` (8 calls) and `workspaceGoalService.ts` (29
calls): `fileLocks` is a getter that returns
`historyService.locks.workspaceFiles`. A memory or foreign-holder layer
reaches these writes too. The getter reads at each use, not at
construction, so tests that pass a partial `HistoryService` need no
edit.
- `sessionTimingService.ts` (4 calls): `new SessionTimingService(config,
telemetry, locks = nodeSessionLocks)`. `desktop.ts` keeps its call.
- `desktop.ts` and `core.ts` do not change.

## Validation

All on the head (`c7cacdb5db`, this diff on main `4770fa63e0`):

- `bun test` of `sessionUsageService*.test.ts`,
`workspaceGoalService*.test.ts`, `sessionTimingService.test.ts` and
`sessionLocks/`: 324 pass, 0 fail. The test files pass with no edit. The
call record fixture is unchanged.
- `make static-check`, `make lint-eslint`: pass.
- `make test`: 27753 pass, 0 fail in the main run, and every other run
passes.
- Tripwire (`scripts/perf/loopTestBaseline.ts --runs 3 --base
origin/main`): 0 trips.
- `make crap-check`: PASS, 0 violations. `make mutate-check`: PASS, 0
mutants in scope.

## Risks

- None for behavior: in the app, `historyService.locks.workspaceFiles`
and the default are the same `workspaceFileLocks` map.

---

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

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

Author: ThomasK33

src/node/services/sessionTimingService.ts

@@ -4,7 +4,8 @@ import * as fs from "fs/promises";
 import { EventEmitter } from "events";
 import writeFileAtomic from "@/node/utils/writeFileAtomic";
 import type { Config } from "@/node/config";
-import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import { nodeSessionLocks } from "@/node/services/sessionLocks/nodeSessionLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 import { normalizeToCanonical } from "@/common/utils/ai/models";
 import type { AgentMode } from "@/common/types/mode";
 import {
@@ -163,7 +164,8 @@ function validateTiming(params: {
 export class SessionTimingService {
   private readonly config: Config;
   private readonly telemetryService: TelemetryService;
-  private readonly fileLocks = workspaceFileLocks;
+  /** The one workspace FIFO (phase 4: from SessionLocks; desktop.ts keeps the Node default). */
+  private readonly fileLocks: SessionLocks["workspaceFiles"];
 
   private readonly activeStreams = new Map<string, ActiveStreamState>();
   private readonly timingFileCache = new Map<string, SessionTimingFile>();
@@ -181,9 +183,14 @@ export class SessionTimingService {
     { lastEmitTimeMs: number; timer?: ReturnType<typeof setTimeout> }
   >();
 
-  constructor(config: Config, telemetryService: TelemetryService) {
+  constructor(
+    config: Config,
+    telemetryService: TelemetryService,
+    locks: SessionLocks = nodeSessionLocks
+  ) {
     this.config = config;
     this.telemetryService = telemetryService;
+    this.fileLocks = locks.workspaceFiles;
   }
 
   addSubscriber(workspaceId: string): void {

src/node/services/sessionUsageService.ts

@@ -8,7 +8,7 @@ import type { Config } from "@/node/config";
 import type { HistoryService } from "./historyService";
 import { isWorkspaceRemovalTombstoned } from "@/node/services/workspaceRemoval";
 import { withTargetMutationLock } from "@/node/services/refinement/targetMutationLocks";
-import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 import type { ChatUsageDisplay } from "@/common/utils/tokens/usageAggregator";
 import { sumUsageHistory } from "@/common/utils/tokens/usageAggregator";
 import { createDisplayUsage } from "@/common/utils/tokens/displayUsage";
@@ -227,7 +227,14 @@ function pruneSettledInFlightKeys(
  */
 export class SessionUsageService {
   private readonly SESSION_USAGE_FILE = "session-usage.json";
-  private readonly fileLocks = workspaceFileLocks;
+  /**
+   * The one workspace FIFO, from the HistoryService's SessionLocks (phase 4), so a
+   * memory or foreign-holder layer reaches these writes too. Read at each use, not
+   * at construction: tests that pass a partial HistoryService keep working.
+   */
+  private get fileLocks(): SessionLocks["workspaceFiles"] {
+    return this.historyService.locks.workspaceFiles;
+  }
   private readonly config: Config;
   private readonly historyService: HistoryService;
   private readonly getProvidersConfig: () => ProvidersConfigMap | null;

src/node/services/workspaceGoalService.ts

@@ -44,7 +44,7 @@ import type { SendMessageError } from "@/common/types/errors";
 import { ProvidersConfigStore, type Config } from "@/node/config";
 import type { HistoryService } from "@/node/services/historyService";
 import type { ExtensionMetadataService } from "@/node/services/ExtensionMetadataService";
-import { workspaceFileLocks } from "@/node/utils/concurrency/workspaceFileLocks";
+import type { SessionLocks } from "@/node/services/sessionLocks/sessionLocks";
 import {
   DEFAULT_GOAL_CONTINUATION_COOLDOWN_MS,
   GOAL_STREAM_ERROR_RESUME_MAX_ATTEMPTS,
@@ -609,7 +609,14 @@ export interface WorkspaceGoalServiceOptions {
 }
 
 export class WorkspaceGoalService {
-  private readonly fileLocks = workspaceFileLocks;
+  /**
+   * The one workspace FIFO, from the HistoryService's SessionLocks (phase 4), so a
+   * memory or foreign-holder layer reaches these writes too. Read at each use, not
+   * at construction: tests that pass a partial HistoryService keep working.
+   */
+  private get fileLocks(): SessionLocks["workspaceFiles"] {
+    return this.historyService.locks.workspaceFiles;
+  }
   private readonly continuationCooldownMs: number;
   private readonly allowUserOriginBudgetWrapup: boolean;
   private readonly suppressKickoffContinuation: boolean;