@atolis-hq/wake 0.2.59 → 0.2.61

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/fs/state-store.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { access, appendFile, mkdir, readFile, readdir, rename } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { validateResourceIndex } from './resource-index.js';
-import { parseEventEnvelope, parseIssueStateRecord, parseLedger, parseRunRecord, parseSourceStateRecord, } from '../../domain/schema.js';
+import { parseEventEnvelope, parseIssueStateRecord, parseLedger, parseRunInputSnapshot, parseRunRecord, parseSourceStateRecord, } from '../../domain/schema.js';
 import { isTerminalStage } from '../../domain/stages.js';
 import { appendJsonLine, readJsonFile, writeJsonFile } from '../../lib/json-file.js';
 import { acquireFileLock } from '../../lib/lock.js';
@@ -509,6 +509,22 @@ export function createStateStore({ wakeRoot }) {
             await upsertRunSummaryIndexEntry(paths, parsed);
             return parsed;
         },
+        async writeRunInputSnapshot(record) {
+            const parsed = parseRunInputSnapshot(record);
+            await writeJsonFile(paths.runInputSnapshotFile(parsed.snapshotId), parsed);
+            return parsed;
+        },
+        async readRunInputSnapshot(snapshotId) {
+            try {
+                return parseRunInputSnapshot(await readJsonFile(paths.runInputSnapshotFile(snapshotId)));
+            }
+            catch (error) {
+                if (isMissingPathError(error)) {
+                    return null;
+                }
+                throw error;
+            }
+        },
         async updateRunRecordIf(runId, input) {
             const current = await this.readRunRecord(runId);
             if (current === null || !input.expect(current)) {

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

@@ -82,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) {
@@ -121,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.');
     }
@@ -232,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

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createLifecycleService } from './lifecycle-service.js';
 import { createPolicyEngine } from './policy-engine.js';
@@ -32,6 +34,19 @@ function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
 }
