@atolis-hq/wake 0.2.46 → 0.2.47

package/dist/src/adapters/claude/claude-runner.js

@@ -3,6 +3,7 @@ import { runAgentCliCommand } from '../runner/cli-command.js';
 import { buildStagePrompt } from '../runner/stage-prompt.js';
 import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
 import { writeRunnerTranscript } from '../runner/transcripts.js';
+import { createAgentExecution } from '../../core/live-execution.js';
 export { buildStagePrompt } from '../runner/stage-prompt.js';
 function slugify(value, maxLength = 40) {
     return value
@@ -152,182 +153,109 @@ function readSandboxLogBreadcrumb() {
     };
 }
 export function createClaudeRunner(options) {
-    return {
-        async run(input) {
-            const sessionName = buildWakeSessionName({
-                sessionName: options.settings.sessionName,
-                issueNumber: input.projection.issue.number,
-                title: input.projection.issue.title,
-                runId: input.runId,
-            });
-            // Resume an in-progress session when the projection carries a session ID
-            // that was created by this same CLI. This happens when the previous run
-            // ended with BLOCKED and the same action is being retried after a human
-            // reply. Any forward-stage transition or FAILED run clears the stored
-            // session ID so that the next action always starts fresh.
-            const priorSessionId = input.projection.wake.sessionId;
-            const priorSessionCli = input.projection.wake.sessionCli;
-            const isResume = priorSessionId !== undefined && priorSessionCli === CLAUDE_CLI_NAME;
-            const stagePrompt = await buildStagePrompt({
-                action: input.action,
-                projection: input.projection,
-                mode: isResume ? 'resume' : 'start',
-                config: input.config,
-                ...(input.promptContextOverrides === undefined
-                    ? {}
-                    : { contextOverrides: input.promptContextOverrides }),
-                ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
-                ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
-            });
-            const model = resolveModel({
-                action: input.action,
-                settings: options.settings,
-            });
-            const args = buildClaudePrintArgs({
-                model,
-                prompt: stagePrompt.prompt,
-                systemPrompt: stagePrompt.harnessPrompt,
-                sessionName,
-                allowedTools: stagePrompt.allowedTools,
-                extraArgs: stagePrompt.extraArgs,
-                maxTurns: stagePrompt.maxTurns,
-                ...(stagePrompt.permissionMode === undefined
-                    ? {}
-                    : { permissionMode: stagePrompt.permissionMode }),
-                ...(options.settings.remoteControl.enabled ? { remoteControlName: sessionName } : {}),
-                ...(options.settings.effort === undefined ? {} : { effort: options.settings.effort }),
-                ...(isResume ? { resumeSessionId: priorSessionId } : {}),
-            });
-            const promptTranscriptPath = await writeRunnerTranscript({
-                config: input.config,
-                projection: input.projection,
-                runId: input.runId,
-                action: input.action,
-                cli: CLAUDE_CLI_NAME,
-                kind: 'prompt',
-                text: stagePrompt.prompt,
-            });
-            console.log(formatClaudeRunLogLine({
-                phase: 'start',
-                runId: input.runId,
-                action: input.action,
-                issueNumber: input.projection.issue.number,
-                repo: input.projection.issue.repo,
-                recentEventIds: input.recentEvents.map((event) => event.eventId),
-                model,
-                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-            }));
-            const result = await runClaudeCommand({
-                command: options.command,
-                args,
-                cwd: input.workspacePath ?? options.cwd,
-                timeoutMs: options.settings.timeoutMs,
-                onProcessStart: async (identity) => {
-                    await input.onProcessStart?.(identity);
-                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                        type: 'agent.process.started',
-                        runId: input.runId,
-                        projection: input.projection,
-                        routing: input.routing,
-                        cli: CLAUDE_CLI_NAME,
-                        model,
-                        payload: { pid: identity.pid, processStartedAt: identity.processStartedAt },
-                    }));
-                },
-            });
-            const responseTranscriptPath = await writeRunnerTranscript({
-                config: input.config,
-                projection: input.projection,
-                runId: input.runId,
-                action: input.action,
-                cli: CLAUDE_CLI_NAME,
-                kind: 'response',
-                text: result.stdout,
-            });
-            if (result.exitCode !== 0 || result.timedOut || result.stdout.trim().length === 0) {
-                const sandboxLog = readSandboxLogBreadcrumb();
-                const failureClass = classifyClaudeCliFailure({
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    timedOut: result.timedOut,
-                });
-                console.error(formatClaudeRunLogLine({
-                    phase: 'failure',
-                    runId: input.runId,
-                    action: input.action,
-                    issueNumber: input.projection.issue.number,
-                    repo: input.projection.issue.repo,
-                    recentEventIds: input.recentEvents.map((event) => event.eventId),
-                    model,
-                    ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                    exitCode: result.exitCode,
-                }));
+    async function executeRun(input) {
+        const sessionName = buildWakeSessionName({
+            sessionName: options.settings.sessionName,
+            issueNumber: input.projection.issue.number,
+            title: input.projection.issue.title,
+            runId: input.runId,
+        });
+        // Resume an in-progress session when the projection carries a session ID
+        // that was created by this same CLI. This happens when the previous run
+        // ended with BLOCKED and the same action is being retried after a human
+        // reply. Any forward-stage transition or FAILED run clears the stored
+        // session ID so that the next action always starts fresh.
+        const priorSessionId = input.projection.wake.sessionId;
+        const priorSessionCli = input.projection.wake.sessionCli;
+        const isResume = priorSessionId !== undefined && priorSessionCli === CLAUDE_CLI_NAME;
+        const stagePrompt = await buildStagePrompt({
+            action: input.action,
+            projection: input.projection,
+            mode: isResume ? 'resume' : 'start',
+            config: input.config,
+            ...(input.promptContextOverrides === undefined
+                ? {}
+                : { contextOverrides: input.promptContextOverrides }),
+            ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
+            ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
+        });
+        const model = resolveModel({
+            action: input.action,
+            settings: options.settings,
+        });
+        const args = buildClaudePrintArgs({
+            model,
+            prompt: stagePrompt.prompt,
+            systemPrompt: stagePrompt.harnessPrompt,
+            sessionName,
+            allowedTools: stagePrompt.allowedTools,
+            extraArgs: stagePrompt.extraArgs,
+            maxTurns: stagePrompt.maxTurns,
+            ...(stagePrompt.permissionMode === undefined
+                ? {}
+                : { permissionMode: stagePrompt.permissionMode }),
+            ...(options.settings.remoteControl.enabled ? { remoteControlName: sessionName } : {}),
+            ...(options.settings.effort === undefined ? {} : { effort: options.settings.effort }),
+            ...(isResume ? { resumeSessionId: priorSessionId } : {}),
+        });
+        const promptTranscriptPath = await writeRunnerTranscript({
+            config: input.config,
+            projection: input.projection,
+            runId: input.runId,
+            action: input.action,
+            cli: CLAUDE_CLI_NAME,
+            kind: 'prompt',
+            text: stagePrompt.prompt,
+        });
+        console.log(formatClaudeRunLogLine({
+            phase: 'start',
+            runId: input.runId,
+            action: input.action,
+            issueNumber: input.projection.issue.number,
+            repo: input.projection.issue.repo,
+            recentEventIds: input.recentEvents.map((event) => event.eventId),
+            model,
+            ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
+        }));
+        const result = await runClaudeCommand({
+            command: options.command,
+            args,
+            cwd: input.workspacePath ?? options.cwd,
+            timeoutMs: options.settings.timeoutMs,
+            ...(input.cancellationSignal === undefined
+                ? {}
+                : { cancellationSignal: input.cancellationSignal }),
+            onProcessStart: async (identity) => {
+                await input.onProcessStart?.(identity);
                 await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                    type: 'agent.process.exited',
+                    type: 'agent.process.started',
                     runId: input.runId,
                     projection: input.projection,
                     routing: input.routing,
                     cli: CLAUDE_CLI_NAME,
                     model,
-                    payload: { exitCode: result.exitCode, timedOut: result.timedOut },
+                    payload: { pid: identity.pid, processStartedAt: identity.processStartedAt },
                 }));
-                let parsedReason;
-                let stdoutFailureDetail;
-                const trimmedStdout = result.stdout.trim();
-                try {
-                    if (trimmedStdout.length > 0) {
-                        parsedReason = parseClaudePrintOutput(result.stdout).result;
-                    }
-                }
-                catch {
-                    // stdout wasn't valid JSON, so it is likely a CLI-level error
-                    // message rather than a Claude print result.
-                    stdoutFailureDetail = trimmedStdout;
-                }
-                return {
-                    result: [
-                        result.timedOut
-                            ? `Claude runner timed out after ${options.settings.timeoutMs}ms and was killed`
-                            : trimmedStdout.length === 0
-                                ? 'Claude runner produced no output'
-                                : parsedReason !== undefined
-                                    ? `Claude runner failed: ${parsedReason}`
-                                    : 'Claude runner failed',
-                        result.stderr,
-                        stdoutFailureDetail,
-                        sandboxLog?.text,
-                        'FAILED',
-                    ]
-                        .filter((part) => part !== undefined && part.length > 0)
-                        .join('\n'),
-                    model,
-                    cli: CLAUDE_CLI_NAME,
-                    failureClass,
-                    metadata: {
-                        stdout: result.stdout,
-                        stderr: result.stderr,
-                        exitCode: result.exitCode,
-                        failureClass,
-                        ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
-                        ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
-                        ...(sandboxLog?.metadata ?? {}),
-                    },
-                };
-            }
-            const parsed = parseClaudePrintOutput(result.stdout);
+            },
+        });
+        const responseTranscriptPath = await writeRunnerTranscript({
+            config: input.config,
+            projection: input.projection,
+            runId: input.runId,
+            action: input.action,
+            cli: CLAUDE_CLI_NAME,
+            kind: 'response',
+            text: result.stdout,
+        });
+        if (result.exitCode !== 0 || result.timedOut || result.stdout.trim().length === 0) {
             const sandboxLog = readSandboxLogBreadcrumb();
-            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                type: 'agent.progress',
-                runId: input.runId,
-                projection: input.projection,
-                routing: input.routing,
-                cli: CLAUDE_CLI_NAME,
-                model,
-                ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
-                payload: { message: 'Claude print result received', raw: parsed },
-            }));
-            console.log(formatClaudeRunLogLine({
-                phase: 'success',
+            const failureClass = classifyClaudeCliFailure({
+                stdout: result.stdout,
+                stderr: result.stderr,
+                timedOut: result.timedOut,
+            });
+            console.error(formatClaudeRunLogLine({
+                phase: 'failure',
                 runId: input.runId,
                 action: input.action,
                 issueNumber: input.projection.issue.number,
@@ -335,21 +263,8 @@ export function createClaudeRunner(options) {
                 recentEventIds: input.recentEvents.map((event) => event.eventId),
                 model,
                 ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-                ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
+                exitCode: result.exitCode,
             }));
-            const tokenUsage = extractTokenUsage(parsed);
-            if (tokenUsage !== undefined) {
-                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
-                    type: 'agent.usage.updated',
-                    runId: input.runId,
-                    projection: input.projection,
-                    routing: input.routing,
-                    cli: CLAUDE_CLI_NAME,
-                    model,
-                    ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
-                    payload: { tokenUsage },
-                }));
-            }
             await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
                 type: 'agent.process.exited',
                 runId: input.runId,
@@ -357,29 +272,124 @@ export function createClaudeRunner(options) {
                 routing: input.routing,
                 cli: CLAUDE_CLI_NAME,
                 model,
-                ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
                 payload: { exitCode: result.exitCode, timedOut: result.timedOut },
             }));
