memorix 1.9.4 → 1.9.6

package/src/server/modern-mcp-bridge.ts

@@ -28,7 +28,9 @@ export interface ModernMcpBridgeOptions extends CreateMemorixServerOptions {
 export interface ModernMcpBridgeLifecycle {
   projectId: string;
   deferredInit: () => Promise<void>;
+  activateProjectRuntime: () => Promise<void>;
   switchProject: (newCwd: string, source?: ProjectBindingSource) => Promise<boolean>;
+  getProjectDataDir: () => string;
   isExplicitlyBound: () => boolean;
   handleTransportClose: () => void;
 }
@@ -37,14 +39,116 @@ export type ModernMcpBridge = ModernMcpServer & {
   memorix: ModernMcpBridgeLifecycle;
 };
 
+let businessRuntimeQueue: Promise<unknown> = Promise.resolve();
+
+/** Serialize access to the legacy process-global store layer. */
+export function withBusinessRuntimeQueue<T>(work: () => Promise<T>): Promise<T> {
+  const result = businessRuntimeQueue.then(work);
+  businessRuntimeQueue = result.catch(() => undefined);
+  return result;
+}
+
+export interface ModernMcpRuntime {
+  projectId: string;
+  getProjectDataDir: () => string;
+  createBridge: () => ModernMcpBridge;
+  close: () => Promise<void>;
+}
+
+interface RuntimePoolEntry {
+  runtime: ModernMcpRuntime;
+  refs: number;
+  lastUsedAt: number;
+}
+
+/**
+ * Reuses the expensive legacy business runtime while giving the v2 handler a
+ * fresh protocol server per request, as required by the official SDK.
+ */
+export class ModernMcpRuntimePool {
+  private readonly entries = new Map<string, RuntimePoolEntry>();
+  private readonly pending = new Map<string, Promise<RuntimePoolEntry>>();
+
+  constructor(private readonly maxEntries = 32) {}
+
+  async createBridge(
+    key: string,
+    create: () => Promise<ModernMcpRuntime>,
+  ): Promise<ModernMcpBridge> {
+    let entry = this.entries.get(key);
+    if (!entry) {
+      let pending = this.pending.get(key);
+      if (!pending) {
+        pending = create().then(runtime => {
+          const created: RuntimePoolEntry = { runtime, refs: 0, lastUsedAt: Date.now() };
+          this.entries.set(key, created);
+          return created;
+        });
+        this.pending.set(key, pending);
+      }
+      try {
+        entry = await pending;
+      } finally {
+        this.pending.delete(key);
+      }
+    }
+
+    entry.refs++;
+    entry.lastUsedAt = Date.now();
+    const bridge = entry.runtime.createBridge();
+    const close = bridge.close.bind(bridge);
+    let released = false;
+    bridge.close = async () => {
+      try {
+        await close();
+      } finally {
+        if (!released) {
+          released = true;
+          entry!.refs = Math.max(0, entry!.refs - 1);
+          entry!.lastUsedAt = Date.now();
+        }
+      }
+    };
+    return bridge;
+  }
+
+  async evictIdle(): Promise<number> {
+    let closed = 0;
+    const idle = [...this.entries.entries()]
+      .filter(([, entry]) => entry.refs === 0)
+      .sort(([, left], [, right]) => left.lastUsedAt - right.lastUsedAt);
+    for (const [key, entry] of idle) {
+      if (this.entries.size <= this.maxEntries || entry.refs > 0) continue;
+      this.entries.delete(key);
+      await entry.runtime.close();
+      closed++;
+    }
+    return closed;
+  }
+
+  async close(): Promise<void> {
+    const entries = [...this.entries.values()];
+    this.entries.clear();
+    await Promise.all(entries.map(entry => entry.runtime.close().catch(() => undefined)));
+  }
+
+  stats(): { entries: number; activeRefs: number; pending: number } {
+    return {
+      entries: this.entries.size,
+      activeRefs: [...this.entries.values()].reduce((sum, entry) => sum + entry.refs, 0),
+      pending: this.pending.size,
+    };
+  }
+}
+
 /**
  * Build an official v2 server whose tools delegate to the existing Memorix
  * implementation. The v1 side is process-local and never becomes a second
  * network endpoint, so project isolation and business behavior stay shared.
  */
-export async function createModernMcpBridge(
+export async function createModernMcpRuntime(
   options: ModernMcpBridgeOptions,
-): Promise<ModernMcpBridge> {
+): Promise<ModernMcpRuntime> {
   const { createMemorixServer } = await import('../server.js');
   const legacy = await createMemorixServer(
     options.projectRoot,
@@ -67,42 +171,64 @@ export async function createModernMcpBridge(
   await legacyClient.connect(clientTransport);
 
   const listed = await legacyClient.listTools();
-  const modern = new ModernMcpServer(getMcpServerInfo());
-
-  for (const tool of listed.tools) {
-    modern.registerTool(
-      tool.name,
-      {
-        ...(tool.title ? { title: tool.title } : {}),
-        ...(tool.description ? { description: tool.description } : {}),
-        inputSchema: fromJsonSchema(tool.inputSchema as Record<string, unknown>),
-      },
-      async (args) => await legacyClient.callTool({
-        name: tool.name,
-        arguments: args as Record<string, unknown>,
-      }) as never,
-    );
-  }
+  const callTool = (name: string, args: Record<string, unknown>) =>
+    withBusinessRuntimeQueue(async () => {
+      await legacy.activateProjectRuntime();
+      return await legacyClient.callTool({ name, arguments: args });
+    });
 
-  const bridge = modern as ModernMcpBridge;
-  bridge.memorix = {
+  const lifecycle: ModernMcpBridgeLifecycle = {
     projectId: legacy.projectId,
     deferredInit: legacy.deferredInit,
+    activateProjectRuntime: legacy.activateProjectRuntime,
     switchProject: legacy.switchProject,
+    getProjectDataDir: legacy.getProjectDataDir,
     isExplicitlyBound: legacy.isExplicitlyBound,
     handleTransportClose: legacy.handleTransportClose,
   };
 
   let closed = false;
-  const modernClose = modern.close.bind(modern);
-  modern.close = async () => {
+  return {
+    projectId: legacy.projectId,
+    getProjectDataDir: legacy.getProjectDataDir,
+    createBridge: () => {
+      const requestServer = new ModernMcpServer(getMcpServerInfo()) as ModernMcpBridge;
+      for (const tool of listed.tools) {
+        requestServer.registerTool(
+          tool.name,
+          {
+            ...(tool.title ? { title: tool.title } : {}),
+            ...(tool.description ? { description: tool.description } : {}),
+            inputSchema: fromJsonSchema(tool.inputSchema as Record<string, unknown>),
+          },
+          async (args) => await callTool(tool.name, args as Record<string, unknown>) as never,
+        );
+      }
+      requestServer.memorix = lifecycle;
+      return requestServer;
+    },
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      await legacyClient.close().catch(() => undefined);
+      await legacy.server.close().catch(() => undefined);
+      legacy.handleTransportClose();
+    },
+  };
+}
+
+export async function createModernMcpBridge(
+  options: ModernMcpBridgeOptions,
+): Promise<ModernMcpBridge> {
+  const runtime = await createModernMcpRuntime(options);
+  const bridge = runtime.createBridge();
+  const close = bridge.close.bind(bridge);
+  let closed = false;
+  bridge.close = async () => {
     if (closed) return;
     closed = true;
-    await modernClose();
-    await legacyClient.close().catch(() => undefined);
-    await legacy.server.close().catch(() => undefined);
-    legacy.handleTransportClose();
+    await close();
+    await runtime.close();
   };
-
   return bridge;
 }

package/src/server/tool-profile.ts

@@ -8,9 +8,9 @@
  * We provide four profiles:
  *   - "micro" (stdio default): Agent-ready project context + bounded recovery/media controls — 9 tools.
  *     Suitable for normal MCP clients where every tool schema costs context tokens.
- *   - "lite": Core memory CRUD, sessions, reasoning, retention, backup — 20 tools.
+ *   - "lite": Core memory CRUD, sessions, reasoning, continuity, retention, backup — 21 tools.
  *     Suitable for solo users who want the full memory surface without team tools.
- *   - "team" (HTTP default): lite + orchestration coordination tools, dashboard, and Knowledge Workspace — 28 tools.
+ *   - "team" (HTTP default): lite + orchestration coordination tools, dashboard, and Knowledge Workspace — 29 tools.
  *     Suitable when an operator explicitly wants task/message/lock surfaces.
  *   - "full": Everything, including niche / advanced tools (consolidate, dedup,
  *     formation metrics, skills, rules/workspace sync, KG-official, image ingest).
@@ -44,6 +44,7 @@ export const TOOL_PROFILES: Record<string, ReadonlyArray<ToolProfile>> = Object.
   // keep the default micro profile at its nine-tool token budget.
   memorix_evidence:           ['lite', 'team', 'full'],
   memorix_feedback:           ['lite', 'team', 'full'],
+  memorix_continuity:         ['lite', 'team', 'full'],
 
   // ── lite: extended solo memory surface ────────────────────────────
   memorix_graph_context:      ['lite', 'team', 'full'],

package/src/server.ts

@@ -253,7 +253,9 @@ export async function createMemorixServer(
   graphManager: KnowledgeGraphManager;
   projectId: string;
   deferredInit: () => Promise<void>;
-  switchProject: (newCwd: string) => Promise<boolean>;
+  activateProjectRuntime: () => Promise<void>;
+  switchProject: (newCwd: string, source?: ProjectBindingSource) => Promise<boolean>;
+  getProjectDataDir: () => string;
   isExplicitlyBound: () => boolean;
   getRequestContext: () => import('./server/request-context.js').MemorixRequestContext;
   handleTransportClose: () => void;
@@ -364,7 +366,7 @@ export async function createMemorixServer(
     const store = getObservationStore();
     console.error(`[memorix] ObservationStore backend: ${store.getBackendName()}, generation: ${store.getGeneration()}`);
   }
-  let graphManager = new KnowledgeGraphManager(projectDir);
+  let graphManager = new KnowledgeGraphManager(projectDir, project.id);
   if (!deferProjectRuntimeInit) {
     await graphManager.init();
     await initObservations(projectDir);
@@ -378,7 +380,7 @@ export async function createMemorixServer(
     await initObservationStore(projectDir);
     await initMiniSkillStore(projectDir);
     await initSessionStore(projectDir);
-    graphManager = new KnowledgeGraphManager(projectDir);
+    graphManager = new KnowledgeGraphManager(projectDir, project.id);
     await graphManager.init();
     await initObservations(projectDir);
 
@@ -497,6 +499,31 @@ export async function createMemorixServer(
     await projectRuntimeInitPromise;
   };
 
+  /**
+   * Restore process-wide stores/config before a pooled modern runtime handles
+   * a tool call. The durable database is shared, but project-root config and
+   * the in-memory observation facade are process-global legacy state.
+   */
+  const activateProjectRuntime = async (): Promise<void> => {
+    if (!projectResolved) return;
+
+    await initObservationStore(projectDir);
+    await initMiniSkillStore(projectDir);
+    await initSessionStore(projectDir);
+    await initObservations(projectDir, { skipCorpusLoad: true });
+
+    try {
+      const { initProjectRoot } = await import('./config/yaml-loader.js');
+      const { resetDotenv, loadDotenv } = await import('./config/dotenv-loader.js');
+      initProjectRoot(project.rootPath);
+      resetDotenv();
+      loadDotenv(project.rootPath);
+    } catch {
+      // Config activation is best-effort; durable project scoping remains explicit.
+    }
+    initLLM({ projectRoot: project.rootPath });
+  };
+
   let maintenanceWorker: { stop(): void } | null = null;
   const startProjectMaintenanceWorker = async (autoCleanup = false): Promise<void> => {
     maintenanceWorker?.stop();
@@ -838,8 +865,9 @@ export async function createMemorixServer(
           currentFormationStage = event.stage;
           if (event.stageDurationMs !== undefined) {
             completedFormationStages[event.stage] = event.stageDurationMs;
-          }
-        };
+    }
+  };
+
         try {
           const formationConfig: FormationConfig = {
             mode: 'active',
@@ -1593,6 +1621,7 @@ export async function createMemorixServer(
         'reliable code-bound memories, stale/suspect cautions, and verification hints. Use this at the start of a new coding turn or after switching tasks.',
       inputSchema: {
         task: z.string().optional().describe('Current coding task or question'),
+        taskId: z.string().max(120).optional().describe('Optional task continuity ledger id to include in the brief'),
         refresh: z.enum(['auto', 'always', 'never']).optional().default('auto').describe(
           'Code Memory refresh policy. auto refreshes only when missing or stale.',
         ),
@@ -1606,7 +1635,7 @@ export async function createMemorixServer(
         limit: z.number().optional().describe('Reserved for future source limits; current prompt stays compact by default.'),
       },
     },
-    async ({ task, refresh, format, agent }) => {
+    async ({ task, taskId, refresh, format, agent }) => {
       const unresolved = requireResolvedProject('build project context for the current project');
       if (unresolved) return unresolved;
 
@@ -1637,6 +1666,7 @@ export async function createMemorixServer(
         dataDir: projectDir,
         observations,
         task,
+        taskId,
         agent,
         refresh: refresh ?? 'auto',
         reader: getObservationReader(),
@@ -4594,6 +4624,99 @@ export async function createMemorixServer(
     },
   );
 
+  server.registerTool(
+    'memorix_continuity',
+    {
+      title: 'Task Continuity Ledger',
+      description:
+        'Maintain a bounded, append-only continuity ledger for a coding task. ' +
+        'Use start for requirements, record for decisions/verification/risks, ' +
+        'show or list to inspect, and close for the final outcome. Pass the returned taskId ' +
+        'to memorix_project_context so the current brief includes this ledger.',
+      inputSchema: {
+        action: z.enum(['start', 'record', 'show', 'list', 'close']).describe('Continuity operation'),
+        taskId: z.string().max(120).optional().describe('Continuity task id'),
+        task: z.string().max(1_000).optional().describe('Task description for start'),
+        requirements: z.array(z.string().max(2_000)).max(8).optional().describe('Requirements for start'),
+        kind: z.enum(['requirement', 'decision', 'verification', 'risk']).optional().describe('Entry kind for record'),
+        content: z.string().max(2_000).optional().describe('Requirement, decision, verification, risk, or outcome text'),
+        verificationStatus: z.enum(['pending', 'passed', 'failed', 'skipped']).optional(),
+        verificationId: z.string().max(120).optional().describe('Stable verification obligation id; reuse it to move pending to passed/failed'),
+        idempotencyKey: z.string().max(200).optional().describe('Stable retry key; repeating the same operation returns the original event'),
+        status: z.enum(['completed', 'blocked', 'abandoned']).optional().describe('Outcome status for close'),
+        sourceRef: z.string().max(500).optional().describe('Evidence or source reference'),
+        evidenceRefs: z.array(z.string().max(500)).max(8).optional(),
+        actor: z.string().max(200).optional(),
+        limit: z.number().int().positive().max(100).optional().default(20),
+      },
+    },
+    async ({ action, taskId, task, requirements, kind, content, verificationStatus, verificationId, idempotencyKey, status, sourceRef, evidenceRefs, actor, limit }) => {
+      const unresolved = requireResolvedProject('manage task continuity for the current project');
+      if (unresolved) return unresolved;
+      const { TaskContinuityStore } = await import('./knowledge/task-continuity.js');
+      const continuity = new TaskContinuityStore();
+      await continuity.init(projectDir);
+      const effectiveActor = actor ?? currentAgentId;
+      try {
+        if (action === 'start') {
+          if (!task?.trim()) return { content: [{ type: 'text' as const, text: 'task is required for continuity start.' }], isError: true };
+          const result = continuity.start({
+            projectId: project.id,
+            task,
+            ...(taskId ? { taskId } : {}),
+            requirements,
+            ...(effectiveActor ? { actor: effectiveActor } : {}),
+            ...(idempotencyKey ? { idempotencyKey } : {}),
+          });
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, ...result }, null, 2) }] };
+        }
+        if (action === 'list') {
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, ledgers: continuity.list(project.id, limit), }, null, 2) }] };
+        }
+        if (!taskId?.trim()) return { content: [{ type: 'text' as const, text: 'taskId is required for this continuity action.' }], isError: true };
+        if (action === 'show') {
+          const ledger = continuity.get(project.id, taskId);
+          if (!ledger) return { content: [{ type: 'text' as const, text: 'Task continuity ledger not found.' }], isError: true };
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, ledger }, null, 2) }] };
+        }
+        if (action === 'record') {
+          if (!kind || !content?.trim()) {
+            return { content: [{ type: 'text' as const, text: 'record requires kind and content.' }], isError: true };
+          }
+          const result = continuity.record({
+            projectId: project.id,
+            taskId,
+            kind,
+            content,
+            ...(verificationStatus ? { verificationStatus } : {}),
+            ...(sourceRef ? { sourceRef } : {}),
+            ...(evidenceRefs ? { evidenceRefs } : {}),
+            ...(effectiveActor ? { actor: effectiveActor } : {}),
+            ...(verificationId ? { verificationId } : {}),
+            ...(idempotencyKey ? { idempotencyKey } : {}),
+          });
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, ...result }, null, 2) }] };
+        }
+        if (!status || !content?.trim()) {
+          return { content: [{ type: 'text' as const, text: 'close requires status and content.' }], isError: true };
+        }
+        const result = continuity.close({
+          projectId: project.id,
+          taskId,
+          status,
+          content,
+          ...(sourceRef ? { sourceRef } : {}),
+          ...(evidenceRefs ? { evidenceRefs } : {}),
+          ...(effectiveActor ? { actor: effectiveActor } : {}),
+          ...(idempotencyKey ? { idempotencyKey } : {}),
+        });
+        return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, ...result }, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: 'text' as const, text: error instanceof Error ? error.message : String(error) }], isError: true };
+      }
+    },
+  );
+
   // Use shared TeamStore (from HTTP server) or create new one (stdio mode).
   // All team state is canonical in SQLite — no JSON persistence, no sync/flush.
   if (teamFeaturesEnabled) {
@@ -5725,7 +5848,8 @@ export async function createMemorixServer(
   };
 
   return {
-    server, graphManager, projectId: project.id, deferredInit, switchProject,
+    server, graphManager, projectId: project.id, deferredInit, activateProjectRuntime, switchProject,
+    getProjectDataDir: () => projectDir,
     isExplicitlyBound: () => projectBinding.isExplicit(),
     getRequestContext,
     handleTransportClose,

package/src/store/file-lock.ts

@@ -20,6 +20,22 @@ const RETRY_INTERVAL_MS = 50;
 const MAX_RETRIES = 60;
 const atomicWriteTails = new Map<string, Promise<void>>();
 
+function canReclaimStaleLock(raw: string): boolean {
+  try {
+    const parsed = JSON.parse(raw) as { pid?: unknown };
+    const pid = Number(parsed.pid);
+    if (!Number.isSafeInteger(pid) || pid < 1) return true;
+    try {
+      process.kill(pid, 0);
+      return false;
+    } catch (error) {
+      return (error as NodeJS.ErrnoException).code !== 'EPERM';
+    }
+  } catch {
+    return true;
+  }
+}
+
 /**
  * Acquire a lock file atomically.
  * Uses O_WRONLY | O_CREAT | O_EXCL — fails if file already exists.
@@ -39,8 +55,11 @@ export async function acquireLock(lockPath: string): Promise<void> {
         try {
           const stat = await fs.stat(lockPath);
           if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-            await fs.unlink(lockPath).catch(() => {});
-            continue;
+            const raw = await fs.readFile(lockPath, 'utf8').catch(() => '');
+            if (canReclaimStaleLock(raw)) {
+              await fs.unlink(lockPath).catch(() => {});
+              continue;
+            }
           }
         } catch {
           continue; // Lock disappeared — retry immediately
@@ -51,7 +70,13 @@ export async function acquireLock(lockPath: string): Promise<void> {
       }
     }
   }
-  // Last resort: force-remove stale lock and try once more
+  // Last resort: reclaim only a stale lock whose recorded owner is no longer
+  // alive. Never delete a long-running live writer's lock just because the
+  // operation exceeded the retry window.
+  const raw = await fs.readFile(lockPath, 'utf8').catch(() => '');
+  if (!canReclaimStaleLock(raw)) {
+    throw new Error(`Failed to acquire lock: ${lockPath} (owner is still running)`);
+  }
   await fs.unlink(lockPath).catch(() => {});
   try {
     const fd = await fs.open(lockPath, 'wx');