@atolis-hq/wake 0.2.57 → 0.2.59

package/README.md

@@ -122,11 +122,11 @@ Wake has no chat UI you need to check for status. Your ticketing system is the
 interface: Wake posts progress updates, asks clarifying questions, and reports
 results as comments on the ticket, and reflects stage and status as labels on
 it. When it's ready, it opens a pull request against your repo the normal way.
-Reviewing, approving, and merging happen exactly where they already do today —
+Reviewing, approving, and merging happen exactly where they already do today -
 nothing new to learn, no separate dashboard to babysit.
 
 A local control-plane UI exists for operators who want to watch runs, inspect
-events, or resume a session directly, but it's a window into the same state —
+events, or resume a session directly, but it's a window into the same state -
 not a required part of the workflow.
 
 ## Supported Agent CLIs
@@ -166,19 +166,19 @@ any time for the full command list, or see
 
 ## Documentation
 
-- [docs/getting-started.md](docs/getting-started.md) — packaged-install setup, sandbox lifecycle, `wake doctor`.
-- [docs/cli.md](docs/cli.md) — full CLI command reference.
-- [docs/vision.md](docs/vision.md) — the rationale and long-term direction for Wake.
-- [docs/architecture.md](docs/architecture.md) — module boundaries and the event-sourced core.
-- [docs/workflows.md](docs/workflows.md) — how stages, prompts, and runner routes are configured.
-- [docs/prompts.md](docs/prompts.md) — how prompt templates map to workflow stages.
-- [docs/configuration.md](docs/configuration.md) — `config.yaml`/`config.workflows.yaml` options and the operator correlation escape hatch.
-- [docs/development.md](docs/development.md) — source-checkout dev setup (`wake-dev`), npm scripts, formatting, self-update, GitHub polling.
-- [docs/runner-comparison.md](docs/runner-comparison.md) — capability differences between supported runners.
+- [docs/getting-started.md](docs/getting-started.md) - packaged-install setup, sandbox lifecycle, `wake doctor`.
+- [docs/cli.md](docs/cli.md) - full CLI command reference.
+- [docs/vision.md](docs/vision.md) - the rationale and long-term direction for Wake.
+- [docs/architecture.md](docs/architecture.md) - module boundaries and the event-sourced core.
+- [docs/workflows.md](docs/workflows.md) - how stages, prompts, and runner routes are configured.
+- [docs/prompts.md](docs/prompts.md) - how prompt templates map to workflow stages.
+- [docs/configuration.md](docs/configuration.md) - `config.yaml`/`config.workflows.yaml` options and the operator correlation escape hatch.
+- [docs/development.md](docs/development.md) - source-checkout dev setup (`wake-dev`), npm scripts, formatting, self-update, GitHub polling.
+- [docs/runner-comparison.md](docs/runner-comparison.md) - capability differences between supported runners.
 
 ## Issues & Feature Requests
 
-Found a bug or have an idea for Wake? [Open an issue](https://github.com/atolis-hq/wake/issues/new) —
+Found a bug or have an idea for Wake? [Open an issue](https://github.com/atolis-hq/wake/issues/new) -
 bug reports and feature requests are both welcome.
 
 ## License

package/dist/src/adapters/github/github-client.js

@@ -216,14 +216,25 @@ export function createGitHubClient(token) {
                 body,
             });
         },
