@yeaft/webchat-agent 1.0.246 → 1.0.248

package/yeaft/work-center/workflow.js

@@ -303,6 +303,7 @@ export function defaultWorkCenterSettings() {
     defaultWorkDir: '',
     globalInstructions: '',
     modelPolicy: { mode: 'inherit', model: null, effort: null },
+    coordinatorModelPolicy: { mode: 'inherit', model: null, effort: 'high' },
     actionModelPolicies: normalizeActionModelPolicies(),
     actionInstructions: normalizeActionInstructions(),
     workflows: [normalizeWorkflowDefinition({
@@ -341,6 +342,9 @@ export function normalizeWorkCenterSettings(value) {
     defaultWorkDir: typeof source.defaultWorkDir === 'string' ? source.defaultWorkDir.trim() : '',
     globalInstructions: normalizeGlobalInstructions(source.globalInstructions),
     modelPolicy: normalizeModelPolicy(source.modelPolicy || migratedModelPolicy),
+    coordinatorModelPolicy: normalizeModelPolicy(
+      source.coordinatorModelPolicy || { ...(source.modelPolicy || migratedModelPolicy), effort: 'high' },
+    ),
     actionModelPolicies: normalizeActionModelPolicies(source.actionModelPolicies, source.modelPolicy || migratedModelPolicy),
     actionInstructions: normalizeActionInstructions(source.actionInstructions || migratedInstructions),
     workflows,
@@ -373,7 +377,7 @@ export function resolvePlanningWorkflowSnapshot(settings, requestedWorkItemType
   const typeInstruction = requestedType
     ? `The user explicitly selected workItemType "${requestedType}". Keep that exact type.`
     : 'Infer one specific workItemType from the contract.';
-  const triageInstruction = `${normalized.actionInstructions.triage}\n\n${typeInstruction}\nReference workflow catalog:\n${catalog || '(none)'}\nUse the catalog only to understand established task categories and sequencing patterns. Always submit the smallest reliable graph of 1 to 8 task-specific Actions; never omit Actions or copy template brief text. The scheduler can run up to ${normalized.maxConcurrentActions} Actions concurrently. Before submitting, compare each pair of Actions and add a dependency only when one consumes a concrete result or side effect of the other; ordering by narrative, phase name, or list position is not a dependency. Split independent analysis, verification, and repository changes into sibling Actions so the scheduler can use that concurrency. Use workspaceMode read only for Actions guaranteed not to mutate files, Git state, services, or external systems; use isolated-write for independent Git changes, integrate for an integrate Action that combines isolated-write dependencies, and shared for serial side effects. If any Action uses isolated-write, add exactly one Action with type integrate and workspaceMode integrate; it must depend directly on every isolated-write Action, and all later Actions must depend on the integration result rather than an isolated-write Action. Non-Git or dirty workspaces are serialized automatically; do not fake parallelism by marking a mutating Action as read. Every generated Action must state objective, approach, expectedOutcome, capability, dependencies, and workspaceMode. The objective, approach, and expectedOutcome must be specific to this WorkItem and that Action: describe the concrete work, the repository-aware execution method, and the verifiable result that will guide the executor. Generic Action-type boilerplate is invalid. Add only Actions required by this task. Do not copy a generic workflow.`;
+  const triageInstruction = `${normalized.actionInstructions.triage}\n\n${typeInstruction}\nReference workflow catalog:\n${catalog || '(none)'}\nUse the catalog only to understand established task categories and sequencing patterns. Always submit the smallest reliable graph of 1 to 8 task-specific Actions; never omit Actions or copy template brief text. Every graph must end in exactly one final acceptance gate: normally one deliver Action, or one terminal review when no delivery operation is required. The final gate must be the unique graph sink and every other Action must be its transitive dependency, so final acceptance cannot run before required evidence. The scheduler can run up to ${normalized.maxConcurrentActions} Actions concurrently. Before submitting, compare each pair of Actions and add a dependency only when one consumes a concrete result or side effect of the other; ordering by narrative, phase name, or list position is not a dependency. Split independent analysis, verification, and repository changes into sibling Actions so the scheduler can use that concurrency. Use workspaceMode read only for Actions guaranteed not to mutate files, Git state, services, or external systems; use isolated-write for independent Git changes, integrate for an integrate Action that combines isolated-write dependencies, and shared for serial side effects. If any Action uses isolated-write, add exactly one Action with type integrate and workspaceMode integrate; it must depend directly on every isolated-write Action, and all later Actions must depend on the integration result rather than an isolated-write Action. Non-Git or dirty workspaces are serialized automatically; do not fake parallelism by marking a mutating Action as read. Every generated Action must state objective, approach, expectedOutcome, capability, dependencies, and workspaceMode. The objective, approach, and expectedOutcome must be specific to this WorkItem and that Action: describe the concrete work, the repository-aware execution method, and the verifiable result that will guide the executor. Generic Action-type boilerplate is invalid. Add only Actions required by this task. Do not copy a generic workflow.`;
   return normalizeWorkflowDefinition({
     id: 'ai-planned',
     name: 'AI planned',
@@ -426,6 +430,40 @@ export function resolveWorkflowSnapshot(settings, workflowId, stageOverrides = {
   });
 }
 
+export function validateGeneratedCompletionGate(stages) {
+  const deliverStages = stages.filter(stage => stage.type === 'deliver');
+  if (deliverStages.length > 1) {
+    throw new Error('AI-planned graph requires exactly one final acceptance gate; multiple deliver Actions are not allowed');
+  }
+  const dependents = new Map(stages.map(stage => [stage.id, []]));
+  for (const stage of stages) {
+    for (const dependencyId of stage.dependsOnStageIds || []) {
+      dependents.get(dependencyId)?.push(stage.id);
+    }
+  }
+  const sinks = stages.filter(stage => (dependents.get(stage.id) || []).length === 0);
+  const gate = deliverStages[0]
+    || (sinks.length === 1 && sinks[0].type === 'review' ? sinks[0] : null);
+  if (!gate) {
+    throw new Error('AI-planned graph requires one final deliver Action or one terminal review Action');
+  }
+  if (sinks.length !== 1 || sinks[0].id !== gate.id) {
+    throw new Error(`AI-planned final acceptance gate "${gate.id}" must be the unique graph sink`);
+  }
+  const byId = new Map(stages.map(stage => [stage.id, stage]));
+  const ancestors = new Set();
+  const visit = stageId => {
+    if (ancestors.has(stageId)) return;
+    ancestors.add(stageId);
+    for (const dependencyId of byId.get(stageId)?.dependsOnStageIds || []) visit(dependencyId);
+  };
+  visit(gate.id);
+  const uncovered = stages.filter(stage => !ancestors.has(stage.id)).map(stage => stage.id);
+  if (uncovered.length > 0) {
+    throw new Error(`AI-planned final acceptance gate "${gate.id}" does not cover Actions: ${uncovered.join(', ')}`);
+  }
+}
+
 export function applyGeneratedPlan(workItem, rawPlan, options = {}) {
   const source = workflowFrom(workItem);
   const forceGraph = options.forceGraph !== false;
@@ -587,6 +625,7 @@ export function applyGeneratedPlan(workItem, rawPlan, options = {}) {
       throw new Error(`AI-planned Action "${stage.id}" must consume isolated writes through integration`);
     }
   }
+  validateGeneratedCompletionGate(generated);
   return normalizeWorkflowDefinition({
     ...source,
     executionMode: forceGraph ? 'graph' : source.executionMode,
@@ -675,16 +714,47 @@ function renderContext(context = []) {
 
 export function actionInstruction(stage, workItem, context = [], sessionContextBlock = renderSessionContextSnapshot(workItem?.sessionContext)) {
   const criteria = (workItem.acceptanceCriteria || []).map(item => `- ${item}`).join('\n') || '- No explicit criteria';
-  const workItemMessages = Array.isArray(workItem.messages) && workItem.messages.length > 0
-    ? `\n\nWorkItem-level user messages (apply to every unfinished Action):\n${workItem.messages.map(message => `- ${message.text}`).join('\n')}`
-    : '';
-  const common = `WorkItem: ${workItem.title}\nGoal: ${workItem.goal}\nAcceptance criteria:\n${criteria}${sessionContextBlock}${workItemMessages}${renderContext(context)}`;
+  const common = `WorkItem: ${workItem.title}\nGoal: ${workItem.goal}\nAcceptance criteria:\n${criteria}${sessionContextBlock}${renderContext(context)}`;
   const policy = stage.instruction || defaultWorkCenterStageInstruction(stage.type);
   const brief = normalizeActionBrief(stage.brief || stage, stage.type);
   const contract = `Action type: ${stage.type}\nWhat to do:\n${brief.objective}\n\nHow to do it:\n${brief.approach}\n\nExpected result:\n${brief.expectedOutcome}`;
   return `${common}\n\n${policy}\n\n${contract}`;
 }
 
+export function withoutActionInputContext(context, preserveInputIds = []) {
+  const preserved = new Set((Array.isArray(preserveInputIds) ? preserveInputIds : []).filter(Boolean));
+  return (Array.isArray(context) ? context : []).filter(entry => (
+    entry?.type !== 'input' || (entry.inputId && preserved.has(entry.inputId))
+  ));
+}
+
+export function canonicalActionInstruction(workItem, action, context = action?.context || []) {
+  const workflowSnapshot = workItem?.workflowSnapshot || null;
+  const workflowStage = (Array.isArray(workflowSnapshot?.stages) ? workflowSnapshot.stages : [])
+    .find(stage => stage?.id === action?.stageId)
+    || (Array.isArray(workflowSnapshot?.stages) ? workflowSnapshot.stages : [])
+      .find(stage => stage?.type === action?.type)
+    || null;
+  const actionInstructions = workflowSnapshot?.actionInstructions;
+  const policyInstruction = actionInstructions && Object.hasOwn(actionInstructions, action?.type)
+    ? actionInstructions[action.type]
+    : actionInstructions?.custom;
+  const stage = {
+    ...(workflowStage || {}),
+    id: action?.stageId || workflowStage?.id || action?.type,
+    type: action?.type || workflowStage?.type || 'custom',
+    instruction: workflowStage?.instruction || policyInstruction || '',
+    brief: action?.brief || workflowStage?.brief || workflowStage || null,
+    assignmentPolicy: action?.assignmentPolicy,
+    modelPolicy: action?.modelPolicy,
+    dependsOnStageIds: action?.dependsOnStageIds,
+    workspaceMode: action?.workspaceMode,
+    changesRequestedStageId: action?.changesRequestedStageId,
+    maxAttempts: action?.maxAttempts,
+  };
+  return actionInstruction(stage, workItem, context);
+}
+
 export function actionForStage(stage, workItem, context = []) {
   return {
     type: stage.type,