@exaudeus/workrail 3.73.1 → 3.74.0

package/dist/trigger/coordinator-deps.js

@@ -45,6 +45,102 @@ const infra_js_1 = require("../context-assembly/infra.js");
 function createCoordinatorDeps(deps) {
     const { ctx, execFileAsync, consoleService } = deps;
     let dispatch = null;
+    async function fetchAgentResult(sessionHandle) {
+        const emptyResult = { recapMarkdown: null, artifacts: [] };
+        if (consoleService === null) {
+            return emptyResult;
+        }
+        try {
+            const detailResult = await consoleService.getSessionDetail(sessionHandle);
+            if (detailResult.isErr())
+                return emptyResult;
+            const run = detailResult.value.runs[0];
+            if (!run)
+                return emptyResult;
+            const tipNodeId = run.preferredTipNodeId;
+            if (!tipNodeId)
+                return emptyResult;
+            const allNodeIds = run.nodes
+                .map((n) => n.nodeId)
+                .filter((id) => typeof id === 'string' && id !== '');
+            const nodeIdsToFetch = allNodeIds.length > 0 ? allNodeIds : [tipNodeId];
+            let recap = null;
+            const collectedArtifacts = [];
+            for (const nodeId of nodeIdsToFetch) {
+                try {
+                    const nodeResult = await consoleService.getNodeDetail(sessionHandle, nodeId);
+                    if (nodeResult.isErr())
+                        continue;
+                    if (nodeId === tipNodeId)
+                        recap = nodeResult.value.recapMarkdown;
+                    if (nodeResult.value.artifacts.length > 0)
+                        collectedArtifacts.push(...nodeResult.value.artifacts);
+                }
+                catch {
+                    continue;
+                }
+            }
+            return { recapMarkdown: recap, artifacts: collectedArtifacts };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            process.stderr.write(`[WARN coord:reason=exception handle=${sessionHandle.slice(0, 16)}] fetchAgentResult: ${msg}\n`);
+            return emptyResult;
+        }
+    }
+    async function fetchChildSessionResult(handle, coordinatorSessionId) {
+        if (consoleService === null) {
+            process.stderr.write(`[WARN coord:reason=await_degraded handle=${handle.slice(0, 16)}${coordinatorSessionId ? ' parent=' + coordinatorSessionId.slice(0, 16) : ''}] fetchChildSessionResult: ConsoleService unavailable\n`);
+            return {
+                kind: 'await_degraded',
+                message: 'ConsoleService unavailable -- cannot read child session outcome',
+            };
+        }
+        let runStatus = null;
+        try {
+            const detailResult = await consoleService.getSessionDetail(handle);
+            if (detailResult.isErr()) {
+                process.stderr.write(`[WARN coord:reason=getSessionDetail_failed handle=${handle.slice(0, 16)}] fetchChildSessionResult: ${String(detailResult.error)}\n`);
+                return {
+                    kind: 'failed',
+                    reason: 'error',
+                    message: `Could not read session detail: ${String(detailResult.error)}`,
+                };
+            }
+            const run = detailResult.value.runs[0];
+            runStatus = run?.status ?? null;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            process.stderr.write(`[WARN coord:reason=exception handle=${handle.slice(0, 16)}] fetchChildSessionResult getSessionDetail: ${msg}\n`);
+            return { kind: 'failed', reason: 'error', message: `Exception reading session detail: ${msg}` };
+        }
+        if (runStatus === 'complete' || runStatus === 'complete_with_gaps') {
+            const agentResult = await fetchAgentResult(handle);
+            return {
+                kind: 'success',
+                notes: agentResult.recapMarkdown,
+                artifacts: agentResult.artifacts,
+            };
+        }
+        if (runStatus === 'blocked') {
+            return {
+                kind: 'failed',
+                reason: 'stuck',
+                message: `Child session ${handle.slice(0, 16)} reached blocked state`,
+            };
+        }
+        if (runStatus === null) {
+            return {
+                kind: 'timed_out',
+                message: `Child session ${handle.slice(0, 16)} has no terminal run status (likely timed out)`,
+            };
+        }
+        return {
+            kind: 'timed_out',
+            message: `Child session ${handle.slice(0, 16)} is still in state '${runStatus}' -- awaitSessions may not have been called`,
+        };
+    }
     return {
         setDispatch(fn) {
             if (dispatch !== null) {
@@ -53,11 +149,16 @@ function createCoordinatorDeps(deps) {
             }
             dispatch = fn;
         },
-        spawnSession: async (workflowId, goal, workspace, context, agentConfig) => {
+        spawnSession: async (workflowId, goal, workspace, context, agentConfig, parentSessionId) => {
             if (dispatch === null) {
                 return { kind: 'err', error: 'in-process router not initialized -- coordinator deps not ready' };
             }
-            const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId, workspacePath: workspace, goal }, ctx, { is_autonomous: 'true', workspacePath: workspace, triggerSource: 'daemon' });
+            const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId, workspacePath: workspace, goal }, ctx, {
+                is_autonomous: 'true',
+                workspacePath: workspace,
+                triggerSource: 'daemon',
+                ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+            });
             if (startResult.isErr()) {
                 const detail = `${startResult.error.kind}${'message' in startResult.error ? ': ' + startResult.error.message : ''}`;
                 return { kind: 'err', error: `Session creation failed: ${detail}` };
@@ -173,47 +274,113 @@ function createCoordinatorDeps(deps) {
             };
         },
         getAgentResult: async (sessionHandle) => {
-            const emptyResult = { recapMarkdown: null, artifacts: [] };
-            if (consoleService === null) {
-                return emptyResult;
+            return fetchAgentResult(sessionHandle);
+        },
+        getChildSessionResult: async (handle, coordinatorSessionId) => {
+            return fetchChildSessionResult(handle, coordinatorSessionId);
+        },
+        spawnAndAwait: async (workflowId, goal, workspace, opts) => {
+            const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+            const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const coordinatorSessionId = opts?.coordinatorSessionId;
+            const agentConfig = opts?.agentConfig;
+            if (dispatch === null) {
+                return {
+                    kind: 'failed',
+                    reason: 'error',
+                    message: 'spawnAndAwait: in-process router not initialized (setDispatch not called)',
+                };
             }
-            try {
-                const detailResult = await consoleService.getSessionDetail(sessionHandle);
-                if (detailResult.isErr())
-                    return emptyResult;
-                const run = detailResult.value.runs[0];
-                if (!run)
-                    return emptyResult;
-                const tipNodeId = run.preferredTipNodeId;
-                if (!tipNodeId)
-                    return emptyResult;
-                const allNodeIds = run.nodes.map((n) => n.nodeId).filter((id) => typeof id === 'string' && id !== '');
-                const nodeIdsToFetch = allNodeIds.length > 0 ? allNodeIds : [tipNodeId];
-                let recap = null;
-                const collectedArtifacts = [];
-                for (const nodeId of nodeIdsToFetch) {
-                    try {
-                        const nodeResult = await consoleService.getNodeDetail(sessionHandle, nodeId);
-                        if (nodeResult.isErr())
-                            continue;
-                        if (nodeId === tipNodeId) {
-                            recap = nodeResult.value.recapMarkdown;
+            const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId, workspacePath: workspace, goal }, ctx, {
+                is_autonomous: 'true',
+                workspacePath: workspace,
+                triggerSource: 'daemon',
+                ...(coordinatorSessionId !== undefined ? { parentSessionId: coordinatorSessionId } : {}),
+            });
+            if (startResult.isErr()) {
+                const detail = `${startResult.error.kind}${'message' in startResult.error ? ': ' + startResult.error.message : ''}`;
+                return { kind: 'failed', reason: 'error', message: `Session creation failed: ${detail}` };
+            }
+            const startContinueToken = startResult.value.response.continueToken;
+            let handle;
+            if (!startContinueToken) {
+                handle = workflowId;
+            }
+            else {
+                const tokenResult = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(startContinueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
+                if (tokenResult.isErr()) {
+                    return {
+                        kind: 'failed',
+                        reason: 'error',
+                        message: `Internal error: could not extract session handle from new session: ${tokenResult.error.message}`,
+                    };
+                }
+                handle = tokenResult.value.sessionId;
+                const trigger = {
+                    workflowId,
+                    goal,
+                    workspacePath: workspace,
+                    ...(agentConfig !== undefined ? { agentConfig } : {}),
+                };
+                const r = startResult.value.response;
+                const allocatedSession = {
+                    continueToken: r.continueToken ?? '',
+                    checkpointToken: r.checkpointToken,
+                    firstStepPrompt: r.pending?.prompt ?? '',
+                    isComplete: r.isComplete,
+                    triggerSource: 'daemon',
+                };
+                const source = {
+                    kind: 'pre_allocated',
+                    trigger,
+                    session: allocatedSession,
+                };
+                dispatch(trigger, source);
+            }
+            const awaitResult = await (async () => {
+                const POLL_INTERVAL_MS = 3000;
+                if (consoleService === null) {
+                    return null;
+                }
+                const startMs = Date.now();
+                const pending = new Set([handle]);
+                while (pending.size > 0) {
+                    const elapsed = Date.now() - startMs;
+                    if (elapsed >= timeoutMs)
+                        break;
+                    for (const h of [...pending]) {
+                        try {
+                            const detail = await consoleService.getSessionDetail(h);
+                            if (detail.isErr())
+                                continue;
+                            const run = detail.value.runs[0];
+                            if (!run)
+                                continue;
+                            const status = run.status;
+                            if (status === 'complete' || status === 'complete_with_gaps') {
+                                pending.delete(h);
+                            }
+                            else if (status === 'blocked') {
+                                pending.delete(h);
+                            }
                         }
-                        if (nodeResult.value.artifacts.length > 0) {
-                            collectedArtifacts.push(...nodeResult.value.artifacts);
+                        catch {
+                            pending.delete(h);
                         }
                     }
-                    catch {
-                        continue;
+                    if (pending.size > 0) {
+                        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
                     }
                 }
-                return { recapMarkdown: recap, artifacts: collectedArtifacts };
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                process.stderr.write(`[WARN coord:reason=exception handle=${sessionHandle.slice(0, 16)}] getAgentResult: ${msg}\n`);
-                return emptyResult;
+                return handle;
+            })();
+            if (awaitResult === null) {
+                return {
+                    kind: 'await_degraded',
+                    message: 'ConsoleService unavailable -- cannot await child session outcome',
+                };
             }
+            return fetchChildSessionResult(handle, coordinatorSessionId);
         },
         listOpenPRs: async (workspace) => {
             try {

package/dist/trigger/delivery-action.d.ts

@@ -27,6 +27,7 @@ export type DeliveryResult = {
 } | {
     readonly _tag: 'pr_opened';
     readonly url: string;
+    readonly sha: string;
 } | {
     readonly _tag: 'skipped';
     readonly reason: string;

package/dist/trigger/delivery-action.js

@@ -342,7 +342,7 @@ async function runDelivery(artifact, workspacePath, flags, execFn) {
         });
     }
     const prUrl = prStdout.trim().split('\n').at(-1)?.trim() ?? '';
-    return { _tag: 'pr_opened', url: prUrl };
+    return { _tag: 'pr_opened', url: prUrl, sha };
 }
 function formatExecError(e) {
     if (e instanceof Error) {

package/dist/trigger/delivery-pipeline.d.ts

@@ -1,6 +1,8 @@
 import type { WorkflowRunSuccess } from '../daemon/workflow-runner.js';
 import type { TriggerDefinition } from './types.js';
 import type { ExecFn, HandoffArtifact } from './delivery-action.js';
+import type { ExecutionSessionGateV2 } from '../v2/usecases/execution-session-gate.js';
+import type { SessionEventLogAppendStorePortV2 } from '../v2/ports/session-event-log-store.port.js';
 export type DeliveryStageOutcome = {
     readonly kind: 'continue';
 } | {
@@ -9,10 +11,19 @@ export type DeliveryStageOutcome = {
 };
 export interface DeliveryStage {
     readonly name: string;
-    run(result: WorkflowRunSuccess, trigger: TriggerDefinition, execFn: ExecFn, ctx: PipelineContext): Promise<DeliveryStageOutcome>;
+    run(result: WorkflowRunSuccess, trigger: TriggerDefinition, execFn: ExecFn, ctx: PipelineContext, deps?: DeliveryPipelineDeps): Promise<DeliveryStageOutcome>;
 }
 export interface PipelineContext {
     handoffArtifact?: HandoffArtifact;
+    commitSha?: string;
+    prUrl?: string;
 }
-export declare function runDeliveryPipeline(stages: readonly DeliveryStage[], result: WorkflowRunSuccess, trigger: TriggerDefinition, execFn: ExecFn, triggerId: string): Promise<void>;
+export interface DeliveryPipelineDeps {
+    readonly gate: ExecutionSessionGateV2;
+    readonly sessionStore: SessionEventLogAppendStorePortV2 & import('../v2/ports/session-event-log-store.port.js').SessionEventLogReadonlyStorePortV2;
+    readonly idFactory: {
+        readonly mintEventId: () => string;
+    };
+}
+export declare function runDeliveryPipeline(stages: readonly DeliveryStage[], result: WorkflowRunSuccess, trigger: TriggerDefinition, execFn: ExecFn, triggerId: string, deps?: DeliveryPipelineDeps): Promise<void>;
 export declare const DEFAULT_DELIVERY_PIPELINE: readonly DeliveryStage[];

package/dist/trigger/delivery-pipeline.js

@@ -39,11 +39,16 @@ const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const workflow_runner_js_1 = require("../daemon/workflow-runner.js");
 const delivery_action_js_1 = require("./delivery-action.js");
-async function runDeliveryPipeline(stages, result, trigger, execFn, triggerId) {
+const constants_js_1 = require("../v2/durable-core/constants.js");
+const index_js_1 = require("../v2/durable-core/ids/index.js");
+const session_index_js_1 = require("../v2/durable-core/session-index.js");
+const sorted_event_log_js_1 = require("../v2/durable-core/sorted-event-log.js");
+const neverthrow_1 = require("neverthrow");
+async function runDeliveryPipeline(stages, result, trigger, execFn, triggerId, deps) {
     const ctx = {};
     try {
         for (const stage of stages) {
-            const outcome = await stage.run(result, trigger, execFn, ctx);
+            const outcome = await stage.run(result, trigger, execFn, ctx, deps);
             if (outcome.kind === 'stop') {
                 console.log(`[DeliveryPipeline] Stage "${stage.name}" stopped pipeline: triggerId=${triggerId} reason=${outcome.reason}`);
                 return;
@@ -96,9 +101,12 @@ const gitDeliveryStage = {
         switch (deliveryResult._tag) {
             case 'committed':
                 console.log(`[DeliveryPipeline] Delivery committed: triggerId=${trigger.id} sha=${deliveryResult.sha}`);
+                ctx.commitSha = deliveryResult.sha;
                 break;
             case 'pr_opened':
-                console.log(`[DeliveryPipeline] Delivery PR opened: triggerId=${trigger.id} url=${deliveryResult.url}`);
+                console.log(`[DeliveryPipeline] Delivery PR opened: triggerId=${trigger.id} url=${deliveryResult.url} sha=${deliveryResult.sha}`);
+                ctx.commitSha = deliveryResult.sha;
+                ctx.prUrl = deliveryResult.url;
                 break;
             case 'skipped':
                 console.log(`[DeliveryPipeline] Delivery skipped: triggerId=${trigger.id} reason=${deliveryResult.reason}`);
@@ -111,6 +119,52 @@ const gitDeliveryStage = {
         return { kind: 'continue' };
     },
 };
+const recordCommitShasStage = {
+    name: 'recordCommitShas',
+    async run(result, _trigger, _execFn, ctx, deps) {
+        const { sessionId } = result;
+        if (!sessionId || !ctx.commitSha || !deps) {
+            return { kind: 'continue' };
+        }
+        try {
+            const sid = (0, index_js_1.asSessionId)(sessionId);
+            const shas = [ctx.commitSha];
+            const prUrl = ctx.prUrl;
+            await deps.gate.withHealthySessionLock(sid, (lock) => deps.sessionStore.load(sid).andThen((truth) => {
+                const sortedResult = (0, sorted_event_log_js_1.asSortedEventLog)(truth.events);
+                if (sortedResult.isErr()) {
+                    return (0, neverthrow_1.okAsync)(undefined);
+                }
+                const index = (0, session_index_js_1.buildSessionIndex)(sortedResult.value);
+                const runCompleted = truth.events.find(e => e.kind === 'run_completed');
+                const runId = runCompleted?.scope.runId;
+                if (!runId) {
+                    return (0, neverthrow_1.okAsync)(undefined);
+                }
+                const event = {
+                    v: 1,
+                    eventId: deps.idFactory.mintEventId(),
+                    eventIndex: index.nextEventIndex,
+                    sessionId,
+                    kind: constants_js_1.EVENT_KIND.DELIVERY_RECORDED,
+                    dedupeKey: `delivery-recorded:${sessionId}:${runId}`,
+                    scope: { runId },
+                    data: { shas, ...(prUrl ? { prUrl } : {}) },
+                    timestampMs: Date.now(),
+                };
+                return deps.sessionStore.append(lock, { events: [event], snapshotPins: [] });
+            })).match(() => {
+                console.log(`[DeliveryPipeline] Commit SHAs recorded: sessionId=${sessionId} shas=${shas.join(',')}`);
+            }, (err) => {
+                console.warn(`[DeliveryPipeline] Could not record commit SHAs: sessionId=${sessionId} err=${JSON.stringify(err)}`);
+            });
+        }
+        catch (err) {
+            console.warn(`[DeliveryPipeline] Unexpected error in recordCommitShasStage: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { kind: 'continue' };
+    },
+};
 const cleanupWorktreeStage = {
     name: 'cleanupWorktree',
     async run(result, trigger, execFn, _ctx) {
@@ -143,6 +197,7 @@ const deleteSidecarStage = {
 exports.DEFAULT_DELIVERY_PIPELINE = [
     parseHandoffStage,
     gitDeliveryStage,
+    recordCommitShasStage,
     cleanupWorktreeStage,
     deleteSidecarStage,
 ];

package/dist/trigger/trigger-router.js

@@ -118,7 +118,7 @@ function validateHmac(rawBody, secret, headerValue) {
     }
     return crypto.timingSafeEqual(Buffer.from(expected, 'utf8'), Buffer.from(received, 'utf8'));
 }
-async function maybeRunDelivery(triggerId, trigger, result, execFn) {
+async function maybeRunDelivery(triggerId, trigger, result, execFn, deps) {
     if (result._tag !== 'success')
         return;
     if (result.lastStepNotes === undefined) {
@@ -131,7 +131,7 @@ async function maybeRunDelivery(triggerId, trigger, result, execFn) {
     }
     if (trigger.autoCommit !== true)
         return;
-    await (0, delivery_pipeline_js_1.runDeliveryPipeline)(delivery_pipeline_js_1.DEFAULT_DELIVERY_PIPELINE, result, trigger, execFn, triggerId);
+    await (0, delivery_pipeline_js_1.runDeliveryPipeline)(delivery_pipeline_js_1.DEFAULT_DELIVERY_PIPELINE, result, trigger, execFn, triggerId, deps);
 }
 class Semaphore {
     constructor(max) {
@@ -340,7 +340,10 @@ class TriggerRouter {
                 (0, assert_never_js_1.assertNever)(result);
             }
             this.notificationService?.notify(result, workflowTrigger.goal);
-            await maybeRunDelivery(trigger.id, trigger, originalResult, this.execFn);
+            const deliveryDeps = this.ctx.v2
+                ? { gate: this.ctx.v2.gate, sessionStore: this.ctx.v2.sessionStore, idFactory: this.ctx.v2.idFactory }
+                : undefined;
+            await maybeRunDelivery(trigger.id, trigger, originalResult, this.execFn, deliveryDeps);
         });
         return { _tag: 'enqueued', triggerId: trigger.id };
     }

package/dist/v2/durable-core/constants.d.ts

@@ -38,6 +38,7 @@ export declare const EVENT_KIND: {
     readonly DIVERGENCE_RECORDED: "divergence_recorded";
     readonly DECISION_TRACE_APPENDED: "decision_trace_appended";
     readonly RUN_COMPLETED: "run_completed";
+    readonly DELIVERY_RECORDED: "delivery_recorded";
 };
 export type EventKindV1 = typeof EVENT_KIND[keyof typeof EVENT_KIND];
 export declare const OUTPUT_CHANNEL: {

package/dist/v2/durable-core/constants.js

@@ -41,6 +41,7 @@ exports.EVENT_KIND = {
     DIVERGENCE_RECORDED: 'divergence_recorded',
     DECISION_TRACE_APPENDED: 'decision_trace_appended',
     RUN_COMPLETED: 'run_completed',
+    DELIVERY_RECORDED: 'delivery_recorded',
 };
 exports.OUTPUT_CHANNEL = {
     RECAP: 'recap',