-        async enablePullRequestAutoMerge(pullRequestNodeId) {
-            await octokit.graphql(`mutation EnableWakeAutoMerge($pullRequestId: ID!) {
-          enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId }) {
+        // GitHub's REST merge method takes a lowercase merge_method value,
+        // distinct from the GraphQL PullRequestMergeMethod enum used by
+        // enablePullRequestAutoMerge below.
+        async mergePullRequest(owner, repo, pullNumber, mergeMethod) {
+            await octokit.rest.pulls.merge({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                merge_method: mergeMethod.toLowerCase(),
+            });
+        },
+        async enablePullRequestAutoMerge(pullRequestNodeId, mergeMethod) {
+            await octokit.graphql(`mutation EnableWakeAutoMerge($pullRequestId: ID!, $mergeMethod: PullRequestMergeMethod!) {
+          enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId, mergeMethod: $mergeMethod }) {
             pullRequest {
               id
             }
           }
-        }`, { pullRequestId: pullRequestNodeId });
+        }`, { pullRequestId: pullRequestNodeId, mergeMethod });
         },
         async replyToReviewComment(owner, repo, pullNumber, commentId, body) {
             return octokit.rest.pulls.createReplyForReviewComment({

package/dist/src/adapters/github/github-pull-request-merge-actor.js

@@ -1,3 +1,11 @@
+// GitHub's enablePullRequestAutoMerge mutation queues a merge pending
+// required checks; it refuses with an "already in clean status" error when
+// there's nothing left to wait for (checks already passed/skipped). That's
+// not a policy rejection — it just means the direct merge endpoint is the
+// right call instead of the auto-merge queue.
+function isAlreadyCleanError(error) {
+    return error instanceof Error && /is in clean status/i.test(error.message);
+}
 function parseGithubPullRequestResourceUri(resourceUri) {
     const match = /^github:pr:([^/]+)\/([^#]+)#(\d+)$/.exec(resourceUri);
     if (match === null) {
@@ -20,10 +28,18 @@ export function createGitHubPullRequestMergeActor(input) {
             const ref = parseGithubPullRequestResourceUri(resourceUri);
             await input.client.createPullRequestApproval(ref.owner, ref.repo, ref.pullNumber, body);
         },
-        async enableAutoMerge(resourceUri) {
+        async enableAutoMerge(resourceUri, mergeMethod) {
             const ref = parseGithubPullRequestResourceUri(resourceUri);
             const pr = await input.client.getPullRequest(ref.owner, ref.repo, ref.pullNumber);
-            await input.client.enablePullRequestAutoMerge(pr.node_id);
+            try {
+                await input.client.enablePullRequestAutoMerge(pr.node_id, mergeMethod);
+            }
+            catch (error) {
+                if (!isAlreadyCleanError(error)) {
+                    throw error;
+                }
+                await input.client.mergePullRequest(ref.owner, ref.repo, ref.pullNumber, mergeMethod);
+            }
         },
     };
 }

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

@@ -40,7 +40,13 @@ function newCommentsSinceLastRun(projection) {
         ? projection.comments.findIndex((comment) => comment.id === handledCommentId)
         : -1;
     const candidates = cursorIndex === -1 ? projection.comments : projection.comments.slice(cursorIndex + 1);
-    return candidates.filter((comment) => !comment.isBotAuthored);
+    // Bot-authored comments are normally excluded so an agent never reacts to
+    // its own prior status posts as new instructions. A bot-authored comment
+    // on a correlated PR/review surface (resourceUri set) is the one
+    // exception — resolvePendingReviewFeedback (policy-engine.ts) already
+    // treats that surface as the deliberate act that triggers `revise`, so
+    // its prompt must actually carry the comment that dispatched it.
+    return candidates.filter((comment) => !comment.isBotAuthored || comment.resourceUri !== undefined);
 }
 function previousCommentsThroughLastRun(projection) {
     const handledCommentId = projection.context.lastHandledCommentId;

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

@@ -334,63 +334,88 @@ export function createTickRunner(deps) {
             nextStage: null,
         };
     }
+    function describeMergeActorError(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
     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 ?? '');
+        // Never enumerate specific rejection reasons (self-approval, merge-method
+        // restrictions, branch protection, ...) by string-matching the merge
+        // actor's error — there are too many, and Wake shouldn't need to know
+        // its provider's vocabulary. Any failure here is permanent enough not to
+        // retry blindly forever, so it becomes a policy block with the actor's
+        // own message attached. approve and autoMerge are independent: one
+        // failing doesn't stop the other from being attempted.
+        const blockedReasons = [];
         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`,
-                },
-            }));
+            try {
+                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`,
+                    },
+                }));
+            }
+            catch (error) {
+                blockedReasons.push(`Merge policy blocked the approval step: ${describeMergeActorError(error)}`);
+            }
         }
         const autoMergeEventId = `pr-auto-merge-enabled-${commentId}`;
         if (input.mergePolicy.autoMerge &&
             (await deps.stateStore.readEventEnvelope(autoMergeEventId)) === null) {
-            await deps.prMergeActor.enableAutoMerge(targetResourceUri);
-            const occurredAt = eventStampNow();
-            await deps.stateStore.appendEventEnvelope(createEventEnvelope({
-                eventId: autoMergeEventId,
-                workItemKey: input.projection.workItemKey,
-                streamScope: 'work-item',
-                direction: 'internal',
-                sourceSystem: 'wake',
-                sourceEventType: PR_AUTO_MERGE_ENABLED_EVENT,
-                sourceRefs: {
-                    resourceUri: targetResourceUri,
-                    commentId: input.approvalResolution.triggeringCommentId,
-                },
-                occurredAt,
-                ingestedAt: occurredAt,
-                trigger: 'context-only',
-                payload: {
-                    idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-auto-merge`,
-                },
-            }));
+            try {
+                await deps.prMergeActor.enableAutoMerge(targetResourceUri, input.mergePolicy.mergeMethod);
+                const occurredAt = eventStampNow();
+                await deps.stateStore.appendEventEnvelope(createEventEnvelope({
+                    eventId: autoMergeEventId,
+                    workItemKey: input.projection.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'internal',
+                    sourceSystem: 'wake',
+                    sourceEventType: PR_AUTO_MERGE_ENABLED_EVENT,
+                    sourceRefs: {
+                        resourceUri: targetResourceUri,
+                        commentId: input.approvalResolution.triggeringCommentId,
+                    },
+                    occurredAt,
+                    ingestedAt: occurredAt,
+                    trigger: 'context-only',
+                    payload: {
+                        idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-auto-merge`,
+                    },
+                }));
+            }
+            catch (error) {
+                blockedReasons.push(`Merge policy blocked the auto-merge step: ${describeMergeActorError(error)}`);
+            }
         }
