@yeaft/webchat-agent 1.0.165 → 1.0.167

package/connection/message-router.js

@@ -29,7 +29,7 @@ import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getYeaftSettings, updateYeaftSettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../yeaft/config-api.js';
 import { discoverLlmModels } from '../llm-model-discovery.js';
 import { fetchModelsDev } from '../yeaft/llm/models-dev.js';
-import { handleYeaftSessionSend, handleYeaftAskUserAnswer, handleYeaftSubAgentPrompt, handleYeaftTaskCancel, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftCreateSession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager, preloadYeaftSkillSlashCommands } from '../yeaft/web-bridge.js';
+import { handleYeaftSessionSend, handleYeaftAskUserAnswer, handleYeaftSubAgentPrompt, handleYeaftTaskCancel, handleYeaftModeSwitch, handleYeaftModelSwitch, resetYeaftSession, handleYeaftLoadHistory, handleYeaftSearchHistory, handleYeaftLoadHistoryWindow, handleYeaftLoadMoreHistory, handleYeaftAbortThread, handleYeaftAbortAll, handleYeaftAbortTurn, handleYeaftVpSubscribe, handleYeaftVpCreate, handleYeaftVpUpdate, handleYeaftVpDelete, handleYeaftVpRead, handleYeaftListSessions, handleYeaftCreateSession, handleYeaftRenameSession, handleYeaftUpdateSession, handleYeaftUpdateSessionConfig, handleYeaftArchiveSession, handleYeaftDeleteSession, handleYeaftSessionAddMember, handleYeaftSessionRemoveMember, handleYeaftSessionSetDefaultVp, handleYeaftScanWorkdirSessions, handleYeaftRestoreSession, handleYeaftDreamTrigger, handleYeaftFetchToolStats, handleYeaftFetchDebugHistory, handleYeaftMcpList, handleYeaftMcpAdd, handleYeaftMcpRemove, handleYeaftMcpReload, broadcastLanguageChange, broadcastYeaftSessionSnapshotEager, preloadYeaftSkillSlashCommands } from '../yeaft/web-bridge.js';
 import { startYeaftStatusRefresh, forceRefreshYeaftStatus } from '../yeaft/status-cache.js';
 import { handleWorkCenterRequest } from '../yeaft/work-center/bridge.js';
 
