@atolis-hq/wake 0.2.55 → 0.2.57

package/dist/src/adapters/runner/stage-prompt.js

@@ -168,6 +168,10 @@ export async function buildStagePrompt(input) {
     if (resolvedWorkspaceMode === 'branch') {
         context.branch = branchNameForIssue(input.projection.issue.number);
     }
+    // Opaque to this file (resourceUri locator grammar is provider-specific,
+    // ADR 0001 §1) — passed through as-is so a provider-aware prompt template
+    // can interpret it without stage-prompt.ts knowing any adapter's format.
+    context.correlatedResources = input.projection.correlatedResources;
     const allowedTools = parseFrontmatterList(template.frontmatter.allowedTools);
     const allowedToolsListStr = allowedTools.length > 0 ? allowedTools.join(', ') : '(none)';
     context.allowedToolsList = allowedToolsListStr;

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

@@ -195,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, '\\$&');
@@ -390,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
@@ -1041,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`,
@@ -1102,7 +1129,7 @@ export function createTickRunner(deps) {
                                 },
                                 outcome: {
                                     approved: true,
-                                    nextStage,
+                                    nextStage: applied.nextStage,
                                     reason: approvalResolution.reason,
                                 },
                                 timestamp: approvedAt,
@@ -1112,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 {
@@ -1733,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({
@@ -1751,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/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.55",
+  "version": "0.2.57",
   "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}}

package/prompts/pr-review.md

@@ -1,13 +1,19 @@
 ---
 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
+allowedTools: Bash(gh pr view *), Bash(gh pr diff *), Bash(gh pr checks *), Bash(gh pr list *), Bash(gh run view *), Bash(gh api repos/*/pulls*), Bash(gh api repos/*/commits/*), Bash(gh issue view *), 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}}.
 
+Wake's known correlated resources for this work item (each has a `resourceUri` in `<provider>:<kind>:<locator>` form, e.g. a GitHub PR is `github:pr:<repo>#<number>`):
+```
+{{correlatedResources}}
+```
+
 Objective:
-- Identify the pull request for this work item using read-only GitHub commands.
+- If a resource above has `role: "implementation"` and `relation: "primary"`, that is the PR for this work item — use its `resourceUri` to identify the PR number (do not use the issue number) and review that PR. Do not substitute or guess a different PR.
+- Otherwise, identify the pull request for this work item using read-only GitHub commands (`gh pr list`, `gh api repos/*/pulls`, `gh issue view {{issueNumber}}` to find a linked PR). Never assume the PR number equals the issue number — verify it. If you cannot find exactly one plausible PR, report `BLOCKED` rather than guess.
 - 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.