+            let parsedReason;
+            let stdoutFailureDetail;
+            const trimmedStdout = result.stdout.trim();
+            try {
+                if (trimmedStdout.length > 0) {
+                    parsedReason = parseClaudePrintOutput(result.stdout).result;
+                }
+            }
+            catch {
+                // stdout wasn't valid JSON, so it is likely a CLI-level error
+                // message rather than a Claude print result.
+                stdoutFailureDetail = trimmedStdout;
+            }
             return {
-                result: parsed.result,
+                result: [
+                    result.timedOut
+                        ? `Claude runner timed out after ${options.settings.timeoutMs}ms and was killed`
+                        : trimmedStdout.length === 0
+                            ? 'Claude runner produced no output'
+                            : parsedReason !== undefined
+                                ? `Claude runner failed: ${parsedReason}`
+                                : 'Claude runner failed',
+                    result.stderr,
+                    stdoutFailureDetail,
+                    sandboxLog?.text,
+                    'FAILED',
+                ]
+                    .filter((part) => part !== undefined && part.length > 0)
+                    .join('\n'),
                 model,
                 cli: CLAUDE_CLI_NAME,
-                ...(parseRunnerResult(parsed.result).status === 'FAILED'
-                    ? { failureClass: 'task' }
-                    : {}),
-                ...(parsed.session_id === undefined ? {} : { session_id: parsed.session_id }),
-                ...(tokenUsage === undefined ? {} : { tokenUsage }),
+                failureClass,
                 metadata: {
                     stdout: result.stdout,
                     stderr: result.stderr,
-                    raw: parsed,
-                    skipApproval: stagePrompt.skipApproval,
-                    allowAutoApproval: stagePrompt.allowAutoApproval,
+                    exitCode: result.exitCode,
+                    failureClass,
                     ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
                     ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
                     ...(sandboxLog?.metadata ?? {}),
                 },
             };
