@yeaft/webchat-agent 1.0.171 → 1.0.173

package/package.json

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

@@ -524,6 +524,9 @@ export class Engine {
   /** @type {Array<{content:string|Array, preview:string}>} */
   #pendingUserMessages = [];
 
+  /** True after the bridge queued input in its external per-thread buffer. */
+  #externalUserWakePending = false;
+
   /**
    * Tasks (background bash, sub-agent spawns) that were launched DURING
    * the currently-running query() and have NOT terminated yet. The query
@@ -1654,6 +1657,7 @@ export class Engine {
 
   #drainPendingUserMessages(drainPendingUserMessages) {
     const pending = [];
+    this.#externalUserWakePending = false;
     if (typeof drainPendingUserMessages === 'function') {
       try {
         const drained = drainPendingUserMessages();
@@ -1809,6 +1813,7 @@ export class Engine {
       this.#abortReason = null;
       this.#currentThreadId = MAIN_THREAD_ID;
       this.#pendingUserMessages.length = 0;
+      this.#externalUserWakePending = false;
       this.#asyncTaskToolMeta.clear();
       this.#pendingTaskResultMessages.length = 0;
       this.#pendingTaskResultUpdates.length = 0;
@@ -2955,7 +2960,8 @@ export class Engine {
         while (!signal?.aborted
                && this.#pendingTaskResultMessages.length === 0
                && this.#pendingTaskResultUpdates.length === 0
-               && this.#pendingUserMessages.length === 0) {
+               && this.#pendingUserMessages.length === 0
+               && !this.#externalUserWakePending) {
           if (this.#pendingAsyncTaskIds.size === 0) break;
           await this.#waitForAsyncWake(signal);
         }
@@ -3680,6 +3686,20 @@ export class Engine {
     return true;
   }
 
+  /**
+   * Wake a query whose external pending-message hook has received input.
+   * The bridge keeps the full message (attachments and provenance included)
+   * in its thread queue; this method only releases an async-task wait so the
+   * normal drain callback can consume it at the next safe adapter boundary.
+   * @returns {boolean}
+   */
+  wakeForPendingUserMessage() {
+    if (!this.isRunning) return false;
+    this.#externalUserWakePending = true;
+    this.#wakeAsyncTaskWaiters();
+    return true;
+  }
+
   /**
    * Install the coordinator that lets an external dispatcher (web-bridge)
    * route a background task's terminal event back to THIS engine while
@@ -3851,6 +3871,7 @@ export class Engine {
       if (this.#pendingTaskResultMessages.length > 0) return resolve();
       if (this.#pendingTaskResultUpdates.length > 0) return resolve();
       if (this.#pendingUserMessages.length > 0) return resolve();
+      if (this.#externalUserWakePending) return resolve();
       if (signal?.aborted) return resolve();
       this.#asyncTaskWaiters.push(resolve);
       if (signal && typeof signal.addEventListener === 'function') {

package/yeaft/tools/ask-user.js

@@ -66,6 +66,13 @@ Guidelines:
     }
 
     const answers = await ctx.askUser({ question, options });
+    if (answers?.__yeaftTimedOut) {
+      return JSON.stringify({
+        question,
+        timedOut: true,
+        message: 'The user did not answer before the request expired. Continue without this input.',
+      });
+    }
     return JSON.stringify({ question, answers });
   },
 });

package/yeaft/web-bridge.js

@@ -80,7 +80,27 @@ const YEAFT_SKILL_COMMAND_PREFIX = 'yeaft-skills:';
 const PROJECT_SKILL_TIERS = new Set(['project', 'project-claude', 'project-codex']);
 const BASE_RUNTIME_KEY = '__base__';
 
-/** @type {Map<string, {resolve:Function, sessionId:string, vpId:string, threadId:string, turnId:string, signal?:AbortSignal, onAbort?:Function}>} */
+/**
+ * Live AskUser requests. They are Session-scoped runtime state rather than a
+ * turn lock: every connected client may answer the same request, while the
+ * first valid answer wins. Pending requests are replayed when another device
+ * loads the Session.
+ * @type {Map<string, {
+ *   resolve:Function,
+ *   reject?:Function,
+ *   sessionId:string,
+ *   vpId:string,
+ *   threadId:string,
+ *   turnId:string,
+ *   question:string,
+ *   options:Array<string>,
+ *   createdAt:number,
+ *   expiresAt:number,
+ *   timer?:NodeJS.Timeout|null,
+ *   resumeQueryTimer?:Function,
+ *   signal?:AbortSignal,
+ *   onAbort?:Function,
+ * }>} */
 const pendingUserPrompts = new Map();
 
 /** @type {import('./session.js').Session | null} */
@@ -212,6 +232,7 @@ function scheduleYeaftLoadHistoryMetadataReplay(sessionId) {
         yeaftDir: ctx.CONFIG?.yeaftDir || null,
         tasks: replaySession.taskManager ? replaySession.taskManager.listActiveTasks() : [],
       }, { sessionId });
