@atolis-hq/wake 0.2.35 → 0.2.36

package/dist/src/core/policy-engine.js

@@ -21,6 +21,8 @@ function belowFailureRetryLimit(issue, config) {
 // quoted reply containing /approved does not approve the gate.
 const approvedCommandPattern = /^\/approved\b/i;
 const changesCommandPattern = /^\/changes\b/i;
+const prReviewApprovalMarker = '<!-- wake:pr-review-approved -->';
+const prReviewChangesMarker = '<!-- wake:pr-review-changes-requested -->';
 // The action Wake runs when a correlated PR gets new reviewer feedback while
 // the work item is awaiting approval. Not configurable per workflow: it's a
 // lateral response to a PR surface, not a workflow stage.
@@ -63,6 +65,16 @@ function latestUnhandledHumanComment(issue) {
     }
     return latestHumanComment;
 }
+function latestUnhandledComment(issue) {
+    const context = issue.context;
+    const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
+    const lastBotIndex = issue.comments.reduce((acc, c, i) => (c.isBotAuthored ? i : acc), -1);
+    const latest = issue.comments.slice(lastBotIndex).at(-1);
+    if (latest === undefined || latest.id === handledCommentId) {
+        return undefined;
+    }
+    return latest;
+}
 export function createPolicyEngine() {
     return {
         isEligible(issue, config) {
@@ -159,10 +171,16 @@ export function createPolicyEngine() {
             // No new human comment since the last handled one; stay idle instead of
             // falling through to the LLM while awaiting explicit approval feedback.
             const latestHumanComment = latestUnhandledHumanComment(issue);
-            if (latestHumanComment === undefined) {
+            const latestComment = latestUnhandledComment(issue);
+            if (pendingAction === undefined) {
                 return null;
             }
-            if (pendingAction === undefined) {
+            if (latestComment?.isBotAuthored === true &&
+                latestComment.resourceUri !== undefined &&
+                latestComment.body.includes(prReviewApprovalMarker)) {
+                return { approved: true, pendingAction };
+            }
+            if (latestHumanComment === undefined) {
                 return null;
             }
             const approved = matchesCommand(latestHumanComment.body, approvedCommandPattern);
@@ -188,6 +206,12 @@ export function createPolicyEngine() {
                 return null;
             }
             const latestHumanComment = latestUnhandledHumanComment(issue);
+            const latestComment = latestUnhandledComment(issue);
+            if (latestComment?.isBotAuthored === true &&
+                latestComment.resourceUri !== undefined &&
+                latestComment.body.includes(prReviewChangesMarker)) {
+                return reviewFeedbackAction;
+            }
             // resourceUri is set only on comments folded from a correlated PR/review
             // surface (schema.ts's commentSnapshotSchema: "absent = the originating
             // issue thread"). A comment on that surface is itself the deliberate

package/dist/src/core/projection-updater.js

@@ -192,6 +192,16 @@ async function applyEvent(current, event, ctx, config) {
     }
     if (event.sourceEventType === 'wake.run.completed') {
         const payload = event.payload;
+        if (payload.watcherRun === true) {
+            return parseIssueStateRecord({
+                ...current,
+                wake: {
+                    ...current.wake,
+                    syncedAt: event.ingestedAt,
+                    recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+                },
+            });
+        }
         // Clear the session when the stage moves forward (new action needed) or the
         // run failed outright. Keep it for BLOCKED so the same action can resume
         // the in-progress session after a human replies.

package/dist/src/core/scheduled-workflow-source.js

@@ -63,7 +63,7 @@ function floorToMinute(date) {
     copy.setUTCSeconds(0, 0);
     return copy;
 }
-function previousMatchingSlot(input) {
+export function previousMatchingSlot(input) {
     const parsed = parseCron(input.cron);
     const slot = floorToMinute(input.now);
     const afterMs = input.after === undefined ? undefined : Date.parse(input.after);

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

@@ -1,22 +1,27 @@
+import { join } from 'node:path';
 import { createLifecycleService } from './lifecycle-service.js';
 import { createPolicyEngine } from './policy-engine.js';
 import { createProjectionUpdater } from './projection-updater.js';
 import { acquireFileLock } from '../lib/lock.js';
-import { CORRELATION_REGISTERED_EVENT, parseRunnerArtifacts, parseRunnerResult, } from '../domain/schema.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 { chooseAction as chooseWorkflowAction, isKnownWorkflowStage, workflowChangedBlockReason, workflowForProjection, workflowLabelForWorkflowName, workflowNameForProjection, } from '../domain/workflows.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';
 import { customCommandWorkspace, isCustomCommandAction } from '../domain/custom-commands.js';
 import { resolveQuotaPauseUntil } from './quota-backoff.js';
 import { createLabelsEvent, createPublishIntentEvent } from './event-builders.js';
+import { previousMatchingSlot } from './scheduled-workflow-source.js';
 import { createOutbox } from './outbox.js';
 import { createEventResolver } from './event-resolver.js';
 import { createStaleRunReconciler } from './stale-run-reconciler.js';
 import { createWorkspaceCleanup } from './workspace-cleanup.js';
 import { createRunLease, isRunLeaseExpired, renewRunLease, runLeaseRenewalIntervalMs, } from './run-lease.js';
 import { currentProcessIdentity, processIdentityMatches } from '../lib/process-identity.js';
+import { readJsonFile, writeJsonFile } from '../lib/json-file.js';
+import { isMissingPathError } from '../lib/state-health.js';
+const prReviewApprovalMarker = '<!-- wake:pr-review-approved -->';
 function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
@@ -317,6 +322,201 @@ export function createTickRunner(deps) {
             await lock.release();
         }
     }
+    function watcherStatus(projection) {
+        const sentinel = projection.context.lastRunSentinel;
+        if (sentinel === 'AWAITING_APPROVAL')
+            return 'awaiting-approval';
+        if (sentinel === 'BLOCKED')
+            return 'blocked';
+        if (sentinel === 'FAILED')
+            return 'failed';
+        if (sentinel === 'DONE')
+            return 'done';
+        return 'pending';
+    }
+    function watcherKey(input) {
+        return [
+            input.workItemKey,
+            input.parentWorkflowName,
+            input.parentStage,
+            String(input.watcherIndex),
+        ]
+            .join('__')
+            .replace(/[^A-Za-z0-9._-]/g, '_');
+    }
+    function watcherStateFile(key) {
+        return join(deps.stateStore.paths.dataRoot, 'watchers', `${key}.json`);
+    }
+    async function readWatcherState(key) {
+        try {
+            const raw = await readJsonFile(watcherStateFile(key));
+            if (raw === null || typeof raw !== 'object')
+                return null;
+            const record = raw;
+            return record.schemaVersion === 1 &&
+                record.key === key &&
+                typeof record.updatedAt === 'string'
+                ? {
+                    schemaVersion: 1,
+                    key,
+                    ...(typeof record.lastDispatchedEventId === 'string'
+                        ? { lastDispatchedEventId: record.lastDispatchedEventId }
+                        : {}),
+                    ...(typeof record.lastDispatchedSlot === 'string'
+                        ? { lastDispatchedSlot: record.lastDispatchedSlot }
+                        : {}),
+                    updatedAt: record.updatedAt,
+                }
+                : null;
+        }
+        catch (error) {
+            if (isMissingPathError(error))
+                return null;
+            throw error;
+        }
+    }
+    async function writeWatcherState(key, patch) {
+        const current = await readWatcherState(key);
+        await writeJsonFile(watcherStateFile(key), {
+            schemaVersion: 1,
+            key,
+            ...(current?.lastDispatchedEventId === undefined
+                ? {}
+                : { lastDispatchedEventId: current.lastDispatchedEventId }),
+            ...(current?.lastDispatchedSlot === undefined
+                ? {}
+                : { lastDispatchedSlot: current.lastDispatchedSlot }),
+            ...patch,
+            updatedAt: deps.clock.now().toISOString(),
+        });
+    }
+    async function nextWatcherDispatch(projections, now) {
+        for (const projection of projections) {
+            const parentWorkflow = workflowForProjection(projection, deps.config);
+            if (parentWorkflow === null)
+                continue;
+            const parentWorkflowName = workflowNameForProjection(projection, deps.config);
+            const stage = parentWorkflow.stages[projection.wake.stage];
+            if (stage === undefined)
+                continue;
+            for (const [watcherIndex, watcher] of (stage.watch ?? []).entries()) {
+                if (!watcher.while.status.includes(watcherStatus(projection)))
+                    continue;
+                const key = watcherKey({
+                    workItemKey: projection.workItemKey,
+                    parentWorkflowName,
+                    parentStage: projection.wake.stage,
+                    watcherIndex,
+                });
+                const state = await readWatcherState(key);
+                if (watcher.on !== undefined) {
+                    const events = await deps.stateStore.listRecentEventEnvelopes({
+                        workItemKey: projection.workItemKey,
+                        direction: 'internal',
+                        limit: 200,
+                    });
+                    const matchingEvents = events
+                        .filter((event) => watcher.on.event.includes(event.sourceEventType))
+                        .sort((left, right) => left.ingestedAt.localeCompare(right.ingestedAt));
+                    const cursorIndex = state?.lastDispatchedEventId === undefined
+                        ? -1
+                        : matchingEvents.findIndex((event) => event.eventId === state.lastDispatchedEventId);
+                    const newest = matchingEvents.slice(cursorIndex + 1).at(-1);
+                    if (newest !== undefined) {
+                        return {
+                            projection,
+                            parentWorkflowName,
+                            parentStage: projection.wake.stage,
+                            watcherIndex,
+                            targetWorkflowName: watcher.workflow,
+                            trigger: { kind: 'event', eventId: newest.eventId },
+                        };
+                    }
+                }
+                if (watcher.schedule !== undefined) {
+                    const slot = previousMatchingSlot({
+                        cron: watcher.schedule.cron,
+                        now,
+                        ...(state?.lastDispatchedSlot === undefined ? {} : { after: state.lastDispatchedSlot }),
+                    });
+                    if (slot !== null) {
+                        return {
+                            projection,
+                            parentWorkflowName,
+                            parentStage: projection.wake.stage,
+                            watcherIndex,
+                            targetWorkflowName: watcher.workflow,
+                            trigger: { kind: 'schedule', slot },
+                        };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    async function resolvePrReviewTarget(input) {
+        if (deps.artifactVerifier === undefined) {
+            return null;
+        }
+        const { artifacts } = parseRunnerArtifacts(input.runnerResult.result);
+        for (const artifact of artifacts) {
+            const verified = await deps.artifactVerifier.verify(artifact, {
+                branch: branchNameForIssue(input.projection.issue.number),
+                repo: input.projection.issue.repo,
+            });
+            if (verified === null) {
+                continue;
+            }
+            const incumbent = await deps.resourceIndex.resolve(verified.resourceUri);
+            if (incumbent !== undefined && incumbent !== input.projection.workItemKey) {
+                const conflict = createEventEnvelope({
+                    eventId: `${input.runId}-pr-review-primary-conflict`,
+                    workItemKey: input.projection.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'internal',
+                    sourceSystem: 'wake',
+                    sourceEventType: CORRELATION_PRIMARY_CONFLICT_EVENT,
+                    sourceRefs: { runId: input.runId },
+                    occurredAt: input.occurredAt,
+                    ingestedAt: input.occurredAt,
+                    trigger: 'context-only',
+                    payload: {
+                        resourceUri: verified.resourceUri,
+                        incumbentWorkItemKey: incumbent,
+                    },
+                });
+                const appended = await deps.stateStore.appendEventEnvelope(conflict);
+                await projectionUpdater.rebuildFromEvents([appended]);
+                return null;
+            }
+            if (incumbent === undefined) {
+                const event = createEventEnvelope({
+                    eventId: `${input.runId}-pr-review-artifact-${verified.resourceUri.replace(/[^a-z0-9]+/gi, '-')}`,
+                    workItemKey: input.projection.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'internal',
+                    sourceSystem: 'wake',
+                    sourceEventType: CORRELATION_REGISTERED_EVENT,
+                    sourceRefs: { runId: input.runId },
+                    occurredAt: input.occurredAt,
+                    ingestedAt: input.occurredAt,
+                    trigger: 'context-only',
+                    payload: {
+                        resourceUri: verified.resourceUri,
+                        role: 'implementation',
+                        relation: 'primary',
+                        provenance: 'agent-reported',
+                        registeredBy: input.runId,
+                        idempotencyKey: `${input.runId}:pr-review-artifact-registration:${verified.resourceUri}`,
+                    },
+                });
+                const appended = await deps.stateStore.appendEventEnvelope(event);
+                await projectionUpdater.rebuildFromEvents([appended]);
+            }
+            return verified.resourceUri;
+        }
+        return null;
+    }
     async function runRunnerTick() {
         const lock = await acquireFileLock(deps.stateStore.paths.runnerLockFile);
         if (!lock.acquired) {
@@ -335,7 +535,12 @@ export function createTickRunner(deps) {
             if (await parkConfigDriftedProjections(projections)) {
                 return { status: 'processed' };
             }
-            let candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
+            const watcherDispatch = await nextWatcherDispatch(projections, tickStartedAt);
+            let 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' };
             }
@@ -357,19 +562,41 @@ export function createTickRunner(deps) {
                     candidate = (await deps.stateStore.readIssueState(candidate.workItemKey)) ?? candidate;
                 }
             }
-            if (policy.resolveNextEligibleAction(candidate, deps.config) === null) {
+            if (!watcherRun && policy.resolveNextEligibleAction(candidate, deps.config) === null) {
                 return { status: 'idle' };
             }
             const workflow = workflowForProjection(candidate, deps.config);
             if (workflow === null) {
                 return { status: 'idle' };
             }
-            const workflowName = workflowNameForProjection(candidate, deps.config);
+            let workflowName = workflowNameForProjection(candidate, deps.config);
             let action;
             let command;
             let claimedStage = candidate.wake.stage;
             let workspaceMode = 'none';
-            if (isAwaitingApproval(candidate)) {
+            if (watcherDispatch !== null) {
+                const targetWorkflow = deps.config.workflows[watcherDispatch.targetWorkflowName];
+                if (targetWorkflow === undefined) {
+                    return { status: 'idle' };
+                }
+                const entryStageName = workflowEntryStage(targetWorkflow);
+                const entryStage = targetWorkflow.stages[entryStageName];
+                if (entryStage === undefined) {
+                    return { status: 'idle' };
+                }
+                action = entryStage.action ?? entryStageName;
+                claimedStage = entryStageName;
+                workspaceMode = entryStage.workspace;
+                workflowName = watcherDispatch.targetWorkflowName;
+                watcherStateKeyForRun = watcherKey({
+                    workItemKey: watcherDispatch.projection.workItemKey,
+                    parentWorkflowName: watcherDispatch.parentWorkflowName,
+                    parentStage: watcherDispatch.parentStage,
+                    watcherIndex: watcherDispatch.watcherIndex,
+                });
+                watcherTriggerForRun = watcherDispatch.trigger;
+            }
+            else if (isAwaitingApproval(candidate)) {
                 const customCommandRequest = policy.resolveCustomCommandRequest(candidate, deps.config);
                 if (customCommandRequest !== null) {
                     action = customCommandRequest.action;
@@ -508,6 +735,13 @@ export function createTickRunner(deps) {
                 workerProcessStartedAt: workerIdentity.processStartedAt,
                 metadata: {
                     sourceRevision,
+                    ...(watcherRun
+                        ? {
+                            watcher: true,
+                            watcherWorkflow: workflowName,
+                            watcherTrigger: watcherTriggerForRun,
+                        }
+                        : {}),
                 },
             };
             await deps.stateStore.writeRunRecord(runningRecord);
@@ -536,13 +770,19 @@ export function createTickRunner(deps) {
                 payload: {
                     action,
                     priorStage: candidate.wake.stage,
-                    claimedStage,
+                    ...(watcherRun ? {} : { claimedStage }),
                     sourceRevision,
+                    ...(watcherRun ? { watcherRun: true, watcherTrigger: watcherTriggerForRun } : {}),
                 },
             });
             await deps.stateStore.appendEventEnvelope(claimedEvent);
             await transitionRunLifecycle('CLAIMED');
             await projectionUpdater.rebuildFromEvents([claimedEvent]);
+            if (watcherStateKeyForRun !== undefined && watcherTriggerForRun !== undefined) {
+                await writeWatcherState(watcherStateKeyForRun, watcherTriggerForRun.kind === 'event'
+                    ? { lastDispatchedEventId: watcherTriggerForRun.eventId }
+                    : { lastDispatchedSlot: watcherTriggerForRun.slot });
+            }
             await deliverOutboundEvent(createLabelsEvent({
                 projection: candidate,
                 runId,
@@ -594,9 +834,19 @@ export function createTickRunner(deps) {
                 const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
                 await transitionRunLifecycle('RUNNING');
                 startLeaseRenewal();
+                const runnerProjection = watcherRun
+                    ? {
+                        ...candidate,
+                        wake: {
+                            ...candidate.wake,
+                            sessionId: undefined,
+                            sessionCli: undefined,
+                        },
+                    }
+                    : candidate;
                 const runnerResult = await deps.runner.run({
                     action,
-                    projection: candidate,
+                    projection: runnerProjection,
                     recentEvents,
                     config: deps.config,
                     runId,
@@ -639,7 +889,16 @@ export function createTickRunner(deps) {
                     ? null
                     : lifecycle.nextStageFromSentinel(claimedStage, sentinel, workflow);
                 const finishedAt = deps.clock.now().toISOString();
-                if (workspaceMode === 'branch') {
+                let prReviewTargetResourceUri = null;
+                if (watcherRun && action === 'pr-review') {
+                    prReviewTargetResourceUri = await resolvePrReviewTarget({
+                        projection: candidate,
+                        runId,
+                        runnerResult,
+                        occurredAt: finishedAt,
+                    });
+                }
+                else if (workspaceMode === 'branch') {
                     await registerReportedArtifacts({
                         projection: candidate,
                         runId,
@@ -764,21 +1023,24 @@ export function createTickRunner(deps) {
                         envelope: parsedRunnerResult.envelope,
                         executionOutcome,
                         ...(workflowOutcome !== undefined ? { workflowOutcome } : {}),
+                        ...(watcherRun ? { watcherRun: true, watcherTrigger: watcherTriggerForRun } : {}),
                     },
                 });
                 await deps.stateStore.appendEventEnvelope(runCompletedEvent);
                 await projectionUpdater.rebuildFromEvents([runCompletedEvent]);
-                await deliverOutboundEvent(createLabelsEvent({
-                    projection: candidate,
-                    runId,
-                    statusLabel: statusLabelForOutcome({
-                        sentinel,
-                        stage: nextStage ?? claimedStage,
-                    }),
-                    stageLabel: stageLabelForStage(nextStage ?? claimedStage),
-                    workflowLabel: workflowLabelForWorkflowName(workflowName),
-                    occurredAt: finishedAt,
-                }));
+                if (!watcherRun) {
+                    await deliverOutboundEvent(createLabelsEvent({
+                        projection: candidate,
+                        runId,
+                        statusLabel: statusLabelForOutcome({
+                            sentinel,
+                            stage: nextStage ?? claimedStage,
+                        }),
+                        stageLabel: stageLabelForStage(nextStage ?? claimedStage),
+                        workflowLabel: workflowLabelForWorkflowName(workflowName),
+                        occurredAt: finishedAt,
+                    }));
+                }
                 const publishIntent = createPublishIntentEvent({
                     projection: candidate,
                     runId,
@@ -793,7 +1055,32 @@ export function createTickRunner(deps) {
                         ? { previousFailureClass: candidate.context.lastFailureClass }
                         : {}),
                 });
-                if (shouldPublishRunResult({
+                if (watcherRun && action === 'pr-review') {
+                    if (prReviewTargetResourceUri !== null &&
+                        (sentinel === 'DONE' || sentinel === 'FAILED')) {
+                        await deliverOutboundEvent({
+                            ...publishIntent,
+                            sourceRefs: {
+                                ...publishIntent.sourceRefs,
+                                resourceUri: prReviewTargetResourceUri,
+                            },
+                            payload: {
+                                ...publishIntent.payload,
+                                kind: sentinel === 'DONE' ? 'approval-request' : 'status-update',
+                                body: sentinel === 'DONE'
+                                    ? `${parsedRunnerResult.body}\n\n${prReviewApprovalMarker}`
+                                    : `${parsedRunnerResult.body}\n\n<!-- wake:pr-review-changes-requested -->`,
+                                idempotencyKey: `${runId}:pr-review-verdict-comment`,
+                            },
+                        });
+                    }
+                    else {
+                        await suppressOutboundEvent(publishIntent, {
+                            suppressedPublishReason: 'pr-review-no-actionable-verdict',
+                        });
+                    }
+                }
+                else if (shouldPublishRunResult({
                     failureClass: runnerResult.failureClass,
                     previousFailureClass: candidate.context.lastFailureClass,
                 })) {

package/dist/src/domain/schema.js

@@ -371,12 +371,26 @@ const runnerHealthEntrySchema = z.object({
     lastFailureAt: isoTimestampSchema.optional(),
 });
 const workflowWorkspaceSchema = z.enum(['none', 'read-only', 'branch']);
+const workflowTriggerScheduleSchema = z.object({
+    cron: z.string().min(1),
+});
 const workflowStageSchema = stageRouteSchema.extend({
     workspace: workflowWorkspaceSchema,
     onDone: identifierSchema,
-});
-const workflowTriggerScheduleSchema = z.object({
-    cron: z.string().min(1),
+    watch: z
+        .array(z.object({
+        while: z.object({
+            status: z.array(z.string().min(1)).min(1),
+        }),
+        on: z
+            .object({
+            event: z.array(z.string().min(1)).min(1),
+        })
+            .optional(),
+        schedule: workflowTriggerScheduleSchema.optional(),
+        workflow: identifierSchema,
+    }))
+        .optional(),
 });
 const workflowTriggerSchema = z.object({
     schedule: workflowTriggerScheduleSchema.optional(),
@@ -831,6 +845,22 @@ export const wakeConfigSchema = wakeConfigBaseSchema.superRefine((config, ctx) =
                     message: `Workflow stage "${stageName}" omits action but no prompts/${stageName}.md template exists.`,
                 });
             }
+            for (const [index, watcher] of (stage.watch ?? []).entries()) {
+                if (watcher.on === undefined && watcher.schedule === undefined) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ['workflows', workflowName, 'stages', stageName, 'watch', index],
+                        message: 'Watcher must declare at least one of on or schedule.',
+                    });
+                }
+                if (config.workflows[watcher.workflow] === undefined) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ['workflows', workflowName, 'stages', stageName, 'watch', index, 'workflow'],
+                        message: `Watcher targets unknown workflow "${watcher.workflow}".`,
+                    });
+                }
+            }
         }
         if (actualEntryStage !== undefined &&
             stageSet.has(actualEntryStage) &&

package/dist/src/version.js

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

package/package.json

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

package/prompts/pr-review.md

@@ -0,0 +1,29 @@
+---
+permissionMode: default
+allowedTools: Bash(gh pr view *), Bash(gh pr diff *), Bash(gh pr checks *), Bash(gh run view *), Bash(gh api repos/*/pulls/*), Bash(gh api repos/*/commits/*), Bash(git status), Bash(git log *), Bash(git diff *), Read, Glob, Grep
+maxTurns: 8
+skipApproval: true
+---
+You are Wake, in the PR-REVIEW workflow for work item {{workItemKey}}.
+
+Objective:
+- Identify the pull request for this work item using read-only GitHub commands.
+- Review the PR's diff, tests/checks, and surrounding code for correctness.
+- Report the PR you examined using a `wake-artifacts` block.
+- End with the Wake result envelope.
+
+Verdict mapping:
+- Use `DONE` only when you are confident the PR is safe to merge.
+- Use `FAILED` when the PR needs changes; explain the required changes clearly.
+- Use `BLOCKED` when you cannot determine a safe verdict.
+
+Safety rules:
+- Do not merge, approve via GitHub review, enable auto-merge, edit labels, push commits, or perform any administrative GitHub mutation.
+- Do not use any `gh` subcommand other than the read-only commands allowed for this prompt.
+- If you cannot find exactly one plausible PR for this work item, report `BLOCKED`.
+- If the PR you reviewed is not reported in the `wake-artifacts` block, Wake will ignore the verdict.
+
+Artifact reporting:
+```wake-artifacts
+{ "artifacts": [{ "kind": "pr", "url": "<the PR URL>" }] }
+```