+        }
+        const parsed = parseClaudePrintOutput(result.stdout);
+        const sandboxLog = readSandboxLogBreadcrumb();
+        await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+            type: 'agent.progress',
+            runId: input.runId,
+            projection: input.projection,
+            routing: input.routing,
+            cli: CLAUDE_CLI_NAME,
+            model,
+            ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
+            payload: { message: 'Claude print result received', raw: parsed },
+        }));
+        console.log(formatClaudeRunLogLine({
+            phase: 'success',
+            runId: input.runId,
+            action: input.action,
+            issueNumber: input.projection.issue.number,
+            repo: input.projection.issue.repo,
+            recentEventIds: input.recentEvents.map((event) => event.eventId),
+            model,
+            ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
+            ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
+        }));
+        const tokenUsage = extractTokenUsage(parsed);
+        if (tokenUsage !== undefined) {
+            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                type: 'agent.usage.updated',
+                runId: input.runId,
+                projection: input.projection,
+                routing: input.routing,
+                cli: CLAUDE_CLI_NAME,
+                model,
+                ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
+                payload: { tokenUsage },
+            }));
+        }
+        await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+            type: 'agent.process.exited',
+            runId: input.runId,
+            projection: input.projection,
+            routing: input.routing,
+            cli: CLAUDE_CLI_NAME,
+            model,
+            ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
+            payload: { exitCode: result.exitCode, timedOut: result.timedOut },
+        }));
+        return {
+            result: parsed.result,
+            model,
+            cli: CLAUDE_CLI_NAME,
+            ...(parseRunnerResult(parsed.result).status === 'FAILED'
+                ? { failureClass: 'task' }
+                : {}),
+            ...(parsed.session_id === undefined ? {} : { session_id: parsed.session_id }),
+            ...(tokenUsage === undefined ? {} : { tokenUsage }),
+            metadata: {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                raw: parsed,
+                skipApproval: stagePrompt.skipApproval,
+                allowAutoApproval: stagePrompt.allowAutoApproval,
+                ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
+                ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
+                ...(sandboxLog?.metadata ?? {}),
+            },
+        };
+    }
+    return {
+        async start(input) {
+            return createAgentExecution(input, executeRun);
+        },
+        async run(input) {
+            return (await this.start(input)).result;
         },
         async smoke() {
             const args = buildClaudePrintArgs({

package/dist/src/adapters/codex/codex-runner.js

@@ -2,6 +2,7 @@ import { buildStagePrompt } from '../runner/stage-prompt.js';
 import { runAgentCliCommand } from '../runner/cli-command.js';
 import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
 import { writeRunnerTranscript } from '../runner/transcripts.js';
+import { createAgentExecution } from '../../core/live-execution.js';
 import { parseRunnerResult } from '../../domain/schema.js';
 const CODEX_CLI_NAME = 'Codex';
 export function buildCodexExecArgs(input) {
@@ -201,7 +202,10 @@ export function buildCodexToolCapabilityNote(input) {
     return input.mode === 'resume' ? `Reminder: this is still a planning-only stage. ${note}` : note;
 }
 export function createCodexRunner(options) {
-    return {
+    const runner = {
+        async start(input) {
+            return createAgentExecution(input, (liveInput) => runner.run(liveInput));
+        },
         async run(input) {
             const runMode = 'start';
             const toolCapabilityNote = buildCodexToolCapabilityNote({
@@ -269,6 +273,9 @@ export function createCodexRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.cancellationSignal === undefined
+                    ? {}
+                    : { cancellationSignal: input.cancellationSignal }),
                 onProcessStart: async (identity) => {
                     await input.onProcessStart?.(identity);
                     await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
@@ -474,4 +481,5 @@ export function createCodexRunner(options) {
             };
         },
     };
+    return runner;
 }

package/dist/src/adapters/cursor/cursor-runner.js

@@ -3,6 +3,7 @@ import { buildStagePrompt } from '../runner/stage-prompt.js';
 import { runAgentCliCommand } from '../runner/cli-command.js';
 import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
 import { writeRunnerTranscript } from '../runner/transcripts.js';
+import { createAgentExecution } from '../../core/live-execution.js';
 const CURSOR_CLI_NAME = 'Cursor';
 export function buildCursorAgentArgs(input) {
     const fullPrompt = buildCursorPromptText(input);
@@ -154,7 +155,10 @@ function readSandboxLogBreadcrumb() {
     };
 }
 export function createCursorRunner(options) {
-    return {
+    const runner = {
+        async start(input) {
+            return createAgentExecution(input, (liveInput) => runner.run(liveInput));
+        },
         async run(input) {
             const priorSessionId = input.projection.wake.sessionId;
             const priorSessionCli = input.projection.wake.sessionCli;
@@ -220,6 +224,9 @@ export function createCursorRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
+                ...(input.cancellationSignal === undefined
+                    ? {}
+                    : { cancellationSignal: input.cancellationSignal }),
                 onProcessStart: async (identity) => {
                     await input.onProcessStart?.(identity);
                     await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
@@ -412,4 +419,5 @@ export function createCursorRunner(options) {
             };
         },
     };
+    return runner;
 }

package/dist/src/adapters/fake/fake-runner.js

@@ -1,8 +1,22 @@
 import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
+import { createAgentExecution } from '../../core/live-execution.js';
 export function createFakeRunner(result, options) {
-    return {
+    const runner = {
+        async start(input) {
+            return createAgentExecution(input, (liveInput) => runner.run(liveInput));
+        },
         async run(_) {
             const cli = options?.cli ?? 'Fake';
+            const isCanceled = () => _.cancellationSignal?.aborted === true;
+            if (isCanceled()) {
+                return {
+                    result: 'Fake runner canceled\nFAILED',
+                    model: 'fake',
+                    cli,
+                    failureClass: 'infra',
+                    metadata: { source: 'fake-runner', canceled: true },
+                };
+            }
             await emitRuntimeEvent(_.onRuntimeEvent, runnerRuntimeEvent({
                 type: 'agent.process.started',
                 runId: _.runId,
@@ -32,6 +46,15 @@ export function createFakeRunner(result, options) {
                 sessionId: 'fake-session-1',
                 payload: { exitCode: 0, synthetic: true },
             }));
+            if (isCanceled()) {
+                return {
+                    result: 'Fake runner canceled\nFAILED',
+                    model: 'fake',
+                    cli,
+                    failureClass: 'infra',
+                    metadata: { source: 'fake-runner', canceled: true },
+                };
+            }
             return (result ?? {
                 result: [
                     'Fake runner completed',
@@ -50,4 +73,5 @@ export function createFakeRunner(result, options) {
             });
         },
     };
+    return runner;
 }

package/dist/src/adapters/runner/cli-command.js

@@ -11,6 +11,7 @@ export function runAgentCliCommand(input) {
         let stdout = '';
         let stderr = '';
         let timedOut = false;
+        let canceled = false;
         let killTimer;
         let startNotification = Promise.resolve();
         let startNotificationError;
@@ -22,13 +23,24 @@ export function runAgentCliCommand(input) {
                 });
             }
         }
+        const terminate = () => {
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => child.kill('SIGKILL'), TIMEOUT_KILL_GRACE_MS);
+        };
         const timeoutTimer = input.timeoutMs === undefined
             ? undefined
             : setTimeout(() => {
                 timedOut = true;
-                child.kill('SIGTERM');
-                killTimer = setTimeout(() => child.kill('SIGKILL'), TIMEOUT_KILL_GRACE_MS);
+                terminate();
             }, input.timeoutMs);
+        const abortListener = () => {
+            canceled = true;
+            terminate();
+        };
+        input.cancellationSignal?.addEventListener('abort', abortListener, { once: true });
+        if (input.cancellationSignal?.aborted === true) {
+            abortListener();
+        }
         child.stdout.on('data', (chunk) => {
             stdout += chunk.toString();
         });
@@ -38,11 +50,13 @@ export function runAgentCliCommand(input) {
         child.on('error', (error) => {
             clearTimeout(timeoutTimer);
             clearTimeout(killTimer);
+            input.cancellationSignal?.removeEventListener('abort', abortListener);
             reject(error);
         });
         child.on('close', async (exitCode) => {
             clearTimeout(timeoutTimer);
             clearTimeout(killTimer);
+            input.cancellationSignal?.removeEventListener('abort', abortListener);
             await startNotification;
             if (startNotificationError !== undefined) {
                 reject(startNotificationError);
@@ -52,7 +66,7 @@ export function runAgentCliCommand(input) {
                 stdout,
                 stderr,
                 exitCode: exitCode ?? 1,
-                timedOut,
+                timedOut: timedOut || canceled,
             });
         });
     });

package/dist/src/core/live-execution.js

@@ -0,0 +1,81 @@
+import { currentProcessIdentity } from '../lib/process-identity.js';
+function createEventQueue() {
+    const queue = [];
+    const waiters = [];
+    let closed = false;
+    function emit(value) {
+        const waiter = waiters.shift();
+        if (waiter !== undefined) {
+            waiter(value);
+            return;
+        }
+        queue.push(value);
+    }
+    async function nextQueued() {
+        const value = queue.shift();
+        if (value !== undefined)
+            return value;
+        if (closed)
+            return { kind: 'done' };
+        return new Promise((resolve) => waiters.push(resolve));
+    }
+    return {
+        push(event) {
+            if (!closed)
+                emit({ kind: 'event', event });
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            emit({ kind: 'done' });
+        },
+        fail(error) {
+            if (closed)
+                return;
+            closed = true;
+            emit({ kind: 'error', error });
+        },
+        iterable: {
+            async *[Symbol.asyncIterator]() {
+                while (true) {
+                    const value = await nextQueued();
+                    if (value.kind === 'done')
+                        return;
+                    if (value.kind === 'error')
+                        throw value.error;
+                    yield value.event;
+                }
+            },
+        },
+    };
+}
+export function createAgentExecution(input, execute) {
+    const controller = new AbortController();
+    const events = createEventQueue();
+    const result = Promise.resolve()
+        .then(() => execute({
+        ...input,
+        cancellationSignal: controller.signal,
+        onRuntimeEvent: async (event) => {
+            await input.onRuntimeEvent?.(event);
+            events.push(event);
+        },
+    }))
+        .then((value) => {
+        events.close();
+        return value;
+    }, (error) => {
+        events.fail(error);
+        throw error;
+    });
+    return {
+        runId: input.runId,
+        processIdentity: currentProcessIdentity(),
+        events: events.iterable,
+        async cancel(reason) {
+            controller.abort(reason);
+        },
+        result,
+    };
+}

package/dist/src/core/tick-runner.js

@@ -18,12 +18,14 @@ import { createOutbox } from './outbox.js';
 import { createEventResolver } from './event-resolver.js';
 import { createStaleRunReconciler } from './stale-run-reconciler.js';
 import { createWorkspaceCleanup } from './workspace-cleanup.js';
+import { createAgentExecution } from './live-execution.js';
 import { createAutonomousDecisionAuditEvent, workflowRevision as computeWorkflowRevision, } from './audit-events.js';
 import { createRunLease, isRunLeaseExpired, renewRunLease, runLeaseRenewalIntervalMs, } from './run-lease.js';
 import { currentProcessIdentity, processIdentityMatches } from '../lib/process-identity.js';
 import { readJsonFile, writeJsonFile } from '../lib/json-file.js';
 import { isMissingPathError } from '../lib/state-health.js';
 const prReviewApprovalMarker = '<!-- wake:pr-review-approved -->';
+const activeRunSourceRefreshIntervalMs = 1_000;
 function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
@@ -433,6 +435,21 @@ export function createTickRunner(deps) {
     function runnerTimeoutMs() {
         return maxConfiguredRunnerTimeoutMs(deps.config);
     }
+    function cancellationReasonForIneligibleProjection(projection) {
+        if (projection === null || projection.issue.state !== 'open') {
+            return 'CANCELED_BY_SOURCE_CLOSED';
+        }
+        const requiredAssignees = deps.config.sources.github.policy.requiredAssignees;
+        if (requiredAssignees.length > 0 &&
+            !requiredAssignees.some((login) => projection.issue.assignees.includes(login))) {
+            return 'CANCELED_BY_UNASSIGNMENT';
+        }
+        const workflow = workflowForProjection(projection, deps.config);
+        if (workflow === null || !isKnownWorkflowStage(projection.wake.stage, workflow)) {
+            return 'CANCELED_BY_WORKFLOW_CHANGE';
+        }
+        return 'CANCELED_BY_SUPERSEDING_EVENT';
+    }
     async function isRunningRecordActive(record, now) {
         if (record.lease !== undefined && !isRunLeaseExpired(record, now)) {
             return true;
@@ -1171,6 +1188,12 @@ export function createTickRunner(deps) {
                     });
                 }, runLeaseRenewalIntervalMs);
             }
+            function delayActiveRunRefresh() {
+                return new Promise((resolve) => {
+                    const timer = setTimeout(resolve, activeRunSourceRefreshIntervalMs);
+                    timer.unref?.();
+                });
+            }
             try {
                 await transitionRunLifecycle('PREPARING');
                 const prepareResult = workspaceMode === 'branch'
@@ -1202,17 +1225,20 @@ export function createTickRunner(deps) {
                 const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
                 await transitionRunLifecycle('RUNNING');
                 startLeaseRenewal();
+                const activeCandidate = candidate;
                 const runnerProjection = watcherRun
                     ? {
-                        ...candidate,
+                        ...activeCandidate,
                         wake: {
-                            ...candidate.wake,
+                            ...activeCandidate.wake,
                             sessionId: undefined,
                             sessionCli: undefined,
                         },
                     }
-                    : candidate;
-                const runnerResult = await deps.runner.run({
+                    : activeCandidate;
+                let executionFinished = false;
+                let cancellationReason = null;
+                const runnerInput = {
                     action,
                     projection: runnerProjection,
                     recentEvents,
@@ -1237,7 +1263,79 @@ export function createTickRunner(deps) {
                         });
                     },
                     onRuntimeEvent: appendRuntimeEvent,
-                });
+                };
+                const execution = deps.runner.start === undefined
+                    ? createAgentExecution(runnerInput, (liveInput) => deps.runner.run(liveInput))
+                    : await deps.runner.start(runnerInput);
+                async function persistCancellationRequest(reason) {
+                    const requestedAt = deps.clock.now().toISOString();
+                    await deps.stateStore.updateRunRecordIf(runId, {
+                        expect: (record) => record.status === 'running' &&
+                            record.lease?.leaseId === lease.leaseId &&
+                            record.lease.ownerInstanceId === ownerInstanceId,
+                        update: (record) => ({
+                            ...record,
+                            metadata: {
+                                ...record.metadata,
+                                cancellation: {
+                                    reason,
+                                    requestedAt,
+                                    source: 'active-source-reconciliation',
+                                },
+                            },
+                        }),
+                    });
+                }
+                async function superviseActiveSource() {
+                    if (deps.workSource.refreshForDispatch === undefined) {
+                        return null;
+                    }
+                    while (!executionFinished) {
+                        await delayActiveRunRefresh();
+                        if (executionFinished) {
+                            return null;
+                        }
+                        let activeRefresh;
+                        try {
+                            activeRefresh = await deps.workSource.refreshForDispatch({
+                                projection: activeCandidate,
+                            });
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (activeRefresh === null) {
+                            continue;
+                        }
+                        if (activeRefresh.events.length > 0) {
+                            await ingestInboundEvents(activeRefresh.events);
+                        }
+                        const refreshedProjection = (await deps.stateStore.readIssueState(activeCandidate.workItemKey)) ??
+                            activeCandidate;
+                        const ineligible = activeRefresh.sourceExists === false ||
+                            !policy.isEligible(refreshedProjection, deps.config);
+                        if (!ineligible) {
+                            continue;
+                        }
+                        const reason = cancellationReasonForIneligibleProjection(activeRefresh.sourceExists === false ? null : refreshedProjection);
+                        cancellationReason = reason;
+                        await persistCancellationRequest(reason);
+                        await execution.cancel(reason);
+                        return reason;
+                    }
+                    return null;
+                }
+                const runnerResult = await Promise.race([
+                    execution.result.finally(() => {
+                        executionFinished = true;
+                    }),
+                    superviseActiveSource().then(async (reason) => {
+                        if (reason === null) {
+                            return execution.result;
+                        }
+                        return execution.result;
+                    }),
+                ]);
                 clearInterval(leaseRenewalTimer);
                 leaseRenewalTimer = undefined;
                 const parsedRunnerResult = parseRunnerResult(runnerResult.result);
@@ -1343,16 +1441,19 @@ export function createTickRunner(deps) {
                 const resultMetadata = {
                     ...runnerResult.metadata,
                     envelope: parsedRunnerResult.envelope,
+                    ...(cancellationReason === null ? {} : { cancellationReason }),
                     ...(runnerResult.failureClass === undefined
                         ? {}
                         : { failureClass: runnerResult.failureClass }),
                     ...(runnerResult.routing === undefined ? {} : { routing: runnerResult.routing }),
                 };
-                const executionOutcome = runnerResult.failureClass === 'quota'
-                    ? 'QUOTA_EXHAUSTED'
-                    : runnerResult.failureClass === 'infra'
-                        ? 'PROCESS_FAILED'
-                        : 'COMPLETED';
+                const executionOutcome = cancellationReason !== null
+                    ? cancellationReason
+                    : runnerResult.failureClass === 'quota'
+                        ? 'QUOTA_EXHAUSTED'
+                        : runnerResult.failureClass === 'infra'
+                            ? 'PROCESS_FAILED'
+                            : 'COMPLETED';
                 const workflowOutcome = sentinel === 'DONE'
                     ? 'DONE'
                     : sentinel === 'BLOCKED'
@@ -1410,7 +1511,9 @@ export function createTickRunner(deps) {
                         sessionId: runnerResult.session_id,
                         sessionCli: runnerResult.cli,
                         workspacePath,
-                        reason: `runner:${sentinel.toLowerCase()}`,
+                        reason: cancellationReason === null
+                            ? `runner:${sentinel.toLowerCase()}`
+                            : `runner:${String(cancellationReason).toLowerCase()}`,
                         ...(runnerResult.routing === undefined ? {} : { routing: runnerResult.routing }),
                         ...(runnerResult.failureClass === undefined
                             ? {}

package/dist/src/domain/schema.js

@@ -24,6 +24,10 @@ export const executionOutcomeValues = [
     'TIMED_OUT',
     'STALLED',
     'CANCELED_BY_RECONCILIATION',
+    'CANCELED_BY_SOURCE_CLOSED',
+    'CANCELED_BY_UNASSIGNMENT',
+    'CANCELED_BY_SUPERSEDING_EVENT',
+    'CANCELED_BY_WORKFLOW_CHANGE',
     'CANCELED_BY_OPERATOR',
     'QUOTA_EXHAUSTED',
     'MALFORMED_OUTPUT',

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g580cc47";
+export const wakeVersion = "g009f6be";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.46",
+  "version": "0.2.47",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {