@atolis-hq/wake 0.2.58 → 0.2.60

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/claude/claude-runner.js

@@ -1,6 +1,6 @@
 import { parseClaudePrintResult, parseRunnerResult } from '../../domain/schema.js';
 import { runAgentCliCommand } from '../runner/cli-command.js';
-import { buildStagePrompt } from '../runner/stage-prompt.js';
+import { buildStagePrompt, sentinelListForApproval } from '../runner/stage-prompt.js';
 import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
 import { writeRunnerTranscript } from '../runner/transcripts.js';
 import { createAgentExecution } from '../../core/live-execution.js';
@@ -120,6 +120,80 @@ function extractTokenUsage(parsed) {
     };
 }
 const CLAUDE_CLI_NAME = 'Claude';
+// Bounded — this is a single "just tell me the status" follow-up, not a
+// second attempt at the task, so it never needs more than one turn.
+const ENVELOPE_REPAIR_MAX_TURNS = 1;
+const ENVELOPE_REPAIR_TIMEOUT_MS = 60_000;
+function buildEnvelopeRepairPrompt(skipApproval) {
+    return [
+        'Your previous reply did not end with the required `wake-result` envelope, so it could not be parsed.',
+        'Reply with ONLY a fenced `wake-result` JSON block containing a `status` field, then repeat that status word on its own line after the closing fence.',
+        `The status must be exactly one of: ${sentinelListForApproval(skipApproval)}, reflecting the outcome of your previous turn.`,
+        'Do not repeat, summarize, or redo any of your previous work — this reply is parsed automatically and anything besides the envelope is discarded.',
+    ].join('\n');
+}
+function mergeTokenUsage(base, extra) {
+    if (extra === undefined) {
+        return base;
+    }
+    if (base === undefined) {
+        return extra;
+    }
+    return {
+        inputTokens: base.inputTokens + extra.inputTokens,
+        outputTokens: base.outputTokens + extra.outputTokens,
+        ...(base.cacheCreationInputTokens === undefined && extra.cacheCreationInputTokens === undefined
+            ? {}
+            : {
+                cacheCreationInputTokens: (base.cacheCreationInputTokens ?? 0) + (extra.cacheCreationInputTokens ?? 0),
+            }),
+        ...(base.cacheReadInputTokens === undefined && extra.cacheReadInputTokens === undefined
+            ? {}
+            : {
+                cacheReadInputTokens: (base.cacheReadInputTokens ?? 0) + (extra.cacheReadInputTokens ?? 0),
+            }),
+        ...(base.costUsd === undefined && extra.costUsd === undefined
+            ? {}
+            : { costUsd: (base.costUsd ?? 0) + (extra.costUsd ?? 0) }),
+        ...(base.turns === undefined && extra.turns === undefined
+            ? {}
+            : { turns: (base.turns ?? 0) + (extra.turns ?? 0) }),
+    };
+}
+// Asks the same (still-live) session to restate just its result envelope,
+// for the case where a run otherwise completed but the model forgot the
+// mandatory trailer — cheaper and more honest than defaulting the whole run
+// to BLOCKED because of a formatting slip. Returns undefined on any failure
+// so the caller falls back to the original (unparseable) result untouched.
+async function attemptEnvelopeRepair(input) {
+    const args = buildClaudePrintArgs({
+        model: input.model,
+        prompt: buildEnvelopeRepairPrompt(input.skipApproval),
+        sessionName: input.sessionName,
+        resumeSessionId: input.sessionId,
+        maxTurns: ENVELOPE_REPAIR_MAX_TURNS,
+    });
+    const result = await runClaudeCommand({
+        command: input.command,
+        args,
+        cwd: input.cwd,
+        timeoutMs: input.timeoutMs,
+    });
+    if (result.exitCode !== 0 || result.timedOut || result.stdout.trim().length === 0) {
+        return undefined;
+    }
+    try {
+        const parsed = parseClaudePrintOutput(result.stdout);
+        const repairTokenUsage = extractTokenUsage(parsed);
+        return {
+            text: parsed.result,
+            ...(repairTokenUsage === undefined ? {} : { tokenUsage: repairTokenUsage }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function classifyClaudeCliFailure(input) {
     if (input.timedOut) {
         return 'infra';
@@ -341,6 +415,30 @@ export function createClaudeRunner(options) {
             ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
         }));
         const tokenUsage = extractTokenUsage(parsed);
+        let effectiveResultText = parsed.result;
+        let effectiveTokenUsage = tokenUsage;
+        let envelopeRepaired = false;
+        if (parseRunnerResult(effectiveResultText).envelope === 'missing' &&
+            parsed.session_id !== undefined) {
+            const repair = await attemptEnvelopeRepair({
+                command: options.command,
+                cwd: input.workspacePath ?? options.cwd,
+                model,
+                sessionName,
+                sessionId: parsed.session_id,
+                skipApproval: stagePrompt.skipApproval,
+                timeoutMs: Math.min(options.settings.timeoutMs, ENVELOPE_REPAIR_TIMEOUT_MS),
+            });
+            if (repair !== undefined && parseRunnerResult(repair.text).envelope !== 'missing') {
+                effectiveResultText = `${effectiveResultText.trimEnd()}\n\n${repair.text.trim()}`;
+                effectiveTokenUsage = mergeTokenUsage(effectiveTokenUsage, repair.tokenUsage);
+                envelopeRepaired = true;
+                console.log(`[claude-run] envelope repair succeeded runId=${input.runId} sessionId=${parsed.session_id}`);
+            }
+            else {
+                console.error(`[claude-run] envelope repair failed runId=${input.runId} sessionId=${parsed.session_id}`);
+            }
+        }
         if (tokenUsage !== undefined) {
             await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
                 type: 'agent.usage.updated',
@@ -364,20 +462,21 @@ export function createClaudeRunner(options) {
             payload: { exitCode: result.exitCode, timedOut: result.timedOut },
         }));
         return {
-            result: parsed.result,
+            result: effectiveResultText,
             model,
             cli: CLAUDE_CLI_NAME,
-            ...(parseRunnerResult(parsed.result).status === 'FAILED'
+            ...(parseRunnerResult(effectiveResultText).status === 'FAILED'
                 ? { failureClass: 'task' }
                 : {}),
             ...(parsed.session_id === undefined ? {} : { session_id: parsed.session_id }),
-            ...(tokenUsage === undefined ? {} : { tokenUsage }),
+            ...(effectiveTokenUsage === undefined ? {} : { tokenUsage: effectiveTokenUsage }),
             metadata: {
                 stdout: result.stdout,
                 stderr: result.stderr,
                 raw: parsed,
                 skipApproval: stagePrompt.skipApproval,
                 allowAutoApproval: stagePrompt.allowAutoApproval,
+                ...(envelopeRepaired ? { envelopeRepaired: true } : {}),
                 ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
                 ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
                 ...(sandboxLog?.metadata ?? {}),

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;
@@ -76,7 +82,7 @@ function parseFrontmatterMaxTurns(input) {
     }
     return parsed;
 }
-function sentinelListForApproval(skipApproval) {
+export function sentinelListForApproval(skipApproval) {
     return skipApproval ? 'DONE, BLOCKED, FAILED' : 'AWAITING_APPROVAL, BLOCKED, FAILED';
 }
 function sentinelInstructionsForApproval(skipApproval) {
@@ -115,7 +121,7 @@ function buildHarnessPrompt(input) {
     if (input.upstreamChanges !== undefined && input.upstreamChanges.trim().length > 0) {
         lines.push('', 'Upstream update notice:', 'Before resuming this session, Wake pulled the latest default-branch changes into your workspace. New commits included:', input.upstreamChanges.trimEnd());
     }
-    lines.push('', 'Result envelope ABI:', 'Respond concisely. End your response with a fenced `wake-result` JSON block, then on its own line after the closing fence repeat the status word for degraded-mode fallback.', `The JSON \`status\` and final line must be exactly one of: ${sentinelListForApproval(input.skipApproval)}.`, sentinelInstructionsForApproval(input.skipApproval), 'The JSON object must contain only the `status` field. Do not add other fields.');
+    lines.push('', 'Result envelope ABI:', 'Respond concisely. End your response with a fenced `wake-result` JSON block, then on its own line after the closing fence repeat the status word for degraded-mode fallback.', `The JSON \`status\` and final line must be exactly one of: ${sentinelListForApproval(input.skipApproval)}.`, sentinelInstructionsForApproval(input.skipApproval), 'The JSON object must contain only the `status` field. Do not add other fields.', 'This envelope is mandatory, not optional formatting: an automated parser reads only your final lines, and a reply that omits it is discarded and treated as BLOCKED regardless of the work you actually completed.');
     if (input.prTrackingEnabled) {
         lines.push('', 'Artifact reporting:', 'If you created a pull request during this stage, report it before the result envelope by adding a fenced `wake-artifacts` JSON block:', '```wake-artifacts', '{ "artifacts": [{ "kind": "pr", "url": "<the PR URL>" }] }', '```', 'Only report a PR you actually created in this run. Omit the block entirely if you created no PR.');
     }
@@ -226,8 +232,9 @@ export async function buildStagePrompt(input) {
         commentSections,
         includeRepoDetails: resolvedWorkspaceMode === 'read-only',
     });
+    const envelopeReminder = 'Before you finish: end this reply with the `wake-result` envelope exactly as your instructions describe, or this run is discarded and marked BLOCKED.';
     return {
-        prompt: `${renderedTemplate}\n\n${untrustedDataBlock}`,
+        prompt: `${renderedTemplate}\n\n${untrustedDataBlock}\n\n${envelopeReminder}`,
         harnessPrompt: buildHarnessPrompt({
             skipApproval,
             prTrackingEnabled: input.config?.sources.github.enabled === true &&

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

@@ -108,7 +108,7 @@ function classifyFailedRun(input) {
             ? 'unknown'
             : 'none';
     const failurePhase = input.failurePhase ??
-        (input.envelope === 'degraded' && input.sentinel === 'FAILED'
+        ((input.envelope === 'degraded' || input.envelope === 'missing') && input.sentinel === 'FAILED'
             ? 'result-parsing'
             : failurePhaseForRecord(input.record));
     let retrySafety;
@@ -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: [],
 });
@@ -1110,7 +1117,11 @@ export function parseRunnerResult(result) {
         return {
             status: body.length === 0 ? 'FAILED' : 'BLOCKED',
             body,
-            envelope: 'degraded',
+            // No structured envelope AND no recognizable bare sentinel at all —
+            // distinct from 'degraded' (a deliberate bare-sentinel reply) so
+            // callers can retry a runner that simply forgot the trailer instead
+            // of trusting a fabricated BLOCKED/FAILED default.
+            envelope: 'missing',
         };
     }
     let removed = false;

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

package/package.json

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