@yeaft/webchat-agent 1.0.76 → 1.0.78

package/yeaft/conversation/search.js

@@ -8,14 +8,24 @@ import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import { parseMessage, parseSeqFromId } from './persist.js';
 
+function parseJsonLine(line) {
+  if (!line || !line.trim()) return null;
+  try {
+    const msg = JSON.parse(line);
+    return msg && typeof msg === 'object' ? msg : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
- * Search messages in a directory for a keyword.
+ * Search Markdown messages in a directory for a keyword.
  *
  * @param {string} dir — messages directory
  * @param {string} keyword — search term (case-insensitive)
  * @returns {object[]} — matching messages
  */
-function searchDir(dir, keyword) {
+function searchMarkdownDir(dir, keyword) {
   if (!existsSync(dir)) return [];
 
   const lowerKeyword = keyword.toLowerCase();
@@ -35,6 +45,29 @@ function searchDir(dir, keyword) {
   return results;
 }
 
+function searchSegmentDir(dir, keyword) {
+  if (!existsSync(dir)) return [];
+  const lowerKeyword = keyword.toLowerCase();
+  const files = readdirSync(dir)
+    .filter(f => f.endsWith('.jsonl'))
+    .sort()
+    .reverse();
+
+  const results = [];
+  for (const file of files) {
+    const raw = readFileSync(join(dir, file), 'utf8');
+    if (!raw.toLowerCase().includes(lowerKeyword)) continue;
+    const lines = raw.split('\n');
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const line = lines[i];
+      if (!line || !line.toLowerCase().includes(lowerKeyword)) continue;
+      const msg = parseJsonLine(line);
+      if (msg) results.push(msg);
+    }
+  }
+  return results;
+}
+
 function compareNewest(a, b) {
   const sa = parseSeqFromId(a?.id);
   const sb = parseSeqFromId(b?.id);
@@ -42,7 +75,7 @@ function compareNewest(a, b) {
   return String(b?.time || '').localeCompare(String(a?.time || ''));
 }
 
-function sessionConversationMessageDirs(dir) {
+function sessionConversationDirs(dir) {
   const dirs = [];
   const seen = new Set();
   for (const rootName of ['sessions', 'groups']) {
@@ -57,12 +90,9 @@ function sessionConversationMessageDirs(dir) {
       }
 
       const conversationDir = join(sessionDir, 'conversation');
-      for (const kind of ['messages', 'cold']) {
-        const messagesDir = join(conversationDir, kind);
-        if (seen.has(messagesDir)) continue;
-        seen.add(messagesDir);
-        dirs.push(messagesDir);
-      }
+      if (seen.has(conversationDir)) continue;
+      seen.add(conversationDir);
+      dirs.push(conversationDir);
     }
   }
   return dirs;
@@ -79,17 +109,23 @@ function sessionConversationMessageDirs(dir) {
 export function searchMessages(dir, keyword, limit = 20) {
   if (!keyword || !keyword.trim()) return [];
 
-  const dirs = [
-    join(dir, 'chat', 'messages'),
-    join(dir, 'chat', 'cold'),
-    ...sessionConversationMessageDirs(dir),
+  const conversationDirs = [
+    join(dir, 'chat'),
+    ...sessionConversationDirs(dir),
+  ];
+
+  const markdownDirs = [
+    ...conversationDirs.flatMap(d => [join(d, 'messages'), join(d, 'cold')]),
     // Compatibility for profiles created before chat/session split.
     join(dir, 'conversation', 'messages'),
     join(dir, 'conversation', 'cold'),
   ];
+  const segmentDirs = conversationDirs.map(d => join(d, 'segments'));
 
-  return dirs
-    .flatMap(d => searchDir(d, keyword))
+  return [
+    ...segmentDirs.flatMap(d => searchSegmentDir(d, keyword)),
+    ...markdownDirs.flatMap(d => searchMarkdownDir(d, keyword)),
+  ]
     .sort(compareNewest)
     .slice(0, limit);
 }

package/yeaft/session.js

@@ -45,7 +45,7 @@ import { TaskManager } from './tasks/manager.js';
 // resumes with the same onDemand/recent membership it had on
 // disconnect. Engine.#runQuery uses the registry to populate the
 // AMS each turn and to run `memory/adjust.js` post-turn.
-import { ensureDefaultSessionIfEmpty } from './sessions/session-crud.js';
+import { ensureDefaultSessionIfEmpty, yeaftDirForWorkDir } from './sessions/session-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { topUpDefaultVps } from './vp/seed-topup.js';
 import { archiveLegacyScopes } from './memory/seed-backfill.js';
@@ -71,6 +71,7 @@ const DEFAULT_COMPACT_TRIGGER_RATIO = 0.7;
 /**
  * @typedef {Object} SessionOptions
  * @property {string} [dir] — Yeaft data directory override (default: ~/.yeaft)
+ * @property {string} [workDir] — Session workDir; when provided, storage lives under <workDir>/.yeaft while config still comes from dir/defaults
  * @property {string} [model] — Model override
  * @property {string} [language] — Language override ('en' | 'zh')
  * @property {boolean} [debug] — Debug mode override
@@ -136,6 +137,7 @@ function prepareToolStatsDir(yeaftDir) {
 export async function loadSession(options = {}) {
   const {
     dir,
+    workDir,
     model,
     language,
     debug,
@@ -146,21 +148,29 @@ export async function loadSession(options = {}) {
     serverMode = false,
   } = options;
 
-  // ─── 1. Determine yeaftDir + ensure directory structure ──
-  //        Must happen BEFORE loadConfig so that first-run
-  //        generates a default config.json that loadConfig can read.
+  // ─── 1. Determine config + store directories ─────────────
+  //        Must happen BEFORE loadConfig so that first-run generates a
+  //        default config.json that loadConfig can read. workDir-backed
+  //        Sessions store conversation/session data under <workDir>/.yeaft,
+  //        but runtime config still comes from the agent-local configDir.
   const overrides = { ...configOverrides };
   if (dir) overrides.dir = dir;
   if (model) overrides.model = model;
   if (language) overrides.language = language;
   if (debug !== undefined) overrides.debug = debug;
 
-  const yeaftDir = overrides.dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
-  const initResult = initYeaftDir(yeaftDir);
-  overrides.dir = yeaftDir;
-
-  // Log any warnings from directory initialization
-  for (const w of initResult.warnings) {
+  const sessionWorkDir = typeof workDir === 'string' && workDir.trim() ? workDir.trim() : '';
+  const configDir = overrides.dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const yeaftDir = sessionWorkDir ? yeaftDirForWorkDir(sessionWorkDir) : configDir;
+  const configInitResult = initYeaftDir(configDir);
+  const storeInitResult = yeaftDir === configDir ? configInitResult : initYeaftDir(yeaftDir);
+  overrides.dir = configDir;
+
+  // Log any warnings from directory initialization.
+  const initWarnings = yeaftDir === configDir
+    ? configInitResult.warnings
+    : [...configInitResult.warnings, ...storeInitResult.warnings];
+  for (const w of initWarnings) {
     console.warn(`[Yeaft] ${w}`);
   }
 
@@ -212,7 +222,7 @@ export async function loadSession(options = {}) {
   // ─── 2a. Permission pre-check ─────────────────────────
   //         If the data dir is not writable, mark session as read-only.
   //         Persistence (conversation, memory, dream) is skipped in this mode.
-  if (!initResult.writable) {
+  if (!storeInitResult.writable) {
     config._readOnly = true;
     console.warn(`[Yeaft] ${yeaftDir} is not writable — running in read-only mode`);
   }
@@ -365,24 +375,23 @@ export async function loadSession(options = {}) {
   }
 
   // ─── 6. Load skills ────────────────────────────────────
-  // Project tier root for skills + MCP project assets. Per-session workDir
-  // overlays are loaded by web-bridge once it knows the selected Session meta;
-  // the base runtime still uses the agent process cwd for global/default status.
-  const projectTierRoot = process.cwd();
+  // User/global runtime assets still come from configDir. workDir, when
+  // present, is only a project tier overlay plus the storage root.
+  const projectTierRoot = sessionWorkDir || process.cwd();
 
   let skillManager;
   if (skipSkills) {
     // Pass the literal user-tier dir (matches the normal branch's tier 2)
     // so any save/remove calls land in the same place users expect. New
     // `SkillManager` API takes literal scan dirs — no auto-suffix of /skills.
-    skillManager = new SkillManager(join(yeaftDir, 'skills'));
+    skillManager = new SkillManager(join(configDir, 'skills'));
     // Don't call .load() — empty skill manager
   } else {
-    skillManager = createSkillManager(yeaftDir, projectTierRoot);
+    skillManager = createSkillManager(configDir, projectTierRoot);
   }
 
   // ─── 7. Connect MCP servers ────────────────────────────
-  const mcpConfig = loadMCPConfig(yeaftDir, undefined, projectTierRoot);
+  const mcpConfig = loadMCPConfig(configDir, undefined, projectTierRoot);
   const mcpManager = new MCPManager();
   let mcpStatus = { connected: [], failed: [] };
 

package/yeaft/web-bridge.js

@@ -12,10 +12,7 @@
  *
  * task-330c lint guard:
  *   ⚠️ DO NOT introduce greedy `text.replace(/---ROUTE---[\s\S]*$/g, '')`
- *      style strips on incoming/outgoing message bodies. Crew ROUTE
- *      stripping is owned EXCLUSIVELY by `agent/crew/routing.js`
- *      `parseRoutes()` which returns `{routes, displayBody}` with exact
- *      ranges removed.
+ *      style strips on incoming/outgoing message bodies.
  */
 
 import { delimiter, join } from 'node:path';
@@ -53,6 +50,7 @@ import {
   scanWorkdirSessions,
   restoreSessionToRegistry,
   readWorkDirRegistry,
+  yeaftDirForWorkDir,
 } from './sessions/session-crud.js';
 import { openSession, loadSessionMeta } from './sessions/session-store.js';
 import { loadSessionConfig, resolveSessionConfig, SessionConfigError } from './sessions/session-config.js';
@@ -414,6 +412,13 @@ function projectRuntimeKey(workDir) {
   return normalizeSessionWorkDir(workDir) || '__agent_cwd__';
 }
 
+function resolveStoreYeaftDirForSession(defaultYeaftDir, { sessionId = null, sessionMeta = null, workDir = '' } = {}) {
+  const normalizedWorkDir = normalizeSessionWorkDir(workDir || sessionMeta?.workDir);
+  if (normalizedWorkDir) return yeaftDirForWorkDir(normalizedWorkDir);
+  if (sessionId) return resolveSessionYeaftDir(defaultYeaftDir, sessionId);
+  return defaultYeaftDir;
+}
+
 function createThreadId() {
   return `thr_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
 }
@@ -3583,7 +3588,7 @@ async function runYeaftSessionSend(msg) {
 
   // ── Attachments (images + files) ───────────────────────────────
   // Server has already resolved fileId → { name, mimeType, data:base64,
-  // isImage } via the same path crew uses (client-conversation.js relay
+  // isImage } via the client-conversation.js relay
   // for `yeaft_*`). We persist files to disk under the agent's CWD so
   // file-tools (file-read / bash) can pick them up with relative paths,
   // and we build per-image content blocks for the LLM call. The
@@ -3880,6 +3885,11 @@ async function ensureSessionLoaded(opts = {}) {
   sessionLoadPromise = (async () => {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const normalizedWorkDir = normalizeSessionWorkDir(opts?.workDir || opts?.sessionMeta?.workDir);
+    const sessionYeaftDir = resolveStoreYeaftDirForSession(yeaftDir, {
+      sessionId: opts?.sessionId || opts?.sessionMeta?.id || null,
+      sessionMeta: opts?.sessionMeta || null,
+      workDir: normalizedWorkDir,
+    });
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
       ...(normalizedWorkDir && { workDir: normalizedWorkDir }),
@@ -5640,12 +5650,22 @@ export async function handleYeaftLoadHistory(msg) {
     const limit = (typeof msg.limit === 'number') ? msg.limit : 10;
     ensureYeaftConversationId();
 
+    let sessionMetaForRuntime = null;
+    let sessionYeaftDir = yeaftDir;
+    if (sessionId) {
+      try {
+        sessionYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
+        const metaDir = join(sessionsRoot(sessionYeaftDir), sessionId);
+        sessionMetaForRuntime = loadSessionMeta(metaDir);
+      } catch { /* best-effort metadata hint */ }
+    }
+
     // First paint must not wait for full Yeaft runtime boot (MCP connects,
-    // skill scans, memory index sync). The conversation markdown store is the
+    // skill scans, memory index sync). The conversation segment store is the
     // source of truth and can be opened cheaply, so replay the visible message
     // window immediately, then finish loadSession below for actual turns.
     const coldStoreStart = perfNowMs();
-    const coldStore = new ConversationStore(yeaftDir);
+    const coldStore = new ConversationStore(sessionYeaftDir);
     traceDuration('history.cold_store_open', coldStoreStart);
     if (sessionId && (afterSeqRaw !== null || afterMessageId)) {
       let afterSeq = afterSeqRaw;
@@ -5675,14 +5695,6 @@ export async function handleYeaftLoadHistory(msg) {
     }
     historyAlreadyReplayed = true;
 
-    let sessionMetaForRuntime = null;
-    if (sessionId) {
-      try {
-        const groupYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-        const metaDir = join(sessionsRoot(groupYeaftDir), sessionId);
-        sessionMetaForRuntime = loadSessionMeta(metaDir);
-      } catch { /* best-effort metadata hint */ }
-    }
     // Full runtime boot can be expensive (memory FTS sync, skills, MCP, dream
     // boot checks). It is not needed to render persisted history, so keep this
     // request short and let message-send await the same single-flight boot when

package/crew/builtin-actions.js

@@ -1,154 +0,0 @@
-/**
- * Crew — built-in role actions (task-330a §B)
- *
- * These two actions replace the "PM 给自己发闭环消息" anti-pattern that
- * task-330a §A now rejects at the routing layer:
- *
- *   • taskClose(session, { taskId, summary, fromRole })
- *       — directly mark the task complete on the kanban + broadcast a
- *         status card via sendCrewMessage. No ROUTE round-trip.
- *
- *   • roleStandby(session, { role, reason, fromRole })
- *       — flip a role's runtime state to 'standby' and broadcast.
- *         Persistence to .crew/context/role-states.json is a 330d
- *         concern — we only define the in-memory contract here.
- *
- * Both functions are pure server-side helpers. They do NOT consume a
- * routing turn (no session.round++, no dispatchToRole). Callers that
- * choose to expose them as Claude tools (via canCallTool / mcp) must
- * wire that separately — task-330a defines the contract; tool-binding
- * lands in 330d alongside the role-state persistence layer.
- *
- * Red lines (per PM dispatch):
- *   - Do not mutate routing protocol shape (.routes / displayBody).
- *   - Do not break task-319/328 (parser tests stay green).
- *   - Old session replay must keep working — we only add new keys to
- *     session.roleStates[role], never remove.
- */
-
-import { sendCrewMessage, sendStatusUpdate } from './ui-messages.js';
-import { updateKanban, appendChangelog, updateFeatureIndex, isValidTaskId } from './task-files.js';
-
-/** Valid standby reasons — extend with care; consumers may grep for these. */
-export const STANDBY_REASONS = Object.freeze([
-  'task_closed', 'awaiting_input', 'manual', 'idle', 'paused',
-]);
-
-/**
- * Mark a task as complete on the kanban + broadcast a status card.
- *
- * Mirrors the side-effects that role-output.js performs when it detects a
- * completed TASKS block, so the two paths converge on the same kanban
- * state regardless of which one fires.
- *
- * @param {object} session
- * @param {{ taskId: string, summary?: string, fromRole?: string }} params
- * @returns {Promise<{ ok: boolean, taskId: string, reason?: string }>}
- */
-export async function taskClose(session, { taskId, summary, fromRole }) {
-  if (!session) {
-    return { ok: false, taskId: taskId || null, reason: 'no_session' };
-  }
-  if (!taskId || !isValidTaskId(taskId)) {
-    return { ok: false, taskId: taskId || null, reason: 'invalid_task_id' };
-  }
-
-  // Mark in the in-memory completion set so future kanban rebuilds keep it.
-  if (!session._completedTaskIds) session._completedTaskIds = new Set();
-  const wasAlreadyCompleted = session._completedTaskIds.has(taskId);
-  session._completedTaskIds.add(taskId);
-
-  const feature = session.features?.get(taskId);
-  const taskTitle = feature?.taskTitle || taskId;
-  const cleanSummary = (summary && String(summary).trim()) || '已完成';
-
-  // Persist to the kanban file (best-effort; warns on failure).
-  try {
-    await updateKanban(session, { taskId, completed: true, summary: cleanSummary });
-  } catch (e) {
-    console.warn(`[Crew] taskClose: updateKanban failed for ${taskId}:`, e.message);
-  }
-
-  // Append to features index + changelog only on first close (idempotent).
-  if (!wasAlreadyCompleted) {
-    updateFeatureIndex(session)
-      .catch(e => console.warn('[Crew] taskClose: updateFeatureIndex failed:', e.message));
-    appendChangelog(session, taskId, taskTitle)
-      .catch(e => console.warn(`[Crew] taskClose: appendChangelog failed for ${taskId}:`, e.message));
-  }
-
-  // Broadcast status card so the UI reflects the close immediately.
-  try {
-    sendCrewMessage({
-      type: 'crew_task_closed',
-      sessionId: session.id,
-      taskId,
-      taskTitle,
-      summary: cleanSummary,
-      fromRole: fromRole || null,
-      timestamp: Date.now(),
-    });
-    sendStatusUpdate(session);
-  } catch (e) {
-    console.warn(`[Crew] taskClose: broadcast failed for ${taskId}:`, e.message);
-  }
-
-  return { ok: true, taskId };
-}
-
-/**
- * Flip a role into 'standby' (in-memory) and broadcast.
- *
- * 330a defines the contract; 330d wires the .crew/context/role-states.json
- * persistence. We DO mutate `session.roleStates[role].standby` here so the
- * UI / status pipeline can reflect the change immediately, and 330d can
- * snapshot it on the next debounced save.
- *
- * @param {object} session
- * @param {{ role: string, reason?: string, fromRole?: string }} params
- * @returns {{ ok: boolean, role: string, reason?: string }}
- */
-export function roleStandby(session, { role, reason, fromRole }) {
-  if (!session) {
-    return { ok: false, role: role || null, reason: 'no_session' };
-  }
-  if (!role || typeof role !== 'string') {
-    return { ok: false, role: role || null, reason: 'invalid_role' };
-  }
-  if (!session.roles || !session.roles.has(role)) {
-    return { ok: false, role, reason: 'unknown_role' };
-  }
-
-  const normalizedReason = reason && STANDBY_REASONS.includes(reason)
-    ? reason
-    : 'manual';
-
-  // Ensure the roleState bucket exists (cold-start safe).
-  let roleState = session.roleStates?.get?.(role);
-  if (!roleState) {
-    roleState = {};
-    session.roleStates?.set?.(role, roleState);
-  }
-  // New keys only — never delete legacy fields (replay safety).
-  roleState.standby = {
-    reason: normalizedReason,
-    since: Date.now(),
-    setBy: fromRole || null,
-  };
-
-  try {
-    sendCrewMessage({
-      type: 'crew_role_standby',
-      sessionId: session.id,
-      role,
-      reason: normalizedReason,
-      fromRole: fromRole || null,
-      timestamp: Date.now(),
-    });
-    sendStatusUpdate(session);
-  } catch (e) {
-    console.warn(`[Crew] roleStandby: broadcast failed for ${role}:`, e.message);
-  }
-
-  return { ok: true, role, reason: normalizedReason };
-}

package/crew/context-loader.js

@@ -1,171 +0,0 @@
-/**
- * Crew Context Loader — detect and parse .crew/ directory structure.
- *
- * Reads .crew/CLAUDE.md, session.json, per-role CLAUDE.md files,
- * kanban, and feature files. Used by the frontend to detect whether
- * a project has a Crew setup and display role metadata.
- */
-
-import { join } from 'path';
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import ctx from '../context.js';
-
-const MAX_CLAUDE_MD_LEN = 8192;
-
-/**
- * Read a file, returning null on any error.
- * @param {string} filePath
- * @returns {string|null}
- */
-function readFileOrNull(filePath) {
-  try {
-    if (!existsSync(filePath)) return null;
-    return readFileSync(filePath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Deduplicate Crew roles by roleType.
- * Crew may have dev-1, dev-2, dev-3 — collapse to a single "dev" entry.
- * Attaches per-role CLAUDE.md content.
- */
-function deduplicateRoles(sessionRoles, roleClaudes) {
-  const byType = new Map();
-  const merged = [];
-
-  for (const r of sessionRoles) {
-    const type = r.roleType || r.name;
-    const claudeMd = roleClaudes[r.name] || '';
-
-    if (byType.has(type)) continue;
-    byType.set(type, true);
-
-    const name = type;
-    let displayName = r.displayName || name;
-    displayName = displayName.replace(/-\d+$/, '');
-
-    merged.push({
-      name,
-      displayName,
-      icon: r.icon || '',
-      description: r.description || '',
-      claudeMd: claudeMd.substring(0, MAX_CLAUDE_MD_LEN),
-      roleType: type,
-      isDecisionMaker: !!r.isDecisionMaker,
-    });
-  }
-
-  return merged;
-}
-
-/**
- * Load .crew context from a project directory.
- * Returns null if .crew/ doesn't exist.
- */
-export function loadCrewContext(projectDir) {
-  const crewDir = join(projectDir, '.crew');
-  if (!existsSync(crewDir)) return null;
-
-  // 1. Shared CLAUDE.md
-  const sharedClaudeMd = readFileOrNull(join(crewDir, 'CLAUDE.md')) || '';
-
-  // 2. session.json → roles, teamType, language, features
-  let sessionRoles = [];
-  let teamType = 'dev';
-  let language = 'zh-CN';
-  let sessionFeatures = [];
-  const sessionPath = join(crewDir, 'session.json');
-  const sessionJson = readFileOrNull(sessionPath);
-  if (sessionJson) {
-    try {
-      const session = JSON.parse(sessionJson);
-      if (Array.isArray(session.roles)) sessionRoles = session.roles;
-      if (session.teamType) teamType = session.teamType;
-      if (session.language) language = session.language;
-      if (Array.isArray(session.features)) sessionFeatures = session.features;
-    } catch {
-      // Invalid JSON — ignore
-    }
-  }
-
-  // 3. Per-role CLAUDE.md from .crew/roles/*/CLAUDE.md
-  const roleClaudes = {};
-  const rolesDir = join(crewDir, 'roles');
-  if (existsSync(rolesDir)) {
-    try {
-      const roleDirs = readdirSync(rolesDir, { withFileTypes: true })
-        .filter(d => d.isDirectory())
-        .map(d => d.name);
-      for (const dirName of roleDirs) {
-        const md = readFileOrNull(join(rolesDir, dirName, 'CLAUDE.md'));
-        if (md) roleClaudes[dirName] = md;
-      }
-    } catch {
-      // Permission error or similar — ignore
-    }
-  }
-
-  // 4. Merge roles: deduplicate by roleType, attach claudeMd
-  const roles = deduplicateRoles(sessionRoles, roleClaudes);
-
-  // 5. Kanban
-  const kanban = readFileOrNull(join(crewDir, 'context', 'kanban.md')) || '';
-
-  // 6. Feature files from context/features/*.md
-  const features = [];
-  const featuresDir = join(crewDir, 'context', 'features');
-  if (existsSync(featuresDir)) {
-    try {
-      const files = readdirSync(featuresDir)
-        .filter(f => f.endsWith('.md') && f !== 'index.md')
-        .sort();
-      for (const f of files) {
-        const content = readFileOrNull(join(featuresDir, f));
-        if (content) {
-          features.push({ name: f.replace('.md', ''), content });
-        }
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  return { sharedClaudeMd, roles, kanban, features, teamType, language, sessionFeatures };
-}
-
-/**
- * Handle check_crew_context message — check if a project has .crew/ setup
- * and return role metadata for the frontend.
- */
-export function handleCheckCrewContext(msg) {
-  const { projectDir, requestId } = msg;
-  if (!projectDir) {
-    ctx.sendToServer({ type: 'crew_context_result', requestId, found: false });
-    return;
-  }
-  const crewContext = loadCrewContext(projectDir);
-  if (!crewContext) {
-    ctx.sendToServer({ type: 'crew_context_result', requestId, found: false });
-    return;
-  }
-  // Return a safe subset for the frontend (no full claudeMd content, just metadata)
-  ctx.sendToServer({
-    type: 'crew_context_result',
-    requestId,
-    found: true,
-    roles: crewContext.roles.map(r => ({
-      name: r.name,
-      displayName: r.displayName,
-      icon: r.icon,
-      description: r.description,
-      roleType: r.roleType,
-      isDecisionMaker: r.isDecisionMaker,
-      hasClaudeMd: !!(r.claudeMd && r.claudeMd.length > 0),
-    })),
-    teamType: crewContext.teamType,
-    language: crewContext.language,
-    featureCount: crewContext.features.length,
-  });
-}