@@ -479,6 +479,14 @@ export async function handleMessage(msg) {
       await handleYeaftLoadHistory(msg);
       break;
 
+    case 'yeaft_search_history':
+      await handleYeaftSearchHistory(msg);
+      break;
+
+    case 'yeaft_load_history_window':
+      await handleYeaftLoadHistoryWindow(msg);
+      break;
+
     case 'yeaft_load_more_history':
     case 'unify_load_more_history':
       await handleYeaftLoadMoreHistory(msg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.165",
+  "version": "1.0.167",
   "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/conversation/persist.js

@@ -1395,6 +1395,105 @@ export class ConversationStore {
     return Number.isFinite(seq) ? seq : null;
   }
 
+  /**
+   * Search user-visible messages inside one Session. The scan is newest-first
+   * and stops as soon as one page plus a `hasMore` sentinel is found, so a
+   * common recent hit does not materialize the full transcript.
+   *
+   * @param {string} sessionId
+   * @param {string} query
+   * @param {{ limit?: number, beforeSeq?: number|null }} [opts]
+   * @returns {{ results: object[], hasMore: boolean, nextBeforeSeq: number|null }}
+   */
+  searchVisibleBySession(sessionId, query, opts = {}) {
+    const needle = typeof query === 'string' ? query.trim().toLocaleLowerCase() : '';
+    if (!sessionId || needle.length < 2) return { results: [], hasMore: false, nextBeforeSeq: null };
+
+    const limit = Math.min(50, Math.max(1, Number.isFinite(opts.limit) ? Math.floor(opts.limit) : 20));
+    const beforeSeq = Number.isFinite(opts.beforeSeq) ? opts.beforeSeq : Infinity;
+    const results = [];
+    const seen = new Set();
+    let hasMore = false;
+
+    for (const message of this.#iterateSessionRows(sessionId, { beforeSeq, desc: true })) {
+      if (!message || message.sessionId !== sessionId || isHiddenConversationRow(message)) continue;
+      if (message.role !== 'user' && message.role !== 'assistant') continue;
+      if (!message.id || seen.has(message.id)) continue;
+      seen.add(message.id);
+
+      const text = this.#visibleSearchText(message.content);
+      const matchIndex = text.toLocaleLowerCase().indexOf(needle);
+      if (matchIndex < 0) continue;
+      if (results.length >= limit) {
+        hasMore = true;
+        break;
+      }
+
+      const seq = parseSeqFromId(message.id);
+      if (!Number.isFinite(seq)) continue;
+      results.push({
+        messageId: message.id,
+        turnId: message.turnId || message.threadId || message.id,
+        seq,
+        role: message.role,
+        speakerVpId: message.speakerVpId || null,
+        timestamp: message.ts || message.time || null,
+        snippet: this.#searchSnippet(text, matchIndex, needle.length),
+      });
+    }
+
+    return {
+      results,
+      hasMore,
+      nextBeforeSeq: hasMore && results.length > 0 ? results[results.length - 1].seq : null,
+    };
+  }
+
+  /**
+   * Load a bounded visible window around a search hit. This deliberately does
+   * not mutate normal older-history cursors: the web client merges the window
+   * into its cache solely to mount and focus the requested virtual-list item.
+   *
+   * @param {string} sessionId
+   * @param {number} anchorSeq
+   * @param {{ beforeTurns?: number, afterTurns?: number }} [opts]
+   * @returns {{ messages: object[], oldestSeq: number|null, hasMoreBefore: boolean }}
+   */
+  loadVisibleWindowBySession(sessionId, anchorSeq, opts = {}) {
+    if (!sessionId || !Number.isFinite(anchorSeq)) {
+      return { messages: [], oldestSeq: null, hasMoreBefore: false };
+    }
+
+    const beforeTurns = Math.min(10, Math.max(1, Number.isFinite(opts.beforeTurns) ? Math.floor(opts.beforeTurns) : 3));
+    const afterTurns = Math.min(10, Math.max(1, Number.isFinite(opts.afterTurns) ? Math.floor(opts.afterTurns) : 3));
+    const before = this.loadVisibleBySession(sessionId, anchorSeq + 1, beforeTurns + 1);
+    const messages = before.messages.slice();
+    const seen = new Set(messages.map(message => message?.id).filter(Boolean));
+    let followingUserTurns = 0;
+
+    for (const message of this.#iterateSessionRows(sessionId, { afterSeq: anchorSeq, desc: false })) {
+      if (!message || message.sessionId !== sessionId || isHiddenConversationRow(message)) continue;
+      if (message.role !== 'user' && message.role !== 'assistant') continue;
+      if (message.role === 'user') {
+        followingUserTurns += 1;
+        if (followingUserTurns > afterTurns) break;
+      }
+      if (message.id && seen.has(message.id)) continue;
+      const projected = this.#projectVisibleMessage(message);
+      if (!projected) continue;
+      if (projected.id) seen.add(projected.id);
+      messages.push(projected);
+    }
+
+    messages.sort(compareMessagesBySeq);
+    const oldestSeq = messages.length > 0 ? parseSeqFromId(messages[0].id) : null;
+    return {
+      messages,
+      oldestSeq: Number.isFinite(oldestSeq) ? oldestSeq : null,
+      hasMoreBefore: before.hasMore,
+    };
+  }
+
   /**
    * Count hot messages.
    *
@@ -2115,6 +2214,33 @@ export class ConversationStore {
     };
   }
 
+  #visibleSearchText(content) {
+    if (typeof content === 'string') return content.replace(/\s+/g, ' ').trim();
+    if (!Array.isArray(content)) return '';
+    return content
+      .filter(part => part && typeof part === 'object' && part.type === 'text')
+      .map(part => typeof part.text === 'string' ? part.text : '')
+      .join(' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+
+  #searchSnippet(text, matchIndex, needleLength) {
+    const radius = 90;
+    const start = Math.max(0, matchIndex - radius);
+    const end = Math.min(text.length, matchIndex + needleLength + radius);
+    return `${start > 0 ? '…' : ''}${text.slice(start, end)}${end < text.length ? '…' : ''}`;
+  }
+
+  #projectVisibleMessage(message) {
+    if (!message || (message.role !== 'user' && message.role !== 'assistant')) return null;
+    if (message.role !== 'assistant' || !Array.isArray(message.toolCalls) || message.toolCalls.length === 0) {
+      return message;
+    }
+    const { toolCalls, ...rest } = message;
+    return { ...rest, toolSummaryCount: toolCalls.length };
+  }
+
   #readSegmentRows(conversationDir, opts = {}) {
     return this.#segmentStoreForConversationDir(conversationDir).readAll(opts);
   }

package/yeaft/tools/create-work-item.js

@@ -58,7 +58,8 @@ Use this when work must continue beyond the current turn, needs role handoffs, r
 
     // Dynamic import avoids tools/index -> create-work-item -> bridge -> runner
     // -> tools/index becoming a static initialization cycle.
-    const { createWorkItemFromProducer } = await import('../work-center/bridge.js');
+    const { createWorkItemFromProducer, snapshotCurrentSessionContext } = await import('../work-center/bridge.js');
+    const sessionContext = await snapshotCurrentSessionContext(sessionId);
     const detail = await createWorkItemFromProducer({
       title,
       goal,
@@ -74,6 +75,7 @@ Use this when work must continue beyond the current turn, needs role handoffs, r
         createdBy: ctx.currentVpId || 'assistant',
       },
       linkedSessionIds: [sessionId],
+      sessionContext,
       start: input.start !== false,
     });
     return JSON.stringify({

package/yeaft/web-bridge.js

@@ -50,6 +50,7 @@ import {
   restoreSessionToRegistry,
   readWorkDirRegistry,
   migrateRegisteredWorkDirSessions,
+  resolveSessionYeaftDir,
 } from './sessions/session-crud.js';
 import { openSession, loadSessionMeta } from './sessions/session-store.js';
 import { loadSessionConfig, resolveSessionConfig, SessionConfigError } from './sessions/session-config.js';
@@ -5872,6 +5873,82 @@ export async function handleYeaftLoadHistory(msg) {
  *
  * @param {object} msg — { sessionId, beforeSeq, turns }
  */
+export async function handleYeaftSearchHistory(msg) {
+  const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
+  const query = typeof msg?.query === 'string' ? msg.query.trim().slice(0, 500) : '';
+  const requestId = typeof msg?.requestId === 'string' ? msg.requestId : null;
+  const beforeSeq = Number.isFinite(msg?.beforeSeq) ? msg.beforeSeq : null;
+  const limit = Math.min(50, Math.max(1, Number.isFinite(msg?.limit) ? Math.floor(msg.limit) : 20));
+  const response = {
+    type: 'yeaft_history_search_result',
+    requestId,
+    sessionId: sessionId || null,
+    query,
+    results: [],
+    hasMore: false,
+    nextBeforeSeq: null,
+    _requestClientId: msg?._requestClientId || null,
+  };
+
+  if (!sessionId || query.length < 2) {
+    sendToServer(response);
+    return;
+  }
+
+  try {
+    const defaultYeaftDir = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
+    const storeDir = resolveSessionYeaftDir(defaultYeaftDir, sessionId);
+    const store = new ConversationStore(storeDir);
+    const result = store.searchVisibleBySession(sessionId, query, { limit, beforeSeq });
+    sendToServer({ ...response, ...result });
+  } catch (err) {
+    console.error('[Yeaft] Session history search failed:', err?.message || err);
+    sendToServer({ ...response, error: 'search_failed' });
+  }
+}
+
+export async function handleYeaftLoadHistoryWindow(msg) {
+  const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
+  const requestId = typeof msg?.requestId === 'string' ? msg.requestId : null;
+  const anchorSeq = Number(msg?.anchorSeq);
+  const anchorMessageId = typeof msg?.anchorMessageId === 'string' ? msg.anchorMessageId : null;
+  const response = {
+    type: 'yeaft_history_window',
+    requestId,
+    conversationId: ensureYeaftConversationId(),
+    sessionId: sessionId || null,
+    anchorMessageId,
+    anchorSeq: Number.isFinite(anchorSeq) ? anchorSeq : null,
+    messages: [],
+    oldestSeq: null,
+    hasMoreBefore: false,
+    _requestClientId: msg?._requestClientId || null,
+  };
+
+  if (!sessionId || !Number.isFinite(anchorSeq)) {
+    sendToServer({ ...response, error: 'invalid_anchor' });
+    return;
+  }
+
+  try {
+    const defaultYeaftDir = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
+    const storeDir = resolveSessionYeaftDir(defaultYeaftDir, sessionId);
+    const store = new ConversationStore(storeDir);
+    const window = store.loadVisibleWindowBySession(sessionId, anchorSeq, {
+      beforeTurns: msg?.beforeTurns,
+      afterTurns: msg?.afterTurns,
+    });
+    sendToServer({
+      ...response,
+      ...window,
+      messages: projectVisibleHistoryChunkMessages(window.messages),
+    });
+  } catch (err) {
+    console.error('[Yeaft] Session history anchor load failed:', err?.message || err);
+    sendToServer({ ...response, error: 'window_load_failed' });
+  }
+}
+
 export async function handleYeaftLoadMoreHistory(msg) {
   const sessionId = (msg && typeof msg.sessionId === 'string' && msg.sessionId) || null;
   const perfTraceId = typeof msg?.perfTraceId === 'string' && msg.perfTraceId.trim() ? msg.perfTraceId.trim() : null;

package/yeaft/work-center/assignment.js

@@ -136,13 +136,21 @@ export function resolveWorkItemModel(config, vp, rawPolicy) {
     throw policyError(`Configured Work Center model is unavailable: ${model}`);
   }
   const effortOptions = Array.isArray(available?.effortOptions) ? available.effortOptions : [];
-  if (policy.effort && !effortOptions.includes(policy.effort)) {
-    throw policyError(`Configured Work Center effort is unsupported by ${model}: ${policy.effort}`);
-  }
+  const effortOrder = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+  const requestedIndex = effortOrder.indexOf(policy.effort);
+  const effort = !policy.effort || effortOptions.length === 0
+    ? null
+    : effortOptions.includes(policy.effort)
+      ? policy.effort
+      : effortOptions
+          .map(value => ({ value, distance: Math.abs(effortOrder.indexOf(value) - requestedIndex) }))
+          .filter(item => effortOrder.includes(item.value))
+          .sort((left, right) => left.distance - right.distance
+            || effortOrder.indexOf(right.value) - effortOrder.indexOf(left.value))[0]?.value || null;
   const parsed = parseModelRef(model);
   return {
     model,
-    effort: policy.effort || null,
+    effort,
     provider: available?.provider || parsed.providerName || null,
     source,
     policy,

package/yeaft/work-center/bridge.js

@@ -9,6 +9,7 @@ import { projectWorkCenterEvent, projectWorkItemDetail } from './projection.js';
 import { previewWorkCenterPlan } from './planner.js';
 import { readWorkCenterSettings, writeWorkCenterSettings } from './settings.js';
 import { defaultWorkCenterStageInstructions } from './workflow.js';
+import { snapshotSessionContext } from './session-context.js';
 import { join } from 'node:path';
 
 let service = null;
@@ -22,8 +23,7 @@ const BROWSER_DETAIL_OPS = new Set(['get', 'create', 'update', 'start', 'cancel'
 // client-supplied value and only emits files resolved from owned upload ids.
 const BROWSER_FILE_FIELDS = Object.freeze({
   create: [
-    'title', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'reuseMemory', 'origin',
-    'linkedSessionIds', 'files', 'start',
+    'title', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'reuseMemory', 'files', 'start',
   ],
   guide: ['id', 'guidance', 'actionId', 'revision', 'files'],
 });
@@ -100,6 +100,7 @@ async function createDefaultService() {
     },
     policyProvider: async () => readWorkCenterSettings(yeaftDir),
     attachmentRoot: join(yeaftDir, 'work-center', 'attachments'),
+    actionWorktreeRoot: join(yeaftDir, 'work-center', 'worktrees'),
     registry: defaultRegistry,
     store: null,
   });
@@ -107,6 +108,9 @@ async function createDefaultService() {
     yeaftDir,
     runner,
     runtimeInfoProvider: getSettingsRuntime,
+    watcherOptions: {
+      concurrencyProvider: () => readWorkCenterSettings(yeaftDir).maxConcurrentActions,
+    },
     onEvent(event) {
       send({ type: 'work_center_event', event: projectWorkCenterEvent(event) });
     },
@@ -140,6 +144,11 @@ export async function bootWorkCenter() {
   return ensureWorkCenter();
 }
 
+export async function snapshotCurrentSessionContext(sessionId) {
+  const runtime = await getRuntime();
+  return snapshotSessionContext(runtime?.conversationStore, sessionId);
+}
+
 export async function createWorkItemFromProducer(payload) {
   const workCenter = await ensureWorkCenter();
   return workCenter.handle('create', payload, { trustedProducer: true });

package/yeaft/work-center/controller.js

@@ -6,6 +6,7 @@ import {
   initialActionFor,
   RUN_OUTCOMES,
 } from './workflow.js';
+import { renderSessionContextSnapshot } from './session-context.js';
 import { normalizeEvidence } from './evidence.js';
 
 function normalizeCriteria(value) {
@@ -132,12 +133,18 @@ export class WorkflowController {
       attachments: Array.isArray(input.attachments) ? input.attachments : [],
     };
     let firstAction = input.start !== false ? initialActionFor(draft) : null;
+    if (firstAction) {
+      firstAction = {
+        ...firstAction,
+        instruction: actionInstruction(firstAction, draft, [], renderSessionContextSnapshot(draft.sessionContext)),
+      };
+    }
     if (firstAction && draft.reuseMemory !== false) {
       const context = this.store.getReusableContext(draft.workDir, draft.id);
       firstAction = {
         ...firstAction,
         context,
-        instruction: actionInstruction(firstAction, draft, context),
+        instruction: actionInstruction(firstAction, draft, context, renderSessionContextSnapshot(draft.sessionContext)),
       };
     }
     return this.store.createWorkItem(draft, firstAction);
@@ -151,7 +158,7 @@ export class WorkflowController {
       return {
         ...action,
         context,
-        instruction: actionInstruction(action, workItem, context),
+        instruction: actionInstruction(action, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
       };
     });
     if (!detail) throw new Error(`WorkItem not found: ${id}`);
@@ -200,7 +207,7 @@ export class WorkflowController {
       return {
         ...step,
         context,
-        instruction: actionInstruction(step, workItem, context),
+        instruction: actionInstruction(step, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
         maxAttempts: previous.maxAttempts || 2,
       };
     }, input.attachments);
@@ -221,6 +228,9 @@ export class WorkflowController {
             assignmentPolicy: previous.assignmentPolicy,
             modelPolicy: previous.modelPolicy,
             requiredRole: previous.requiredRole,
+            dependsOnStageIds: previous.dependsOnStageIds,
+            workspaceMode: previous.workspaceMode,
+            changesRequestedStageId: previous.changesRequestedStageId,
             brief: previous.brief,
           }
         : initialActionFor(workItem);
@@ -240,7 +250,7 @@ export class WorkflowController {
       return {
         ...step,
         context,
-        instruction: actionInstruction(step, workItem, context),
+        instruction: actionInstruction(step, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
         maxAttempts: previous?.maxAttempts || 2,
       };
     });
@@ -287,6 +297,7 @@ export class WorkflowController {
             workItemStatus: 'waiting',
             keepCurrentAction: true,
             eventType: 'action.waiting',
+            graphAdvance: workItem.workflowSnapshot?.executionMode === 'graph',
             eventData: { reason: result.waitingReason },
           };
         }
@@ -298,6 +309,7 @@ export class WorkflowController {
             workItemStatus: retryable ? 'ready' : 'needs_attention',
             keepCurrentAction: true,
             eventType: retryable ? 'action.retry_scheduled' : 'action.retry_exhausted',
+            graphAdvance: workItem.workflowSnapshot?.executionMode === 'graph',
             eventData: {
               attempt: action.attempt,
               maxAttempts: action.maxAttempts,
@@ -312,6 +324,7 @@ export class WorkflowController {
             workItemStatus: 'needs_attention',
             keepCurrentAction: true,
             eventType: 'action.failed',
+            graphAdvance: workItem.workflowSnapshot?.executionMode === 'graph',
             eventData: { error: result.error },
           };
         }
@@ -332,6 +345,35 @@ export class WorkflowController {
         const plannedWorkItem = generatedWorkflow
           ? { ...effectiveWorkItem, workflowSnapshot: generatedWorkflow }
           : effectiveWorkItem;
+        const context = [...(action.context || []), contextEntry(action, result, activeRun)];
+        if (plannedWorkItem.workflowSnapshot?.executionMode === 'graph') {
+          if (action.type === 'review' && result.reviewDecision === 'changes_requested') {
+            const targetStage = plannedWorkItem.workflowSnapshot.stages
+              .find(stage => stage.id === action.changesRequestedStageId);
+            if (!targetStage) throw new Error('Work Center review return target is missing');
+            return {
+              actionStatus: 'completed', workItemStatus: 'ready', graphAdvance: true,
+              graphResetStageId: action.changesRequestedStageId,
+              graphResetAction: actionForStage(targetStage, plannedWorkItem, context),
+              eventType: 'review.changes_requested',
+              eventData: { targetStageId: action.changesRequestedStageId },
+            };
+          }
+          const nextActions = generatedWorkflow
+            ? generatedWorkflow.stages.slice(1).map(stage => actionForStage(stage, plannedWorkItem, context))
+            : [];
+          return {
+            actionStatus: 'completed',
+            workItemStatus: nextActions.length > 0 ? 'ready' : 'running',
+            contractPatch,
+            workflowSnapshot: generatedWorkflow,
+            nextActions,
+            graphAdvance: true,
+            eventType: 'action.completed',
+            eventData: { nextActionCount: nextActions.length, reviewDecision: result.reviewDecision },
+          };
+        }
+
         const nextStep = getNextStep(plannedWorkItem, action.stageId || action.type, result);
         if (!nextStep) {
           return {
@@ -344,7 +386,6 @@ export class WorkflowController {
           };
         }
 
-        const context = [...(action.context || []), contextEntry(action, result, activeRun)];
         return {
           actionStatus: 'completed',
           workItemStatus: 'ready',

package/yeaft/work-center/projection.js

@@ -100,6 +100,8 @@ function projectAction(action, runs) {
     type: action.type,
     stageId: action.stageId || action.type,
     assignmentPolicy: projectAssignmentPolicy(action.assignmentPolicy),
+    dependsOnStageIds: Array.isArray(action.dependsOnStageIds) ? action.dependsOnStageIds : [],
+    workspaceMode: action.workspaceMode || 'shared',
     requiredRole: action.requiredRole || '',
     brief: normalizeActionBrief(action.brief, action.type),
     status: action.status,
@@ -152,6 +154,7 @@ export function projectWorkItemDetail(detail) {
     workflowTemplate: detail.workflowTemplate,
     workItemType: detail.workflowSnapshot?.workItemType || null,
     planningMode: detail.workflowSnapshot?.planningMode || 'static',
+    executionMode: detail.workflowSnapshot?.executionMode || 'linear',
     status: detail.status,
     currentActionId: detail.currentActionId || null,
     executionStats: sumExecutionStats(Array.isArray(detail.runs) ? detail.runs : []),
@@ -206,6 +209,7 @@ export function projectWorkItemSummary(detail) {
     goal: detail.goal,
     workItemType: detail.workflowSnapshot?.workItemType || null,
     planningMode: detail.workflowSnapshot?.planningMode || 'static',
+    executionMode: detail.workflowSnapshot?.executionMode || 'linear',
     status: detail.status,
     currentActionId: detail.currentActionId || null,
     executionStats: sumExecutionStats(Array.isArray(detail.runs) ? detail.runs : []),