@atolis-hq/wake 0.2.58 → 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,15 +334,8 @@ 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'));
+    function describeMergeActorError(error) {
+        return error instanceof Error ? error.message : String(error);
     }
     async function performApprovedPrMergeActions(input) {
         if (deps.prMergeActor === undefined ||
@@ -353,23 +346,19 @@ export function createTickRunner(deps) {
         const targetResourceUri = input.approvalResolution.targetResourceUri;
         const commentId = input.approvalResolution.triggeringCommentId.replace(/[^a-z0-9]+/gi, '-');
         const reviewBody = reviewerMessageFromApprovalComment(input.approvalResolution.triggeringCommentBody ?? '');
-        let blockedReason = null;
+        // 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) {
-            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,
@@ -390,33 +379,41 @@ export function createTickRunner(deps) {
                     },
                 }));
             }
+            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 (blockedReason !== null) {
-            return { blocked: true, reason: blockedReason };
+        if (blockedReasons.length > 0) {
+            return { blocked: true, reason: blockedReasons.join(' ') };
         }
         return { blocked: false };
     }

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

package/package.json

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

package/prompts/plan-review.md

@@ -33,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}}