@yeaft/webchat-agent 1.0.299 → 1.0.301

package/yeaft/tools/history-search.js

@@ -138,12 +138,12 @@ export default defineTool({
     en: `Search through past conversation history.
 
 Searches message content for all whitespace-separated terms (case-insensitive).
-Tool-result messages are excluded. Useful for finding previous discussions, decisions, or code snippets.
+Inside a Session, search is limited to that Session plus sibling Sessions in the same Project on this Agent. Tool-result messages are excluded. Useful for finding previous discussions, decisions, or code snippets.
 
 Results are returned newest-first with a bounded matching snippet and source metadata.`,
     zh: `搜索历史对话记录。
 
-在已持久化消息的正文中搜索全部空格分隔的关键词（不区分大小写），并排除工具结果消息。用于查找之前的讨论、决策或代码片段。
+在已持久化消息的正文中搜索全部空格分隔的关键词（不区分大小写）。在 Session 内仅搜索当前 Session，以及同一 Agent 上同 Project 的兄弟 Session；排除工具结果消息。用于查找之前的讨论、决策或代码片段。
 
 结果按最新优先返回，包含有界的命中片段和来源信息。`
   },
@@ -180,7 +180,16 @@ Results are returned newest-first with a bounded matching snippet and source met
 
     try {
       const telemetry = {};
-      const results = searchMessages(yeaftDir, keyword, limit, { telemetry });
+      const projectSessionIds = Array.isArray(ctx?.projectSessionIds)
+        ? ctx.projectSessionIds.filter(id => typeof id === 'string' && id.trim()).map(id => id.trim())
+        : [];
+      const scopedSessionIds = ctx?.sessionId
+        ? Array.from(new Set([ctx.sessionId, ...projectSessionIds]))
+        : null;
+      const results = searchMessages(yeaftDir, keyword, limit, {
+        telemetry,
+        ...(scopedSessionIds ? { sessionIds: scopedSessionIds } : {}),
+      });
       const searchTelemetry = {
         resultCount: results.length,
         scannedFiles: telemetry.scannedFiles || 0,

package/yeaft/tools/index.js

@@ -37,6 +37,7 @@ import fileEdit from './file-edit.js';
 import globTool from './glob.js';
 import grepTool from './grep.js';
 import listDir from './list-dir.js';
+import diskUsage from './disk-usage.js';
 import applyPatch from './apply-patch.js';
 import listTasks from './list-tasks.js';
 import readTaskLog from './read-task-log.js';
@@ -102,6 +103,7 @@ export const allTools = [
   globTool,
   grepTool,
   listDir,
+  diskUsage,
   applyPatch,
   listTasks,
   readTaskLog,

package/yeaft/tools/process-runner.js

@@ -0,0 +1,211 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+
+const DEFAULT_MAX_BYTES = 512 * 1024;
+const DEFAULT_KILL_GRACE_MS = 250;
+const DEFAULT_FORCE_SETTLE_MS = 1000;
+
+function abortError(signal) {
+  if (signal?.reason instanceof Error && signal.reason.name === 'AbortError') return signal.reason;
+  const error = new Error(
+    signal?.reason instanceof Error ? signal.reason.message : 'The operation was aborted',
+  );
+  error.name = 'AbortError';
+  return error;
+}
+
+function killProcessTree(proc, signal, platform, spawnProcessSync) {
+  if (!proc.pid) return false;
+  if (platform === 'win32') {
+    try {
+      const result = spawnProcessSync('taskkill', ['/pid', String(proc.pid), '/t', '/f'], {
+        stdio: 'ignore',
+        windowsHide: true,
+        timeout: 5000,
+      });
+      if (!result.error && result.status === 0) return true;
+    } catch {}
+    try { return proc.kill(signal) !== false; } catch { return false; }
+  }
+  try {
+    process.kill(-proc.pid, signal);
+    return true;
+  } catch {
+    try { return proc.kill(signal) !== false; } catch { return false; }
+  }
+}
+
+/**
+ * Execute a binary directly without a shell and keep captured output bounded.
+ *
+ * @param {string} command
+ * @param {string[]} args
+ * @param {{ cwd?: string, signal?: AbortSignal, timeoutMs?: number, maxBytes?: number, env?: NodeJS.ProcessEnv, preserveCarriageReturns?: boolean, killGraceMs?: number, forceSettleMs?: number, platform?: NodeJS.Platform, spawnProcess?: typeof spawn, spawnProcessSync?: typeof spawnSync }} [options]
+ */
+export function runProcess(command, args, options = {}) {
+  if (options.signal?.aborted) return Promise.reject(abortError(options.signal));
+
+  return new Promise((resolve, reject) => {
+    const platform = options.platform || process.platform;
+    const spawnProcess = options.spawnProcess || spawn;
+    const spawnProcessSync = options.spawnProcessSync || spawnSync;
+    const maxBytes = Number.isFinite(options.maxBytes)
+      ? Math.max(0, options.maxBytes)
+      : DEFAULT_MAX_BYTES;
+    const killGraceMs = Number.isFinite(options.killGraceMs)
+      ? Math.max(0, options.killGraceMs)
+      : DEFAULT_KILL_GRACE_MS;
+    const forceSettleMs = Number.isFinite(options.forceSettleMs)
+      ? Math.max(1, options.forceSettleMs)
+      : DEFAULT_FORCE_SETTLE_MS;
+    const proc = spawnProcess(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+      detached: platform !== 'win32',
+    });
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    let truncated = false;
+    let settled = false;
+    let timedOut = false;
+    let aborted = false;
+    let stopRequested = false;
+    let forceRequested = false;
+    let timer = null;
+    let forceTimer = null;
+    let forceSettleTimer = null;
+
+    let onStdout;
+    let onStderr;
+    let onError;
+    let onClose;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+      if (forceSettleTimer) clearTimeout(forceSettleTimer);
+      timer = null;
+      forceTimer = null;
+      forceSettleTimer = null;
+      options.signal?.removeEventListener('abort', onAbort);
+      if (onStdout) proc.stdout?.off('data', onStdout);
+      if (onStderr) proc.stderr?.off('data', onStderr);
+      if (onError) proc.off('error', onError);
+      if (onClose) proc.off('close', onClose);
+    };
+    const decode = (chunks, wasTruncated, preserveCarriageReturns = false) => {
+      const decoder = new StringDecoder('utf8');
+      let value = decoder.write(Buffer.concat(chunks));
+      if (!wasTruncated) value += decoder.end();
+      return preserveCarriageReturns ? value : value.replace(/\r/g, '');
+    };
+    const finish = code => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (aborted) {
+        reject(abortError(options.signal));
+        return;
+      }
+      resolve({
+        code: timedOut ? 124 : (code ?? 1),
+        stdout: decode(stdout, stdoutTruncated, options.preserveCarriageReturns),
+        stderr: decode(stderr, stderrTruncated),
+        truncated,
+        timedOut,
+      });
+    };
+    const forceStop = () => {
+      if (settled || forceRequested) return;
+      forceRequested = true;
+      killProcessTree(proc, 'SIGKILL', platform, spawnProcessSync);
+      forceSettleTimer = setTimeout(() => finish(null), forceSettleMs);
+      forceSettleTimer.unref?.();
+    };
+    const stop = () => {
+      if (settled || stopRequested) return;
+      stopRequested = true;
+      if (platform === 'win32') {
+        // taskkill must run while the parent PID still identifies the tree.
+        // It is already forceful, so do not wait for the direct child to exit.
+        forceRequested = true;
+        killProcessTree(proc, 'SIGKILL', platform, spawnProcessSync);
+        if (!settled) {
+          forceSettleTimer = setTimeout(() => finish(null), forceSettleMs);
+          forceSettleTimer.unref?.();
+        }
+        return;
+      }
+      killProcessTree(proc, 'SIGTERM', platform, spawnProcessSync);
+      forceTimer = setTimeout(forceStop, killGraceMs);
+      forceTimer.unref?.();
+    };
+    const onAbort = () => {
+      aborted = true;
+      stop();
+    };
+    const capture = (target, chunk, isStdout) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const current = isStdout ? stdoutBytes : stderrBytes;
+      const remaining = maxBytes - current;
+      if (remaining <= 0) {
+        truncated = true;
+        if (isStdout) stdoutTruncated = true;
+        else stderrTruncated = true;
+        stop();
+        return;
+      }
+      const bounded = buffer.length > remaining ? buffer.subarray(0, remaining) : buffer;
+      target.push(bounded);
+      if (isStdout) stdoutBytes += bounded.length;
+      else stderrBytes += bounded.length;
+      if (bounded.length !== buffer.length) {
+        truncated = true;
+        if (isStdout) stdoutTruncated = true;
+        else stderrTruncated = true;
+        stop();
+      }
+    };
+
+    onStdout = chunk => capture(stdout, chunk, true);
+    onStderr = chunk => capture(stderr, chunk, false);
+    onError = error => {
+      if (settled) return;
+      if (stopRequested) {
+        finish(null);
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    onClose = code => {
+      if (stopRequested && !forceRequested) {
+        // The direct child is gone. Kill any process that remained in its
+        // detached group before releasing the tool call.
+        forceRequested = true;
+        killProcessTree(proc, 'SIGKILL', platform, spawnProcessSync);
+      }
+      finish(code);
+    };
+    proc.stdout.on('data', onStdout);
+    proc.stderr.on('data', onStderr);
+    proc.on('error', onError);
+    proc.on('close', onClose);
+
+    if (Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        stop();
+      }, options.timeoutMs);
+      timer.unref?.();
+    }
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.signal?.aborted) onAbort();
+  });
+}

