@yeaft/webchat-agent 1.0.296 → 1.0.299

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.296",
+  "version": "1.0.299",
   "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

@@ -3595,6 +3595,7 @@ export class Engine {
         let displayImages = [];
         let isError = false;
         let toolErrorOutput = null;
+        let fatalToolError = null;
         currentToolCallForAsyncTask = {
           id: tc.id,
           name: tc.name,
@@ -3668,6 +3669,7 @@ export class Engine {
             output = `Error: ${err.message}`;
             isError = true;
             yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, threadId: this.currentThreadId };
+            if (err?.fatalToolTimeout === true) fatalToolError = err;
           }
         }
 
@@ -3756,6 +3758,7 @@ export class Engine {
           isError,
         }));
         queryToolCount += 1;
+        if (fatalToolError) throw fatalToolError;
       }
 
       // PR-L: flush any duplicate-call reminders queued during the batch.

package/yeaft/sessions/session-crud.js

@@ -541,7 +541,7 @@ export function renameSession(yeaftDir, sessionId, newName) {
   if (!name) throw new SessionCrudError('invalid_name', sessionId);
   const handle = requireSession(yeaftDir, sessionId);
   const meta = handle.getMeta();
-  handle.saveMeta({ ...meta, name });
+  handle.saveMeta({ ...meta, name, metadataUpdatedAt: new Date().toISOString() });
   const next = handle.getMeta();
   handle.close();
   return next;
@@ -561,7 +561,7 @@ export function updateSessionAnnouncement(yeaftDir, sessionId, text) {
   const announcement = text.trim();
   const handle = requireSession(yeaftDir, sessionId);
   const meta = handle.getMeta();
-  handle.saveMeta({ ...meta, announcement });
+  handle.saveMeta({ ...meta, announcement, metadataUpdatedAt: new Date().toISOString() });
   const next = handle.getMeta();
   handle.close();
   return next;
@@ -577,7 +577,10 @@ export function updateSessionAnnouncement(yeaftDir, sessionId, text) {
 export function updateSessionConfig(yeaftDir, sessionId, partial) {
   const handle = requireSession(yeaftDir, sessionId);
   try {
-    return saveSessionConfig(yeaftDir, sessionId, partial || {});
+    const saved = saveSessionConfig(yeaftDir, sessionId, partial || {});
+    const meta = handle.getMeta();
+    handle.saveMeta({ ...meta, metadataUpdatedAt: new Date().toISOString() });
+    return saved;
   } finally {
     handle.close();
   }
@@ -708,7 +711,7 @@ export function addMember(yeaftDir, sessionId, vpId) {
   try {
     const meta = handle.getMeta();
     const next = rosterAdd(meta, vpId);
-    handle.saveMeta(next);
+    handle.saveMeta({ ...next, metadataUpdatedAt: new Date().toISOString() });
     return handle.getMeta();
   } finally {
     handle.close();
@@ -728,7 +731,7 @@ export function removeMember(yeaftDir, sessionId, vpId) {
       return meta;
     }
     const next = rosterRemove(meta, vpId);
-    handle.saveMeta(next);
+    handle.saveMeta({ ...next, metadataUpdatedAt: new Date().toISOString() });
     return handle.getMeta();
   } finally {
     handle.close();
@@ -741,7 +744,7 @@ export function setSessionDefaultVp(yeaftDir, sessionId, vpId) {
   try {
     const meta = handle.getMeta();
     const next = setDefaultVp(meta, vpId);
-    handle.saveMeta(next);
+    handle.saveMeta({ ...next, metadataUpdatedAt: new Date().toISOString() });
     return handle.getMeta();
   } finally {
     handle.close();

package/yeaft/sessions/session-store.js

@@ -145,6 +145,7 @@ export function createSession(sessionsRoot, spec) {
     workDir: typeof spec.workDir === 'string' ? spec.workDir.trim() : '',
     workspaceKey: typeof spec.workspaceKey === 'string' ? spec.workspaceKey.trim() : '',
     createdAt: spec.createdAt || new Date().toISOString(),
+    metadataUpdatedAt: spec.metadataUpdatedAt || spec.createdAt || new Date().toISOString(),
   };
   h.saveMeta(meta);
   return h;

package/yeaft/tools/file-edit.js

@@ -75,16 +75,16 @@ Guidelines:
   isDestructive: () => false,
   async execute(input, ctx) {
     const { file_path, old_string, new_string, replace_all = false } = input;
-    if (!file_path) return JSON.stringify({ error: 'file_path is required' });
-    if (old_string === undefined) return JSON.stringify({ error: 'old_string is required' });
-    if (new_string === undefined) return JSON.stringify({ error: 'new_string is required' });
-    if (old_string === new_string) return JSON.stringify({ error: 'old_string and new_string are identical' });
+    if (!file_path) return JSON.stringify({ errorEffect: 'none', error: 'file_path is required' });
+    if (old_string === undefined) return JSON.stringify({ errorEffect: 'none', error: 'old_string is required' });
+    if (new_string === undefined) return JSON.stringify({ errorEffect: 'none', error: 'new_string is required' });
+    if (old_string === new_string) return JSON.stringify({ errorEffect: 'none', error: 'old_string and new_string are identical' });
 
     const cwd = ctx?.cwd || process.cwd();
     const absPath = resolve(cwd, file_path);
 
     if (!existsSync(absPath)) {
-      return JSON.stringify({ error: `File not found: ${absPath}` });
+      return JSON.stringify({ errorEffect: 'none', error: `File not found: ${absPath}` });
     }
 
     try {
@@ -106,6 +106,7 @@ Guidelines:
           ? old_string.slice(0, 100) + '...'
           : old_string;
         return JSON.stringify({
+          errorEffect: 'none',
           error: `old_string not found in file`,
           hint: `The exact text "${preview}" was not found in ${absPath}. Check whitespace and indentation.`,
         });
@@ -113,6 +114,7 @@ Guidelines:
 
       if (count > 1 && !replace_all) {
         return JSON.stringify({
+          errorEffect: 'none',
           error: `old_string found ${count} times — not unique. Use replace_all: true to replace all occurrences, or provide more context to make it unique.`,
           occurrences: count,
         });
@@ -137,7 +139,7 @@ Guidelines:
         message: `Replaced ${replace_all ? count : 1} occurrence(s) in ${absPath}`,
       });
     } catch (err) {
-      return JSON.stringify({ error: `Failed to edit file: ${err.message}` });
+      return JSON.stringify({ errorEffect: 'unknown', error: `Failed to edit file: ${err.message}` });
     }
   },
 });

package/yeaft/tools/file-write.js

@@ -56,9 +56,9 @@ Guidelines:
   isDestructive: () => false,
   async execute(input, ctx) {
     const { file_path, content } = input;
-    if (!file_path) return JSON.stringify({ error: 'file_path is required' });
+    if (!file_path) return JSON.stringify({ errorEffect: 'none', error: 'file_path is required' });
     if (content === undefined || content === null) {
-      return JSON.stringify({ error: 'content is required' });
+      return JSON.stringify({ errorEffect: 'none', error: 'content is required' });
     }
 
     const cwd = ctx?.cwd || process.cwd();

package/yeaft/tools/registry.js

@@ -194,23 +194,31 @@ export function normalizeToolOutput(output) {
   return text;
 }
 
-export function isToolErrorOutput(output) {
+function parseToolErrorOutput(output) {
   const text = normalizeToolOutput(output).trim();
-  if (!text.startsWith('{')) return false;
+  if (!text.startsWith('{')) return null;
   try {
     const parsed = JSON.parse(text);
-    return Boolean(
-      parsed
+    return parsed
       && typeof parsed === 'object'
       && !Array.isArray(parsed)
       && typeof parsed.error === 'string'
-      && parsed.error.trim(),
-    );
+      && parsed.error.trim()
+      ? parsed
+      : null;
   } catch {
-    return false;
+    return null;
   }
 }
 
+export function isToolErrorOutput(output) {
+  return parseToolErrorOutput(output) !== null;
+}
+
+export function toolErrorEffect(output) {
+  return parseToolErrorOutput(output)?.errorEffect === 'none' ? 'none' : 'unknown';
+}
+
 function truncateUtf8(text, maxBytes) {
   if (maxBytes <= 0) return '';
   const buffer = Buffer.from(String(text), 'utf8');
@@ -435,9 +443,19 @@ export class ToolRegistry {
     const rawTimeout = Number.isFinite(tool.timeoutMs) ? tool.timeoutMs : DEFAULT_TOOL_TIMEOUT_MS;
     const useTimeout = rawTimeout > 0;
 
-    const output = useTimeout
-      ? await runWithTimeout(tool.execute(input, ctx), rawTimeout, name)
-      : await tool.execute(input, ctx);
+    let output;
+    try {
+      output = useTimeout
+        ? await runWithTimeout(tool.execute(input, ctx), rawTimeout, name)
+        : await tool.execute(input, ctx);
+    } catch (error) {
+      if (error instanceof ToolExecutionTimeoutError
+          && tool.sideEffectScope !== 'run'
+          && tool.isReadOnly?.(input) !== true) {
+        error.fatalToolTimeout = true;
+      }
+      throw error;
+    }
 
     return normalizeToolOutput(output);
   }

package/yeaft/tools/types.js

@@ -63,6 +63,7 @@
  * @property {(input?: object) => boolean} [isReadOnly] — read-only operation?
  * @property {(input?: object) => boolean} [isDestructive] — destructive operation?
  * @property {'json-error-envelope' | null} [errorOutput] — explicit returned-output error contract; null means only thrown errors fail
+ * @property {'external' | 'run'} [sideEffectScope] — whether mutations escape the current Run collector
  */
 
 /**
@@ -77,6 +78,7 @@
  *   isReadOnly?: (input?: object) => boolean,
  *   isDestructive?: (input?: object) => boolean,
  *   errorOutput?: 'json-error-envelope' | null,
+ *   sideEffectScope?: 'external' | 'run',
  *   timeoutMs?: number,
  * }} def
  * @returns {ToolDef}
@@ -91,6 +93,7 @@ export function defineTool({
   isReadOnly = () => false,
   isDestructive = () => false,
   errorOutput = 'json-error-envelope',
+  sideEffectScope = 'external',
   timeoutMs,
 }) {
   if (!name) throw new Error('Tool must have a name');
@@ -105,6 +108,7 @@ export function defineTool({
     isReadOnly,
     isDestructive,
     errorOutput,
+    sideEffectScope,
   };
   // Legacy tool-name aliases. Registered as extra lookup keys so old
   // jsonl tool_calls (e.g. `SendMessage` → `PromptAgent`) keep resolving,

package/yeaft/web-bridge.js

@@ -1098,6 +1098,10 @@ const ESCALATE_AFTER_ABORT_MS = 15_000;
 /** Virtual conversationId for the Yeaft session */
 let yeaftConversationId = null;
 
+function createYeaftConversationId() {
+  return `yeaft-${randomUUID()}`;
+}
+
 /** Last agent-level Yeaft slash command payload. Replayed after the web side
  *  creates/replaces the virtual Yeaft conversation id so `/` autocomplete never
  *  falls back to built-ins while full Session metadata is still loading. */
@@ -1316,7 +1320,7 @@ function loadVisibleGroupHistoryPage(store, sessionId, limit, beforeSeq = null)
 
 function ensureYeaftConversationId() {
   if (!yeaftConversationId) {
-    yeaftConversationId = `yeaft-${Date.now()}`;
+    yeaftConversationId = createYeaftConversationId();
     replayCachedSkillSlashCommandsToYeaftConversation();
   }
   return yeaftConversationId;
@@ -3110,6 +3114,7 @@ function sendSessionRosterChanged(session) {
     roster: session.roster,
     defaultVpId: session.defaultVpId,
     workDir: session.workDir || '',
+    metadataUpdatedAt: session.metadataUpdatedAt || session.createdAt || null,
   };
   sendSessionEvent({ type: 'session_roster_changed', ...payload });
 }
@@ -7029,7 +7034,7 @@ export async function resetYeaftSession() {
     claimRuntimeOwnership(session);
     installYeaftRuntimeBridge(session);
 
-    yeaftConversationId = `yeaft-${Date.now()}`;
+    yeaftConversationId = createYeaftConversationId();
     scheduleBaseRuntimeLoad();
     hydrateYeaftStatusFromSession(session, { reason: 'reset', emitEvent: true });
     broadcastSkillSlashCommands(session);
@@ -7346,6 +7351,9 @@ export const __testHooks = {
   ensureYeaftConversationIdForTest() {
     return ensureYeaftConversationId();
   },
+  setYeaftConversationIdForTest(value) {
+    yeaftConversationId = value || null;
+  },
   preloadYeaftSkillSlashCommandsForTest() {
     return broadcastSkillSlashCommands(session);
   },

package/yeaft/work-center/coordinator.js

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { resolveMaxOutputTokens } from '../models.js';
 import {
   LLMAuthError,
@@ -531,6 +531,8 @@ export class WorkItemCoordinator {
     this.runtimeProvider = options.runtimeProvider;
     this.policyProvider = typeof options.policyProvider === 'function' ? options.policyProvider : async () => ({});
     this.registry = options.registry;
+    this.ownerBootId = options.ownerBootId || randomUUID();
+    this.claimLeaseMs = Math.max(5_000, Number(options.claimLeaseMs) || 60_000);
     this.attachmentRoot = options.attachmentRoot || null;
     this.languageProvider = typeof options.languageProvider === 'function'
       ? options.languageProvider
@@ -550,7 +552,7 @@ export class WorkItemCoordinator {
       throw new Error('Work Center Coordinator message or attachments are required');
     }
     const promptText = text || `The user added ${addedAttachments.length} attachment(s) for this WorkItem.`;
-    const started = this.store.beginCoordinatorTurn(id, text, {
+    let started = this.store.beginCoordinatorTurn(id, text, {
       revision: Number(input.revision),
       planRevision: Number(input.planRevision),
       ledgerRevision: Number(input.ledgerRevision),
@@ -564,6 +566,9 @@ export class WorkItemCoordinator {
     if (started.duplicate) {
       return { detail: started.detail, task: Promise.resolve(started.detail), duplicate: true };
     }
+    const claimed = this.store.claimStartedCoordinatorTurn(started, this.ownerBootId, this.claimLeaseMs);
+    if (!claimed) return { detail: started.detail, task: Promise.resolve(started.detail), duplicate: true };
+    started = claimed;
     options.onUpdate?.('coordinator.turn_started', started.detail);
     return this.#scheduleTurn(started, {
       text: promptText,
@@ -611,11 +616,13 @@ export class WorkItemCoordinator {
       },
     });
     if (!started) return null;
-    options.onUpdate?.('coordinator.recovery_started', started.detail);
+    const claimed = this.store.claimStartedCoordinatorTurn(started, this.ownerBootId, this.claimLeaseMs);
+    if (!claimed) return null;
+    options.onUpdate?.('coordinator.recovery_started', claimed.detail);
     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(claimed, { text, recovery: true, options });
   }
 
   #scheduleTurn(started, {
@@ -623,11 +630,19 @@ export class WorkItemCoordinator {
   }) {
     const abortController = new AbortController();
     this.activeTurns.set(started.turnId, abortController);
+    const claim = started.fence?.claim;
+    const renewalTimer = claim ? setInterval(() => {
+      if (!this.store.renewCoordinatorMailbox(
+        claim.mailboxId, claim.ownerBootId, claim.claimEpoch, this.claimLeaseMs,
+      )) abortController.abort('work_center_coordinator_claim_lost');
+    }, Math.max(1_000, Math.floor(this.claimLeaseMs / 3))) : null;
+    renewalTimer?.unref?.();
     const task = new Promise(resolve => setTimeout(resolve, 0))
       .then(() => this.#executeTurn(started, {
         text, recovery, addedAttachments, options, abortController,
       }))
       .finally(() => {
+        if (renewalTimer) clearInterval(renewalTimer);
         this.activeTurns.delete(started.turnId);
         this.activeTasks.delete(started.turnId);
       });
@@ -638,6 +653,7 @@ export class WorkItemCoordinator {
   async #executeTurn(started, {
     text, recovery, addedAttachments, options, abortController,
   }) {
+    let providerTurn = null;
     try {
       let normalized = null;
       let mutation = null;
@@ -698,6 +714,7 @@ export class WorkItemCoordinator {
           const correction = lastError
             ? `\n\nYour previous decision was rejected by the deterministic validator:\n${String(lastError.message || lastError).slice(0, 2_000)}\nReturn a corrected complete JSON decision.`
             : '';
+          providerTurn = null;
           try {
             let result;
             try {
@@ -717,9 +734,11 @@ export class WorkItemCoordinator {
                 effortSource: resolved.source,
                 effortContext: { scenario: 'work-center-coordinator' },
               };
-              const providerTurn = this.store.prepareCoordinatorProviderTurn(
-                started.detail.id, started.turnId, attemptCount, requestBody,
+              const claim = started.fence.claim;
+              providerTurn = this.store.prepareCoordinatorProviderTurn(
+                started.detail.id, started.turnId, attemptCount, requestBody, claim,
               );
+              if (!providerTurn) return started.detail;
               if (providerTurn.status === 'unknown') {
                 throw new Error('Coordinator provider dispatch outcome is unknown and requires review');
               }
@@ -731,15 +750,17 @@ export class WorkItemCoordinator {
                   ...requestBody,
                   signal: abortController.signal,
                   onRequestStart: () => {
-                    if (!this.store.dispatchCoordinatorProviderTurn(providerTurn.id)) {
+                    if (!this.store.dispatchCoordinatorProviderTurn(providerTurn.id, claim)) {
+                      abortController.abort('work_center_coordinator_dispatch_fence_lost');
                       throw new Error('Coordinator provider turn lost its dispatch fence');
                     }
                   },
                 }).then(response => {
                   const persisted = this.store.respondCoordinatorProviderTurn(
-                    providerTurn.id, providerTurn.requestHash, response,
+                    providerTurn.id, providerTurn.requestHash, response, claim,
                   );
                   if (!persisted) throw new Error('Coordinator provider response lost its CAS fence');
+                  providerTurn = persisted;
                   return response;
                 }),
                 new Promise((_, reject) => {
@@ -778,6 +799,9 @@ export class WorkItemCoordinator {
             break;
           } catch (error) {
             normalized = null;
+            if (providerTurn?.status === 'responded') {
+              this.store.rejectCoordinatorProviderTurn(providerTurn.id, error, started.fence.claim);
+            }
             if (abortController.signal.aborted || this.shuttingDown || error?.coordinatorClassified) {
               throw error;
             }
@@ -824,16 +848,19 @@ export class WorkItemCoordinator {
         mutation,
         attemptCount,
       }, started.fence);
-      if (!detail) throw new Error('Work Center Coordinator turn is stale or already completed');
+      if (!detail) return this.store.getWorkItemDetail(started.detail.id);
       options.onUpdate?.(recovery ? 'coordinator.recovery_completed' : 'coordinator.turn_completed', detail);
       return detail;
     } catch (error) {
+      if (providerTurn?.status === 'responded') {
+        this.store.rejectCoordinatorProviderTurn(providerTurn.id, error, started.fence.claim);
+      }
       const detail = this.store.failCoordinatorTurn(started.turnId, error, started.fence);
       if (detail) {
         options.onUpdate?.('coordinator.turn_failed', detail);
         return detail;
       }
-      throw error;
+      return this.store.getWorkItemDetail(started.detail.id);
     }
   }
 

package/yeaft/work-center/durable-model.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 
-export const WORK_CENTER_SCHEMA_VERSION = 33;
+export const WORK_CENTER_SCHEMA_VERSION = 35;
 
 const MIGRATIONS = [
   ['23-conversation-stream', migrateConversationStream],
@@ -14,6 +14,8 @@ const MIGRATIONS = [
   ['31-reliability-guards', migrateReliabilityGuards],
   ['32-engine-turn-status-contract', migrateEngineTurnStatusContract],
   ['33-coordinator-provider-turns', migrateCoordinatorProviderTurns],
+  ['34-engine-turn-status-repair', repairEngineTurnStatusContract],
+  ['35-coordinator-provider-claims', migrateCoordinatorProviderClaims],
 ];
 
 const MIGRATION_ALIASES = new Map([
@@ -295,9 +297,14 @@ function migrateRuntimeIndexes(db) {
   `);
 }
 
-function migrateEngineTurnStatusContract(db, now) {
+const ENGINE_TURN_STATUS_CHECK = /status\s+TEXT\s+NOT\s+NULL\s+CHECK\s*\(\s*status\s+IN\s*\(\s*'prepared'\s*,\s*'dispatching'\s*,\s*'responded'\s*,\s*'unknown'\s*,\s*'cancelled'\s*,\s*'legacy_imported'\s*\)\s*\)/i;
+
+function hasEngineTurnStatusContract(db) {
   const sql = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'engine_turns'`).get()?.sql || '';
-  if (/dispatching/.test(sql) && /responded/.test(sql) && /legacy_imported/.test(sql)) return;
+  return ENGINE_TURN_STATUS_CHECK.test(sql);
+}
+
+function rebuildEngineTurnStatusContract(db, now) {
   db.exec('PRAGMA defer_foreign_keys = ON');
   db.exec(`
     CREATE TABLE engine_turns_new (
@@ -389,6 +396,40 @@ function migrateEngineTurnStatusContract(db, now) {
   if (foreignKeyViolations.length > 0) throw new Error('EngineTurn status migration violated foreign keys');
 }
 
+function migrateEngineTurnStatusContract(db, now) {
+  if (hasEngineTurnStatusContract(db)) return;
+  rebuildEngineTurnStatusContract(db, now);
+}
+
+function repairEngineTurnStatusContract(db, now) {
+  if (!hasEngineTurnStatusContract(db)) rebuildEngineTurnStatusContract(db, now);
+  if (!hasEngineTurnStatusContract(db)) {
+    throw new Error('EngineTurn status repair did not install the required status contract');
+  }
+  const foreignKeys = db.prepare('PRAGMA foreign_key_list(engine_turns)').all();
+  const referencedTables = foreignKeys.map(row => row.table).sort();
+  if (foreignKeys.length !== 3
+      || JSON.stringify(referencedTables) !== JSON.stringify(['actions', 'runs', 'work_items'])) {
+    throw new Error('EngineTurn status repair did not preserve required foreign keys');
+  }
+  const indexes = db.prepare('PRAGMA index_list(engine_turns)').all();
+  const hasIndex = columns => indexes.some(index => {
+    const actual = db.prepare(`PRAGMA index_info(${JSON.stringify(index.name)})`).all()
+      .map(row => row.name);
+    return actual.length === columns.length && actual.every((value, offset) => value === columns[offset]);
+  });
+  if (!hasIndex(['status', 'updated_at'])
+      || !hasIndex(['request_key'])
+      || !hasIndex(['run_id', 'ordinal'])) {
+    throw new Error('EngineTurn status repair did not preserve required indexes');
+  }
+  const immutableTrigger = db.prepare(`SELECT 1 AS present FROM sqlite_master
+    WHERE type = 'trigger' AND name = 'trg_engine_turn_request_immutable'`).get();
+  if (!immutableTrigger) throw new Error('EngineTurn status repair did not preserve request immutability');
+  const foreignKeyViolations = db.prepare('PRAGMA foreign_key_check').all();
+  if (foreignKeyViolations.length > 0) throw new Error('EngineTurn status repair violated foreign keys');
+}
+
 function migrateCoordinatorProviderTurns(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS coordinator_provider_turns (
@@ -422,6 +463,21 @@ function migrateCoordinatorProviderTurns(db) {
   `);
 }
 
+function migrateCoordinatorProviderClaims(db) {
+  for (const [column, definition] of [
+    ['claim_owner', 'TEXT'],
+    ['claim_epoch', 'INTEGER NOT NULL DEFAULT 0'],
+  ]) {
+    if (!hasColumn(db, 'coordinator_provider_turns', column)) {
+      db.exec(`ALTER TABLE coordinator_provider_turns ADD COLUMN ${column} ${definition}`);
+    }
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_coordinator_provider_turns_claim
+      ON coordinator_provider_turns(coordinator_turn_id, claim_owner, claim_epoch, status);
+  `);
+}
+
 function migrateReliabilityGuards(db) {
   for (const [column, definition] of [
     ['dispatch_capability', "TEXT NOT NULL DEFAULT 'unknown'"],

package/yeaft/work-center/projection.js

@@ -1036,6 +1036,8 @@ export function projectWorkCenterEvent(event) {
     type,
     ...(eventActionId ? { actionId: eventActionId } : {}),
     ...(typeof event?.runId === 'string' && event.runId ? { runId: event.runId } : {}),
+    ...(typeof event?.clientMessageId === 'string' && event.clientMessageId
+      ? { clientMessageId: truncateUtf8(event.clientMessageId, 256) } : {}),
     workItem: {
       ...projectWorkItemSummary(event?.workItem),
       actionStats: projectActionStats(event?.workItem, liveActionId),

package/yeaft/work-center/runner.js

@@ -1,5 +1,5 @@
 import { Engine } from '../engine.js';
-import { ToolRegistry } from '../tools/registry.js';
+import { ToolRegistry, isToolErrorOutput, toolErrorEffect } from '../tools/registry.js';
 import { defineTool } from '../tools/types.js';
 import { allTools } from '../tools/index.js';
 import { parsePatch } from '../tools/apply-patch.js';
@@ -274,6 +274,7 @@ function wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunAct
         ? input
         : assertToolInput(tool.name, input, canonicalDir, canonicalAttachmentFiles);
       const trackOperation = typeof operationLifecycle === 'function'
+        && tool.sideEffectScope !== 'run'
         && tool.isReadOnly?.(checkedInput) !== true;
       const operation = trackOperation ? operationLifecycle(tool.name, checkedInput) : null;
       let output;
@@ -288,7 +289,12 @@ function wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunAct
         operation?.complete('unknown', { error: String(error?.message || error) });
         throw error;
       }
-      operation?.complete('applied', { outputHash: hashMainlineSnapshot({ output: String(output || '') }) });
+      const outputHash = hashMainlineSnapshot({ output: String(output || '') });
+      const returnedError = tool.errorOutput === 'json-error-envelope' && isToolErrorOutput(output);
+      const effectStatus = returnedError
+        ? toolErrorEffect(output) === 'none' ? 'failed_no_effect' : 'unknown'
+        : 'applied';
+      operation?.complete(effectStatus, { outputHash });
       if (!isRunActive()) throw new Error('Work Center Run lease was lost during tool execution');
       if (['FileRead', 'ViewImage'].includes(tool.name) && typeof output === 'string') {
         const withoutFilePaths = canonicalAttachmentFiles.reduce(
@@ -386,6 +392,7 @@ export function createSubmitWorkItemPlanTool({
     },
     isConcurrencySafe: () => false,
     isReadOnly: () => false,
+    sideEffectScope: 'run',
   });
 }
 
@@ -444,6 +451,7 @@ export function createProposeWorkItemActionsTool({
       ctx.requestEndTurn?.({ kind: 'work_item_actions_proposed', proposalId: input.proposalId });
       return JSON.stringify({ submitted: true, proposalId: input.proposalId, actionCount: input.actions.length });
     },
+    sideEffectScope: 'run',
   });
 }
 
@@ -465,6 +473,7 @@ export function createRequestWorkItemReplanTool({ workItem, collector, isRunActi
       ctx.requestEndTurn?.({ kind: 'work_item_replan_requested', proposalId: input.proposalId });
       return JSON.stringify({ submitted: true, proposalId: input.proposalId });
     },
+    sideEffectScope: 'run',
   });
 }
 
@@ -519,6 +528,7 @@ export function createSubmitWorkItemReplanTool({ vps, workItem, action, actions,
     },
     isConcurrencySafe: () => false,
     isReadOnly: () => false,
+    sideEffectScope: 'run',
   });
 }
 
@@ -1038,7 +1048,7 @@ export class WorkItemRunner {
     const operationLifecycle = (toolName, input) => {
       operationOrdinal += 1;
       const idempotencyKey = `${run.id}:tool:${operationOrdinal}`;
-      this.store.createOperation({
+      const claimed = this.store.createAndClaimOperation({
         workItemId: workItem.id,
         actionId: action.id,
         runId: run.id,
@@ -1046,8 +1056,7 @@ export class WorkItemRunner {
         idempotencyKey,
         replayPolicy: 'never_automatic',
         payload: { inputHash: hashMainlineSnapshot(input) },
-      });
-      const claimed = this.store.claimOperation(idempotencyKey, ownerBootId, run.leaseEpoch, false);
+      }, ownerBootId, run.leaseEpoch, false);
       if (!claimed) throw new Error(`Work Center could not claim Operation ${idempotencyKey}`);
       return {
         complete: (effectStatus, result) => {