@atolis-hq/wake 0.2.56 → 0.2.58

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

@@ -334,38 +334,62 @@ export function createTickRunner(deps) {
             nextStage: null,
         };
     }
+    // GitHub rejects a review that would approve the PR's own author (422 "Can
+    // not approve your own pull request") — the default single-identity setup
+    // where implement and pr-review share one bot account. Permanent, not
+    // transient: never worth retrying, so it's treated as a policy block
+    // rather than left to propagate as an uncaught tick failure.
+    function isSelfApprovalError(error) {
+        return (error instanceof Error &&
+            error.status === 422 &&
+            error.message.toLowerCase().includes('approve your own pull request'));
+    }
     async function performApprovedPrMergeActions(input) {
         if (deps.prMergeActor === undefined ||
             input.approvalResolution.targetResourceUri === undefined ||
             input.approvalResolution.triggeringCommentId === undefined) {
-            return;
+            return { blocked: false };
         }
         const targetResourceUri = input.approvalResolution.targetResourceUri;
         const commentId = input.approvalResolution.triggeringCommentId.replace(/[^a-z0-9]+/gi, '-');
         const reviewBody = reviewerMessageFromApprovalComment(input.approvalResolution.triggeringCommentBody ?? '');
+        let blockedReason = null;
         const approvedEventId = `pr-merge-approved-${commentId}`;
         if (input.mergePolicy.approve &&
             (await deps.stateStore.readEventEnvelope(approvedEventId)) === null) {
-            await deps.prMergeActor.approve(targetResourceUri, reviewBody);
-            const occurredAt = eventStampNow();
-            await deps.stateStore.appendEventEnvelope(createEventEnvelope({
-                eventId: approvedEventId,
-                workItemKey: input.projection.workItemKey,
-                streamScope: 'work-item',
-                direction: 'internal',
-                sourceSystem: 'wake',
-                sourceEventType: PR_REVIEW_APPROVED_EVENT,
-                sourceRefs: {
-                    resourceUri: targetResourceUri,
-                    commentId: input.approvalResolution.triggeringCommentId,
-                },
-                occurredAt,
-                ingestedAt: occurredAt,
-                trigger: 'context-only',
-                payload: {
-                    idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-review-approval`,
-                },
-            }));
+            let approved = true;
+            try {
+                await deps.prMergeActor.approve(targetResourceUri, reviewBody);
+            }
+            catch (error) {
+                if (!isSelfApprovalError(error)) {
+                    throw error;
+                }
+                approved = false;
+                blockedReason =
+                    'Merge policy blocked the approval step because GitHub refuses a review that approves its own author (implement and pr-review run as the same bot identity). Either disable merge.approve and rely on merge.autoMerge alone, or configure a second reviewer identity.';
+            }
+            if (approved) {
+                const occurredAt = eventStampNow();
+                await deps.stateStore.appendEventEnvelope(createEventEnvelope({
+                    eventId: approvedEventId,
+                    workItemKey: input.projection.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'internal',
+                    sourceSystem: 'wake',
+                    sourceEventType: PR_REVIEW_APPROVED_EVENT,
+                    sourceRefs: {
+                        resourceUri: targetResourceUri,
+                        commentId: input.approvalResolution.triggeringCommentId,
+                    },
+                    occurredAt,
+                    ingestedAt: occurredAt,
+                    trigger: 'context-only',
+                    payload: {
+                        idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-review-approval`,
+                    },
+                }));
+            }
         }
         const autoMergeEventId = `pr-auto-merge-enabled-${commentId}`;
         if (input.mergePolicy.autoMerge &&
@@ -391,6 +415,10 @@ export function createTickRunner(deps) {
                 },
             }));
         }
+        if (blockedReason !== null) {
+            return { blocked: true, reason: blockedReason };
+        }
+        return { blocked: false };
     }
     // The one deterministic approval transition: /approved, wake:auto, and a
     // watcher child's onSuccess.approve all resolve a pending approval through
@@ -1031,7 +1059,20 @@ export function createTickRunner(deps) {
                 action = entryStage.action ?? entryStageName;
                 claimedStage = entryStageName;
                 workspaceMode = entryStage.workspace;
-                promptContextOverrides = entryStage.promptContext;
+                // The triggering event's own body (e.g. a refine plan comment) is
+                // durable and already local the moment this fires — projection.comments
+                // only gets it once a later GitHub poll echoes it back, which a watcher
+                // dispatched off the same-tick completion event can easily outrace.
+                const triggeringEvent = watcherDispatch.trigger.kind === 'event'
+                    ? await deps.stateStore.readEventEnvelope(watcherDispatch.trigger.eventId)
+                    : null;
+                const triggeringBody = triggeringEvent?.payload.body;
+                promptContextOverrides = {
+                    ...entryStage.promptContext,
+                    ...(typeof triggeringBody === 'string'
+                        ? { parentPendingReviewBody: triggeringBody }
+                        : {}),
+                };
                 workflowName = watcherDispatch.targetWorkflowName;
                 watcherStateKeyForRun = watcherKey({
                     workItemKey: watcherDispatch.projection.workItemKey,
@@ -1078,11 +1119,19 @@ export function createTickRunner(deps) {
                                     workflowName,
                                 });
                             }
-                            await performApprovedPrMergeActions({
+                            const mergeActionsResult = await performApprovedPrMergeActions({
                                 projection: candidate,
                                 approvalResolution,
                                 mergePolicy,
                             });
+                            if (mergeActionsResult.blocked) {
+                                return await publishPrMergePolicyBlock({
+                                    projection: candidate,
+                                    approvalResolution,
+                                    reason: mergeActionsResult.reason,
+                                    workflowName,
+                                });
+                            }
                         }
                         const approvalId = `approval-${candidate.issue.number}-${deps.clock.now().getTime()}`;
                         const approvedAt = deps.clock.now().toISOString();

package/dist/src/version.js

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

package/package.json

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

package/prompts/plan-review.md

@@ -9,6 +9,15 @@ You are Wake, in the PLAN-REVIEW workflow for work item {{workItemKey}}.
 
 Your job is only to determine whether the pending plan on this work item is ready to proceed to the next stage.
 
+The pending plan under review:
+<wake-pending-plan>
+{{#if parentPendingReviewBody}}
+{{parentPendingReviewBody}}
+{{else}}
+(Wake did not attach the pending plan text to this run. Fall back to `gh issue view {{issueNumber}}` to read it directly — do not assume no plan exists just because it isn't shown above.)
+{{/if}}
+</wake-pending-plan>
+
 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)?

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.