package/yeaft/tools/search-paths.js

@@ -0,0 +1,108 @@
+import { extname } from 'node:path';
+
+export const SEARCH_SKIP_DIRS = new Set([
+  'node_modules', '.git', '__pycache__', '.next', '.nuxt',
+  'dist', 'build', '.cache', '.venv', 'venv', '.tox',
+  'vendor', 'target', '.gradle', '.idea', '.vscode',
+]);
+
+export const SEARCH_SKIP_GLOBS = Object.freeze([
+  ...[...SEARCH_SKIP_DIRS].flatMap(name => [`!${name}/**`, `!**/${name}/**`]),
+  '!.yeaft/worktrees/**',
+  '!**/.yeaft/worktrees/**',
+]);
+
+const TYPE_EXTENSIONS = {
+  js: ['.js', '.jsx', '.mjs', '.cjs'], ts: ['.ts', '.tsx', '.mts', '.cts'],
+  py: ['.py'], rust: ['.rs'], go: ['.go'], java: ['.java'],
+  json: ['.json'], yaml: ['.yaml', '.yml'], markdown: ['.md', '.markdown'],
+  html: ['.html', '.htm'], css: ['.css'], shell: ['.sh', '.bash', '.zsh'],
+};
+
+export function isSkippedSearchDirectory(relativePath, name) {
+  const normalized = String(relativePath || '').replace(/\\/g, '/');
+  return SEARCH_SKIP_DIRS.has(name)
+    || normalized === '.yeaft/worktrees'
+    || normalized.endsWith('/.yeaft/worktrees');
+}
+
+function expandBraces(pattern) {
+  const match = pattern.match(/\{([^{}]+)\}/);
+  if (!match) return [pattern];
+  return match[1].split(',').flatMap(part => expandBraces(
+    pattern.slice(0, match.index) + part + pattern.slice(match.index + match[0].length),
+  ));
+}
+
+function globToRegExp(pattern) {
+  let source = '';
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === '*' && pattern[index + 1] === '*') {
+      index += 1;
+      if (pattern[index + 1] === '/') {
+        index += 1;
+        source += '(?:.*/)?';
+      } else {
+        source += '.*';
+      }
+    } else if (char === '*') {
+      source += '[^/]*';
+    } else if (char === '?') {
+      source += '[^/]';
+    } else {
+      source += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+export function createSearchPathMatcher({ glob, type } = {}) {
+  const normalizedGlob = String(glob || '').replace(/\\/g, '/');
+  const globMatchers = normalizedGlob
+    ? expandBraces(normalizedGlob).map(globToRegExp)
+    : [];
+  const matchBase = normalizedGlob && !normalizedGlob.includes('/');
+  const extensions = type ? TYPE_EXTENSIONS[type] : null;
+
+  return path => {
+    const normalized = String(path || '').replace(/\\/g, '/');
+    const candidate = matchBase ? normalized.split('/').pop() : normalized;
+    if (globMatchers.length && !globMatchers.some(matcher => matcher.test(candidate))) return false;
+    if (type && !extensions?.includes(extname(normalized).toLowerCase())) return false;
+    return true;
+  };
+}
+
+export function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  if (signal.reason instanceof Error && signal.reason.name === 'AbortError') {
+    throw signal.reason;
+  }
+  const error = new Error(
+    signal.reason instanceof Error ? signal.reason.message : 'The operation was aborted',
+  );
+  error.name = 'AbortError';
+  throw error;
+}
+
+export function isAbortError(error) {
+  return error?.name === 'AbortError';
+}
+
+export function waitForAbortable(promise, signal) {
+  throwIfAborted(signal);
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      try { throwIfAborted(signal); } catch (error) { reject(error); }
+    };
+    const cleanup = () => signal.removeEventListener('abort', onAbort);
+    signal.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve(promise).then(
+      value => { cleanup(); resolve(value); },
+      error => { cleanup(); reject(error); },
+    );
+  });
+}

