@atolis-hq/wake 0.2.60 → 0.2.61

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/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);
 }
@@ -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);
 }

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 = "gf59c4fc";
+export const wakeVersion = "g99d278b";

package/package.json

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