+      if (sessionId) replayPendingUserPrompts(sessionId);
       sendSessionSnapshotBroadcast();
       if (sessionId && session === replaySession) {
         sendDreamSnapshotForSession(sessionId, { trigger: 'load_history' }).catch(() => null);
@@ -796,6 +817,8 @@ export function broadcastLanguageChange(language) {
 /** Query timeout in ms — abort if LLM doesn't respond within this window */
 const QUERY_TIMEOUT_MS = 120_000;
 const HIGH_REASONING_QUERY_TIMEOUT_MS = 300_000;
+/** AskUser is human-paced but must never pin a VP turn forever. */
+const ASK_USER_TIMEOUT_MS = 10 * 60_000;
 
 function isHighReasoningEffort(effort) {
   const value = typeof effort === 'string' ? effort.trim().toLowerCase() : '';
@@ -1378,6 +1401,12 @@ export function __testGetVpThreads(sessionId, vpId) {
   }));
 }
 
+/** Test-only: attach an Engine-like wake target to a seeded VP thread. */
+export function __testSetVpThreadEngine({ sessionId, vpId, threadId, engine }) {
+  const thread = getOrCreateVpThread({ sessionId, vpId, threadId });
+  thread.engine = engine || null;
+}
+
 /** Test-only: seed a VP thread without starting its engine driver. */
 export function __testSeedVpThread({ sessionId, vpId, threadId, title = 'test thread', status = 'queued' }) {
   const thread = getOrCreateVpThread({ sessionId, vpId, threadId, title });
@@ -1725,31 +1754,43 @@ async function routeEnvelopeToVpThread(sessionId, vpId, envelope) {
       senderVpId: isInternalAppend ? (envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null) : null,
       sourceThreadId: isInternalAppend ? visibleInboundThreadId(envelope, thread.threadId) : null,
     });
