@atolis-hq/wake 0.2.54 → 0.2.56

package/dist/src/adapters/fs/state-store.js

@@ -1,11 +1,15 @@
+import { setTimeout as delay } from 'node:timers/promises';
 import { access, appendFile, mkdir, readFile, readdir, rename } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { validateResourceIndex } from './resource-index.js';
 import { parseEventEnvelope, parseIssueStateRecord, parseLedger, parseRunRecord, parseSourceStateRecord, } from '../../domain/schema.js';
 import { isTerminalStage } from '../../domain/stages.js';
 import { appendJsonLine, readJsonFile, writeJsonFile } from '../../lib/json-file.js';
+import { acquireFileLock } from '../../lib/lock.js';
 import { createWakePaths } from '../../lib/paths.js';
 import { isMissingPathError, stateHealthIssue, StateHealthError, throwIfUnhealthy, } from '../../lib/state-health.js';
+const runSummaryIndexLockTimeoutMs = 5_000;
+const runSummaryIndexLockPollMs = 10;
 async function readIssueStateFile(file) {
     try {
         return parseIssueStateRecord(await readJsonFile(file));
@@ -24,9 +28,116 @@ async function readIssueStateFile(file) {
         ]);
     }
 }
-async function readRunRecordFile(file) {
+// The board/runs/metrics UI list many run records at once purely for their
+// small fields (status, timing, routing) - metadata.stdout/stderr/raw and
+// runtimeEvents are captured agent output that can run into single-digit MB
+// per run, and holding all of them in memory for a full-history listing is
+// what took the UI process OOM. Stripped only for bulk-list reads; single-run
+// reads (readRunRecord) keep the full record since reconciliation code
+// spreads a record's metadata back into a rewrite (see stale-run-reconciler).
+function stripHeavyRunRecordFields(record) {
+    if (record.metadata === undefined && record.runtimeEvents === undefined) {
+        return record;
+    }
+    const { runtimeEvents: _runtimeEvents, metadata, ...rest } = record;
+    if (metadata === undefined) {
+        return rest;
+    }
+    const { stdout: _stdout, stderr: _stderr, raw: _raw, ...restMetadata } = metadata;
+    return { ...rest, metadata: restMetadata };
+}
+function parseRunRecordSummaryIndex(input, date) {
+    if (input === null || typeof input !== 'object') {
+        throw new Error('Run summary index must be an object');
+    }
+    const record = input;
+    if (record.schemaVersion !== 1) {
+        throw new Error('Run summary index schemaVersion must be 1');
+    }
+    if (record.date !== date) {
+        throw new Error(`Run summary index date must be ${date}`);
+    }
+    if (!Array.isArray(record.entries)) {
+        throw new Error('Run summary index entries must be an array');
+    }
+    return {
+        schemaVersion: 1,
+        date,
+        entries: record.entries.map((entry) => parseRunRecord(entry)),
+    };
+}
+async function withRunSummaryIndexLock(paths, date, operation) {
+    const deadline = Date.now() + runSummaryIndexLockTimeoutMs;
+    while (true) {
+        const lock = await acquireFileLock(paths.runDateIndexLockFile(date), {
+            staleAfterMs: runSummaryIndexLockTimeoutMs,
+        });
+        if (lock.acquired) {
+            try {
+                return await operation();
+            }
+            finally {
+                await lock.release();
+            }
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out acquiring run summary index lock for ${date}`);
+        }
+        await delay(runSummaryIndexLockPollMs);
+    }
+}
+async function readRunSummaryIndex(paths, date) {
+    return parseRunRecordSummaryIndex(await readJsonFile(paths.runDateIndexFile(date)), date);
+}
+async function writeRunSummaryIndex(paths, date, entries) {
+    await writeJsonFile(paths.runDateIndexFile(date), {
+        schemaVersion: 1,
+        date,
+        entries: entries.sort((left, right) => left.startedAt.localeCompare(right.startedAt)),
+    });
+}
+async function countRunDateBucketFiles(paths, date) {
+    return (await readdir(join(paths.dataRoot, 'runs', 'by-date', date), { withFileTypes: true }).catch((error) => {
+        if (isMissingPathError(error)) {
+            return [];
+        }
+        throw error;
+    })).filter((file) => file.isFile() && file.name.endsWith('.json') && file.name !== 'index.json')
+        .length;
+}
+async function rebuildRunSummaryIndexForDate(paths, date) {
+    const recordsById = new Map();
+    const bucketFiles = (await readdir(join(paths.dataRoot, 'runs', 'by-date', date)).catch(() => []))
+        .filter((file) => file.endsWith('.json') && file !== 'index.json')
+        .sort();
+    for (const file of bucketFiles) {
+        const record = await readRunRecordFile(join(paths.dataRoot, 'runs', 'by-date', date, file), {
+            summarize: true,
+        });
+        if (record !== null) {
+            recordsById.set(record.runId, record);
+        }
+    }
+    const entries = [...recordsById.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+    await writeRunSummaryIndex(paths, date, entries);
+    return entries;
+}
+async function upsertRunSummaryIndexEntry(paths, record) {
+    const date = record.startedAt.slice(0, 10);
+    const summary = stripHeavyRunRecordFields(record);
+    await withRunSummaryIndexLock(paths, date, async () => {
+        const entries = await readRunSummaryIndex(paths, date)
+            .then((index) => index.entries)
+            .catch(() => []);
+        const nextById = new Map(entries.map((entry) => [entry.runId, entry]));
+        nextById.set(summary.runId, summary);
+        await writeRunSummaryIndex(paths, date, [...nextById.values()]);
+    });
+}
+async function readRunRecordFile(file, options) {
     try {
-        return parseRunRecord(await readJsonFile(file));
+        const record = parseRunRecord(await readJsonFile(file));
+        return options?.summarize === true ? stripHeavyRunRecordFields(record) : record;
     }
     catch {
         return null;
@@ -167,6 +278,44 @@ async function collectEventIssues(paths) {
     }
     return issues;
 }
+async function collectRunSummaryIndexIssues(paths) {
+    const issues = [];
+    const byDateRoot = join(paths.dataRoot, 'runs', 'by-date');
+    const dateDirs = await readdir(byDateRoot, { withFileTypes: true }).catch((error) => {
+        if (isMissingPathError(error)) {
+            return [];
+        }
+        throw error;
+    });
+    for (const entry of dateDirs) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const date = entry.name;
+        const runFileCount = await countRunDateBucketFiles(paths, date);
+        const indexFile = paths.runDateIndexFile(date);
+        try {
+            const index = await readRunSummaryIndex(paths, date);
+            if (index.entries.length !== runFileCount) {
+                issues.push(stateHealthIssue({
+                    surface: 'runs',
+                    kind: 'incomplete',
+                    path: indexFile,
+                    message: `Run summary index has ${index.entries.length} entries but ${runFileCount} run files exist for ${date}`,
+                }));
+            }
+        }
+        catch (error) {
+            issues.push(stateHealthIssue({
+                surface: 'runs',
+                kind: isMissingPathError(error) ? 'incomplete' : 'corrupted',
+                path: indexFile,
+                message: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }
+    return issues;
+}
 function issueArchiveAgeDate(item) {
     const stageChangedAt = item.wake.stageHistory.at(-1)?.changedAt;
     return ([stageChangedAt, item.wake.syncedAt, item.issue.updatedAt]
@@ -181,13 +330,13 @@ function shouldArchiveIssueState(item, options) {
     const ageMs = options.now.getTime() - Date.parse(issueArchiveAgeDate(item));
     return Number.isFinite(ageMs) && ageMs > options.archiveFreshnessDays * 24 * 60 * 60 * 1000;
 }
-export async function listRunRecords(wakeRoot) {
+async function listRunRecordsImpl(wakeRoot, options) {
     const runsRoot = join(createWakePaths(wakeRoot).dataRoot, 'runs');
     const recordsById = new Map();
     try {
         const files = (await readdir(runsRoot)).filter((file) => file.endsWith('.json')).sort();
         for (const file of files) {
-            const record = await readRunRecordFile(join(runsRoot, file));
+            const record = await readRunRecordFile(join(runsRoot, file), options);
             if (record !== null) {
                 recordsById.set(record.runId, record);
             }
@@ -204,7 +353,7 @@ export async function listRunRecords(wakeRoot) {
                 .filter((file) => file.endsWith('.json'))
                 .sort();
             for (const file of files) {
-                const record = await readRunRecordFile(join(byDateRoot, dateDir, file));
+                const record = await readRunRecordFile(join(byDateRoot, dateDir, file), options);
                 if (record !== null) {
                     recordsById.set(record.runId, record);
                 }
@@ -216,14 +365,38 @@ export async function listRunRecords(wakeRoot) {
     }
     return [...recordsById.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
 }
-async function listRunRecordsForDate(wakeRoot, date) {
+export async function listRunRecords(wakeRoot) {
+    return listRunRecordsImpl(wakeRoot);
+}
+// Same records as listRunRecords, but with metadata.stdout/stderr/raw and
+// runtimeEvents stripped per-file as they're read - for callers (board/runs/
+// metrics UI) that list every run and only need the small fields. See
+// stripHeavyRunRecordFields for why this can't just be a post-hoc .map() over
+// listRunRecords: that would still hold every full record in memory at once.
+export async function listRunRecordSummaries(wakeRoot) {
+    const paths = createWakePaths(wakeRoot);
+    const byDateRoot = join(paths.dataRoot, 'runs', 'by-date');
+    const dateDirs = (await readdir(byDateRoot).catch(() => [])).sort();
+    if (dateDirs.length === 0) {
+        return listRunRecordsImpl(wakeRoot, { summarize: true });
+    }
+    const recordsById = new Map();
+    for (const dateDir of dateDirs) {
+        const records = await listRunRecordSummariesForDate(wakeRoot, dateDir);
+        for (const record of records) {
+            recordsById.set(record.runId, record);
+        }
+    }
+    return [...recordsById.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+}
+async function listRunRecordsForDateImpl(wakeRoot, date, options) {
     const runsRoot = join(createWakePaths(wakeRoot).dataRoot, 'runs');
     const recordsById = new Map();
     const bucketFiles = (await readdir(join(runsRoot, 'by-date', date)).catch(() => []))
         .filter((file) => file.endsWith('.json'))
         .sort();
     for (const file of bucketFiles) {
-        const record = await readRunRecordFile(join(runsRoot, 'by-date', date, file));
+        const record = await readRunRecordFile(join(runsRoot, 'by-date', date, file), options);
         if (record !== null) {
             recordsById.set(record.runId, record);
         }
@@ -233,7 +406,7 @@ async function listRunRecordsForDate(wakeRoot, date) {
             .filter((file) => file.endsWith('.json'))
             .sort();
         for (const file of legacyFiles) {
-            const record = await readRunRecordFile(join(runsRoot, file));
+            const record = await readRunRecordFile(join(runsRoot, file), options);
             if (record?.startedAt.slice(0, 10) === date) {
                 recordsById.set(record.runId, record);
             }
@@ -241,6 +414,42 @@ async function listRunRecordsForDate(wakeRoot, date) {
     }
     return [...recordsById.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
 }
+async function listRunRecordsForDate(wakeRoot, date) {
+    return listRunRecordsForDateImpl(wakeRoot, date);
+}
+async function listRunRecordSummariesForDate(wakeRoot, date) {
+    const paths = createWakePaths(wakeRoot);
+    try {
+        const index = await readRunSummaryIndex(paths, date);
+        const runFileCount = await countRunDateBucketFiles(paths, date);
+        if (index.entries.length === runFileCount && (index.entries.length > 0 || runFileCount > 0)) {
+            return index.entries;
+        }
+    }
+    catch {
+        // Rebuild below under the per-date lock.
+    }
+    const rebuilt = await withRunSummaryIndexLock(paths, date, async () => {
+        const runFileCount = await countRunDateBucketFiles(paths, date);
+        if (runFileCount === 0) {
+            return null;
+        }
+        try {
+            const index = await readRunSummaryIndex(paths, date);
+            if (index.entries.length === runFileCount) {
+                return index.entries;
+            }
+        }
+        catch {
+            // Rebuild below.
+        }
+        return rebuildRunSummaryIndexForDate(paths, date);
+    });
+    if (rebuilt !== null) {
+        return rebuilt;
+    }
+    return listRunRecordsForDateImpl(wakeRoot, date, { summarize: true });
+}
 async function listRecentRunRecords(wakeRoot, limit) {
     const runsRoot = join(createWakePaths(wakeRoot).dataRoot, 'runs');
     const recordsById = new Map();
@@ -297,6 +506,7 @@ export function createStateStore({ wakeRoot }) {
             const parsed = parseRunRecord(record);
             await writeJsonFile(paths.runFile(parsed.runId), parsed);
             await writeJsonFile(paths.runDateFile(parsed.startedAt.slice(0, 10), parsed.runId), parsed);
+            await upsertRunSummaryIndexEntry(paths, parsed);
             return parsed;
         },
         async updateRunRecordIf(runId, input) {
@@ -316,16 +526,38 @@ export function createStateStore({ wakeRoot }) {
                 return parseRunRecord(await readJsonFile(paths.runFile(runId)));
             }
             catch {
-                const recent = await listRecentRunRecords(wakeRoot, 500);
-                return recent.find((record) => record.runId === runId) ?? null;
+                // buildBoard calls this once per work item (readRunRecord per
+                // lastRunId), so a missing flat file used to mean a full,
+                // unstripped listRecentRunRecords(500) scan - every heavy
+                // stdout/raw payload in the 500 most recent runs, parsed again for
+                // every item on the board. Scan summaries to locate the record's
+                // date bucket instead, then do one targeted full read of just that
+                // file so the caller still gets full fidelity.
+                const summaries = await listRunRecordSummaries(wakeRoot);
+                const match = summaries.find((record) => record.runId === runId);
+                if (match === undefined) {
+                    return null;
+                }
+                try {
+                    return parseRunRecord(await readJsonFile(paths.runDateFile(match.startedAt.slice(0, 10), runId)));
+                }
+                catch {
+                    return match;
+                }
             }
         },
         async listRunRecords() {
             return listRunRecords(wakeRoot);
         },
+        async listRunRecordSummaries() {
+            return listRunRecordSummaries(wakeRoot);
+        },
         async listRunRecordsForDate(date) {
             return listRunRecordsForDate(wakeRoot, date);
         },
+        async listRunRecordSummariesForDate(date) {
+            return listRunRecordSummariesForDate(wakeRoot, date);
+        },
         async listRecentRunRecords(limit = 10) {
             return listRecentRunRecords(wakeRoot, limit);
         },
@@ -511,6 +743,7 @@ export function createStateStore({ wakeRoot }) {
             const issues = [
                 ...(await collectEventIssues(paths)),
                 ...(await collectIssueStateIssues(paths)),
+                ...(await collectRunSummaryIndexIssues(paths)),
                 ...(await validateResourceIndex(paths)),
             ];
             return { healthy: issues.length === 0, issues };

package/dist/src/adapters/github/github-pull-request-activity-source.js

@@ -82,6 +82,53 @@ export function createGitHubPullRequestActivitySource(deps) {
             rootId: Number(rootIdStr),
         };
     }
+    function prCommentPublishedEvent(input) {
+        return createEventEnvelope({
+            eventId: `${input.intent.eventId}-published`,
+            workItemKey: input.intent.workItemKey,
+            streamScope: 'work-item',
+            direction: 'outbound',
+            sourceSystem: githubPrSource,
+            sourceEventType: 'pr.comment.reply.published',
+            sourceRefs: { repo: input.repoRef, resourceUri: input.resourceUri },
+            occurredAt: input.publishedAt,
+            ingestedAt: input.publishedAt,
+            trigger: 'context-only',
+            payload: {
+                intentEventId: input.intent.eventId,
+                idempotencyKey: input.intent.payload.idempotencyKey,
+                deliveryState: 'CONFIRMED',
+                kind: input.intent.payload.kind,
+                body: input.intent.payload.body,
+                providerId: input.providerId,
+            },
+        });
+    }
+    function reviewCommentPublishedEvent(input) {
+        return createEventEnvelope({
+            eventId: `${input.intent.eventId}-published`,
+            workItemKey: input.intent.workItemKey,
+            streamScope: 'work-item',
+            direction: 'outbound',
+            sourceSystem: githubPrSource,
+            sourceEventType: 'pr.review-comment.reply.published',
+            sourceRefs: {
+                resourceUri: input.resourceUri,
+                sourceUrl: input.sourceUrl,
+            },
+            occurredAt: input.publishedAt,
+            ingestedAt: input.publishedAt,
+            trigger: 'context-only',
+            payload: {
+                intentEventId: input.intent.eventId,
+                idempotencyKey: input.intent.payload.idempotencyKey,
+                deliveryState: 'CONFIRMED',
+                kind: input.intent.payload.kind,
+                body: input.intent.payload.body,
+                providerId: input.providerId,
+            },
+        });
+    }
     async function discoverPullRequests(ingestedAt) {
         const seenPrData = new Map();
         const confirmedOpenRepos = new Set();
@@ -429,30 +476,30 @@ export function createGitHubPullRequestActivitySource(deps) {
                 if (ref === null) {
                     throw new Error(`cannot deliver intent ${input.event.eventId}: malformed review-thread uri ${resourceUri}`);
                 }
+                const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
+                if (marker !== undefined) {
+                    const comments = await deps.client.listReviewComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
+                    const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+                    if (existing !== undefined) {
+                        return [
+                            reviewCommentPublishedEvent({
+                                intent: input.event,
+                                resourceUri,
+                                sourceUrl: existing.html_url,
+                                publishedAt,
+                                providerId: existing.id,
+                            }),
+                        ];
+                    }
+                }
                 const response = await deps.client.replyToReviewComment(ref.owner, ref.repo, ref.number, ref.rootId, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
                 return [
-                    createEventEnvelope({
-                        eventId: `${input.event.eventId}-published`,
-                        workItemKey: input.event.workItemKey,
-                        streamScope: 'work-item',
-                        direction: 'outbound',
-                        sourceSystem: githubPrSource,
-                        sourceEventType: 'pr.review-comment.reply.published',
-                        sourceRefs: {
-                            resourceUri,
-                            sourceUrl: response?.html_url,
-                        },
-                        occurredAt: publishedAt,
-                        ingestedAt: publishedAt,
-                        trigger: 'context-only',
-                        payload: {
-                            intentEventId: input.event.eventId,
-                            idempotencyKey: input.event.payload.idempotencyKey,
-                            deliveryState: 'CONFIRMED',
-                            kind: input.event.payload.kind,
-                            body: input.event.payload.body,
-                            providerId: response?.id,
-                        },
+                    reviewCommentPublishedEvent({
+                        intent: input.event,
+                        resourceUri,
+                        sourceUrl: response?.html_url,
+                        publishedAt,
+                        providerId: response?.id,
                     }),
                 ];
             }
@@ -460,27 +507,30 @@ export function createGitHubPullRequestActivitySource(deps) {
             if (ref === null) {
                 throw new Error(`cannot deliver intent ${input.event.eventId}: malformed pr uri ${resourceUri}`);
             }
+            const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
+            if (marker !== undefined) {
+                const comments = await deps.client.listComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
+                const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+                if (existing !== undefined) {
+                    return [
+                        prCommentPublishedEvent({
+                            intent: input.event,
+                            resourceUri,
+                            repoRef: ref.repoRef,
+                            publishedAt,
+                            providerId: existing.id,
+                        }),
+                    ];
+                }
+            }
             const response = await deps.client.createComment(ref.owner, ref.repo, ref.number, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
             return [
-                createEventEnvelope({
-                    eventId: `${input.event.eventId}-published`,
-                    workItemKey: input.event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'outbound',
-                    sourceSystem: githubPrSource,
-                    sourceEventType: 'pr.comment.reply.published',
-                    sourceRefs: { repo: ref.repoRef, resourceUri },
-                    occurredAt: publishedAt,
-                    ingestedAt: publishedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        intentEventId: input.event.eventId,
-                        idempotencyKey: input.event.payload.idempotencyKey,
-                        deliveryState: 'CONFIRMED',
-                        kind: input.event.payload.kind,
-                        body: input.event.payload.body,
-                        providerId: response?.data?.id,
-                    },
+                prCommentPublishedEvent({
+                    intent: input.event,
+                    resourceUri,
+                    repoRef: ref.repoRef,
+                    publishedAt,
+                    providerId: response?.data?.id,
                 }),
             ];
         },
@@ -502,25 +552,12 @@ export function createGitHubPullRequestActivitySource(deps) {
                     return [];
                 }
                 return [
-                    createEventEnvelope({
-                        eventId: `${input.event.eventId}-published`,
-                        workItemKey: input.event.workItemKey,
-                        streamScope: 'work-item',
-                        direction: 'outbound',
-                        sourceSystem: githubPrSource,
-                        sourceEventType: 'pr.review-comment.reply.published',
-                        sourceRefs: { resourceUri, sourceUrl: existing.html_url },
-                        occurredAt: publishedAt,
-                        ingestedAt: publishedAt,
-                        trigger: 'context-only',
-                        payload: {
-                            intentEventId: input.event.eventId,
-                            idempotencyKey: input.event.payload.idempotencyKey,
-                            deliveryState: 'CONFIRMED',
-                            kind: input.event.payload.kind,
-                            body: input.event.payload.body,
-                            providerId: existing.id,
-                        },
+                    reviewCommentPublishedEvent({
+                        intent: input.event,
+                        resourceUri,
+                        sourceUrl: existing.html_url,
+                        publishedAt,
+                        providerId: existing.id,
                     }),
                 ];
             }
@@ -534,25 +571,12 @@ export function createGitHubPullRequestActivitySource(deps) {
                 return [];
             }
             return [
-                createEventEnvelope({
-                    eventId: `${input.event.eventId}-published`,
-                    workItemKey: input.event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'outbound',
-                    sourceSystem: githubPrSource,
-                    sourceEventType: 'pr.comment.reply.published',
-                    sourceRefs: { repo: ref.repoRef, resourceUri },
-                    occurredAt: publishedAt,
-                    ingestedAt: publishedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        intentEventId: input.event.eventId,
-                        idempotencyKey: input.event.payload.idempotencyKey,
-                        deliveryState: 'CONFIRMED',
-                        kind: input.event.payload.kind,
-                        body: input.event.payload.body,
-                        providerId: existing.id,
-                    },
+                prCommentPublishedEvent({
+                    intent: input.event,
+                    resourceUri,
+                    repoRef: ref.repoRef,
+                    publishedAt,
+                    providerId: existing.id,
                 }),
             ];
         },

package/dist/src/adapters/http/ui-assets.js

@@ -59,6 +59,10 @@ export const indexHtml = `<!DOCTYPE html>
   .card:hover { border-color: var(--accent); }
   .card .title { font-weight: 600; margin-bottom: 0.25rem; }
   .card .meta { color: #9aa2ad; font-size: 0.72rem; }
+  .child-run { display: grid; grid-template-columns: auto 1fr; gap: 0.25rem 0.45rem; align-items: center; margin-top: 0.45rem; padding: 0.4rem; border-radius: 6px; background: #181c22; border: 1px solid #334155; color: #cbd5e1; font-size: 0.72rem; }
+  .child-run .dot { width: 0.48rem; height: 0.48rem; border-radius: 50%; background: var(--accent); box-shadow: 0 0 0 3px rgba(45, 212, 191, 0.14); }
+  .child-run .run-title { font-weight: 650; color: #e5e7eb; }
+  .child-run .run-meta { grid-column: 2; color: #94a3b8; }
   .chip { display: inline-block; background: #2c313a; border-radius: 4px; padding: 0.05rem 0.35rem; font-size: 0.68rem; margin-right: 0.2rem; }
   .chip-label { background: transparent; border: 1px solid #3a4150; color: #9aa2ad; margin-bottom: 0.2rem; }
   table { border-collapse: collapse; width: 100%; font-size: 0.8rem; }
@@ -286,6 +290,14 @@ async function renderBoard(context) {
   const board = await getJson('/board', context.signal);
   if (!isActiveRequest(context.requestId)) return;
   const main = document.getElementById('main');
+  const renderChildRun = (run) => el('div', { class: 'child-run' }, [
+    el('span', { class: 'dot' }),
+    el('div', { class: 'run-title', text: run.action + ' running' }),
+    el('div', {
+      class: 'run-meta',
+      text: [run.runnerName, run.tier, fmtMs(run.ageMs)].filter(Boolean).join(' · '),
+    }),
+  ]);
   const columns = el('div', { class: 'columns' }, CONDITIONS.map((cond) => {
     const items = board.filter((c) => c.condition === cond);
     const cards = items.map((item) => el('div', {
@@ -301,6 +313,7 @@ async function renderBoard(context) {
         ? [el('div', { class: 'meta' }, item.labels.map((label) => el('span', { class: 'chip chip-label', text: label })))]
         : []),
       el('div', { class: 'meta', text: item.lastRunSentinel ? 'last: ' + item.lastRunAction + ' → ' + item.lastRunSentinel : item.conditionReason }),
+      ...((item.activeChildRuns || []).map(renderChildRun)),
     ]));
     return el('div', { class: 'col' + (items.length === 0 ? ' col-empty' : '') }, [
       el('h2', { text: cond + ' (' + items.length + ')' }),

package/dist/src/adapters/http/ui-data.js

@@ -74,17 +74,39 @@ function timeInStageMs(item, now) {
     const lastChange = item.wake.stageHistory.at(-1)?.changedAt ?? item.wake.syncedAt;
     return now.getTime() - Date.parse(lastChange);
 }
+function activeChildRunsForItem(item, runs, now) {
+    return runs
+        .filter((run) => run.workItemKey === item.workItemKey &&
+        run.status === 'running' &&
+        run.runId !== item.wake.lastRunId)
+        .sort((left, right) => left.startedAt.localeCompare(right.startedAt))
+        .map((run) => ({
+        runId: run.runId,
+        action: run.action,
+        status: run.status,
+        startedAt: run.startedAt,
+        ageMs: now.getTime() - Date.parse(run.startedAt),
+        ...(run.routing?.runnerName === undefined ? {} : { runnerName: run.routing.runnerName }),
+        ...(run.routing?.runnerKind === undefined ? {} : { runnerKind: run.routing.runnerKind }),
+        ...(run.routing?.tier === undefined ? {} : { tier: run.routing.tier }),
+    }));
+}
 export async function buildBoard(input) {
     const items = await input.stateStore.listIssueStates({
         archiveFreshnessDays: input.config.ui.archiveFreshnessDays,
         now: input.now,
     });
-    const lastRuns = await Promise.all(items.map((item) => item.wake.lastRunId === undefined
-        ? Promise.resolve(null)
-        : input.stateStore.readRunRecord(item.wake.lastRunId)));
-    return items.map((item, index) => {
-        const lastRun = lastRuns[index] ?? null;
+    // One bulk summarized scan shared by every item, instead of readRunRecord()
+    // per item - deriveCondition only reads status/sentinel, so this doesn't
+    // need full records, and doing a separate lookup (with its own fallback
+    // scan when a flat run file is missing) per item made board loads scale
+    // with items x run-history size instead of just run-history size.
+    const runs = await input.stateStore.listRunRecordSummaries();
+    const runsById = new Map(runs.map((run) => [run.runId, run]));
+    return items.map((item) => {
+        const lastRun = item.wake.lastRunId === undefined ? null : (runsById.get(item.wake.lastRunId) ?? null);
         const { condition, reason } = deriveCondition(item, lastRun, input.config);
+        const activeChildRuns = activeChildRunsForItem(item, runs, input.now);
         return {
             repo: item.issue.repo,
             number: item.issue.number,
@@ -98,6 +120,7 @@ export async function buildBoard(input) {
             lastRunAction: lastRun?.action,
             lastRunSentinel: lastRun?.sentinel,
             lastRunStatus: lastRun?.status,
+            ...(activeChildRuns.length === 0 ? {} : { activeChildRuns }),
             sessionId: item.wake.sessionId,
             workspacePath: item.wake.workspacePath,
         };
@@ -109,7 +132,7 @@ export async function buildStatus(input) {
         input.stateStore.readLedger(),
         input.stateStore.isPaused(),
         input.stateStore.listRecentEventEnvelopes({ limit: 1 }),
-        input.stateStore.listRunRecordsForDate(today),
+        input.stateStore.listRunRecordSummariesForDate(today),
         input.stateStore.listRecentRunRecords(1),
         buildBoard(input),
     ]);
@@ -245,7 +268,7 @@ export async function buildItemDetail(input) {
     if (item === null) {
         return null;
     }
-    const allRuns = await input.stateStore.listRunRecords();
+    const allRuns = await input.stateStore.listRunRecordSummaries();
     const runs = allRuns
         .filter((run) => run.workItemKey === item.workItemKey)
         .sort((left, right) => left.startedAt.localeCompare(right.startedAt));
@@ -282,7 +305,7 @@ export async function buildItemTranscripts(input) {
     if (!input.config.transcripts.enabled) {
         return { enabled: false, sessions: [] };
     }
-    const runs = (await input.stateStore.listRunRecords()).filter((run) => run.workItemKey === input.workItemKey);
+    const runs = (await input.stateStore.listRunRecordSummaries()).filter((run) => run.workItemKey === input.workItemKey);
     const runsById = new Map(runs.map((run) => [run.runId, run]));
     const workDir = input.stateStore.paths.transcriptWorkDir(input.workItemKey);
     const sessionDirs = (await readdir(workDir, { withFileTypes: true }).catch(() => []))
@@ -357,7 +380,7 @@ export async function buildEventsFeed(input) {
     });
 }
 export async function buildRuns(input) {
-    const runs = await input.stateStore.listRunRecords();
+    const runs = await input.stateStore.listRunRecordSummaries();
     return runs
         .filter((run) => input.status === undefined || run.status === input.status)
         .filter((run) => input.action === undefined || run.action === input.action)
@@ -476,7 +499,7 @@ function findBucket(timestamp, buckets) {
 async function listRunsForBuckets(stateStore, buckets) {
     const dates = [...new Set(buckets.map((bucket) => bucket.bucket.slice(0, 10)))];
     const runsById = new Map();
-    const recordsByDate = await Promise.all(dates.map((date) => stateStore.listRunRecordsForDate(date)));
+    const recordsByDate = await Promise.all(dates.map((date) => stateStore.listRunRecordSummariesForDate(date)));
     for (const records of recordsByDate) {
         for (const record of records) {
             runsById.set(record.runId, record);

package/dist/src/core/stale-run-reconciler.js

@@ -144,7 +144,14 @@ export function createStaleRunReconciler(deps) {
     }
     async function reconcileStaleRunningRecords(now) {
         const finishedAt = now.toISOString();
-        const runRecords = await deps.stateStore.listRunRecords();
+        // Summarized: the scan below (staleReason/classifyReconciledFailure/the
+        // newerCompletedRun comparison) only reads status/lifecycle/timestamps/pids
+        // and metadata.workspacePath, none of which are stripped - this runs every
+        // tick, so loading every run's captured stdout/raw here just to check
+        // staleness on all of them was a real OOM risk. The stale ones actually
+        // rewritten below re-fetch the full record first so captured output isn't
+        // dropped on write.
+        const runRecords = await deps.stateStore.listRunRecordSummaries();
         await recoverMissingRunRecordClaims(runRecords, finishedAt);
         const staleRecords = [];
         for (const record of runRecords) {
@@ -166,15 +173,16 @@ export function createStaleRunReconciler(deps) {
             // spelled out so the non-null projection is available below for its
             // workItemKey.
             if (projection === null || projection.wake.lastRunId !== record.runId || newerCompletedRun) {
+                const fullRecord = (await deps.stateStore.readRunRecord(record.runId)) ?? record;
                 await deps.stateStore.writeRunRecord({
-                    ...record,
+                    ...fullRecord,
                     lifecycle: 'TERMINAL',
                     status: 'superseded',
                     finishedAt,
                     executionOutcome: 'SUPERSEDED',
                     summary: 'Stale running record was superseded by a newer run.',
                     metadata: {
-                        ...record.metadata,
+                        ...fullRecord.metadata,
                         reconciledBy: 'stale-running-record',
                         supersededBy: projection?.wake.lastRunId,
                     },
@@ -183,8 +191,9 @@ export function createStaleRunReconciler(deps) {
             }
             const staleExecutionOutcome = reason === 'timeout' ? 'TIMED_OUT' : recoveryOutcomeForLifecycle(record.lifecycle);
             const failureContext = classifyReconciledFailure(record);
+            const fullRecord = (await deps.stateStore.readRunRecord(record.runId)) ?? record;
             await deps.stateStore.writeRunRecord({
-                ...record,
+                ...fullRecord,
                 lifecycle: 'TERMINAL',
                 status: 'failed',
                 finishedAt,
@@ -193,7 +202,7 @@ export function createStaleRunReconciler(deps) {
                 ...failureContext,
                 summary: `Run exceeded timeout while marked running and was reconciled by a later tick.`,
                 metadata: {
-                    ...record.metadata,
+                    ...fullRecord.metadata,
                     reconciledBy: 'stale-running-record',
                     recoveryLifecycle: record.lifecycle,
                     staleReason: reason,

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

@@ -26,11 +26,28 @@ import { currentProcessIdentity, processIdentityMatches } from '../lib/process-i
 import { readJsonFile, writeJsonFile } from '../lib/json-file.js';
 import { isMissingPathError } from '../lib/state-health.js';
 const prReviewApprovalMarker = '<!-- wake:pr-review-approved -->';
+const prReviewChangesMarker = '<!-- wake:pr-review-changes-requested -->';
 const activeRunSourceRefreshIntervalMs = 1_000;
 function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
 }
+function latestActionableCommentId(candidate) {
+    const handledCommentId = typeof candidate.context.lastHandledCommentId === 'string'
+        ? candidate.context.lastHandledCommentId
+        : undefined;
+    const lastBotIndex = candidate.comments.reduce((acc, comment, index) => {
+        return comment.isBotAuthored ? index : acc;
+    }, -1);
+    const latestComment = candidate.comments.slice(lastBotIndex).at(-1);
+    if (latestComment?.id !== handledCommentId &&
+        latestComment?.isBotAuthored === true &&
+        latestComment.resourceUri !== undefined &&
+        latestComment.body.includes(prReviewChangesMarker)) {
+        return latestComment.id;
+    }
+    return latestHumanCommentId(candidate);
+}
 function projectedSourceRevision(projection) {
     const latestCommentUpdatedAt = projection.comments
         .map((comment) => comment.updatedAt)
@@ -43,6 +60,12 @@ function projectedSourceRevision(projection) {
 function isLateralReadOnlyAction(action, config) {
     return isCustomCommandAction(action, config);
 }
+function isEventFromWatcherRun(event) {
+    return (typeof event.payload === 'object' &&
+        event.payload !== null &&
+        'watcherRun' in event.payload &&
+        event.payload.watcherRun === true);
+}
 function shouldPublishRunResult(input) {
     if (input.failureClass === 'quota') {
         return false;
@@ -172,8 +195,10 @@ export function createTickRunner(deps) {
         return projection.issue.labels.includes(label);
     }
     function approvedMergePolicyForStage(stage) {
-        return (stage?.watch?.find((watch) => watch.onApproved?.merge !== undefined)?.onApproved?.merge ??
-            null);
+        // Schema defaults materialize a disabled merge block whenever onSuccess is
+        // set (e.g. approve-only watchers); treat it as no merge policy at all.
+        const merge = stage?.watch?.find((watch) => watch.onSuccess?.merge !== undefined)?.onSuccess?.merge ?? null;
+        return merge !== null && (merge.approve || merge.autoMerge) ? merge : null;
     }
     function escapeRegex(input) {
         return input.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
@@ -367,6 +392,50 @@ export function createTickRunner(deps) {
             }));
         }
     }
+    // The one deterministic approval transition: /approved, wake:auto, and a
+    // watcher child's onSuccess.approve all resolve a pending approval through
+    // this same event shape, so replay folds them identically.
+    async function applyApprovalTransition(input) {
+        const nextStage = lifecycle.nextStageFromSentinel(input.projection.wake.stage, 'DONE', input.workflow);
+        if (nextStage === null) {
+            return null;
+        }
+        const approvalCompletedEvent = createEventEnvelope({
+            eventId: `${input.approvalId}-completed`,
+            workItemKey: input.projection.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: RUN_COMPLETED_EVENT,
+            sourceRefs: {
+                repo: input.projection.issue.repo,
+                issueNumber: input.projection.issue.number,
+                runId: input.approvalId,
+            },
+            occurredAt: input.approvedAt,
+            ingestedAt: input.approvedAt,
+            trigger: 'immediate',
+            payload: {
+                action: input.pendingAction,
+                sentinel: 'DONE',
+                nextStage,
+                runId: input.approvalId,
+                reason: input.reason,
+                ...input.payloadExtras,
+            },
+        });
+        await deps.stateStore.appendEventEnvelope(approvalCompletedEvent);
+        await projectionUpdater.rebuildFromEvents([approvalCompletedEvent]);
+        await deliverOutboundEvent(createLabelsEvent({
+            projection: input.projection,
+            runId: input.approvalId,
+            statusLabel: statusLabelForStage(nextStage),
+            stageLabel: stageLabelForStage(nextStage),
+            workflowLabel: workflowLabelForWorkflowName(input.workflowName),
+            occurredAt: input.approvedAt,
+        }));
+        return { nextStage };
+    }
     // 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
@@ -462,7 +531,7 @@ export function createTickRunner(deps) {
     async function markPendingActionableIssues(projections) {
         const activeRunWorkItemKeys = new Set();
         const now = deps.clock.now();
-        for (const record of await deps.stateStore.listRunRecords()) {
+        for (const record of await deps.stateStore.listRunRecordSummaries()) {
             if (record.status === 'running' && (await isRunningRecordActive(record, now))) {
                 activeRunWorkItemKeys.add(record.workItemKey);
             }
@@ -501,7 +570,7 @@ export function createTickRunner(deps) {
     async function exceedsDispatchRateLimit(now) {
         const { windowMs, maxDispatches } = deps.config.scheduler.dispatchRateLimit;
         const windowStartMs = now.getTime() - windowMs;
-        const runRecords = await deps.stateStore.listRunRecords();
+        const runRecords = await deps.stateStore.listRunRecordSummaries();
         const recentCount = runRecords.reduce((count, record) => {
             const startedAtMs = Date.parse(record.startedAt);
             return Number.isFinite(startedAtMs) &&
@@ -541,7 +610,7 @@ export function createTickRunner(deps) {
             }));
     }
     async function hasSchedulerCapacity(now) {
-        const runRecords = await deps.stateStore.listRunRecords();
+        const runRecords = await deps.stateStore.listRunRecordSummaries();
         for (const record of runRecords) {
             if (record.status !== 'running') {
                 continue;
@@ -763,6 +832,7 @@ export function createTickRunner(deps) {
                     });
                     const matchingEvents = events
                         .filter((event) => watcher.on.event.includes(event.sourceEventType))
+                        .filter((event) => !isEventFromWatcherRun(event))
                         .sort((left, right) => left.ingestedAt.localeCompare(right.ingestedAt));
                     const cursorIndex = state?.lastDispatchedEventId === undefined
                         ? -1
@@ -881,12 +951,12 @@ export function createTickRunner(deps) {
             if (await parkConfigDriftedProjections(projections)) {
                 return { status: 'processed' };
             }
-            const watcherDispatch = await nextWatcherDispatch(projections, tickStartedAt);
-            let candidate = watcherDispatch?.projection;
+            let candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
+            const watcherDispatch = candidate === undefined ? await nextWatcherDispatch(projections, tickStartedAt) : null;
+            candidate ??= watcherDispatch?.projection;
             let watcherStateKeyForRun;
             let watcherTriggerForRun;
             const watcherRun = watcherDispatch !== null;
-            candidate ??= projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
             if (candidate === undefined) {
                 return { status: 'idle' };
             }
@@ -1017,48 +1087,29 @@ export function createTickRunner(deps) {
                         const approvalId = `approval-${candidate.issue.number}-${deps.clock.now().getTime()}`;
                         const approvedAt = deps.clock.now().toISOString();
                         const automaticApproval = approvalResolution.automatic === true;
-                        const nextStage = lifecycle.nextStageFromSentinel(candidate.wake.stage, 'DONE', workflow);
-                        if (nextStage === null) {
+                        const applied = await applyApprovalTransition({
+                            projection: candidate,
+                            pendingAction: approvalResolution.pendingAction,
+                            approvalId,
+                            approvedAt,
+                            reason: automaticApproval ? 'auto:approved' : 'human:approved',
+                            workflow,
+                            workflowName,
+                            payloadExtras: automaticApproval
+                                ? {
+                                    autoResolution: {
+                                        kind: 'awaiting-approval',
+                                        classification: 'auto-approval',
+                                        reasoning: approvalResolution.reason,
+                                    },
+                                }
+                                : {
+                                    handledCommentId: approvalResolution.triggeringCommentId ?? latestHumanCommentId(candidate),
+                                },
+                        });
+                        if (applied === null) {
                             return { status: 'idle' };
                         }
-                        const approvalCompletedEvent = createEventEnvelope({
-                            eventId: `${approvalId}-completed`,
-                            workItemKey: candidate.workItemKey,
-                            streamScope: 'work-item',
-                            direction: 'internal',
-                            sourceSystem: 'wake',
-                            sourceEventType: RUN_COMPLETED_EVENT,
-                            sourceRefs: {
-                                repo: candidate.issue.repo,
-                                issueNumber: candidate.issue.number,
-                                runId: approvalId,
-                            },
-                            occurredAt: approvedAt,
-                            ingestedAt: approvedAt,
-                            trigger: 'immediate',
-                            payload: {
-                                action: approvalResolution.pendingAction,
-                                sentinel: 'DONE',
-                                nextStage,
-                                runId: approvalId,
-                                reason: automaticApproval ? 'auto:approved' : 'human:approved',
-                                ...(automaticApproval
-                                    ? {}
-                                    : {
-                                        handledCommentId: approvalResolution.triggeringCommentId ?? latestHumanCommentId(candidate),
-                                    }),
-                                ...(automaticApproval
-                                    ? {
-                                        autoResolution: {
-                                            kind: 'awaiting-approval',
-                                            classification: 'auto-approval',
-                                            reasoning: approvalResolution.reason,
-                                        },
-                                    }
-                                    : {}),
-                            },
-                        });
-                        await deps.stateStore.appendEventEnvelope(approvalCompletedEvent);
                         if (automaticApproval) {
                             await appendAuditEvent({
                                 eventId: `${approvalId}-audit-auto-resolution`,
@@ -1078,7 +1129,7 @@ export function createTickRunner(deps) {
                                 },
                                 outcome: {
                                     approved: true,
-                                    nextStage,
+                                    nextStage: applied.nextStage,
                                     reason: approvalResolution.reason,
                                 },
                                 timestamp: approvedAt,
@@ -1088,20 +1139,11 @@ export function createTickRunner(deps) {
                                 },
                             });
                         }
-                        await projectionUpdater.rebuildFromEvents([approvalCompletedEvent]);
-                        await deliverOutboundEvent(createLabelsEvent({
-                            projection: candidate,
-                            runId: approvalId,
-                            statusLabel: statusLabelForStage(nextStage),
-                            stageLabel: stageLabelForStage(nextStage),
-                            workflowLabel: workflowLabelForWorkflowName(workflowName),
-                            occurredAt: approvedAt,
-                        }));
                         return {
                             status: 'processed',
                             runId: approvalId,
                             sentinel: 'DONE',
-                            nextStage,
+                            nextStage: applied.nextStage,
                         };
                     }
                     else {
@@ -1669,7 +1711,7 @@ export function createTickRunner(deps) {
                         // unset lets the next tick retry instead of silently eating the request (S9).
                         ...(runnerResult.failureClass === 'quota' || runnerResult.failureClass === 'infra'
                             ? {}
-                            : { handledCommentId: latestHumanCommentId(candidate) }),
+                            : { handledCommentId: latestActionableCommentId(candidate) }),
                         body: parsedRunnerResult.body,
                         envelope: parsedRunnerResult.envelope,
                         executionOutcome,
@@ -1709,6 +1751,10 @@ export function createTickRunner(deps) {
                 if (watcherRun) {
                     // Watcher-dispatched runs own PR verdict delivery and correlation
                     // registration regardless of the target workflow/action name.
+                    const pendingApprovalAction = candidate.context.pendingApprovalAction;
+                    const watcherSuccessPolicy = watcherDispatch === null
+                        ? undefined
+                        : deps.config.workflows[watcherDispatch.parentWorkflowName]?.stages[watcherDispatch.parentStage]?.watch?.[watcherDispatch.watcherIndex]?.onSuccess;
                     if (prReviewTargetResourceUri !== null &&
                         (sentinel === 'DONE' || sentinel === 'FAILED')) {
                         await deliverOutboundEvent({
@@ -1727,6 +1773,58 @@ export function createTickRunner(deps) {
                             },
                         });
                     }
+                    else if (watcherDispatch !== null &&
+                        watcherSuccessPolicy?.approve === true &&
+                        (sentinel === 'DONE' || sentinel === 'FAILED' || sentinel === 'BLOCKED')) {
+                        // No PR surface to carry the verdict comment: the child's sentinel
+                        // is its verdict. Publish the review body for every verdict so the
+                        // human sees why; only DONE resolves the parent's pending gate.
+                        await deliverOutboundEvent(publishIntent);
+                        const approvalId = `${runId}-parent-approval`;
+                        const parentWorkflow = deps.config.workflows[watcherDispatch.parentWorkflowName];
+                        if (sentinel === 'DONE' &&
+                            isAwaitingApproval(candidate) &&
+                            typeof pendingApprovalAction === 'string' &&
+                            parentWorkflow !== undefined &&
+                            (await deps.stateStore.readEventEnvelope(`${approvalId}-completed`)) === null) {
+                            const approvedAt = eventStampNow();
+                            const applied = await applyApprovalTransition({
+                                projection: candidate,
+                                pendingAction: pendingApprovalAction,
+                                approvalId,
+                                approvedAt,
+                                reason: 'watcher:approved',
+                                workflow: parentWorkflow,
+                                workflowName: watcherDispatch.parentWorkflowName,
+                            });
+                            if (applied !== null) {
+                                await appendAuditEvent({
+                                    eventId: `${approvalId}-audit-watcher-approval`,
+                                    decisionType: 'approval.watcher-resolved',
+                                    workItemKey: candidate.workItemKey,
+                                    runId,
+                                    workflowRevision: await computeWorkflowRevision({
+                                        config: deps.config,
+                                        workflowName: watcherDispatch.parentWorkflowName,
+                                        workflow: parentWorkflow,
+                                        action: pendingApprovalAction,
+                                    }),
+                                    inputsConsidered: {
+                                        watcherWorkflow: watcherDispatch.targetWorkflowName,
+                                        pendingAction: pendingApprovalAction,
+                                        childRunId: runId,
+                                        childSentinel: sentinel,
+                                    },
+                                    outcome: { approved: true, nextStage: applied.nextStage },
+                                    timestamp: approvedAt,
+                                    sourceRefs: {
+                                        repo: candidate.issue.repo,
+                                        issueNumber: candidate.issue.number,
+                                    },
+                                });
+                            }
+                        }
+                    }
                     else {
                         await suppressOutboundEvent(publishIntent, {
                             suppressedPublishReason: 'pr-review-no-actionable-verdict',

package/dist/src/domain/schema.js

@@ -430,6 +430,12 @@ const approvedMergePolicySchema = z
     blockedPaths: [],
     blockedLabels: [],
 });
+const watchSuccessPolicySchema = z.object({
+    // Resolve the watched parent stage's pending approval gate when the child
+    // workflow run completes DONE — the child's sentinel is its verdict.
+    approve: z.boolean().default(false),
+    merge: approvedMergePolicySchema.optional(),
+});
 const workflowStageSchema = stageRouteSchema.extend({
     workspace: workflowWorkspaceSchema,
     onDone: identifierSchema,
@@ -445,11 +451,7 @@ const workflowStageSchema = stageRouteSchema.extend({
             .optional(),
         schedule: workflowTriggerScheduleSchema.optional(),
         workflow: identifierSchema,
-        onApproved: z
-            .object({
-            merge: approvedMergePolicySchema.optional(),
-        })
-            .optional(),
+        onSuccess: watchSuccessPolicySchema.optional(),
     }))
         .optional(),
 });

package/dist/src/lib/paths.js

@@ -32,6 +32,8 @@ export function createWakePaths(wakeRoot) {
         sourceStateFile: (source, key) => join(dataRoot, 'sources', sanitizePathKey(source), `${sanitizePathKey(key)}.json`),
         runFile: (runId) => join(dataRoot, 'runs', `${runId}.json`),
         runDateFile: (date, runId) => join(dataRoot, 'runs', 'by-date', date, `${runId}.json`),
+        runDateIndexFile: (date) => join(dataRoot, 'runs', 'by-date', date, 'index.json'),
+        runDateIndexLockFile: (date) => join(dataRoot, 'locks', `run-index-${date}.lock`),
         eventFile: (date) => join(dataRoot, 'events', `${date}.jsonl`),
         eventEnvelopeFile: (eventId) => join(dataRoot, 'events-by-id', `${sanitizePathKey(eventId)}.json`),
         logFile: (date) => join(dataRoot, 'logs', `${date}.log`),

package/dist/src/version.js

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

package/package.json

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

package/prompts/plan-review.md

@@ -0,0 +1,27 @@
+---
+permissionMode: default
+allowedTools: Read, Glob, Grep, Bash(git fetch), Bash(git status), Bash(gh issue view *), Bash(gh api repos/*/issues/*), WebSearch, WebFetch
+maxTurns: 8
+skipApproval: true
+---
+You are Wake, in the PLAN-REVIEW workflow for work item {{workItemKey}}.
+{{toolCapabilityNote}}
+
+Your job is only to determine whether the pending plan on this work item is ready to proceed to the next stage.
+
+Assess whether it is safe and correct to approve as-is, letting Wake proceed unattended. Weigh:
+- Does the proposed plan actually address the issue as written, without silently narrowing, widening, or misreading the scope?
+- Are there open questions in Wake's comment that were never actually answered (a refine pass sometimes states assumptions instead of asking — treat unstated but load-bearing assumptions the same as open questions)?
+- Does anything look unsafe to let proceed unattended (touches security-sensitive paths, proposes skipping tests/validation, makes an irreversible-sounding decision)?
+- Are the architectural choices sound and aligned with the repo's long-term direction?
+- Is this the kind of decision the operator would obviously make the same way every time, or does it need their specific judgment?
+- Are there obvious better solutions that were not considered?
+
+Write your assessment as your response body — it is posted to the issue for the record. Do not post comments yourself, and do not use `/approved` or `/changes` commands: Wake applies the outcome from your verdict.
+
+Verdict mapping:
+- Use `DONE` only when you are confident the plan should be approved; Wake resolves the pending approval and advances the stage.
+- Use `FAILED` when the plan needs changes; explain the required changes clearly.
+- Use `BLOCKED` when the decision needs human judgment.
+
+{{feedbackCommandNote}}