+        if (blockedReasons.length > 0) {
+            return { blocked: true, reason: blockedReasons.join(' ') };
+        }
+        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 +1056,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 +1116,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/domain/schema.js

@@ -416,10 +416,16 @@ const workflowWorkspaceSchema = z.enum(['none', 'read-only', 'branch']);
 const workflowTriggerScheduleSchema = z.object({
     cron: z.string().min(1),
 });
+// Matches GitHub's PullRequestMergeMethod GraphQL enum. GitHub's
+// enablePullRequestAutoMerge mutation defaults to MERGE when unspecified,
+// which fails outright on a repo that only allows squash/rebase merges — so
+// this must be explicit rather than inferred.
+export const mergeMethodSchema = z.enum(['MERGE', 'SQUASH', 'REBASE']);
 const approvedMergePolicySchema = z
     .object({
     approve: z.boolean().default(false),
     autoMerge: z.boolean().default(false),
+    mergeMethod: mergeMethodSchema.default('MERGE'),
     maxFilesChanged: z.number().int().positive().optional(),
     blockedPaths: z.array(z.string().min(1)).default([]),
     blockedLabels: z.array(z.string().min(1)).default([]),
@@ -427,6 +433,7 @@ const approvedMergePolicySchema = z
     .default({
     approve: false,
     autoMerge: false,
+    mergeMethod: 'MERGE',
     blockedPaths: [],
     blockedLabels: [],
 });

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 = "g2fd2fbe";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.57",
+  "version": "0.2.59",
   "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)?
@@ -24,4 +33,16 @@ Verdict mapping:
 - Use `FAILED` when the plan needs changes; explain the required changes clearly.
 - Use `BLOCKED` when the decision needs human judgment.
 
+Do not state your verdict in prose alone (e.g. "Verdict: DONE") — Wake does
+not parse prose. End your response with the Wake result envelope, exactly:
+
+```wake-result
+{ "status": "DONE" }
+```
+DONE
+
+(substituting `FAILED` or `BLOCKED` for both the JSON value and the trailing
+line, matching your actual verdict). A response without this exact block is
+treated as `BLOCKED`, even if your prose says otherwise.
+
 {{feedbackCommandNote}}