@yeaft/webchat-agent 1.0.171 → 1.0.172

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.171",
+  "version": "1.0.172",
   "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/work-center/projection.js

@@ -36,6 +36,44 @@ function sumExecutionStats(values) {
   }, emptyExecutionStats());
 }
 
+const MAX_FAILURE_REASON_LENGTH = 2_000;
+const MAX_FAILURE_INSPECTION_LENGTH = 16_000;
+const SAFE_FAILURE_FALLBACK = 'The Action failed. Sensitive details were omitted.';
+const CREDENTIAL_ASSIGNMENT_PATTERN = /\b(?:[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)|api[_-]?key|access[_-]?token|authorization|password|secret|token)\s*[:=]/i;
+const PROVIDER_TOKEN_PATTERN = /\b(?:sk-(?:proj-)?[A-Za-z0-9_-]{12,}|github_pat_[A-Za-z0-9_]{12,}|gh[pousr]_[A-Za-z0-9_]{12,}|xox[baprs]-[A-Za-z0-9-]{12,}|AKIA[A-Z0-9]{12,})\b/i;
+const HIGH_ENTROPY_SECRET_PATTERN = /\b(?=[A-Za-z0-9_./+=-]{32,}\b)(?=[A-Za-z0-9_./+=-]*[A-Za-z])(?=[A-Za-z0-9_./+=-]*\d)[A-Za-z0-9_./+=-]+\b/;
+const LOCAL_PATH_ASSIGNMENT_PATTERN = /\b(?:path|cwd|file|filename|directory)\s*[:=]\s*(?:\/(?!\/)|[A-Za-z]:\\|\\\\)/i;
+const POSIX_ABSOLUTE_PATH_PATTERN = /(?:^|[\s("'`])\/(?!\/)[^\r\n]*/m;
+const WINDOWS_ABSOLUTE_PATH_PATTERN = /(?:^|[\s("'`])(?:[A-Za-z]:\\|\\\\)[^\r\n]*/m;
+
+function sanitizedUrl(raw) {
+  try {
+    const url = new URL(raw);
+    if (!['http:', 'https:'].includes(url.protocol)) return '[redacted URL]';
+    return `${url.protocol}//${url.host}${url.pathname}`;
+  } catch {
+    return '[redacted URL]';
+  }
+}
+
+function sanitizeFailureReason(value) {
+  const raw = typeof value === 'string'
+    ? value.trim().slice(0, MAX_FAILURE_INSPECTION_LENGTH)
+    : '';
+  if (!raw) return '';
+  const text = raw.replace(/https?:\/\/[^\s<>'"`]+/gi, sanitizedUrl);
+  if (CREDENTIAL_ASSIGNMENT_PATTERN.test(text) || PROVIDER_TOKEN_PATTERN.test(text)
+      || HIGH_ENTROPY_SECRET_PATTERN.test(text)) return SAFE_FAILURE_FALLBACK;
+  if (LOCAL_PATH_ASSIGNMENT_PATTERN.test(text) || POSIX_ABSOLUTE_PATH_PATTERN.test(text)
+      || WINDOWS_ABSOLUTE_PATH_PATTERN.test(text)) {
+    return SAFE_FAILURE_FALLBACK;
+  }
+  return text
+    .replace(/\b(?:Bearer|Basic)\s+[^\s,;]+/gi, '[redacted credential]')
+    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '')
+    .slice(0, MAX_FAILURE_REASON_LENGTH);
+}
+
 function actionExecution(action, runs) {
   const matchingRuns = Array.isArray(runs)
     ? runs.filter(run => run?.actionId === action?.id)
@@ -44,6 +82,7 @@ function actionExecution(action, runs) {
     return {
       ...executionStats(action),
       response: '',
+      failureReason: '',
       progressRevision: 0,
       messages: [],
     };
@@ -53,19 +92,29 @@ function actionExecution(action, runs) {
     count(right.progressRevision) - count(left.progressRevision)
       || count(right.startedAt) - count(left.startedAt)
   ))[0];
+  const runsByEnd = [...matchingRuns]
+    .sort((left, right) => count(right.endedAt || right.startedAt) - count(left.endedAt || left.startedAt));
+  const latestRun = runsByEnd[0];
+  const showCurrentFailure = action?.status === 'failed'
+    || ['failed', 'retryable', 'interrupted'].includes(latestRun?.status);
+  const latestFailure = showCurrentFailure
+    ? runsByEnd.find(run => sanitizeFailureReason(run?.error))
+    : null;
   const messages = [...matchingRuns]
     .sort((left, right) => count(left.startedAt) - count(right.startedAt))
     .map((run, index) => ({
       id: `${action.id}:${index + 1}`,
       status: run.status || 'running',
       text: typeof run.response === 'string' ? run.response.trim().slice(0, 16_000) : '',
+      failureReason: sanitizeFailureReason(run.error),
       createdAt: count(run.startedAt),
       updatedAt: count(run.endedAt || run.startedAt),
     }))
-    .filter(message => message.text);
+    .filter(message => message.text || message.failureReason);
   return {
     ...stats,
     response: typeof latest?.response === 'string' ? latest.response : '',
+    failureReason: sanitizeFailureReason(latestFailure?.error),
     progressRevision: count(latest?.progressRevision),
     messages,
   };
@@ -109,6 +158,7 @@ function projectAction(action, runs) {
     loopCount: execution.loopCount,
     toolCount: execution.toolCount,
     response: execution.response,
+    failureReason: execution.failureReason,
     progressRevision: execution.progressRevision,
     messages: execution.messages,
   };
@@ -125,8 +175,11 @@ function projectActionStats(detail) {
       loopCount: projected.loopCount,
       toolCount: projected.toolCount,
       response: projected.response,
+      failureReason: projected.failureReason,
       progressRevision: projected.progressRevision,
-      messages: projected.messages,
+      messages: projected.messages
+        .map(({ failureReason, ...message }) => message)
+        .filter(message => message.text),
     };
   });
 }
@@ -139,6 +192,15 @@ function waitingReason(detail) {
   ))?.waitingReason || '';
 }
 
+function workItemFailureReason(detail) {
+  if (!['needs_attention', 'cancelled'].includes(detail?.status) || !Array.isArray(detail?.runs)) return '';
+  const ordered = [...detail.runs].sort((left, right) => (
+    count(right.endedAt || right.startedAt) - count(left.endedAt || left.startedAt)
+  ));
+  const current = ordered.find(run => run?.actionId === detail.currentActionId && sanitizeFailureReason(run.error));
+  return sanitizeFailureReason(current?.error || ordered.find(run => sanitizeFailureReason(run?.error))?.error);
+}
+
 /**
  * Authenticated browser detail DTO. Raw execution records stay Agent-local;
  * the browser receives only aggregate execution stats plus the explicit user-facing response.
@@ -160,6 +222,7 @@ export function projectWorkItemDetail(detail) {
     executionStats: sumExecutionStats(Array.isArray(detail.runs) ? detail.runs : []),
     reuseMemory: detail.reuseMemory !== false,
     waitingReason: waitingReason(detail),
+    failureReason: workItemFailureReason(detail),
     origin: detail.origin?.sessionId ? { sessionId: detail.origin.sessionId } : null,
     linkedSessionIds: Array.isArray(detail.linkedSessionIds) ? detail.linkedSessionIds : [],
     attachments: projectAttachments(detail.attachments),
@@ -213,6 +276,7 @@ export function projectWorkItemSummary(detail) {
     status: detail.status,
     currentActionId: detail.currentActionId || null,
     executionStats: sumExecutionStats(Array.isArray(detail.runs) ? detail.runs : []),
+    failureReason: workItemFailureReason(detail),
     currentAction: projectedAction ? {
       id: projectedAction.id,
       type: projectedAction.type,

package/yeaft/work-center/runner.js

@@ -327,7 +327,7 @@ function completionContract(action, workItem) {
     ? ',\n  "contractPatch": { "goal": "optional refined goal", "acceptanceCriteria": ["optional refined criterion"] }'
     : '';
   const planField = action.type === 'triage' && workItem?.workflowSnapshot?.planningMode === 'ai'
-    ? ',\n  "plan": { "workItemType": "specific-lowercase-slug", "actions": [{ "id": "stable-id", "name": "User-facing name", "type": "extensible-lowercase-slug (built-ins include research|design|diagnose|implement|migrate|test|review|document|operate|deliver|integrate|write|custom)", "capability": "specific executor capability", "objective": "what this Action must do", "approach": "how this Action should do it", "expectedOutcome": "verifiable result this Action must produce", "dependsOnActionIds": ["earlier Action id; [] means concurrent root"], "workspaceMode": "read|isolated-write|integrate|shared", "separateFromActionTypes": ["optional prior Action type"], "changesRequestedActionId": "for review: optional earlier editable Action id; omit to use nearest", "maxAttempts": 2 }] }'
+    ? ',\n  "plan": { "workItemType": "specific-lowercase-slug", "actions": [{ "id": "stable-id", "name": "User-facing name", "type": "extensible-lowercase-slug (built-ins include research|design|diagnose|implement|migrate|test|review|document|operate|deliver|integrate|write|custom)", "capability": "specific executor capability", "objective": "task-specific concrete work this Action must do", "approach": "task-specific repository-aware method the executor must follow", "expectedOutcome": "task-specific verifiable result this Action must produce", "dependsOnActionIds": ["earlier Action id; [] means concurrent root"], "workspaceMode": "read|isolated-write|integrate|shared", "separateFromActionTypes": ["optional prior Action type"], "changesRequestedActionId": "for review: optional earlier editable Action id; omit to use nearest", "maxAttempts": 2 }] }'
     : '';
   const acceptanceChecks = (workItem?.acceptanceCriteria || []).map(criterion => ({
     criterion,

package/yeaft/work-center/workflow.js

@@ -341,7 +341,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}\nReusable Action templates:\n${catalog || '(none)'}\nIf the final type matches a reusable template, return its workItemType and omit actions so Work Center can apply that frozen template. Otherwise generate the smallest reliable graph of 1 to 8 Actions. Split independent work into separate Actions and declare dependsOnActionIds. Use workspaceMode read for analysis, isolated-write for independent Git changes, integrate for an integrate Action that combines isolated-write dependencies, and shared for serial side effects. Non-Git or dirty workspaces are serialized automatically. Every generated Action must state objective, approach, expectedOutcome, capability, dependencies, and workspaceMode. Add only Actions required by this task. Do not copy a generic workflow.`;
+  const triageInstruction = `${normalized.actionInstructions.triage}\n\n${typeInstruction}\nReusable Action templates:\n${catalog || '(none)'}\nIf the final type matches a reusable template, return its workItemType and omit actions so Work Center can apply that frozen template. Otherwise generate the smallest reliable graph of 1 to 8 Actions. Split independent work into separate Actions and declare dependsOnActionIds. Use workspaceMode read for analysis, isolated-write for independent Git changes, integrate for an integrate Action that combines isolated-write dependencies, and shared for serial side effects. Non-Git or dirty workspaces are serialized automatically. 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',
@@ -434,14 +434,20 @@ export function applyGeneratedPlan(workItem, rawPlan) {
     if (seen.has(id)) throw new Error(`Duplicate AI-planned Action id: ${id}`);
     seen.add(id);
     const objective = typeof input.objective === 'string' ? input.objective.trim().slice(0, 2_000) : '';
-    if (!objective) throw new Error(`AI-planned Action "${id}" requires an objective`);
-    const defaults = defaultActionBrief(type);
-    const approach = typeof input.approach === 'string' && input.approach.trim()
-      ? input.approach.trim().slice(0, 2_000)
-      : defaults.approach;
-    const expectedOutcome = typeof input.expectedOutcome === 'string' && input.expectedOutcome.trim()
+    if (!objective) throw new Error(`AI-planned Action "${id}" requires a task-specific objective`);
+    const approach = typeof input.approach === 'string' ? input.approach.trim().slice(0, 2_000) : '';
+    if (!approach) throw new Error(`AI-planned Action "${id}" requires a task-specific approach`);
+    const expectedOutcome = typeof input.expectedOutcome === 'string'
       ? input.expectedOutcome.trim().slice(0, 2_000)
-      : defaults.expectedOutcome;
+      : '';
+    if (!expectedOutcome) {
+      throw new Error(`AI-planned Action "${id}" requires a task-specific expectedOutcome`);
+    }
+    const defaults = defaultActionBrief(type);
+    if (objective === defaults.objective || approach === defaults.approach
+      || expectedOutcome === defaults.expectedOutcome) {
+      throw new Error(`AI-planned Action "${id}" must not reuse generic Action-type brief text`);
+    }
     const actionInstruction = Object.hasOwn(source.actionInstructions, type)
       ? source.actionInstructions[type]
       : source.actionInstructions.custom;