@atolis-hq/wake 0.1.3 → 0.1.5

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

@@ -2,6 +2,10 @@ import { Octokit } from '@octokit/rest';
 export function createGitHubClient(token) {
     const octokit = new Octokit({ auth: token });
     return {
+        async getAuthenticatedLogin() {
+            const { data } = await octokit.rest.users.getAuthenticated();
+            return data.login;
+        },
         // `maxResults` is a hard cap on issues returned, not just a page size:
         // octokit.paginate otherwise walks every page regardless of page size,
         // which burns GitHub's rate limit (a "fourth budget") on repos with many
@@ -55,6 +59,37 @@ export function createGitHubClient(token) {
             });
             return data;
         },
+        async getRequiredStatusChecks(owner, repo, branch) {
+            const { data } = await octokit.rest.repos.getBranch({
+                owner,
+                repo,
+                branch,
+            });
+            const requiredStatusChecks = data.protection?.required_status_checks;
+            return {
+                contexts: requiredStatusChecks?.contexts ?? [],
+                checks: (requiredStatusChecks?.checks ?? [])
+                    .map((check) => check.context)
+                    .filter((context) => typeof context === 'string'),
+            };
+        },
+        async listCheckRunsForRef(owner, repo, ref) {
+            const { data } = await octokit.rest.checks.listForRef({
+                owner,
+                repo,
+                ref,
+                per_page: 100,
+            });
+            return data.check_runs;
+        },
+        async getCombinedStatusForRef(owner, repo, ref) {
+            const { data } = await octokit.rest.repos.getCombinedStatusForRef({
+                owner,
+                repo,
+                ref,
+            });
+            return data.statuses;
+        },
         async listPullRequests(owner, repo, maxResults) {
             const perPage = Math.min(maxResults, 100);
             const results = [];

package/dist/src/adapters/github/github-issues-work-source.js

@@ -105,8 +105,14 @@ function normalizeTicketCommentEvent(input) {
             // not be able to unblock a blocked issue; only an actual human reply should.
             // The marker check catches Wake's own comments even when expectedEcho
             // missed them (crash-recovery gap) or the agent account type is 'User'.
+            // The selfLogin check catches a comment posted by direct API/CLI call
+            // (e.g. a `revise` run replying via `gh api`) that never carries the
+            // marker at all — without it, Wake's own reply looks human and
+            // re-triggers another run against itself (#258 follow-up incident: 99
+            // duplicate replies from exactly this gap).
             botAuthoredComment: input.comment.user?.type === 'Bot' ||
-                (input.comment.body ?? '').includes(wakeCommentMarker),
+                (input.comment.body ?? '').includes(wakeCommentMarker) ||
+                (input.selfLogin !== undefined && input.comment.user?.login === input.selfLogin),
         },
     });
 }