-    persistInboundMessageOnceByMsgId({
-      msgId: envelope?.msg?.id,
-      text,
-      sessionId,
-      threadId: visibleInboundThreadId(envelope, thread.threadId),
-      role: isInternalAppend ? 'assistant' : 'user',
-      speakerVpId: envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null,
-      attachments: Array.isArray(envelope?.msg?.meta?.attachments) ? envelope.msg.meta.attachments : [],
-      internal: isInternalAppend,
-      ts: envelope?.msg?.ts || null,
-      clientMessageId: envelope?.msg?.meta?.clientMessageId || null,
-    });
-    thread.updatedAt = Date.now();
-    try {
-      sendSessionEvent({
-        type: 'vp_thread_user_appended',
+    // A thread parked on a background task has no adapter activity to poll this
+    // queue. Wake its Engine explicitly so the new user message is consumed
+    // immediately while the task remains tracked in TaskManager. If the Engine
+    // is not actually running, this was a stale classifier hit; remove the
+    // append and fall through to a normal queued turn instead of orphaning it.
+    let appendedToRunningThread = false;
+    try { appendedToRunningThread = thread.engine?.wakeForPendingUserMessage?.() === true; } catch { /* best-effort wake */ }
+    if (!appendedToRunningThread) {
+      thread.pendingQueries.pop();
+      related = false;
+    } else {
+      persistInboundMessageOnceByMsgId({
+        msgId: envelope?.msg?.id,
+        text,
         sessionId,
-        vpId,
-        threadId: thread.threadId,
-        title: thread.title,
-        turnId,
-        ts: Date.now(),
-      }, { sessionId, vpId, threadId: thread.threadId, turnId });
-    } catch { /* never crash WS pipeline */ }
-    return thread.threadId;
+        threadId: visibleInboundThreadId(envelope, thread.threadId),
+        role: isInternalAppend ? 'assistant' : 'user',
+        speakerVpId: envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null,
+        attachments: Array.isArray(envelope?.msg?.meta?.attachments) ? envelope.msg.meta.attachments : [],
+        internal: isInternalAppend,
+        ts: envelope?.msg?.ts || null,
+        clientMessageId: envelope?.msg?.meta?.clientMessageId || null,
+      });
+      thread.updatedAt = Date.now();
+      try {
+        sendSessionEvent({
+          type: 'vp_thread_user_appended',
+          sessionId,
+          vpId,
+          threadId: thread.threadId,
+          title: thread.title,
+          turnId,
+          ts: Date.now(),
+        }, { sessionId, vpId, threadId: thread.threadId, turnId });
+      } catch { /* never crash WS pipeline */ }
+      return thread.threadId;
+    }
   }
 
   const key = threadKey(sessionId, vpId, thread.threadId);
@@ -2335,6 +2376,60 @@ function sendSessionEvent(event, { sessionId, chatId, vpId, turnId, threadId, pe
   });
 }
 
