@exaudeus/workrail 3.26.1 → 3.27.0

package/dist/daemon/workflow-runner.js

@@ -40,6 +40,7 @@ exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = exports.DAEMON_SESS
 exports.readDaemonSessionState = readDaemonSessionState;
 exports.readAllDaemonSessions = readAllDaemonSessions;
 exports.runStartupRecovery = runStartupRecovery;
+exports.makeContinueWorkflowTool = makeContinueWorkflowTool;
 exports.makeBashTool = makeBashTool;
 exports.buildSessionRecap = buildSessionRecap;
 exports.buildSystemPrompt = buildSystemPrompt;
@@ -337,7 +338,7 @@ function getSchemas() {
     };
     return _schemas;
 }
-function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas) {
+function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas, _executeContinueWorkflowFn = index_js_1.executeContinueWorkflow) {
     return {
         name: 'continue_workflow',
         description: 'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
@@ -345,7 +346,8 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
         inputSchema: schemas['ContinueWorkflowParams'],
         label: 'Continue Workflow',
         execute: async (_toolCallId, params) => {
-            const result = await (0, index_js_1.executeContinueWorkflow)({
+            console.log(`[WorkflowRunner] Tool: continue_workflow sessionId=${sessionId}`);
+            const result = await _executeContinueWorkflowFn({
                 continueToken: params.continueToken,
                 intent: (params.intent ?? 'advance'),
                 output: params.notesMarkdown
@@ -359,8 +361,50 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
             const out = result.value.response;
             const continueToken = out.continueToken ?? '';
             const checkpointToken = out.checkpointToken ?? null;
-            if (continueToken) {
-                await persistTokens(sessionId, continueToken, checkpointToken);
+            const persistToken = (out.kind === 'blocked' ? out.nextCall?.params.continueToken : undefined) ?? continueToken;
+            if (persistToken) {
+                await persistTokens(sessionId, persistToken, checkpointToken);
+            }
+            if (out.kind === 'blocked') {
+                const retryToken = out.nextCall?.params.continueToken ?? continueToken;
+                const lines = ['## Step blocked -- action required\n'];
+                for (const blocker of out.blockers.blockers) {
+                    lines.push(blocker.message);
+                    if (blocker.suggestedFix) {
+                        lines.push(`\nWhat to do: ${blocker.suggestedFix}`);
+                    }
+                    lines.push('');
+                }
+                if (out.validation) {
+                    if (out.validation.issues.length > 0) {
+                        lines.push('**Issues:**');
+                        for (const issue of out.validation.issues)
+                            lines.push(`- ${issue}`);
+                        lines.push('');
+                    }
+                    if (out.validation.suggestions.length > 0) {
+                        lines.push('**Suggestions:**');
+                        for (const s of out.validation.suggestions)
+                            lines.push(`- ${s}`);
+                        lines.push('');
+                    }
+                }
+                if (out.assessmentFollowup) {
+                    lines.push(`**Follow-up required:** ${out.assessmentFollowup.title}`);
+                    lines.push(out.assessmentFollowup.guidance);
+                    lines.push('');
+                }
+                if (out.retryable) {
+                    lines.push(`Retry the same step with corrected output.\n\ncontinueToken: ${retryToken}`);
+                }
+                else {
+                    lines.push(`You cannot proceed without resolving this. Inform the user and wait for their response, then call continue_workflow.\n\ncontinueToken: ${retryToken}`);
+                }
+                const feedback = lines.join('\n');
+                return {
+                    content: [{ type: 'text', text: feedback }],
+                    details: out,
+                };
             }
             if (out.isComplete) {
                 onComplete(params.notesMarkdown);
@@ -391,6 +435,7 @@ function makeBashTool(workspacePath, schemas) {
         inputSchema: schemas['BashParams'],
         label: 'Bash',
         execute: async (_toolCallId, params) => {
+            console.log(`[WorkflowRunner] Tool: bash "${String(params.command).slice(0, 80)}"`);
             const cwd = params.cwd ?? workspacePath;
             try {
                 const { stdout, stderr } = await execAsync(params.command, {
@@ -637,6 +682,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
                 reject(new Error('Workflow timed out'));
             }, sessionTimeoutMs);
         });
+        console.log(`[WorkflowRunner] Agent loop started: sessionId=${sessionId} workflowId=${trigger.workflowId} modelId=${modelId}`);
         await Promise.race([agent.prompt(buildUserMessage(initialPrompt)), timeoutPromise])
             .catch((err) => {
             agent.abort();
@@ -662,6 +708,7 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
         unsubscribe();
         if (timeoutHandle !== undefined)
             clearTimeout(timeoutHandle);
+        console.log(`[WorkflowRunner] Agent loop ended: sessionId=${sessionId} stopReason=${stopReason}${errorMessage ? ` error=${errorMessage.slice(0, 120)}` : ''}`);
     }
     if (timeoutReason !== null) {
         daemonRegistry?.unregister(sessionId, 'failed');

package/dist/infrastructure/session/HttpServer.js

@@ -425,11 +425,17 @@ let HttpServer = class HttpServer {
             const lockData = JSON.parse(lockContent);
             const { reclaim, reason } = this.shouldReclaimLock(lockData);
             if (!reclaim) {
-                console.error(`[Dashboard] Secondary mode: primary lock valid (PID ${lockData.pid}), yielding`);
+                try {
+                    process.stderr.write(`[Dashboard] Secondary mode: primary lock valid (PID ${lockData.pid}), yielding\n`);
+                }
+                catch { }
                 return false;
             }
             else {
-                console.error(`[Dashboard] Lock reclaim needed: ${reason}`);
+                try {
+                    process.stderr.write(`[Dashboard] Lock reclaim needed: ${reason}\n`);
+                }
+                catch { }
             }
             const tempPath = `${this.lockFile}.${process.pid}.${Date.now()}`;
             const newLockData = {
@@ -459,7 +465,24 @@ let HttpServer = class HttpServer {
                         throw err;
                     }
                 }
-                console.error('[Dashboard] Lock reclaimed successfully');
+                try {
+                    const writtenContent = await promises_1.default.readFile(this.lockFile, 'utf-8');
+                    const writtenData = JSON.parse(writtenContent);
+                    if (writtenData.pid !== process.pid) {
+                        try {
+                            process.stderr.write(`[Dashboard] Lost lock election (winner PID ${writtenData.pid}), yielding\n`);
+                        }
+                        catch { }
+                        return false;
+                    }
+                }
+                catch {
+                    return await this.tryBecomePrimary();
+                }
+                try {
+                    process.stderr.write('[Dashboard] Lock reclaimed successfully\n');
+                }
+                catch { }
                 this.isPrimary = true;
                 this.setupPrimaryCleanup();
                 this.heartbeat.start();
@@ -468,10 +491,16 @@ let HttpServer = class HttpServer {
             catch (error) {
                 await promises_1.default.unlink(tempPath).catch(() => { });
                 if (error.code === 'ENOENT') {
-                    console.error('[Dashboard] Lock deleted during reclaim, trying fresh');
+                    try {
+                        process.stderr.write('[Dashboard] Lock deleted during reclaim, trying fresh\n');
+                    }
+                    catch { }
                     return await this.tryBecomePrimary();
                 }
-                console.error('[Dashboard] Lock reclaim failed:', error.message);
+                try {
+                    process.stderr.write(`[Dashboard] Lock reclaim failed: ${error.message}\n`);
+                }
+                catch { }
                 return false;
             }
         }
@@ -479,7 +508,10 @@ let HttpServer = class HttpServer {
             if (error.code === 'ENOENT') {
                 return await this.tryBecomePrimary();
             }
-            console.error('[Dashboard] Lock file corrupted, attempting fresh claim');
+            try {
+                process.stderr.write('[Dashboard] Lock file corrupted, attempting fresh claim\n');
+            }
+            catch { }
             await promises_1.default.unlink(this.lockFile).catch(() => { });
             return await this.tryBecomePrimary();
         }
@@ -574,14 +606,34 @@ let HttpServer = class HttpServer {
     }
     printBanner() {
         const line = '═'.repeat(60);
-        console.error(`\n${line}`);
-        console.error(`🔧 Workrail MCP Server Started`);
-        console.error(line);
-        console.error(`📊 Dashboard: ${this.baseUrl} ${this.isPrimary ? '(PRIMARY - All Projects)' : '(Legacy Mode)'}`);
-        console.error(`💾 Sessions:  ${this.sessionManager.getSessionsRoot()}`);
-        console.error(`🏗️  Project:   ${this.sessionManager.getProjectId()}`);
-        console.error(line);
-        console.error();
+        try {
+            process.stderr.write(`\n${line}\n`);
+        }
+        catch { }
+        try {
+            process.stderr.write(`🔧 Workrail MCP Server Started\n`);
+        }
+        catch { }
+        try {
+            process.stderr.write(`${line}\n`);
+        }
+        catch { }
+        try {
+            process.stderr.write(`📊 Dashboard: ${this.baseUrl} ${this.isPrimary ? '(PRIMARY - All Projects)' : '(Legacy Mode)'}\n`);
+        }
+        catch { }
+        try {
+            process.stderr.write(`💾 Sessions:  ${this.sessionManager.getSessionsRoot()}\n`);
+        }
+        catch { }
+        try {
+            process.stderr.write(`🏗️  Project:   ${this.sessionManager.getProjectId()}\n`);
+        }
+        catch { }
+        try {
+            process.stderr.write(`${line}\n\n`);
+        }
+        catch { }
     }
     async openDashboard(sessionId) {
         if (!this.baseUrl) {

package/dist/manifest.json

@@ -246,8 +246,8 @@
       "bytes": 31
     },
     "cli.js": {
-      "sha256": "6d4c8dcb090ec7bdd765fdb855c1b39a9969ff854b9d37a363333cde7a75a1bb",
-      "bytes": 12273
+      "sha256": "d144366ebfb945c4947770899e2774516d594a085582ca3ee50a0cd46c081723",
+      "bytes": 13297
     },
     "cli/commands/cleanup.d.ts": {
       "sha256": "efe1f9e2ecd58e92007ed38b9581a3852c2babe4b3f2a97237dccd878eebe7ec",
@@ -429,12 +429,12 @@
       "sha256": "cf9d09641f1c31fffe6c7835b30bbbad52572befec1acab7fb9a0c188431af36",
       "bytes": 60355
     },
-    "console/assets/index-HhtarvD5.js": {
-      "sha256": "08f261e8ee93433485c04dfceb497517787ffa0c9e871415a7a0aca5d05fe731",
+    "console/assets/index-FtTaDku8.js": {
+      "sha256": "625240493d1fa1987817a5799b9f45244eac9e4c195a1a979c6be8c32e313eb2",
       "bytes": 754653
     },
     "console/index.html": {
-      "sha256": "c9d211c6ed52bc75fb22ae55d4e9bb349f22dcde4a03911603749fb0a68facdf",
+      "sha256": "293f13ff188d761de3d29dddb7ed9c6ff2e1fc804989b6c43f43c6aca7da7f13",
       "bytes": 417
     },
     "core/error-handler.d.ts": {
@@ -470,12 +470,12 @@
       "bytes": 1009
     },
     "daemon/workflow-runner.d.ts": {
-      "sha256": "31917d6322216bdb971c3023a9991d850a71bd25434846039e1024ed9983a22b",
-      "bytes": 2791
+      "sha256": "049d32530519c1a9b82959df91e144a6324b0b9dfe7b6ed507624c450cc2fb77",
+      "bytes": 3178
     },
     "daemon/workflow-runner.js": {
-      "sha256": "6dea8cd52c9e885b1b56a8c2485727e1a1db47c79912433514c37626209f780a",
-      "bytes": 29981
+      "sha256": "0243e7e779f08edf8258fd3946f815c0ff6cc4fd10eaa1511d358da31cbf1f68",
+      "bytes": 32730
     },
     "di/container.d.ts": {
       "sha256": "003bb7fb7478d627524b9b1e76bd0a963a243794a687ff233b96dc0e33a06d9f",
@@ -634,8 +634,8 @@
       "bytes": 2025
     },
     "infrastructure/session/HttpServer.js": {
-      "sha256": "cb3c733c5dfd4e998e0170d60e1689390454afdeb9c8a5838fd9af3a9da2fa56",
-      "bytes": 31241
+      "sha256": "914e38d3f9ed1264075d226e24e60a32d8a2f1d425631404873a1be62f067386",
+      "bytes": 32736
     },
     "infrastructure/session/SessionDataNormalizer.d.ts": {
       "sha256": "c89bb5e00d7d01fb4aa6d0095602541de53c425c6b99b67fa8367eb29cb63e9e",
@@ -762,8 +762,8 @@
       "bytes": 409
     },
     "mcp-server.js": {
-      "sha256": "1ab44bb05d75fe445fce6ea819c489e93e1d39ffedcd7a80c566e7085a0dd796",
-      "bytes": 3577
+      "sha256": "3445ca2f12e70a07ce693ed6efde67826ebab00f85716954def4ee82f86da0cd",
+      "bytes": 3668
     },
     "mcp/assert-output.d.ts": {
       "sha256": "f1b821c3652423b15a09d2d1c5a042ee565a503c3d7196bd8220fbe697e0dc75",
@@ -1122,8 +1122,8 @@
       "bytes": 960
     },
     "mcp/server.js": {
-      "sha256": "b60d150f98355033ef172a58e7c2b12f01848f0bbb4a2b633276791ffce96637",
-      "bytes": 16178
+      "sha256": "655e05345310422de6487e9f045e04c53266eb0c71d4a6482a605c67761eb25e",
+      "bytes": 16962
     },
     "mcp/step-content-envelope.d.ts": {
       "sha256": "19bd63c4d4de1d5d93393d346625d28ffd1bebdc320d4ba4e694cb740ec97d3b",
@@ -1174,36 +1174,36 @@
       "bytes": 8822
     },
     "mcp/transports/bridge-entry.d.ts": {
-      "sha256": "83be835fd6beba67c8eb6f1ec23a998599ca13008522dd472d443d824601bbbe",
-      "bytes": 2496
+      "sha256": "ba4c1df0691feeb79f4c7f9a8347807c86dbbb180cc4d5ba66740b6f8f216231",
+      "bytes": 3556
     },
     "mcp/transports/bridge-entry.js": {
-      "sha256": "e975252f9c7b9c79ad19f3f380eeae46f97d6b229a0f7130780c1620f85fea0a",
-      "bytes": 13220
+      "sha256": "f48e2c8700fec74daa5a9a47ab59143a44eba85ea938a408e2970029d53e23b5",
+      "bytes": 20196
     },
     "mcp/transports/bridge-events.d.ts": {
-      "sha256": "e0e8a7a8477e05840aa0d1a1e563c466d6c0c7af8d0a123b22a4338e0a18e32b",
-      "bytes": 879
+      "sha256": "ba4034309d5a4d762166c058079a9b461d0c403c5b329d2f5ee3bf4bd4f446e1",
+      "bytes": 1324
     },
     "mcp/transports/bridge-events.js": {
       "sha256": "40e0eeb42aec6fb2906ac3da1d9f017cb9b9de56125736d4e90667239c5f019b",
       "bytes": 955
     },
     "mcp/transports/fatal-exit.d.ts": {
-      "sha256": "c4a6fe6f17cab799577bd527e6bd6df404b01855de05b0edb9176a81cfa104db",
-      "bytes": 380
+      "sha256": "e51b420a4f4b9d21cff8c79180618fb0ee43d17f4fb402b1fa05d05e9cd0b4bc",
+      "bytes": 490
     },
     "mcp/transports/fatal-exit.js": {
-      "sha256": "519d281c8affd4672c4232ba8b718bb15d6a1ace214a9f6896d01e6092d0fe13",
-      "bytes": 2756
+      "sha256": "3b9f7b93cbb672b8491fd6fd73e4c799cccf7e51567edf0b9fc0faccbc1f41c8",
+      "bytes": 3593
     },
     "mcp/transports/http-entry.d.ts": {
       "sha256": "35d313b120dcf38643de9462559163581b89943fe432706986252e8b698b9507",
       "bytes": 70
     },
     "mcp/transports/http-entry.js": {
-      "sha256": "f070de7c59b9b33db9c1a04a289fb0f83852832e8370bd09bc57ee33ff2d37a9",
-      "bytes": 3477
+      "sha256": "31ab4e9f518e1f9b6fd46a8b7e221639029abea51e0cbfe22e5008fecdc46e6b",
+      "bytes": 3887
     },
     "mcp/transports/http-listener.d.ts": {
       "sha256": "6c6cd6dcfe110ed8fa1dc2f9c96caba55959555f98048d3694ac104f42d6d51a",
@@ -1213,21 +1213,29 @@
       "sha256": "d9b7deb9015e55b5b1e9b3e415b74a7fbbe8b6afb94bbd5a5f7957cd1a7f3f50",
       "bytes": 3534
     },
+    "mcp/transports/primary-tombstone.d.ts": {
+      "sha256": "b03c75684b5191752b9a0494a5a6c2b463e8dcf6d2d22d7e265cb6f94454513a",
+      "bytes": 891
+    },
+    "mcp/transports/primary-tombstone.js": {
+      "sha256": "faec43962d124e5a296ec1c4419693f33ea2c9fd25e26831bd9c486389001c74",
+      "bytes": 1545
+    },
     "mcp/transports/shutdown-hooks.d.ts": {
       "sha256": "abf3799e44183c8a7e3614e2f14c1d7c8c4bb4ce0b720d3005ee165e4dd6f211",
       "bytes": 547
     },
     "mcp/transports/shutdown-hooks.js": {
-      "sha256": "b44d0daaabfc4a896a910691637473d238127157f762743fec35625b6d12d4eb",
-      "bytes": 2701
+      "sha256": "e9b6261e223700d1d0d6253edff824c5ed6c42778afba2b18575b48923876e01",
+      "bytes": 3082
     },
     "mcp/transports/stdio-entry.d.ts": {
       "sha256": "4ced3c9e00ef67555781dea74315290eea8a9dbffd38155bc00c3fb07b0c1794",
       "bytes": 59
     },
     "mcp/transports/stdio-entry.js": {
-      "sha256": "2213a3989715b972806c5a28566e0cd3a92da580382c154025fd0b5e023a4f98",
-      "bytes": 3908
+      "sha256": "3acac4d05321d0bccb00aae61053b58327afc95bd4a05c1b2b4e853f774c036e",
+      "bytes": 4299
     },
     "mcp/transports/transport-mode.d.ts": {
       "sha256": "1c59128ab0174bd2a113fff17521e6339ca367f2b8980c2f2c164ec393c10518",
@@ -1493,6 +1501,14 @@
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
       "bytes": 77
     },
+    "trigger/daemon-console.d.ts": {
+      "sha256": "8c1dca4a4683e4a96a8dc007df556309da0d2a2076ff0981c3b80f148cb5b3ad",
+      "bytes": 937
+    },
+    "trigger/daemon-console.js": {
+      "sha256": "51056eff122fea677803e8f17f800aa94c03cc796210f8d2ef40e767710444d0",
+      "bytes": 5448
+    },
     "trigger/delivery-action.d.ts": {
       "sha256": "58109eaa7124d2864e1d872ff0148548932d2fa4d7e672f5fd83d4bbe40afdda",
       "bytes": 1188

package/dist/mcp/server.js

@@ -246,27 +246,43 @@ async function composeServer() {
         console.error('[PerfTrace] WORKRAIL_DEV=1 -- tool call timing active');
     }
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        const handlerStartMs = Date.now();
-        const handlerStartHr = performance.now();
-        const handler = handlers[name];
-        if (!handler) {
-            const unknownResult = {
-                content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        try {
+            const { name, arguments: args } = request.params;
+            const handlerStartMs = Date.now();
+            const handlerStartHr = performance.now();
+            const handler = handlers[name];
+            if (!handler) {
+                const unknownResult = {
+                    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+                const durationMs = Math.round((performance.now() - handlerStartHr) * 100) / 100;
+                try {
+                    timingSink({ toolName: name ?? '(unknown)', startedAtMs: handlerStartMs, durationMs, outcome: 'unknown_tool' });
+                }
+                catch {
+                }
+                return unknownResult;
+            }
+            const requestCtx = ctx.v2
+                ? { ...ctx, v2: { ...ctx.v2, resolvedRootUris: rootsManager.getCurrentRootUris() } }
+                : ctx;
+            return await (0, tool_call_timing_js_1.withToolCallTiming)(name, () => handler(args ?? {}, requestCtx), timingSink);
+        }
+        catch (err) {
+            process.stderr.write(`[WorkRail] Unhandled exception at CallTool boundary: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            code: 'INTERNAL_ERROR',
+                            message: 'WorkRail encountered an unexpected error. This is not caused by your input.',
+                            retry: { kind: 'retryable', suggestedDelayMs: 0 },
+                        }),
+                    }],
                 isError: true,
             };
-            const durationMs = Math.round((performance.now() - handlerStartHr) * 100) / 100;
-            try {
-                timingSink({ toolName: name ?? '(unknown)', startedAtMs: handlerStartMs, durationMs, outcome: 'unknown_tool' });
-            }
-            catch {
-            }
-            return unknownResult;
         }
-        const requestCtx = ctx.v2
-            ? { ...ctx, v2: { ...ctx.v2, resolvedRootUris: rootsManager.getCurrentRootUris() } }
-            : ctx;
-        return (0, tool_call_timing_js_1.withToolCallTiming)(name, () => handler(args ?? {}, requestCtx), timingSink);
     });
     server.setRequestHandler(ListResourcesRequestSchema, async () => ({
         resources: [

package/dist/mcp/transports/bridge-entry.d.ts

@@ -4,6 +4,8 @@ export interface BridgeConfig {
     readonly reconnectMaxAttempts: number;
     readonly forwardTimeoutMs: number;
     readonly maxRespawnAttempts: number;
+    readonly spawnLockStaleMs: number;
+    readonly waitForPrimaryPollMs: number;
 }
 export declare const DEFAULT_BRIDGE_CONFIG: BridgeConfig;
 type HttpBridgeTransport = {
@@ -20,6 +22,8 @@ export type ConnectionState = {
     readonly attempt: number;
     readonly maxAttempts: number;
     readonly respawnBudget: number;
+} | {
+    readonly kind: 'waiting_for_primary';
 } | {
     readonly kind: 'closed';
 };
@@ -30,6 +34,12 @@ export type ReconnectOutcome = {
 } | {
     readonly kind: 'aborted';
 };
+export type SpawnLockResult = {
+    readonly kind: 'acquired';
+} | {
+    readonly kind: 'skipped';
+    readonly reason: string;
+};
 export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
 export type SpawnLike = (command: string, args: ReadonlyArray<string>, opts: {
     readonly env: NodeJS.ProcessEnv;
@@ -38,11 +48,31 @@ export type SpawnLike = (command: string, args: ReadonlyArray<string>, opts: {
 }) => {
     unref: () => void;
 };
+export type WriteFileSyncLike = (path: string, content: string, opts: {
+    flag: 'wx';
+}) => void;
+export type StatSyncLike = (path: string) => {
+    mtimeMs: number;
+};
+export type UnlinkSyncLike = (path: string) => void;
+export type HealthResponse = {
+    readonly port: number;
+    readonly pid: number;
+};
 export declare function detectHealthyPrimary(port: number, opts?: {
     retries?: number;
     baseDelayMs?: number;
     fetch?: FetchLike;
-}): Promise<number | null>;
+}): Promise<HealthResponse | null>;
+export declare function spawnLockPath(port: number): string;
+export declare function acquireSpawnLock(port: number, staleMs: number, deps?: {
+    readonly writeFileSync?: WriteFileSyncLike;
+    readonly statSync?: StatSyncLike;
+    readonly unlinkSync?: UnlinkSyncLike;
+}): SpawnLockResult;
+export declare function releaseSpawnLock(port: number, deps?: {
+    readonly unlinkSync?: UnlinkSyncLike;
+}): void;
 export declare function spawnPrimary(port: number, deps: {
     spawn: SpawnLike;
     fetch?: FetchLike;
@@ -57,6 +87,7 @@ type OutcomeHandlerDeps = {
     readonly setConnectionState: (state: ConnectionState) => void;
     readonly performShutdown: (reason: string) => void;
     readonly startReconnectLoop: () => void;
+    readonly startWaitLoop: () => void;
     readonly triggerSpawn: () => Promise<void>;
     readonly config: Pick<BridgeConfig, 'reconnectMaxAttempts'>;
 };
@@ -66,5 +97,6 @@ export declare function handleReconnectOutcome(outcome: ReconnectOutcome, reconn
 export declare function startBridgeServer(primaryPort: number, config?: BridgeConfig, deps?: {
     spawn?: SpawnLike;
     fetch?: FetchLike;
+    originalPrimaryPid?: number;
 }): Promise<void>;
 export {};