@stigmer/runner 3.1.1 → 3.1.3

package/src/activities/execute-deep-agent/__tests__/prompt-builder.test.ts

@@ -1,5 +1,7 @@
 import { describe, it, expect } from "vitest";
+import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { buildEnhancedSystemPrompt } from "../prompt-builder.js";
+import { PLAN_MODE_DIRECTIVE } from "../../../shared/plan-mode-prompt.js";
 import { SourceType } from "../../../shared/workspace/types.js";
 import type { ProvisionResult } from "../../../shared/workspace/types.js";
 
@@ -205,4 +207,101 @@ describe("buildEnhancedSystemPrompt", () => {
 
     expect(prompt).not.toContain("## Workspace");
   });
+
+  describe("plan mode", () => {
+    const base = {
+      instructions: "Test",
+      provisionResults: [],
+      containerRoot: "",
+      skillsPromptSection: "",
+      workspaceFileRefs: [],
+      workspaceRoot: "/workspace",
+      injectedFiles: [],
+    };
+
+    it("appends the shared plan-mode directive as the final section", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        interactionMode: InteractionMode.PLAN,
+      });
+
+      expect(prompt).toContain("## Plan mode");
+      expect(prompt.endsWith(PLAN_MODE_DIRECTIVE)).toBe(true);
+    });
+
+    it("omits the directive for Agent mode", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        interactionMode: InteractionMode.AGENT,
+      });
+
+      expect(prompt).not.toContain("## Plan mode");
+    });
+
+    it("omits the directive when the mode is unset", () => {
+      const prompt = buildEnhancedSystemPrompt(base);
+
+      expect(prompt).not.toContain("## Plan mode");
+    });
+  });
+
+  describe("build from plan", () => {
+    const base = {
+      instructions: "Test",
+      provisionResults: [],
+      containerRoot: "",
+      skillsPromptSection: "",
+      workspaceFileRefs: [],
+      workspaceRoot: "/workspace",
+      injectedFiles: [],
+    };
+    const planFile = {
+      filename: "plan.md",
+      path: ".stigmer/inputs/plan.md",
+      size: 1024,
+    };
+
+    it("appends the implement-plan directive pointing at the injected plan", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        buildFromPlan: true,
+        injectedFiles: [planFile],
+      });
+
+      expect(prompt).toContain("## Implement the approved plan");
+      expect(prompt).toContain("`.stigmer/inputs/plan.md`");
+      expect(prompt).toContain("APPROVED");
+    });
+
+    it("falls back to the conversation-plan variant when the plan did not inject", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        buildFromPlan: true,
+      });
+
+      expect(prompt).toContain("## Implement the approved plan");
+      expect(prompt).toContain("conversation above");
+      expect(prompt).not.toContain("plan.md");
+    });
+
+    it("omits the directive for an ordinary execution", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        injectedFiles: [planFile],
+      });
+
+      expect(prompt).not.toContain("## Implement the approved plan");
+    });
+
+    it("carries the plan-derived progress-tracking instruction (Tier 3)", () => {
+      const prompt = buildEnhancedSystemPrompt({
+        ...base,
+        buildFromPlan: true,
+        injectedFiles: [planFile],
+      });
+
+      expect(prompt).toContain("to-do list");
+      expect(prompt).toContain("break the plan into");
+    });
+  });
 });

package/src/activities/execute-deep-agent/__tests__/sequential-gate-resume.test.ts

