memorix 1.8.4 → 1.8.6

package/src/cli/commands/serve.ts

@@ -1,5 +1,10 @@
 /**
- * memorix serve — Start MCP Server on stdio
+ * memorix serve - Start MCP Server on stdio transport.
+ *
+ * The official MCP v2 stdio entry owns modern discovery, per-request metadata,
+ * legacy compatibility, and protocol lifecycle. Memorix keeps its startup
+ * gate in front of that entry so early claim-less discovery remains compatible
+ * with clients shipped before the 2026 protocol revision.
  */
 
 import { defineCommand } from 'citty';
@@ -7,6 +12,7 @@ import { resolveToolProfile } from '../../server/tool-profile.js';
 import { getMcpServerInfo } from '../../server/mcp-discovery.js';
 import { StdioStartupGate } from '../../server/stdio-startup-gate.js';
 import { mcpFileUriToPath } from '../mcp-root-path.js';
+import type { ModernMcpBridge } from '../../server/modern-mcp-bridge.js';
 
 export default defineCommand({
   meta: {
@@ -31,40 +37,42 @@ export default defineCommand({
     },
   },
   run: async ({ args }) => {
-    // Take ownership of stdin before project/config/runtime initialization. The
-    // gate answers handshake-free discovery and queues every other JSON-RPC line
-    // until the SDK transport is connected, so cold starts cannot lose requests.
+    const { serveStdio, StdioServerTransport } = await import('@modelcontextprotocol/server/stdio');
+    const { createModernMcpBridge } = await import('../../server/modern-mcp-bridge.js');
+    const { detectProject, findGitInSubdirs, isSystemDirectory } = await import('../../project/detector.js');
+    const { homedir } = await import('node:os');
+    const { writeLastProjectRoot } = await import('../../project/launch-root.js');
+    const { resolveServeProject } = await import('./serve-shared.js');
+
+    // Take ownership of stdin before project/config/runtime initialization.
+    // The gate answers the old claim-less discover probe and queues every
+    // other line until the official v2 transport is listening.
+    let stdioHandle: { close: () => Promise<void> } | undefined;
+    let stdinEndedBeforeHandle = false;
     const startupGate = new StdioStartupGate({
       stdin: process.stdin,
       stdout: process.stdout,
       serverInfo: getMcpServerInfo(),
       onError: (error) => {
         console.error(`[memorix] stdio startup gate error: ${error.message}`);
-        // The stream is no longer safe to replay after an input-limit or I/O
-        // failure. Exit instead of leaving a half-connected MCP process alive.
         process.exit(1);
       },
       onEnd: () => {
-        console.error('[memorix] stdin closed — exiting');
-        // The gate has already ended the transport input when ready. Set the
-        // exit code and let pending JSON-RPC stdout writes drain naturally.
-        process.exitCode = 0;
+        console.error('[memorix] stdin closed - exiting');
+        if (stdioHandle) {
+          void stdioHandle.close().catch((error) => {
+            console.error(`[memorix] stdio close error: ${error instanceof Error ? error.message : String(error)}`);
+          });
+        } else {
+          stdinEndedBeforeHandle = true;
+        }
       },
     });
     startupGate.start();
 
-    const { StdioServerTransport } = await import(
-      '@modelcontextprotocol/sdk/server/stdio.js'
-    );
-    const { createMemorixServer } = await import('../../server.js');
-    const { detectProject, findGitInSubdirs, isSystemDirectory } = await import('../../project/detector.js');
-    const { homedir } = await import('node:os');
-    const { resolveServeProject } = await import('./serve-shared.js');
-
-    // Priority: explicit --cwd arg > MEMORIX_PROJECT_ROOT env > INIT_CWD (npm lifecycle) > process.cwd()
+    // Priority: explicit --cwd arg > MEMORIX_PROJECT_ROOT > INIT_CWD > process.cwd().
     let safeCwd: string;
     try { safeCwd = process.cwd(); } catch { safeCwd = homedir(); }
-
     const resolution = resolveServeProject(
       {
         cwdArg: args.cwd,
@@ -75,101 +83,95 @@ export default defineCommand({
       },
       { detectProject, findGitInSubdirs, isSystemDirectory },
     );
-
-    for (const message of resolution.messages) {
-      console.error(message);
-    }
+    for (const message of resolution.messages) console.error(message);
 
     if (!resolution.detectedProject) {
       console.error(`[memorix] [WARN] ${resolution.error}`);
-      console.error(`[memorix] Starting in deferred-binding mode — project will bind via MCP roots or memorix_session_start.`);
-      console.error(`[memorix] For non-git directories, use --allow-untracked to enable untracked/ fallback.`);
-      // Don't exit — allow deferred binding via session_start or MCP roots (fixes Cursor stdio #75)
+      console.error('[memorix] Starting in deferred-binding mode - bind with memorix_session_start(projectRoot=...) when needed.');
+      console.error('[memorix] For non-git directories, use --allow-untracked to enable untracked/ fallback.');
     }
 
     const detected = resolution.detectedProject;
     const projectRoot = resolution.projectRoot;
-    if (detected) {
-      const { writeLastProjectRoot } = await import('../../project/launch-root.js');
-      writeLastProjectRoot(detected.rootPath);
-    }
+    if (detected) writeLastProjectRoot(detected.rootPath);
 
-    // Always register ALL tools BEFORE connecting transport.
-    // This ensures tools/list returns the full tool set immediately on connect.
-    // When no project detected, use deferred binding (allowUntrackedFallback=false, deferProjectInitUntilBound=true)
     const allowUntracked = args['allow-untracked'] ?? false;
-    const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: 'micro' });
-    const serverOptions = detected
-      ? { toolProfile, deferProjectRuntimeInit: true }
-      : { allowUntrackedFallback: allowUntracked, deferProjectInitUntilBound: !allowUntracked, deferProjectRuntimeInit: true, toolProfile };
-    const { server, projectId, deferredInit, switchProject } = await createMemorixServer(projectRoot, undefined, undefined, serverOptions);
-    const transport = new StdioServerTransport(startupGate.input, process.stdout);
-    await server.connect(transport);
-    startupGate.markReady();
-
-    console.error(`[memorix] MCP Server running on stdio (project: ${projectId})`);
-    console.error(`[memorix] Project root: ${detected?.rootPath ?? projectRoot}`);
+    const toolProfile = resolveToolProfile({
+      explicit: args.mode,
+      envValue: process.env.MEMORIX_MODE,
+      fallback: 'micro',
+    });
 
-    // ── MCP Roots Protocol ──────────────────────────────────────────
-    // After connect, request workspace roots from the client (IDE).
-    // This is the proper way to discover the user's workspace —
-    // no --cwd needed if the IDE supports roots capability.
-    const tryRootsSwitch = async () => {
-      try {
-        const { roots } = await server.server.listRoots();
-        if (!roots || roots.length === 0) return;
+    const transport = new StdioServerTransport(startupGate.input, process.stdout);
+    const createBridge = async (): Promise<ModernMcpBridge> => {
+      const bridge = await createModernMcpBridge({
+        projectRoot,
+        allowUntrackedFallback: allowUntracked,
+        deferProjectInitUntilBound: !allowUntracked,
+        deferProjectRuntimeInit: true,
+        toolProfile,
+      });
 
-        for (const root of roots) {
-          if (!root.uri.startsWith('file://')) continue;
-          const rootPath = mcpFileUriToPath(root.uri);
-          if (!rootPath) continue;
+      const tryRootsSwitch = async (): Promise<void> => {
+        try {
+          if (bridge.memorix.isExplicitlyBound()) return;
+          const { roots } = await bridge.server.listRoots();
+          for (const root of roots ?? []) {
+            if (!root.uri.startsWith('file://')) continue;
+            const rootPath = mcpFileUriToPath(root.uri);
+            if (!rootPath) continue;
 
-          const rootDetected = detectProject(rootPath);
-          if (rootDetected) {
-            const switched = await switchProject(rootPath);
+            const switched = await bridge.memorix.switchProject(rootPath, 'mcp-roots');
             if (switched) {
-              console.error(`[memorix] [UPDATED] Project updated via MCP roots: ${rootDetected.id}`);
+              console.error(`[memorix] [UPDATED] Project updated via MCP roots: ${rootPath}`);
+              return;
             }
-            return; // use first valid root
-          }
-          // Root itself has no .git — try its subdirs
-          const subGit = findGitInSubdirs(rootPath);
-          if (subGit) {
-            const switched = await switchProject(subGit);
-            if (switched) {
+            const subGit = findGitInSubdirs(rootPath);
+            if (subGit && await bridge.memorix.switchProject(subGit, 'mcp-roots')) {
               console.error(`[memorix] [UPDATED] Project updated via MCP roots (subdir): ${subGit}`);
+              return;
             }
-            return;
           }
+        } catch (error) {
+          console.error(`[memorix] MCP roots not available (${error instanceof Error ? error.message : 'unsupported'})`);
         }
-      } catch (err) {
-        // Client doesn't support roots — that's OK, fall back to existing detection
-        console.error(`[memorix] MCP roots not available (${(err as Error).message ?? 'unsupported'})`);
-      }
-    };
-
-    // Do NOT proactively call listRoots() after connect — this violates MCP SEP-2260
-    // which requires server-initiated requests to be associated with a client request.
-    // Some clients (e.g. Codex) treat standalone roots/list as unexpected and may
-    // fail to inject MCP tools. Instead, rely on:
-    //   1. RootsListChangedNotification (client-initiated, then we respond)
-    //   2. memorix_session_start({ projectRoot }) for explicit binding
-    //   3. cwd-based detection as fallback (already done in deferred-binding)
+      };
 
-    // Listen for roots changes (user switches workspace)
-    try {
-      const { RootsListChangedNotificationSchema } = await import('@modelcontextprotocol/sdk/types.js');
-      server.server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
-        console.error(`[memorix] Roots changed — re-detecting project...`);
+      // roots/list is a legacy-era request. The v2 SDK rejects it on the
+      // modern era, while retaining this handler keeps existing IDE clients.
+      bridge.server.setNotificationHandler('notifications/roots/list_changed', async () => {
         await tryRootsSwitch();
       });
-    } catch { /* notification handler setup is optional */ }
 
-    const deferredInitTimer = setTimeout(() => {
-      deferredInit().catch(e => console.error(`[memorix] Deferred init error:`, e));
-    }, 5_000);
-    deferredInitTimer.unref?.();
-    // Fire-and-forget: background update check. Default is notify-only.
+      const deferredInitTimer = setTimeout(() => {
+        bridge.memorix.deferredInit().catch((error) => {
+          console.error(`[memorix] Deferred init error: ${error instanceof Error ? error.message : String(error)}`);
+        });
+      }, 5_000);
+      deferredInitTimer.unref?.();
+
+      const originalClose = bridge.close.bind(bridge);
+      bridge.close = async () => {
+        clearTimeout(deferredInitTimer);
+        await originalClose();
+      };
+      return bridge;
+    };
+
+    stdioHandle = serveStdio(createBridge, {
+      transport,
+      legacy: 'serve',
+      onerror: (error) => console.error(`[memorix] stdio MCP error: ${error.message}`),
+    });
+    startupGate.markReady();
+    if (stdinEndedBeforeHandle) {
+      void stdioHandle.close().catch((error) => {
+        console.error(`[memorix] stdio close error: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }
+
+    console.error(`[memorix] MCP Server running on stdio (profile: ${toolProfile}, project: ${detected?.id ?? 'deferred'})`);
+    console.error(`[memorix] Project root: ${detected?.rootPath ?? projectRoot}`);
     import('../update-checker.js').then(m => m.checkForUpdates()).catch(() => {});
   },
 });

package/src/cli/commands/setup.ts

@@ -31,6 +31,7 @@ import { KiroMCPAdapter } from '../../workspace/mcp-adapters/kiro.js';
 import { OpenCodeMCPAdapter } from '../../workspace/mcp-adapters/opencode.js';
 import { TraeMCPAdapter } from '../../workspace/mcp-adapters/trae.js';
 import { DshMCPAdapter } from '../../workspace/mcp-adapters/dsh.js';
+import { WorkbuddyMCPAdapter } from '../../workspace/mcp-adapters/workbuddy.js';
 import { CodeBuddyMCPAdapter } from '../../workspace/mcp-adapters/codebuddy.js';
 import { getSetupIntegrationRows as readSetupIntegrationRows } from '../../integrations/registry.js';
 import { OFFICIAL_MEMORIX_SKILLS } from '../../hooks/official-skills.js';
@@ -192,6 +193,7 @@ const SUPPORTED_SETUP_AGENTS: AgentName[] = [
   'kiro',
   'trae',
   'dsh',
+  'workbuddy',
   'pi',
 ];
 
@@ -405,6 +407,7 @@ export function getMcpAdapter(agent: McpConfigAgent): MCPConfigAdapter {
     opencode: new OpenCodeMCPAdapter(),
     trae: new TraeMCPAdapter(),
     dsh: new DshMCPAdapter(),
+    workbuddy: new WorkbuddyMCPAdapter(),
   };
   return adapters[agent];
 }
@@ -1611,7 +1614,14 @@ export async function installAgentSetup(agent: AgentName, plan: SetupPlan, globa
     }
   } else if (plan.actions.includes('hooks')) {
     const result = await installHooks(agent, targetRoot, global);
-    p.log.success(`${agent}: integration files -> ${result.configPath}`);
+    const note = (result.generated as Record<string, unknown>)?.note;
+    if (result.configPath) {
+      p.log.success(`${agent}: integration files -> ${result.configPath}`);
+    } else if (note) {
+      p.log.info(`${agent}: ${note}`);
+    } else {
+      p.log.info(`${agent}: no hooks or guidance are available at this scope`);
+    }
   } else if (plan.actions.includes('project-guidance')) {
     const rulesPath = await installAgentGuidance(agent, targetRoot, global);
     p.log.success(`${agent}: guidance -> ${rulesPath}`);

package/src/cli/commands/uninstall.ts

@@ -24,7 +24,7 @@ import * as os from 'node:os';
 
 // ── MCP config paths (documented, not modified) ────────────────────
 
-interface MCPConfigEntry {
+export interface MCPConfigEntry {
   agent: string;
   path: string;
   kind: 'project' | 'global';
@@ -66,7 +66,7 @@ function checkDshPatch(p: string): boolean {
 }
 
 /** Detects memorix MCP config entries in both global and project-level paths. */
-function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
+export function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
   const entries: MCPConfigEntry[] = [];
 
   // ── Global paths ──
@@ -236,6 +236,28 @@ function getMCPConfigEntries(home: string, cwd: string): MCPConfigEntry[] {
     note: 'Remove the memory-memorix insert row from this patch file.',
   });
 
+  // WorkBuddy — global
+  const workbuddyCfg = path.join(home, '.workbuddy', 'mcp.json');
+  entries.push({
+    agent: 'WorkBuddy',
+    path: workbuddyCfg,
+    kind: 'global',
+    format: 'json',
+    detected: checkJSON(workbuddyCfg),
+    note: 'Remove the "memorix" key from mcpServers in this file.',
+  });
+
+  // WorkBuddy — project level (project-only installs must be discoverable too)
+  const workbuddyProjectCfg = path.join(cwd, '.workbuddy', 'mcp.json');
+  entries.push({
+    agent: 'WorkBuddy',
+    path: workbuddyProjectCfg,
+    kind: 'project',
+    format: 'json',
+    detected: checkJSON(workbuddyProjectCfg),
+    note: 'Remove the "memorix" key from mcpServers in this file.',
+  });
+
   return entries;
 }
 

package/src/cli/index.ts

@@ -389,7 +389,7 @@ const main = defineCommand({
       console.error('  integrate  Install one IDE integration into the current repo');
       console.error('  status     Show project info + stats');
       console.error('  dashboard  Open standalone dashboard (read-mostly)');
-      console.error('  hooks      Open legacy hook installer menu');
+      console.error('  hooks      Install, inspect, or remove agent hooks');
       console.error('  cleanup    Remove old memories');
       console.error('  purge      Retire all memories (project by default, --all for everything)');
       console.error('  sync       Rules/workspace sync plus interactive wizard');

package/src/codegraph/task-lens.ts

@@ -143,19 +143,73 @@ const KEYWORDS: Record<Exclude<TaskLensId, 'general'>, string[]> = {
 // Continuation is a delivery intent, not a task lens. A request can both resume
 // prior work and be a bugfix, feature, or release task, so callers keep the
 // normal lens and add a bounded prior-work projection separately.
-const CONTINUATION_KEYWORDS = [
+//
+// Matching triggers buildHookProjectContext() and a full prior-work brief,
+// which measurably costs 2-3x an ordinary prompt (~3s → ~7.5s locally, 15s+
+// under load) — enough to blow the 10s UserPromptSubmit hook timeout, after
+// which Claude Code discards the injection entirely.
+//
+// The split below is about *evidence of intent*, not about the words alone:
+//
+//   EXPLICIT   — handoff vocabulary is deliberate on its own. "交接" and
+//                "handoff" are not said casually, so a bare mention counts.
+//   AMBIGUOUS  — "继续" / "continue" / "恢复" are everyday verbs. Bare, they
+//                are filler meaning "go on" (and "恢复" usually means "restore
+//                the service" in ops work). Carrying a real task they are a
+//                genuine resume request — `memorix resume "继续处理发布阻塞问题"`
+//                is documented usage — so they require substantive content.
+const EXPLICIT_HANDOFF_KEYWORDS = [
+  'handoff',
+  'hand off',
+  'hand over',
+  'previous session',
+  'last session',
+  'pick up where',
+  '交接',          // 覆盖「任务交接」「工作交接」
+  '接手',
+  '上次会话',
+  '上次的会话',
+];
+
+const AMBIGUOUS_CONTINUATION_KEYWORDS = [
   'continue',
   'resume',
-  'pick up',
   'carry on',
-  'previous session',
+  'pick up',
   '继续',
-  '接手',
   '恢复',
   '延续',
-  '上次会话',
 ];
 
+/**
+ * Characters that carry no task meaning on their own: punctuation, whitespace,
+ * Chinese modal particles, and the generic scaffolding words users wrap around
+ * a bare "继续" ("任务继续", "继续一下").
+ */
+const TASK_FILLER_WORDS = /\b(?:please|task|work|the|a|an)\b/giu;
+const TASK_FILLER_PHRASES = /(?:吧|了|呢|啊|吗|嘛|呀|哦|噢|一下|一起|接着|请|帮我)/gu;
+
+/** Minimum residual code points that count as a real task description. */
+const MIN_TASK_SUBSTANCE = 2;
+
+function hasSubstantiveTask(text: string, keyword: string): boolean {
+  const withoutKeyword = text.replace(
+    new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'),
+    ' ',
+  );
+  const residual = withoutKeyword
+    // English fillers are removed as whole words, so `a` in `API` and `work`
+    // in `workflow` remain meaningful task text.
+    .replace(TASK_FILLER_WORDS, ' ')
+    .replace(TASK_FILLER_PHRASES, ' ')
+    .replace(/[\s\p{P}]/gu, '');
+
+  // These are scaffolding-only phrases, not tasks. Keep `工作流` intact by
+  // checking the complete residual instead of removing `工作` as a prefix.
+  if (/^(?:任务|工作|一下|一起|接着)$/u.test(residual)) return false;
+  return Array.from(residual).length >= MIN_TASK_SUBSTANCE;
+}
+
 const LENS_PRIORITY: Exclude<TaskLensId, 'general'>[] = [
   'bugfix',
   'release',
@@ -250,11 +304,22 @@ export function resolveTaskLens(task?: string): TaskLens {
  * Detect when the caller is asking to continue existing work. This stays
  * separate from task-lens routing so "continue fixing the timeout" remains a
  * bugfix, while still receiving a compact prior-work brief.
+ *
+ * Explicit handoff vocabulary counts on its own. Everyday continuation verbs
+ * additionally require a substantive task, so a bare "继续" / "continue" — the
+ * single most common thing a user types to mean "go on" — stays on the cheap
+ * path instead of paying for a full brief on every turn.
  */
 export function isContinuationTask(task?: string): boolean {
   const normalized = (task ?? '').trim().toLowerCase();
-  return normalized.length > 0 && CONTINUATION_KEYWORDS.some((keyword) =>
-    containsTaskKeyword(normalized, keyword),
+  if (normalized.length === 0) return false;
+
+  if (EXPLICIT_HANDOFF_KEYWORDS.some((keyword) => containsTaskKeyword(normalized, keyword))) {
+    return true;
+  }
+
+  return AMBIGUOUS_CONTINUATION_KEYWORDS.some((keyword) =>
+    containsTaskKeyword(normalized, keyword) && hasSubstantiveTask(normalized, keyword),
   );
 }
 

package/src/dashboard/static/index.html

@@ -142,7 +142,7 @@
           <path d="M23 21v-2a4 4 0 0 0-3-3.87"/>
           <path d="M16 3.13a4 4 0 0 1 0 7.75"/>
         </svg>
-        <span class="nav-label">Team</span>
+        <span class="nav-label">Coordination</span>
       </button>
     </div>
     <div class="sidebar-spacer"></div>
@@ -211,10 +211,6 @@
 
   <!-- Apache ECharts 5 — Knowledge Graph renderer -->
   <script src="https://cdn.jsdelivr.net/npm/echarts@5.5.1/dist/echarts.min.js"></script>
-  <!-- Cytoscape.js + Dagre — legacy entity-graph fallback -->
-  <script src="https://unpkg.com/cytoscape@3.30.4/dist/cytoscape.min.js"></script>
-  <script src="https://unpkg.com/dagre@0.8.5/dist/dagre.min.js"></script>
-  <script src="https://unpkg.com/cytoscape-dagre@2.5.0/cytoscape-dagre.js"></script>
   <script>
     // Cache-bust app.js by appending mtime-based version so edits always hit the browser.
     (function () {