package/yeaft/tools/types.js

@@ -14,6 +14,7 @@
  * @typedef {Object} ToolContext
  * @property {AbortSignal} [signal] — cancellation signal
  * @property {string} [yeaftDir] — Yeaft data directory
+ * @property {Promise<Array> & {toolReady?: Record<string, Promise<object>>}} [managedCliReady] — resolves after optional managed CLI setup; toolReady exposes per-command readiness
  * @property {ReturnType<import('../runtime-platform.js').getRuntimePlatformInfo>} [runtimePlatform]
  *   — runtime OS/shell facts for platform-aware tools
  * @property {string} [cwd] — working directory
@@ -23,6 +24,7 @@
  * @property {object} [config] — engine config
  * @property {import('../tasks/manager.js').TaskManager} [taskManager] — Session task manager
  * @property {string} [sessionId] — current Session id
+ * @property {string[]} [projectSessionIds] — same-Agent sibling Session ids in the current Project
  * @property {string} [threadId] — current Session thread id
  * @property {string} [currentVpId] — R6: VP id of the caller (set in multi-VP groups)
  * @property {string} [currentGroupId] — R6: group id of the caller's RoleInstance

package/yeaft/web-bridge.js

@@ -589,6 +589,54 @@ const vpCurrentTodos = new Map();
  *                     sessionHandle: object }>}
  */
 const sessionContexts = new Map();