@@ -51,7 +51,9 @@ import type { SetupResult } from "../setup.js";
 vi.mock("@temporalio/activity", () => ({
   Context: {
     current: () => ({
-      cancellationSignal: { aborted: false },
+      // A real AbortSignal: the workspace-lock wait registers abort listeners
+      // on it, which a bare `{ aborted: false }` stub cannot satisfy.
+      cancellationSignal: new AbortController().signal,
       heartbeat: vi.fn(),
     }),
   },
@@ -187,7 +189,9 @@ function fakeMemoryGateSetup(opts: {
     agent: {},
     session: { spec: { workspaceEntries: [] } },
     workspaceBackend: {
-      rootDir: "/tmp/ws",
+      // Unique per test file: the workspace turn lock keys on this path, and a
+      // path shared across files would serialize parallel test workers for real.
+      rootDir: "/tmp/stigmer-test-ws-seq-gate",
       exists: vi.fn(async () => false),
       readFile: vi.fn(async () => ""),
     },
@@ -252,6 +256,7 @@ const memoryConfig: Config = {
   checkpointerProxyEndpoint: null,
   primaryModel: "claude-sonnet",
   cursorStreamStallTimeoutMs: 180000,
+  workspaceLockTimeoutMs: 900000,
 };
 
 function toolCallIds(status: AgentExecutionStatus): string[] {

package/src/activities/execute-deep-agent/index.ts

@@ -19,7 +19,13 @@ import { AgentMessageSchema, ToolCallSchema } from "@stigmer/protos/ai/stigmer/a
 import { ExecutionPhase, FileCaptureClass, FileChangeSetStatus, InteractionMode, MessageType, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { activityStarted, activityFinished } from "../../idle-watchdog.js";
 import { normalizeActivityInput, type ExecuteActivityInput } from "../../shared/activity-input.js";
-import { persistStatus, slimStatus, utcTimestamp } from "../../shared/status.js";
+import { persistStatus, reportSetupProgress, slimStatus, utcTimestamp } from "../../shared/status.js";
+import {
+  acquireWorkspaceLock,
+  WorkspaceLockCancelledError,
+  WorkspaceLockTimeoutError,
+  type ReleaseWorkspaceLock,
+} from "../../shared/workspace/workspace-lock.js";
 import type { ToolOutputOffloadContext } from "../../shared/status-offload.js";
 import { publishPlanArtifact } from "../../shared/plan-artifact.js";
 import { classifyTool } from "../../shared/tool-kind.js";
@@ -44,11 +50,15 @@ import {
   captureBaselineToLedger,
   captureCandidateToLedger,
 } from "../../shared/filereview/capture.js";
+import {
+  captureFileChangeProgress,
+  newProgressCaptureState,
+} from "../../shared/filereview/progress.js";
 import { hasCandidateCaptured } from "../../shared/filereview/events.js";
 import { casBlobReader, type CasPathCapture } from "../../shared/filereview/cas-substrate.js";
 import { partitionIgnoredPathsBySecret } from "../../shared/filereview/secret-paths.js";
 import type { CasCaptureObserver } from "./cas-capture-observer.js";
-import { collectSubAgentToolCallIds } from "../../shared/tool-row.js";
+import { collectSubAgentToolCallIds, withholdSecretContentFromMessages } from "../../shared/tool-row.js";
 import { stampFlowedFileEditRows, stampFlowedSubAgentFileEditRows } from "./stamp-flowed-rows.js";
 
 /** The harness id stamped on the deep-agent's file-review ledger events. */
@@ -75,6 +85,11 @@ export function createDeepAgentActivities(config: Config) {
       const { executionId, threadId, turnSeq } = normalizeActivityInput(arg0, arg1);
       activityStarted();
       let setup: SetupResult | null = null;
+      // Exclusive turn lock on the workspace working tree — held across the
+      // entire tree-mutating window (decision reconcile, agent writes,
+      // candidate capture, write-back) and released in the finally. Mirrors
+      // the Cursor harness; see shared/workspace/workspace-lock.ts.
+      let releaseWorkspaceLock: ReleaseWorkspaceLock | undefined;
 
       try {
         console.log(`[ExecuteDeepAgent] Started for execution ${executionId}`);
@@ -163,6 +178,45 @@ export function createDeepAgentActivities(config: Config) {
         const gitRoot = setup.workspaceBackend.rootDir;
         const changeSetId = `${executionId}:${turnSeq}`;
 
+        // Serialize this turn against every other execution sharing this
+        // working tree — an unserialized concurrent write lands inside this
+        // turn's baseline→candidate window and gets misattributed to this
+        // turn's review. Acquired before ANY tree mutation below (decision
+        // reconcile, agent writes, candidate capture, write-back); waiting
+        // surfaces a visible state and heartbeats, and a cancel aborts the
+        // wait immediately. Mirrors the Cursor harness wiring exactly.
+        try {
+          releaseWorkspaceLock = await acquireWorkspaceLock(gitRoot, {
+            onWaiting: () => reportSetupProgress(
+              client, executionId, "Waiting for workspace — in use by another session",
+            ),
+            heartbeat: () => Context.current().heartbeat(),
+            signal: Context.current().cancellationSignal,
+            timeoutMs: config.workspaceLockTimeoutMs,
+          });
+        } catch (lockErr) {
+          if (lockErr instanceof WorkspaceLockCancelledError) {
+            throw new CancelledFailure("Activity cancelled while waiting for the workspace lock");
+          }
+          if (lockErr instanceof WorkspaceLockTimeoutError) {
+            const failedStatus = create(AgentExecutionStatusSchema, {
+              phase: ExecutionPhase.EXECUTION_FAILED,
+              error: lockErr.message,
+              completedAt: utcTimestamp(),
+              messages: [
+                create(AgentMessageSchema, {
+                  type: MessageType.MESSAGE_SYSTEM,
+                  content: `Execution failed: ${lockErr.message}`,
+                  timestamp: utcTimestamp(),
+                }),
+              ],
+            });
+            await persistStatus(client, executionId, failedStatus, { offload: statusOffload });
+            return slimStatus(failedStatus);
+          }
+          throw lockErr;
+        }
+
         // (1) Capture-mode resume — reconcile any DECIDED change set FIRST (this
         // drops the per-execution refs), before the next baseline re-pins them
         // (refs are executionId-keyed). Then (2) short-circuit a pure file-review
@@ -269,6 +323,15 @@ export function createDeepAgentActivities(config: Config) {
           });
         }
 
+        // Per-turn state for mid-run live capture (DD-32): the last progress tree
+        // sha (short-circuit) + last capture time (floor), threaded across the
+        // streaming loop's persists via the beforePersist hook below. The capture
+        // flags are hoisted so the deferred hook does not depend on `setup`
+        // (non-null here, but not narrowable inside a later-invoked closure).
+        const progressState = newProgressCaptureState();
+        const progressCaptureMode = setup.captureMode;
+        const progressGitWorkspace = setup.gitWorkspace;
+
         const cancellationSignal = Context.current().cancellationSignal;
 
         const result: StreamResult = await streamExecution({
@@ -294,6 +357,23 @@ export function createDeepAgentActivities(config: Config) {
             globalBypass: setup.globalBypass,
           },
           streamVersion: setup.streamVersion,
+          // Mid-run live capture (DD-32): attach file_change_progress before each
+          // scheduled persist. Git capture mode only (a pinned baseline exists);
+          // deep-agent writes no runner-owned gate files into the tree, so no
+          // excludePaths — matching its turn-boundary candidate capture.
+          beforePersist: async (status) => {
+            if (!progressCaptureMode || !progressGitWorkspace || !captureBaselineTree) {
+              return;
+            }
+            await captureFileChangeProgress({
+              status,
+              gitRoot,
+              executionId,
+              changeSetId,
+              baselineTree: captureBaselineTree,
+              state: progressState,
+            });
+          },
         });
 
         await processPostStream({
@@ -308,6 +388,20 @@ export function createDeepAgentActivities(config: Config) {
           executionId,
         });
 
+        // Never-persist-secret backstop (DD-26 #2): withhold content from any
+        // built-in write row targeting a secret-like path, across the top-level
+        // and sub-agent transcripts, before ANY persist below. On the deny-gate a
+        // secret write is hard-blocked (a COMPLETED row) or — under
+        // auto_approve_all, where no gate is installed — flowed; either way the
+        // streamed row still carries `args` from handleToolStarted, and the
+        // capture-mode stamping pass (which performs the same scrub) does not run
+        // here. Idempotent / a no-op in capture mode. This single post-stream
+        // sweep is the one choke point that precedes every downstream persist.
+        withholdSecretContentFromMessages(
+          initialStatus.messages,
+          initialStatus.subAgentExecutions,
+        );
+
         // Turn boundary (capture mode): capture the candidate change set from the
         // git diff and author CANDIDATE_CAPTURED, then stamp the flowed file-edit
         // rows with the change set id — they stay visible in place as
@@ -492,9 +586,10 @@ export function createDeepAgentActivities(config: Config) {
         }
 
         // Plan mode: the agent's final message is the plan. Publish it as a
-        // first-class plan.md artifact so the UI can render a reviewable Plan
-        // card and a follow-up Implement run can reference it. Read-only mode
-        // produces no file to auto-publish, so this is the only artifact path.
+        // first-class plan artifact (named from the plan's title) so the UI can
+        // render a reviewable Plan card and a follow-up Implement run can
+        // reference it. Read-only mode produces no file to auto-publish, so
+        // this is the only artifact path.
         // Requires artifact storage; with none (proxy misconfig) the plan text
         // still lives in the final message — only the reviewable artifact is
         // skipped (mirrors Cursor's storage-guarded plan publish).
@@ -590,6 +685,10 @@ export function createDeepAgentActivities(config: Config) {
 
       } finally {
         await cleanup(setup);
+        // Release the workspace turn lock LAST — the next queued turn must
+        // not baseline until every mutation of this one has landed.
+        // Idempotent and non-throwing (see workspace-lock.ts).
+        await releaseWorkspaceLock?.();
         activityFinished();
       }
     },

package/src/activities/execute-deep-agent/prompt-builder.ts

@@ -7,8 +7,14 @@
  */
 
 import { relative } from "node:path";
+import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { ProvisionResult, GitMetadata } from "../../shared/workspace/types.js";
 import { SourceType } from "../../shared/workspace/types.js";
+import { PLAN_MODE_DIRECTIVE } from "../../shared/plan-mode-prompt.js";
+import {
+  buildImplementPlanDirective,
+  findApprovedPlanPath,
+} from "../../shared/implement-plan-prompt.js";
 
 const RESPONSE_RULES = `
 
@@ -84,6 +90,22 @@ export interface PromptBuilderInput {
   workspaceFileRefs: string[];
   workspaceRoot: string;
   injectedFiles: InjectedFile[];
+  /**
+   * The execution's interaction mode. PLAN appends the shared plan-mode
+   * directive so the model knows the turn's deliverable is a plan document.
+   * Tool-level write enforcement is separate (see setup.ts permissions) —
+   * without this directive the model is silently read-only but never told
+   * to produce a plan.
+   */
+  interactionMode?: InteractionMode;
+  /**
+   * The execution is a Build-from-plan turn (spec.execution_config
+   * .build_from_plan): appends the shared implement-plan directive, pointing
+   * the model at the injected approved plan document (or, when the plan
+   * attachment did not materialize, at the conversation's plan). The user
+   * message itself is just a short label ("Build from plan").
+   */
+  buildFromPlan?: boolean;
 }
 
 export interface InjectedFile {
@@ -128,6 +150,23 @@ export function buildEnhancedSystemPrompt(input: PromptBuilderInput): string {
   prompt += RESPONSE_RULES;
   prompt += SUB_AGENT_RULES;
 
+  // Last sections on purpose: these per-execution directives redefine the
+  // turn's deliverable, so they must be the freshest instruction the model
+  // reads. (PLAN and build_from_plan are mutually exclusive in practice —
+  // the build turn is always an Agent-mode execution.)
+  if (input.interactionMode === InteractionMode.PLAN) {
+    prompt += "\n\n## Plan mode\n\n" + PLAN_MODE_DIRECTIVE;
+  }
+
+  if (input.buildFromPlan) {
+    const planPath = findApprovedPlanPath(
+      input.injectedFiles.map((f) => f.path),
+    );
+    prompt +=
+      "\n\n## Implement the approved plan\n\n" +
+      buildImplementPlanDirective(planPath);
+  }
+
   return prompt;
 }
 

package/src/activities/execute-deep-agent/setup.ts

@@ -35,6 +35,7 @@ import { isGitWorkTree, isPathCapturable } from "../../shared/filereview/git-sub
 import { deriveCaptureMode } from "../../shared/filereview/capture.js";
 import { resolveWorkspacePath } from "../../shared/file-change.js";
 import { ensurePlatformDir } from "../../shared/workspace/platform-dir.js";
+import { resolveSessionWorkspaceRoot } from "../../shared/workspace/session-root.js";
 import { buildWorkspaceFileTree } from "../../shared/workspace/file-tree.js";
 import { reportSetupProgress } from "../../shared/status.js";
 import { resolveEnvironment, type EnvironmentResult } from "./environment.js";
@@ -49,7 +50,7 @@ import { getDefaultModel } from "../../shared/model-registry.js";
 import { buildChatModel } from "../../shared/model-client.js";
 import {
   loadArtifactStorageConfig,
-  createArtifactStorage,
+  resolveUsableArtifactStorage,
   type ArtifactStorage,
 } from "../../shared/artifact-storage.js";
 import {
@@ -201,20 +202,14 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
     await reportSetupProgress(client, executionId, "Resolving environment…");
     const envResult: EnvironmentResult = await resolveEnvironment(client, executionId);
 
-    // Step 6: Create artifact storage. Best-effort, mirroring the Cursor harness:
-    // `createArtifactStorage` throws only for proxy transport with a missing
-    // token/endpoint (a misconfiguration; local storage never throws). We degrade
-    // rather than crash — an absent store flips capture mode off (deny-gate
-    // fallback below) and disables offload, instead of failing the whole execution.
-    let artifactStorage: ArtifactStorage | undefined;
-    try {
-      artifactStorage = createArtifactStorage(loadArtifactStorageConfig(config));
-    } catch (storageErr) {
-      console.warn(
-        `[setup] artifact storage unavailable — capture degrades to the deny-gate ` +
-        `and tool-output offload is disabled: execution=${executionId}, error=${storageErr}`,
-      );
-    }
+    // Step 6: Resolve a usable artifact store (shared with the Cursor harness so
+    // both degrade identically). Returns `undefined` — never throws — when there
+    // is no working substrate: a proxy misconfig OR an unwritable local path
+    // (which `createArtifactStorage` cannot detect, since it just holds a path).
+    // An absent store flips capture mode off (deny-gate fallback below) and
+    // disables offload, instead of flowing writes then crashing at the boundary.
+    const artifactStorage: ArtifactStorage | undefined =
+      await resolveUsableArtifactStorage(loadArtifactStorageConfig(config), { executionId });
 
     // Step 7: Provision workspace
     await reportSetupProgress(client, executionId, "Initializing workspace…");
@@ -372,6 +367,8 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
       workspaceFileRefs: execution.spec!.workspaceFileRefs || [],
       workspaceRoot: workspaceBackend.rootDir,
       injectedFiles,
+      interactionMode: execution.spec!.executionConfig?.interactionMode,
+      buildFromPlan: execution.spec!.executionConfig?.buildFromPlan,
     });
 
     // Step 9: Construct the LLM model. Resolution to the provider API id
@@ -631,6 +628,11 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
 
 /**
  * Provision workspace from session workspace entries.
+ *
+ * A session with no entries gets its own empty per-session directory (see
+ * shared/workspace/session-root.ts) — never the shared root, which would
+ * leak other sessions' files into it. Mirrors the Cursor harness's
+ * provisionCursorWorkspace exactly.
  */
 async function provisionWorkspace(
   config: Config,
@@ -639,13 +641,19 @@ async function provisionWorkspace(
   sessionId: string,
 ): Promise<{ workspaceBackend: WorkspaceBackend; provisionResults: ProvisionResult[] }> {
   const platformDir = await ensurePlatformDir(sessionId);
-  const workspaceBackend = new LocalWorkspaceBackend(config.workspaceRootDir, platformDir);
 
   const workspaceEntries = session.spec!.workspaceEntries || [];
   if (workspaceEntries.length === 0) {
-    return { workspaceBackend, provisionResults: [] };
+    const sessionRoot = await resolveSessionWorkspaceRoot(
+      config.workspaceRootDir, workspaceEntries, sessionId,
+    );
+    return {
+      workspaceBackend: new LocalWorkspaceBackend(sessionRoot, platformDir),
+      provisionResults: [],
+    };
   }
 
+  const workspaceBackend = new LocalWorkspaceBackend(config.workspaceRootDir, platformDir);
   const provisioner = new WorkspaceProvisioner();
   const provisionResults = await provisioner.provisionAll(
     workspaceEntries.map(entry => ({

package/src/activities/execute-deep-agent/streaming-v3.ts

@@ -118,10 +118,15 @@ export async function streamExecutionV3(
         }
 
         statusBuilder.syncSubAgentExecutions();
+        // Mid-run live capture (DD-32): attach file_change_progress to the live
+        // status before it is persisted. Injected so this loop stays ignorant of
+        // file-review specifics; a no-op when the hook is absent or nothing changed.
+        const statusToPersist = statusBuilder.currentStatus;
+        await deps.beforePersist?.(statusToPersist);
         const signal = await persistStatus(
           client,
           executionId,
-          statusBuilder.currentStatus,
+          statusToPersist,
           { offload, retry: retryOptions },
         );
         scheduler.markUpdateSent(eventsProcessed);

package/src/activities/execute-deep-agent/streaming.ts

@@ -83,6 +83,13 @@ export interface StreamDependencies {
   readonly approvalProvider?: ApprovalPolicyProvider;
   /** Streaming protocol version. Defaults to "v2" if unset. */
   readonly streamVersion?: "v2" | "v3";
+  /**
+   * Optional hook invoked with the live status just before each scheduled
+   * persist. Used by mid-run live capture (DD-32) to attach file_change_progress.
+   * Kept as an injected callback (closing over the turn's baseline tree / change
+   * set id in index.ts) so this loop stays ignorant of file-review specifics.
+   */
+  readonly beforePersist?: (status: AgentExecutionStatus) => Promise<void>;
 }
 
 export interface StreamResult {
@@ -189,10 +196,14 @@ async function streamExecutionV2(
           statusBuilder.clearForceFlag();
         }
 
+        // Mid-run live capture (DD-32): attach file_change_progress to the live
+        // status before persisting (see streaming-v3.ts for the rationale).
+        const statusToPersist = statusBuilder.currentStatus;
+        await deps.beforePersist?.(statusToPersist);
         const signal = await persistStatus(
           client,
           executionId,
-          statusBuilder.currentStatus,
+          statusToPersist,
           { offload, retry: retryOptions },
         );
         scheduler.markUpdateSent(eventsProcessed);

package/src/config.ts

@@ -37,6 +37,12 @@ import { homedir, tmpdir } from "node:os";
  */
 export const DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS = 180_000;
 
+// Re-exported so the runner/manager options mappers default the lock-wait
+// bound from the same constant the lock module owns (no drift across the
+// three construction sites — mirrors DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS).
+export { DEFAULT_WORKSPACE_LOCK_TIMEOUT_MS } from "./shared/workspace/workspace-lock.js";
+import { DEFAULT_WORKSPACE_LOCK_TIMEOUT_MS } from "./shared/workspace/workspace-lock.js";
+
 export interface Config {
   readonly taskQueue: string;
   readonly temporalAddress: string;
@@ -83,6 +89,12 @@ export interface Config {
    * heartbeatTimeout (process liveness) and the 30s keep-alive heartbeat.
    */
   readonly cursorStreamStallTimeoutMs: number;
+  /**
+   * Max wait (milliseconds) for the per-workspace turn lock before failing
+   * the execution with a "workspace is in use by another session" error.
+   * See shared/workspace/workspace-lock.ts for the serialization model.
+   */
+  readonly workspaceLockTimeoutMs: number;
   /** Shared mutable token reference for dynamic token updates (manager mode). */
   readonly stigmerTokenRef?: { current: string | null };
 }
@@ -145,6 +157,10 @@ export function loadConfig(): Config {
     ? parseInt(process.env.CURSOR_STREAM_STALL_TIMEOUT_MS, 10)
     : DEFAULT_CURSOR_STREAM_STALL_TIMEOUT_MS;
 
+  const workspaceLockTimeoutMs = process.env.WORKSPACE_LOCK_TIMEOUT_MS
+    ? parseInt(process.env.WORKSPACE_LOCK_TIMEOUT_MS, 10)
+    : DEFAULT_WORKSPACE_LOCK_TIMEOUT_MS;
+
   return {
     taskQueue,
     temporalAddress,
@@ -162,6 +178,7 @@ export function loadConfig(): Config {
     checkpointerProxyEndpoint,
     primaryModel,
     cursorStreamStallTimeoutMs,
+    workspaceLockTimeoutMs,
   };
 }