@atolis-hq/wake 0.2.44 → 0.2.46

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

@@ -1,6 +1,7 @@
 import { parseClaudePrintResult, parseRunnerResult } from '../../domain/schema.js';
 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';
 export { buildStagePrompt } from '../runner/stage-prompt.js';
 function slugify(value, maxLength = 40) {
@@ -221,7 +222,18 @@ export function createClaudeRunner(options) {
                 args,
                 cwd: input.workspacePath ?? options.cwd,
                 timeoutMs: options.settings.timeoutMs,
-                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
+                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,
@@ -250,6 +262,15 @@ export function createClaudeRunner(options) {
                     ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
                     exitCode: result.exitCode,
                 }));
+                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                    type: 'agent.process.exited',
+                    runId: input.runId,
+                    projection: input.projection,
+                    routing: input.routing,
+                    cli: CLAUDE_CLI_NAME,
+                    model,
+                    payload: { exitCode: result.exitCode, timedOut: result.timedOut },
+                }));
                 let parsedReason;
                 let stdoutFailureDetail;
                 const trimmedStdout = result.stdout.trim();
@@ -295,6 +316,16 @@ export function createClaudeRunner(options) {
             }
             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,
@@ -307,6 +338,28 @@ export function createClaudeRunner(options) {
                 ...(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,

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

@@ -1,5 +1,6 @@
 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 { parseRunnerResult } from '../../domain/schema.js';
 const CODEX_CLI_NAME = 'Codex';
@@ -268,7 +269,18 @@ export function createCodexRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
-                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
+                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: CODEX_CLI_NAME,
+                        model,
+                        payload: { pid: identity.pid, processStartedAt: identity.processStartedAt },
+                    }));
+                },
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,
@@ -300,6 +312,15 @@ export function createCodexRunner(options) {
                     ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
                     exitCode: result.exitCode,
                 }));
+                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                    type: 'agent.process.exited',
+                    runId: input.runId,
+                    projection: input.projection,
+                    routing: input.routing,
+                    cli: CODEX_CLI_NAME,
+                    model,
+                    payload: { exitCode: result.exitCode, timedOut: result.timedOut },
+                }));
                 return {
                     result: [
                         result.timedOut
@@ -331,6 +352,60 @@ export function createCodexRunner(options) {
             }
             const parsed = extractCodexExecResult(result.stdout);
             const sandboxLog = readSandboxLogBreadcrumb();
+            const rawEvents = result.stdout
+                .split(/\r?\n/)
+                .filter((line) => line.trim().length > 0)
+                .map((line) => JSON.parse(line));
+            for (const raw of rawEvents) {
+                if (raw.type === 'thread.started' && typeof raw.thread_id === 'string') {
+                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                        type: 'agent.session.started',
+                        runId: input.runId,
+                        projection: input.projection,
+                        routing: input.routing,
+                        cli: CODEX_CLI_NAME,
+                        model,
+                        sessionId: raw.thread_id,
+                        payload: { raw },
+                    }));
+                }
+                else if (raw.type === 'turn.completed') {
+                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                        type: 'agent.turn.completed',
+                        runId: input.runId,
+                        projection: input.projection,
+                        routing: input.routing,
+                        cli: CODEX_CLI_NAME,
+                        model,
+                        ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                        payload: { raw },
+                    }));
+                }
+                else if (raw.type === 'item.completed') {
+                    await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                        type: 'agent.progress',
+                        runId: input.runId,
+                        projection: input.projection,
+                        routing: input.routing,
+                        cli: CODEX_CLI_NAME,
+                        model,
+                        ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                        payload: { raw },
+                    }));
+                }
+            }
+            if (parsed.tokenUsage !== undefined) {
+                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                    type: 'agent.usage.updated',
+                    runId: input.runId,
+                    projection: input.projection,
+                    routing: input.routing,
+                    cli: CODEX_CLI_NAME,
+                    model,
+                    ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                    payload: { tokenUsage: parsed.tokenUsage },
+                }));
+            }
             console.log(formatCodexRunLogLine({
                 phase: 'success',
                 runId: input.runId,
@@ -342,6 +417,16 @@ export function createCodexRunner(options) {
                 ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
                 ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
             }));
+            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                type: 'agent.process.exited',
+                runId: input.runId,
+                projection: input.projection,
+                routing: input.routing,
+                cli: CODEX_CLI_NAME,
+                model,
+                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                payload: { exitCode: result.exitCode, timedOut: result.timedOut },
+            }));
             return {
                 result: parsed.result,
                 model,
@@ -354,10 +439,7 @@ export function createCodexRunner(options) {
                 metadata: {
                     stdout: result.stdout,
                     stderr: result.stderr,
-                    raw: result.stdout
-                        .split(/\r?\n/)
-                        .filter((line) => line.trim().length > 0)
-                        .map((line) => JSON.parse(line)),
+                    raw: rawEvents,
                     skipApproval: stagePrompt.skipApproval,
                     allowAutoApproval: stagePrompt.allowAutoApproval,
                     ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),

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

@@ -1,6 +1,7 @@
 import { parseRunnerResult } from '../../domain/schema.js';
 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';
 const CURSOR_CLI_NAME = 'Cursor';
 export function buildCursorAgentArgs(input) {
@@ -219,7 +220,18 @@ export function createCursorRunner(options) {
                 }),
                 cwd,
                 timeoutMs: options.settings.timeoutMs,
-                ...(input.onProcessStart === undefined ? {} : { onProcessStart: input.onProcessStart }),
+                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: CURSOR_CLI_NAME,
+                        model,
+                        payload: { pid: identity.pid, processStartedAt: identity.processStartedAt },
+                    }));
+                },
             });
             const responseTranscriptPath = await writeRunnerTranscript({
                 config: input.config,
@@ -248,6 +260,15 @@ export function createCursorRunner(options) {
                     ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
                     exitCode: result.exitCode,
                 }));
