@atolis-hq/wake 0.2.57 → 0.2.58

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 = "gd9be6f5";
+export const wakeVersion = "g4624f39";

package/package.json

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