@yeaft/webchat-agent 1.0.530 → 1.0.532

package/package.json

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

@@ -2356,6 +2356,7 @@ export class Engine {
     const resolveCurrentActiveToolNames = () => this.#toolRegistry
       ? resolveActiveToolNames({
           toolNames: registeredToolNames,
+          gitReadAlwaysVisible: this.#config?._gitReadAlwaysVisible === true,
           prompt,
           messages,
           collabToolPolicy: effectiveCollabToolPolicy,

package/yeaft/sub-agent/runner.js

@@ -143,7 +143,10 @@ export function startSubAgent(agent, deps = {}) {
     subEngine = new Engine({
       adapter: deps.adapter,
       trace: deps.trace,
-      config: { ...deps.config, _readOnly: true },
+      config: {
+        ...deps.config, _readOnly: true,
+        _gitReadAlwaysVisible: (agent.personaData || getPersona(agent.persona))?.id === 'reviewer',
+      },
       conversationStore: null,
       memoryIndex: deps.memoryIndex || null,
       memoryStore: deps.memoryStore || null,

package/yeaft/tools/activation.js

@@ -38,6 +38,7 @@ export const SUB_AGENT_MANAGEMENT_TOOL_NAMES = Object.freeze([
 ]);
 
 export const CONDITIONAL_BUILTIN_TOOL_NAMES = new Set([
+  'GitRead',
   'HistorySearch',
   'DiskUsage',
   'ApplyPatch',
@@ -57,6 +58,7 @@ export const CONDITIONAL_BUILTIN_TOOL_NAMES = new Set([
   'ImageGeneration',
 ]);
 
+const GIT_INTENT_RE = /(?:\bgit(?:read)?\b|\bdiff\b|\breview\b|\bcommit(?:s)?\b|\bbranch(?:es)?\b|\bworktree\b|\bpull request\b|\bPR\b|代码审查|审查|评审|提交|分支|工作树|工作区(?:状态|改动)|合并|变更差异)/iu;
 const HISTORY_INTENT_RE = /(?:\bhistory\b|\b(?:prior|previous) (?:chat|conversation|discussion)\b|\bprevious(?:ly)? discussed\b|\bwhat did we (?:decide|discuss|say|agree)\b|\b(?:our|the) (?:earlier|last) decision\b|历史|之前(?:的)?(?:对话|讨论|会话|决定)|过去(?:的)?会话|我们(?:之前|上次)(?:决定|讨论|说)了什么)/iu;
 const DISK_INTENT_RE = /(?:\bdisk (?:usage|space|full)\b|\bstorage (?:usage|space|full)\b|\blargest director|\benospc\b|\bno space left on device\b|磁盘(?:占用|空间|已满)|存储空间|目录占用|空间不足)/iu;
 const PATCH_INTENT_RE = /(?:\b(?:implement|refactor|fix|edit)\b|修复|重构|修改|实现|\bapply (?:a )?patch\b|\bunified diff\b|\bpatch file\b|应用补丁|统一 diff|补丁文件)/iu;
@@ -120,6 +122,7 @@ function matchedMcpTools(intentText, toolNames) {
  *   activeTasks?: object[],
  *   subAgentToolsActivated?: boolean,
  *   imageGenerationConfigured?: boolean,
+ *   gitReadAlwaysVisible?: boolean,
  * }} opts
  * @returns {Set<string>}
  */
@@ -131,6 +134,7 @@ export function resolveActiveToolNames({
   activeTasks = [],
   subAgentToolsActivated = false,
   imageGenerationConfigured = false,
+  gitReadAlwaysVisible = false,
 } = {}) {
   const registered = new Set(Array.isArray(toolNames) ? toolNames : []);
   const active = new Set(ALWAYS_VISIBLE_TOOL_NAMES.filter(name => registered.has(name)));
@@ -139,6 +143,7 @@ export function resolveActiveToolNames({
   const hasActiveTasks = tasks.length > 0;
   const hasSubAgentTask = tasks.some(task => task?.kind === 'sub_agent');
 
+  if (gitReadAlwaysVisible || GIT_INTENT_RE.test(intentText)) active.add('GitRead');
   if (HISTORY_INTENT_RE.test(intentText)) active.add('HistorySearch');
   if (DISK_INTENT_RE.test(intentText)) active.add('DiskUsage');
   if (PATCH_INTENT_RE.test(intentText)) active.add('ApplyPatch');

package/yeaft/tools/git-read.js

@@ -27,13 +27,13 @@ const COMMON_ARGS = Object.freeze([
 // Worktree status/diff may invoke clean/process filters even with textconv and
 // external diff disabled. Discover their keys, never values, and override them
 // for this process only. Incomplete discovery fails closed.
-async function filterOverrides(run, options) {
+async function filterOverrides(run) {
   const result = await run('git', [
     ...COMMON_ARGS, 'config', '--null', '--name-only', '--get-regexp',
     '^filter\\..*\\.(clean|smudge|process|required)$',
-  ], options);
-  if (result.truncated || result.timedOut || (result.code !== 0 && result.code !== 1)) {
-    throw new Error('Cannot safely inspect Git content filters');
+  ]);
+  if (result.truncated || result.timedOut || result.terminationError || (result.code !== 0 && result.code !== 1)) {
+    throw Object.assign(new Error('Cannot safely inspect Git content filters'), { result });
   }
   if (result.code === 1) return [];
   const keys = [...new Set(result.stdout.split('\0').filter(Boolean))];
@@ -47,8 +47,8 @@ async function filterOverrides(run, options) {
 }
 
 function errorOutput(message, operation) {
-  return JSON.stringify({
-    error: message, errorEffect: 'none', code: 'invalid_arguments',
+  return boundedFailure({
+    error: takeUtf8(message, 1024), errorEffect: 'none', code: 'invalid_arguments',
     hint: `Use only fields for the chosen operation. Minimal example: ${JSON.stringify({ operation: ['status', 'diff', 'show', 'log'].includes(operation) ? operation : 'status' })}`,
   });
 }
@@ -170,21 +170,19 @@ function takeUtf8(text, maxBytes) {
   return buffer.subarray(0, end).toString('utf8');
 }
 
-export function formatGitReadResult(operation, result) {
-  const timedOut = Boolean(result.timedOut);
-  const runnerTruncated = Boolean(result.truncated);
+function formatSuccess(operation, result) {
   const sections = [];
   if (result.stdout) sections.push(`STDOUT:\n${result.stdout}`);
   if (result.stderr) sections.push(`STDERR:\n${result.stderr}`);
   const body = sections.join('\n');
   const baseHeader = truncated => [
     `operation: ${operation}`,
-    `exitCode: ${runnerTruncated ? 'not observed (output limit reached)' : result.code}`,
-    `timedOut: ${timedOut}`,
+    `exitCode: ${result.code}`,
+    'timedOut: false',
     `truncated: ${truncated}`,
   ].join('\n');
-  const initial = `${baseHeader(runnerTruncated)}\n\n${body || '(no output)'}`;
-  if (!runnerTruncated && Buffer.byteLength(initial, 'utf8') <= MAX_RESULT_BYTES) return initial;
+  const initial = `${baseHeader(false)}\n\n${body || '(no output)'}`;
+  if (Buffer.byteLength(initial, 'utf8') <= MAX_RESULT_BYTES) return initial;
 
   const marker = '\n\n[Output truncated by GitRead; narrow the revision or paths.]';
   const header = `${baseHeader(true)}\n\n`;
@@ -195,6 +193,62 @@ export function formatGitReadResult(operation, result) {
   return header + takeUtf8(body || '(no output)', bodyBudget) + marker;
 }
 
+// Keep returned errors parseable even when JSON escaping expands raw output.
+// Engine uses this envelope (not text exit codes) for tool_end.isError.
+function boundedFailure(fields, output = '') {
+  const envelope = { ...fields, ...(output ? { output: String(output) } : {}) };
+  // Metadata is not necessarily small: even an invalid cwd reaches spawn.
+  // Bound each string after allowing for JSON's worst-case 6x escaping;
+  // the fixed envelope fields then leave ample room for diagnostics.
+  for (const [key, value] of Object.entries(fields)) {
+    if (typeof value === 'string' && Buffer.byteLength(value, 'utf8') > 512) {
+      envelope[key] = takeUtf8(value, 512) + '[truncated]';
+      envelope.truncated = true;
+    }
+  }
+  let serialized = JSON.stringify(envelope);
+  const marker = '\n[GitRead diagnostic truncated; narrow the revision or paths.]';
+  if (Buffer.byteLength(serialized, 'utf8') > MAX_RESULT_BYTES) {
+    envelope.truncated = true;
+    let low = 0;
+    let high = Math.min(Buffer.byteLength(output, 'utf8'), MAX_RESULT_BYTES);
+    while (low < high) {
+      const mid = Math.ceil((low + high) / 2);
+      envelope.output = takeUtf8(output, mid) + marker;
+      if (Buffer.byteLength(JSON.stringify(envelope), 'utf8') <= MAX_RESULT_BYTES) low = mid;
+      else high = mid - 1;
+    }
+    envelope.output = takeUtf8(output, low) + marker;
+    serialized = JSON.stringify(envelope);
+  }
+  return serialized;
+}
+
+export function formatGitReadResult(operation, result, { resolvedCwd, stage = operation } = {}) {
+  if (result.code === 0 && !result.timedOut && !result.truncated && !result.terminationError) {
+    return formatSuccess(operation, result);
+  }
+  const code = result.terminationError ? 'git_exit_unconfirmed'
+    : result.timedOut ? 'git_timeout'
+      : result.truncated ? 'git_output_limit'
+        : !Number.isInteger(result.code) ? 'git_exit_unconfirmed' : 'git_failed';
+  const error = {
+    git_exit_unconfirmed: 'Git process exit was not confirmed',
+    git_timeout: 'Git read timed out',
+    git_output_limit: 'Git read stopped at the capture limit; output is incomplete',
+    git_failed: `Git exited with code ${result.code}`,
+  }[code];
+  // Put stderr first so a long partial diff cannot hide Git's explanation.
+  const output = [result.terminationError, result.stderr && `STDERR:\n${result.stderr}`,
+    result.stdout && `STDOUT:\n${result.stdout}`].filter(Boolean).join('\n');
+  return boundedFailure({
+    error, errorEffect: 'none', code, operation, stage, resolvedCwd,
+    exitCode: result.truncated || result.terminationError ? null : (result.code ?? null),
+    timedOut: Boolean(result.timedOut), truncated: Boolean(result.truncated),
+    ...(result.terminationError || code === 'git_exit_unconfirmed' ? { terminationConfirmed: false } : {}),
+  }, output);
+}
+
 const gitReadTool = defineTool({
   name: 'GitRead',
   description: {
@@ -203,19 +257,19 @@ const gitReadTool = defineTool({
 Supported operations are intentionally limited:
 - status: compact branch and working-tree status.
 - diff: tracked changes against HEAD by default, or an explicit base...head range; optional paths narrow the result.
-- show: one commit (HEAD by default), optionally narrowed by paths.
+- show: exactly one commit (HEAD by default; tags are peeled to commits), optionally narrowed by paths. Ranges and non-commit objects are rejected.
 - log: a compact bounded commit list (20 entries by default, maximum 50).
 
-GitRead never fetches, writes Git state, or creates worktrees. It disables pagers, external diff, textconv, content filters, optional locks, fsmonitor, and submodule traversal. Filter-normalized files (such as LFS) show raw worktree bytes; submodule status needs separate inspection. Revisions and paths beginning with "-" are rejected. Output reports whether it was truncated.`,
+GitRead never fetches, writes Git state, or creates worktrees. It disables pagers, external diff, textconv, content filters, optional locks, fsmonitor, and submodule traversal. Filter-normalized files (such as LFS) show raw worktree bytes; submodule status needs separate inspection. Revisions and paths beginning with "-" are rejected. Output reports truncation. Git failures, timeouts and capture-limit stops return an error with bounded diagnostics.`,
     zh: `有界读取本地 Git 证据，不使用 shell，也不访问网络。
 
 操作范围刻意限制为：
 - status：紧凑显示分支和工作区状态。
 - diff：默认显示相对 HEAD 的已跟踪改动，也可指定 base...head；可用 paths 缩小范围。
-- show：显示一个提交（默认 HEAD），可用 paths 缩小范围。
+- show：显示唯一提交（默认 HEAD；tag 解析到 commit），可用 paths 缩小范围。拒绝范围及非 commit 对象。
 - log：紧凑且有界的提交列表（默认 20 条，最多 50 条）。
 
-GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、external diff、textconv、内容 filter、optional locks、fsmonitor 和子模块遍历。LFS 等 filter 文件显示原始工作区字节，子模块状态需单独检查。拒绝以 "-" 开头的 revision 与路径；结果明确标识是否截断。`,
+GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、external diff、textconv、内容 filter、optional locks、fsmonitor 和子模块遍历。LFS 等 filter 文件显示原始工作区字节，子模块状态需单独检查。拒绝以 "-" 开头的 revision 与路径；结果明确标识是否截断；Git 失败、超时及捕获上限终止返回含有界诊断的错误。`,
   },
   parameters: {
     type: 'object',
@@ -224,7 +278,7 @@ GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、e
       operation: { type: 'string', enum: ['status', 'diff', 'show', 'log'] },
       base: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'diff only; empty/omitted means working-tree changes against HEAD' },
       head: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'diff only; requires base, empty/omitted defaults to HEAD' },
-      revision: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'show/log only; empty/omitted defaults to HEAD' },
+      revision: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'show/log only; empty/omitted defaults to HEAD. show requires a single commit, not a range/tree/blob' },
       paths: {
         type: 'array',
         maxItems: MAX_PATHS,
@@ -241,7 +295,9 @@ GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、e
   async execute(input, ctx) {
     const built = buildGitReadArgs(input);
     if (built.error) return errorOutput(built.error, input?.operation);
+    input = normalizeInput(input);
     const cwd = resolve(ctx?.cwd || process.cwd());
+    let stage = input.operation;
     try {
       const run = ctx?.[RUN_PROCESS_OVERRIDE] || runProcess;
       const startedAt = Date.now();
@@ -250,6 +306,7 @@ GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、e
         signal: ctx?.signal,
         timeoutMs: TIMEOUT_MS,
         maxBytes: MAX_CAPTURE_BYTES,
+        requireExitConfirmation: true,
         env: {
           ...process.env,
           GIT_PAGER: 'cat',
@@ -261,14 +318,54 @@ GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、e
           NO_COLOR: '1',
         },
       };
-      const overrides = await filterOverrides(run, options);
-      const result = await run('git', [...overrides, ...built.args], {
-        ...options, timeoutMs: Math.max(1, TIMEOUT_MS - (Date.now() - startedAt)),
-      });
-      return formatGitReadResult(input.operation, result);
+      const read = (command, args) => {
+        const remaining = TIMEOUT_MS - (Date.now() - startedAt);
+        if (remaining <= 0) {
+          throw Object.assign(new Error('Git read timed out'), { code: 'git_timeout', timedOut: true });
+        }
+        return run(command, args, { ...options, timeoutMs: remaining });
+      };
+      // Only these operations inspect worktree bytes. Object-only reads must
+      // not pay for filter discovery or fail on an unusable worktree filter.
+      const readsWorktree = input.operation === 'status'
+        || (input.operation === 'diff' && input.base === undefined);
+      let overrides = [];
+      if (readsWorktree) {
+        stage = 'filter_inspection';
+        overrides = await filterOverrides(read);
+      }
+      let args = built.args;
+      if (input.operation === 'show') {
+        stage = 'resolve_commit';
+        const resolved = await read('git', [
+          ...COMMON_ARGS, 'rev-parse', '--verify', '--end-of-options', `${input.revision || 'HEAD'}^{commit}`,
+        ]);
+        if (resolved.code !== 0 || resolved.truncated || resolved.timedOut || resolved.terminationError) {
+          return formatGitReadResult(input.operation, resolved, { resolvedCwd: cwd, stage });
+        }
+        const commit = resolved.stdout.trim();
+        if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(commit)) {
+          throw new Error('Expected exactly one resolved commit object ID');
+        }
+        args = buildGitReadArgs({ ...input, revision: commit }).args;
+      }
+      stage = input.operation;
+      const result = await read('git', [...overrides, ...args]);
+      return formatGitReadResult(input.operation, result, { resolvedCwd: cwd, stage });
     } catch (error) {
       if (error?.name === 'AbortError') throw error;
-      return JSON.stringify({ error: `GitRead failed: ${error?.message || String(error)}`, resolvedCwd: cwd });
+      if (error?.result) {
+        return formatGitReadResult(input.operation, error.result, { resolvedCwd: cwd, stage });
+      }
+      return boundedFailure({
+        error: 'GitRead failed', errorEffect: 'none',
+        code: error?.name === 'ProcessTerminationError' ? 'git_exit_unconfirmed'
+          : error?.code === 'git_timeout' ? 'git_timeout'
+            : stage === 'filter_inspection' ? 'git_filter_inspection_failed' : 'git_execution_error',
+        operation: input.operation, stage, resolvedCwd: cwd,
+        ...(error?.timedOut ? { timedOut: true } : {}),
+        ...(error?.name === 'ProcessTerminationError' ? { terminationConfirmed: false } : {}),
+      }, error?.message || String(error));
     }
   },
 });

package/yeaft/work-center/bridge.js

@@ -20,7 +20,7 @@ let shutdownPromise = null;
 let serviceFactory = null;
 
 const BROWSER_DETAIL_OPS = new Set([
-  'get', 'create', 'update', 'start', 'cancel', 'resume', 'post_work_item_message', 'action_input', 'retry_action', 'guide', 'retry',
+  'get', 'create', 'update', 'start', 'cancel', 'resume', 'extend_budget', 'post_work_item_message', 'action_input', 'retry_action', 'guide', 'retry',
 ]);
 const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_requests', 'get_action_request']);
 // `files` is an internal server-to-Agent field. The browser relay rejects any
@@ -39,7 +39,8 @@ const BROWSER_FILE_FIELDS = Object.freeze({
   ],
   action_input: ['id', 'text', 'actionId', 'revision', 'generation', 'quote', 'files'],
   retry_action: ['id', 'actionId', 'revision', 'generation'],
-  resume: ['id', 'revision'],
+  resume: ['id', 'revision', 'executionControlRevision'],
+  extend_budget: ['id', 'executionControlRevision', 'additions'],
   delete: ['id', 'revision'],
   guide: ['id', 'guidance', 'actionId', 'revision', 'generation', 'files'],
   get_action_messages: ['id', 'actionId', 'generation', 'cursor', 'limit'],

package/yeaft/work-center/capabilities.js

@@ -0,0 +1,44 @@
+/**
+ * Work Center reuses builtin tool implementations, but owns their lifecycle.
+ * Keep the executable subset and the Coordinator's capability description in
+ * one place. This is a host policy, not a claim that shell/MCP is sandboxed.
+ */
+export const WORK_ITEM_TOOL_NAMES = Object.freeze([
+  'FileRead', 'FileWrite', 'FileEdit', 'ApplyPatch', 'Glob', 'Grep',
+  'ListDir', 'Bash', 'WebSearch', 'WebFetch', 'ViewImage', 'Skill',
+]);
+
+export function workItemBuiltinToolNames(hasAttachments = false) {
+  return WORK_ITEM_TOOL_NAMES.filter(name => !hasAttachments || name !== 'Bash');
+}
+
+/** Only identities/roles needed for assignment, never VP souls or credentials. */
+export function workItemCapabilityContext(vps = [], { hasAttachments = false } = {}) {
+  const bounded = (value, limit) => typeof value === 'string' ? value.slice(0, limit) : '';
+  const selected = [];
+  for (const vp of vps.slice(0, 48)) {
+    // An id must round-trip to the registry; never offer a truncated identity.
+    if (typeof vp.id !== 'string' || !vp.id || vp.id.length > 128) continue;
+    const candidate = {
+      id: vp.id,
+      name: bounded(vp.name, 120),
+      role: bounded(vp.role, 200),
+      traits: (Array.isArray(vp.traits) ? vp.traits : []).slice(0, 8).map(value => bounded(value, 80)),
+    };
+    if (Buffer.byteLength(JSON.stringify([...selected, candidate]), 'utf8') > 8 * 1024) break;
+    selected.push(candidate);
+  }
+  return {
+    executor: 'yeaft-engine',
+    tools: workItemBuiltinToolNames(hasAttachments),
+    vps: selected,
+    omittedVpCount: Math.max(0, vps.length - selected.length),
+    mcp: 'Workspace-configured MCP tools are resolved by the executor. Availability and authorization must be verified, not inferred from a VP name.',
+    limitations: [
+      'No unmanaged background jobs, recursive sub-agents, or Session transcript access.',
+      'VP roles provide expertise, not missing tools, credentials, permissions, or external environments.',
+      'Use one Action for local investigation, implementation and tests when no independent boundary is needed.',
+      'Missing permission or an unavailable required capability is a blocker, not a reason to create more roles.',
+    ],
+  };
+}

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

@@ -14,20 +14,28 @@ export function normalizeContractPatch(value) {
     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');
+    if (!['response', 'workspace_files', 'pull_request', 'merge'].includes(value.deliveryTarget)) {
+      throw new Error('contractPatch.deliveryTarget must be response, workspace_files, pull_request, or merge');
     }
     patch.deliveryTarget = value.deliveryTarget;
   }
   return Object.keys(patch).length > 0 ? patch : null;
 }
 
+// Reject even falsy/raw patch fields before normalization can hide an attempted change.
+export function assertCoordinatorContractAuthority(value, userOriginated) {
+  if (userOriginated === true || !value || typeof value !== 'object') return;
+  if (['title', 'goal', 'acceptanceCriteria', 'deliveryTarget'].some(key => Object.hasOwn(value, key))) {
+    throw new Error('Automatic Work Center Coordinator contract and delivery target changes are forbidden; refinement requires a user-originated turn');
+  }
+}
+
 function normalizeAcceptanceChecks(value, criteria) {
   if (!Array.isArray(value) || value.length !== criteria.length) return null;
   const checks = value.map((raw, index) => {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
     const criterion = typeof raw.criterion === 'string' ? raw.criterion.trim() : '';
-    const status = ['passed', 'deferred', 'not_applicable'].includes(raw.status) ? raw.status : '';
+    const status = ['passed', 'failed', 'deferred', 'not_applicable'].includes(raw.status) ? raw.status : '';
     const evidence = typeof raw.evidence === 'string' ? raw.evidence.trim().slice(0, 1_000) : '';
     if (criterion !== criteria[index] || !status || !evidence) return null;
     return { criterion, status, evidence };

package/yeaft/work-center/controller.js

@@ -176,6 +176,13 @@ export class WorkflowController {
     return this.store.getWorkItemDetail(id);
   }
 
+  extendBudget(id, input = {}) {
+    if (!Number.isSafeInteger(input.executionControlRevision)) {
+      throw new Error('executionControlRevision is required to extend execution budget');
+    }
+    return this.store.extendExecutionBudget(id, input.executionControlRevision, input.additions || {});
+  }
+
   resume(id, input = {}) {
     const revision = Number(input.revision);
     if (!Number.isInteger(revision) || revision < 1) {
@@ -195,7 +202,7 @@ export class WorkflowController {
           renderSessionContextSnapshot(workItem.sessionContext),
         ),
       };
-    });
+    }, input.executionControlRevision);
     if (!detail) throw new Error(`WorkItem not found: ${id}`);
     return detail;
   }

package/yeaft/work-center/coordinator.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { resolveMaxOutputTokens } from '../models.js';
+import { callCoordinatorWithResourceControl } from './resource-control.js';
 import { normalizeSessionMessageQuote, sessionMessageQuotePrompt } from '../session-message-quote.js';
 import {
   LLMAuthError,
@@ -8,8 +9,9 @@ import {
   LLMServerError,
 } from '../llm/adapter.js';
 import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
-import { normalizeContractPatch } from './completion-contract.js';
+import { assertCoordinatorContractAuthority, normalizeContractPatch } from './completion-contract.js';
 import { normalizeOutputs } from './evidence.js';
+import { deriveGoalProgress } from './goal-state.js';
 import {
   normalizeDynamicActionClosures,
   prepareDynamicActionMutation,
@@ -19,6 +21,7 @@ import { applyCoordinatorReplan } from './plan-mutation.js';
 import { buildWorkItemAttachmentContext } from './attachments.js';
 import { sanitizeDiagnosticText } from './debug-projection.js';
 import { generatedActionGraphRules } from './workflow.js';
+import { workItemCapabilityContext } from './capabilities.js';
 
 const COORDINATOR_MAX_REPLY_CHARS = 8_000;
 const COORDINATOR_MAX_INSTRUCTION_CHARS = 8_000;
@@ -184,7 +187,7 @@ const COORDINATOR_SYSTEM_PROMPT = `You are the Work Center Coordinator. The user
 
 Your responsibilities:
 - Explain the current WorkItem state and blockers in plain language.
-- Keep the WorkItem title, goal, acceptance criteria, and unfinished Action graph aligned with the user's latest intent.
+- Change title, goal, acceptance criteria, or delivery target only in an explicit user-originated refinement turn. Automatic advance/recovery must preserve the user contract and address its gaps, never relax it.
 - Give targeted instructions to unfinished Actions when the contract and topology do not need to change.
 - Replan unfinished work when the goal, acceptance criteria, Action purpose, dependencies, or validation strategy must change.
 - Preserve completed Action history. Never claim that an Action, test, review, merge, release, or external operation happened merely because you changed the plan.
@@ -237,14 +240,17 @@ Return exactly one JSON object and no surrounding prose:
 
 Rules:
 - answer: explain state only. Never use it for an automatic advance trigger.
+- Never mutate title, goal, acceptanceCriteria, or deliveryTarget during automatic advance/recovery. contractPatch is allowed only for explicit user-originated refinement, never to make existing evidence pass. For an older WorkItem with no acceptance criteria, request_human to establish its completion condition before commissioning new work.
 - 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.
+- A missing skill/capability label is not a missing execution capability. Prefer an existing VP with a task-specific brief. Missing tools, credentials, or authorization require request_human; never expand roles as a workaround. create_vp is only appropriate when creating a persistent role is itself an explicit user deliverable.
 - 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: 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.
+- 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 a response/report, workspace files, PR, or merge when the contract does not already say. After the user answers, persist it with contractPatch.deliveryTarget = response | 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.
+- Action templates are reusable capabilities, not a prescribed workflow. A simple Action includes its local tools and necessary tests; do not impose research/design/implement/test/review/deliver stages.
+- Read goalProgress.remainingCriteria, delivery, and blockers first. Resource limits are shared by coordination and all execution, including retries; reserve enough for verification and delivery. Never create a new Action or role merely to evade an exhausted attempt limit. Each new Action must close a concrete current gap. Prefer optional goalRefs: {"criteria":["exact unmet criterion"],"blockerActionIds":["current blocker Action id"],"delivery":false}, plus rationale explaining why this work changes the observed state. Repeating an objective requires goalRefs and a concrete new rationale; do not package already sufficient evidence.
+- response delivery is a substantive answer/report in a canonical completed Run summary with evidence and valid checks; do not invent a file, PR, or extra delivery Action.
 - Never return destructive cancellation. The user owns the explicit cancel control.`;
 
 function coordinatorSystemPrompt(language, detail) {
@@ -438,6 +444,8 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
   const source = parsed?.decision && typeof parsed.decision === 'object' && !Array.isArray(parsed.decision)
     ? parsed.decision
     : {};
+  const automatic = options.automatic === true || (options.recovery === true && options.userOriginated !== true);
+  assertCoordinatorContractAuthority(source.contractPatch, !automatic && options.userOriginated !== false);
   const dynamic = isDynamicWorkItem(detail);
   const allowedKinds = dynamic
     ? (options.automatic === true
@@ -474,9 +482,6 @@ 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,
@@ -505,9 +510,6 @@ 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');
@@ -530,6 +532,7 @@ export function normalizeCoordinatorResponse(value, detail, options = {}) {
         actions: detail.actions || [],
         decision,
         availableVpIds: options.availableVpIds,
+        automatic,
       }),
     };
   }
@@ -583,7 +586,7 @@ function finalizedCriteria(detail, contractPatch) {
   return criteria;
 }
 
-function coordinatorSnapshot(detail) {
+export function coordinatorSnapshot(detail) {
   const runs = Array.isArray(detail.runs) ? detail.runs : [];
   const canonicalRunByAction = new Map();
   for (const action of detail.actions || []) {
@@ -655,8 +658,25 @@ function coordinatorSnapshot(detail) {
     throw new Error('Active Actions cannot be represented within the Coordinator snapshot budget');
   }
 
+  const progress = deriveGoalProgress(detail);
+  const goalProgress = {
+    contractRevision: progress.contractRevision,
+    completedCriteriaCount: progress.completedCriteriaCount,
+    totalCriteriaCount: progress.totalCriteriaCount,
+    remainingCriteria: boundedJsonArray(progress.remainingCriteria.map(value => truncateUtf8(value, 768)), 2 * 1024),
+    delivery: { ...progress.delivery, evidenceRunIds: progress.delivery.evidenceRunIds.slice(0, 24) },
+    criteria: boundedJsonArray(progress.criteria.map(item => ({ ...item,
+      criterion: truncateUtf8(item.criterion, 768), evidenceRunIds: item.evidenceRunIds.slice(0, 24),
+      ...(item.conflictingRunIds ? { conflictingRunIds: item.conflictingRunIds.slice(0, 24) } : {}),
+    })), 2 * 1024),
+    blockers: boundedJsonArray(progress.blockers.map(item => ({ ...item, reason: truncateUtf8(item.reason, 384) })), 1 * 1024),
+  };
+  goalProgress.omittedCriteriaCount = progress.criteria.length - goalProgress.criteria.length;
+  goalProgress.omittedRemainingCriteriaCount = progress.remainingCriteria.length - goalProgress.remainingCriteria.length;
+  goalProgress.omittedBlockerCount = progress.blockers.length - goalProgress.blockers.length;
   return {
     workItem,
+    goalProgress,
     actions,
     omittedCompletedActionCount: Math.max(0, completed.length - actions.filter(action => ['completed', 'closed'].includes(action.status)).length),
     conversation: coordinatorHistory(detail.messages),
@@ -772,7 +792,8 @@ export class WorkItemCoordinator {
       : detail?.actions?.find(candidate => (
           candidate.id === detail.currentActionId && candidate.status === 'failed'
         ));
-    if (!detail || ['done', 'cancelled'].includes(detail.status) || action?.status !== 'failed') return null;
+    if (!detail || ['done', 'cancelled'].includes(detail.status) || action?.status !== 'failed'
+        || !this.store.canAutomaticallyCoordinate(id)) return null;
     const started = this.store.beginCoordinatorTurn(id, '', {
       revision: detail.revision,
       planRevision: detail.planRevision,
@@ -896,7 +917,10 @@ export class WorkItemCoordinator {
           try {
             let result;
             try {
-              const latestMessage = `Current WorkItem snapshot:\n${snapshotText}\n\n${recovery ? 'Automatic failure recovery trigger' : 'Latest user message'}:\n${text}${attachmentContext.promptBlock}${correction}`;
+              const capabilities = JSON.stringify(workItemCapabilityContext(vps, {
+                hasAttachments: started.detail.attachments?.length > 0,
+              }));
+              const latestMessage = `Available execution capabilities (role metadata is descriptive, not authorization):\n${capabilities}\n\nCurrent WorkItem snapshot:\n${snapshotText}\n\n${recovery ? 'Automatic failure recovery trigger' : 'Latest user message'}:\n${text}${attachmentContext.promptBlock}${correction}`;
               const content = attachmentContext.promptParts.length > 0
                 ? [{ type: 'text', text: latestMessage }, ...attachmentContext.promptParts]
                 : latestMessage;
@@ -925,15 +949,9 @@ export class WorkItemCoordinator {
                 result = providerTurn.response;
               } else {
                 result = await Promise.race([
-                runtime.adapter.call({
+                callCoordinatorWithResourceControl(runtime.adapter, this.store, providerTurn, claim, {
                   ...requestBody,
                   signal: abortController.signal,
-                  onRequestStart: () => {
-                    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, claim,
@@ -956,6 +974,7 @@ export class WorkItemCoordinator {
             normalized = normalizeCoordinatorResponse(result?.text, started.detail, {
               recovery,
               automatic: started.fence.automatic === true,
+              userOriginated: started.fence.userOriginated === true,
               recoveryActionId: started.fence.recovery?.actionId || null,
               availableVpIds: vps.map(vp => vp.id),
             });
@@ -1037,12 +1056,14 @@ export class WorkItemCoordinator {
         : recovery ? 'coordinator.recovery_completed' : 'coordinator.turn_completed', detail);
       return detail;
     } catch (error) {
+      if (providerTurn) this.store.settleCoordinatorRequest(providerTurn.id, null, false);
       if (providerTurn?.status === 'responded') {
         this.store.rejectCoordinatorProviderTurn(providerTurn.id, error, started.fence.claim);
       }
       const detail = this.store.failCoordinatorTurn(started.turnId, error, {
         ...started.fence,
         speaker,
+        interrupted: abortController.signal.aborted || this.shuttingDown,
       });
       if (detail) {
         options.onUpdate?.('coordinator.turn_failed', detail);