@@ -297,6 +303,7 @@ export function createGitHubIssuesWorkSource(deps) {
                                 issueNumber: issue.number,
                                 comment,
                                 ingestedAt,
+                                ...(deps.selfLogin === undefined ? {} : { selfLogin: deps.selfLogin }),
                                 ...(known?.updatedAt === undefined
                                     ? {}
                                     : { existingUpdatedAt: known.updatedAt }),

package/dist/src/adapters/github/github-pull-request-activity-source.js

@@ -22,8 +22,30 @@ function reviewThreadRootId(comment, byId) {
 function reviewThreadResourceUri(repo, prNumber, rootId) {
     return buildResourceUri('github', 'pr-review-thread', `${repo}#${prNumber}/rt_${rootId}`);
 }
-function isBotAuthored(comment) {
-    return comment.user?.type === 'Bot' || (comment.body ?? '').includes(wakeCommentMarker);
+function safeEventToken(value) {
+    return value.replace(/[^a-z0-9]+/gi, '-');
+}
+function isFailingCheckRun(run) {
+    return (run.status === 'completed' &&
+        (run.conclusion === 'failure' ||
+            run.conclusion === 'timed_out' ||
+            run.conclusion === 'cancelled' ||
+            run.conclusion === 'action_required'));
+}
+function isFailingStatus(status) {
+    return status.state === 'failure' || status.state === 'error';
+}
+// selfLogin is the only reliable signal for an agent-authored comment posted
+// by direct API/CLI call (e.g. a `revise` run replying via `gh api
+// .../replies`), which never carries the marker and whose account `type` is
+// `User`, not `Bot` — checking only those two would let the agent's own
+// replies look human and re-trigger another run against themselves (#258
+// follow-up incident: 99 duplicate replies from exactly this gap). Optional
+// because it's undefined when the GitHub client is a fake/test double.
+function isBotAuthored(comment, selfLogin) {
+    return (comment.user?.type === 'Bot' ||
+        (comment.body ?? '').includes(wakeCommentMarker) ||
+        (selfLogin !== undefined && comment.user?.login === selfLogin));
 }
 export function createGitHubPullRequestActivitySource(deps) {
     function repoAndNumberFromPrUri(resourceUri) {
@@ -119,7 +141,7 @@ export function createGitHubPullRequestActivitySource(deps) {
                             resourceUri,
                         },
                     },
-                    derivedHints: { botAuthoredComment: isBotAuthored(comment) },
+                    derivedHints: { botAuthoredComment: isBotAuthored(comment, deps.selfLogin) },
                 }));
             }
             const reviews = await deps.client.listReviews(ref.owner, ref.repo, ref.number, perPage);
@@ -150,7 +172,7 @@ export function createGitHubPullRequestActivitySource(deps) {
                             resourceUri,
                         },
                     },
-                    derivedHints: { botAuthoredComment: isBotAuthored(review) },
+                    derivedHints: { botAuthoredComment: isBotAuthored(review, deps.selfLogin) },
                 }));
             }
             const reviewComments = await deps.client.listReviewComments(ref.owner, ref.repo, ref.number, perPage);
@@ -188,7 +210,7 @@ export function createGitHubPullRequestActivitySource(deps) {
                             reviewThread: { path: comment.path, line: comment.line ?? comment.original_line ?? undefined },
                         },
                     },
-                    derivedHints: { botAuthoredComment: isBotAuthored(comment) },
+                    derivedHints: { botAuthoredComment: isBotAuthored(comment, deps.selfLogin) },
                 }));
             }
         }
@@ -197,13 +219,118 @@ export function createGitHubPullRequestActivitySource(deps) {
         }
         return events;
     }
