@yeaft/webchat-agent 1.0.202 → 1.0.204

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.202"}
+{"version":"1.0.204"}

package/package.json

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

@@ -32,7 +32,7 @@ import { archiveTurn } from './archive/turn-archive.js';
 import { archiveToolResults } from './archive/tool-results.js';
 import { readSummary as readScopeSummary } from './memory/store.js';
 import { runAdjust } from './memory/adjust.js';
-import { cleanMemoryPromptText } from './memory/prompt-cleanup.js';
+import { cleanMemoryPromptText, isMemoryPromptRelevant } from './memory/prompt-cleanup.js';
 import { isVpSeedBackfillStub } from './memory/seed-backfill.js';
 import { runStopHooks } from './stop-hooks.js';
 import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
@@ -388,6 +388,20 @@ export function shouldAllowGroupReflection({
  * }} args
  * @returns {Array<{scope: string, summary: string}>}
  */
+export function selectResidentTopicScopes(topicScopes, recallEntries, userMsg = '') {
+  const recalledTopicScopes = new Set((recallEntries || [])
+    .map(entry => entry?.scope)
+    .filter(scope => typeof scope === 'string' && /^sessions\/[^/]+\/topic\//.test(scope)));
+  return (Array.isArray(topicScopes) ? topicScopes : [])
+    .filter(scope => recalledTopicScopes.has(scope) || isTopicScopeRelevant(scope, userMsg));
+}
+
+function isTopicScopeRelevant(scope, userMsg) {
+  if (!userMsg || typeof scope !== 'string') return false;
+  const label = scope.replace(/^sessions\/[^/]+\/topic\//, '').replace(/[/-]+/g, ' ');
+  return isMemoryPromptRelevant(label, userMsg);
+}
+
 export function buildResidentEntries(args) {
   const summaries = (args && args.summaries) || {};
   const out = [];
@@ -873,6 +887,7 @@ export class Engine {
    *   ownVpId?: string|null,
    *   summaries: { user?: string, session?: string, vp?: string },
    *   recallEntries: object[],
+   *   userMsg?: string,
    * }} args
    * @returns {{
    *   ams: import('./memory/ams.js').ActiveMemorySet,
@@ -912,7 +927,7 @@ export class Engine {
     ams.setOnDemand(segs);
 
     // (c) Snapshot — render the AMS layers as a single prompt block.
-    const snapshotBlock = this.#renderAmsSnapshot(ams, this.#config.language || 'en');
+    const snapshotBlock = this.#renderAmsSnapshot(ams, this.#config.language || 'en', args.userMsg || '');
 
     const scopes = buildRelevantScopes({
       sessionId: args.sessionId,
@@ -929,10 +944,11 @@ export class Engine {
    *
    * @param {import('./memory/ams.js').ActiveMemorySet} ams
    * @param {string} [language]
+   * @param {string} [userMsg]
    * @returns {string}
    */
-  #renderAmsSnapshot(ams, language = 'en') {
-    const snap = ams.snapshot();
+  #renderAmsSnapshot(ams, language = 'en', userMsg = '') {
+    const snap = ams.snapshot({ userMsg });
     if (!snap) return '';
     const parts = [];
     if (snap.resident.length === 0 && snap.recent.length === 0 && snap.onDemand.length === 0) {
@@ -1906,6 +1922,11 @@ export class Engine {
     if (recallEntryCount > 0) {
       yield { type: 'recall', entryCount: recallEntryCount, cached: false, threadId };
     }
+    const topicScopesForResident = selectResidentTopicScopes(
+      topicScopesForMemory,
+      recallResult?.entries || [],
+      prompt,
+    );
 
     // Layer-A summaries — same scopes AMS Resident will surface, loaded
     // here so we can pass them into #prepareAms. (Rolling per-scope
@@ -1916,7 +1937,7 @@ export class Engine {
         ? vpPersona.vpId
         : (typeof senderVpId === 'string' ? senderVpId : undefined),
       language: this.#config.language || 'en',
-      topicScopes: topicScopesForMemory,
+      topicScopes: topicScopesForResident,
     });
 
     // ─── AMS: populate + snapshot ───────────────────────────────
@@ -1935,6 +1956,7 @@ export class Engine {
       ownVpId: ownVpIdForAms,
       summaries,
       recallEntries: recallResult ? (recallResult.entries || []) : [],
+      userMsg: prompt,
     });
     if (amsContext && amsContext.snapshotBlock) {
       memoryInjection = amsContext.snapshotBlock;

package/yeaft/memory/ams.js

@@ -17,7 +17,12 @@
  */
 
 import { approxTokens } from './budget.js';
-import { cleanMemoryPromptText, isDuplicateMemoryText, rememberMemoryText } from './prompt-cleanup.js';
+import {
+  cleanMemoryPromptText,
+  filterMemoryPromptTextForPrompt,
+  isDuplicateMemoryText,
+  rememberMemoryText,
+} from './prompt-cleanup.js';
 import { isVpForeign } from './store.js';
 
 const RECENT_DEFAULT_CAPACITY = 64;
@@ -144,16 +149,18 @@ export class ActiveMemorySet {
    * system prompt. Each layer is greedily packed within its budget;
    * overflow is dropped from this turn but not from disk.
    *
+   * @param {{ userMsg?: string }} [opts]
    * @returns {AmsSnapshot}
    */
-  snapshot() {
+  snapshot(opts = {}) {
+    const userMsg = typeof opts.userMsg === 'string' ? opts.userMsg : '';
     const seenPromptText = new Set();
 
     // Resident: pack scopes by priority order (caller provides via insert
     // order — current group's own vp first, then user, etc.).
     const { picked: resPicked, cost: resCost } = pickMemoryItems({
       items: [...this._resident.entries()].map(([scope, summary]) => ({
-        scope, summary: cleanMemoryPromptText(summary),
+        scope, summary: filterMemoryPromptTextForPrompt(summary, userMsg),
       })),
       budget: this.budget.resident,
       seen: seenPromptText,
@@ -165,7 +172,7 @@ export class ActiveMemorySet {
     const { picked: recPicked, cost: recCost } = pickMemoryItems({
       items: [...this._recent.values()]
         .reverse()
-        .map(e => ({ ...e.seg, body: cleanMemoryPromptText(e.seg?.body) })),
+        .map(e => ({ ...e.seg, body: filterMemoryPromptTextForPrompt(e.seg?.body, userMsg) })),
       budget: this.budget.recent,
       seen: seenPromptText,
       textOf: seg => seg.body,
@@ -175,7 +182,7 @@ export class ActiveMemorySet {
     // OnDemand: insertion order from caller (already FTS-ranked).
     const { picked: odPicked, cost: odCost } = pickMemoryItems({
       items: [...this._onDemand.values()]
-        .map(seg => ({ ...seg, body: cleanMemoryPromptText(seg?.body) })),
+        .map(seg => ({ ...seg, body: filterMemoryPromptTextForPrompt(seg?.body, userMsg) })),
       budget: this.budget.onDemand,
       seen: seenPromptText,
       textOf: seg => seg.body,

package/yeaft/memory/prompt-cleanup.js

@@ -8,6 +8,20 @@
 
 const DREAM_STATE_BLOCK_RE = /<!--\s*dream-state\s*-->[\s\S]*?<!--\s*\/dream-state\s*-->/gi;
 
+const TRANSIENT_MEMORY_RE = /\b(work\s*item|current\s+(?:state|work|task)|in[_ -]?progress|todo|next\s+step|blocker|blocked|pr\s*#?\d+|pull\s+request|review|merge\s+commit|release\s+tag|tag\s+v\d|v\d+\.\d+\.\d+)\b|(?:工作项|当前(?:状态|任务|工作)|正在|待办|下一步|阻塞|评审|合并|发布|标签|已推|已合并|已完成)/i;
+const ASCII_WORD_RE = /[a-z0-9_]{3,}/gi;
+const CJK_RUN_RE = /[\u4e00-\u9fff]{2,}/g;
+const MARKDOWN_LIST_ITEM_RE = /^\s*(?:[-*+]\s+|\d+[.)]\s+)/;
+const COMMON_INTENT_TOKENS = new Set([
+  'current', 'state', 'work', 'task', 'item', 'items', 'todo', 'todos',
+  'next', 'step', 'steps', 'done', 'completed', 'finish', 'finished',
+  'merge', 'merged', 'review', 'reviewed', 'release', 'tag', 'tags',
+  'pr', 'pull', 'request', 'issue', 'fix', 'feat', 'test', 'tests',
+  'dream', 'memory', 'session', 'topic', 'status', 'blocker', 'blocked',
+  '当前', '状态', '任务', '工作', '工作项', '待办', '下一步', '完成', '已完成',
+  '合并', '评审', '发布', '标签', '记忆', '主题', '阻塞', '正在',
+]);
+
 /**
  * Remove Dream scheduler metadata blocks from memory text.
  *
@@ -31,6 +45,134 @@ export function cleanMemoryPromptText(text) {
     .trim();
 }
 
+/**
+ * Whether a memory item describes short-lived execution state rather than a
+ * stable preference / project fact. Transient memory is still valid on disk, but
+ * should only enter the prompt when it is related to the current user turn.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function isTransientMemoryText(text) {
+  return TRANSIENT_MEMORY_RE.test(cleanMemoryPromptText(text));
+}
+
+/**
+ * Conservative prompt relevance gate for transient Dream memories. Stable
+ * memories are handled by the caller; this function only answers whether a
+ * known-transient item has lexical overlap with the current user request.
+ *
+ * @param {string} memoryText
+ * @param {string} userText
+ * @returns {boolean}
+ */
+export function isTransientMemoryRelevant(memoryText, userText) {
+  return isMemoryPromptRelevant(memoryText, userText);
+}
+
+/**
+ * Conservative lexical relevance check used only at prompt assembly time. It is
+ * deliberately not semantic clustering: if there is no concrete token overlap,
+ * the memory should win again through FTS when the user asks for it explicitly.
+ *
+ * @param {string} memoryText
+ * @param {string} userText
+ * @returns {boolean}
+ */
+export function isMemoryPromptRelevant(memoryText, userText) {
+  const memoryTokens = promptRelevanceTokens(memoryText);
+  const userTokens = promptRelevanceTokens(userText);
+  if (memoryTokens.size === 0 || userTokens.size === 0) return false;
+  for (const token of memoryTokens) {
+    if (userTokens.has(token)) return true;
+  }
+  return false;
+}
+
+/**
+ * Drop irrelevant transient paragraphs while preserving stable memory text. This
+ * keeps disk memory intact; it only trims what enters the current prompt.
+ *
+ * @param {string} text
+ * @param {string} userText
+ * @returns {string}
+ */
+export function filterMemoryPromptTextForPrompt(text, userText) {
+  const cleaned = cleanMemoryPromptText(text);
+  if (!cleaned || !userText) return cleaned;
+  const kept = [];
+  for (const chunk of splitMemoryPromptChunks(cleaned)) {
+    if (!isTransientMemoryText(chunk) || isTransientMemoryRelevant(chunk, userText)) {
+      kept.push(chunk);
+    }
+  }
+  return joinMemoryPromptChunks(kept).trim();
+}
+
+function splitMemoryPromptChunks(text) {
+  const chunks = [];
+  for (const block of String(text || '').split(/\n{2,}/)) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+    chunks.push(...splitListBlock(trimmed));
+  }
+  return chunks;
+}
+
+function splitListBlock(block) {
+  const lines = block.split('\n');
+  if (!lines.some(line => MARKDOWN_LIST_ITEM_RE.test(line))) return [block];
+
+  const chunks = [];
+  let current = [];
+  for (const line of lines) {
+    if (MARKDOWN_LIST_ITEM_RE.test(line) && current.length > 0) {
+      chunks.push(current.join('\n').trim());
+      current = [];
+    }
+    current.push(line);
+  }
+  if (current.length > 0) chunks.push(current.join('\n').trim());
+  return chunks.filter(Boolean);
+}
+
+function joinMemoryPromptChunks(chunks) {
+  const out = [];
+  let previousWasList = false;
+  for (const chunk of chunks) {
+    const isList = MARKDOWN_LIST_ITEM_RE.test(chunk);
+    if (out.length > 0 && !(previousWasList && isList)) out.push('');
+    out.push(chunk);
+    previousWasList = isList;
+  }
+  return out.join('\n');
+}
+
+/**
+ * @param {string} text
+ * @returns {Set<string>}
+ */
+export function promptRelevanceTokens(text) {
+  const cleaned = cleanMemoryPromptText(text).toLowerCase();
+  const out = new Set();
+  for (const match of cleaned.matchAll(ASCII_WORD_RE)) {
+    const token = match[0];
+    if (!COMMON_INTENT_TOKENS.has(token)) out.add(token);
+  }
+  for (const match of cleaned.matchAll(CJK_RUN_RE)) {
+    for (const token of cjkBigrams(match[0])) {
+      if (!COMMON_INTENT_TOKENS.has(token)) out.add(token);
+    }
+  }
+  return out;
+}
+
+function cjkBigrams(text) {
+  const out = [];
+  for (let i = 0; i < text.length - 1; i += 1) out.push(text.slice(i, i + 2));
+  return out;
+}
+
 /**
  * Normalized key for conservative prompt dedupe. This is intentionally simple:
  * exact semantic clustering belongs in Dream; prompt assembly only removes

package/yeaft/work-center/runner.js

@@ -756,6 +756,21 @@ export class WorkItemRunner {
         };
       }
       const dependencies = this.store.listActionDependencies(workItem.id, action.dependsOnStageIds || []);
+      if (dependencies.length > 0 && dependencies.every(dependency => (
+        dependency.workspaceMode === 'shared' && !dependency.workspace?.isolated
+      ))) {
+        const persistedAction = this.store.setActionWorkspaceForRun(
+          action.id,
+          run.id,
+          ownerBootId,
+          run.leaseEpoch,
+          action.generation,
+          null,
+          'shared',
+        );
+        if (!persistedAction) throw integrationFenceError('Work Center integration fallback lost its Run lease');
+        return { ...claim, action: persistedAction };
+      }
       const integration = prepareActionIntegration({
         workDir: workItem.workspaceKey || workItem.workDir,
         dependencies,

package/yeaft/work-center/store.js

@@ -933,6 +933,21 @@ export class WorkItemStore {
       const nextWorkspaceMode = workspaceMode || action.workspaceMode;
       const specChanged = nextWorkspaceMode !== action.workspaceMode;
       const nextAction = { ...action, workspaceMode: nextWorkspaceMode };
+      const now = this.now();
+      if (action.workspaceMode === 'isolated-write' && nextWorkspaceMode === 'shared') {
+        const workItem = this.getWorkItem(action.workItemId);
+        const workspaceConflict = workItem?.workspaceKey
+          ? this.db.prepare(`SELECT 1 FROM actions running
+            JOIN work_items running_item ON running_item.id = running.work_item_id
+            WHERE running.id != ? AND running.status = 'running'
+              AND running_item.workspace_key = ? LIMIT 1`).get(action.id, workItem.workspaceKey)
+          : null;
+        if (workspaceConflict) {
+          const error = new Error('Work Center cannot fall back to shared while the workspace has another running Action');
+          error.workItemPrepareDeferred = true;
+          throw error;
+        }
+      }
       const changed = this.db.prepare(`UPDATE actions SET workspace = ?, workspace_mode = ?,
         generation = generation + ?, spec_hash = ?, result_run_id = CASE WHEN ? = 1 THEN NULL ELSE result_run_id END,
         updated_at = ? WHERE id = ? AND status = 'running' AND current_run_id = ?
@@ -942,13 +957,90 @@ export class WorkItemStore {
         specChanged ? 1 : 0,
         specChanged ? actionSpecHash(nextAction) : action.specHash,
         specChanged ? 1 : 0,
-        this.now(),
+        now,
         actionId,
         runId,
         leaseEpoch,
         expectedGeneration,
       );
-      return Number(changed.changes) === 1 ? this.getAction(actionId) : null;
+      if (Number(changed.changes) !== 1) return null;
+
+      if (action.workspaceMode === 'isolated-write' && nextWorkspaceMode === 'shared') {
+        const pendingRows = this.db.prepare(`SELECT * FROM actions
+          WHERE work_item_id = ? AND id != ? AND workspace_mode IN ('isolated-write', 'integrate')
+          AND status = 'ready' AND current_run_id IS NULL`).all(action.workItemId, action.id);
+        for (const row of pendingRows) {
+          const pending = mapAction(row);
+          const fallback = { ...pending, workspaceMode: 'shared', workspace: null };
+          const repaired = this.db.prepare(`UPDATE actions SET workspace = NULL, workspace_mode = 'shared',
+            generation = generation + 1, spec_hash = ?, result_run_id = NULL, updated_at = ?
+            WHERE id = ? AND status = 'ready' AND current_run_id IS NULL
+            AND generation = ? AND workspace_mode = ?`).run(
+            actionSpecHash(fallback),
+            now,
+            pending.id,
+            pending.generation,
+            pending.workspaceMode,
+          );
+          if (Number(repaired.changes) !== 1) {
+            throw new Error('Work Center could not serialize the pending Action graph after workspace fallback');
+          }
+        }
+      }
+      return this.getAction(actionId);
+    });
+  }
+
+  #graphWorkItemState(workItemId) {
+    const remaining = this.db.prepare(`SELECT id, status FROM actions WHERE work_item_id = ?
+      AND status IN ('ready', 'running', 'waiting', 'failed') ORDER BY sequence`).all(workItemId);
+    const blocked = remaining.find(candidate => candidate.status === 'waiting' || candidate.status === 'failed');
+    const runnable = remaining.find(candidate => candidate.status === 'ready' || candidate.status === 'running');
+    return {
+      status: blocked ? (blocked.status === 'waiting' ? 'waiting' : 'needs_attention')
+        : runnable ? (remaining.some(candidate => candidate.status === 'running') ? 'running' : 'ready')
+          : 'done',
+      currentActionId: blocked?.id || runnable?.id || null,
+    };
+  }
+
+  deferRun(runId, ownerBootId, leaseEpoch, reason = 'Work Center resource is temporarily busy') {
+    return withTransaction(this.db, () => {
+      const active = this.#activeRunRow(runId, ownerBootId, leaseEpoch, true);
+      if (!active) return null;
+      const action = this.getAction(active.action_id);
+      const workItem = this.getWorkItem(active.work_item_id);
+      const now = this.now();
+      const changedRun = this.db.prepare(`UPDATE runs SET status = 'interrupted', ended_at = ?, error = ?,
+        failure_kind = 'resource_deferred', failure_code = 'workspace_busy'
+        WHERE id = ? AND owner_boot_id = ? AND lease_epoch = ? AND status = 'running'`).run(
+        now, reason, runId, ownerBootId, leaseEpoch,
+      );
+      if (Number(changedRun.changes) !== 1) return null;
+      const changedAction = this.db.prepare(`UPDATE actions SET status = 'ready', attempt = MAX(attempt - 1, 0),
+        current_run_id = NULL, updated_at = ? WHERE id = ? AND status = 'running'
+        AND current_run_id = ? AND lease_epoch = ? AND generation = ?`).run(
+        now, action.id, runId, leaseEpoch, action.generation,
+      );
+      if (Number(changedAction.changes) !== 1) {
+        throw new Error('Work Center deferred Run lost the current Action fence');
+      }
+      const graphMode = isGraphWorkItem(workItem);
+      const graphState = graphMode ? this.#graphWorkItemState(workItem.id) : null;
+      const changedWorkItem = graphMode
+        ? this.db.prepare(`UPDATE work_items SET status = ?, current_action_id = ?, current_run_id = NULL,
+            updated_at = ? WHERE id = ? AND status IN ('ready', 'running', 'waiting', 'needs_attention')`).run(
+            graphState.status, graphState.currentActionId, now, workItem.id,
+          )
+        : this.db.prepare(`UPDATE work_items SET status = 'ready', current_run_id = NULL, updated_at = ?
+          WHERE id = ? AND status = 'running' AND current_action_id = ? AND current_run_id = ?`).run(
+          now, workItem.id, action.id, runId,
+        );
+      if (Number(changedWorkItem.changes) !== 1) {
+        throw new Error('Work Center deferred Run lost the WorkItem fence');
+      }
+      this.appendEvent(workItem.id, 'run.deferred', { reason }, { actionId: action.id, runId });
+      return this.getWorkItemDetail(workItem.id);
     });
   }
 
@@ -1444,6 +1536,19 @@ export class WorkItemStore {
                 OR (running.work_item_id != a.work_item_id
                   AND a.workspace_mode != 'read' AND running.workspace_mode != 'read'))
           )
+          AND NOT EXISTS (
+            SELECT 1 FROM runs deferred
+            WHERE deferred.action_id = a.id
+              AND deferred.failure_kind = 'resource_deferred'
+              AND deferred.failure_code = 'workspace_busy'
+              AND EXISTS (
+                SELECT 1 FROM actions blocker
+                JOIN work_items blocker_item ON blocker_item.id = blocker.work_item_id
+                WHERE blocker.status = 'running' AND blocker.id != a.id
+                  AND blocker_item.workspace_key != ''
+                  AND blocker_item.workspace_key = w.workspace_key
+              )
+          )
         ORDER BY a.updated_at ASC, a.sequence ASC LIMIT 1`).get();
       if (!row) return null;
       const now = this.now();
@@ -1858,14 +1963,9 @@ export class WorkItemStore {
       let currentActionId = nextAction?.id ?? (transition.keepCurrentAction ? action.id : null);
       let changedWorkItem;
       if (transition.graphAdvance) {
-        const remaining = this.db.prepare(`SELECT id, status FROM actions WHERE work_item_id = ?
-          AND status IN ('ready', 'running', 'waiting', 'failed') ORDER BY sequence`).all(workItem.id);
-        const blocked = remaining.find(candidate => candidate.status === 'waiting' || candidate.status === 'failed');
-        const runnable = remaining.find(candidate => candidate.status === 'ready' || candidate.status === 'running');
-        workItemStatus = blocked ? (blocked.status === 'waiting' ? 'waiting' : 'needs_attention')
-          : runnable ? (remaining.some(candidate => candidate.status === 'running') ? 'running' : 'ready')
-            : 'done';
-        currentActionId = blocked?.id || runnable?.id || null;
+        const graphState = this.#graphWorkItemState(workItem.id);
+        workItemStatus = graphState.status;
+        currentActionId = graphState.currentActionId;
         changedWorkItem = this.db.prepare(`UPDATE work_items SET status = ?, current_action_id = ?,
           current_run_id = NULL, ledger_revision = ledger_revision + ?, updated_at = ?
           WHERE id = ? AND status IN ('ready', 'running', 'waiting', 'needs_attention')

package/yeaft/work-center/watcher.js

@@ -143,6 +143,17 @@ export class WorkItemWatcher {
               );
               break;
             }
+            if (error?.workItemPrepareDeferred) {
+              const detail = this.store.deferRun(
+                claim.run.id,
+                this.ownerBootId,
+                claim.run.leaseEpoch,
+                error.message,
+              );
+              if (!detail) throw new Error('Work Center deferred preparation lost its Run lease');
+              this.onEvent({ type: 'run.deferred', workItem: detail });
+              break;
+            }
             this.controller.submit(claim.run.id, this.ownerBootId, claim.run.leaseEpoch, {
               outcome: error?.workItemPrepareRetryable ? 'retryable' : 'failed',
               response: '', summary: '', evidence: [],

package/yeaft/work-center/workflow.js

@@ -373,7 +373,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. 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. 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. 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. 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',