+/** Latest server-authoritative Project identity and same-Agent siblings per Session. */
+const projectContextBySession = new Map();
+
+function normalizeProjectContext(value, sessionId) {
+  if (!value || typeof value !== 'object' || !Array.isArray(value.sessionIds)) return null;
+  const currentSessionId = typeof sessionId === 'string' ? sessionId.trim() : '';
+  return {
+    projectId: typeof value.projectId === 'string' && value.projectId.trim()
+      ? value.projectId.trim()
+      : null,
+    projectName: typeof value.projectName === 'string' && value.projectName.trim()
+      ? value.projectName.trim()
+      : null,
+    sessionIds: Array.from(new Set(value.sessionIds
+      .filter(id => typeof id === 'string' && id.trim())
+      .map(id => id.trim())
+      .filter(id => id !== currentSessionId))),
+  };
+}
+
+function legacyProjectContext(yeaftDir, sessionId) {
+  const project = loadProjects(yeaftDir).find(row => row.sessionIds.includes(sessionId));
+  if (!project) return null;
+  return normalizeProjectContext({
+    projectId: project.id,
+    projectName: project.name,
+    sessionIds: project.sessionIds,
+  }, sessionId);
+}
+
+function buildProjectSharedBlock(projectContext, summaries = '') {
+  const context = normalizeProjectContext(projectContext, null);
+  const body = typeof summaries === 'string' ? summaries.trim() : '';
+  if (!context?.projectId && !body) return '';
+  const lines = ['[Project Shared Context]'];
+  if (context?.projectId) {
+    const label = context.projectName
+      ? `${context.projectName} (${context.projectId})`
+      : context.projectId;
+    lines.push(`Project: ${label}`);
+    lines.push('Sharing boundary: sibling Sessions in this Project on this Agent only.');
+  } else {
+    lines.push('Sharing boundary: sibling Sessions in the same Project on this Agent only.');
+  }
+  lines.push('Read-only memory summaries preserve each source Session identity.');
+  if (body) lines.push('', body);
+  return lines.join('\n');
+}
 
 function vpKey(sessionId, vpId) {
   return `${sessionId}::${vpId}`;
@@ -1731,6 +1779,7 @@ function getOrCreateVpEngine(sessionId, vpId, threadId = 'main') {
     skillManager: session.skillManager,
     mcpManager: session.mcpManager,
     yeaftDir: session.yeaftDir,
+    managedCliReady: session.managedCliReady || null,
     // Share the session-shared ToolUsageStats so per-VP tool calls land
     // in the same on-disk snapshot the `yeaft_fetch_tool_stats` handler
     // reads. Without this, engine's record-on-tool-exec guard
@@ -2297,6 +2346,7 @@ export async function __testResetVpState() {
   asyncTaskOwners.clear();
   vpAborts.clear();
   sessionContexts.clear();
+  projectContextBySession.clear();
   vpCurrentTodos.clear();
   threadClassifier = defaultClassifyThread;
   if (_vpUnsubscribe) {
@@ -3028,8 +3078,14 @@ const PROJECT_CONTEXT_MAX_TOKENS = 4096;
 const PROJECT_CONTEXT_TRUNCATION_NOTICE = '\n[Summary truncated to Project context budget]';
 
 async function sharedProjectContext(yeaftDir, sessionId, options = {}) {
-  const project = loadProjects(yeaftDir).find(row => row.sessionIds.includes(sessionId));
-  if (!project) return '';
+  const requestedSiblingIds = Array.isArray(options.sessionIds)
+    ? options.sessionIds.filter(id => typeof id === 'string' && id.trim()).map(id => id.trim())
+    : null;
+  const project = requestedSiblingIds === null
+    ? loadProjects(yeaftDir).find(row => row.sessionIds.includes(sessionId))
+    : null;
+  const sourceSessionIds = requestedSiblingIds || project?.sessionIds || [];
+  if (sourceSessionIds.length === 0) return '';
   const memoryRoot = join(yeaftDir, 'memory');
   const language = options.language || 'en';
   const configuredBudget = Number.isFinite(options.tokenBudget) && options.tokenBudget > 0
@@ -3037,7 +3093,7 @@ async function sharedProjectContext(yeaftDir, sessionId, options = {}) {
     : PROJECT_CONTEXT_MAX_TOKENS;
   const tokenBudget = Math.min(configuredBudget, PROJECT_CONTEXT_MAX_TOKENS);
   let context = '';
-  const siblingIds = project.sessionIds
+  const siblingIds = sourceSessionIds
     .filter(id => id !== sessionId)
     .slice(0, PROJECT_CONTEXT_MAX_SIBLINGS);
   for (const siblingId of siblingIds) {
@@ -3341,6 +3397,7 @@ export function handleYeaftArchiveSession(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = archiveSession(yeaftDir, sessionId);
+    projectContextBySession.delete(sessionId);
     invalidateGroupContext(sessionId);
     sendSessionCrudResult({
       op: 'archive',
@@ -3362,6 +3419,7 @@ export function handleYeaftDeleteSession(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = deleteSession(yeaftDir, sessionId);
+    projectContextBySession.delete(sessionId);
     removeSessionFromProjects(yeaftDir, sessionId);
     ctx.assetOutbox?.removeSession(sessionId);
     // Cascade: remove every persisted message stamped with this group id.
@@ -4495,6 +4553,20 @@ async function runYeaftSessionSend(msg) {
     },
   });
 
+  const hasInboundProjectContext = Object.prototype.hasOwnProperty.call(msg, 'projectContext');
+  const inboundProjectContext = normalizeProjectContext(msg.projectContext, sessionId);
+  if (hasInboundProjectContext) {
+    projectContextBySession.set(sessionId, inboundProjectContext || {
+      projectId: null,
+      projectName: null,
+      sessionIds: [],
+    });
+  } else {
+    // An old Server does not know this field. Drop any context cached from a
+    // newer Server before falling back to this Agent's legacy projects.json.
+    projectContextBySession.delete(sessionId);
+  }
+
   // Ingest user text. The coordinator persists, applies mention/fanout
   // rules, and calls deliver() (== enqueueForVp) for each chosen VP —
   // which both (a) emits vp_typing_start and (b) ensures a driver runs.
@@ -4519,6 +4591,9 @@ async function runYeaftSessionSend(msg) {
       _promptParts: attachmentBundle.promptParts,
       _promptSuffix: attachmentBundle.promptSuffix,
       _perfTraceId: perfTraceId,
+      _projectContext: msg.projectContext && typeof msg.projectContext === 'object'
+        ? msg.projectContext
+        : null,
     });
   } catch (err) {
     console.warn('[Yeaft] yeaft_session_chat: coord.ingest failed', err?.message || err);
@@ -4762,6 +4837,7 @@ export async function ensureSessionLoaded(opts = {}) {
       skipMCP: true,
       skipSkills: true,
       serverMode: true,
+      managedCliReady: ctx.managedCliReady,
     });
     claimRuntimeOwnership(session);
 
@@ -5159,12 +5235,19 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         threadId,
       });
       if (queryOpts) {
-        const projectContext = await sharedProjectContext(ctx.CONFIG?.yeaftDir, sessionId, {
+        const envelopeProjectContext = normalizeProjectContext(inboundEnvelope?._projectContext, sessionId);
+        const projectContext = envelopeProjectContext
+          || projectContextBySession.get(sessionId)
+          || legacyProjectContext(ctx.CONFIG?.yeaftDir, sessionId);
+        const projectSessionIds = projectContext?.sessionIds || [];
+        queryOpts.projectSessionIds = projectSessionIds;
+        const projectSummaries = await sharedProjectContext(ctx.CONFIG?.yeaftDir, sessionId, {
+          sessionIds: projectSessionIds,
           language: session?.config?.language,
           tokenBudget: Math.max(512, Math.floor((session?.config?.messageTokenBudget || 32768) / 8)),
         });
-        if (projectContext) {
-          const sharedBlock = `[Project Shared Context]\nRead-only memory summaries from sibling Sessions in the same Project. Preserve each source Session identity.\n\n${projectContext}`;
+        const sharedBlock = buildProjectSharedBlock(projectContext, projectSummaries);
+        if (sharedBlock) {
           queryOpts.sessionAnnouncement = queryOpts.sessionAnnouncement
             ? `${queryOpts.sessionAnnouncement}\n\n${sharedBlock}`
             : sharedBlock;
@@ -7007,6 +7090,7 @@ export async function resetYeaftSession() {
   vpEngineConfigKeys.clear();
   asyncTaskOwners.clear();
   sessionContexts.clear();
+  projectContextBySession.clear();
   vpCurrentTodos.clear();
   threadClassifier = defaultClassifyThread;
   // History-dedup cache is keyed by per-session coordinator msg ids;
@@ -7030,6 +7114,7 @@ export async function resetYeaftSession() {
       skipMCP: true,
       skipSkills: true,
       serverMode: true,
+      managedCliReady: ctx.managedCliReady,
     });
     claimRuntimeOwnership(session);
     installYeaftRuntimeBridge(session);
@@ -7289,6 +7374,8 @@ export async function handleYeaftMcpReload(msg = {}) {
 export const __testHooks = {
   loadProjects,
   sharedProjectContext,
+  buildProjectSharedBlock,
+  normalizeProjectContext,
   loadVisibleGroupHistoryPage,
   projectVisibleHistoryChunkMessages,
   persistInboundMessageOnceByMsgId,