+// Matched as a token at the start of a (trimmed) line, mirroring the
+// /approved and /changes commands in policy-engine.ts.
+const interruptCommandPattern = /^\/interrupt\b/i;
+// Plain comments during a run are additional context for the next turn, not
+// a signal to abandon the current attempt - only an explicit /interrupt
+// should cancel an in-flight run, per the PR #411 follow-up discussion.
+function newHumanCommentsSince(snapshot, refreshed) {
+    const knownIds = new Set(snapshot.comments.map((comment) => comment.id));
+    return refreshed.comments.filter((comment) => !comment.isBotAuthored && !knownIds.has(comment.id));
+}
+function requestsInterrupt(comments) {
+    return comments.some((comment) => comment.body.split(/\r?\n/).some((line) => interruptCommandPattern.test(line.trim())));
+}
 function latestActionableCommentId(candidate) {
     const handledCommentId = typeof candidate.context.lastHandledCommentId === 'string'
         ? candidate.context.lastHandledCommentId
@@ -57,6 +72,22 @@ function projectedSourceRevision(projection) {
         ? `${projection.issue.repo}#${projection.issue.number}@${projection.issue.updatedAt}`
         : `${projection.issue.repo}#${projection.issue.number}@${projection.issue.updatedAt};comments@${latestCommentUpdatedAt}`;
 }
+function stableJson(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`)
+        .join(',')}}`;
+}
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(stableJson(value)).digest('hex')}`;
+}
 function isLateralReadOnlyAction(action, config) {
     return isCustomCommandAction(action, config);
 }
@@ -108,7 +139,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;
@@ -587,6 +618,74 @@ export function createTickRunner(deps) {
     function runnerTimeoutMs() {
         return maxConfiguredRunnerTimeoutMs(deps.config);
     }
+    async function promptHashForAction(action) {
+        const promptsRoot = deps.config.paths.promptsRoot;
+        if (promptsRoot === undefined) {
+            return sha256({ action, status: 'not-configured' });
+        }
+        for (const suffix of ['.md', '.start.md', '.resume.md']) {
+            const path = join(promptsRoot, `${action}${suffix}`);
+            try {
+                return `sha256:${createHash('sha256')
+                    .update(await readFile(path, 'utf8'))
+                    .digest('hex')}`;
+            }
+            catch {
+                // Try the next supported prompt template name.
+            }
+        }
+        return sha256({ action, status: 'missing' });
+    }
+    function triggerEventIdForRun(input) {
+        if (input.watcherTrigger?.kind === 'event') {
+            return input.watcherTrigger.eventId;
+        }
+        return input.recentEvents.at(-1)?.eventId;
+    }
+    async function createRunInputSnapshot(input) {
+        const validation = input.workspaceValidation !== null &&
+            typeof input.workspaceValidation === 'object' &&
+            !Array.isArray(input.workspaceValidation)
+            ? input.workspaceValidation
+            : undefined;
+        const repositoryHead = typeof validation?.baseRevision === 'string' ? validation.baseRevision : undefined;
+        const workspaceHead = typeof validation?.headRevision === 'string' ? validation.headRevision : undefined;
+        const triggerEventId = triggerEventIdForRun({
+            ...(input.watcherTrigger === undefined ? {} : { watcherTrigger: input.watcherTrigger }),
+            recentEvents: input.recentEvents,
+        });
+        return deps.stateStore.writeRunInputSnapshot({
+            schemaVersion: 1,
+            snapshotId: `${input.runId}-input`,
+            runId: input.runId,
+            createdAt: input.createdAt,
+            action: input.action,
+            workflowName: input.workflowName,
+            claimedStage: input.claimedStage,
+            projectionVersion: input.projection.wake.syncedAt,
+            sourceUpdatedAt: input.projection.issue.updatedAt,
+            sourceRevision: input.sourceRevision,
+            ...(triggerEventId === undefined ? {} : { triggerEventId }),
+            ...(input.recentEvents.at(-1)?.eventId === undefined
+                ? {}
+                : { handledThroughEventId: input.recentEvents.at(-1).eventId }),
+            workflowHash: await computeWorkflowRevision({
+                config: deps.config,
+                workflowName: input.workflowName,
+                workflow: input.workflow,
+                action: input.action,
+            }),
+            promptHash: await promptHashForAction(input.action),
+            ...(repositoryHead === undefined ? {} : { repositoryHead }),
+            ...(workspaceHead === undefined ? {} : { workspaceHead }),
+            runnerConfigurationHash: sha256({
+                routing: input.routing,
+                runner: deps.config.runners[input.routing.runnerName],
+            }),
+            projection: input.projection,
+            recentEvents: input.recentEvents,
+        });
+    }
     // Counted from durable run records (never an in-memory counter, per the
     // "tick is a pure function of durable state" invariant), so this holds
     // across process restarts and is a backstop independent of any specific
@@ -1395,6 +1494,35 @@ export function createTickRunner(deps) {
                     timer.unref?.();
                 });
             }
+            const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
+            const activeCandidate = candidate;
+            const runnerProjection = watcherRun
+                ? {
+                    ...activeCandidate,
+                    wake: {
+                        ...activeCandidate.wake,
+                        sessionId: undefined,
+                        sessionCli: undefined,
+                    },
+                }
+                : activeCandidate;
+            const inputSnapshot = await createRunInputSnapshot({
+                runId,
+                createdAt: deps.clock.now().toISOString(),
+                action,
+                workflowName,
+                workflow: deps.config.workflows[workflowName] ?? workflow,
+                claimedStage,
+                projection: runnerProjection,
+                recentEvents,
+                sourceRevision,
+                routing,
+                ...(watcherTriggerForRun === undefined ? {} : { watcherTrigger: watcherTriggerForRun }),
+            });
+            await deps.stateStore.writeRunRecord({
+                ...(await deps.stateStore.readRunRecord(runId)),
+                inputSnapshotId: inputSnapshot.snapshotId,
+            });
             try {
                 await transitionRunLifecycle('PREPARING');
                 const prepareResult = workspaceMode === 'branch'
@@ -1421,25 +1549,14 @@ export function createTickRunner(deps) {
                         ...preparedRecord.metadata,
                         ...(workspacePath === undefined ? {} : { workspacePath }),
                         workspaceMode,
+                        inputSnapshotId: inputSnapshot.snapshotId,
                         ...(prepareResult.validation === undefined
                             ? {}
                             : { workspaceValidation: prepareResult.validation }),
                     },
                 });
-                const recentEvents = await deps.stateStore.listEventEnvelopesForWorkItem(candidate.workItemKey, 6);
                 await transitionRunLifecycle('RUNNING');
                 startLeaseRenewal();
-                const activeCandidate = candidate;
-                const runnerProjection = watcherRun
-                    ? {
-                        ...activeCandidate,
-                        wake: {
-                            ...activeCandidate.wake,
-                            sessionId: undefined,
-                            sessionCli: undefined,
-                        },
-                    }
-                    : activeCandidate;
                 let executionFinished = false;
                 let cancellationReason = null;
                 const runnerInput = {
@@ -1516,6 +1633,14 @@ export function createTickRunner(deps) {
                         }
                         const refreshedProjection = (await deps.stateStore.readIssueState(activeCandidate.workItemKey)) ??
                             activeCandidate;
+                        const newHumanComments = newHumanCommentsSince(inputSnapshot.projection, refreshedProjection);
+                        if (requestsInterrupt(newHumanComments)) {
+                            const reason = 'CANCELED_BY_SUPERSEDING_EVENT';
+                            cancellationReason = reason;
+                            await persistCancellationRequest(reason);
+                            await execution.cancel(reason);
+                            return reason;
+                        }
                         const ineligible = activeRefresh.sourceExists === false ||
                             !policy.isEligible(refreshedProjection, deps.config);
                         if (!ineligible) {
@@ -1549,9 +1674,13 @@ export function createTickRunner(deps) {
                 // the protocol; treat it as AWAITING_APPROVAL so the gate is enforced.
                 const skipApproval = runnerResult.metadata?.skipApproval;
                 const sentinel = rawSentinel === 'DONE' && skipApproval === false ? 'AWAITING_APPROVAL' : rawSentinel;
-                const nextStage = isLateralReadOnlyAction(action, deps.config) && sentinel === 'DONE'
+                // A canceled run must not advance the stage regardless of what the
+                // runner echoed back — the snapshot it acted on was superseded.
+                const nextStage = cancellationReason !== null
                     ? null
-                    : lifecycle.nextStageFromSentinel(claimedStage, sentinel, workflow);
+                    : isLateralReadOnlyAction(action, deps.config) && sentinel === 'DONE'
+                        ? null
+                        : lifecycle.nextStageFromSentinel(claimedStage, sentinel, workflow);
                 const finishedAt = deps.clock.now().toISOString();
                 let workspaceBookkeeping;
                 if (workspacePath !== undefined) {
@@ -1674,13 +1803,17 @@ export function createTickRunner(deps) {
                         : runnerResult.failureClass === 'infra'
                             ? 'PROCESS_FAILED'
                             : 'COMPLETED';
-                const workflowOutcome = sentinel === 'DONE'
-                    ? 'DONE'
-                    : sentinel === 'BLOCKED'
-                        ? 'BLOCKED'
-                        : sentinel === 'AWAITING_APPROVAL'
-                            ? 'AWAITING_APPROVAL'
-                            : undefined;
+                // Canceled runs don't produce a meaningful workflow outcome; the input
+                // they acted on was superseded so the sentinel is not authoritative.
+                const workflowOutcome = cancellationReason !== null
+                    ? undefined
+                    : sentinel === 'DONE'
+                        ? 'DONE'
+                        : sentinel === 'BLOCKED'
+                            ? 'BLOCKED'
+                            : sentinel === 'AWAITING_APPROVAL'
+                                ? 'AWAITING_APPROVAL'
+                                : undefined;
                 await transitionRunLifecycle('FINALISING');
                 const finalisingRecord = (await deps.stateStore.readRunRecord(runId));
                 const failureContext = sentinel === 'FAILED'
@@ -1753,11 +1886,13 @@ export function createTickRunner(deps) {
                         ...(failureContext === undefined ? {} : failureContext),
                         // Only mark the triggering comment handled when the run reached the
                         // agent and produced a real outcome. Quota/infra failures are transient
-                        // blips, not an answer to the human's comment — leaving handledCommentId
-                        // unset lets the next tick retry instead of silently eating the request (S9).
-                        ...(runnerResult.failureClass === 'quota' || runnerResult.failureClass === 'infra'
+                        // blips; canceled runs acted on a superseded snapshot — in both cases
+                        // leave handledCommentId unset so the next tick can retry (S9).
+                        ...(runnerResult.failureClass === 'quota' ||
+                            runnerResult.failureClass === 'infra' ||
+                            cancellationReason !== null
                             ? {}
-                            : { handledCommentId: latestActionableCommentId(candidate) }),
+                            : { handledCommentId: latestActionableCommentId(inputSnapshot.projection) }),
                         body: parsedRunnerResult.body,
                         envelope: parsedRunnerResult.envelope,
                         executionOutcome,

package/dist/src/domain/custom-commands.js

@@ -1,4 +1,4 @@
-export const reservedCommandNames = ['approved', 'changes'];
+export const reservedCommandNames = ['approved', 'changes', 'interrupt'];
 function latestUnhandledHumanComment(issue) {
     const context = issue.context;
     const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;

package/dist/src/domain/schema.js

@@ -311,6 +311,27 @@ export const issueStateRecordSchema = z.object({
     context: z.record(z.string(), z.unknown()).default({}),
     correlatedResources: z.array(correlatedResourceSchema).default([]),
 });
+export const runInputSnapshotSchema = z.object({
+    schemaVersion: z.literal(1),
+    snapshotId: z.string(),
+    runId: z.string(),
+    createdAt: isoTimestampSchema,
+    action: identifierSchema,
+    workflowName: identifierSchema,
+    claimedStage: identifierSchema,
+    projectionVersion: z.string(),
+    sourceUpdatedAt: isoTimestampSchema,
+    sourceRevision: z.string(),
+    triggerEventId: z.string().optional(),
+    handledThroughEventId: z.string().optional(),
+    workflowHash: z.string(),
+    promptHash: z.string(),
+    repositoryHead: z.string().optional(),
+    workspaceHead: z.string().optional(),
+    runnerConfigurationHash: z.string(),
+    projection: issueStateRecordSchema,
+    recentEvents: z.array(eventEnvelopeSchema),
+});
 const runTokenUsageSchema = z.object({
     inputTokens: z.number().nonnegative(),
     outputTokens: z.number().nonnegative(),
@@ -392,6 +413,7 @@ export const runRecordSchema = z.preprocess((input) => {
     externalSideEffects: externalSideEffectsSchema.optional(),
     retrySafety: retrySafetySchema.optional(),
     summary: z.string().optional(),
+    inputSnapshotId: z.string().optional(),
     routing: runnerRoutingSchema.optional(),
     lease: runLeaseSchema.optional(),
     workerPid: z.number().int().positive().optional(),
@@ -979,7 +1001,7 @@ export const wakeConfigSchema = wakeConfigBaseSchema.superRefine((config, ctx) =
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
                 path: ['commands', commandName],
-                message: `Command "/${commandName}" is reserved for Wake approval control.`,
+                message: `Command "/${commandName}" is reserved for Wake's own control flow.`,
             });
         }
         if (command.action === undefined && !promptExists(promptsRoot, commandName)) {
@@ -1008,6 +1030,9 @@ export function parseIssueStateRecord(input) {
 export function parseRunRecord(input) {
     return runRecordSchema.parse(input);
 }
+export function parseRunInputSnapshot(input) {
+    return runInputSnapshotSchema.parse(input);
+}
 export function parseEventEnvelope(input) {
     return eventEnvelopeSchema.parse(input);
 }
@@ -1117,7 +1142,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/lib/paths.js

@@ -32,6 +32,7 @@ export function createWakePaths(wakeRoot) {
         sourceStateFile: (source, key) => join(dataRoot, 'sources', sanitizePathKey(source), `${sanitizePathKey(key)}.json`),
         runFile: (runId) => join(dataRoot, 'runs', `${runId}.json`),
         runDateFile: (date, runId) => join(dataRoot, 'runs', 'by-date', date, `${runId}.json`),
+        runInputSnapshotFile: (snapshotId) => join(dataRoot, 'runs', 'input-snapshots', `${sanitizePathKey(snapshotId)}.json`),
         runDateIndexFile: (date) => join(dataRoot, 'runs', 'by-date', date, 'index.json'),
         runDateIndexLockFile: (date) => join(dataRoot, 'locks', `run-index-${date}.lock`),
         eventFile: (date) => join(dataRoot, 'events', `${date}.jsonl`),

package/dist/src/version.js

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

package/package.json

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