+function pendingUserPromptEvent(requestId, pending, extra = {}) {
+  return {
+    type: 'ask_user_question',
+    requestId,
+    questions: [{
+      question: pending.question,
+      options: pending.options.map(label => ({ label, description: '' })),
+      multiSelect: false,
+    }],
+    createdAt: pending.createdAt,
+    expiresAt: pending.expiresAt,
+    ...extra,
+  };
+}
+
+function sendPendingUserPrompt(requestId, pending, extra = {}) {
+  sendSessionEvent(pendingUserPromptEvent(requestId, pending, extra), {
+    sessionId: pending.sessionId,
+    vpId: pending.vpId,
+    threadId: pending.threadId,
+    turnId: pending.turnId,
+  });
+}
+
+function replayPendingUserPrompts(sessionId) {
+  const now = Date.now();
+  for (const [requestId, pending] of pendingUserPrompts) {
+    if (pending.sessionId !== sessionId || pending.expiresAt <= now) continue;
+    sendPendingUserPrompt(requestId, pending, { replay: true });
+  }
+}
+
+function settlePendingUserPrompt(requestId, pending, { answers = null, timedOut = false } = {}) {
+  if (pendingUserPrompts.get(requestId) !== pending) return false;
+  pendingUserPrompts.delete(requestId);
+  if (pending.timer) clearTimeout(pending.timer);
+  if (pending.signal && pending.onAbort) {
+    try { pending.signal.removeEventListener('abort', pending.onAbort); } catch { /* ignore */ }
+  }
+  try { pending.resumeQueryTimer?.(); } catch { /* best-effort */ }
+  sendSessionEvent({
+    type: timedOut ? 'ask_user_expired' : 'ask_user_answered',
+    requestId,
+    ...(timedOut ? { expiredAt: Date.now() } : { answers: answers || {} }),
+  }, {
+    sessionId: pending.sessionId,
+    vpId: pending.vpId,
+    threadId: pending.threadId,
+    turnId: pending.turnId,
+  });
+  pending.resolve(timedOut ? { __yeaftTimedOut: true } : (answers || {}));
+  return true;
+}
+
 function configuredVpPaths() {
   const yeaftDir = ctx.CONFIG?.yeaftDir;
   if (typeof yeaftDir !== 'string' || !yeaftDir.trim()) return {};
@@ -4560,40 +4655,44 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         askUser: ({ question, options }) => new Promise((resolve, reject) => {
           const requestId = `ask_${randomUUID()}`;
           const signal = vpAbort.signal;
-          // User think time is not engine silence. Pause the query watchdog until
-          // the card is answered; the normal tool/LLM budget resumes afterward.
+          const createdAt = Date.now();
+          // Human think time is not engine silence. Pause the query watchdog,
+          // but keep a separate bounded AskUser lifetime so an abandoned card
+          // cannot pin the VP forever.
           if (queryTimer) {
             clearTimeout(queryTimer);
             queryTimer = null;
           }
-          const onAbort = () => {
-            pendingUserPrompts.delete(requestId);
-            reject(new Error('aborted'));
-          };
-          pendingUserPrompts.set(requestId, {
-            resolve: answers => {
-              resetQueryTimer();
-              resolve(answers);
-            },
+          const pending = {
+            resolve,
+            reject,
             sessionId,
             vpId,
             threadId,
             turnId,
+            question,
+            options: Array.isArray(options) ? options.filter(label => typeof label === 'string') : [],
+            createdAt,
+            expiresAt: createdAt + ASK_USER_TIMEOUT_MS,
+            timer: null,
+            resumeQueryTimer: resetQueryTimer,
             signal,
-            onAbort,
-          });
+            onAbort: null,
+          };
+          const onAbort = () => {
+            if (pendingUserPrompts.get(requestId) !== pending) return;
+            pendingUserPrompts.delete(requestId);
+            if (pending.timer) clearTimeout(pending.timer);
+            reject(new Error('aborted'));
+          };
+          pending.onAbort = onAbort;
+          pending.timer = setTimeout(() => {
+            settlePendingUserPrompt(requestId, pending, { timedOut: true });
+          }, ASK_USER_TIMEOUT_MS);
+          if (typeof pending.timer.unref === 'function') pending.timer.unref();
+          pendingUserPrompts.set(requestId, pending);
           signal.addEventListener('abort', onAbort, { once: true });
-          sendSessionEvent({
-            type: 'ask_user_question',
-            requestId,
-            questions: [{
-              question,
-              options: Array.isArray(options)
-                ? options.map(label => ({ label, description: '' }))
-                : [],
-              multiSelect: false,
-            }],
-          }, envelope);
+          sendPendingUserPrompt(requestId, pending);
         }),
         threadId,
         vpTurnId: turnId,
@@ -5639,12 +5738,7 @@ export function handleYeaftAskUserAnswer(msg) {
   if (msg.turnId && msg.turnId !== pending.turnId) return false;
   if (msg.threadId && msg.threadId !== pending.threadId) return false;
 
-  pendingUserPrompts.delete(requestId);
-  if (pending.signal && pending.onAbort) {
-    try { pending.signal.removeEventListener('abort', pending.onAbort); } catch { /* ignore */ }
-  }
-  pending.resolve(msg.answers || {});
-  return true;
+  return settlePendingUserPrompt(requestId, pending, { answers: msg.answers || {} });
 }
 
 export async function handleYeaftSessionSend(msg) {
@@ -6543,13 +6637,21 @@ export const __testHooks = {
     vpAborts.clear();
     vpInboxes.clear();
   },
-  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test' } = {}) {
+  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test', question = 'Continue?', options = [], createdAt = Date.now(), expiresAt = Date.now() + ASK_USER_TIMEOUT_MS } = {}) {
     let resolved;
     const promise = new Promise(resolve => { resolved = resolve; });
-    pendingUserPrompts.set(requestId, { resolve: resolved, sessionId, vpId, threadId, turnId });
+    pendingUserPrompts.set(requestId, { resolve: resolved, sessionId, vpId, threadId, turnId, question, options, createdAt, expiresAt, timer: null });
     return promise;
   },
+  replayPendingUserPrompts,
+  settlePendingUserPromptForTest(requestId, opts = {}) {
+    const pending = pendingUserPrompts.get(requestId);
+    return pending ? settlePendingUserPrompt(requestId, pending, opts) : false;
+  },
   resetPendingUserPrompts() {
+    for (const pending of pendingUserPrompts.values()) {
+      if (pending.timer) clearTimeout(pending.timer);
+    }
     pendingUserPrompts.clear();
   },
   resetVpStatusBroker() {

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;