@yeaft/webchat-agent 1.0.412 → 1.0.414

package/yeaft/work-center/projection.js

@@ -7,6 +7,7 @@ import {
   sanitizeDiagnosticText,
 } from './debug-projection.js';
 import { runMatchesActionIdentity } from './action-identity.js';
+import { normalizeOutputs } from './evidence.js';
 import { taskSpecificActionBrief } from './workflow.js';
 import { buildMainlineProjection } from './mainline-projection.js';
 
@@ -60,7 +61,7 @@ function projectCurrentActionSummary(action, projectedAction = action) {
   };
 }
 
-const BOARD_ACTION_STATUSES = ['completed', 'running', 'ready', 'waiting', 'failed'];
+const BOARD_ACTION_STATUSES = ['completed', 'closed', 'running', 'ready', 'waiting', 'failed'];
 
 function boardActionCounts(actions) {
   const counts = Object.fromEntries(BOARD_ACTION_STATUSES.map(status => [status, 0]));
@@ -610,6 +611,8 @@ function projectAction(action, runs, events, includeBody = true) {
     requiredRole: action.requiredRole || '',
     generation: Math.max(1, count(action.generation) || 1),
     replacesActionId: action.replacesActionId || null,
+    closeReason: action.closeReason || null,
+    closedAt: count(action.closedAt),
     brief: projectedBrief,
     status: action.status,
     assignedVp,
@@ -784,14 +787,17 @@ function sanitizeMainlineDiagnostic(value, maxBytes) {
     .replace(/(?<![:/])\/(?:[^/\s"'<>]+\/)*[^/\s"'<>]+/g, '[path redacted]');
 }
 
-function projectCanonicalEvidence(value) {
+function projectCanonicalEvidence(value, options = {}) {
   if (!Array.isArray(value)) return [];
   return value.slice(0, 20).map(item => {
     if (typeof item === 'string') return sanitizeMainlineDiagnostic(item, 1_000);
     if (!item || typeof item !== 'object') return null;
     const projected = {};
     for (const key of ['kind', 'label', 'ref', 'status']) {
-      if (typeof item[key] === 'string') projected[key] = sanitizeMainlineDiagnostic(item[key], 1_000);
+      if (typeof item[key] !== 'string') continue;
+      projected[key] = options.preserveRef === true && key === 'ref'
+        ? truncateUtf8(item[key], 1_000)
+        : sanitizeMainlineDiagnostic(item[key], 1_000);
     }
     return Object.keys(projected).length > 0 ? projected : null;
   }).filter(Boolean);
@@ -810,7 +816,7 @@ function projectMainlineBrowser(detail) {
   const attentionActionIds = Array.isArray(detail.attentionActionIds)
     ? detail.attentionActionIds
     : nodes.filter(node => ['waiting', 'failed'].includes(node.status)).map(node => node.id);
-  const counts = Object.fromEntries(['completed', 'running', 'ready', 'waiting', 'failed']
+  const counts = Object.fromEntries(['completed', 'closed', 'running', 'ready', 'waiting', 'failed']
     .map(status => [status, nodes.filter(node => node.status === status).length]));
   return {
     contract: {
@@ -848,6 +854,7 @@ function projectMainlineBrowser(detail) {
           status: result.status,
           summary: sanitizeMainlineDiagnostic(result.summary, MAX_ACTION_DIAGNOSTIC_CHARS),
           evidence: projectCanonicalEvidence(result.evidence),
+          outputs: projectCanonicalEvidence(normalizeOutputs(result.outputs), { preserveRef: true }),
           waitingReason: sanitizeDiagnosticText(result.waitingReason, MAX_ACTION_DIAGNOSTIC_CHARS) || null,
           reviewDecision: typeof result.reviewDecision === 'string'
             ? truncateUtf8(result.reviewDecision, 256) : null,
@@ -859,6 +866,10 @@ function projectMainlineBrowser(detail) {
 
 function waitingReason(detail) {
   if (typeof detail?.waitingReason === 'string') return detail.waitingReason;
+  const coordinatorQuestion = [...(Array.isArray(detail?.messages) ? detail.messages : [])]
+    .reverse().find(message => message?.role === 'assistant'
+      && message?.decision?.kind === 'request_human')?.decision?.question;
+  if (typeof coordinatorQuestion === 'string' && coordinatorQuestion.trim()) return coordinatorQuestion;
   if (detail?.status !== 'waiting') return '';
   const waitingEvent = Array.isArray(detail?.events)
     ? detail.events.find(event => event?.type === 'action.waiting'
@@ -893,6 +904,19 @@ export function projectWorkItemDetail(detail, options = {}) {
     : detail.events;
   const mainline = projectMainlineBrowser(detail);
   const mainlineActionById = new Map((mainline?.actions || []).map(action => [action.id, action]));
+  const canonicalOutputs = [];
+  const seenOutputs = new Set();
+  const runById = new Map((Array.isArray(detail.runs) ? detail.runs : []).map(run => [run.id, run]));
+  for (const action of Array.isArray(detail.actions) ? detail.actions : []) {
+    const run = action?.resultRunId ? runById.get(action.resultRunId) : null;
+    if (!run || run.status !== 'completed') continue;
+    for (const output of normalizeOutputs(run.outputs)) {
+      const key = `${output.kind}\u0000${output.ref}`;
+      if (seenOutputs.has(key)) continue;
+      seenOutputs.add(key);
+      canonicalOutputs.push({ ...output, actionId: action.id, runId: run.id });
+    }
+  }
   const projected = {
     id: detail.id,
     revision: detail.revision,
@@ -900,6 +924,11 @@ export function projectWorkItemDetail(detail, options = {}) {
     ledgerRevision: count(detail.ledgerRevision),
     coordinatorRevision: count(detail.coordinatorRevision),
     coordinationMode: detail.coordinationMode || 'legacy',
+    outputs: canonicalOutputs.slice(0, 50).map(output => ({
+      ...projectCanonicalEvidence([output], { preserveRef: true })[0],
+      actionId: truncateUtf8(output.actionId || '', 256) || null,
+      runId: truncateUtf8(output.runId || '', 256) || null,
+    })).filter(output => output.kind && output.label && output.ref),
     finalResult: detail.finalResult && typeof detail.finalResult === 'object' ? {
       summary: truncateUtf8(detail.finalResult.summary || '', MAX_ACTION_MESSAGE_CHARS),
       acceptanceResults: Array.isArray(detail.finalResult.acceptanceResults)
@@ -911,6 +940,15 @@ export function projectWorkItemDetail(detail, options = {}) {
           })) : [],
       evidenceRunIds: Array.isArray(detail.finalResult.evidenceRunIds)
         ? detail.finalResult.evidenceRunIds.map(String).slice(0, 64) : [],
+      outputs: Array.isArray(detail.finalResult.outputs)
+        ? detail.finalResult.outputs.slice(0, 50).map(rawOutput => {
+            const output = normalizeOutputs([rawOutput])[0];
+            if (!output) return null;
+            return {
+              ...projectCanonicalEvidence([output], { preserveRef: true })[0],
+              runId: truncateUtf8(rawOutput?.runId || '', 256) || null,
+            };
+          }).filter(output => output?.kind && output.label && output.ref) : [],
       residualRisks: Array.isArray(detail.finalResult.residualRisks)
         ? detail.finalResult.residualRisks
           .map(risk => truncateUtf8(risk, MAX_ACTION_MESSAGE_CHARS)).slice(0, 24) : [],
@@ -933,6 +971,8 @@ export function projectWorkItemDetail(detail, options = {}) {
       ? sumExecutionStats(detail.runs)
       : executionStats(detail.executionStats),
     reuseMemory: detail.reuseMemory !== false,
+    deliveryTarget: ['workspace_files', 'pull_request', 'merge'].includes(detail.deliveryTarget)
+      ? detail.deliveryTarget : null,
     waitingReason: sanitizeDiagnosticText(waitingReason(detail), MAX_ACTION_DIAGNOSTIC_CHARS),
     failureReason: workItemFailureReason(detail),
 
@@ -955,6 +995,7 @@ export function projectWorkItemDetail(detail, options = {}) {
           .includes(message.decision.kind)
           ? message.decision.kind : null,
         reason: truncateUtf8(message.decision.reason || '', MAX_ACTION_DIAGNOSTIC_CHARS),
+        question: truncateUtf8(message.decision.question || '', MAX_ACTION_DIAGNOSTIC_CHARS) || null,
         changedContract: message.decision.changedContract === true,
         affectedActionIds: Array.isArray(message.decision.affectedActionIds)
           ? message.decision.affectedActionIds.map(id => String(id)).slice(0, 8) : [],

package/yeaft/work-center/runner.js

@@ -4,6 +4,8 @@ import { defineTool } from '../tools/types.js';
 import { allTools } from '../tools/index.js';
 import { parsePatch } from '../tools/apply-patch.js';
 import { defaultRegistry } from '../vp/registry.js';
+import { createVp } from '../vp/vp-crud.js';
+import { loadVpFromDir } from '../vp/vp-store.js';
 import { createTrace } from '../debug-trace.js';
 import { isPathInsideOrEqual } from '../tools/path-safety.js';
 import { resolveWorkItemModel, selectWorkItemVp } from './assignment.js';
@@ -41,7 +43,7 @@ import {
   MAX_REPLAN_ADDED_ACTIONS,
 } from './plan-mutation.js';
 import { normalizeContractPatch, validateCompletedResult } from './completion-contract.js';
-import { normalizeEvidence } from './evidence.js';
+import { normalizeEvidence, normalizeOutputs } from './evidence.js';
 import {
   MAINLINE_CONTEXT_HARD_LIMIT_BYTES,
   buildMainlineContextSnapshot,
@@ -268,18 +270,18 @@ function assertToolInput(toolName, input, workDir, attachmentFiles) {
   return next;
 }
 
-export function workItemToolPolicySnapshot(workDir, attachmentRefs = [], mcpToolNames = []) {
+export function workItemToolPolicySnapshot(workDir, attachmentRefs = [], extraToolNames = []) {
   const hasAttachments = attachmentRefs.length > 0;
   const builtInTools = WORK_ITEM_TOOL_NAMES.filter(name => !hasAttachments || name !== 'Bash');
   return {
     policyVersion: 1,
-    allowedToolNames: [...builtInTools, ...mcpToolNames],
+    allowedToolNames: [...builtInTools, ...extraToolNames],
     readRoots: [workDir],
     attachmentRefs,
     writeRoots: [workDir],
     shell: { enabled: !hasAttachments, fixedCwd: workDir, background: false, sandboxed: false },
     async: false,
-    mcpTools: [...mcpToolNames],
+    mcpTools: extraToolNames.filter(name => name.startsWith('mcp__')),
   };
 }
 
@@ -329,6 +331,69 @@ function wrapWorkItemTool(tool, canonicalDir, canonicalAttachmentFiles, isRunAct
   };
 }
 
+export function createWorkItemVpTool({ yeaftDir, registry, isRunActive }) {
+  return defineTool({
+    name: 'CreateWorkItemVp',
+    description: 'Create one persistent specialist VP in this Agent instance after the Coordinator assigned this VP-authoring Action. Use a narrow role and persona for the missing capability; do not clone an existing VP or create a general-purpose replacement.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['vpId', 'displayName', 'role', 'area', 'traits', 'persona'],
+      properties: {
+        vpId: { type: 'string', minLength: 1, maxLength: 64 },
+        displayName: { type: 'string', minLength: 1, maxLength: 120 },
+        displayNameZh: { type: 'string', maxLength: 120 },
+        description: { type: 'string', maxLength: 500 },
+        descriptionZh: { type: 'string', maxLength: 500 },
+        role: { type: 'string', minLength: 1, maxLength: 200 },
+        roleZh: { type: 'string', maxLength: 200 },
+        area: { type: 'string', minLength: 1, maxLength: 64 },
+        traits: { type: 'array', minItems: 1, maxItems: 20, uniqueItems: true, items: { type: 'string', minLength: 1, maxLength: 80 } },
+        modelHint: { type: 'string', enum: ['primary', 'fast'] },
+        persona: { type: 'string', minLength: 1, maxLength: 12_000 },
+      },
+    },
+    async execute(input) {
+      if (!isRunActive()) throw new Error('Work Center Run is no longer active');
+      if (!yeaftDir) throw new Error('Work Center VP creation requires the current Agent data directory');
+      const libDir = path.join(yeaftDir, 'virtual-persons');
+      const { vpId, dir } = createVp(input, {
+        libDir,
+        memoryRoot: path.join(yeaftDir, 'memory'),
+      });
+      const vp = loadVpFromDir(dir);
+      if (!vp) throw new Error(`Created Work Center VP could not be loaded: ${vpId}`);
+      registry?.setVp?.(vp);
+      return JSON.stringify({ created: true, vpId });
+    },
+    isConcurrencySafe: () => false,
+    isReadOnly: () => false,
+    sideEffectScope: 'external',
+  });
+}
+
+function assertCreateVpActionAuthority(workItem, action, registry) {
+  if (action?.type !== 'create_vp') return;
+  if (action.workspaceMode === 'read') {
+    const error = new Error('create_vp Action cannot use read workspace mode because VP creation mutates Agent-global state');
+    error.retryable = false;
+    throw error;
+  }
+  const assignmentPolicy = action.assignmentPolicy;
+  const assignedVpIds = assignmentPolicy?.mode === 'planned'
+    ? assignmentPolicy.candidateVpIds || []
+    : [];
+  if (!isDynamicWorkItem(workItem)
+      || action.creationSource !== 'dynamic_coordinator'
+      || assignedVpIds.length !== 1
+      || !String(assignmentPolicy?.assignmentReason || '').trim()
+      || !registry?.getVp?.(assignedVpIds[0])) {
+    const error = new Error('create_vp Action lacks dynamic Coordinator provenance and one explicit existing VP assignment');
+    error.retryable = false;
+    throw error;
+  }
+}
+
 export function planningVpCatalog(vps) {
   return vps.map(vp => ({
     id: vp.id,
@@ -350,7 +415,7 @@ export function createSubmitWorkItemPlanTool({
 }) {
   const vpCatalog = planningVpCatalog(vps);
   const vpIds = vpCatalog.map(vp => vp.id);
-  const actionTypes = BUILT_IN_ACTION_TYPES.filter(type => type !== 'triage');
+  const actionTypes = BUILT_IN_ACTION_TYPES.filter(type => !['triage', 'create_vp'].includes(type));
   const catalogDescription = `Action types: ${actionTypes.join(', ')}. Available VPs: ${vpCatalog.map(vp => `${vp.id} (${vp.role || vp.area || 'VP'}; ${vp.traits.join(', ') || 'no traits'})`).join('; ')}.`;
   return defineTool({
     name: 'SubmitWorkItemPlan',
@@ -445,7 +510,7 @@ function plannedActionSchema(vpIds, { requireCandidates = true } = {}) {
   if (requireCandidates) required.push('candidateVpIds', 'assignmentReason');
   return { type: 'object', additionalProperties: false, required, properties: {
     id: { type: 'string', minLength: 1, maxLength: 64 }, name: { type: 'string', minLength: 1, maxLength: 120 },
-    type: { type: 'string', enum: BUILT_IN_ACTION_TYPES.filter(type => type !== 'triage') }, capability: { type: 'string', maxLength: 64 },
+    type: { type: 'string', enum: BUILT_IN_ACTION_TYPES.filter(type => !['triage', 'create_vp'].includes(type)) }, capability: { type: 'string', maxLength: 64 },
     objective: { type: 'string', minLength: 1, maxLength: 2_000 }, approach: { type: 'string', minLength: 1, maxLength: 2_000 }, expectedOutcome: { type: 'string', minLength: 1, maxLength: 2_000 },
     candidateVpIds: { type: 'array', minItems: 1, uniqueItems: true, items: { type: 'string', enum: vpIds } }, assignmentReason: { type: 'string', minLength: 1, maxLength: 1_000 },
     dependsOnActionIds: { type: 'array', uniqueItems: true, items: { type: 'string' } }, workspaceMode: { type: 'string', enum: ['read', 'isolated-write', 'integrate', 'shared'] },
@@ -631,6 +696,7 @@ export function parseStructuredResult(text, actionType) {
       outcome: parsed.outcome,
       summary: String(parsed.summary || ''),
       evidence: Array.isArray(parsed.evidence) ? parsed.evidence : [],
+      outputs: normalizeOutputs(parsed.outputs),
       waitingReason: parsed.waitingReason ? String(parsed.waitingReason) : null,
       error: parsed.error ? String(parsed.error) : null,
       reviewDecision: ['approved', 'changes_requested'].includes(parsed.reviewDecision)
@@ -689,10 +755,11 @@ function completionContract(action, workItem) {
   "outcome": "completed|waiting|retryable|failed",
   "summary": "short result",
   "evidence": ["test, PR, file, or other verifiable evidence"],
+  "outputs": [{ "kind": "file|link|pr|commit", "label": "user-facing output name", "ref": "safe relative path for file, safe HTTP(S) URL for link/pr, or commit hash/full refs/... name for commit; never relabel a URL as file/commit" }],
   "acceptanceChecks": ${JSON.stringify(acceptanceChecks)},
   "waitingReason": null,
   "error": null${reviewField}${triageField}${planField}
-}\nFor completed, provide at least one concrete evidence item and exactly one acceptanceChecks entry for every current acceptance criterion, in the same order, with status passed, deferred, or not_applicable and a non-empty evidence reference. Triage must use its proposed criteria when submitting a contractPatch. An intermediate Action may defer criteria outside its task-specific expected result; the final deliver Action, and an approved review with no downstream work, require every criterion to pass. If a criterion is no longer applicable, ask the WorkItem Coordinator to revise the contract instead of pretending it passed. This is a deterministic submission gate, not independent proof: later verification and delivery Actions must verify the claims. A model turn ending is not completion. Use waiting when user or external input is required. Use retryable only for a transient failure. Do not start background jobs or delegate this Action.`;
+}\nFor completed, provide at least one concrete evidence item and exactly one acceptanceChecks entry for every current acceptance criterion, in the same order, with status passed, deferred, or not_applicable and a non-empty evidence reference. Report every user-consumable file, URL, PR, or commit in outputs; evidence proves work, while outputs tell the user where the deliverable is. Triage must use its proposed criteria when submitting a contractPatch. An intermediate Action may defer criteria outside its task-specific expected result; the final deliver Action, and an approved review with no downstream work, require every criterion to pass. If a criterion is no longer applicable, ask the WorkItem Coordinator to revise the contract instead of pretending it passed. This is a deterministic submission gate, not independent proof: later verification and delivery Actions must verify the claims. A model turn ending is not completion. Use waiting when user or external input is required. Use retryable only for a transient failure. Do not start background jobs or delegate this Action.`;
 }
 
 function safeCheckpointUrl(value) {
@@ -1023,6 +1090,7 @@ export class WorkItemRunner {
   }
 
   async run({ workItem, action, run, signal, ownerBootId, onProgress, registerProgressReader, registerInputWake, onEngineEvent = null }) {
+    assertCreateVpActionAuthority(workItem, action, this.registry);
     const runtime = await this.runtimeProvider();
     const currentSettings = ['ai', 'coordinator'].includes(workItem?.workflowSnapshot?.planningMode)
       && this.policyProvider ? await this.policyProvider() : null;
@@ -1106,6 +1174,13 @@ export class WorkItemRunner {
       && workItem?.workflowSnapshot?.planningMode === 'ai'
       && !replanToolEnabled;
     const runTools = [];
+    if (executionAction.type === 'create_vp') {
+      runTools.push(createWorkItemVpTool({
+        yeaftDir: runtime.yeaftDir || this.yeaftDir,
+        registry: this.registry,
+        isRunActive,
+      }));
+    }
     if (planToolEnabled) runTools.push(createSubmitWorkItemPlanTool({
       vps: this.registry.listVps(),
       workItem,

package/yeaft/work-center/service.js

@@ -259,6 +259,12 @@ export class WorkCenterService {
             coordinationMode: DYNAMIC_COORDINATION_MODE,
             executionSchemaVersion: DYNAMIC_EXECUTION_SCHEMA_VERSION,
             workDir,
+            // Creation-time delivery authority comes only from an explicit
+            // browser/user request. Trusted model producers may provide
+            // Session provenance, but cannot grant themselves delivery rights.
+            deliveryTarget: requestContext.userOriginated === true
+              && ['workspace_files', 'pull_request', 'merge'].includes(payload.deliveryTarget)
+              ? payload.deliveryTarget : null,
             reuseMemory: payload.reuseMemory !== false,
             origin: payload.origin && typeof payload.origin === 'object'
               ? {