+                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                    type: 'agent.process.exited',
+                    runId: input.runId,
+                    projection: input.projection,
+                    routing: input.routing,
+                    cli: CURSOR_CLI_NAME,
+                    model,
+                    payload: { exitCode: result.exitCode, timedOut: result.timedOut },
+                }));
                 return {
                     result: [
                         result.timedOut
@@ -299,6 +320,28 @@ export function createCursorRunner(options) {
                 };
             }
             const sandboxLog = readSandboxLogBreadcrumb();
+            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                type: 'agent.progress',
+                runId: input.runId,
+                projection: input.projection,
+                routing: input.routing,
+                cli: CURSOR_CLI_NAME,
+                model,
+                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                payload: { message: 'Cursor agent result received', raw: parsed },
+            }));
+            if (parsed.tokenUsage !== undefined) {
+                await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                    type: 'agent.usage.updated',
+                    runId: input.runId,
+                    projection: input.projection,
+                    routing: input.routing,
+                    cli: CURSOR_CLI_NAME,
+                    model,
+                    ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                    payload: { tokenUsage: parsed.tokenUsage },
+                }));
+            }
             console.log(formatCursorRunLogLine({
                 phase: 'success',
                 runId: input.runId,
@@ -310,6 +353,16 @@ export function createCursorRunner(options) {
                 ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
                 ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
             }));
+            await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
+                type: 'agent.process.exited',
+                runId: input.runId,
+                projection: input.projection,
+                routing: input.routing,
+                cli: CURSOR_CLI_NAME,
+                model,
+                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                payload: { exitCode: result.exitCode, timedOut: result.timedOut },
+            }));
             return {
                 result: parsed.result,
                 model,

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

@@ -1,6 +1,37 @@
+import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
 export function createFakeRunner(result, options) {
     return {
         async run(_) {
+            const cli = options?.cli ?? 'Fake';
+            await emitRuntimeEvent(_.onRuntimeEvent, runnerRuntimeEvent({
+                type: 'agent.process.started',
+                runId: _.runId,
+                projection: _.projection,
+                routing: _.routing,
+                cli,
+                model: 'fake',
+                payload: { synthetic: true },
+            }));
+            await emitRuntimeEvent(_.onRuntimeEvent, runnerRuntimeEvent({
+                type: 'agent.progress',
+                runId: _.runId,
+                projection: _.projection,
+                routing: _.routing,
+                cli,
+                model: 'fake',
+                sessionId: 'fake-session-1',
+                payload: { message: 'Fake runner completed', synthetic: true },
+            }));
+            await emitRuntimeEvent(_.onRuntimeEvent, runnerRuntimeEvent({
+                type: 'agent.process.exited',
+                runId: _.runId,
+                projection: _.projection,
+                routing: _.routing,
+                cli,
+                model: 'fake',
+                sessionId: 'fake-session-1',
+                payload: { exitCode: 0, synthetic: true },
+            }));
             return (result ?? {
                 result: [
                     'Fake runner completed',
@@ -11,7 +42,7 @@ export function createFakeRunner(result, options) {
                     'DONE',
                 ].join('\n'),
                 model: 'fake',
-                cli: options?.cli ?? 'Fake',
+                cli,
                 session_id: 'fake-session-1',
                 metadata: {
                     source: 'fake-runner',

package/dist/src/adapters/runner/runtime-events.js

@@ -0,0 +1,32 @@
+function runnerKindForCli(cli) {
+    if (cli === 'Claude') {
+        return 'claude';
+    }
+    if (cli === 'Codex') {
+        return 'codex';
+    }
+    if (cli === 'Cursor') {
+        return 'cursor';
+    }
+    return 'fake';
+}
+export function runnerRuntimeEvent(input) {
+    return {
+        type: input.type,
+        runId: input.runId,
+        workItemId: input.projection.workItemKey,
+        runner: {
+            name: input.routing?.runnerName ?? input.cli.toLowerCase(),
+            kind: input.routing?.runnerKind ?? runnerKindForCli(input.cli),
+            cli: input.cli,
+            ...(input.model === undefined ? {} : { model: input.model }),
+        },
+        ...(input.sessionId === undefined ? {} : { sessionId: input.sessionId }),
+        payload: input.payload ?? {},
+    };
+}
+export async function emitRuntimeEvent(emit, event) {
+    if (emit !== undefined) {
+        await emit(event);
+    }
+}

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

@@ -6,6 +6,7 @@ import { acquireFileLock } from '../lib/lock.js';
 import { CORRELATION_REGISTERED_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, parseRunnerArtifacts, parseRunnerResult, } from '../domain/schema.js';
 import { maxConfiguredRunnerTimeoutMs, resolveRunnerRouting } from '../domain/runner-routing.js';
 import { awaitingApprovalRunnerSentinel, stageLabelForStage } from '../domain/stages.js';
+import { isMeaningfulRuntimeEvent } from '../domain/runtime-events.js';
 import { chooseAction as chooseWorkflowAction, entryStage as workflowEntryStage, isKnownWorkflowStage, workflowChangedBlockReason, workflowForProjection, workflowLabelForWorkflowName, workflowNameForProjection, } from '../domain/workflows.js';
 import { createEventEnvelope } from '../lib/event-log.js';
 import { branchNameForIssue } from '../domain/branch-naming.js';
@@ -399,7 +400,17 @@ export function createTickRunner(deps) {
         return watch;
     }
     async function markPendingActionableIssues(projections) {
+        const activeRunWorkItemKeys = new Set();
+        const now = deps.clock.now();
+        for (const record of await deps.stateStore.listRunRecords()) {
+            if (record.status === 'running' && (await isRunningRecordActive(record, now))) {
+                activeRunWorkItemKeys.add(record.workItemKey);
+            }
+        }
         for (const projection of projections) {
+            if (activeRunWorkItemKeys.has(projection.workItemKey)) {
+                continue;
+            }
             const statusLabel = statusLabelForStage(projection.wake.stage);
             const stageLabel = stageLabelForStage(projection.wake.stage);
             const workflowLabel = workflowLabelForWorkflowName(workflowNameForProjection(projection, deps.config));
@@ -1052,6 +1063,30 @@ export function createTickRunner(deps) {
                     lifecycle,
                 });
             }
+            async function appendRuntimeEvent(event) {
+                const timestamp = event.timestamp ?? 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) => {
+                        const runtimeEvents = record.runtimeEvents ?? [];
+                        const sequence = event.sequence ?? runtimeEvents.length;
+                        const normalizedEvent = {
+                            ...event,
+                            timestamp,
+                            sequence,
+                        };
+                        return {
+                            ...record,
+                            runtimeEvents: [...runtimeEvents, normalizedEvent],
+                            ...(isMeaningfulRuntimeEvent(normalizedEvent)
+                                ? { lastMeaningfulActivityAt: normalizedEvent.timestamp }
+                                : {}),
+                        };
+                    },
+                });
+            }
             const claimedAt = eventStampNow();
             const claimedEvent = createEventEnvelope({
                 eventId: `${runId}-claimed`,
@@ -1201,6 +1236,7 @@ export function createTickRunner(deps) {
                             }),
                         });
                     },
+                    onRuntimeEvent: appendRuntimeEvent,
                 });
                 clearInterval(leaseRenewalTimer);
                 leaseRenewalTimer = undefined;

package/dist/src/domain/runtime-events.js

@@ -0,0 +1,36 @@
+export const runtimeEventTypeValues = [
+    'run.claimed',
+    'run.started',
+    'workspace.preparing',
+    'workspace.ready',
+    'agent.process.started',
+    'agent.session.started',
+    'agent.progress',
+    'agent.tool.requested',
+    'agent.approval.requested',
+    'agent.input.required',
+    'agent.usage.updated',
+    'agent.turn.completed',
+    'agent.process.exited',
+    'run.completed',
+    'run.failed',
+    'run.stalled',
+    'run.canceled',
+];
+export function isMeaningfulRuntimeEvent(event) {
+    return (event.type === 'agent.progress' ||
+        event.type === 'agent.tool.requested' ||
+        event.type === 'agent.approval.requested' ||
+        event.type === 'agent.input.required' ||
+        event.type === 'agent.usage.updated' ||
+        event.type === 'agent.turn.completed');
+}
+export function runtimeEventPayload(input) {
+    return {
+        ...(input.message === undefined ? {} : { message: input.message }),
+        ...(input.raw === undefined ? {} : { raw: input.raw }),
+        ...(input.exitCode === undefined ? {} : { exitCode: input.exitCode }),
+        ...(input.timedOut === undefined ? {} : { timedOut: input.timedOut }),
+        ...(input.tokenUsage === undefined ? {} : { tokenUsage: input.tokenUsage }),
+    };
+}

package/dist/src/domain/schema.js

@@ -5,6 +5,7 @@ import { z } from 'zod';
 import { reservedCommandNames } from './custom-commands.js';
 import { runnerSentinelValues } from './stages.js';
 import { correlationProvenanceSchema, correlationRelationSchema, correlationRoleSchema, resourceUriSchema, } from './resource-uri.js';
+import { runtimeEventTypeValues } from './runtime-events.js';
 import { alwaysManualIgnoredLabels } from './manual-labels.js';
 const isoTimestampSchema = z.string().datetime({ offset: true });
 const identifierSchema = z.string().min(1);
@@ -47,6 +48,21 @@ export const executionAttemptLifecycleValues = [
 export const executionOutcomeSchema = z.enum(executionOutcomeValues);
 export const workflowOutcomeSchema = z.enum(workflowOutcomeValues);
 export const executionAttemptLifecycleSchema = z.enum(executionAttemptLifecycleValues);
+export const runtimeEventSchema = z.object({
+    type: z.enum(runtimeEventTypeValues),
+    runId: z.string(),
+    workItemId: z.string(),
+    runner: z.object({
+        name: z.string(),
+        kind: z.enum(['fake', 'claude', 'codex', 'cursor']),
+        cli: z.string(),
+        model: z.string().optional(),
+    }),
+    sessionId: z.string().optional(),
+    timestamp: isoTimestampSchema,
+    sequence: z.number().int().nonnegative(),
+    payload: z.record(z.string(), z.unknown()).default({}),
+});
 export const defaultAgentIdentity = 'Wake';
 export const defaultSmokePrompt = `This is ${defaultAgentIdentity}, reply with "hi ${defaultAgentIdentity} only"`;
 const modelOverridesSchema = z
@@ -361,6 +377,8 @@ export const runRecordSchema = z.preprocess((input) => {
     workerProcessStartedAt: z.string().optional(),
     agentPid: z.number().int().positive().optional(),
     agentProcessStartedAt: z.string().optional(),
+    lastMeaningfulActivityAt: isoTimestampSchema.optional(),
+    runtimeEvents: z.array(runtimeEventSchema).optional(),
     tokenUsage: runTokenUsageSchema.optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
 }));

package/dist/src/version.js

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

package/package.json

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