memorix 1.8.4 → 1.8.6

package/src/hooks/official-skills.ts

@@ -38,6 +38,9 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
       '| Need the full source for a search hit | `memorix_detail` | `memorix memory detail --id <id>` |',
       '| Need the sequence around one memory | `memorix_timeline` | `memorix memory timeline --id <id>` |',
+      '| Check source and freshness for a memory | `memorix_evidence` | `memorix evidence list|get|events` |',
+      '| Record whether a memory helped, conflicted, or was corrected | `memorix_feedback` | `memorix feedback record|show|audit` |',
+      '| Inspect or import controlled media | `memorix_media` | `memorix media import|attach|list|show|status` |',
       '| Learned reusable project knowledge | `memorix_store` | `memorix memory store --type <type> --entity <name> --title "<title>" "<text>"` |',
       '| Task or bug is complete/outdated | `memorix_resolve` | `memorix memory resolve --ids <ids>` |',
       '',
@@ -168,6 +171,8 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       'Promote memories into mini-skills only when they are reusable instructions, not just historical notes.',
       '',
+      'The standard setup uses the `lite` MCP profile. `memorix_skills` and `memorix_promote` are full-profile tools, so use the CLI fallback unless the current server was explicitly started with `MEMORIX_MODE=full` or `--mode full`. Do not probe hidden MCP tools repeatedly.',
+      '',
       '## Tool Router',
       '',
       '| Situation | Prefer | CLI fallback |',
@@ -203,15 +208,17 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '| Situation | Prefer | CLI fallback |',
       '|---|---|---|',
       '| Run managed subagent execution | CLI | `memorix orchestrate --goal "<goal>" --agents claude:1,codex:1` |',
-      '| Register coordination identity | `team_manage` action `join` | `memorix team join --agentType <agent>` |',
-      '| Create or inspect tasks | `team_task` | `memorix task create|list|claim|complete` |',
-      '| Send or read coordination messages | `team_message` | `memorix message send|broadcast|inbox` |',
-      '| Share structured handoff | `memorix_handoff` | `memorix handoff send` |',
-      '| Avoid file conflicts | `team_file_lock` | `memorix lock lock|unlock|status` |',
-      '| Poll joined coordination state | `memorix_poll` | `memorix poll` |',
+      '| Register coordination identity when team MCP tools are available | `team_manage` action `join` | `memorix team join --agentType <agent>` |',
+      '| Create or inspect tasks when team MCP tools are available | `team_task` | `memorix task create|list|claim|complete` |',
+      '| Send or read coordination messages when team MCP tools are available | `team_message` | `memorix message send|broadcast|inbox` |',
+      '| Share structured handoff when team MCP tools are available | `memorix_handoff` | `memorix handoff send` |',
+      '| Avoid file conflicts when team MCP tools are available | `team_file_lock` | `memorix lock lock|unlock|status` |',
+      '| Poll joined coordination state when team MCP tools are available | `memorix_poll` | `memorix poll` |',
       '',
       '## Boundaries',
       '',
+      'The standard setup uses the `lite` MCP profile. Coordination MCP tools are exposed only by `team` or `full`; use the CLI fallback for ordinary installations, or explicitly start the server with `--mode team`. Do not probe unavailable team tools in a loop.',
+      '',
       '- For ordinary memory, do not join coordination state.',
       '- For production multi-agent execution, prefer `memorix orchestrate` so the main process owns planning, dispatch, retries, and verification gates.',
       '- `memorix orchestrate` uses the current checkout for single-worker runs and task worktrees for parallel runs. Use `--isolated` to force worktree isolation, `--no-worktree` to disable it, `--allow-dirty` to run with uncommitted changes, and `--no-auto-merge` to preserve task worktrees for manual review.',

package/src/hooks/types.ts

@@ -42,6 +42,7 @@ export type AgentName =
   | 'opencode'
   | 'trae'
   | 'dsh'
+  | 'workbuddy'
   | 'pi'
   | 'omp';
 
