npm - @yeaft/webchat-agent - Versions diffs - 1.0.366 → 1.0.368 - Mend

@yeaft/webchat-agent 1.0.366 → 1.0.368

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +51 -51
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/tools/create-work-item.js +8 -8
package/yeaft/work-center/controller.js +12 -2
package/yeaft/work-center/coordinator.js +156 -26
package/yeaft/work-center/durable-model.js +51 -1
package/yeaft/work-center/dynamic-coordination.js +243 -0
package/yeaft/work-center/execution-mode.js +16 -0
package/yeaft/work-center/mainline-projection.js +25 -13
package/yeaft/work-center/projection.js +32 -9
package/yeaft/work-center/runner.js +18 -13
package/yeaft/work-center/service.js +86 -13
package/yeaft/work-center/store.js +535 -60

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=86aebbdf"></script>
+  <script type="module" src="app.bundle.js?v=76df89f4"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.366",
+  "version": "1.0.368",
   "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/tools/create-work-item.js CHANGED Viewed

@@ -11,10 +11,10 @@ export default defineTool({
   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 only the goal contract; Work Center triage chooses the task type, Actions, and executors. The current Session is always stamped as the origin and cannot be overridden by model input.`,
+Use this when work must continue beyond the current turn, needs role handoffs, review, waiting, retry, or durable tracking. This creates only the goal contract; the Work Center Coordinator dynamically chooses the next Actions and executors until the acceptance criteria are verified. The current Session is always stamped as the origin and cannot be overridden by model input.`,
     zh: `从当前 Session 创建一个持久化的 Agent 级工作项。
-当工作需要跨 turn 继续、需要角色接力、评审、等待、重试或长期跟踪时使用。该工具只创建目标契约，任务类型、Action 和执行者由 Work Center triage 决定，不在当前 turn 内执行。来源 Session 由运行时强制写入，模型输入不能覆盖。`,
+当工作需要跨 turn 继续、需要角色接力、评审、等待、重试或长期跟踪时使用。该工具只创建目标契约；Work Center Coordinator 会动态选择下一批 Action 和执行者，直到验收条件得到验证。来源 Session 由运行时强制写入，模型输入不能覆盖。`,
   },
   parameters: {
     type: 'object',
@@ -42,15 +42,15 @@ Use this when work must continue beyond the current turn, needs role handoffs, r
       },
       start: {
         type: 'boolean',
-        description: { en: 'Start triage immediately (default true)', zh: '是否立即开始 triage（默认 true）' },
+        description: { en: 'Start Coordinator execution immediately (default true)', zh: '是否立即启动 Coordinator 执行（默认 true）' },
       },
     },
     required: ['title', 'goal'],
   },
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
-  // The Work Center watcher can advance from triage into a writable Action
-  // after creation returns. A paused item has no watcher-owned execution.
+  // The persistent Coordinator can create a writable Action after creation
+  // returns. A paused item has no Coordinator- or watcher-owned execution.
   mayMutateWorkspaceAfterReturn: input => input?.start !== false,
   async execute(input, ctx = {}) {
     const sessionId = typeof ctx.sessionId === 'string' ? ctx.sessionId.trim() : '';
@@ -69,9 +69,9 @@ Use this when work must continue beyond the current turn, needs role handoffs, r
       acceptanceCriteria: cleanCriteria(input.acceptanceCriteria),
       workItemType: typeof input.workItemType === 'string' ? input.workItemType.trim() : 'auto',
       workDir: typeof input.workDir === 'string' ? input.workDir.trim() : (ctx.cwd || ''),
-      // The Agent-local Work Center settings choose the default workflow and
-      // freeze its policy snapshot. Tool callers create the contract; they do
-      // not get to smuggle a different dispatch policy into it.
+      // Agent-local Work Center settings freeze the Action-template and model
+      // policy snapshot. Tool callers create the contract; they cannot smuggle
+      // a different dispatch policy into it.
       origin: {
         sessionId,
         messageId: ctx.inboundEnvelope?.msgId || null,

package/yeaft/work-center/controller.js CHANGED Viewed

@@ -12,6 +12,7 @@ import {
 import { renderSessionContextSnapshot } from './session-context.js';
 import { normalizeSessionMessageQuote } from '../session-message-quote.js';
 import { normalizeEvidence } from './evidence.js';
+import { isDynamicWorkItem } from './execution-mode.js';
 import { applyAdditivePlanProposal, applyReplanMutation } from './plan-mutation.js';
 import { normalizeContractPatch, validateCompletedResult } from './completion-contract.js';
@@ -129,7 +130,7 @@ export class WorkflowController {
       acceptanceCriteria: Array.isArray(input.acceptanceCriteria) ? input.acceptanceCriteria : [],
       attachments: Array.isArray(input.attachments) ? input.attachments : [],
     };
-    let firstAction = input.start !== false ? initialActionFor(draft) : null;
+    let firstAction = input.start !== false && !isDynamicWorkItem(draft) ? initialActionFor(draft) : null;
     if (firstAction) {
       firstAction = {
         ...firstAction,
@@ -301,7 +302,7 @@ export class WorkflowController {
           quote: input.inputEvent?.quote || null,
         });
       }
-      if (Number(workItem.executionSchemaVersion) === 2 && input.inputEvent?.inputId) {
+      if (Number(workItem.executionSchemaVersion) >= 2 && input.inputEvent?.inputId) {
         context.push({
           type: 'input',
           role: 'user',
@@ -337,6 +338,15 @@ export class WorkflowController {
       throw new Error('Run has unconsumed Action input and cannot finish yet');
     }
     const result = normalizeTerminalResult(rawResult, activeAction);
+    if (isDynamicWorkItem(activeWorkItem)) {
+      result.contractPatch = null;
+      result.plan = null;
+      result.planProposal = null;
+      result.replanRequest = null;
+      result.replanMutation = null;
+      result.nextActions = [];
+      result.expandPlan = null;
+    }
     if (result.outcome === 'completed'
         && activeAction.stageId?.startsWith('replan-')
         && !result.replanMutation) {

package/yeaft/work-center/coordinator.js CHANGED Viewed

@@ -9,6 +9,8 @@ import {
 } from '../llm/adapter.js';
 import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
 import { normalizeContractPatch } from './completion-contract.js';
+import { prepareDynamicActionMutation } from './dynamic-coordination.js';
+import { isDynamicWorkItem } from './execution-mode.js';
 import { applyCoordinatorReplan } from './plan-mutation.js';
 import { buildWorkItemAttachmentContext } from './attachments.js';
 import { sanitizeDiagnosticText } from './debug-projection.js';
@@ -124,17 +126,25 @@ function coordinatorStageReferences(detail) {
   };
 }
-function boundedAction(action, result, stageReferences, compact = false) {
+function boundedAction(action, result, stageReferences, compact = false, dynamic = false) {
   const brief = action?.brief && typeof action.brief === 'object' ? action.brief : null;
   return {
-    stageId: stageReferences.project(action?.stageId),
+    ...(dynamic
+      ? {
+          actionId: truncateUtf8(action?.id, 256),
+          sourceActionIds: (Array.isArray(action?.sourceActionIds) ? action.sourceActionIds : [])
+            .slice(0, 8).map(value => truncateUtf8(value, 256)).filter(Boolean),
+        }
+      : { stageId: stageReferences.project(action?.stageId) }),
     type: truncateUtf8(action?.type, 64),
     status: truncateUtf8(action?.status, 64),
     generation: Math.max(1, Number(action?.generation) || 1),
-    dependencies: (Array.isArray(action?.dependsOnStageIds) ? action.dependsOnStageIds : [])
-      .slice(0, 8)
-      .map(value => stageReferences.project(value))
-      .filter(Boolean),
+    ...(dynamic ? {} : {
+      dependencies: (Array.isArray(action?.dependsOnStageIds) ? action.dependsOnStageIds : [])
+        .slice(0, 8)
+        .map(value => stageReferences.project(value))
+        .filter(Boolean),
+    }),
     workspaceMode: truncateUtf8(action?.workspaceMode, 64),
     ...(!compact && brief ? {
       brief: {
@@ -146,7 +156,15 @@ function boundedAction(action, result, stageReferences, compact = false) {
     result: result ? {
       status: truncateUtf8(result.status, 64),
       summary: truncateUtf8(result.summary, compact ? 256 : 768),
-      ...(!compact ? { evidence: boundedEvidence(result.evidence) } : {}),
+      ...(!compact ? {
+        evidence: boundedEvidence(result.evidence),
+        acceptanceChecks: (Array.isArray(result.acceptanceChecks) ? result.acceptanceChecks : [])
+          .slice(0, 24).map(check => ({
+            criterion: truncateUtf8(check?.criterion, 512),
+            status: truncateUtf8(check?.status, 64),
+            evidence: truncateUtf8(check?.evidence, 1_000),
+          })),
+      } : {}),
       waitingReason: truncateUtf8(result.waitingReason, 384) || null,
       error: truncateUtf8(result.error, 384) || null,
       reviewDecision: truncateUtf8(result.reviewDecision, 64) || null,
@@ -188,11 +206,42 @@ Decision rules:
 - Stage ids in the snapshot may be bounded aliases. Echo them exactly; the runtime resolves them to durable identities.
 - Never return destructive cancellation. Tell the user to use the explicit cancel control instead.`;
-function coordinatorSystemPrompt(language) {
+const DYNAMIC_COORDINATOR_SYSTEM_PROMPT = `You are the persistent Work Center Coordinator. You own progress toward one durable WorkItem.
+Observe the current contract, Action journal, canonical Run evidence, and conversation. Decide only the next justified step; never predict or emit a complete workflow graph.
+Return exactly one JSON object and no surrounding prose:
+{
+  "reply": "natural user-facing response",
+  "decision": {
+    "kind": "answer|create_actions|guide_actions|request_human|complete",
+    "reason": "short audit reason",
+    "question": null,
+    "workItemType": null,
+    "contractPatch": null,
+    "supersedeActionIds": [],
+    "guidance": [],
+    "actions": [],
+    "completion": null
+  }
+}
+Rules:
+- answer: explain state only. Never use it for an automatic advance trigger.
+- create_actions: create 1..8 currently runnable Actions. Every Action needs type, objective, approach, expectedOutcome, capability, candidateVpIds, assignmentReason, sourceActionIds, workspaceMode, and optional maxAttempts/separateFromActionTypes. sourceActionIds are context/audit references, never scheduling dependencies. Do not include dependsOnActionIds, dependsOnStageIds, stages, or a graph.
+- guide_actions: target 1..8 unfinished non-running Actions by durable actionId.
+- request_human: only when external information or a user decision is genuinely required.
+- complete: only when every acceptance criterion has canonical completed Run evidence and there are no unfinished Actions. Include summary, ordered acceptanceResults with evidenceRunIds, evidenceRunIds, and residualRisks.
+- Preserve completed Action history. Never claim tests, review, merge, release, or external effects without canonical Run evidence.
+- Action templates are reusable capabilities, not a prescribed workflow. Create the smallest useful Action boundary, not tool-call-sized work.
+- Never return destructive cancellation. The user owns the explicit cancel control.`;
+function coordinatorSystemPrompt(language, detail) {
   const userLanguage = coordinatorLanguage(language) === 'zh'
     ? 'Simplified Chinese (zh-CN)'
     : 'English';
-  return `${COORDINATOR_SYSTEM_PROMPT}
+  const base = isDynamicWorkItem(detail) ? DYNAMIC_COORDINATOR_SYSTEM_PROMPT : COORDINATOR_SYSTEM_PROMPT;
+  return `${base}
 User-facing language: ${userLanguage}. Write reply and question in that language. Keep JSON property names and decision enum values in English. Never expose deterministic validator errors as the user-facing reply; explain the underlying issue plainly.`;
 }
@@ -327,19 +376,22 @@ function normalizeGuidance(value, detail) {
   if (!Array.isArray(value) || value.length < 1 || value.length > 8) {
     throw new Error('Work Center Coordinator guidance requires between 1 and 8 targets');
   }
-  const activeByStage = new Map((detail.actions || [])
-    .filter(action => !['completed', 'superseded', 'cancelled'].includes(action.status))
-    .map(action => [action.stageId, action]));
+  const dynamic = isDynamicWorkItem(detail);
+  const active = (detail.actions || [])
+    .filter(action => !['completed', 'superseded', 'cancelled'].includes(action.status));
+  const activeByReference = new Map(active.map(action => [dynamic ? action.id : action.stageId, action]));
   const stageReferences = coordinatorStageReferences(detail);
   const seen = new Set();
   return value.map(entry => {
-    const stageId = stageReferences.resolve(entry?.stageId);
-    if (!stageId || seen.has(stageId) || !activeByStage.has(stageId)) {
-      throw new Error(`Work Center Coordinator guidance references an invalid unfinished Action: ${stageId || '(missing)'}`);
+    const reference = dynamic
+      ? (typeof entry?.actionId === 'string' ? entry.actionId.trim() : '')
+      : stageReferences.resolve(entry?.stageId);
+    if (!reference || seen.has(reference) || !activeByReference.has(reference)) {
+      throw new Error(`Work Center Coordinator guidance references an invalid unfinished Action: ${reference || '(missing)'}`);
     }
-    seen.add(stageId);
+    seen.add(reference);
     return {
-      stageId,
+      ...(dynamic ? { actionId: reference } : { stageId: reference }),
       instruction: cleanText(entry?.instruction, COORDINATOR_MAX_INSTRUCTION_CHARS, 'guidance instruction'),
     };
   });
@@ -368,9 +420,14 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
   const source = parsed?.decision && typeof parsed.decision === 'object' && !Array.isArray(parsed.decision)
     ? parsed.decision
     : {};
-  const allowedKinds = options.recovery === true
-    ? ['guide_actions', 'replan', 'request_human']
-    : ['answer', 'guide_actions', 'replan'];
+  const dynamic = isDynamicWorkItem(detail);
+  const allowedKinds = dynamic
+    ? (options.automatic === true
+      ? ['create_actions', 'guide_actions', 'request_human', 'complete']
+      : ['answer', 'create_actions', 'guide_actions', 'request_human', 'complete'])
+    : (options.recovery === true
+      ? ['guide_actions', 'replan', 'request_human']
+      : ['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');
@@ -411,6 +468,41 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
       },
     };
   }
+  if (dynamic && kind === 'complete') {
+    return {
+      reply,
+      decision: {
+        kind,
+        reason,
+        completion: source.completion,
+        contractPatch: null,
+        guidance: [],
+        actions: [],
+      },
+    };
+  }
+  if (dynamic && kind === 'create_actions') {
+    const contractPatch = normalizeContractPatch(source.contractPatch);
+    const decision = {
+      kind,
+      reason,
+      workItemType: source.workItemType,
+      contractPatch,
+      supersedeActionIds: source.supersedeActionIds,
+      guidance: [],
+      actions: source.actions,
+    };
+    return {
+      reply,
+      decision,
+      mutation: prepareDynamicActionMutation({
+        workItem: detail,
+        actions: detail.actions || [],
+        decision,
+        availableVpIds: options.availableVpIds,
+      }),
+    };
+  }
   const contractPatch = normalizeContractPatch(source.contractPatch);
   if (!Array.isArray(source.actions)) {
     throw new Error('Work Center Coordinator replan requires the complete unfinished Action graph');
@@ -496,6 +588,7 @@ function coordinatorSnapshot(detail) {
     throw new Error('WorkItem contract cannot be represented within the Coordinator snapshot budget');
   }
+  const dynamic = isDynamicWorkItem(detail);
   const currentActions = (Array.isArray(detail.actions) ? detail.actions : [])
     .filter(action => !['superseded', 'cancelled'].includes(action.status));
   const stageReferences = coordinatorStageReferences(detail);
@@ -510,20 +603,24 @@ function coordinatorSnapshot(detail) {
     canonicalRunByAction.get(action.id),
     stageReferences,
     action.status === 'completed',
+    dynamic,
   ));
   let actions = boundedJsonArray(projectedActions, COORDINATOR_MAX_ACTIONS_BYTES);
-  let includedActionIdentities = new Set(actions.map(action => `${action.stageId}:${action.generation}`));
-  if (unfinished.some(action => !includedActionIdentities.has(`${stageReferences.project(action.stageId)}:${action.generation}`))) {
+  const identity = action => `${dynamic ? action.actionId : action.stageId}:${action.generation}`;
+  const expectedIdentity = action => `${dynamic ? action.id : stageReferences.project(action.stageId)}:${action.generation}`;
+  let includedActionIdentities = new Set(actions.map(identity));
+  if (unfinished.some(action => !includedActionIdentities.has(expectedIdentity(action)))) {
     projectedActions = selected.map(action => boundedAction(
       action,
       canonicalRunByAction.get(action.id),
       stageReferences,
       true,
+      dynamic,
     ));
     actions = boundedJsonArray(projectedActions, COORDINATOR_MAX_ACTIONS_BYTES);
-    includedActionIdentities = new Set(actions.map(action => `${action.stageId}:${action.generation}`));
+    includedActionIdentities = new Set(actions.map(identity));
   }
-  if (unfinished.some(action => !includedActionIdentities.has(`${stageReferences.project(action.stageId)}:${action.generation}`))) {
+  if (unfinished.some(action => !includedActionIdentities.has(expectedIdentity(action)))) {
     throw new Error('Active Actions cannot be represented within the Coordinator snapshot budget');
   }
@@ -604,6 +701,34 @@ export class WorkItemCoordinator {
     });
   }
+  advance(mailboxId, options = {}) {
+    if (this.shuttingDown) throw new Error('Work Center Coordinator is shutting down');
+    const claim = this.store.claimCoordinatorMailbox(options.workItemId, this.ownerBootId, this.claimLeaseMs);
+    if (!claim) return null;
+    if (claim.id !== mailboxId) {
+      this.store.releaseCoordinatorMailboxClaim(
+        claim.id, this.ownerBootId, Number(claim.claim_epoch),
+      );
+      return null;
+    }
+    const started = this.store.beginDynamicCoordinatorTurn(mailboxId, {
+      ownerBootId: this.ownerBootId,
+      claimEpoch: Number(claim.claim_epoch),
+    });
+    if (!started) {
+      this.store.releaseCoordinatorMailboxClaim(
+        claim.id, this.ownerBootId, Number(claim.claim_epoch),
+      );
+      return null;
+    }
+    options.onUpdate?.('coordinator.advance_started', started.detail);
+    const trigger = started.detail.messages?.find(message => message.turnId === started.turnId)?.trigger;
+    const text = `Automatic WorkItem advance trigger: ${JSON.stringify(trigger || { kind: claim.kind })}. `
+      + 'Observe the current durable state and choose the next justified Actions, a genuine human request, '
+      + 'or evidence-backed completion. Do not stop merely because the previous Action ended.';
+    return this.#scheduleTurn(started, { text, recovery: false, options });
+  }
   recover(id, options = {}) {
     if (this.shuttingDown) throw new Error('Work Center Coordinator is shutting down');
     const detail = this.store.getWorkItemDetail(id);
@@ -746,7 +871,7 @@ export class WorkItemCoordinator {
                 : latestMessage;
               const requestBody = {
                 model: resolved.model,
-                system: coordinatorSystemPrompt(language),
+                system: coordinatorSystemPrompt(language, started.detail),
                 messages: [{ role: 'user', content }],
                 maxTokens: Math.min(
                   resolveMaxOutputTokens(resolved.model, runtime.config),
@@ -799,8 +924,11 @@ export class WorkItemCoordinator {
             }
             normalized = normalizeCoordinatorResponse(result?.text, started.detail, {
               recovery,
+              automatic: started.fence.automatic === true,
               recoveryActionId: started.fence.recovery?.actionId || null,
+              availableVpIds: vps.map(vp => vp.id),
             });
+            mutation = normalized.mutation || null;
             if (normalized.decision.kind === 'replan') {
               finalizedCriteria(started.detail, normalized.decision.contractPatch);
               mutation = applyCoordinatorReplan({
@@ -873,7 +1001,9 @@ export class WorkItemCoordinator {
         attemptCount,
       }, started.fence);
       if (!detail) return this.store.getWorkItemDetail(started.detail.id);
-      options.onUpdate?.(recovery ? 'coordinator.recovery_completed' : 'coordinator.turn_completed', detail);
+      options.onUpdate?.(started.fence.automatic === true
+        ? 'coordinator.advance_completed'
+        : recovery ? 'coordinator.recovery_completed' : 'coordinator.turn_completed', detail);
       return detail;
     } catch (error) {
       if (providerTurn?.status === 'responded') {

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

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
-export const WORK_CENTER_SCHEMA_VERSION = 35;
+export const WORK_CENTER_SCHEMA_VERSION = 37;
 const MIGRATIONS = [
   ['23-conversation-stream', migrateConversationStream],
@@ -16,6 +16,8 @@ const MIGRATIONS = [
   ['33-coordinator-provider-turns', migrateCoordinatorProviderTurns],
   ['34-engine-turn-status-repair', repairEngineTurnStatusContract],
   ['35-coordinator-provider-claims', migrateCoordinatorProviderClaims],
+  ['36-dynamic-coordination', migrateDynamicCoordination],
+  ['37-run-acceptance-checks', migrateRunAcceptanceChecks],
 ];
 const MIGRATION_ALIASES = new Map([
@@ -478,6 +480,54 @@ function migrateCoordinatorProviderClaims(db) {
   `);
 }
+function migrateDynamicCoordination(db) {
+  if (!hasColumn(db, 'work_items', 'coordination_mode')) {
+    db.exec("ALTER TABLE work_items ADD COLUMN coordination_mode TEXT NOT NULL DEFAULT 'legacy'");
+  }
+  if (!hasColumn(db, 'work_items', 'final_result')) {
+    db.exec('ALTER TABLE work_items ADD COLUMN final_result TEXT');
+  }
+  if (!hasColumn(db, 'actions', 'source_action_ids')) {
+    db.exec("ALTER TABLE actions ADD COLUMN source_action_ids TEXT NOT NULL DEFAULT '[]'");
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_work_items_dynamic_status
+      ON work_items(coordination_mode, status, updated_at);
+    CREATE TRIGGER IF NOT EXISTS trg_work_item_final_result_immutable
+    BEFORE UPDATE OF final_result ON work_items
+    WHEN OLD.final_result IS NOT NULL AND NEW.final_result IS NOT OLD.final_result
+    BEGIN
+      SELECT RAISE(ABORT, 'WorkItem final result is immutable');
+    END;
+  `);
+}
+function migrateRunAcceptanceChecks(db) {
+  if (!hasColumn(db, 'runs', 'acceptance_checks')) {
+    db.exec("ALTER TABLE runs ADD COLUMN acceptance_checks TEXT NOT NULL DEFAULT '[]'");
+  }
+  db.exec(`
+    DROP TRIGGER IF EXISTS trg_runs_terminal_identity_immutable;
+    CREATE TRIGGER IF NOT EXISTS trg_runs_terminal_identity_immutable
+    BEFORE UPDATE ON runs
+    WHEN OLD.terminal_status IS NOT NULL AND (
+      NEW.action_id IS NOT OLD.action_id OR NEW.work_item_id IS NOT OLD.work_item_id OR
+      NEW.owner_boot_id IS NOT OLD.owner_boot_id OR NEW.lease_epoch IS NOT OLD.lease_epoch OR
+      NEW.ordinal IS NOT OLD.ordinal OR NEW.started_at IS NOT OLD.started_at OR
+      NEW.status IS NOT OLD.status OR NEW.ended_at IS NOT OLD.ended_at OR
+      NEW.terminal_status IS NOT OLD.terminal_status OR NEW.terminal_at IS NOT OLD.terminal_at OR
+      NEW.response IS NOT OLD.response OR NEW.summary IS NOT OLD.summary OR
+      NEW.evidence IS NOT OLD.evidence OR NEW.acceptance_checks IS NOT OLD.acceptance_checks OR
+      NEW.waiting_reason IS NOT OLD.waiting_reason OR NEW.error IS NOT OLD.error OR
+      NEW.failure_kind IS NOT OLD.failure_kind OR NEW.failure_code IS NOT OLD.failure_code OR
+      NEW.review_decision IS NOT OLD.review_decision OR NEW.contract_patch IS NOT OLD.contract_patch OR
+      NEW.checkpoint IS NOT OLD.checkpoint)
+    BEGIN
+      SELECT RAISE(ABORT, 'terminal Run result is immutable');
+    END;
+  `);
+}
 function migrateReliabilityGuards(db) {
   for (const [column, definition] of [
     ['dispatch_capability', "TEXT NOT NULL DEFAULT 'unknown'"],