@yeaft/webchat-agent 1.0.411 → 1.0.413

package/package.json

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

@@ -22,7 +22,7 @@ import { promises as fsp } from 'fs';
 import { join, resolve as resolvePath } from 'path';
 import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
 import { getRuntimePlatformInfo } from './runtime-platform.js';
-import { LLMContextError, LLMAbortError, LLMAuthError, LLMRateLimitError, LLMServerError, LLMStreamIdleTimeoutError } from './llm/adapter.js';
+import { LLMContextError, LLMAbortError, LLMAuthError, LLMPolicyError, LLMRateLimitError, LLMServerError, LLMStreamIdleTimeoutError } from './llm/adapter.js';
 import { runMemoryPreflow, buildRelevantScopes, memoryScopeLabel } from './sessions/pre-flow.js';
 import {
   readProjectDoc,
@@ -155,6 +155,8 @@ const RETRY_DEFAULTS = Object.freeze({
 
 const RETRY_CONTINUATION_PROMPT =
   'Continue from the exact point where the previous response stopped. Do not repeat text already produced.';
+const POLICY_RECOVERY_PROMPT =
+  'Continue this authorized code review, but describe security findings abstractly. Do not repeat credential-like or exploit payloads, secrets, tokens, or step-by-step misuse instructions. Preserve the technical conclusion, evidence location, severity, and remediation.';
 
 // Accept legacy namespaced commands and Claude Code-style bare skill commands.
 // Project-tier skills are shown as /<skill-name>; /yeaft-skills:<name> and
@@ -2791,6 +2793,7 @@ export class Engine {
     let retryPolicy = resolveRetryPolicy(this.#config);
     let consecutiveRetryableErrors = 0;
     let consecutiveForbiddenErrors = 0;
+    let contentPolicyRecoveryAttempts = 0;
 
     while (true) {
       turnNumber++;
@@ -3442,17 +3445,42 @@ export class Engine {
             errorName: err?.name || null,
             statusCode: err?.statusCode ?? null,
             retryable: err instanceof LLMRateLimitError || err instanceof LLMServerError,
+            reasonCode: err?.reasonCode || null,
             message: String(err?.message || '').slice(0, 200),
           },
         });
 
         const earlyIsRateLimit = err instanceof LLMRateLimitError;
         const earlyIsTransient = err instanceof LLMServerError;
+        const earlyIsContentPolicy = err instanceof LLMPolicyError;
         // A completed tool_call has already crossed the streaming boundary to
         // the caller. Replaying that request would publish a duplicate call and
         // leave ambiguous execution ownership, so only pre-tool failures are
         // eligible for transparent retry or model fallback.
         const canReplayProviderRequest = toolCalls.length === 0;
+        if (earlyIsContentPolicy && canReplayProviderRequest && contentPolicyRecoveryAttempts === 0) {
+          contentPolicyRecoveryAttempts = 1;
+          endAttemptTrace('llm_retry');
+          if (responseText) prepareRetryContinuation();
+          retryLifecycle.pendingContinuation = {
+            role: 'user',
+            content: POLICY_RECOVERY_PROMPT,
+            userAuthored: false,
+          };
+          yield {
+            type: 'llm_retry',
+            attempt: 1,
+            maxRetries: 1,
+            delayMs: 0,
+            reason: 'content_policy_recovery',
+            recoveryMode: 'continue',
+            errorName: err.name,
+            statusCode: err.statusCode ?? 422,
+            message: 'Provider content-safety rejection; retrying once with sensitive examples abstracted.',
+          };
+          yield { type: 'turn_end', turnNumber, stopReason: 'llm_retry', threadId };
+          continue;
+        }
         const earlyIsTemporaryForbidden = err instanceof LLMAuthError
           && err.statusCode === 403
           && err.temporary === true;
@@ -3640,9 +3668,25 @@ export class Engine {
             && consecutiveRetryableErrors >= retryPolicy.maxRetries;
           errorEvent.retryAttempts = consecutiveRetryableErrors;
           errorEvent.maxRetries = retryPolicy.maxRetries;
+        } else if (err instanceof LLMPolicyError) {
+          errorEvent.reason = 'content_policy_denied';
+          errorEvent.retryExhausted = contentPolicyRecoveryAttempts >= 1;
+          errorEvent.retryAttempts = contentPolicyRecoveryAttempts;
+          errorEvent.maxRetries = 1;
         }
         yield errorEvent;
-        yield { type: 'turn_end', turnNumber, stopReason: 'error', threadId, terminal: true };
+        yield {
+          type: 'turn_end',
+          turnNumber,
+          stopReason: 'error',
+          threadId,
+          terminal: true,
+          detail: {
+            errorName: err?.name || 'Error',
+            statusCode: err?.statusCode ?? null,
+            reason: errorEvent.reason || err?.reasonCode || null,
+          },
+        };
         break;
       }
 

package/yeaft/llm/adapter.js

@@ -140,6 +140,29 @@ export function classifyAuthError(statusCode, responseBody = '', details = {}) {
   });
 }
 
+/** Provider content-safety rejection (commonly 422) — eligible for one sanitized recovery. */
+export class LLMPolicyError extends Error {
+  constructor(_providerMessage, statusCode = 422, details = {}) {
+    super('The LLM provider blocked this request under its content-safety policy. Continue and avoid repeating sensitive payloads or credential-like examples.');
+    this.name = 'LLMPolicyError';
+    this.statusCode = statusCode;
+    this.reasonCode = 'content_policy_denied';
+    this.provider = details.provider || null;
+    this.model = details.model || null;
+  }
+}
+
+const CONTENT_POLICY_RE = /(?:content (?:was )?flagged|content[-_ ]?safety|cybersecurity risk|safety policy|safety system|content[_ -]?filter|policy[_ -]?violation)/i;
+
+export function classifyPolicyError(statusCode, responseBody = '', details = {}) {
+  const status = Number(statusCode) || 0;
+  const signals = providerErrorSignals(responseBody);
+  if (status !== 422 || (!CONTENT_POLICY_RE.test(signals.code) && !CONTENT_POLICY_RE.test(signals.message))) {
+    return null;
+  }
+  return new LLMPolicyError(signals.message, status, details);
+}
+
 /** Context too long error (413 or API-specific) — need compaction. */
 export class LLMContextError extends Error {
   constructor(message) {

package/yeaft/llm/anthropic.js

@@ -13,6 +13,7 @@ import {
   retryAfterFromResponse,
   LLMAuthError,
   classifyAuthError,
+  classifyPolicyError,
   LLMContextError,
   LLMServerError,
   LLMAbortError,
@@ -230,6 +231,8 @@ export class AnthropicAdapter extends LLMAdapter {
       const retryAfter = retryAfterFromResponse(response);
       return new LLMRateLimitError(`Anthropic overloaded (${authHint}): ${body}`, status, retryAfter);
     }
+    const policyError = classifyPolicyError(status, body);
+    if (policyError) return policyError;
     if (body.includes('prompt is too long') || body.includes('max_tokens')) {
       return new LLMContextError(`Anthropic context error (${authHint}): ${body}`);
     }

package/yeaft/llm/openai-responses.js

@@ -30,6 +30,7 @@ import {
   LLMRateLimitError,
   LLMAuthError,
   classifyAuthError,
+  classifyPolicyError,
   LLMContextError,
   LLMServerError,
   LLMAbortError,
@@ -219,6 +220,8 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
       const retryAfter = retryAfterFromResponse(response);
       return new LLMRateLimitError(`Overloaded: ${body}`, status, retryAfter);
     }
+    const policyError = classifyPolicyError(status, body);
+    if (policyError) return policyError;
     if (status === 413 || body.includes('context_length_exceeded') || body.includes('maximum context length')) {
       return new LLMContextError(`Context too long: ${body}`);
     }

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

@@ -74,7 +74,7 @@ Use this when work must continue beyond the current turn, needs role handoffs, r
       // a different dispatch policy into it.
       origin: {
         sessionId,
-        messageId: ctx.inboundEnvelope?.msgId || null,
+        messageId: ctx.inboundEnvelope?.msg?.id || null,
         createdBy: ctx.currentVpId || 'assistant',
       },
       linkedSessionIds: [sessionId],

package/yeaft/web-bridge.js

@@ -4464,9 +4464,13 @@ function handleEngineEvent(event, hctx) {
       const errMsg = event.error?.message || 'Unknown error';
       const retryAttempts = Number.isFinite(event.retryAttempts) ? event.retryAttempts : 0;
       const exhaustedIdle = event.reason === 'stream_idle_timeout' && event.retryExhausted;
-      const visibleErrMsg = exhaustedIdle && retryAttempts > 0
-        ? `${errMsg} after ${retryAttempts} fresh request retries`
-        : errMsg;
+      const contentPolicyDenied = event.reason === 'content_policy_denied'
+        || event.error?.reasonCode === 'content_policy_denied';
+      const visibleErrMsg = contentPolicyDenied
+        ? 'Provider blocked this request for content-safety reasons after one safe recovery attempt. Continue and ask the VP to avoid repeating sensitive payloads, credentials, tokens, or exploit samples.'
+        : exhaustedIdle && retryAttempts > 0
+          ? `${errMsg} after ${retryAttempts} fresh request retries`
+          : errMsg;
       hctx.lastEngineErrorDetail = {
         message: visibleErrMsg,
         ...(event.reason ? { reason: event.reason } : {}),

package/yeaft/work-center/bridge.js

@@ -27,7 +27,8 @@ const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_req
 // client-supplied value and only emits files resolved from owned upload ids.
 const BROWSER_FILE_FIELDS = Object.freeze({
   create: [
-    'title', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'reuseMemory', 'files', 'start',
+    'title', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'deliveryTarget',
+    'reuseMemory', 'files', 'start',
   ],
   post_work_item_message: [
     'id', 'clientMessageId', 'text', 'target', 'revision', 'planRevision', 'ledgerRevision',
@@ -225,7 +226,7 @@ export async function handleWorkCenterRequest(msg) {
       const payload = Object.hasOwn(BROWSER_FILE_FIELDS, op)
         ? browserFilePayload(op, msg.payload)
         : (BROWSER_ACTION_DEBUG_OPS.has(op) ? browserFilePayload(op, msg.payload) : (msg.payload || {}));
-      data = await workCenter.handle(op, payload);
+      data = await workCenter.handle(op, payload, { userOriginated: true });
     }
     if (BROWSER_DETAIL_OPS.has(op) && data?.accepted !== true) {
       data = workCenter.projectBrowserDetail(data);

package/yeaft/work-center/completion-contract.js

@@ -13,6 +13,12 @@ export function normalizeContractPatch(value) {
     if (!criteria) throw new Error('contractPatch.acceptanceCriteria must be an array');
     patch.acceptanceCriteria = criteria;
   }
+  if (Object.hasOwn(value, 'deliveryTarget')) {
+    if (!['workspace_files', 'pull_request', 'merge'].includes(value.deliveryTarget)) {
+      throw new Error('contractPatch.deliveryTarget must be workspace_files, pull_request, or merge');
+    }
+    patch.deliveryTarget = value.deliveryTarget;
+  }
   return Object.keys(patch).length > 0 ? patch : null;
 }
 

package/yeaft/work-center/controller.js

@@ -11,7 +11,7 @@ import {
 } from './workflow.js';
 import { renderSessionContextSnapshot } from './session-context.js';
 import { normalizeSessionMessageQuote } from '../session-message-quote.js';
-import { normalizeEvidence } from './evidence.js';
+import { normalizeEvidence, normalizeOutputs } from './evidence.js';
 import { isDynamicWorkItem } from './execution-mode.js';
 import { applyAdditivePlanProposal, applyReplanMutation } from './plan-mutation.js';
 import { normalizeContractPatch, validateCompletedResult } from './completion-contract.js';
@@ -25,6 +25,7 @@ function normalizeTerminalResult(result, action) {
     response: String(result.response || ''),
     summary: String(result.summary || ''),
     evidence: normalizeEvidence(result.evidence),
+    outputs: normalizeOutputs(result.outputs),
     waitingReason: result.waitingReason ? String(result.waitingReason) : null,
     error: result.error ? String(result.error) : null,
     failureKind: result.failureKind === 'system_blocked' ? 'system_blocked' : null,

package/yeaft/work-center/coordinator.js

@@ -9,7 +9,11 @@ import {
 } from '../llm/adapter.js';
 import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
 import { normalizeContractPatch } from './completion-contract.js';
-import { prepareDynamicActionMutation } from './dynamic-coordination.js';
+import { normalizeOutputs } from './evidence.js';
+import {
+  normalizeDynamicActionClosures,
+  prepareDynamicActionMutation,
+} from './dynamic-coordination.js';
 import { isDynamicWorkItem } from './execution-mode.js';
 import { applyCoordinatorReplan } from './plan-mutation.js';
 import { buildWorkItemAttachmentContext } from './attachments.js';
@@ -127,6 +131,7 @@ function coordinatorStageReferences(detail) {
 }
 
 function boundedAction(action, result, stageReferences, compact = false, dynamic = false) {
+  const preserveCanonicalResult = action?.status === 'completed';
   const brief = action?.brief && typeof action.brief === 'object' ? action.brief : null;
   return {
     ...(dynamic
@@ -153,18 +158,21 @@ function boundedAction(action, result, stageReferences, compact = false, dynamic
         expectedOutcome: truncateUtf8(brief.expectedOutcome, 256),
       },
     } : {}),
+    ...(action?.closeReason ? { closeReason: truncateUtf8(action.closeReason, 1_000) } : {}),
     result: result ? {
+      runId: truncateUtf8(result.id, 256),
       status: truncateUtf8(result.status, 64),
       summary: truncateUtf8(result.summary, compact ? 256 : 768),
-      ...(!compact ? {
-        evidence: boundedEvidence(result.evidence),
-        acceptanceChecks: (Array.isArray(result.acceptanceChecks) ? result.acceptanceChecks : [])
+      evidence: boundedEvidence(result.evidence),
+      outputs: boundedEvidence(normalizeOutputs(result.outputs)),
+      acceptanceChecks: preserveCanonicalResult
+        ? (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,
@@ -219,6 +227,7 @@ Return exactly one JSON object and no surrounding prose:
     "question": null,
     "workItemType": null,
     "contractPatch": null,
+    "closeActions": [],
     "supersedeActionIds": [],
     "guidance": [],
     "actions": [],
@@ -229,10 +238,12 @@ Return exactly one JSON object and no surrounding prose:
 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.
+- If no existing VP can execute a required capability, create one create_vp Action assigned to the existing VP best suited to author that specialist. After it completes, create the original Action with the new VP id. Never fail or retry the original Action merely because its capability label has no match.
+- closeActions may accompany create_actions. Each entry is {"actionId":"failed or waiting durable Action id","reason":"why it is no longer required"}. Close only work made obsolete by replacement evidence or a clarified contract. Closed Actions remain audit history, are never acceptance evidence, and do not block completion.
 - 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.
+- request_human: use when external information or a user decision is genuinely required. Before creating mutating or delivery Actions, ask whether the delivery boundary is files only, PR, or merge when the contract does not already say. After the user answers, persist it with contractPatch.deliveryTarget = workspace_files | pull_request | merge before creating more Actions.
+- complete: only when every acceptance criterion has canonical completed Run evidence and there are no unfinished Actions after applying optional closeActions. Include summary, ordered acceptanceResults with evidenceRunIds, evidenceRunIds, and residualRisks. Reuse structured outputs already present on canonical Runs; do not create repetitive evidence-packaging Actions.
+- Preserve completed and closed 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.`;
 
@@ -270,6 +281,13 @@ function cleanText(value, limit, name) {
   return text;
 }
 
+function requiresDeliveryBoundaryDecision(detail, actions) {
+  const requested = Array.isArray(actions) ? actions : [];
+  return !detail?.deliveryTarget && requested.some(action => (
+    action?.type === 'create_vp' || action?.workspaceMode !== 'read'
+  ));
+}
+
 function permanentCoordinatorDiagnostic(cause, phase, language) {
   const zh = coordinatorLanguage(language) === 'zh';
   if (cause instanceof LLMAuthError) {
@@ -378,7 +396,7 @@ function normalizeGuidance(value, detail) {
   }
   const dynamic = isDynamicWorkItem(detail);
   const active = (detail.actions || [])
-    .filter(action => !['completed', 'superseded', 'cancelled'].includes(action.status));
+    .filter(action => !['completed', 'closed', '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();
@@ -456,13 +474,17 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
     };
   }
   if (kind === 'request_human') {
+    if (options.automatic === true && source.contractPatch?.deliveryTarget) {
+      throw new Error('Automatic Work Center Coordinator delivery target changes are forbidden');
+    }
+    const contractPatch = dynamic ? normalizeContractPatch(source.contractPatch) : null;
     return {
       reply,
       decision: {
         kind,
         reason,
         question: cleanText(source.question, COORDINATOR_MAX_REPLY_CHARS, 'human question'),
-        contractPatch: null,
+        contractPatch: dynamic && options.automatic !== true ? contractPatch : null,
         guidance: [],
         actions: [],
       },
@@ -474,6 +496,7 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
       decision: {
         kind,
         reason,
+        closeActions: normalizeDynamicActionClosures(source.closeActions, detail.actions || []),
         completion: source.completion,
         contractPatch: null,
         guidance: [],
@@ -482,12 +505,19 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
     };
   }
   if (dynamic && kind === 'create_actions') {
+    if (options.automatic === true && source.contractPatch?.deliveryTarget) {
+      throw new Error('Automatic Work Center Coordinator delivery target changes are forbidden');
+    }
     const contractPatch = normalizeContractPatch(source.contractPatch);
+    if (requiresDeliveryBoundaryDecision(detail, source.actions)) {
+      throw new Error('Work Center delivery target is unconfirmed; the delivery boundary requires request_human before creating mutating or delivery Actions');
+    }
     const decision = {
       kind,
       reason,
       workItemType: source.workItemType,
       contractPatch,
+      closeActions: source.closeActions,
       supersedeActionIds: source.supersedeActionIds,
       guidance: [],
       actions: source.actions,
@@ -581,6 +611,7 @@ function coordinatorSnapshot(detail) {
     status: truncateUtf8(detail.status, 64),
     title: truncateUtf8(detail.title, 1 * 1024),
     goal: truncateUtf8(detail.goal, 4 * 1024),
+    deliveryTarget: detail.deliveryTarget || null,
     acceptanceCriteria,
     workItemType: truncateUtf8(detail.workflowSnapshot?.workItemType, 256) || null,
   };
@@ -592,8 +623,8 @@ function coordinatorSnapshot(detail) {
   const currentActions = (Array.isArray(detail.actions) ? detail.actions : [])
     .filter(action => !['superseded', 'cancelled'].includes(action.status));
   const stageReferences = coordinatorStageReferences(detail);
-  const unfinished = currentActions.filter(action => action.status !== 'completed');
-  const completed = currentActions.filter(action => action.status === 'completed');
+  const unfinished = currentActions.filter(action => !['completed', 'closed'].includes(action.status));
+  const completed = currentActions.filter(action => ['completed', 'closed'].includes(action.status));
   const selected = [
     ...unfinished,
     ...completed.slice(-Math.max(0, COORDINATOR_MAX_ACTIONS - unfinished.length)),
@@ -627,7 +658,7 @@ function coordinatorSnapshot(detail) {
   return {
     workItem,
     actions,
-    omittedCompletedActionCount: Math.max(0, completed.length - actions.filter(action => action.status === 'completed').length),
+    omittedCompletedActionCount: Math.max(0, completed.length - actions.filter(action => ['completed', 'closed'].includes(action.status)).length),
     conversation: coordinatorHistory(detail.messages),
   };
 }

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

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 
-export const WORK_CENTER_SCHEMA_VERSION = 37;
+export const WORK_CENTER_SCHEMA_VERSION = 39;
 
 const MIGRATIONS = [
   ['23-conversation-stream', migrateConversationStream],
@@ -18,6 +18,8 @@ const MIGRATIONS = [
   ['35-coordinator-provider-claims', migrateCoordinatorProviderClaims],
   ['36-dynamic-coordination', migrateDynamicCoordination],
   ['37-run-acceptance-checks', migrateRunAcceptanceChecks],
+  ['38-action-closure-and-outputs', migrateActionClosureAndOutputs],
+  ['39-action-creation-source', migrateActionCreationSource],
 ];
 
 const MIGRATION_ALIASES = new Map([
@@ -528,6 +530,48 @@ function migrateRunAcceptanceChecks(db) {
   `);
 }
 
+function migrateActionClosureAndOutputs(db) {
+  if (!hasColumn(db, 'work_items', 'delivery_target')) {
+    db.exec('ALTER TABLE work_items ADD COLUMN delivery_target TEXT');
+  }
+  if (!hasColumn(db, 'actions', 'close_reason')) {
+    db.exec('ALTER TABLE actions ADD COLUMN close_reason TEXT');
+  }
+  if (!hasColumn(db, 'actions', 'closed_at')) {
+    db.exec('ALTER TABLE actions ADD COLUMN closed_at INTEGER');
+  }
+  if (!hasColumn(db, 'runs', 'outputs')) {
+    db.exec("ALTER TABLE runs ADD COLUMN outputs 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.outputs IS NOT OLD.outputs 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 migrateActionCreationSource(db) {
+  if (!hasColumn(db, 'actions', 'creation_source')) {
+    db.exec("ALTER TABLE actions ADD COLUMN creation_source TEXT NOT NULL DEFAULT 'legacy'");
+  }
+}
+
 function migrateReliabilityGuards(db) {
   for (const [column, definition] of [
     ['dispatch_capability', "TEXT NOT NULL DEFAULT 'unknown'"],

package/yeaft/work-center/dynamic-coordination.js

@@ -70,6 +70,25 @@ function normalizeSourceActionIds(value, actions) {
   return ids;
 }
 
+export function normalizeDynamicActionClosures(value, actions) {
+  if (!Array.isArray(value)) return [];
+  const byId = new Map(actions.map(action => [action.id, action]));
+  const seen = new Set();
+  return value.map(raw => {
+    const actionId = requiredText(raw?.actionId, 'close actionId', 256);
+    if (seen.has(actionId)) throw new Error(`Work Center dynamic Action close target is duplicated: ${actionId}`);
+    seen.add(actionId);
+    const action = byId.get(actionId);
+    if (!action || !['waiting', 'failed'].includes(action.status)) {
+      throw new Error(`Work Center can close only a waiting or failed Action: ${actionId}`);
+    }
+    return {
+      actionId,
+      reason: requiredText(raw?.reason, 'close reason', 2_000),
+    };
+  });
+}
+
 function normalizeSupersededActionIds(value, actions) {
   const ids = uniqueStrings(value);
   const byId = new Map(actions.map(action => [action.id, action]));
@@ -106,7 +125,12 @@ export function prepareDynamicActionMutation({
   const knownVpIds = Array.isArray(availableVpIds)
     ? new Set(availableVpIds.map(value => String(value || '').trim()).filter(Boolean))
     : null;
+  const closeActions = normalizeDynamicActionClosures(decision.closeActions, actions);
+  const closeActionIds = new Set(closeActions.map(entry => entry.actionId));
   const supersedeActionIds = normalizeSupersededActionIds(decision.supersedeActionIds, actions);
+  if (supersedeActionIds.some(actionId => closeActionIds.has(actionId))) {
+    throw new Error('Work Center cannot both close and supersede the same Action');
+  }
   const effectiveWorkItem = {
     ...workItem,
     ...(decision.contractPatch || {}),
@@ -133,6 +157,12 @@ export function prepareDynamicActionMutation({
       const unavailable = candidateVpIds.find(vpId => !knownVpIds.has(vpId));
       if (unavailable) throw new Error(`Work Center dynamic Action references unavailable VP "${unavailable}"`);
     }
+    if (type === 'create_vp' && !knownVpIds) {
+      throw new Error('Work Center create_vp Action requires the available VP inventory');
+    }
+    if (type === 'create_vp' && candidateVpIds.length !== 1) {
+      throw new Error('Work Center create_vp Action requires exactly one existing VP and an assignment reason');
+    }
     const assignmentReason = candidateVpIds.length > 0
       ? requiredText(raw.assignmentReason, 'assignmentReason', 1_000)
       : '';
@@ -140,6 +170,9 @@ export function prepareDynamicActionMutation({
     const workspaceMode = DYNAMIC_WORKSPACE_MODES.has(raw.workspaceMode)
       ? raw.workspaceMode
       : 'shared';
+    if (type === 'create_vp' && workspaceMode === 'read') {
+      throw new Error('Work Center create_vp Action cannot use read workspace mode because VP creation mutates Agent-global state');
+    }
     const sourceActionIds = normalizeSourceActionIds(raw.sourceActionIds, actions);
     if (workspaceMode === 'integrate' && sourceActionIds.length === 0) {
       throw new Error('Work Center integrate Action requires sourceActionIds');
@@ -198,6 +231,7 @@ export function prepareDynamicActionMutation({
   if (!workItemType) throw new Error('Work Center Coordinator must choose a specific WorkItem type');
   return {
     createdActions,
+    closeActions,
     supersedeActionIds,
     contractPatch: decision.contractPatch || null,
     workItemType,