@yeaft/webchat-agent 1.0.255 → 1.0.257

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.255",
+  "version": "1.0.257",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/work-center/action-identity.js

@@ -8,23 +8,31 @@ export function eventMatchesActionGeneration(event, action) {
 }
 
 export function currentActionInputEventIds(events, action) {
-  const inputEvents = new Map((Array.isArray(events) ? events : [])
-    .filter(event => event?.type === 'action.input_added' && event.actionId === action?.id)
+  const actionEvents = (Array.isArray(events) ? events : [])
+    .filter(event => event?.actionId === action?.id);
+  const inputEvents = new Map(actionEvents
+    .filter(event => event.type === 'action.input_added')
     .map(event => [String(event.id), event]));
   const valid = new Set();
+  const superseded = new Set();
   for (const event of inputEvents.values()) {
     if (eventMatchesActionGeneration(event, action)) valid.add(String(event.id));
   }
-  for (const event of Array.isArray(events) ? events : []) {
-    if (event?.type !== 'action.input_rebound' || event.actionId !== action?.id
-        || !eventMatchesActionGeneration(event, action)) continue;
+  for (const event of actionEvents) {
     const sourceEventIds = [
       event.data?.sourceEventId,
       ...(Array.isArray(event.data?.sourceEventIds) ? event.data.sourceEventIds : []),
-    ].filter(value => value != null);
+    ].filter(value => value != null).map(String);
+    if (event.type === 'action.input_superseded') {
+      for (const eventId of sourceEventIds) {
+        superseded.add(eventId);
+        valid.delete(eventId);
+      }
+      continue;
+    }
+    if (event.type !== 'action.input_rebound' || !eventMatchesActionGeneration(event, action)) continue;
     for (const eventId of sourceEventIds) {
-      const key = String(eventId);
-      if (inputEvents.has(key)) valid.add(key);
+      if (inputEvents.has(eventId) && !superseded.has(eventId)) valid.add(eventId);
     }
   }
   return valid;

package/yeaft/work-center/bridge.js

@@ -20,7 +20,7 @@ let shutdownPromise = null;
 let serviceFactory = null;
 
 const BROWSER_DETAIL_OPS = new Set([
-  'get', 'create', 'update', 'start', 'cancel', 'action_input', 'retry_action', 'guide', 'retry',
+  'get', 'create', 'update', 'start', 'cancel', 'resume', 'action_input', 'retry_action', 'guide', 'retry',
 ]);
 const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_requests', 'get_action_request']);
 // `files` is an internal server-to-Agent field. The browser relay rejects any
@@ -34,6 +34,7 @@ const BROWSER_FILE_FIELDS = Object.freeze({
   ],
   action_input: ['id', 'text', 'actionId', 'revision', 'generation', 'files'],
   retry_action: ['id', 'actionId', 'revision', 'generation'],
+  resume: ['id', 'revision'],
   delete: ['id', 'revision'],
   guide: ['id', 'guidance', 'actionId', 'revision', 'generation', 'files'],
   get_action_messages: ['id', 'actionId', 'generation', 'cursor', 'limit'],
@@ -220,7 +221,9 @@ export async function handleWorkCenterRequest(msg) {
         : (BROWSER_ACTION_DEBUG_OPS.has(op) ? browserFilePayload(op, msg.payload) : (msg.payload || {}));
       data = await workCenter.handle(op, payload);
     }
-    if (BROWSER_DETAIL_OPS.has(op)) data = workCenter.projectBrowserDetail(data);
+    if (BROWSER_DETAIL_OPS.has(op) && data?.accepted !== true) {
+      data = workCenter.projectBrowserDetail(data);
+    }
     send({
       type: 'work_center_response',
       requestId,

package/yeaft/work-center/controller.js

@@ -173,6 +173,30 @@ export class WorkflowController {
     return this.store.getWorkItemDetail(id);
   }
 
+  resume(id, input = {}) {
+    const revision = Number(input.revision);
+    if (!Number.isInteger(revision) || revision < 1) {
+      throw new Error('revision is required to resume a WorkItem');
+    }
+    const detail = this.store.resumeWorkItemAtomic(id, revision, workItem => {
+      const action = initialActionFor(workItem);
+      if (workItem.reuseMemory === false) return action;
+      const context = this.store.getReusableContext(workItem.workDir, workItem.id);
+      return {
+        ...action,
+        context,
+        instruction: actionInstruction(
+          action,
+          workItem,
+          context,
+          renderSessionContextSnapshot(workItem.sessionContext),
+        ),
+      };
+    });
+    if (!detail) throw new Error(`WorkItem not found: ${id}`);
+    return detail;
+  }
+
   guide(id, input = {}) {
     const guidance = typeof input.guidance === 'string' ? input.guidance.trim().slice(0, 8_000) : '';
     const addedAttachmentCount = Math.max(0, Number(input.addedAttachmentCount) || 0);

package/yeaft/work-center/coordinator.js

@@ -16,6 +16,7 @@ const COORDINATOR_MAX_REPLY_CHARS = 8_000;
 const COORDINATOR_MAX_INSTRUCTION_CHARS = 8_000;
 const COORDINATOR_MAX_OUTPUT_TOKENS = 8_192;
 const COORDINATOR_MAX_SNAPSHOT_BYTES = 64 * 1024;
+const COORDINATOR_DECISION_ATTEMPTS = 2;
 const COORDINATOR_RECOVERY_DECISION_ATTEMPTS = 2;
 const COORDINATOR_MAX_CONVERSATION_MESSAGES = 20;
 const COORDINATOR_MAX_ACTIONS = 64;
@@ -302,7 +303,9 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
     : {};
   const allowedKinds = options.recovery === true
     ? ['guide_actions', 'replan', 'request_human']
-    : ['answer', 'guide_actions', 'replan'];
+    : options.controlRequired === true
+      ? ['guide_actions', 'replan']
+      : ['answer', 'guide_actions', 'replan'];
   const kind = allowedKinds.includes(source.kind) ? source.kind : '';
   if (!kind) throw new Error('Work Center Coordinator decision kind is invalid');
   const reason = cleanText(source.reason, 2_000, 'decision reason');
@@ -494,12 +497,15 @@ export class WorkItemCoordinator {
     }, {
       attachments: input.attachments,
       addedAttachments,
+      recovery: input.recovery,
+      requireWaitingRecovery: input.controlRequired === true,
     });
     if (!started) throw new Error(`WorkItem not found: ${id}`);
     options.onUpdate?.('coordinator.turn_started', started.detail);
     return this.#scheduleTurn(started, {
       text: promptText,
       recovery: false,
+      controlRequired: input.controlRequired === true,
       addedAttachments,
       options,
     });
@@ -535,15 +541,17 @@ export class WorkItemCoordinator {
     const text = `Action stage "${action.stageId}" failed. Decide the next safe control transition. `
       + 'Failure is not a terminal WorkItem state: guide or replan executable work whenever possible. '
       + 'Request human input only when the snapshot lacks information required for a safe decision.';
-    return this.#scheduleTurn(started, { text, recovery: true, options });
+    return this.#scheduleTurn(started, { text, recovery: true, controlRequired: false, options });
   }
 
-  #scheduleTurn(started, { text, recovery, addedAttachments = [], options }) {
+  #scheduleTurn(started, {
+    text, recovery, controlRequired = false, addedAttachments = [], options,
+  }) {
     const abortController = new AbortController();
     this.activeTurns.set(started.turnId, abortController);
     const task = new Promise(resolve => setTimeout(resolve, 0))
       .then(() => this.#executeTurn(started, {
-        text, recovery, addedAttachments, options, abortController,
+        text, recovery, controlRequired, addedAttachments, options, abortController,
       }))
       .finally(() => {
         this.activeTurns.delete(started.turnId);
@@ -554,7 +562,7 @@ export class WorkItemCoordinator {
   }
 
   async #executeTurn(started, {
-    text, recovery, addedAttachments, options, abortController,
+    text, recovery, controlRequired, addedAttachments, options, abortController,
   }) {
     try {
       let normalized = null;
@@ -605,7 +613,9 @@ export class WorkItemCoordinator {
         } catch (error) {
           throw coordinatorExecutionError(error, 'selection');
         }
-        const maxAttempts = recovery ? COORDINATOR_RECOVERY_DECISION_ATTEMPTS : 1;
+        const maxAttempts = recovery
+          ? COORDINATOR_RECOVERY_DECISION_ATTEMPTS
+          : COORDINATOR_DECISION_ATTEMPTS;
         for (let index = 0; index < maxAttempts; index += 1) {
           attemptCount = index + 1;
           mutation = null;
@@ -645,6 +655,7 @@ export class WorkItemCoordinator {
             }
             normalized = normalizeCoordinatorResponse(result?.text, started.detail, {
               recovery,
+              controlRequired,
               recoveryActionId: started.fence.recovery?.actionId || null,
             });
             if (normalized.decision.kind === 'replan') {

package/yeaft/work-center/projection.js

@@ -901,6 +901,11 @@ export function projectWorkItemDetail(detail, options = {}) {
         affectedActionIds: Array.isArray(message.decision.affectedActionIds)
           ? message.decision.affectedActionIds.map(id => String(id)).slice(0, 8) : [],
       } : null,
+      recovery: message.recovery && typeof message.recovery === 'object' ? {
+        actionId: truncateUtf8(String(message.recovery.actionId || ''), 256),
+        actionGeneration: Math.max(0, count(message.recovery.actionGeneration)),
+        stageId: truncateUtf8(String(message.recovery.stageId || ''), 256),
+      } : null,
       createdAt: count(message.createdAt),
       updatedAt: count(message.updatedAt || message.createdAt),
     })),

package/yeaft/work-center/runner.js

@@ -32,6 +32,7 @@ import { MCPManager } from '../mcp.js';
 import { buildMcpFlattenedTools } from '../tools/mcp-tools.js';
 import { recallWorkspaceSessionContext } from './workspace-context.js';
 import { applyGeneratedPlan, BUILT_IN_ACTION_TYPES } from './workflow.js';
+import { applyAdditivePlanProposal } from './plan-mutation.js';
 import { normalizeContractPatch, validateCompletedResult } from './completion-contract.js';
 import { normalizeEvidence } from './evidence.js';
 import {
@@ -395,13 +396,18 @@ function plannedActionSchema(vpIds, { requireCandidates = true } = {}) {
   } };
 }
 
