@yeaft/webchat-agent 1.0.530 → 1.0.532

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

@@ -1,4 +1,6 @@
 import { randomUUID } from 'node:crypto';
+import { assertCoordinatorContractAuthority, normalizeContractPatch } from './completion-contract.js';
+import { deriveGoalProgress } from './goal-state.js';
 import {
   BUILT_IN_ACTION_TYPES,
   MAX_WORK_ITEM_ACTIONS,
@@ -110,7 +112,9 @@ export function prepareDynamicActionMutation({
   actions,
   decision,
   availableVpIds = null,
+  automatic = false,
 }) {
+  assertCoordinatorContractAuthority(decision?.contractPatch, !automatic);
   if (!isDynamicWorkItem(workItem)) {
     throw new Error('Work Center dynamic Action creation requires a Coordinator-driven WorkItem');
   }
@@ -131,10 +135,20 @@ export function prepareDynamicActionMutation({
   if (supersedeActionIds.some(actionId => closeActionIds.has(actionId))) {
     throw new Error('Work Center cannot both close and supersede the same Action');
   }
+  const contractPatch = normalizeContractPatch(decision.contractPatch);
   const effectiveWorkItem = {
     ...workItem,
-    ...(decision.contractPatch || {}),
+    ...(contractPatch || {}),
   };
+  if (contractPatch && ['title', 'goal', 'acceptanceCriteria', 'deliveryTarget']
+    .some(key => JSON.stringify(effectiveWorkItem[key]) !== JSON.stringify(workItem[key]))) {
+    effectiveWorkItem.revision = (Number(workItem.revision) || 1) + 1;
+  }
+  const progress = deriveGoalProgress({ ...effectiveWorkItem, actions });
+  if (progress.totalCriteriaCount > 0 && !progress.remainingCriteria.length
+      && progress.delivery.status === 'passed' && !progress.blockers.length) {
+    throw new Error('Action creation requires an unmet goal condition or blocker; current evidence already supports completion');
+  }
   const createdActions = requested.map((raw, index) => {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
       throw new Error('Work Center Coordinator Action specification must be an object');
@@ -187,6 +201,18 @@ export function prepareDynamicActionMutation({
         throw new Error(`Work Center integrate Action source is not a completed isolated write: ${invalid}`);
       }
     }
+    // Optional refs are persisted inside the existing brief envelope, keeping
+    // historical Actions readable without a schema migration.
+    const goalRefs = normalizeDynamicGoalRefs(raw.goalRefs, effectiveWorkItem, actions);
+    const repeated = actions.some(previous => !['closed', 'superseded', 'cancelled'].includes(previous.status)
+      && previous.type === type && previous.brief?.objective === brief.objective)
+      || requested.slice(0, index).some(previous => previous.type === type && previous.objective?.trim() === brief.objective);
+    const rationale = raw.rationale || (goalRefs ? raw.goalRefs.rationale : '');
+    if (repeated && (!goalRefs || typeof rationale !== 'string' || rationale.trim().length < 20)) {
+      throw new Error('Repeated Action requires goalRefs and a concrete rationale explaining the remaining gap or changed evidence');
+    }
+    if (goalRefs) brief.goalRefs = goalRefs;
+    if (typeof rationale === 'string' && rationale.trim()) brief.rationale = rationale.trim().slice(0, 2_000);
     const action = {
       id,
       type,
@@ -233,11 +259,34 @@ export function prepareDynamicActionMutation({
     createdActions,
     closeActions,
     supersedeActionIds,
-    contractPatch: decision.contractPatch || null,
+    contractPatch,
     workItemType,
   };
 }
 
+/** Optional explicit connection to an unmet criterion, delivery boundary, or blocker. */
+export function normalizeDynamicGoalRefs(value, workItem, actions = []) {
+  if (value == null) return null;
+  if (typeof value !== 'object' || Array.isArray(value)) throw new Error('Action goalRefs must be an object');
+  const criteria = uniqueStrings(value.criteria);
+  const blockerActionIds = uniqueStrings(value.blockerActionIds);
+  const delivery = value.delivery === true;
+  const progress = deriveGoalProgress({ ...workItem, actions });
+  if (!criteria.length && !blockerActionIds.length && !delivery) {
+    throw new Error('Action goalRefs must address an unmet criterion, delivery condition, or blocker');
+  }
+  if (criteria.some(criterion => !progress.remainingCriteria.includes(criterion))) {
+    throw new Error('Action goalRefs references an unknown or already satisfied criterion');
+  }
+  if (blockerActionIds.some(id => !progress.blockers.some(blocker => blocker.actionId === id))) {
+    throw new Error('Action goalRefs references an unknown or resolved blocker');
+  }
+  if (delivery && progress.delivery.status === 'passed') {
+    throw new Error('Action goalRefs references an already satisfied delivery condition');
+  }
+  return { criteria, blockerActionIds, delivery };
+}
+
 function normalizeEvidenceRunIds(value) {
   return uniqueStrings(value);
 }

package/yeaft/work-center/goal-state.js

@@ -0,0 +1,135 @@
+import { normalizeEvidence, normalizeOutputs } from './evidence.js';
+import { runMatchesActionIdentity } from './action-identity.js';
+
+const CHECK_STATUSES = new Set(['passed', 'failed', 'deferred', 'not_applicable']);
+const INACTIVE = new Set(['closed', 'superseded', 'cancelled']);
+const NEGATIVE = new Set(['failed', 'error', 'pending']);
+const revision = value => Math.max(1, Number(value) || 1);
+
+export function validGoalChecks(run, criteria) {
+  return Array.isArray(run?.acceptanceChecks) && run.acceptanceChecks.length === criteria.length
+    && run.acceptanceChecks.every((check, index) => (
+      check?.criterion === criteria[index] && CHECK_STATUSES.has(check.status)
+      && typeof check.evidence === 'string' && check.evidence.trim()
+    ));
+}
+
+export function hasContradictoryEvidence(run) {
+  return !!run?.error || run?.reviewDecision === 'changes_requested'
+    || [...normalizeEvidence(run?.evidence), ...normalizeOutputs(run?.outputs)]
+      .some(item => NEGATIVE.has(item.status));
+}
+
+/**
+ * Read only durable identities, never a model's progress estimate. Older records
+ * use Action.contractRevision when the optional execution manifest is absent.
+ * A completed Run needs its canonical pointer; failed/waiting Actions use their
+ * latest terminal attempt only to report blockers/contradictions, never proof.
+ */
+export function currentGoalRuns(detail) {
+  const runs = Array.isArray(detail?.runs) ? detail.runs : [];
+  const result = [];
+  for (const action of detail?.actions || []) {
+    if (INACTIVE.has(action.status) || action.status === 'running'
+        || revision(action.contractRevision) !== revision(detail.revision)) continue;
+    const owned = runs.filter(run => run.actionId === action.id
+      && (!run.workItemId || run.workItemId === detail.id)
+      && (!action.workItemId || action.workItemId === detail.id)
+      && runMatchesActionIdentity(run, action)
+      && (run.executionManifest?.actionGeneration == null || revision(run.executionManifest.actionGeneration) === revision(action.generation))
+      && (!run.executionManifest?.actionSpecHash || run.executionManifest.actionSpecHash === action.specHash)
+      && revision(run.executionManifest?.contractRevision ?? action.contractRevision) === revision(detail.revision)
+      && revision(run.contextSnapshot?.contract?.revision ?? action.contractRevision) === revision(detail.revision)
+      && ['completed', 'failed', 'waiting'].includes(run.status));
+    const run = action.status === 'completed'
+      ? owned.find(candidate => candidate.id === action.resultRunId && candidate.status === 'completed')
+      : ['failed', 'waiting'].includes(action.status)
+        ? owned.sort((a, b) => Number(b.endedAt || b.startedAt) - Number(a.endedAt || a.startedAt))[0]
+        : null;
+    if (run) result.push(run);
+  }
+  return result;
+}
+
+/** Derived, restart-safe projection; no new database state or migrations. */
+export function deriveGoalProgress(detail) {
+  const contract = Array.isArray(detail?.acceptanceCriteria) ? detail.acceptanceCriteria : [];
+  const runs = currentGoalRuns(detail);
+  const proof = runs.filter(run => run.status === 'completed' && normalizeEvidence(run.evidence).length > 0
+    && !hasContradictoryEvidence(run) && validGoalChecks(run, contract));
+  const byId = new Map((detail?.actions || []).map(action => [action.id, action]));
+  // Retrying, guiding, or closing an Action is not a correction. Keep historical
+  // negative observations until a newer current canonical Run disproves them.
+  // These attempts can invalidate proof but can never establish it.
+  const observations = (detail?.runs || []).filter(run => {
+    const action = byId.get(run.actionId);
+    return action && (!run.workItemId || run.workItemId === detail.id)
+      && (!action.workItemId || action.workItemId === detail.id)
+      && ['completed', 'failed', 'waiting', 'retryable'].includes(run.status)
+      && revision(run.executionManifest?.contractRevision ?? action.contractRevision) === revision(detail.revision)
+      && revision(run.contextSnapshot?.contract?.revision ?? action.contractRevision) === revision(detail.revision);
+  });
+  const observedAt = run => Number(run.endedAt || run.startedAt) || 0;
+  // Subsequent writes can invalidate earlier tests. A later read-only observation
+  // does not invalidate unrelated proof; after a write, re-check the affected
+  // contract rather than completing from a pre-change observation.
+  // Retiring a writer is not rollback. Include historical attempts, including
+  // failed/closed/superseded generations, in the freshness watermark.
+  const writes = (detail?.runs || []).filter(run => {
+    const action = byId.get(run.actionId);
+    return action && (!run.workItemId || run.workItemId === detail.id)
+      && action.workspaceMode && action.workspaceMode !== 'read'
+      && revision(run.executionManifest?.contractRevision ?? action.contractRevision) === revision(detail.revision);
+  });
+  // Ending after another writer is insufficient: tests may have run before its
+  // mutation. Without a durable ordering at equal timestamps, require a new
+  // observation. The writer's own end-to-end proof remains usable.
+  const freshProof = proof.filter(run => writes.every(writer => writer.id === run.id
+    || (Number(run.startedAt) || observedAt(run)) > observedAt(writer)));
+  const contradictions = contract.map((criterion, index) => observations.filter(run => (
+    run.acceptanceChecks?.[index]?.criterion === criterion
+      && (run.acceptanceChecks[index].status === 'failed'
+        || (run.acceptanceChecks[index].status !== 'not_applicable' && hasContradictoryEvidence(run)))
+  )));
+  const latestContradictionAt = contradictions.map(runs => Math.max(-Infinity, ...runs.map(observedAt)));
+  const criteria = contract.map((criterion, index) => {
+    // A correction establishes new proof; it never revives an older disproved
+    // Run. Overlapping/tied observations cannot establish corrective ordering.
+    const passing = freshProof.filter(run => run.acceptanceChecks[index].status === 'passed'
+      && (Number(run.startedAt) || observedAt(run)) > latestContradictionAt[index]);
+    const conflicts = passing.length ? [] : contradictions[index];
+    const evidenceRunIds = passing.map(run => run.id);
+    return {
+      criterion,
+      status: conflicts.length ? 'failed' : evidenceRunIds.length ? 'passed' : 'unmet',
+      evidenceRunIds: conflicts.length ? [] : evidenceRunIds,
+      ...(conflicts.length ? { conflictingRunIds: conflicts.map(run => run.id) } : {}),
+    };
+  });
+  const target = detail?.deliveryTarget || null;
+  const outputKind = { workspace_files: 'file', pull_request: 'pr', merge: 'commit' }[target];
+  const deliveryRunIds = freshProof.filter(run => target === 'response'
+    ? typeof run.summary === 'string' && run.summary.trim()
+      // Summaries are indivisible: do not deliver one whose applicable claims
+      // predate a contradiction, even after a different Run corrects it.
+      && run.acceptanceChecks.every((check, index) => check.status !== 'failed'
+        && (check.status === 'not_applicable'
+          || (Number(run.startedAt) || observedAt(run)) > latestContradictionAt[index]))
+    : outputKind && normalizeOutputs(run.outputs).some(output => output.kind === outputKind && !NEGATIVE.has(output.status)))
+    .map(run => run.id);
+  const blockers = (detail?.actions || []).filter(action => ['failed', 'waiting'].includes(action.status))
+    .map(action => {
+      const run = runs.find(candidate => candidate.actionId === action.id);
+      return { actionId: action.id, status: action.status, reason: run?.waitingReason || run?.error || action.brief?.objective || '' };
+    });
+  return {
+    contractRevision: revision(detail?.revision),
+    criteria,
+    remainingCriteria: criteria.filter(item => item.status !== 'passed').map(item => item.criterion),
+    completedCriteriaCount: criteria.filter(item => item.status === 'passed').length,
+    totalCriteriaCount: criteria.length,
+    evidenceRunIds: [...new Set(criteria.flatMap(item => item.evidenceRunIds))],
+    blockers,
+    delivery: { target, status: deliveryRunIds.length ? 'passed' : 'unmet', evidenceRunIds: deliveryRunIds },
+  };
+}

package/yeaft/work-center/projection.js

@@ -162,6 +162,15 @@ function sumExecutionStats(values) {
   }, emptyExecutionStats());
 }
 
+function combinedExecutionStats(detail) {
+  const stats = Array.isArray(detail.runs) ? sumExecutionStats(detail.runs) : executionStats(detail.executionStats);
+  if (detail.executionControl?.usage) {
+    const usage = executionStats(detail.executionControl.usage);
+    for (const key of Object.keys(usage)) if (!['loopCount', 'toolCount'].includes(key)) stats[key] = usage[key];
+  }
+  return stats;
+}
+
 function actionGeneration(value) {
   return Math.max(1, count(value) || 1);
 }
@@ -765,6 +774,7 @@ function enforceWorkItemBrowserDtoBudget(value, options = {}) {
     status: truncateUtf8(workItem.status, 256),
     currentActionId: truncateUtf8(workItem.currentActionId, 4 * 1024) || null,
     executionStats: workItem.executionStats,
+    executionControl: workItem.executionControl,
     actionCount: count(workItem.actionCount),
     actions: Array.isArray(workItem.actions) ? [] : undefined,
     actionStats: Array.isArray(workItem.actionStats) ? [] : undefined,
@@ -896,6 +906,39 @@ function workItemFailureReason(detail) {
  * Authenticated browser detail DTO. Raw execution records stay Agent-local;
  * the browser receives only aggregate execution stats plus the explicit user-facing response.
  */
+function projectGoalProgress(progress) {
+  if (!progress || !Array.isArray(progress.criteria)) return null;
+  const ids = value => Array.isArray(value) ? value.slice(0, 64).map(id => truncateUtf8(String(id), 256)) : [];
+  const prioritized = [...progress.criteria.filter(item => item.status !== 'passed'),
+    ...progress.criteria.filter(item => item.status === 'passed')];
+  const criteria = prioritized.slice(0, 100).map(item => ({
+    criterion: truncateUtf8(item.criterion || '', 1024),
+    status: ['passed', 'failed'].includes(item.status) ? item.status : 'unmet',
+    evidenceRunIds: ids(item.evidenceRunIds),
+    ...(item.conflictingRunIds ? { conflictingRunIds: ids(item.conflictingRunIds) } : {}),
+  }));
+  return {
+    contractRevision: count(progress.contractRevision), criteria,
+    completedCriteriaCount: count(progress.completedCriteriaCount),
+    totalCriteriaCount: count(progress.totalCriteriaCount),
+    remainingCriteriaCount: Math.max(0, count(progress.totalCriteriaCount) - count(progress.completedCriteriaCount)),
+    omittedCriteriaCount: Math.max(0, progress.criteria.length - criteria.length),
+    remainingCriteria: criteria.filter(item => item.status !== 'passed').map(item => item.criterion),
+    evidenceRunIds: ids(progress.evidenceRunIds),
+    blockers: (progress.blockers || []).slice(0, 64).map(blocker => ({
+      actionId: truncateUtf8(blocker.actionId || '', 256),
+      status: blocker.status === 'failed' ? 'failed' : 'waiting',
+      reason: sanitizeDiagnosticText(blocker.reason || '', MAX_ACTION_DIAGNOSTIC_CHARS),
+    })),
+    delivery: {
+      target: ['response', 'workspace_files', 'pull_request', 'merge'].includes(progress.delivery?.target)
+        ? progress.delivery.target : null,
+      status: progress.delivery?.status === 'passed' ? 'passed' : 'unmet',
+      evidenceRunIds: ids(progress.delivery?.evidenceRunIds),
+    },
+  };
+}
+
 export function projectWorkItemDetail(detail, options = {}) {
   if (!detail) return null;
   const liveActionId = bodyActionId(detail);
@@ -949,6 +992,12 @@ export function projectWorkItemDetail(detail, options = {}) {
               runId: truncateUtf8(rawOutput?.runId || '', 256) || null,
             };
           }).filter(output => output?.kind && output.label && output.ref) : [],
+      responses: Array.isArray(detail.finalResult.responses)
+        ? detail.finalResult.responses.slice(0, 24).map(response => ({
+            runId: truncateUtf8(response?.runId || '', 256),
+            summary: truncateUtf8(response?.summary || '', 8 * 1024),
+            evidence: projectCanonicalEvidence(response?.evidence),
+          })) : [],
       residualRisks: Array.isArray(detail.finalResult.residualRisks)
         ? detail.finalResult.residualRisks
           .map(risk => truncateUtf8(risk, MAX_ACTION_MESSAGE_CHARS)).slice(0, 24) : [],
@@ -956,6 +1005,7 @@ export function projectWorkItemDetail(detail, options = {}) {
     title: detail.title,
     goal: detail.goal,
     acceptanceCriteria: Array.isArray(detail.acceptanceCriteria) ? detail.acceptanceCriteria : [],
+    goalProgress: projectGoalProgress(detail.goalProgress),
     workflowTemplate: detail.workflowTemplate,
     workItemType: detail.workflowSnapshot?.workItemType || detail.workItemType || null,
     planningMode: detail.workflowSnapshot?.planningMode || detail.planningMode || 'static',
@@ -967,11 +1017,10 @@ export function projectWorkItemDetail(detail, options = {}) {
     attentionActionIds: Array.isArray(detail.attentionActionIds) ? detail.attentionActionIds : undefined,
     mainline,
     currentActionId: detail.currentActionId || null,
-    executionStats: Array.isArray(detail.runs)
-      ? sumExecutionStats(detail.runs)
-      : executionStats(detail.executionStats),
+    executionControl: detail.executionControl,
+    executionStats: combinedExecutionStats(detail),
     reuseMemory: detail.reuseMemory !== false,
-    deliveryTarget: ['workspace_files', 'pull_request', 'merge'].includes(detail.deliveryTarget)
+    deliveryTarget: ['response', 'workspace_files', 'pull_request', 'merge'].includes(detail.deliveryTarget)
       ? detail.deliveryTarget : null,
     waitingReason: sanitizeDiagnosticText(waitingReason(detail), MAX_ACTION_DIAGNOSTIC_CHARS),
     failureReason: workItemFailureReason(detail),
@@ -1059,7 +1108,8 @@ export function projectWorkItemSummary(detail) {
         ? detail.actionStats.map(action => ({ ...action })) : [],
       actionCount: count(detail.actionCount),
       completedActionCount: count(detail.completedActionCount),
-      executionStats: executionStats(detail.executionStats),
+      executionStats: combinedExecutionStats(detail),
+      executionControl: detail.executionControl,
       origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
       linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
       attachmentCount: Array.isArray(detail.attachments) ? detail.attachments.length : 0,
@@ -1094,9 +1144,8 @@ export function projectWorkItemSummary(detail) {
     currentActionId: detail.currentActionId || null,
     actionCount: detail.actions.filter(item => !['superseded', 'cancelled'].includes(item?.status)).length,
     completedActionCount: detail.actions.filter(item => item?.status === 'completed').length,
-    executionStats: Array.isArray(detail.runs)
-      ? sumExecutionStats(detail.runs)
-      : executionStats(detail.executionStats),
+    executionControl: detail.executionControl,
+    executionStats: combinedExecutionStats(detail),
     failureReason: workItemFailureReason(detail),
 
     currentAction: projectCurrentActionSummary(action, projectedAction),