+    async function pollRequiredCheckFailures(ref, resourceUri, ingestedAt) {
+        if (!deps.config.sources.github.pullRequests.enabled ||
+            !deps.config.sources.github.pullRequests.checks.enabled ||
+            deps.client.getRequiredStatusChecks === undefined ||
+            deps.client.listCheckRunsForRef === undefined ||
+            deps.client.getCombinedStatusForRef === undefined) {
+            return [];
+        }
+        const pr = await deps.client.getPullRequest(ref.owner, ref.repo, ref.number);
+        const headSha = pr.head.sha;
+        const baseRef = pr.base?.ref;
+        if (headSha === undefined || baseRef === undefined) {
+            return [];
+        }
+        const required = await deps.client.getRequiredStatusChecks(ref.owner, ref.repo, baseRef);
+        const requiredContexts = new Set([...required.contexts, ...required.checks]);
+        if (requiredContexts.size === 0) {
+            return [];
+        }
+        const [checkRuns, statuses] = await Promise.all([
+            deps.client.listCheckRunsForRef(ref.owner, ref.repo, headSha),
+            deps.client.getCombinedStatusForRef(ref.owner, ref.repo, headSha),
+        ]);
+        const events = [];
+        for (const run of checkRuns) {
+            if (!requiredContexts.has(run.name) || !isFailingCheckRun(run)) {
+                continue;
+            }
+            const occurredAt = run.completed_at ?? run.started_at ?? ingestedAt;
+            const sourceUrl = run.html_url ?? run.details_url ?? pr.html_url;
+            events.push(createUnkeyedEventEnvelope({
+                eventId: `pr-check-failed-${safeEventToken(ref.repoRef)}-${ref.number}-${safeEventToken(run.name)}-${headSha}-${safeEventToken(occurredAt)}-${run.conclusion}`,
+                streamScope: 'work-item',
+                direction: 'inbound',
+                sourceSystem: githubPrSource,
+                sourceEventType: 'pr.checks.failed',
+                sourceRefs: { repo: ref.repoRef, sourceUrl, resourceUri },
+                occurredAt,
+                ingestedAt,
+                trigger: 'context-only',
+                payload: {
+                    comment: {
+                        id: `pr-check-failed-${headSha}-${run.id}-${run.conclusion}`,
+                        body: `Required check failed: ${run.name} (${run.conclusion}).`,
+                        author: { login: 'github-checks' },
+                        createdAt: occurredAt,
+                        updatedAt: occurredAt,
+                        resourceUri,
+                    },
+                    checkFailure: {
+                        kind: 'check_run',
+                        name: run.name,
+                        conclusion: run.conclusion,
+                        headSha,
+                    },
+                },
+            }));
+        }
+        for (const status of statuses) {
+            if (!requiredContexts.has(status.context) || !isFailingStatus(status)) {
+                continue;
+            }
+            events.push(createUnkeyedEventEnvelope({
+                eventId: `pr-status-failed-${safeEventToken(ref.repoRef)}-${ref.number}-${safeEventToken(status.context)}-${headSha}-${safeEventToken(status.updated_at)}-${status.state}`,
+                streamScope: 'work-item',
+                direction: 'inbound',
+                sourceSystem: githubPrSource,
+                sourceEventType: 'pr.checks.failed',
+                sourceRefs: { repo: ref.repoRef, sourceUrl: status.target_url ?? pr.html_url, resourceUri },
+                occurredAt: status.updated_at,
+                ingestedAt,
+                trigger: 'context-only',
+                payload: {
+                    comment: {
+                        id: `pr-status-failed-${headSha}-${status.context}-${status.state}`,
+                        body: `Required status failed: ${status.context} (${status.state})${status.description === undefined || status.description === null ? '.' : `: ${status.description}`}`,
+                        author: { login: 'github-status' },
+                        createdAt: status.created_at,
+                        updatedAt: status.updated_at,
+                        resourceUri,
+                    },
+                    checkFailure: {
+                        kind: 'status',
+                        name: status.context,
+                        conclusion: status.state,
+                        headSha,
+                    },
+                },
+            }));
+        }
+        return events;
+    }
     return {
         async pollEvents(input) {
             const ingestedAt = deps.now().toISOString();
             const watched = (input?.watch ?? []).filter((ref) => ref.resourceUri.startsWith('github:pr:'));
             const discovered = await discoverPullRequests(ingestedAt);
             const activityBatches = await Promise.all(watched.map((ref) => pollWatchedPr(ref.resourceUri, ingestedAt)));
-            return [...discovered, ...activityBatches.flat()];
+            const checkBatches = await Promise.all(watched.map(async (watchRef) => {
+                const ref = repoAndNumberFromPrUri(watchRef.resourceUri);
+                if (ref === null) {
+                    return [];
+                }
+                try {
+                    return await pollRequiredCheckFailures(ref, watchRef.resourceUri, ingestedAt);
+                }
+                catch (error) {
+                    console.error(`[github-pr-activity-source] check poll failed for ${watchRef.resourceUri}, skipping this tick: ${error instanceof Error ? error.message : String(error)}`);
+                    return [];
+                }
+            }));
+            return [...discovered, ...activityBatches.flat(), ...checkBatches.flat()];
         },
         async deliverIntent(input) {
             const resourceUri = input.event.sourceRefs.resourceUri;

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

@@ -3,18 +3,30 @@ import { chooseAction, workflowForProjection } from '../../domain/workflows.js';
 import { branchNameForIssue } from '../git/git-workspace-manager.js';
 import { loadPromptTemplate, renderPromptTemplate } from './prompt-templates.js';
 const questionCommandPattern = /^\/question\b/i;
+function reviewCommentApiId(comment) {
+    // github-pull-request-activity-source.ts composites review-comment ids as
+    // `pr-review-comment-<id>`; strip that prefix back off to recover the raw
+    // id `gh api .../pulls/comments/<id>/replies` needs.
+    if (comment.reviewThread === undefined) {
+        return undefined;
+    }
+    const match = /^pr-review-comment-(.+)$/.exec(comment.id);
+    return match?.[1];
+}
 function formatComment(comment) {
     const surfaceLine = comment.reviewThread !== undefined
         ? `Surface: review comment on ${comment.reviewThread.path}${comment.reviewThread.line === undefined ? '' : `:${comment.reviewThread.line}`}`
         : comment.resourceUri !== undefined
             ? `Surface: ${comment.resourceUri}`
             : 'Surface: issue thread';
+    const reviewCommentId = reviewCommentApiId(comment);
     return [
         '<wake-comment>',
         `Author: ${comment.author.login}`,
         `Created: ${comment.createdAt}`,
         `Bot-authored: ${comment.isBotAuthored ? 'yes' : 'no'}`,
         surfaceLine,
+        ...(reviewCommentId === undefined ? [] : [`Review-comment-id: ${reviewCommentId}`]),
         'Body:',
         comment.body,
         '</wake-comment>',

package/dist/src/core/policy-engine.js

@@ -10,6 +10,10 @@ function isAwaitingApproval(issue) {
 const approvedCommandPattern = /^\/approved\b/i;
 const changesCommandPattern = /^\/changes\b/i;
 const questionCommandPattern = /^\/question\b/i;
+// The action Wake runs when a correlated PR gets new reviewer feedback while
+// the work item is awaiting approval. Not configurable per workflow: it's a
+// lateral response to a PR surface, not a workflow stage.
+const reviewFeedbackAction = 'revise';
 function matchesCommand(body, pattern) {
     return body
         .split(/\r?\n/)
@@ -157,6 +161,27 @@ export function createPolicyEngine() {
             }
             return { approved, pendingAction };
         },
+        // Callers must try resolveApprovalTransition first and only fall back to
+        // this when it returns null. resolveApprovalTransition doesn't check
+        // resourceUri, so a PR-surface comment that happens to carry an explicit
+        // /approved, /changes, or /question command is deliberately still routed
+        // there — this function only ever sees comments resolveApprovalTransition
+        // already passed on (plain PR feedback with no command).
+        resolvePendingReviewFeedback(issue) {
+            if (!isAwaitingApproval(issue)) {
+                return null;
+            }
+            const latestHumanComment = latestUnhandledHumanComment(issue);
+            // resourceUri is set only on comments folded from a correlated PR/review
+            // surface (schema.ts's commentSnapshotSchema: "absent = the originating
+            // issue thread"). A comment on that surface is itself the deliberate
+            // act — unlike an issue-thread reply, it doesn't need an explicit
+            // /approved-style command to count as a decision.
+            if (latestHumanComment === undefined || latestHumanComment.resourceUri === undefined) {
+                return null;
+            }
+            return reviewFeedbackAction;
+        },
         qualifiesForMint(unresolved, config) {
             const resourceUri = unresolved.sourceRefs.resourceUri;
             if (resourceUri === undefined) {

package/dist/src/core/projection-updater.js

@@ -91,7 +91,8 @@ async function applyEvent(current, event, ctx, config) {
         event.sourceEventType === 'ticket.comment.updated' ||
         event.sourceEventType === 'pr.comment.created' ||
         event.sourceEventType === 'pr.review.created' ||
-        event.sourceEventType === 'pr.review-comment.created') {
+        event.sourceEventType === 'pr.review-comment.created' ||
+        event.sourceEventType === 'pr.checks.failed') {
         const comment = event.payload.comment;
         if (comment === undefined || typeof comment !== 'object' || comment === null) {
             return current;

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

@@ -33,6 +33,9 @@ function latestHumanCommentId(candidate) {
 // projection passed in as `candidate`/`projection`, since the completion
 // event that would update lastHandledCommentId for *this* run hasn't been
 // folded yet at the point this runs).
+function isReviewThreadResourceUri(resourceUri) {
+    return resourceUri.split(':')[1] === 'pr-review-thread';
+}
 function isFreshTriggeringComment(candidate) {
     const context = candidate.context;
     const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
@@ -115,8 +118,20 @@ export function createTickRunner(deps) {
                 // latestComment.resourceUri would misroute the reply to whatever
                 // surface last happened to comment, even long after that comment
                 // was already replied to.
+                //
+                // Never threads a pr-review-thread surface specifically: this is
+                // Wake's own status/approval-request/question card, a milestone
+                // message, not a targeted reply to one inline comment — burying it
+                // as a reply deep in a single review thread makes it easy to miss.
+                // Omitting resourceUri here falls back to sourceOrigin in
+                // sink-router.ts, landing it on the correlated issue (or, for a
+                // standalone PR-only work item, GitHub's shared issue/PR comments
+                // endpoint posts it as a top-level PR comment instead). Replies to
+                // individual review threads are the agent's own job now — see
+                // prompts/revise.md — via `gh api .../replies`, not this card.
                 ...(input.projection.latestComment?.resourceUri === undefined ||
-                    !isFreshTriggeringComment(input.projection)
+                    !isFreshTriggeringComment(input.projection) ||
+                    isReviewThreadResourceUri(input.projection.latestComment.resourceUri)
                     ? {}
                     : { resourceUri: input.projection.latestComment.resourceUri }),
             },
@@ -196,7 +211,8 @@ export function createTickRunner(deps) {
             return false;
         }
         if (isAwaitingApproval(projection)) {
-            return policy.resolveApprovalTransition(projection) !== null;
+            return (policy.resolveApprovalTransition(projection) !== null ||
+                policy.resolvePendingReviewFeedback(projection) !== null);
         }
         const nextAction = policy.chooseAction(projection, workflow) ??
             policy.chooseRetryActionAfterHumanReply(projection);
@@ -951,9 +967,16 @@ export function createTickRunner(deps) {
             if (isAwaitingApproval(candidate)) {
                 const approvalResolution = policy.resolveApprovalTransition(candidate);
                 if (approvalResolution === null) {
-                    return { status: 'idle' };
+                    const reviewAction = policy.resolvePendingReviewFeedback(candidate);
+                    if (reviewAction === null) {
+                        return { status: 'idle' };
+                    }
+                    action = reviewAction;
+                    const workflowAction = chooseWorkflowAction(candidate, workflow);
+                    claimedStage = workflowAction?.stage ?? candidate.wake.stage;
+                    workspaceMode = workflowAction?.workspace ?? 'none';
                 }
-                if (approvalResolution.approved) {
+                else if (approvalResolution.approved) {
                     const approvalId = `approval-${candidate.issue.number}-${deps.clock.now().getTime()}`;
                     const approvedAt = deps.clock.now().toISOString();
                     const nextStage = lifecycle.nextStageFromSentinel(candidate.wake.stage, 'DONE', workflow);
@@ -1000,15 +1023,28 @@ export function createTickRunner(deps) {
                         nextStage,
                     };
                 }
-                action = approvalResolution.pendingAction;
-                const workflowAction = chooseWorkflowAction(candidate, workflow);
-                claimedStage = workflowAction?.stage ?? candidate.wake.stage;
-                workspaceMode = workflowAction?.workspace ?? 'none';
+                else {
+                    action = approvalResolution.pendingAction;
+                    const workflowAction = chooseWorkflowAction(candidate, workflow);
+                    claimedStage = workflowAction?.stage ?? candidate.wake.stage;
+                    workspaceMode = workflowAction?.workspace ?? 'none';
+                }
             }
             else {
                 const workflowAction = chooseWorkflowAction(candidate, workflow);
-                const nextAction = workflowAction?.action ??
-                    policy.chooseRetryActionAfterHumanReply(candidate);
+                // Retry takes priority over the stage's fresh default action.
+                // chooseWorkflowAction almost always returns a non-null action for
+                // any valid stage (e.g. 'implement'), so checking it first would
+                // silently discard chooseRetryActionAfterHumanReply's decision
+                // whenever a FAILED/BLOCKED run left a lateral action (like
+                // `revise`) unfinished with a fresh human reply waiting — instead
+                // of resuming that action, it would restart the stage from
+                // scratch (#258 follow-up incident: a FAILED `revise` run fell
+                // back to a full fresh `implement` run and lost the PR-feedback
+                // context).
+                const nextAction = policy.chooseRetryActionAfterHumanReply(candidate) ??
+                    workflowAction?.action ??
+                    null;
                 if (nextAction === null) {
                     return { status: 'idle' };
                 }

package/dist/src/domain/schema.js

@@ -378,8 +378,8 @@ export const wakeConfigSchema = z.object({
         intervalMs: z.number().int().positive().default(60 * 1000),
         // Cap for the idle-cadence backoff (#81): consecutive idle ticks double the
         // sleep, up to this ceiling, so a quiet repo doesn't poll every intervalMs.
-        maxIntervalMs: z.number().int().positive().default(10 * 60 * 1000),
-    }).default({ intervalMs: 60 * 1000, maxIntervalMs: 10 * 60 * 1000 }),
+        maxIntervalMs: z.number().int().positive().default(5 * 60 * 1000),
+    }).default({ intervalMs: 60 * 1000, maxIntervalMs: 5 * 60 * 1000 }),
     transcripts: z.object({
         enabled: z.boolean().default(false),
         retainAfterWorkspaceCleanup: z.boolean().default(false),
@@ -452,12 +452,15 @@ export const wakeConfigSchema = z.object({
                 enabled: z.boolean().default(false),
                 maxPullRequestsPerRepo: z.number().int().positive().default(25),
                 commentPageSize: z.number().int().positive().default(25),
+                checks: z.object({
+                    enabled: z.boolean().default(true),
+                }).default({ enabled: true }),
                 policy: z.object({
                     requiredAuthors: z.array(z.string()).default([]),
                 }).default({ requiredAuthors: [] }),
-            }).default({ enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, policy: { requiredAuthors: [] } }),
-        }).default({ enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, policy: { requiredAuthors: [] } } }),
-    }).default({ github: { enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, policy: { requiredAuthors: [] } } } }),
+            }).default({ enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, checks: { enabled: true }, policy: { requiredAuthors: [] } }),
+        }).default({ enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, checks: { enabled: true }, policy: { requiredAuthors: [] } } }),
+    }).default({ github: { enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, checks: { enabled: true }, policy: { requiredAuthors: [] } } } }),
     sinks: z.record(z.string(), sinkEntrySchema).default({}),
 }).superRefine((config, ctx) => {
     const promptsRoot = config.paths.promptsRoot ?? defaultPromptsRoot();

package/dist/src/main.js

@@ -178,6 +178,14 @@ export async function buildRuntime(args) {
     const githubClient = config.sources.github.enabled
         ? createGitHubClient(await resolveGitHubToken())
         : undefined;
+    // Resolved once alongside the client: the login Wake itself posts as, so
+    // both GitHub work sources can recognize a comment Wake's own agent posted
+    // by direct API/CLI call (not through formatWakeComment, so it never
+    // carries the wake:agent marker) as bot-authored instead of a fresh human
+    // reply that would re-trigger another run against itself.
+    const selfLogin = githubClient !== undefined
+        ? await githubClient.getAuthenticatedLogin()
+        : undefined;
     const artifactVerifier = prTrackingEnabled && githubClient !== undefined
         ? createGitHubArtifactVerifier({ client: githubClient })
         : undefined;
@@ -188,6 +196,7 @@ export async function buildRuntime(args) {
             config,
             resourceIndex,
             now: () => systemClock.now(),
+            ...(selfLogin === undefined ? {} : { selfLogin }),
         })
         : await createFileBackedFakeTicketingSystem({
             fixturePath: stateStore.paths.issueFixtureFile,
@@ -202,6 +211,7 @@ export async function buildRuntime(args) {
             config,
             resourceIndex,
             now: () => systemClock.now(),
+            ...(selfLogin === undefined ? {} : { selfLogin }),
         })
         : null;
     const workSource = createWorkSourceFanIn([

package/dist/src/version.js

@@ -1 +1 @@
-export const wakeVersion = "0.1.3+g38d84e4";
+export const wakeVersion = "0.1.5+g2910a1f";

package/package.json

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

package/prompts/revise.md

@@ -0,0 +1,61 @@
+---
+stage: implement
+permissionMode: acceptEdits
+allowedTools: Bash(git *), Bash(gh *), Bash(npm *), Bash(curl *), Bash(jq *), Edit, Write, Read, Glob, Grep, WebSearch, WebFetch
+extraArgs:
+maxTurns: 100
+skipApproval: false
+---
+{{#if isStart}}
+You are Wake, running the REVISE action for {{workItemKey}}, responding to
+feedback on the pull request already open for this work item.
+
+Your current working directory is a git checkout of {{repo}}, already on
+branch {{branch}}, with an open pull request against main.
+
+Wake will provide the comment(s) that triggered this run below in a
+delimited untrusted data block. Each one is tagged with the surface it came
+from — a specific file/line on the PR (a review comment) or the PR
+conversation itself.
+{{else}}
+Resuming the REVISE action session for {{workItemKey}}.
+
+Your current working directory is still the git checkout of {{repo}} on
+branch {{branch}}. Continue from where you left off rather than starting
+over, unless the new comments below change the approach.
+
+New comments since your last turn (excludes Wake/bot comments) are provided
+below in a delimited untrusted data block, tagged with the surface each one
+came from.
+{{/if}}
+
+For each new comment, decide independently what it actually needs — do not
+apply one blanket response to the whole batch:
+- A concrete, reasonable change: make it, commit, and push to {{branch}}.
+- A question, or something you'd want clarified before acting on it: answer
+  it in your response. Do not change code solely because a question was
+  asked.
+- A request that seems mistaken, suboptimal, or in tension with the existing
+  approach: don't implement it reflexively. Explain your reasoning, and
+  either justify the current approach or propose an alternative. Reserve
+  pushing back for requests you have a concrete, substantive reason to
+  disagree with — when a reasonable person could go either way, prefer
+  making the change over defending your original choice.
+
+Reply routing: for every review comment in this batch (each is tagged below
+with its `Review-comment-id`), reply directly on that comment's own thread
+yourself — do not rely on anything else to do this for you. Look up the PR
+number if you need it with `gh pr view --json number -q .number`, then
+reply with:
+`gh api repos/{{repo}}/pulls/<pr-number>/comments/<review-comment-id>/replies -f body="<!-- wake:agent -->
+
+<reply>"`
+The leading `<!-- wake:agent -->` line is required on every reply body —
+without it, Wake cannot tell your own reply apart from a new human comment,
+which would make Wake reply to itself again. Do not reply to the same
+comment more than once. Your prose response here (outside of any `gh api`
+calls) is only a short summary for Wake's own status update — it is posted
+separately (to the issue, or as a top-level PR comment), not attached to any
+specific thread — so don't rely on it to answer a specific comment; put the
+actual answer in the threaded reply.
+Do not merge the pull request yourself.