@atolis-hq/wake 0.2.77 → 0.2.79

package/dist/src/adapters/fake/fake-ticketing-system.js

@@ -95,10 +95,18 @@ export function createFakeTicketingSystem(options) {
                 const workflowLabel = typeof input.event.payload.workflowLabel === 'string'
                     ? input.event.payload.workflowLabel
                     : undefined;
+                const frozenLabel = typeof input.event.payload.frozenLabel === 'string'
+                    ? input.event.payload.frozenLabel
+                    : undefined;
+                const scheduledLabel = typeof input.event.payload.scheduledLabel === 'string'
+                    ? input.event.payload.scheduledLabel
+                    : undefined;
                 const labels = [
                     ...currentLabels.filter((label) => !label.startsWith('wake:status.') &&
                         !label.startsWith('wake:stage.') &&
-                        !label.startsWith('wake:workflow.')),
+                        !label.startsWith('wake:workflow.') &&
+                        label !== 'wake:frozen' &&
+                        label !== 'wake:scheduled-workflow'),
                     ...(statusLabel === undefined
                         ? currentLabels.filter((label) => label.startsWith('wake:status.'))
                         : [statusLabel]),
@@ -108,6 +116,8 @@ export function createFakeTicketingSystem(options) {
                     ...(workflowLabel === undefined
                         ? currentLabels.filter((label) => label.startsWith('wake:workflow.'))
                         : [workflowLabel]),
+                    ...(frozenLabel === undefined ? [] : [frozenLabel]),
+                    ...(scheduledLabel === undefined ? [] : [scheduledLabel]),
                 ];
                 return [
                     createEventEnvelope({

package/dist/src/adapters/fs/state-store.js

@@ -46,6 +46,9 @@ function stripHeavyRunRecordFields(record) {
     const { stdout: _stdout, stderr: _stderr, raw: _raw, ...restMetadata } = metadata;
     return { ...rest, metadata: restMetadata };
 }
+function compareIssueStatesForListing(left, right) {
+    return left.workItemKey.localeCompare(right.workItemKey);
+}
 function parseRunRecordSummaryIndex(input, date) {
     if (input === null || typeof input !== 'object') {
         throw new Error('Run summary index must be an object');
@@ -670,7 +673,7 @@ export function createStateStore({ wakeRoot }) {
             for (const item of items) {
                 byWorkItemKey.set(item.workItemKey, item);
             }
-            return [...byWorkItemKey.values()].sort((left, right) => left.workItemKey.localeCompare(right.workItemKey));
+            return [...byWorkItemKey.values()].sort(compareIssueStatesForListing);
         },
         async listEventEnvelopes() {
             const eventsRoot = join(paths.dataRoot, 'events');

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

@@ -5,10 +5,12 @@ import { defaultAgentIdentity } from '../../domain/schema.js';
 import { buildResourceUri } from '../../domain/resource-uri.js';
 import { wakeStageLabelPrefix } from '../../domain/stages.js';
 import { wakeWorkflowLabelPrefix } from '../../domain/workflows.js';
+import { FROZEN_WORK_ITEM_LABEL } from '../../domain/work-item-lifecycle.js';
 import { createEventEnvelope, createUnkeyedEventEnvelope } from '../../lib/event-log.js';
 import { createWakePaths } from '../../lib/paths.js';
 import { wakeVersion } from '../../version.js';
 import { buildResumeCommandForCli } from '../runner/runner-cli-adapter.js';
+import { SCHEDULED_WORKFLOW_LABEL } from '../../domain/work-item-labels.js';
 const wakeStatusLabelPrefix = 'wake:status.';
 const pollOverlapMs = 60 * 60 * 1000;
 // Hidden marker appended to every comment Wake posts. `expectedEcho` normally
@@ -524,10 +526,22 @@ export function createGitHubIssuesWorkSource(deps) {
                 const nextWorkflowLabel = typeof input.event.payload.workflowLabel === 'string'
                     ? input.event.payload.workflowLabel
                     : undefined;
+                // Unlike the three label families above, frozen/scheduled are single
+                // toggle labels: every call site now computes the full authoritative
+                // desired state via labelsForWorkItem, so their absence here means
+                // "should not be present" (not "leave unspecified as before").
+                const nextFrozenLabel = typeof input.event.payload.frozenLabel === 'string'
+                    ? input.event.payload.frozenLabel
+                    : undefined;
+                const nextScheduledLabel = typeof input.event.payload.scheduledLabel === 'string'
+                    ? input.event.payload.scheduledLabel
+                    : undefined;
                 const nextLabels = [
                     ...currentLabels.filter((label) => !label.startsWith(wakeStatusLabelPrefix) &&
                         !label.startsWith(wakeStageLabelPrefix) &&
-                        !label.startsWith(wakeWorkflowLabelPrefix)),
+                        !label.startsWith(wakeWorkflowLabelPrefix) &&
+                        label !== FROZEN_WORK_ITEM_LABEL &&
+                        label !== SCHEDULED_WORKFLOW_LABEL),
                     ...(nextStatusLabel !== undefined
                         ? [nextStatusLabel]
                         : currentLabels.filter((label) => label.startsWith(wakeStatusLabelPrefix))),
@@ -537,6 +551,8 @@ export function createGitHubIssuesWorkSource(deps) {
                     ...(nextWorkflowLabel !== undefined
                         ? [nextWorkflowLabel]
                         : currentLabels.filter((label) => label.startsWith(wakeWorkflowLabelPrefix))),
+                    ...(nextFrozenLabel !== undefined ? [nextFrozenLabel] : []),
+                    ...(nextScheduledLabel !== undefined ? [nextScheduledLabel] : []),
                 ];
                 const labelsChanged = nextLabels.length !== currentLabels.length ||
                     !nextLabels.every((label, index) => label === currentLabels[index]);
@@ -564,6 +580,8 @@ export function createGitHubIssuesWorkSource(deps) {
                                 ...(nextStatusLabel !== undefined ? { statusLabel: nextStatusLabel } : {}),
                                 ...(nextStageLabel !== undefined ? { stageLabel: nextStageLabel } : {}),
                                 ...(nextWorkflowLabel !== undefined ? { workflowLabel: nextWorkflowLabel } : {}),
+                                ...(nextFrozenLabel !== undefined ? { frozenLabel: nextFrozenLabel } : {}),
+                                ...(nextScheduledLabel !== undefined ? { scheduledLabel: nextScheduledLabel } : {}),
                                 labels: nextLabels,
                                 providerEventType: 'github.issue.labels.updated',
                             },
@@ -602,6 +620,8 @@ export function createGitHubIssuesWorkSource(deps) {
                     input.event.payload.statusLabel,
                     input.event.payload.stageLabel,
                     input.event.payload.workflowLabel,
+                    input.event.payload.frozenLabel,
+                    input.event.payload.scheduledLabel,
                 ].filter((label) => typeof label === 'string');
                 if (expected.every((label) => currentLabels.includes(label))) {
                     return [

package/dist/src/adapters/http/ui-assets.js

@@ -477,7 +477,7 @@ function renderItemDetails(detail, boardItem) {
       el('dd', { text: value }),
     ])));
   }
-  const isFrozen = typeof detail.item.context.frozenAt === 'string';
+  const isFrozen = detail.item.context.frozen !== undefined && detail.item.context.frozen !== null;
   const actionBar = el('div', { class: 'action-bar' });
   const lastRun = detail.runs.at(-1);
   if (lastRun && lastRun.sentinel === 'FAILED') {

package/dist/src/adapters/http/ui-server.js

@@ -6,11 +6,10 @@ import { createLabelsEvent } from '../../core/event-builders.js';
 import { createProjectionUpdater } from '../../core/projection-updater.js';
 import { CORRELATION_RETRACTED_EVENT, RETRY_REQUESTED_EVENT, RUN_REQUESTED_EVENT, WORK_ITEM_DELETED_EVENT, WORK_ITEM_FROZEN_EVENT, WORK_ITEM_UNFROZEN_EVENT, } from '../../domain/event-types.js';
 import { configuredTicketSource } from '../../domain/sources.js';
-import { stageLabelForStage } from '../../domain/stages.js';
 import { isWorkItemDeleted, isWorkItemFrozen } from '../../domain/work-item-lifecycle.js';
-import { workflowLabelForWorkflowName, workflowNameForProjection } from '../../domain/workflows.js';
 import { createEventEnvelope } from '../../lib/event-log.js';
 import { writeJsonFile } from '../../lib/json-file.js';
+import { labelsForWorkItem } from '../../domain/work-item-labels.js';
 import { indexHtml } from './ui-assets.js';
 import { buildBoard, buildConfigView, buildEventsFeed, buildHealth, buildItemDetail, buildItemTranscripts, buildMetrics, buildRuns, buildStatus, buildWorkspaces, } from './ui-data.js';
 function sendJson(res, status, body) {
@@ -81,13 +80,10 @@ function buildUiWorkItemEvent(input) {
 }
 async function appendLabelSyncEvent(input) {
     const occurredAt = input.now().toISOString();
-    const workflowName = workflowNameForProjection(input.item, input.config);
     const labelEvent = createLabelsEvent({
         projection: input.item,
         runId: `${input.action}-${input.item.workItemKey}-${input.now().getTime()}`,
-        statusLabel: 'wake:status.pending',
-        stageLabel: stageLabelForStage(input.item.wake.stage),
-        workflowLabel: workflowLabelForWorkflowName(workflowName),
+        ...labelsForWorkItem(input.item, input.config),
         occurredAt,
     });
     const appended = await input.stateStore.appendEventEnvelope(labelEvent);

package/dist/src/core/event-builders.js

@@ -143,6 +143,8 @@ export function createLabelsEvent(input) {
             statusLabel: input.statusLabel,
             stageLabel: input.stageLabel,
             workflowLabel: input.workflowLabel,
+            ...(input.frozenLabel === undefined ? {} : { frozenLabel: input.frozenLabel }),
+            ...(input.scheduledLabel === undefined ? {} : { scheduledLabel: input.scheduledLabel }),
             origin: input.projection.origin ?? 'github',
             idempotencyKey: `${input.runId}:${labelKind}`,
             deliveryState: 'PENDING',

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

@@ -218,7 +218,17 @@ export function createPolicyEngine() {
             if (!approved && !changesRequested) {
                 return null;
             }
-            return { approved, pendingAction };
+            return {
+                approved,
+                pendingAction,
+                ...(changesRequested
+                    ? {
+                        changesRequested: true,
+                        triggeringCommentId: latestHumanComment.id,
+                        triggeringCommentBody: latestHumanComment.body,
+                    }
+                    : {}),
+            };
         },
         // Callers must try resolveApprovalTransition first and only fall back to
         // this when it returns null. resolveApprovalTransition doesn't check
@@ -247,6 +257,20 @@ export function createPolicyEngine() {
             }
             return reviewFeedbackAction;
         },
+        // A rejecting review watcher (or an already-folded /changes reply) sets
+        // context.status = 'changes-requested' with no fresh comment required —
+        // this is the gap #472 described: nothing distinguished a plan-review
+        // rejection from "never reviewed yet." Bounding (escalating to 'blocked'
+        // once config.retry.maxChangesRequestedRetries is exceeded) already
+        // happened at fold time, so this only has to check the current status.
+        resolveChangesRequestedAction(issue) {
+            if (!isAwaitingApproval(issue) || issue.context.status !== 'changes-requested') {
+                return null;
+            }
+            return typeof issue.context.pendingApprovalAction === 'string'
+                ? issue.context.pendingApprovalAction
+                : null;
+        },
         resolveCustomCommandRequest(issue, config) {
             return resolveCustomCommand(issue, config);
         },
@@ -274,6 +298,10 @@ export function createPolicyEngine() {
                 if (approval !== null) {
                     return { action: approval.pendingAction, workflow };
                 }
+                const changesRequestedAction = this.resolveChangesRequestedAction(issue);
+                if (changesRequestedAction !== null) {
+                    return { action: changesRequestedAction, workflow };
+                }
                 const reviewAction = this.resolvePendingReviewFeedback(issue);
                 if (reviewAction !== null) {
                     return { action: reviewAction, workflow };

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

@@ -2,6 +2,7 @@ import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRE
 import { UNRESOLVED_WORK_ITEM_KEY, parseIssueStateRecord } from '../domain/schema.js';
 import { doneRunnerSentinel, stageFromLabels } from '../domain/stages.js';
 import { FROZEN_WORK_ITEM_LABEL } from '../domain/work-item-lifecycle.js';
+import { workItemStatusForRunOutcome } from '../domain/work-item-status.js';
 import { builtInDefaultWorkflowDefinition, defaultWorkflowName, selectWorkflowForEvent, workflowStageVocabulary, } from '../domain/workflows.js';
 import { isCustomCommandAction } from '../domain/custom-commands.js';
 import { createEventEnvelope } from '../lib/event-log.js';
@@ -25,6 +26,10 @@ function createProjectionFromIssueEvent(event, config) {
     const labels = Array.isArray(issue.labels)
         ? issue.labels
         : [];
+    // Only the scheduled-workflow-source's synthetic ticket carries a
+    // wake:schedule resourceUri; no other mint path sets this, so `scheduled`
+    // has a real backing context field instead of only ever living in a label.
+    const scheduled = event.sourceRefs.resourceUri?.split(':')[1] === 'schedule';
     return parseIssueStateRecord({
         schemaVersion: 1,
         workItemKey: event.workItemKey,
@@ -36,7 +41,7 @@ function createProjectionFromIssueEvent(event, config) {
             recentEventIds: [event.eventId],
             syncedAt: event.ingestedAt,
         },
-        context: {},
+        context: scheduled ? { scheduled: true } : {},
     });
 }
 async function pinSelectedWorkflow(projection, event, ctx, config) {
@@ -174,6 +179,10 @@ async function applyEvent(current, event, ctx, config) {
         }
         return parseIssueStateRecord({
             ...current,
+            context: {
+                ...current.context,
+                status: 'working',
+            },
             wake: {
                 ...current.wake,
                 stage: payload.claimedStage,
@@ -193,6 +202,42 @@ async function applyEvent(current, event, ctx, config) {
     }
     if (event.sourceEventType === RUN_COMPLETED_EVENT) {
         const payload = event.payload;
+        // A rejecting plan-review/pr-review watcher sub-run (§5, trigger 1) or a
+        // human /changes reply (§5, trigger 2) folds onto the parent's context
+        // without touching wake.stage/lastRunId/session — same isolation
+        // guarantee PR #479 established for watcher runs generally. Checked
+        // before the watcherRun early-return below so a rejecting watcher run
+        // (which also carries watcherRun: true) still updates status/feedback,
+        // while every other watcher-run completion (e.g. an approving DONE
+        // verdict) still hits that early-return untouched.
+        if (payload.changesRequested === true) {
+            const currentChangesRequestedCount = typeof current.context.changesRequestedCount === 'number' &&
+                Number.isInteger(current.context.changesRequestedCount)
+                ? current.context.changesRequestedCount
+                : 0;
+            const nextChangesRequestedCount = currentChangesRequestedCount + 1;
+            const maxRetries = config?.retry.maxChangesRequestedRetries ?? Infinity;
+            const escalate = nextChangesRequestedCount > maxRetries;
+            return parseIssueStateRecord({
+                ...current,
+                context: {
+                    ...current.context,
+                    status: escalate ? 'blocked' : 'changes-requested',
+                    changesRequestedCount: nextChangesRequestedCount,
+                    ...(payload.reviewFeedbackBody === undefined
+                        ? {}
+                        : { changesRequestedFeedback: payload.reviewFeedbackBody }),
+                    ...(payload.handledCommentId === undefined
+                        ? {}
+                        : { lastHandledCommentId: payload.handledCommentId }),
+                },
+                wake: {
+                    ...current.wake,
+                    syncedAt: event.ingestedAt,
+                    recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+                },
+            });
+        }
         if (payload.watcherRun === true) {
             return parseIssueStateRecord({
                 ...current,
@@ -265,6 +310,19 @@ async function applyEvent(current, event, ctx, config) {
                 ? { lastExternalSideEffects: payload.externalSideEffects }
                 : {}),
             ...(payload.retrySafety !== undefined ? { lastRetrySafety: payload.retrySafety } : {}),
+            ...(payload.sentinel === undefined || isCompletedCustomCommand
+                ? {}
+                : {
+                    status: workItemStatusForRunOutcome({
+                        sentinel: payload.sentinel,
+                        stage: payload.nextStage ?? current.wake.stage,
+                    }),
+                }),
+            // A fresh DONE/AWAITING_APPROVAL cycle resolves whatever changes were
+            // previously requested — reset the loop counter and stored feedback.
+            ...(payload.sentinel === doneRunnerSentinel || payload.sentinel === 'AWAITING_APPROVAL'
+                ? { changesRequestedCount: 0, changesRequestedFeedback: undefined }
+                : {}),
         };
         if (payload.sentinel === 'BLOCKED' || payload.sentinel === 'FAILED') {
             nextContext.blockedFromStage = current.wake.stage;
@@ -359,8 +417,10 @@ async function applyEvent(current, event, ctx, config) {
             ...current,
             context: {
                 ...current.context,
-                deletedAt: event.occurredAt,
-                deletedBy: typeof event.payload.requestedBy === 'string' ? event.payload.requestedBy : 'unknown',
+                deleted: {
+                    at: event.occurredAt,
+                    by: typeof event.payload.requestedBy === 'string' ? event.payload.requestedBy : 'unknown',
+                },
             },
             wake: {
                 ...current.wake,
@@ -380,8 +440,10 @@ async function applyEvent(current, event, ctx, config) {
             },
             context: {
                 ...current.context,
-                frozenAt: event.occurredAt,
-                frozenBy: typeof event.payload.requestedBy === 'string' ? event.payload.requestedBy : 'unknown',
+                frozen: {
+                    at: event.occurredAt,
+                    by: typeof event.payload.requestedBy === 'string' ? event.payload.requestedBy : 'unknown',
+                },
             },
             wake: {
                 ...current.wake,
@@ -392,8 +454,7 @@ async function applyEvent(current, event, ctx, config) {
     }
     if (event.sourceEventType === WORK_ITEM_UNFROZEN_EVENT) {
         const nextContext = { ...current.context };
-        delete nextContext.frozenAt;
-        delete nextContext.frozenBy;
+        delete nextContext.frozen;
         return parseIssueStateRecord({
             ...current,
             issue: {

package/dist/src/core/stale-run-reconciler.js

@@ -1,7 +1,6 @@
 import { createLabelsEvent } from './event-builders.js';
 import { RUN_COMPLETED_EVENT } from '../domain/event-types.js';
-import { stageLabelForStage } from '../domain/stages.js';
-import { workflowLabelForWorkflowName, workflowNameForProjection } from '../domain/workflows.js';
+import { labelsForWorkItem } from '../domain/work-item-labels.js';
 import { createEventEnvelope } from '../lib/event-log.js';
 // Reconciles run records still marked `running` past the runner timeout: a
 // record whose work item has already moved on is superseded, otherwise it is
@@ -89,9 +88,7 @@ export function createStaleRunReconciler(deps) {
         await deps.deliverOutboundEvent(createLabelsEvent({
             projection,
             runId,
-            statusLabel: 'wake:status.failed',
-            stageLabel: stageLabelForStage(projection.wake.stage),
-            workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(projection, deps.config)),
+            ...labelsForWorkItem(projection, deps.config),
             occurredAt: finishedAt,
         }));
     }

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

@@ -8,10 +8,11 @@ import { acquireFileLock } from '../lib/lock.js';
 import { CORRELATION_REGISTERED_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, PR_AUTO_MERGE_ENABLED_EVENT, PR_REVIEW_APPROVED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT, RUN_CLAIMED_EVENT, RUN_COMPLETED_EVENT, } from '../domain/event-types.js';
 import { parseRunnerArtifacts, parseRunnerResult } from '../domain/schema.js';
 import { maxConfiguredRunnerTimeoutMs, resolveRunnerRouting } from '../domain/runner-routing.js';
-import { awaitingApprovalRunnerSentinel, stageLabelForStage } from '../domain/stages.js';
-import { isWorkItemDeleted, isWorkItemRunnable } from '../domain/work-item-lifecycle.js';
+import { awaitingApprovalRunnerSentinel } from '../domain/stages.js';
+import { FROZEN_WORK_ITEM_LABEL, isWorkItemDeleted, isWorkItemRunnable, } from '../domain/work-item-lifecycle.js';
 import { isMeaningfulRuntimeEvent } from '../domain/runtime-events.js';
-import { chooseAction as chooseWorkflowAction, entryStage as workflowEntryStage, isKnownWorkflowStage, workflowChangedBlockReason, workflowForProjection, workflowLabelForWorkflowName, workflowNameForProjection, } from '../domain/workflows.js';
+import { chooseAction as chooseWorkflowAction, entryStage as workflowEntryStage, isKnownWorkflowStage, workflowChangedBlockReason, workflowForProjection, workflowNameForProjection, } from '../domain/workflows.js';
+import { labelsForWorkItem, SCHEDULED_WORKFLOW_LABEL, } from '../domain/work-item-labels.js';
 import { createEventEnvelope } from '../lib/event-log.js';
 import { branchNameForIssue } from '../domain/branch-naming.js';
 import { customCommandWorkspace, isCustomCommandAction } from '../domain/custom-commands.js';
@@ -205,23 +206,13 @@ export function createTickRunner(deps) {
     function isAwaitingApproval(projection) {
         return projection.context.lastRunSentinel === awaitingApprovalRunnerSentinel;
     }
-    function statusLabelForStage(stage) {
-        if (stage === 'done') {
-            return 'wake:status.completed';
-        }
-        return 'wake:status.pending';
-    }
-    function statusLabelForOutcome(input) {
-        if (input.sentinel === 'AWAITING_APPROVAL') {
-            return 'wake:status.awaiting-approval';
-        }
-        if (input.sentinel === 'BLOCKED') {
-            return 'wake:status.blocked';
-        }
-        if (input.sentinel === 'FAILED') {
-            return 'wake:status.failed';
-        }
-        return statusLabelForStage(input.stage);
+    // Always reads the current projection at write time (never a threaded
+    // local like a stale `workflowName`/`claimedStage`), so a mid-run
+    // WORKFLOW_SELECTED_EVENT or freeze/schedule change can never be
+    // stamped with a label reflecting a snapshot from before it took effect.
+    async function currentLabelsForWorkItem(workItemKey, fallback) {
+        const projection = (await deps.stateStore.readIssueState(workItemKey)) ?? fallback;
+        return labelsForWorkItem(projection, deps.config);
     }
     function hasLabel(projection, label) {
         return projection.issue.labels.includes(label);
@@ -354,9 +345,7 @@ export function createTickRunner(deps) {
         await deliverOutboundEvent(createLabelsEvent({
             projection: input.projection,
             runId,
-            statusLabel: 'wake:status.blocked',
-            stageLabel: stageLabelForStage(input.projection.wake.stage),
-            workflowLabel: workflowLabelForWorkflowName(input.workflowName),
+            ...(await currentLabelsForWorkItem(input.projection.workItemKey, input.projection)),
             occurredAt,
         }));
         return {
@@ -486,13 +475,51 @@ export function createTickRunner(deps) {
         await deliverOutboundEvent(createLabelsEvent({
             projection: input.projection,
             runId: input.approvalId,
-            statusLabel: statusLabelForStage(nextStage),
-            stageLabel: stageLabelForStage(nextStage),
-            workflowLabel: workflowLabelForWorkflowName(input.workflowName),
+            ...(await currentLabelsForWorkItem(input.projection.workItemKey, input.projection)),
             occurredAt: input.approvedAt,
         }));
         return { nextStage };
     }
+    // Folds a human /changes reply onto the parent's context via the same
+    // `changesRequested` RUN_COMPLETED payload shape a rejecting review watcher
+    // uses (projection-updater.ts) — same fold, same bounding against
+    // config.retry.maxChangesRequestedRetries, so a human bouncing /changes
+    // repeatedly escalates to 'blocked' exactly like an auto-revise loop would.
+    async function applyChangesRequestedTransition(input) {
+        const currentCount = typeof input.projection.context.changesRequestedCount === 'number' &&
+            Number.isInteger(input.projection.context.changesRequestedCount)
+            ? input.projection.context.changesRequestedCount
+            : 0;
+        const escalated = currentCount + 1 > deps.config.retry.maxChangesRequestedRetries;
+        const event = createEventEnvelope({
+            eventId: `${input.requestId}-changes-requested`,
+            workItemKey: input.projection.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: RUN_COMPLETED_EVENT,
+            sourceRefs: {
+                repo: input.projection.issue.repo,
+                issueNumber: input.projection.issue.number,
+                runId: input.requestId,
+            },
+            occurredAt: input.requestedAt,
+            ingestedAt: input.requestedAt,
+            trigger: 'immediate',
+            payload: {
+                changesRequested: true,
+                runId: input.requestId,
+                reason: 'human:changes-requested',
+                ...(input.feedbackBody === undefined ? {} : { reviewFeedbackBody: input.feedbackBody }),
+                ...(input.triggeringCommentId === undefined
+                    ? {}
+                    : { handledCommentId: input.triggeringCommentId }),
+            },
+        });
+        await deps.stateStore.appendEventEnvelope(event);
+        await projectionUpdater.rebuildFromEvents([event]);
+        return { escalated };
+    }
     // Closes the loop on #82's review feedback: rather than scrape a PR link
     // out of the agent's free text, the agent emits a `wake-artifacts` fence
     // (domain/schema.ts's parseRunnerArtifacts) and Wake verifies each claim
@@ -585,6 +612,11 @@ export function createTickRunner(deps) {
         }
         return watch;
     }
+    // Runs against every open, non-deleted item every tick (not just ones with
+    // an eligible next action) so a stale label self-heals even on a parked
+    // item nothing else would otherwise re-check — this is also where
+    // wake:frozen/wake:scheduled-workflow get their only reconciliation
+    // coverage, since freeze/unfreeze no longer writes labels inline (§6).
     async function markPendingActionableIssues(projections) {
         const activeRunWorkItemKeys = new Set();
         const now = deps.clock.now();
@@ -594,24 +626,28 @@ export function createTickRunner(deps) {
             }
         }
         for (const projection of projections) {
-            if (!isWorkItemRunnable(projection) || activeRunWorkItemKeys.has(projection.workItemKey)) {
+            if (isWorkItemDeleted(projection) || activeRunWorkItemKeys.has(projection.workItemKey)) {
                 continue;
             }
-            const statusLabel = statusLabelForStage(projection.wake.stage);
-            const stageLabel = stageLabelForStage(projection.wake.stage);
-            const workflowLabel = workflowLabelForWorkflowName(workflowNameForProjection(projection, deps.config));
-            if (policy.resolveNextEligibleAction(projection, deps.config) === null ||
-                (hasLabel(projection, statusLabel) &&
-                    hasLabel(projection, stageLabel) &&
-                    hasLabel(projection, workflowLabel))) {
+            const labels = labelsForWorkItem(projection, deps.config);
+            const matchesDesired = hasLabel(projection, labels.statusLabel) &&
+                hasLabel(projection, labels.stageLabel) &&
+                hasLabel(projection, labels.workflowLabel) &&
+                (labels.frozenLabel === undefined || hasLabel(projection, labels.frozenLabel)) &&
+                (labels.scheduledLabel === undefined || hasLabel(projection, labels.scheduledLabel));
+            // A toggle label (frozen/scheduled) whose desired state is "absent"
+            // still needs to be checked for stray presence — the family-prefix
+            // labels above don't need this since removing them is folded into
+            // "does the current one match" by construction.
+            const hasStrayToggleLabel = (labels.frozenLabel === undefined && hasLabel(projection, FROZEN_WORK_ITEM_LABEL)) ||
+                (labels.scheduledLabel === undefined && hasLabel(projection, SCHEDULED_WORKFLOW_LABEL));
+            if (matchesDesired && !hasStrayToggleLabel) {
                 continue;
             }
             await deliverOutboundEvent(createLabelsEvent({
                 projection,
                 runId: `pending-${projection.workItemKey}-${deps.clock.now().getTime()}`,
-                statusLabel,
-                stageLabel,
-                workflowLabel,
+                ...labels,
                 occurredAt: eventStampNow(),
             }));
         }
@@ -786,9 +822,7 @@ export function createTickRunner(deps) {
             await deliverOutboundEvent(createLabelsEvent({
                 projection,
                 runId: eventId,
-                statusLabel: 'wake:status.blocked',
-                stageLabel: stageLabelForStage(projection.wake.stage),
-                workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(projection, deps.config)),
+                ...(await currentLabelsForWorkItem(projection.workItemKey, projection)),
                 occurredAt,
             }));
             parked = true;
@@ -842,9 +876,10 @@ export function createTickRunner(deps) {
             }
             const projections = await deps.stateStore.listIssueStates();
             await cleanupClosedIssueWorkspaces(projections);
-            if (inboundEvents.length > 0) {
-                await markPendingActionableIssues(projections);
-            }
+            // Runs every tick, not only when this tick happened to poll a fresh
+            // inbound event — a stale label on a parked item (nothing else ever
+            // re-checks it once there's no next action) otherwise never self-heals.
+            await markPendingActionableIssues(projections);
             return {
                 status: inboundEvents.length > 0 ? 'processed' : 'idle',
             };
@@ -1191,15 +1226,30 @@ export function createTickRunner(deps) {
                 else {
                     const approvalResolution = policy.resolveApprovalTransition(candidate);
                     if (approvalResolution === null) {
-                        const reviewAction = policy.resolvePendingReviewFeedback(candidate);
-                        if (reviewAction === null) {
-                            return { status: 'idle' };
+                        const changesRequestedAction = policy.resolveChangesRequestedAction(candidate);
+                        if (changesRequestedAction !== null) {
+                            action = changesRequestedAction;
+                            const workflowAction = chooseWorkflowAction(candidate, workflow);
+                            claimedStage = workflowAction?.stage ?? candidate.wake.stage;
+                            workspaceMode = workflowAction?.workspace ?? 'none';
+                            promptContextOverrides = {
+                                ...workflowAction?.promptContext,
+                                ...(typeof candidate.context.changesRequestedFeedback === 'string'
+                                    ? { parentPendingReviewBody: candidate.context.changesRequestedFeedback }
+                                    : {}),
+                            };
+                        }
+                        else {
+                            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';
+                            promptContextOverrides = workflowAction?.promptContext;
                         }
-                        action = reviewAction;
-                        const workflowAction = chooseWorkflowAction(candidate, workflow);
-                        claimedStage = workflowAction?.stage ?? candidate.wake.stage;
-                        workspaceMode = workflowAction?.workspace ?? 'none';
-                        promptContextOverrides = workflowAction?.promptContext;
                     }
                     else if (approvalResolution.approved) {
                         const mergePolicy = approvedMergePolicyForStage(workflow.stages[candidate.wake.stage]);
@@ -1294,11 +1344,34 @@ export function createTickRunner(deps) {
                         };
                     }
                     else {
+                        const changesRequestId = `changes-requested-${candidate.issue.number}-${deps.clock.now().getTime()}`;
+                        const requestedAt = deps.clock.now().toISOString();
+                        const changesRequestedTriggeringCommentId = approvalResolution.triggeringCommentId ?? latestHumanCommentId(candidate);
+                        const { escalated } = await applyChangesRequestedTransition({
+                            projection: candidate,
+                            requestId: changesRequestId,
+                            requestedAt,
+                            ...(approvalResolution.triggeringCommentBody === undefined
+                                ? {}
+                                : { feedbackBody: approvalResolution.triggeringCommentBody }),
+                            ...(changesRequestedTriggeringCommentId === undefined
+                                ? {}
+                                : { triggeringCommentId: changesRequestedTriggeringCommentId }),
+                        });
+                        if (escalated) {
+                            return { status: 'idle' };
+                        }
                         action = approvalResolution.pendingAction;
                         const workflowAction = chooseWorkflowAction(candidate, workflow);
                         claimedStage = workflowAction?.stage ?? candidate.wake.stage;
                         workspaceMode = workflowAction?.workspace ?? 'none';
-                        promptContextOverrides = workflowAction?.promptContext;
+                        promptContextOverrides = {
+                            ...workflowAction?.promptContext,
+                            ...(approvalResolution.changesRequested === true &&
+                                approvalResolution.triggeringCommentBody !== undefined
+                                ? { parentPendingReviewBody: approvalResolution.triggeringCommentBody }
+                                : {}),
+                        };
                     }
                 }
             }
@@ -1480,9 +1553,7 @@ export function createTickRunner(deps) {
                 await deliverOutboundEvent(createLabelsEvent({
                     projection: candidate,
                     runId,
-                    statusLabel: 'wake:status.working',
-                    stageLabel: stageLabelForStage(claimedStage),
-                    workflowLabel: workflowLabelForWorkflowName(workflowName),
+                    ...(await currentLabelsForWorkItem(candidate.workItemKey, candidate)),
                     occurredAt: eventStampNow(),
                 }));
             }
@@ -1865,6 +1936,17 @@ export function createTickRunner(deps) {
                         ...resultMetadata,
                     },
                 });
+                // Computed before the payload so a rejecting review verdict (either
+                // the PR-artifact-verified path or a plain onSuccess.approve watcher
+                // with no PR) can fold context.status = 'changes-requested' on the
+                // parent via the same RUN_COMPLETED event, instead of requiring a
+                // separate marker comment round-trip (§5).
+                const watcherSuccessPolicy = watcherRun && watcherDispatch !== null
+                    ? deps.config.workflows[watcherDispatch.parentWorkflowName]?.stages[watcherDispatch.parentStage]?.watch?.[watcherDispatch.watcherIndex]?.onSuccess
+                    : undefined;
+                const isReviewRejection = watcherRun &&
+                    (sentinel === 'FAILED' || sentinel === 'BLOCKED') &&
+                    (prReviewTargetResourceUri !== null || watcherSuccessPolicy?.approve === true);
                 const runCompletedEvent = createEventEnvelope({
                     eventId: `${runId}-completed`,
                     workItemKey: candidate.workItemKey,
@@ -1912,6 +1994,9 @@ export function createTickRunner(deps) {
                         executionOutcome,
                         ...(workflowOutcome !== undefined ? { workflowOutcome } : {}),
                         ...(watcherRun ? { watcherRun: true, watcherTrigger: watcherTriggerForRun } : {}),
+                        ...(isReviewRejection
+                            ? { changesRequested: true, reviewFeedbackBody: parsedRunnerResult.body }
+                            : {}),
                     },
                 });
                 await deps.stateStore.appendEventEnvelope(runCompletedEvent);
@@ -1920,12 +2005,7 @@ export function createTickRunner(deps) {
                     await deliverOutboundEvent(createLabelsEvent({
                         projection: candidate,
                         runId,
-                        statusLabel: statusLabelForOutcome({
-                            sentinel,
-                            stage: nextStage ?? claimedStage,
-                        }),
-                        stageLabel: stageLabelForStage(nextStage ?? claimedStage),
-                        workflowLabel: workflowLabelForWorkflowName(workflowName),
+                        ...(await currentLabelsForWorkItem(candidate.workItemKey, candidate)),
                         occurredAt: finishedAt,
                     }));
                 }
@@ -1947,9 +2027,6 @@ export function createTickRunner(deps) {
                     // Watcher-dispatched runs own PR verdict delivery and correlation
                     // registration regardless of the target workflow/action name.
                     const pendingApprovalAction = candidate.context.pendingApprovalAction;
-                    const watcherSuccessPolicy = watcherDispatch === null
-                        ? undefined
-                        : deps.config.workflows[watcherDispatch.parentWorkflowName]?.stages[watcherDispatch.parentStage]?.watch?.[watcherDispatch.watcherIndex]?.onSuccess;
                     if (prReviewTargetResourceUri !== null &&
                         (sentinel === 'DONE' || sentinel === 'FAILED')) {
                         await deliverOutboundEvent({
@@ -2125,9 +2202,7 @@ export function createTickRunner(deps) {
                     await deliverOutboundEvent(createLabelsEvent({
                         projection: candidate,
                         runId,
-                        statusLabel: 'wake:status.failed',
-                        stageLabel: stageLabelForStage(claimedStage),
-                        workflowLabel: workflowLabelForWorkflowName(workflowName),
+                        ...(await currentLabelsForWorkItem(candidate.workItemKey, candidate)),
                         occurredAt: finishedAt,
                     }));
                 }

package/dist/src/domain/schema.js

@@ -7,6 +7,7 @@ import { runnerSentinelValues } from './stages.js';
 import { correlationProvenanceSchema, correlationRelationSchema, correlationRoleSchema, resourceUriSchema, } from './resource-uri.js';
 import { runtimeEventTypeValues } from './runtime-events.js';
 import { alwaysManualIgnoredLabels } from './manual-labels.js';
+import { workItemStatusSchema } from './work-item-status.js';
 export { AUTONOMOUS_DECISION_AUDIT_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, WORK_ITEM_CREATED_EVENT, } from './event-types.js';
 const isoTimestampSchema = z.string().datetime({ offset: true });
 const identifierSchema = z.string().min(1);
@@ -275,6 +276,61 @@ export const eventEnvelopeSchema = z.object({
     raw: z.record(z.string(), z.unknown()).optional(),
     derivedHints: z.record(z.string(), z.unknown()).optional(),
 });
+export const failurePhaseSchema = z.enum([
+    'workspace-validation',
+    'workspace-prep',
+    'process-starting',
+    'running',
+    'result-parsing',
+    'publishing',
+    'unknown',
+]);
+export const externalSideEffectsSchema = z.enum(['none', 'confirmed', 'unknown']);
+export const retrySafetySchema = z.enum([
+    'SAFE_TO_RETRY',
+    'SAFE_TO_RESUME',
+    'REQUIRES_RECONCILIATION',
+    'MANUAL_REVIEW_REQUIRED',
+    'NOT_RETRYABLE',
+]);
+// Typed `context` — every field is optional so an on-disk projection missing
+// some/all of them (pre-dating this schema, or simply untouched since) still
+// parses. See docs/superpowers/specs/2026-07-28-canonical-work-item-status-design.md §4/§8.
+export const issueContextSchema = z.object({
+    // Retry/failure bookkeeping, folded from RUN_COMPLETED (projection-updater.ts).
+    failureCount: z.number().int().nonnegative().optional(),
+    lastRunAction: z.string().optional(),
+    lastCompletedAction: z.string().optional(),
+    lastExecutionOutcome: executionOutcomeSchema.optional(),
+    lastWorkflowOutcome: workflowOutcomeSchema.optional(),
+    lastFailurePhase: failurePhaseSchema.optional(),
+    lastProcessStarted: z.boolean().optional(),
+    lastWorkspaceChanged: z.boolean().optional(),
+    lastExternalSideEffects: externalSideEffectsSchema.optional(),
+    lastRetrySafety: retrySafetySchema.optional(),
+    blockedFromStage: z.string().optional(),
+    lastFailureClass: z.enum(['task', 'quota', 'infra']).optional(),
+    lastHandledCommentId: z.string().optional(),
+    lastRunSentinel: runnerSentinelSchema.optional(),
+    // Set while AWAITING_APPROVAL so the approval path knows which action to
+    // resume (or skip) once a human responds.
+    pendingApprovalAction: z.string().optional(),
+    pendingApprovalAllowAutoApproval: z.boolean().optional(),
+    // Workflow pinned at mint time (WORKFLOW_SELECTED_EVENT); re-read at every
+    // label write instead of trusting a threaded local (workflow-name-drift, §6).
+    workflow: z.string().optional(),
+    // Canonical status — see work-item-status.ts. Additive alongside
+    // lastRunSentinel, not a replacement for it (§3).
+    status: workItemStatusSchema.optional(),
+    changesRequestedCount: z.number().int().nonnegative().optional(),
+    // Feedback body threaded into the next auto-revise prompt as
+    // promptContextOverrides.parentPendingReviewBody (§5).
+    changesRequestedFeedback: z.string().optional(),
+    // Orthogonal facts — not folded into `status` (§2).
+    frozen: z.object({ at: isoTimestampSchema, by: z.string() }).optional(),
+    deleted: z.object({ at: isoTimestampSchema, by: z.string() }).optional(),
+    scheduled: z.boolean().optional(),
+});
 export const issueStateRecordSchema = z.object({
     schemaVersion: z.literal(1),
     workItemKey: z.string(),
@@ -299,7 +355,7 @@ export const issueStateRecordSchema = z.object({
         })
             .default({ commentIds: [], labels: [] }),
     }),
-    context: z.record(z.string(), z.unknown()).default({}),
+    context: issueContextSchema.default({}),
     correlatedResources: z.array(correlatedResourceSchema).default([]),
 });
 export const runInputSnapshotSchema = z.object({
@@ -338,23 +394,6 @@ const runLeaseSchema = z.object({
     lastRenewedAt: isoTimestampSchema,
     expiresAt: isoTimestampSchema,
 });
-export const failurePhaseSchema = z.enum([
-    'workspace-validation',
-    'workspace-prep',
-    'process-starting',
-    'running',
-    'result-parsing',
-    'publishing',
-    'unknown',
-]);
-export const externalSideEffectsSchema = z.enum(['none', 'confirmed', 'unknown']);
-export const retrySafetySchema = z.enum([
-    'SAFE_TO_RETRY',
-    'SAFE_TO_RESUME',
-    'REQUIRES_RECONCILIATION',
-    'MANUAL_REVIEW_REQUIRED',
-    'NOT_RETRYABLE',
-]);
 function legacyRunLifecycle(input) {
     if (input.lifecycle !== undefined) {
         return input;
@@ -649,8 +688,9 @@ const wakeConfigBaseSchema = z.object({
     retry: z
         .object({
         maxFailureRetries: z.number().int().positive().default(5),
+        maxChangesRequestedRetries: z.number().int().positive().default(5),
     })
-        .default({ maxFailureRetries: 5 }),
+        .default({ maxFailureRetries: 5, maxChangesRequestedRetries: 5 }),
     runners: z.record(z.string(), runnerEntrySchema).default({
         fake: { kind: 'fake', cli: 'Fake' },
         'claude-haiku': {

package/dist/src/domain/work-item-labels.js

@@ -0,0 +1,48 @@
+import { stageLabelForStage } from './stages.js';
+import { FROZEN_WORK_ITEM_LABEL } from './work-item-lifecycle.js';
+import { workflowLabelForWorkflowName, workflowNameForProjection } from './workflows.js';
+// The single place that translates the canonical, typed context fields
+// (status/frozen/deleted/scheduled) into wake:* label strings. Lives in
+// domain/ (not adapters/github/) so core/ can call it directly without
+// importing a concrete adapter — the wake: naming convention is Wake's own,
+// not GitHub-specific, matching stageLabelForStage/workflowLabelForWorkflowName
+// which already live here for the same reason.
+export const SCHEDULED_WORKFLOW_LABEL = 'wake:scheduled-workflow';
+const statusLabelByStatus = {
+    queued: 'wake:status.pending',
+    working: 'wake:status.working',
+    'awaiting-approval': 'wake:status.awaiting-approval',
+    'changes-requested': 'wake:status.changes-requested',
+    blocked: 'wake:status.blocked',
+    done: 'wake:status.completed',
+    failed: 'wake:status.failed',
+};
+// A projection that predates context.status being folded (or hasn't had a
+// run complete yet since this design shipped) has no status field — fall
+// back to the same sentinel+stage heuristic the old statusLabelForOutcome
+// used, so an untouched legacy item is translated to the *same* label it
+// already carries (e.g. still-AWAITING_APPROVAL) instead of drifting to a
+// wrong one just because context.status hasn't been folded onto it yet.
+function legacyStatusFallback(projection) {
+    const sentinel = projection.context.lastRunSentinel;
+    if (sentinel === 'AWAITING_APPROVAL') {
+        return 'awaiting-approval';
+    }
+    if (sentinel === 'BLOCKED') {
+        return 'blocked';
+    }
+    if (sentinel === 'FAILED') {
+        return 'failed';
+    }
+    return projection.wake.stage === 'done' ? 'done' : 'queued';
+}
+export function labelsForWorkItem(projection, config) {
+    const statusLabel = statusLabelByStatus[projection.context.status ?? legacyStatusFallback(projection)];
+    return {
+        statusLabel,
+        stageLabel: stageLabelForStage(projection.wake.stage),
+        workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(projection, config)),
+        ...(projection.context.frozen !== undefined ? { frozenLabel: FROZEN_WORK_ITEM_LABEL } : {}),
+        ...(projection.context.scheduled === true ? { scheduledLabel: SCHEDULED_WORKFLOW_LABEL } : {}),
+    };
+}

package/dist/src/domain/work-item-lifecycle.js

@@ -1,9 +1,9 @@
 export const FROZEN_WORK_ITEM_LABEL = 'wake:frozen';
 export function isWorkItemDeleted(item) {
-    return typeof item.context.deletedAt === 'string';
+    return item.context.deleted !== undefined;
 }
 export function isWorkItemFrozen(item) {
-    return typeof item.context.frozenAt === 'string';
+    return item.context.frozen !== undefined;
 }
 export function isWorkItemRunnable(item) {
     return !isWorkItemDeleted(item) && !isWorkItemFrozen(item);

package/dist/src/domain/work-item-status.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+// Canonical, typed status for a work item — folded once in
+// projection-updater.ts, translated (never recomputed) everywhere else
+// (e.g. GitHub labels via labelsForWorkItem). See
+// docs/superpowers/specs/2026-07-28-canonical-work-item-status-design.md.
+export const workItemStatusValues = [
+    'queued',
+    'working',
+    'awaiting-approval',
+    'changes-requested',
+    'blocked',
+    'done',
+    'failed',
+];
+export const workItemStatusSchema = z.enum(workItemStatusValues);
+// Mirrors the sentinel/stage mapping that used to live only in
+// tick-runner.ts's statusLabelForOutcome/statusLabelForStage. Folded onto
+// context.status alongside (not replacing) context.lastRunSentinel.
+export function workItemStatusForRunOutcome(input) {
+    if (input.sentinel === 'AWAITING_APPROVAL') {
+        return 'awaiting-approval';
+    }
+    if (input.sentinel === 'BLOCKED') {
+        return 'blocked';
+    }
+    if (input.sentinel === 'FAILED') {
+        return 'failed';
+    }
+    return input.stage === 'done' ? 'done' : 'queued';
+}

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "gbf60f05";
+export const wakeVersion = "g4eb3621";

package/package.json

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