@yeaft/webchat-agent 1.0.122 → 1.0.124

package/connection/buffer.js

@@ -9,7 +9,11 @@ export const BUFFERABLE_TYPES = new Set([
   'turn_completed', 'conversation_closed',
   'session_id_update', 'compact_status', 'slash_commands_update',
   'background_task_started', 'background_task_output',
-  'subagent_started', 'subagent_message', 'subagent_completed'
+  'subagent_started', 'subagent_message', 'subagent_completed',
+  // Work Center broadcasts are projections over Agent-local SQLite. Buffering
+  // prevents a terminal transition from disappearing during a short reconnect;
+  // clients still refresh with `list` after reconnect for authoritative state.
+  'work_center_event'
 ]);
 
 function bufferMessage(msg, reason) {

package/connection/message-router.js

@@ -31,6 +31,7 @@ import { discoverLlmModels } from '../llm-model-discovery.js';
 import { fetchModelsDev } from '../yeaft/llm/models-dev.js';
 import { handleYeaftSessionSend, handleYeaftSubAgentPrompt, handleYeaftTaskCancel, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftCreateSession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager, preloadYeaftSkillSlashCommands } from '../yeaft/web-bridge.js';
 import { startYeaftStatusRefresh, forceRefreshYeaftStatus } from '../yeaft/status-cache.js';
+import { handleWorkCenterRequest } from '../yeaft/work-center/bridge.js';
 
 export async function applyLlmConfigUpdate(msg, dependencies = {}) {
   const updateConfig = dependencies.updateLlmConfig || updateLlmConfig;
@@ -638,6 +639,10 @@ export async function handleMessage(msg) {
       await handleYeaftFetchDebugHistory(msg);
       break;
 
+    case 'work_center_request':
+      await handleWorkCenterRequest(msg);
+      break;
+
     // Expert roles definition (for ExpertPanel detail view)
     case 'get_expert_roles': {
       const { getExpertRolesDefinition } = await import('../expert-roles.js');

package/connection/upgrade.js

@@ -73,7 +73,7 @@ export function buildWindowsWorkerCommand(nodePath) {
 
 // Shared cleanup logic for restart/upgrade
 function cleanupAndExit(exitCode) {
-  setTimeout(() => {
+  setTimeout(async () => {
     for (const [, term] of ctx.terminals) {
       if (term.pty) { try { term.pty.kill(); } catch {} }
       if (term.timer) clearTimeout(term.timer);
@@ -84,6 +84,12 @@ function cleanupAndExit(exitCode) {
       if (state.inputStream) state.inputStream.done();
     }
     ctx.conversations.clear();
+    try {
+      const { shutdownWorkCenter } = await import('../yeaft/work-center/bridge.js');
+      await shutdownWorkCenter();
+    } catch (err) {
+      console.warn(`[Agent] Work Center shutdown failed: ${err?.message || err}`);
+    }
     stopAgentHeartbeat();
     if (ctx.ws) {
       ctx.ws.removeAllListeners('close');

package/index.js

@@ -290,7 +290,7 @@ async function ensureYeaftSkills() {
 }
 
 // 优雅退出
-function cleanup() {
+async function cleanup() {
   // 清理所有终端
   for (const [, term] of ctx.terminals) {
     if (term.pty) {
@@ -309,18 +309,22 @@ function cleanup() {
     }
   }
   ctx.conversations.clear();
+  try {
+    const { shutdownWorkCenter } = await import('./yeaft/work-center/bridge.js');
+    await shutdownWorkCenter();
+  } catch {}
   if (ctx.ws) ctx.ws.close();
 }
 
-process.on('SIGINT', () => {
+process.on('SIGINT', async () => {
   console.log('Shutting down...');
-  cleanup();
+  await cleanup();
   process.exit(0);
 });
 
-process.on('SIGTERM', () => {
+process.on('SIGTERM', async () => {
   console.log('Shutting down...');
-  cleanup();
+  await cleanup();
   process.exit(0);
 });
 
@@ -341,5 +345,12 @@ process.on('SIGTERM', () => {
   } catch (err) {
     console.warn(`[Agent] models.dev prime failed (will use config/defaults): ${err?.message || err}`);
   }
+  try {
+    const { bootWorkCenter } = await import('./yeaft/work-center/bridge.js');
+    await bootWorkCenter();
+    console.log('[Agent] Work Center watcher started');
+  } catch (err) {
+    console.warn(`[Agent] Work Center failed to start: ${err?.message || err}`);
+  }
   connect();
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.122",
+  "version": "1.0.124",
   "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/engine.js

@@ -2278,7 +2278,7 @@ export class Engine {
         // OpenAI/Anthropic toolCallId pairing intact.
         let wireMessages = stripMetaForWire([...conversationMessages]);
 
-        if (this.#yeaftDir && (this.#config?.archive?.toolResults !== false)) {
+        if (scenario !== 'work-item' && this.#yeaftDir && (this.#config?.archive?.toolResults !== false)) {
           try {
             const swept = await archiveToolResults({
               root: `${this.#yeaftDir}/memory`,
@@ -2315,7 +2315,7 @@ export class Engine {
         // The estimator (`estimateMessagesTokens`) is approxTokens
         // (char/4 with CJK weighting) — good enough for a guard rail; a
         // real tokenizer would be exact but adds a heavy dep.
-        if (this.#yeaftDir && (this.#config?.archive?.toolResults !== false)) {
+        if (scenario !== 'work-item' && this.#yeaftDir && (this.#config?.archive?.toolResults !== false)) {
           const PREFLIGHT_RATIO = 0.85;
           const threshold = Math.floor(currentContextWindow * PREFLIGHT_RATIO);
           const estimate = estimateMessagesTokens(systemPrompt, wireMessages);

package/yeaft/sub-agent/runner.js

@@ -67,6 +67,7 @@ const RESTRICTED_TOOLS = new Set([
   'ListAgents',
   'RouteForward',
   'AskUser',
+  'CreateWorkItem',
 ]);
 
 /** How long an idle sub-agent may wait for a follow-up before the watchdog reaps it. */

package/yeaft/tools/apply-patch.js

@@ -15,7 +15,19 @@ import { resolve, dirname } from 'path';
  * @param {string} patch
  * @returns {Array<{ file: string, hunks: Array }>}
  */
-function parsePatch(patch) {
+function parsePatchTarget(line) {
+  const raw = line.slice(4).replace(/\r$/, '');
+  const tabIndex = raw.indexOf('\t');
+  let filePath = (tabIndex === -1 ? raw : raw.slice(0, tabIndex)).trim();
+  if (!filePath) throw new Error('Patch target path is empty');
+  if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(filePath)) {
+    throw new Error('Patch target path contains control characters');
+  }
+  if (filePath.startsWith('b/')) filePath = filePath.slice(2);
+  return filePath === '/dev/null' ? null : filePath;
+}
+
+export function parsePatch(patch) {
   const files = [];
   const lines = patch.split('\n');
   let currentFile = null;
@@ -30,10 +42,8 @@ function parsePatch(patch) {
       continue;
     }
     if (line.startsWith('+++ ')) {
-      let filePath = line.slice(4).trim();
-      // Strip a/ or b/ prefix
-      if (filePath.startsWith('b/')) filePath = filePath.slice(2);
-      if (filePath === '/dev/null') continue;
+      const filePath = parsePatchTarget(line);
+      if (!filePath) continue;
 
       currentFile = { file: filePath, hunks: [] };
       files.push(currentFile);

package/yeaft/tools/create-work-item.js

@@ -0,0 +1,79 @@
+import { defineTool } from './types.js';
+
+function cleanCriteria(value) {
+  return Array.isArray(value)
+    ? value.map(item => String(item).trim()).filter(Boolean)
+    : [];
+}
+
+export default defineTool({
+  name: 'CreateWorkItem',
+  description: {
+    en: `Create a persistent Agent-level Work Center item from the current Session.
+
+Use this when work must continue beyond the current turn, needs role handoffs, review, waiting, retry, or durable tracking. This creates the work contract; it does not execute it inline. The current Session is always stamped as the origin and cannot be overridden by model input.`,
+    zh: `从当前 Session 创建一个持久化的 Agent 级工作项。
+
+当工作需要跨 turn 继续、需要角色接力、评审、等待、重试或长期跟踪时使用。该工具只创建工作契约，不在当前 turn 内执行。来源 Session 由运行时强制写入，模型输入不能覆盖。`,
+  },
+  parameters: {
+    type: 'object',
+    properties: {
+      title: {
+        type: 'string',
+        description: { en: 'Short work item title', zh: '简短的工作项标题' },
+      },
+      goal: {
+        type: 'string',
+        description: { en: 'Stable outcome the work item must achieve', zh: '工作项必须达到的稳定目标' },
+      },
+      acceptanceCriteria: {
+        type: 'array',
+        items: { type: 'string' },
+        description: { en: 'Verifiable completion criteria', zh: '可验证的完成条件' },
+      },
+      workDir: {
+        type: 'string',
+        description: { en: 'Optional project directory for execution', zh: '执行时使用的可选项目目录' },
+      },
+      start: {
+        type: 'boolean',
+        description: { en: 'Start triage immediately (default true)', zh: '是否立即开始 triage（默认 true）' },
+      },
+    },
+    required: ['title', 'goal'],
+  },
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx = {}) {
+    const sessionId = typeof ctx.sessionId === 'string' ? ctx.sessionId.trim() : '';
+    if (!sessionId) throw new Error('CreateWorkItem requires an active Session');
+    const title = typeof input?.title === 'string' ? input.title.trim() : '';
+    const goal = typeof input?.goal === 'string' ? input.goal.trim() : '';
+    if (!title || !goal) throw new Error('title and goal are required');
+
+    // Dynamic import avoids tools/index -> create-work-item -> bridge -> runner
+    // -> tools/index becoming a static initialization cycle.
+    const { createWorkItemFromProducer } = await import('../work-center/bridge.js');
+    const detail = await createWorkItemFromProducer({
+      title,
+      goal,
+      acceptanceCriteria: cleanCriteria(input.acceptanceCriteria),
+      workDir: typeof input.workDir === 'string' ? input.workDir.trim() : (ctx.cwd || ''),
+      workflowTemplate: 'software-change',
+      origin: {
+        sessionId,
+        messageId: ctx.inboundEnvelope?.msgId || null,
+        createdBy: ctx.currentVpId || 'assistant',
+      },
+      linkedSessionIds: [sessionId],
+      start: input.start !== false,
+    });
+    return JSON.stringify({
+      workItemId: detail.id,
+      status: detail.status,
+      title: detail.title,
+      message: `Created Work Center item ${detail.id}`,
+    });
+  },
+});

package/yeaft/tools/index.js

@@ -55,6 +55,7 @@ import routeForward from './route-forward.js';
 // --- P1 Progress tracking ---
 import todoWrite from './todo-write.js';
 import startPlan from './start-plan.js';
+import createWorkItem from './create-work-item.js';
 
 // H2.f.4: user-facing thread tools (spawnThread/switchThread/listThreads/...)
 // were deleted. PR #797 reintroduces runtime-owned VP thread routing below the
@@ -119,6 +120,7 @@ export const allTools = [
   // P1 Progress tracking
   todoWrite,
   startPlan,
+  createWorkItem,
 
   // P2 Auxiliary
   jsRepl,

package/yeaft/web-bridge.js

@@ -3943,7 +3943,7 @@ export function buildVpQueryOpts({ vpId, sessionCoordinator, sessionId, envelope
  * @param {{ workDir?: string, sessionId?: string|null, sessionMeta?: object, perfTraceId?: string|null, messageType?: string }} [opts]
  * @returns {Promise<import('./session.js').Session>}
  */
-async function ensureSessionLoaded(opts = {}) {
+export async function ensureSessionLoaded(opts = {}) {
   if (session) return session;
   if (sessionLoadPromise) return sessionLoadPromise;
 

package/yeaft/work-center/bridge.js

@@ -0,0 +1,142 @@
+import ctx from '../../context.js';
+import { sendToServer } from '../../connection/buffer.js';
+import { ensureSessionLoaded } from '../web-bridge.js';
+import { defaultRegistry } from '../vp/registry.js';
+import { scanVpLibrary } from '../vp/vp-store.js';
+import { WorkCenterService } from './service.js';
+import { WorkItemRunner } from './runner.js';
+import { projectWorkCenterEvent } from './projection.js';
+import { join } from 'node:path';
+
+let service = null;
+let initPromise = null;
+let shuttingDown = false;
+let shutdownPromise = null;
+let serviceFactory = null;
+
+function send(msg) {
+  sendToServer(msg);
+}
+
+async function getRuntime() {
+  return ensureSessionLoaded();
+}
+
+async function createDefaultService() {
+  const yeaftDir = ctx.CONFIG?.yeaftDir;
+  if (!yeaftDir) throw new Error('Work Center requires a configured Yeaft directory');
+  const runner = new WorkItemRunner({
+    runtimeProvider: async () => {
+      const runtime = await getRuntime();
+      if (defaultRegistry.vpCount() === 0) {
+        for (const vp of scanVpLibrary({ dir: join(runtime.yeaftDir, 'virtual-persons') })) defaultRegistry.setVp(vp);
+      }
+      return {
+        ...runtime,
+        defaultWorkDir: ctx.CONFIG?.workDir || process.cwd(),
+      };
+    },
+    registry: defaultRegistry,
+    store: null,
+  });
+  const created = new WorkCenterService({
+    yeaftDir,
+    runner,
+    onEvent(event) {
+      send({ type: 'work_center_event', event: projectWorkCenterEvent(event) });
+    },
+  });
+  runner.store = created.store;
+  return created;
+}
+
+async function ensureWorkCenter() {
+  if (service) return service;
+  if (shuttingDown) throw new Error('Work Center is shutting down');
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    const created = serviceFactory ? await serviceFactory() : await createDefaultService();
+    if (shuttingDown) {
+      await created.shutdown();
+      throw new Error('Work Center shut down during initialization');
+    }
+    created.start();
+    service = created;
+    return created;
+  })();
+  try {
+    return await initPromise;
+  } finally {
+    initPromise = null;
+  }
+}
+
+export async function bootWorkCenter() {
+  return ensureWorkCenter();
+}
+
+export async function createWorkItemFromProducer(payload) {
+  const workCenter = await ensureWorkCenter();
+  return workCenter.handle('create', payload);
+}
+
+export async function handleWorkCenterRequest(msg) {
+  const requestId = typeof msg.requestId === 'string' ? msg.requestId : null;
+  const op = typeof msg.op === 'string' ? msg.op : '';
+  try {
+    const workCenter = await ensureWorkCenter();
+    const data = await workCenter.handle(op, msg.payload || {});
+    send({
+      type: 'work_center_response',
+      requestId,
+      op,
+      ok: true,
+      data,
+      _requestUserId: msg._requestUserId || null,
+    });
+  } catch (err) {
+    send({
+      type: 'work_center_response',
+      requestId,
+      op,
+      ok: false,
+      error: err?.message || String(err),
+      _requestUserId: msg._requestUserId || null,
+    });
+  }
+}
+
+export async function shutdownWorkCenter() {
+  if (shutdownPromise) return shutdownPromise;
+  shuttingDown = true;
+  const pendingInit = initPromise;
+  shutdownPromise = (async () => {
+    let current = service;
+    if (!current && pendingInit) {
+      try { current = await pendingInit; } catch {}
+    }
+    service = null;
+    if (current) await current.shutdown();
+  })();
+  try {
+    await shutdownPromise;
+  } finally {
+    initPromise = null;
+    shutdownPromise = null;
+  }
+}
+
+export function __testSetWorkCenterService(next) {
+  service = next || null;
+  initPromise = null;
+  shuttingDown = false;
+  shutdownPromise = null;
+}
+
+export function __testSetWorkCenterFactory(factory) {
+  serviceFactory = factory || null;
+  service = null;
+  initPromise = null;
+  shuttingDown = false;
+  shutdownPromise = null;
+}

package/yeaft/work-center/controller.js

@@ -0,0 +1,213 @@
+import { actionInstruction, getNextStep, initialActionFor, RUN_OUTCOMES } from './workflow.js';
+import { normalizeEvidence } from './evidence.js';
+
+function normalizeCriteria(value) {
+  if (!Array.isArray(value)) return null;
+  return value.map(item => String(item).trim()).filter(Boolean);
+}
+
+function normalizeContractPatch(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const patch = {};
+  if (typeof value.goal === 'string' && value.goal.trim()) patch.goal = value.goal.trim();
+  if (Object.prototype.hasOwnProperty.call(value, 'acceptanceCriteria')) {
+    const criteria = normalizeCriteria(value.acceptanceCriteria);
+    if (!criteria) throw new Error('contractPatch.acceptanceCriteria must be an array');
+    patch.acceptanceCriteria = criteria;
+  }
+  return Object.keys(patch).length > 0 ? patch : null;
+}
+
+function normalizeTerminalResult(result, action) {
+  if (!result || !RUN_OUTCOMES.includes(result.outcome)) {
+    throw new Error(`Invalid Work Center outcome: ${result?.outcome || '(missing)'}`);
+  }
+  const normalized = {
+    outcome: result.outcome,
+    summary: String(result.summary || ''),
+    evidence: normalizeEvidence(result.evidence),
+    waitingReason: result.waitingReason ? String(result.waitingReason) : null,
+    error: result.error ? String(result.error) : null,
+    reviewDecision: ['approved', 'changes_requested'].includes(result.reviewDecision)
+      ? result.reviewDecision
+      : null,
+    contractPatch: normalizeContractPatch(result.contractPatch),
+  };
+  if (normalized.outcome === 'waiting' && !normalized.waitingReason) {
+    throw new Error('waiting outcome requires waitingReason');
+  }
+  if (action.type !== 'triage' && normalized.contractPatch) {
+    normalized.outcome = 'failed';
+    normalized.error = 'Only triage may submit a WorkItem contractPatch';
+    normalized.contractPatch = null;
+  }
+  if (action.type === 'review' && normalized.outcome === 'completed' && !normalized.reviewDecision) {
+    normalized.outcome = 'failed';
+    normalized.error = 'Completed review requires approved or changes_requested';
+  }
+  return normalized;
+}
+
+function contextEntry(action, result) {
+  return {
+    type: action.type,
+    role: action.requiredRole,
+    summary: result.summary || '',
+    evidence: result.evidence || [],
+    reviewDecision: result.reviewDecision || null,
+  };
+}
+
+export class WorkflowController {
+  constructor(store) {
+    this.store = store;
+  }
+
+  create(input) {
+    const draft = {
+      ...input,
+      workflowTemplate: input.workflowTemplate || 'software-change',
+      acceptanceCriteria: Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [],
+    };
+    const firstAction = input.start !== false ? initialActionFor(draft) : null;
+    return this.store.createWorkItem(draft, firstAction);
+  }
+
+  start(id) {
+    const detail = this.store.startWorkItemAtomic(id, initialActionFor);
+    if (!detail) throw new Error(`WorkItem not found: ${id}`);
+    return detail;
+  }
+
+  update(id, patch) {
+    const updated = this.store.updateWorkItemAtomic(id, patch, initialActionFor);
+    if (!updated) throw new Error(`WorkItem not found: ${id}`);
+    return this.store.getWorkItemDetail(id);
+  }
+
+  cancel(id) {
+    const workItem = this.store.cancelWorkItemAtomic(id);
+    if (!workItem) throw new Error(`WorkItem not found: ${id}`);
+    return this.store.getWorkItemDetail(id);
+  }
+
+  retry(id, input = {}) {
+    const answer = typeof input.answer === 'string' ? input.answer.trim().slice(0, 8_000) : '';
+    const detail = this.store.retryWorkItemAtomic(id, (workItem, previous, previousRun) => {
+      if (workItem.status === 'waiting' && !answer) {
+        throw new Error('answer is required to resume a waiting WorkItem');
+      }
+      const step = previous
+        ? { type: previous.type, requiredRole: previous.requiredRole }
+        : initialActionFor(workItem);
+      const context = Array.isArray(previous?.context) ? [...previous.context] : [];
+      if (previousRun) {
+        context.push({
+          type: previous.type,
+          role: previous.requiredRole,
+          summary: previousRun.summary || '',
+          evidence: normalizeEvidence(previousRun.evidence),
+          waitingReason: previousRun.waitingReason || null,
+          answer: answer || null,
+        });
+      }
+      return {
+        ...step,
+        context,
+        instruction: actionInstruction(step, workItem, context),
+        maxAttempts: previous?.maxAttempts || 2,
+      };
+    });
+    if (!detail) throw new Error(`WorkItem not found: ${id}`);
+    return detail;
+  }
+
+  submit(runId, ownerBootId, leaseEpoch, rawResult) {
+    const activeRun = this.store.getRun(runId);
+    const activeAction = activeRun ? this.store.getAction(activeRun.actionId) : null;
+    if (!activeRun || !activeAction) throw new Error('Run is stale, cancelled, or already finished');
+    const result = normalizeTerminalResult(rawResult, activeAction);
+    const detail = this.store.finalizeRun(
+      runId,
+      ownerBootId,
+      leaseEpoch,
+      result,
+      ({ action, workItem }) => {
+        if (result.outcome === 'waiting') {
+          return {
+            actionStatus: 'completed',
+            workItemStatus: 'waiting',
+            keepCurrentAction: true,
+            eventType: 'action.waiting',
+            eventData: { reason: result.waitingReason },
+          };
+        }
+
+        if (result.outcome === 'retryable') {
+          const retryable = action.attempt < action.maxAttempts;
+          return {
+            actionStatus: retryable ? 'ready' : 'failed',
+            workItemStatus: retryable ? 'ready' : 'needs_attention',
+            keepCurrentAction: true,
+            eventType: retryable ? 'action.retry_scheduled' : 'action.retry_exhausted',
+            eventData: {
+              attempt: action.attempt,
+              maxAttempts: action.maxAttempts,
+              error: result.error,
+            },
+          };
+        }
+
+        if (result.outcome === 'failed') {
+          return {
+            actionStatus: 'failed',
+            workItemStatus: 'needs_attention',
+            keepCurrentAction: true,
+            eventType: 'action.failed',
+            eventData: { error: result.error },
+          };
+        }
+
+        const contractPatch = action.type === 'triage' ? result.contractPatch : null;
+        const effectiveWorkItem = contractPatch
+          ? {
+              ...workItem,
+              goal: contractPatch.goal ?? workItem.goal,
+              acceptanceCriteria: contractPatch.acceptanceCriteria ?? workItem.acceptanceCriteria,
+              revision: workItem.revision + 1,
+            }
+          : workItem;
+        const nextStep = getNextStep(workItem.workflowTemplate, action.type, result);
+        if (!nextStep) {
+          return {
+            actionStatus: 'completed',
+            workItemStatus: 'done',
+            contractPatch,
+            eventType: 'work_item.completed',
+            eventData: { summary: result.summary },
+          };
+        }
+
+        const context = [...(action.context || []), contextEntry(action, result)];
+        return {
+          actionStatus: 'completed',
+          workItemStatus: 'ready',
+          contractPatch,
+          nextAction: {
+            ...nextStep,
+            context,
+            instruction: actionInstruction(nextStep, effectiveWorkItem, context),
+            maxAttempts: 2,
+          },
+          eventType: 'action.completed',
+          eventData: {
+            nextActionType: nextStep.type,
+            reviewDecision: result.reviewDecision,
+          },
+        };
+      },
+    );
+    if (!detail) throw new Error('Run is stale, cancelled, expired, or already finished');
+    return detail;
+  }
+}