-export function createProposeWorkItemActionsTool({ vps, workItem, actions, collector, isRunActive }) {
+export function createProposeWorkItemActionsTool({
+  vps, workItem, actions, collector, isRunActive, currentAction = null,
+}) {
   const vpCatalog = planningVpCatalog(vps);
   const vpIds = vpCatalog.map(vp => vp.id);
   const existing = actions.filter(action => !['superseded', 'cancelled'].includes(action.status));
+  const currentIdentity = currentAction
+    ? ` Current Action: stageId=${currentAction.stageId}; internalActionId=${currentAction.id}. Its graph references must use stageId.`
+    : '';
   return defineTool({
     name: 'ProposeWorkItemActions',
-    description: `Propose an additive change to the current WorkItem DAG. It is applied only if this Action completes and its Run lease plus basePlanRevision remain valid. Existing Actions: ${existing.map(action => `${action.id}/${action.stageId} (${action.status}, attempt ${action.attempt})`).join('; ')}. Available VPs: ${vpCatalog.map(vp => `${vp.id} (${vp.role || vp.area || 'VP'})`).join('; ')}. Only add new Actions and optionally add dependencies to attempt=0 ready Actions.`,
+    description: `Propose an additive change to the current WorkItem DAG. It is applied only if this Action completes and its Run lease plus basePlanRevision remain valid. Use stable stageId values in dependsOnActionIds, changesRequestedActionId, and dependencyPatches[].addDependsOnActionIds. The only internal id field is dependencyPatches[].actionId, which must use the displayed internalActionId of an eligible ready attempt=0 target.${currentIdentity} Existing Actions: ${existing.map(action => `stageId=${action.stageId} (internalActionId=${action.id}, ${action.status}, attempt ${action.attempt})`).join('; ')}. Available VPs: ${vpCatalog.map(vp => `${vp.id} (${vp.role || vp.area || 'VP'})`).join('; ')}. Only add new Actions and optionally add dependencies to attempt=0 ready Actions. This tool validates the complete additive DAG immediately; if validation fails, correct the proposal in the same turn.`,
     parameters: { type: 'object', additionalProperties: false,
       required: ['summary', 'evidence', 'acceptanceChecks', 'proposalId', 'basePlanRevision', 'actions'],
       properties: {
@@ -413,6 +419,13 @@ export function createProposeWorkItemActionsTool({ vps, workItem, actions, colle
     async execute(input, ctx = {}) {
       if (!isRunActive()) throw new Error('Work Center Run is no longer active');
       if (collector.value) throw new Error('A WorkItem plan mutation was already submitted for this Run');
+      applyAdditivePlanProposal({
+        workItem,
+        actions,
+        proposal: input,
+        availableVpIds: vpIds,
+      });
+      if (!isRunActive()) throw new Error('Work Center Run is no longer active');
       collector.value = { kind: 'expand', input: structuredClone(input) };
       ctx.requestEndTurn?.({ kind: 'work_item_actions_proposed', proposalId: input.proposalId });
       return JSON.stringify({ submitted: true, proposalId: input.proposalId, actionCount: input.actions.length });
@@ -981,7 +994,7 @@ export class WorkItemRunner {
       runTools.push(createProposeWorkItemActionsTool({
         vps: this.registry.listVps(), workItem,
         actions: this.store.getWorkItemDetail(workItem.id).actions,
-        collector: mutationCollector, isRunActive,
+        collector: mutationCollector, isRunActive, currentAction: executionAction,
       }));
       runTools.push(createRequestWorkItemReplanTool({ workItem, collector: mutationCollector, isRunActive }));
     }

package/yeaft/work-center/service.js

@@ -60,6 +60,19 @@ function parseBoardCursor(value) {
   }
 }
 
+function coordinatorHumanRequest(detail, action, generation) {
+  if (detail?.status !== 'waiting'
+      || action?.status !== 'waiting'
+      || Number(action.generation) !== Number(generation)) return null;
+  return [...(Array.isArray(detail.messages) ? detail.messages : [])].reverse().find(message => (
+    message?.role === 'assistant'
+    && message.status === 'completed'
+    && message.decision?.kind === 'request_human'
+    && message.recovery?.actionId === action.id
+    && message.recovery?.actionGeneration === action.generation
+  )) || null;
+}
+
 function listBoardItems(store, payload) {
   const limit = Math.min(Math.max(Number(payload.limit) || 100, 1), 200);
   const cursor = parseBoardCursor(payload.cursor);
@@ -294,6 +307,13 @@ export class WorkCenterService {
         this.#emit({ type: 'work_item.cancelled', workItem: detail });
         return detail;
       }
+      case 'resume': {
+        const id = requiredString(payload.id, 'id');
+        const detail = this.controller.resume(id, { revision: payload.revision });
+        this.watcher.abortInvalidWorkItemRuns(id);
+        this.#emit({ type: 'work_item.resumed', workItem: detail });
+        return detail;
+      }
       case 'delete': {
         const id = requiredString(payload.id, 'id');
         const deleted = this.store.deleteWorkItemAtomic(id, Number(payload.revision));
@@ -367,6 +387,49 @@ export class WorkCenterService {
           throw new Error('generation must be a positive integer');
         }
         const workItem = this.#requiredItem(id);
+        const targetAction = this.#requiredAction(workItem, payload.actionId);
+        const humanRequest = coordinatorHumanRequest(workItem, targetAction, generation);
+        if (humanRequest) {
+          let addedAttachments = [];
+          let turn;
+          try {
+            addedAttachments = appendWorkItemAttachments(workItem.attachments, payload.files, {
+              root: this.attachmentRoot,
+              workItemId: id,
+            });
+            turn = this.coordinator.message(id, {
+              text: typeof payload.text === 'string' ? payload.text : '',
+              revision: payload.revision,
+              planRevision: workItem.planRevision,
+              ledgerRevision: workItem.ledgerRevision,
+              coordinatorRevision: workItem.coordinatorRevision,
+              controlRequired: true,
+              recovery: { ...humanRequest.recovery },
+              addedAttachments,
+              attachments: [...(workItem.attachments || []), ...addedAttachments],
+            }, {
+              onUpdate: (type, nextWorkItem) => {
+                this.watcher.abortInvalidWorkItemRuns(id);
+                this.#emit({ type, workItem: nextWorkItem });
+              },
+            });
+          } catch (error) {
+            try {
+              if ((workItem.attachments || []).length === 0 && addedAttachments.length > 0) {
+                removeWorkItemAttachments(this.attachmentRoot, id);
+              } else {
+                removeWorkItemAttachmentFiles(this.attachmentRoot, id, addedAttachments);
+              }
+            } catch {}
+            throw error;
+          }
+          turn.task.catch(() => {});
+          return {
+            accepted: true,
+            routedTo: 'coordinator',
+            turnId: turn.detail.messages?.at(-1)?.turnId || null,
+          };
+        }
         let addedAttachments = [];
         let detail;
         try {

package/yeaft/work-center/store.js

@@ -8,7 +8,7 @@ import { currentActionInputEventIds, runMatchesActionIdentity } from './action-i
 import { canonicalActionInstruction, withoutActionInputContext } from './workflow.js';
 
 const SCHEMA_VERSION = 22;
-const OPEN_ACTION_STATUSES = "'ready','running','waiting'";
+const UNFINISHED_ACTION_STATUSES = "'ready','running','waiting','failed'";
 const MAX_REUSABLE_CONTEXT_ITEMS = 12;
 const MAX_RUN_RESPONSE_CHARS = 65_536;
 
@@ -2207,27 +2207,33 @@ export class WorkItemStore {
       let recovery = options.recovery && typeof options.recovery === 'object'
         ? { ...options.recovery } : null;
       if (recovery) {
-        const failedAction = activeActions.find(action => action.id === recovery.actionId);
+        const recoveryAction = activeActions.find(action => action.id === recovery.actionId);
+        const requiredStatus = options.requireWaitingRecovery === true ? 'waiting' : 'failed';
         if (['done', 'cancelled'].includes(workItem.status)
-            || failedAction?.status !== 'failed'
-            || failedAction.generation !== recovery.actionGeneration
-            || failedAction.stageId !== recovery.stageId) {
-          throw new Error('WorkItem failure changed before Coordinator recovery started');
+            || recoveryAction?.status !== requiredStatus
+            || recoveryAction.generation !== recovery.actionGeneration
+            || recoveryAction.stageId !== recovery.stageId) {
+          throw new Error(options.requireWaitingRecovery === true
+            ? 'WorkItem human input target changed before the Coordinator turn started'
+            : 'WorkItem failure changed before Coordinator recovery started');
+        }
+        if (options.requireWaitingRecovery !== true) {
+          const priorAttempts = Number(this.db.prepare(`SELECT COUNT(*) AS count FROM events
+            WHERE work_item_id = ? AND type = 'coordinator.recovery_started'
+              AND action_id = ? AND action_generation = ?`).get(
+            id,
+            recoveryAction.id,
+            recoveryAction.generation,
+          )?.count) || 0;
+          recovery = { ...recovery, attempt: priorAttempts + 1 };
         }
-        const priorAttempts = Number(this.db.prepare(`SELECT COUNT(*) AS count FROM events
-          WHERE work_item_id = ? AND type = 'coordinator.recovery_started'
-            AND action_id = ? AND action_generation = ?`).get(
-          id,
-          failedAction.id,
-          failedAction.generation,
-        )?.count) || 0;
-        recovery = { ...recovery, attempt: priorAttempts + 1 };
       }
-      if (!recovery && !String(text || '').trim() && projectedAttachments.length === 0) {
+      const automaticRecovery = recovery && options.requireWaitingRecovery !== true;
+      if (!automaticRecovery && !String(text || '').trim() && projectedAttachments.length === 0) {
         throw new Error('WorkItem Coordinator message or attachments are required');
       }
       const turnId = randomUUID();
-      const userMessage = recovery ? null : {
+      const userMessage = automaticRecovery ? null : {
         id: randomUUID(), turnId, role: 'user', text, attachments: projectedAttachments,
         status: 'completed', createdAt: now,
       };
@@ -2250,7 +2256,7 @@ export class WorkItemStore {
         id, workItem.coordinatorRevision, workItem.revision, workItem.planRevision, workItem.ledgerRevision,
       );
       if (Number(changed.changes) !== 1) throw new Error('Coordinator turn lost its revision fence');
-      this.appendEvent(id, recovery ? 'coordinator.recovery_started' : 'coordinator.turn_started', {
+      this.appendEvent(id, automaticRecovery ? 'coordinator.recovery_started' : 'coordinator.turn_started', {
         turnId,
         status: 'thinking',
         coordinatorRevision,
@@ -2313,17 +2319,17 @@ export class WorkItemStore {
         throw new Error('Coordinator replan requires an AI-planned Action graph');
       }
       if (recovery && decision.kind === 'guide_actions') {
-        const failedAction = activeActions.find(action => (
+        const recoveryAction = activeActions.find(action => (
           action.id === recovery.actionId
           && action.generation === recovery.actionGeneration
           && action.stageId === recovery.stageId
-          && action.status === 'failed'
+          && ['failed', 'waiting'].includes(action.status)
         ));
-        if (!failedAction
+        if (!recoveryAction
             || !Array.isArray(decision.guidance)
             || decision.guidance.length !== 1
-            || decision.guidance[0]?.stageId !== failedAction.stageId) {
-          throw new Error('Coordinator recovery guidance must target only the failed Action identity');
+            || decision.guidance[0]?.stageId !== recoveryAction.stageId) {
+          throw new Error('Coordinator recovery guidance must target only the fenced Action identity');
         }
       }
       let nextWorkItem = workItem;
@@ -2637,16 +2643,32 @@ export class WorkItemStore {
   }
 
   #invalidateExecution(workItem, actionStatus, runStatus, reason, now) {
-    const openActions = this.db.prepare(`SELECT * FROM actions WHERE work_item_id = ?
-      AND status IN (${OPEN_ACTION_STATUSES})`).all(workItem.id).map(mapAction);
-    this.#assertNoIntegrationReservation(openActions, now);
-    this.#supersedePendingActionInputs(openActions, reason, now);
-    if (workItem.currentRunId) {
-      this.db.prepare(`UPDATE runs SET status = ?, ended_at = ?, error = ?
-        WHERE id = ? AND status = 'running'`).run(runStatus, now, reason, workItem.currentRunId);
+    const unfinishedActions = this.db.prepare(`SELECT * FROM actions WHERE work_item_id = ?
+      AND status IN (${UNFINISHED_ACTION_STATUSES})`).all(workItem.id).map(mapAction);
+    this.#assertNoIntegrationReservation(unfinishedActions, now);
+    this.#supersedePendingActionInputs(unfinishedActions, reason, now);
+    const actionIds = unfinishedActions.map(action => action.id);
+    if (actionIds.length === 0) return;
+    const placeholders = actionIds.map(() => '?').join(',');
+    this.db.prepare(`UPDATE runs SET status = ?, ended_at = ?, error = ?, accepting_input = 0
+      WHERE work_item_id = ? AND action_id IN (${placeholders}) AND status = 'running'`).run(
+      runStatus,
+      now,
+      reason,
+      workItem.id,
+      ...actionIds,
+    );
+    const changed = this.db.prepare(`UPDATE actions SET status = ?, current_run_id = NULL,
+      lease_epoch = lease_epoch + 1, updated_at = ? WHERE work_item_id = ?
+      AND id IN (${placeholders}) AND status IN (${UNFINISHED_ACTION_STATUSES})`).run(
+      actionStatus,
+      now,
+      workItem.id,
+      ...actionIds,
+    );
+    if (Number(changed.changes) !== actionIds.length) {
+      throw new Error('Work Center execution changed while it was invalidated');
     }
-    this.db.prepare(`UPDATE actions SET status = ?, current_run_id = NULL, updated_at = ?
-      WHERE work_item_id = ? AND status IN (${OPEN_ACTION_STATUSES})`).run(actionStatus, now, workItem.id);
   }
 
   updateWorkItemAtomic(id, patch, makeInitialAction) {
@@ -2726,6 +2748,93 @@ export class WorkItemStore {
     });
   }
 
+  resumeWorkItemAtomic(id, expectedRevision, makeInitialAction) {
+    return withTransaction(this.db, () => {
+      const workItem = this.getWorkItem(id);
+      if (!workItem) return null;
+      if (!Number.isInteger(expectedRevision) || workItem.revision !== expectedRevision) {
+        throw new Error('WorkItem changed before it was resumed; refresh and try again');
+      }
+      if (workItem.status !== 'cancelled') {
+        throw new Error(`WorkItem in ${workItem.status} cannot be resumed`);
+      }
+
+      const now = this.now();
+      const cancelledActions = this.db.prepare(`SELECT * FROM actions WHERE work_item_id = ?
+        AND status = 'cancelled' ORDER BY sequence`).all(id).map(mapAction);
+      this.#assertNoIntegrationReservation(cancelledActions, now);
+      this.#supersedePendingActionInputs(
+        cancelledActions,
+        'WorkItem resume started a new Action generation',
+        now,
+      );
+      const resumedActions = [];
+      for (const action of cancelledActions) {
+        const context = carryCurrentActionInputContext(this.db, action);
+        const candidate = {
+          ...action,
+          context,
+          status: 'ready',
+          attempt: 0,
+          currentRunId: null,
+          resultRunId: null,
+          workspace: null,
+          generation: action.generation + 1,
+        };
+        candidate.instruction = canonicalActionInstruction(workItem, candidate, context);
+        candidate.specHash = actionSpecHash(candidate);
+        const changed = this.db.prepare(`UPDATE actions SET status = 'ready', attempt = 0,
+          current_run_id = NULL, lease_epoch = lease_epoch + 1, generation = generation + 1,
+          context = ?, instruction = ?, spec_hash = ?, identity_history = ?, result_run_id = NULL,
+          workspace = NULL, updated_at = ? WHERE id = ? AND work_item_id = ?
+          AND status = 'cancelled' AND generation = ? AND spec_hash = ?`).run(
+          stringify(context),
+          candidate.instruction,
+          candidate.specHash,
+          stringify(actionIdentityHistory(action, candidate.generation, candidate.specHash)),
+          now,
+          action.id,
+          id,
+          action.generation,
+          action.specHash,
+        );
+        if (Number(changed.changes) !== 1) {
+          throw new Error('WorkItem Action changed before it was resumed');
+        }
+        resumedActions.push(this.getAction(action.id));
+      }
+
+      if (resumedActions.length === 0) {
+        const initialAction = makeInitialAction(workItem);
+        resumedActions.push(this.#insertAction(id, {
+          ...initialAction,
+          contractRevision: workItem.revision,
+        }, this.#nextSequence(id), now));
+      }
+
+      const currentAction = resumedActions
+        .find(action => action.dependsOnStageIds.length === 0) || resumedActions[0];
+      const changedWorkItem = this.db.prepare(`UPDATE work_items SET status = 'ready',
+        current_action_id = ?, current_run_id = NULL, updated_at = ?
+        WHERE id = ? AND status = 'cancelled' AND revision = ?`).run(
+        currentAction.id,
+        now,
+        id,
+        expectedRevision,
+      );
+      if (Number(changedWorkItem.changes) !== 1) {
+        throw new Error('WorkItem changed before it was resumed; refresh and try again');
+      }
+      this.appendEvent(id, 'work_item.resumed', {
+        resumedActionIds: resumedActions.map(action => action.id),
+      }, {
+        actionId: currentAction.id,
+        actionGeneration: currentAction.generation,
+      });
+      return this.getWorkItemDetail(id);
+    });
+  }
+
   startWorkItemAtomic(id, makeInitialAction) {
     return withTransaction(this.db, () => {
       const workItem = this.getWorkItem(id);