@atolis-hq/wake 0.2.43 → 0.2.45

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/github/github-client.js

@@ -194,6 +194,37 @@ export function createGitHubClient(token) {
                 }),
             });
         },
+        async listPullRequestFiles(owner, repo, pullNumber) {
+            return fetchPaginatedWithEtag({
+                cache: etagCache,
+                cacheKey: `pr-files:${owner}/${repo}#${pullNumber}`,
+                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listFiles, {
+                    owner,
+                    repo,
+                    pull_number: pullNumber,
+                    per_page: 100,
+                    ...(headers === undefined ? {} : { headers }),
+                }),
+            });
+        },
+        async createPullRequestApproval(owner, repo, pullNumber, body) {
+            await octokit.rest.pulls.createReview({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                event: 'APPROVE',
+                body,
+            });
+        },
+        async enablePullRequestAutoMerge(pullRequestNodeId) {
+            await octokit.graphql(`mutation EnableWakeAutoMerge($pullRequestId: ID!) {
+          enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId }) {
+            pullRequest {
+              id
+            }
+          }
+        }`, { pullRequestId: pullRequestNodeId });
+        },
         async replyToReviewComment(owner, repo, pullNumber, commentId, body) {
             return octokit.rest.pulls.createReplyForReviewComment({
                 owner,

package/dist/src/adapters/github/github-pull-request-merge-actor.js

@@ -0,0 +1,29 @@
+function parseGithubPullRequestResourceUri(resourceUri) {
+    const match = /^github:pr:([^/]+)\/([^#]+)#(\d+)$/.exec(resourceUri);
+    if (match === null) {
+        throw new Error(`Unsupported GitHub pull request resource URI: ${resourceUri}`);
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+        pullNumber: Number(match[3]),
+    };
+}
+export function createGitHubPullRequestMergeActor(input) {
+    return {
+        async listChangedFiles(resourceUri) {
+            const ref = parseGithubPullRequestResourceUri(resourceUri);
+            const files = await input.client.listPullRequestFiles(ref.owner, ref.repo, ref.pullNumber);
+            return files.map((file) => file.filename);
+        },
+        async approve(resourceUri, body) {
+            const ref = parseGithubPullRequestResourceUri(resourceUri);
+            await input.client.createPullRequestApproval(ref.owner, ref.repo, ref.pullNumber, body);
+        },
+        async enableAutoMerge(resourceUri) {
+            const ref = parseGithubPullRequestResourceUri(resourceUri);
+            const pr = await input.client.getPullRequest(ref.owner, ref.repo, ref.pullNumber);
+            await input.client.enablePullRequestAutoMerge(pr.node_id);
+        },
+    };
+}

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/policy-engine.js

@@ -188,7 +188,13 @@ export function createPolicyEngine() {
             if (latestComment?.isBotAuthored === true &&
                 latestComment.resourceUri !== undefined &&
                 latestComment.body.includes(prReviewApprovalMarker)) {
-                return { approved: true, pendingAction };
+                return {
+                    approved: true,
+                    pendingAction,
+                    targetResourceUri: latestComment.resourceUri,
+                    triggeringCommentId: latestComment.id,
+                    triggeringCommentBody: latestComment.body,
+                };
             }
             if (latestHumanComment === undefined) {
                 return null;

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';
@@ -110,6 +111,202 @@ export function createTickRunner(deps) {
     function hasLabel(projection, label) {
         return projection.issue.labels.includes(label);
     }
+    function approvedMergePolicyForStage(stage) {
+        return (stage?.watch?.find((watch) => watch.onApproved?.merge !== undefined)?.onApproved?.merge ??
+            null);
+    }
+    function escapeRegex(input) {
+        return input.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    }
+    function globPatternMatches(pattern, path) {
+        const regex = new RegExp(`^${pattern.split('*').map(escapeRegex).join('.*')}$`);
+        return regex.test(path);
+    }
+    function reviewerMessageFromApprovalComment(body) {
+        return body
+            .replaceAll(prReviewApprovalMarker, '')
+            .replaceAll('<!-- wake:pr-review-changes-requested -->', '')
+            .trim();
+    }
+    async function evaluatePrMergeRisk(input) {
+        const incumbent = await deps.resourceIndex.resolve(input.targetResourceUri);
+        if (incumbent !== undefined && incumbent !== input.projection.workItemKey) {
+            return {
+                passed: false,
+                reason: `Merge policy blocked this PR because ${input.targetResourceUri} is primary-correlated to ${incumbent}, not ${input.projection.workItemKey}.`,
+            };
+        }
+        const blockedLabel = input.policy.blockedLabels.find((label) => input.projection.issue.labels.includes(label));
+        if (blockedLabel !== undefined) {
+            return {
+                passed: false,
+                reason: `Merge policy blocked this PR because the work item has blocked label "${blockedLabel}".`,
+            };
+        }
+        if (deps.prMergeActor === undefined) {
+            return {
+                passed: false,
+                reason: 'Merge policy blocked this PR because no pull request merge actor is configured.',
+            };
+        }
+        const filesChanged = await deps.prMergeActor.listChangedFiles(input.targetResourceUri);
+        if (input.policy.maxFilesChanged !== undefined &&
+            filesChanged.length > input.policy.maxFilesChanged) {
+            return {
+                passed: false,
+                reason: `Merge policy blocked this PR because it changes ${filesChanged.length} files, exceeding maxFilesChanged ${input.policy.maxFilesChanged}.`,
+            };
+        }
+        for (const pattern of input.policy.blockedPaths) {
+            const blockedPath = filesChanged.find((path) => globPatternMatches(pattern, path));
+            if (blockedPath !== undefined) {
+                return {
+                    passed: false,
+                    reason: `Merge policy blocked this PR because changed path "${blockedPath}" matches blockedPaths pattern "${pattern}".`,
+                };
+            }
+        }
+        return { passed: true, filesChanged };
+    }
+    async function publishPrMergePolicyBlock(input) {
+        const commentId = input.approvalResolution.triggeringCommentId;
+        const targetResourceUri = input.approvalResolution.targetResourceUri;
+        if (commentId === undefined || targetResourceUri === undefined) {
+            return { status: 'idle' };
+        }
+        const runId = `merge-gate-blocked-${commentId.replace(/[^a-z0-9]+/gi, '-')}`;
+        const occurredAt = eventStampNow();
+        const blockedEvent = createEventEnvelope({
+            eventId: `${runId}-completed`,
+            workItemKey: input.projection.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.run.completed',
+            sourceRefs: {
+                repo: input.projection.issue.repo,
+                issueNumber: input.projection.issue.number,
+                runId,
+                resourceUri: targetResourceUri,
+            },
+            occurredAt,
+            ingestedAt: occurredAt,
+            trigger: 'immediate',
+            payload: {
+                action: input.approvalResolution.pendingAction,
+                sentinel: 'BLOCKED',
+                runId,
+                reason: 'pr-review-merge-policy-blocked',
+                blockReason: 'pr-review-merge-policy-blocked',
+                handledCommentId: commentId,
+                body: input.reason,
+            },
+        });
+        const appended = await deps.stateStore.appendEventEnvelope(blockedEvent);
+        await projectionUpdater.rebuildFromEvents([appended]);
+        const reviewerMessage = reviewerMessageFromApprovalComment(input.approvalResolution.triggeringCommentBody ?? '');
+        const body = [reviewerMessage, input.reason].filter((part) => part.length > 0).join('\n\n');
+        await deliverOutboundEvent(createEventEnvelope({
+            eventId: `${runId}-publish-intent`,
+            workItemKey: input.projection.workItemKey,
+            streamScope: 'work-item',
+            direction: 'outbound',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.publish.intent.requested',
+            sourceRefs: {
+                repo: input.projection.issue.repo,
+                issueNumber: input.projection.issue.number,
+                runId,
+                resourceUri: targetResourceUri,
+            },
+            occurredAt,
+            ingestedAt: occurredAt,
+            trigger: 'context-only',
+            payload: {
+                kind: 'question',
+                origin: input.projection.origin ?? 'github',
+                body,
+                action: input.approvalResolution.pendingAction,
+                sentinel: 'BLOCKED',
+                runId,
+                idempotencyKey: `${commentId}:pr-review-merge-policy-blocked`,
+                deliveryState: 'PENDING',
+            },
+            derivedHints: { stage: input.projection.wake.stage },
+        }));
+        await deliverOutboundEvent(createLabelsEvent({
+            projection: input.projection,
+            runId,
+            statusLabel: 'wake:status.blocked',
+            stageLabel: stageLabelForStage(input.projection.wake.stage),
+            workflowLabel: workflowLabelForWorkflowName(input.workflowName),
+            occurredAt,
+        }));
+        return {
+            status: 'processed',
+            runId,
+            sentinel: 'BLOCKED',
+            nextStage: null,
+        };
+    }
+    async function performApprovedPrMergeActions(input) {
+        if (deps.prMergeActor === undefined ||
+            input.approvalResolution.targetResourceUri === undefined ||
+            input.approvalResolution.triggeringCommentId === undefined) {
+            return;
+        }
+        const targetResourceUri = input.approvalResolution.targetResourceUri;
+        const commentId = input.approvalResolution.triggeringCommentId.replace(/[^a-z0-9]+/gi, '-');
+        const reviewBody = reviewerMessageFromApprovalComment(input.approvalResolution.triggeringCommentBody ?? '');
+        const approvedEventId = `pr-merge-approved-${commentId}`;
+        if (input.mergePolicy.approve &&
+            (await deps.stateStore.readEventEnvelope(approvedEventId)) === null) {
+            await deps.prMergeActor.approve(targetResourceUri, reviewBody);
+            const occurredAt = eventStampNow();
+            await deps.stateStore.appendEventEnvelope(createEventEnvelope({
+                eventId: approvedEventId,
+                workItemKey: input.projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: 'wake.pr-review.approved',
+                sourceRefs: {
+                    resourceUri: targetResourceUri,
+                    commentId: input.approvalResolution.triggeringCommentId,
+                },
+                occurredAt,
+                ingestedAt: occurredAt,
+                trigger: 'context-only',
+                payload: {
+                    idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-review-approval`,
+                },
+            }));
+        }
+        const autoMergeEventId = `pr-auto-merge-enabled-${commentId}`;
+        if (input.mergePolicy.autoMerge &&
+            (await deps.stateStore.readEventEnvelope(autoMergeEventId)) === null) {
+            await deps.prMergeActor.enableAutoMerge(targetResourceUri);
+            const occurredAt = eventStampNow();
+            await deps.stateStore.appendEventEnvelope(createEventEnvelope({
+                eventId: autoMergeEventId,
+                workItemKey: input.projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: 'wake.pr-auto-merge.enabled',
+                sourceRefs: {
+                    resourceUri: targetResourceUri,
+                    commentId: input.approvalResolution.triggeringCommentId,
+                },
+                occurredAt,
+                ingestedAt: occurredAt,
+                trigger: 'context-only',
+                payload: {
+                    idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-auto-merge`,
+                },
+            }));
+        }
+    }
     // Closes the loop on #82's review feedback: rather than scrape a PR link
     // out of the agent's free text, the agent emits a `wake-artifacts` fence
     // (domain/schema.ts's parseRunnerArtifacts) and Wake verifies each claim
@@ -656,6 +853,27 @@ export function createTickRunner(deps) {
                         promptContextOverrides = workflowAction?.promptContext;
                     }
                     else if (approvalResolution.approved) {
+                        const mergePolicy = approvedMergePolicyForStage(workflow.stages[candidate.wake.stage]);
+                        if (approvalResolution.targetResourceUri !== undefined && mergePolicy !== null) {
+                            const risk = await evaluatePrMergeRisk({
+                                projection: candidate,
+                                targetResourceUri: approvalResolution.targetResourceUri,
+                                policy: mergePolicy,
+                            });
+                            if (!risk.passed) {
+                                return await publishPrMergePolicyBlock({
+                                    projection: candidate,
+                                    approvalResolution,
+                                    reason: risk.reason,
+                                    workflowName,
+                                });
+                            }
+                            await performApprovedPrMergeActions({
+                                projection: candidate,
+                                approvalResolution,
+                                mergePolicy,
+                            });
+                        }
                         const approvalId = `approval-${candidate.issue.number}-${deps.clock.now().getTime()}`;
                         const approvedAt = deps.clock.now().toISOString();
                         const automaticApproval = approvalResolution.automatic === true;
@@ -684,7 +902,11 @@ export function createTickRunner(deps) {
                                 nextStage,
                                 runId: approvalId,
                                 reason: automaticApproval ? 'auto:approved' : 'human:approved',
-                                ...(automaticApproval ? {} : { handledCommentId: latestHumanCommentId(candidate) }),
+                                ...(automaticApproval
+                                    ? {}
+                                    : {
+                                        handledCommentId: approvalResolution.triggeringCommentId ?? latestHumanCommentId(candidate),
+                                    }),
                                 ...(automaticApproval
                                     ? {
                                         autoResolution: {
@@ -831,6 +1053,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`,
@@ -980,6 +1226,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(),
 }));
@@ -377,6 +395,20 @@ const workflowWorkspaceSchema = z.enum(['none', 'read-only', 'branch']);
 const workflowTriggerScheduleSchema = z.object({
     cron: z.string().min(1),
 });
+const approvedMergePolicySchema = z
+    .object({
+    approve: z.boolean().default(false),
+    autoMerge: z.boolean().default(false),
+    maxFilesChanged: z.number().int().positive().optional(),
+    blockedPaths: z.array(z.string().min(1)).default([]),
+    blockedLabels: z.array(z.string().min(1)).default([]),
+})
+    .default({
+    approve: false,
+    autoMerge: false,
+    blockedPaths: [],
+    blockedLabels: [],
+});
 const workflowStageSchema = stageRouteSchema.extend({
     workspace: workflowWorkspaceSchema,
     onDone: identifierSchema,
@@ -392,6 +424,11 @@ const workflowStageSchema = stageRouteSchema.extend({
             .optional(),
         schedule: workflowTriggerScheduleSchema.optional(),
         workflow: identifierSchema,
+        onApproved: z
+            .object({
+            merge: approvedMergePolicySchema.optional(),
+        })
+            .optional(),
     }))
         .optional(),
 });

package/dist/src/main.js

@@ -19,6 +19,7 @@ import { createGitHubArtifactVerifier } from './adapters/github/github-artifact-
 import { createGitHubClient } from './adapters/github/github-client.js';
 import { createGitHubIssuesWorkSource } from './adapters/github/github-issues-work-source.js';
 import { createGitHubPullRequestActivitySource } from './adapters/github/github-pull-request-activity-source.js';
+import { createGitHubPullRequestMergeActor } from './adapters/github/github-pull-request-merge-actor.js';
 import { runAuditCommand } from './cli/audit-command.js';
 import { runCorrelateCommand } from './cli/correlate-command.js';
 import { runDoctorCommand } from './cli/doctor-command.js';
@@ -497,6 +498,9 @@ export async function buildRuntime(args) {
     const artifactVerifier = prTrackingEnabled && githubClient !== undefined
         ? createGitHubArtifactVerifier({ client: githubClient })
         : undefined;
+    const prMergeActor = prTrackingEnabled && githubClient !== undefined
+        ? createGitHubPullRequestMergeActor({ client: githubClient })
+        : undefined;
     const ticketingSystem = githubClient !== undefined
         ? createGitHubIssuesWorkSource({
             client: githubClient,
@@ -577,6 +581,7 @@ export async function buildRuntime(args) {
         workspaceManager,
         resourceIndex,
         ...(artifactVerifier === undefined ? {} : { artifactVerifier }),
+        ...(prMergeActor === undefined ? {} : { prMergeActor }),
     });
     return {
         config,

package/dist/src/version.js

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

package/package.json

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