@@ -63,6 +64,7 @@ export const AGENT_SUPPORT_TIER: Record<AgentName, SupportTier> = {
   opencode: 'community',
   trae: 'community',
   dsh: 'community',
+  workbuddy: 'community',
   pi: 'community',
   omp: 'community',
   antigravity: 'community',

package/src/integrations/registry.ts

@@ -159,6 +159,15 @@ export const MEMORIX_INTEGRATIONS: MemorixIntegration[] = [
     surfaces: ['MCP', 'AGENTS.md', 'skills'],
     note: 'DeepSeek Harness support writes a @deepseek-ai/dsh-mcp-client row into $DSH_HOME/cordis.patch.yml (default ~/.dsh/cordis.patch.yml), guidance into the harness AGENTS.md, and skills under $DSH_HOME/skills.',
   },
+  {
+    agent: 'workbuddy',
+    name: 'WorkBuddy',
+    entry: 'official-config',
+    status: 'ready',
+    install: 'memorix setup --agent workbuddy',
+    surfaces: ['MCP', 'AGENTS.md'],
+    note: 'WorkBuddy support writes a memorix MCP server row into ~/.workbuddy/mcp.json (or <project>/.workbuddy/mcp.json for project installs) and guidance into AGENTS.md.',
+  },
   {
     agent: 'memcode',
     name: 'memcode',

package/src/memory/graph.ts

@@ -5,8 +5,8 @@
  * Source: MCP Official Memory Server v0.6.3 (complete rewrite with same API).
  *
  * Key differences from official implementation:
- * - Uses per-project JSONL files (official uses single file)
- * - Async initialization with persistence layer
+ * - Uses the project-scoped SQLite graph store; legacy JSONL is migration-only
+ * - Async initialization with the shared persistence layer
  * - Project-scoped operations
  */
 

package/src/server/mcp-diagnostics.ts

@@ -12,7 +12,7 @@ export interface McpDiagnostics {
     legacy: string;
     discovery: 'supported';
     versionlessRequests: 'legacy-compatible';
-    modernResultMetadata: 'discovery-only';
+    modernResultMetadata: 'supported';
     statelessRequests: 'supported' | 'compatibility-only' | 'unsupported';
     statefulStreamableHttp: 'supported';
   };
@@ -20,12 +20,12 @@ export interface McpDiagnostics {
     tasks: 'supported' | 'unsupported';
     polling: 'supported' | 'unsupported';
     subscriptions: 'supported' | 'unsupported';
-    listCache: 'supported' | 'unsupported';
+    listCache: 'supported' | 'protocol-hints-only' | 'unsupported';
     explicitProjectHandle: 'supported';
   };
 }
 
-/** The pinned SDK is stateful; do not present a fake durable task loop. */
+/** Do not present a fake durable task loop or a cache that does not exist. */
 export function getMcpDiagnostics(): McpDiagnostics {
   return {
     serverName: MCP_SERVER_NAME,
@@ -34,15 +34,17 @@ export function getMcpDiagnostics(): McpDiagnostics {
       legacy: LEGACY_MCP_PROTOCOL_VERSION,
       discovery: 'supported',
       versionlessRequests: 'legacy-compatible',
-      modernResultMetadata: 'discovery-only',
-      statelessRequests: 'compatibility-only',
+      modernResultMetadata: 'supported',
+      statelessRequests: 'supported',
       statefulStreamableHttp: 'supported',
     },
     capabilities: {
       tasks: 'unsupported',
       polling: 'unsupported',
-      subscriptions: 'unsupported',
-      listCache: 'unsupported',
+      subscriptions: 'supported',
+      // The protocol envelope is emitted, but TTL is intentionally zero until
+      // Memorix can invalidate a durable per-project list cache correctly.
+      listCache: 'protocol-hints-only',
       explicitProjectHandle: 'supported',
     },
   };

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

@@ -0,0 +1,108 @@
+/**
+ * Modern MCP protocol bridge.
+ *
+ * Memorix's product handlers still use the mature v1 SDK internally. The
+ * public modern transport is served by the official v2 SDK; this bridge keeps
+ * one source of truth for the tool implementation by forwarding v2 tool calls
+ * through an in-process v1 client/server pair.
+ */
+
+import {
+  fromJsonSchema,
+  McpServer as ModernMcpServer,
+} from '@modelcontextprotocol/server';
+import { Client as LegacyClient } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport as LegacyInMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { getMcpServerInfo } from './mcp-discovery.js';
+import type { CreateMemorixServerOptions } from '../server.js';
+import type { ProjectBindingSource } from './request-context.js';
+
+export interface ModernMcpBridgeOptions extends CreateMemorixServerOptions {
+  projectRoot: string;
+}
+
+/**
+ * Lifecycle hooks kept beside the v2 facade so transport adapters do not lose
+ * Memorix-specific project binding and deferred maintenance behavior.
+ */
+export interface ModernMcpBridgeLifecycle {
+  projectId: string;
+  deferredInit: () => Promise<void>;
+  switchProject: (newCwd: string, source?: ProjectBindingSource) => Promise<boolean>;
+  isExplicitlyBound: () => boolean;
+  handleTransportClose: () => void;
+}
+
+export type ModernMcpBridge = ModernMcpServer & {
+  memorix: ModernMcpBridgeLifecycle;
+};
+
+/**
+ * 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(
+  options: ModernMcpBridgeOptions,
+): Promise<ModernMcpBridge> {
+  const { createMemorixServer } = await import('../server.js');
+  const legacy = await createMemorixServer(
+    options.projectRoot,
+    undefined,
+    undefined,
+    {
+      ...options,
+      allowUntrackedFallback: options.allowUntrackedFallback ?? false,
+      deferProjectInitUntilBound: options.deferProjectInitUntilBound ?? true,
+      deferProjectRuntimeInit: options.deferProjectRuntimeInit ?? true,
+    },
+  );
+
+  const [clientTransport, serverTransport] = LegacyInMemoryTransport.createLinkedPair();
+  const legacyClient = new LegacyClient({
+    name: 'memorix-modern-bridge',
+    version: getMcpServerInfo().version,
+  });
+  await legacy.server.connect(serverTransport);
+  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 bridge = modern as ModernMcpBridge;
+  bridge.memorix = {
+    projectId: legacy.projectId,
+    deferredInit: legacy.deferredInit,
+    switchProject: legacy.switchProject,
+    isExplicitlyBound: legacy.isExplicitlyBound,
+    handleTransportClose: legacy.handleTransportClose,
+  };
+
+  let closed = false;
+  const modernClose = modern.close.bind(modern);
+  modern.close = async () => {
+    if (closed) return;
+    closed = true;
+    await modernClose();
+    await legacyClient.close().catch(() => undefined);
+    await legacy.server.close().catch(() => undefined);
+    legacy.handleTransportClose();
+  };
+
+  return bridge;
+}

package/src/server/stdio-startup-gate.ts

@@ -54,7 +54,21 @@ export class StdioStartupGate {
         this.fail(new Error(`stdio input chunk exceeded ${this.maxBufferSize} bytes`));
         return;
       }
-      this.input.write(chunk);
+      // Keep the old claim-less discovery probe compatible even after the
+      // official v2 transport is ready. Other complete lines are forwarded
+      // unchanged so the v2 transport remains responsible for parsing and
+      // protocol errors.
+      this.pendingInput += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+      let newline = this.pendingInput.indexOf('\n');
+      while (newline >= 0 && !this.stopped) {
+        const line = this.pendingInput.slice(0, newline + 1);
+        this.pendingInput = this.pendingInput.slice(newline + 1);
+        this.handleReadyLine(line);
+        newline = this.pendingInput.indexOf('\n');
+      }
+      if (!this.stopped && Buffer.byteLength(this.pendingInput, 'utf8') > this.maxBufferSize) {
+        this.fail(new Error(`stdio input exceeded ${this.maxBufferSize} bytes`));
+      }
       return;
     }
 
@@ -171,6 +185,24 @@ export class StdioStartupGate {
     this.queuedBytes += bytes;
   }
 
+  private handleReadyLine(line: string): void {
+    const parsed = this.parseLine(line);
+    if (parsed && !('error' in parsed) && this.isDiscoveryRequest(parsed.message)) {
+      const response = {
+        jsonrpc: '2.0',
+        id: parsed.message.id,
+        result: createMcpStartupDiscoverResult(this.serverInfo),
+      };
+      try {
+        this.stdout.write(`${JSON.stringify(response)}\n`);
+      } catch (error) {
+        this.fail(error instanceof Error ? error : new Error(String(error)));
+      }
+      return;
+    }
+    this.input.write(line);
+  }
+
   private parseLine(line: string): ParsedLine {
     const trimmed = line.endsWith('\n') ? line.slice(0, -1).replace(/\r$/, '') : line;
     if (!trimmed.trim()) return null;
@@ -213,7 +245,14 @@ export class StdioStartupGate {
     if (message.method !== MCP_SERVER_DISCOVER_METHOD) return false;
     if (!Object.prototype.hasOwnProperty.call(message, 'id')) return false;
     const params = message.params;
-    return params === undefined || (typeof params === 'object' && params !== null && !Array.isArray(params));
+    // A claim-less discover is the compatibility probe supported by Memorix
+    // 1.8.x. A modern 2026 request carries `_meta` and must flow into the
+    // official v2 stdio classifier after the startup queue is ready.
+    if (params === undefined) return true;
+    return typeof params === 'object'
+      && params !== null
+      && !Array.isArray(params)
+      && !Object.prototype.hasOwnProperty.call(params, '_meta');
   }
 
   private isValidRequestId(id: unknown): id is string | number | null {

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 — 18 tools.
+ *   - "lite": Core memory CRUD, sessions, reasoning, retention, backup — 20 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 — 26 tools.
+ *   - "team" (HTTP default): lite + orchestration coordination tools, dashboard, and Knowledge Workspace — 28 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).
@@ -142,11 +142,12 @@ export function resolveToolProfile(opts: ResolveToolProfileOpts): ToolProfile {
  * Human-readable description for logs / diagnostics.
  */
 export function describeProfile(profile: ToolProfile): string {
+  const count = countToolsInProfile(profile);
   switch (profile) {
-    case 'micro': return 'micro (agent-ready context + bounded recovery/media, ~9 tools)';
-    case 'lite': return 'lite (core memory + sessions, ~18 tools)';
-    case 'team': return 'team (lite + coordination tools + dashboard + knowledge workspace, ~26 tools)';
-    case 'full': return 'full (all tools including advanced / KG-compat)';
+    case 'micro': return `micro (agent-ready context + bounded recovery/media, ${count} tools)`;
+    case 'lite': return `lite (core memory + sessions, ${count} tools)`;
+    case 'team': return `team (lite + coordination tools + dashboard + knowledge workspace, ${count} tools)`;
+    case 'full': return `full (all tools including advanced / KG-compat, ${count} tools)`;
   }
 }
 

package/src/server.ts

@@ -12,7 +12,7 @@
  *
  * Extensibility:
  * - New tools can be registered via server.registerTool()
- * - Rules sync tools will be added in P2
+ * - Rules and workspace sync tools are available only in the explicit full profile
  * - New agent format adapters plug in without changing this file
  */
 

package/src/store/orama-store.ts

@@ -4,8 +4,8 @@
  * Full-text + vector + hybrid search engine backed by Orama.
  * Source: @orama/orama (10.1K stars, <2KB, pure JS, zero deps)
  *
- * Schema designed to store Observations with all searchable fields.
- * Vector search (embeddings) will be added in P1 phase.
+ * Schema designed to index Observations with all searchable fields.
+ * SQLite remains the durable source of truth; this index is rebuilt as needed.
  */
 
 import { create, insert, insertMultiple, search, remove, update, count, getByID, type AnyOrama } from '@orama/orama';

package/src/types.ts

@@ -670,7 +670,7 @@ export interface MemoryRef {
 /** MCP config format adapter interface */
 export interface MCPConfigAdapter {
   /** Setup-only adapters may support a host that does not participate in workspace sync. */
-  readonly source: AgentTarget | 'codebuddy' | 'dsh';
+  readonly source: AgentTarget | 'codebuddy' | 'dsh' | 'workbuddy';
   /** Parse MCP server entries from a config file */
   parse(content: string): MCPServerEntry[];
   /** Generate config file content from MCP server entries */

package/src/wiki/types.ts

@@ -21,8 +21,8 @@ export interface KnowledgeSection {
 
 export interface ProjectKnowledgeOverview {
   /**
-   * A read-only projection of durable memories. This is intentionally not
-   * called a maintained wiki until the 1.2 Knowledge Workspace exists.
+   * A read-only projection of durable memories. The maintained, review-gated
+   * Knowledge Workspace is a separate surface backed by source claims.
    */
   title: 'Memory Overview';
   subtitle: 'Generated from durable project memory';

package/src/workspace/mcp-adapters/workbuddy.ts

@@ -0,0 +1,71 @@
+import type { MCPConfigAdapter, MCPServerEntry } from '../../types.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * WorkBuddy MCP config adapter.
+ *
+ * WorkBuddy stores its MCP server list in a JSON file following the standard
+ * MCP client convention:
+ *
+ *   { "mcpServers": { [name]: { command, args, env?, url?, headers? } } }
+ *
+ * Per the official WorkBuddy MCP guide, two scopes are supported:
+ *   - user-level:    ~/.workbuddy/mcp.json
+ *   - project-level: <project>/.workbuddy/mcp.json
+ *
+ * getConfigPath returns the project-level path when a projectRoot is supplied,
+ * otherwise the user-level path — matching the existing adapter convention.
+ */
+export class WorkbuddyMCPAdapter implements MCPConfigAdapter {
+  readonly source = 'workbuddy' as const;
+
+  parse(content: string): MCPServerEntry[] {
+    try {
+      const config = JSON.parse(content);
+      const servers = config.mcpServers ?? {};
+      return Object.entries(servers).map(([name, entry]: [string, any]) => ({
+        name,
+        command: entry.command ?? '',
+        args: entry.args ?? [],
+        ...(entry.env && Object.keys(entry.env).length > 0 ? { env: entry.env } : {}),
+        ...(entry.url ? { url: entry.url } : {}),
+        ...(entry.headers && Object.keys(entry.headers).length > 0 ? { headers: entry.headers } : {}),
+        ...(entry.disabled === true ? { disabled: true } : {}),
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  generate(servers: MCPServerEntry[]): string {
+    const mcpServers: Record<string, any> = {};
+    for (const s of servers) {
+      const entry: Record<string, any> = {};
+      if (s.url) {
+        entry.url = s.url;
+        if (s.headers && Object.keys(s.headers).length > 0) {
+          entry.headers = s.headers;
+        }
+      } else {
+        entry.command = s.command;
+        entry.args = s.args;
+      }
+      if (s.env && Object.keys(s.env).length > 0) {
+        entry.env = s.env;
+      }
+      if (s.disabled === true) {
+        entry.disabled = true;
+      }
+      mcpServers[s.name] = entry;
+    }
+    return JSON.stringify({ mcpServers }, null, 2) + '\n';
+  }
+
+  getConfigPath(projectRoot?: string): string {
+    if (projectRoot) {
+      return join(projectRoot, '.workbuddy', 'mcp.json');
+    }
+    return join(homedir(), '.workbuddy', 'mcp.json');
+  }
+}