codex-dev-mcp-suite 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-dev-mcp-suite",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Four local, file-based MCP servers for solo devs/vibecoders: persistent project memory, session handoff/resume, git-independent file checkpoints, and token-efficient project briefings. Works with any MCP client.",
   "type": "module",
   "license": "MIT",
@@ -43,23 +43,32 @@
   "files": [
     "bin/*.mjs",
     "project-memory/*.js",
-    "project-memory/*.mjs",
+    "project-memory/server.js",
+    "project-memory/embedding.js",
+    "project-memory/env.js",
+    "project-memory/provider-chain.js",
+    "project-memory/rerank.js",
     "project-memory/package.json",
     "devjournal/*.js",
-    "devjournal/*.mjs",
+    "devjournal/server.js",
+    "devjournal/env.js",
+    "devjournal/provider-chain.js",
+    "devjournal/rerank.js",
     "devjournal/package.json",
     "checkpoint/*.js",
-    "checkpoint/*.mjs",
+    "checkpoint/server.js",
     "checkpoint/package.json",
     "context-pack/*.js",
-    "context-pack/*.mjs",
+    "context-pack/server.js",
     "context-pack/package.json",
-    "_testkit/*.mjs",
-    "run-tests.mjs",
     "backfill-sessions-v2.mjs",
+    "docs/configuration.md",
+    "docs/privacy.md",
+    "docs/clients/*.md",
     "CODEX_DEV_MCP_GUIDE.md",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE",
     ".env.example"
   ]
-}
+}

package/project-memory/embedding.js

@@ -1,19 +1,20 @@
 /**
- * Embedding helper for 9router (OpenAI-compatible /v1/embeddings).
+ * Embedding helper for any OpenAI-compatible /v1/embeddings endpoint.
  * Degrades gracefully: returns null on any failure so callers fall back
  * to keyword search. Never throws.
  */
 import http from "http";
 import https from "https";
 import { URL } from "url";
+import { deterministicEnabled } from "./env.js";
 
-const BASE = process.env.LLM_BASE_URL || process.env.EMBED_URL || process.env.NINEROUTER_URL || "http://localhost:20128";
-const KEY = process.env.LLM_API_KEY || process.env.EMBED_KEY || process.env.NINEROUTER_KEY || "";
-const MODEL = process.env.EMBED_MODEL || "bm/baai/bge-m3";
+const BASE = process.env.MCP_EMBED_BASE_URL || process.env.MCP_LLM_BASE_URL || process.env.LLM_BASE_URL || process.env.EMBED_URL || process.env.NINEROUTER_URL || "http://localhost:20128";
+const KEY = process.env.MCP_EMBED_API_KEY || process.env.MCP_LLM_API_KEY || process.env.LLM_API_KEY || process.env.EMBED_KEY || process.env.NINEROUTER_KEY || "";
+const MODEL = process.env.MCP_EMBED_MODEL || process.env.EMBED_MODEL || "bm/baai/bge-m3";
 const TIMEOUT_MS = Number(process.env.EMBED_TIMEOUT_MS || 15000);
 
 export function embeddingConfig() {
-  return { base: BASE, model: MODEL, enabled: Boolean(KEY) };
+  return { base: BASE, model: MODEL, enabled: Boolean(KEY) && !deterministicEnabled(), deterministic: deterministicEnabled() };
 }
 
 function postJson(urlStr, payload) {
@@ -53,7 +54,7 @@ function postJson(urlStr, payload) {
 
 /** Returns array of vectors aligned to inputs, or null if unavailable. */
 export async function embed(inputs) {
-  if (!KEY) return null;
+  if (!KEY || deterministicEnabled()) return null;
   const arr = Array.isArray(inputs) ? inputs : [inputs];
   if (arr.length === 0) return [];
   const json = await postJson(BASE, { model: MODEL, input: arr });

package/project-memory/env.js

@@ -0,0 +1,3 @@
+export function deterministicEnabled() {
+  return /^(1|true|yes|on)$/i.test(String(process.env.MCP_DETERMINISTIC_FALLBACK || "").trim());
+}

package/project-memory/provider-chain.js

@@ -0,0 +1,56 @@
+import { deterministicEnabled } from "./env.js";
+
+const DEFAULT_BASE = "http://localhost:20128";
+const DEFAULT_MODEL = "kr/claude-haiku-4.5";
+
+function value(name) {
+  return String(process.env[name] || "").trim();
+}
+
+function providerEnv(prefix) {
+  const label = value(prefix);
+  const base = value(`${prefix}_BASE_URL`);
+  const key = value(`${prefix}_API_KEY`);
+  const model = value(`${prefix}_MODEL`);
+  if (!label || !base || !key || !model) return null;
+  return { label, base, key, model };
+}
+
+function numberedProviders() {
+  const providers = [];
+  const primary = providerEnv("MCP_PROVIDER_PRIMARY");
+  if (primary) providers.push(primary);
+
+  const slots = Object.keys(process.env)
+    .map((name) => name.match(/^MCP_PROVIDER_CHAIN(\d+)$/)?.[1])
+    .filter(Boolean)
+    .map(Number)
+    .filter((n) => n >= 2)
+    .sort((a, b) => a - b);
+
+  for (const n of slots) {
+    const provider = providerEnv(`MCP_PROVIDER_CHAIN${n}`);
+    if (provider) providers.push(provider);
+  }
+  return providers;
+}
+
+function legacyProvider() {
+  const base = value("MCP_RERANK_BASE_URL") || value("MCP_LLM_BASE_URL") || value("LLM_BASE_URL") || value("RERANK_URL") || value("NINEROUTER_URL") || DEFAULT_BASE;
+  const key = value("MCP_RERANK_API_KEY") || value("MCP_LLM_API_KEY") || value("LLM_API_KEY") || value("RERANK_KEY") || value("NINEROUTER_KEY");
+  const model = value("MCP_RERANK_MODEL") || value("RERANK_MODEL") || DEFAULT_MODEL;
+  if (!key) return null;
+  return { label: "legacy", base, key, model };
+}
+
+export function providerChainConfig() {
+  const deterministic = deterministicEnabled();
+  const rerankEnabled = process.env.RERANK_ENABLED !== "0";
+  if (deterministic || !rerankEnabled) return { providers: [], enabled: false, deterministic };
+  const providers = numberedProviders();
+  if (providers.length === 0) {
+    const legacy = legacyProvider();
+    if (legacy) providers.push(legacy);
+  }
+  return { providers, enabled: providers.length > 0, deterministic };
+}

package/project-memory/rerank.js

@@ -1,5 +1,5 @@
 /**
- * LLM reranker via 9router chat models (e.g. Kiro kr/claude-haiku-4.5).
+ * LLM reranker via any OpenAI-compatible /v1/chat/completions model.
  * Used when embeddings are unavailable: keyword prefilter -> LLM picks the
  * most relevant candidates. Degrades gracefully: returns null on any failure
  * so callers fall back to keyword ordering. Never throws.
@@ -7,23 +7,29 @@
 import http from "http";
 import https from "https";
 import { URL } from "url";
+import { deterministicEnabled } from "./env.js";
+import { providerChainConfig } from "./provider-chain.js";
 
-const BASE = process.env.LLM_BASE_URL || process.env.RERANK_URL || process.env.NINEROUTER_URL || "http://localhost:20128";
-const KEY = process.env.LLM_API_KEY || process.env.RERANK_KEY || process.env.NINEROUTER_KEY || "";
-const MODEL = process.env.RERANK_MODEL || "kr/claude-haiku-4.5";
 const TIMEOUT_MS = Number(process.env.RERANK_TIMEOUT_MS || 30000);
 const ENABLED = process.env.RERANK_ENABLED !== "0";
 
 export function rerankConfig() {
-  return { base: BASE, model: MODEL, enabled: Boolean(KEY) && ENABLED };
+  const cfg = providerChainConfig();
+  const first = cfg.providers[0] || {};
+  return {
+    base: first.base,
+    model: first.model,
+    providers: cfg.providers.map(({ label, base, model }) => ({ label, base, model })),
+    enabled: ENABLED && cfg.enabled && !deterministicEnabled(),
+    deterministic: deterministicEnabled(),
+  };
 }
 
-function chat(messages) {
+function chatWithProvider(provider, messages) {
   return new Promise((resolve) => {
-    if (!KEY || !ENABLED) return resolve(null);
     let u;
-    try { u = new URL("/v1/chat/completions", BASE); } catch { return resolve(null); }
-    const payload = Buffer.from(JSON.stringify({ model: MODEL, stream: false, temperature: 0, max_tokens: 200, messages }));
+    try { u = new URL("/v1/chat/completions", provider.base); } catch { return resolve(null); }
+    const payload = Buffer.from(JSON.stringify({ model: provider.model, stream: false, temperature: 0, max_tokens: 200, messages }));
     const lib = u.protocol === "https:" ? https : http;
     const req = lib.request(
       {
@@ -31,7 +37,7 @@ function chat(messages) {
         port: u.port || (u.protocol === "https:" ? 443 : 80),
         path: u.pathname,
         method: "POST",
-        headers: { "Content-Type": "application/json", "Content-Length": payload.length, Authorization: `Bearer ${KEY}` },
+        headers: { "Content-Type": "application/json", "Content-Length": payload.length, Authorization: `Bearer ${provider.key}` },
         timeout: TIMEOUT_MS,
       },
       (res) => {
@@ -39,7 +45,6 @@ function chat(messages) {
         res.on("data", (c) => (body += c));
         res.on("end", () => {
           if (res.statusCode !== 200) return resolve(null);
-          // handle plain JSON or SSE stream just in case
           try {
             const j = JSON.parse(body);
             return resolve(j?.choices?.[0]?.message?.content ?? null);
@@ -66,12 +71,22 @@ function chat(messages) {
   });
 }
 
+async function chat(messages) {
+  if (!ENABLED || deterministicEnabled()) return null;
+  const { providers } = providerChainConfig();
+  for (const provider of providers) {
+    const out = await chatWithProvider(provider, messages);
+    if (out) return out;
+  }
+  return null;
+}
+
 /**
  * Given a query and candidates [{id, title, snippet}], ask the model to return
  * the ids ordered by relevance. Returns an array of ids, or null on failure.
  */
 export async function rerank(query, candidates, topK = 5) {
-  if (!KEY || !ENABLED || !candidates || candidates.length === 0) return null;
+  if (!ENABLED || deterministicEnabled() || !candidates || candidates.length === 0 || !providerChainConfig().enabled) return null;
   const list = candidates.map((c, i) => `[${i + 1}] (id:${c.id}) ${c.title}\n    ${String(c.snippet || "").replace(/\s+/g, " ").slice(0, 200)}`).join("\n");
   const sys = "You are a search reranker. Given a user query and a numbered list of notes, return the most relevant notes ordered best-first. Respond with ONLY a comma-separated list of the bracket numbers, e.g. 3,1,5. No prose.";
   const user = `Query: ${query}\n\nNotes:\n${list}\n\nReturn the top ${topK} bracket numbers, best first, comma-separated:`;

package/project-memory/server.js

@@ -28,6 +28,7 @@ import os from "os";
 import crypto from "crypto";
 import { embed, embedOne, cosine, embeddingConfig } from "./embedding.js";
 import { rerank, rerankConfig } from "./rerank.js";
+import { deterministicEnabled } from "./env.js";
 
 const VAULT_ROOT =
   process.env.MEMORY_VAULT_DIR ||
@@ -318,8 +319,8 @@ class ProjectMemoryServer {
       return score;
     };
 
-    let mode = "keyword";
-    const qVec = await embedOne(query);
+    let mode = deterministicEnabled() ? "deterministic" : "keyword";
+    const qVec = deterministicEnabled() ? null : await embedOne(query);
     const haveEmb = qVec && notes.some((n) => Array.isArray(n.embedding));
 
     let scored;
@@ -418,6 +419,7 @@ class ProjectMemoryServer {
 
   async reindex({ dir, force = false }) {
     const p = this.paths(dir);
+    if (deterministicEnabled()) return { content: [{ type: "text", text: `Reindex ${p.slug}: skipped (deterministic no-network mode; embeddings disabled).` }] };
     const index = await this.loadIndex(p);
     const notes = Object.values(index.notes || {});
     if (notes.length === 0) return { content: [{ type: "text", text: `No memories for ${p.slug} yet.` }] };

package/_testkit/harness.mjs

@@ -1,126 +0,0 @@
-/**
- * Minimal MCP stdio test harness — zero external deps.
- * Provides: McpClient (spawn server, initialize, callTool), and a tiny
- * assert/test runner (describe/it/run) with colored-ish plain output.
- */
-import { spawn } from "child_process";
-
-export class McpClient {
-  constructor(serverPath, env = {}) {
-    this.serverPath = serverPath;
-    this.env = { ...process.env, ...env };
-    this.proc = null;
-    this.buf = "";
-    this.pending = new Map();
-    this.nextId = 1;
-  }
-
-  async start() {
-    this.proc = spawn("node", [this.serverPath], { env: this.env, stdio: ["pipe", "pipe", "ignore"] });
-    this.proc.stdout.on("data", (d) => this._onData(d.toString()));
-    await this._rpc("initialize", {
-      protocolVersion: "2024-11-05",
-      capabilities: {},
-      clientInfo: { name: "testkit", version: "1.0.0" },
-    });
-    this._notify("notifications/initialized");
-    await new Promise((r) => setTimeout(r, 50));
-  }
-
-  _onData(chunk) {
-    this.buf += chunk;
-    let idx;
-    while ((idx = this.buf.indexOf("\n")) !== -1) {
-      const line = this.buf.slice(0, idx).trim();
-      this.buf = this.buf.slice(idx + 1);
-      if (!line) continue;
-      let msg;
-      try { msg = JSON.parse(line); } catch { continue; }
-      if (msg.id != null && this.pending.has(msg.id)) {
-        const { resolve } = this.pending.get(msg.id);
-        this.pending.delete(msg.id);
-        resolve(msg);
-      }
-    }
-  }
-
-  _send(obj) { this.proc.stdin.write(JSON.stringify(obj) + "\n"); }
-  _notify(method, params) { this._send({ jsonrpc: "2.0", method, params }); }
-
-  _rpc(method, params, timeoutMs = 30000) {
-    const id = this.nextId++;
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`RPC timeout: ${method}`));
-      }, timeoutMs);
-      this.pending.set(id, { resolve: (m) => { clearTimeout(timer); resolve(m); } });
-      this._send({ jsonrpc: "2.0", id, method, params });
-    });
-  }
-
-  async listTools() {
-    const res = await this._rpc("tools/list", {});
-    return (res.result?.tools || []).map((t) => t.name);
-  }
-
-  async callTool(name, args = {}, timeoutMs = 30000) {
-    const res = await this._rpc("tools/call", { name, arguments: args }, timeoutMs);
-    if (res.error) throw new Error(`RPC error: ${res.error.message}`);
-    const text = res.result?.content?.[0]?.text ?? "";
-    return { text, isError: Boolean(res.result?.isError), raw: res.result };
-  }
-
-  async stop() {
-    try { this.proc?.kill(); } catch { /* ignore */ }
-  }
-}
-
-// ---- tiny test runner ----
-const tests = [];
-let currentSuite = "";
-export function describe(name, fn) { currentSuite = name; fn(); currentSuite = ""; }
-export function it(name, fn) { tests.push({ suite: currentSuite, name, fn }); }
-
-export function assert(cond, msg) {
-  if (!cond) throw new Error("assertion failed: " + (msg || ""));
-}
-export function assertIncludes(haystack, needle, msg) {
-  if (!String(haystack).includes(needle)) {
-    throw new Error(`expected to include "${needle}"${msg ? " — " + msg : ""}\n  got: ${String(haystack).slice(0, 300)}`);
-  }
-}
-export function assertEqual(a, b, msg) {
-  if (a !== b) throw new Error(`expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}${msg ? " — " + msg : ""}`);
-}
-
-export async function run() {
-  let pass = 0, fail = 0;
-  const failures = [];
-  for (const t of tests) {
-    const label = t.suite ? `${t.suite} › ${t.name}` : t.name;
-    try {
-      await t.fn();
-      pass++;
-      console.log(`  ✓ ${label}`);
-    } catch (e) {
-      fail++;
-      failures.push({ label, err: e });
-      console.log(`  ✗ ${label}`);
-      console.log(`      ${e.message.split("\n").join("\n      ")}`);
-    }
-  }
-  console.log(`\n${pass} passed, ${fail} failed (${tests.length} total)`);
-  if (fail > 0) process.exitCode = 1;
-  return { pass, fail, failures };
-}
-
-// unique temp dir helper
-import os from "os";
-import path from "path";
-import fs from "fs";
-export function tmpDir(prefix = "mcp-test-") {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  return d;
-}
-export function rmrf(p) { try { fs.rmSync(p, { recursive: true, force: true }); } catch { /* ignore */ } }

package/checkpoint/test.mjs

@@ -1,73 +0,0 @@
-import { McpClient, describe, it, assert, assertIncludes, run, tmpDir, rmrf } from "../_testkit/harness.mjs";
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SERVER = path.join(__dirname, "server.js");
-const STORE = tmpDir("cp-store-");
-const PROJ = tmpDir("cp-proj-");
-
-// seed project files
-fs.mkdirSync(path.join(PROJ, "src"), { recursive: true });
-fs.writeFileSync(path.join(PROJ, "src", "a.txt"), "original A\n");
-fs.writeFileSync(path.join(PROJ, "README.md"), "# Title\n");
-
-const client = new McpClient(SERVER, { CHECKPOINT_DIR: STORE });
-let cpId = "";
-
-describe("checkpoint", () => {
-  it("lists expected tools", async () => {
-    const tools = await client.listTools();
-    for (const t of ["checkpoint_create", "checkpoint_list", "checkpoint_restore", "checkpoint_diff", "checkpoint_delete"])
-      assert(tools.includes(t), `missing ${t}`);
-  });
-
-  it("creates a checkpoint", async () => {
-    const r = await client.callTool("checkpoint_create", { dir: PROJ, label: "baseline" });
-    assertIncludes(r.text, "Checkpoint");
-    assertIncludes(r.text, "Files stored: 2");
-    cpId = (r.text.match(/Checkpoint (\S+) created/) || [])[1] || "";
-    assert(cpId, "could not parse checkpoint id");
-  });
-
-  it("diff detects add/modify/delete", async () => {
-    fs.writeFileSync(path.join(PROJ, "src", "a.txt"), "CHANGED A\n");
-    fs.writeFileSync(path.join(PROJ, "src", "new.txt"), "brand new\n");
-    fs.rmSync(path.join(PROJ, "README.md"));
-    const r = await client.callTool("checkpoint_diff", { dir: PROJ, id: cpId });
-    assertIncludes(r.text, "Added (1)");
-    assertIncludes(r.text, "src/new.txt");
-    assertIncludes(r.text, "Modified (1)");
-    assertIncludes(r.text, "src/a.txt");
-    assertIncludes(r.text, "Deleted (1)");
-    assertIncludes(r.text, "README.md");
-  });
-
-  it("restores with clean (revert + remove new)", async () => {
-    const r = await client.callTool("checkpoint_restore", { dir: PROJ, id: cpId, clean: true });
-    assertIncludes(r.text, "Restored 2 files");
-    assert(fs.readFileSync(path.join(PROJ, "src", "a.txt"), "utf8").includes("original A"), "a.txt not reverted");
-    assert(fs.existsSync(path.join(PROJ, "README.md")), "README not restored");
-    assert(!fs.existsSync(path.join(PROJ, "src", "new.txt")), "new.txt not removed");
-  });
-
-  it("errors on unknown id", async () => {
-    const r = await client.callTool("checkpoint_diff", { dir: PROJ, id: "nope-123" });
-    assert(r.isError, "expected error flag");
-    assertIncludes(r.text, "not found");
-  });
-
-  it("deletes the checkpoint", async () => {
-    const r = await client.callTool("checkpoint_delete", { dir: PROJ, id: cpId });
-    assertIncludes(r.text, "Deleted checkpoint");
-    const r2 = await client.callTool("checkpoint_list", { dir: PROJ });
-    assertIncludes(r2.text, "No checkpoints");
-  });
-});
-
-await client.start();
-const { fail } = await run();
-await client.stop();
-rmrf(STORE); rmrf(PROJ);
-process.exit(fail > 0 ? 1 : 0);

package/context-pack/test.mjs

@@ -1,66 +0,0 @@
-import { McpClient, describe, it, assert, assertIncludes, run, tmpDir, rmrf } from "../_testkit/harness.mjs";
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SERVER = path.join(__dirname, "server.js");
-const PROJ = tmpDir("ctx-proj-");
-
-fs.mkdirSync(path.join(PROJ, "src"), { recursive: true });
-fs.writeFileSync(path.join(PROJ, "package.json"), JSON.stringify({
-  name: "sample", version: "1.0.0",
-  scripts: { dev: "vite", test: "vitest" },
-  dependencies: { react: "^18.0.0", next: "^14.0.0" },
-}, null, 2));
-fs.writeFileSync(path.join(PROJ, "README.md"), "# Sample Project\nDemo app.\n## Setup\nnpm install\n");
-fs.writeFileSync(path.join(PROJ, "src", "auth.ts"),
-  "export function login(user: string) { return true; }\nexport class AuthService { verify() {} }\nfunction helperInternal() {}\n");
-
-const client = new McpClient(SERVER, {});
-
-describe("context-pack", () => {
-  it("lists expected tools", async () => {
-    const tools = await client.listTools();
-    for (const t of ["pack_overview", "pack_tree", "pack_outline", "pack_search"])
-      assert(tools.includes(t), `missing ${t}`);
-  });
-
-  it("overview detects stack + scripts + readme", async () => {
-    const r = await client.callTool("pack_overview", { dir: PROJ });
-    assertIncludes(r.text, "Next.js");
-    assertIncludes(r.text, "React");
-    assertIncludes(r.text, "dev: vite");
-    assertIncludes(r.text, "Sample Project");
-  });
-
-  it("tree shows dirs and files", async () => {
-    const r = await client.callTool("pack_tree", { dir: PROJ, max_depth: 3 });
-    assertIncludes(r.text, "src/");
-    assertIncludes(r.text, "auth.ts");
-  });
-
-  it("outline extracts symbols", async () => {
-    const r = await client.callTool("pack_outline", { dir: PROJ, file: "src/auth.ts" });
-    assertIncludes(r.text, "login");
-    assertIncludes(r.text, "AuthService");
-    assertIncludes(r.text, "helperInternal");
-  });
-
-  it("outline errors on missing file", async () => {
-    const r = await client.callTool("pack_outline", { dir: PROJ, file: "does/not/exist.ts" });
-    assert(r.isError, "expected error");
-    assertIncludes(r.text, "File not found");
-  });
-
-  it("search matches by path substring", async () => {
-    const r = await client.callTool("pack_search", { dir: PROJ, query: "auth" });
-    assertIncludes(r.text, "src/auth.ts");
-  });
-});
-
-await client.start();
-const { fail } = await run();
-await client.stop();
-rmrf(PROJ);
-process.exit(fail > 0 ? 1 : 0);

package/devjournal/test.mjs

@@ -1,68 +0,0 @@
-import { McpClient, describe, it, assert, assertIncludes, run, tmpDir, rmrf } from "../_testkit/harness.mjs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SERVER = path.join(__dirname, "server.js");
-const STORE = tmpDir("jrnl-");
-const PROJ = "/tmp/jrnl-demo-project";
-
-const client = new McpClient(SERVER, { JOURNAL_DIR: STORE });
-
-describe("devjournal", () => {
-  it("lists expected tools", async () => {
-    const tools = await client.listTools();
-    for (const t of ["journal_log", "journal_handoff", "journal_resume", "journal_timeline", "journal_search", "journal_clear_handoff"])
-      assert(tools.includes(t), `missing ${t}`);
-  });
-
-  it("logs entries", async () => {
-    const r1 = await client.callTool("journal_log", { dir: PROJ, title: "Set up auth", type: "done", body: "login + AuthService" });
-    assertIncludes(r1.text, "Logged [done]");
-    const r2 = await client.callTool("journal_log", { dir: PROJ, title: "Refresh undecided", type: "blocker" });
-    assertIncludes(r2.text, "Logged [blocker]");
-  });
-
-  it("saves a handoff", async () => {
-    const r = await client.callTool("journal_handoff", {
-      dir: PROJ, summary: "Auth scaffolding done; wiring refresh next.",
-      next_steps: ["Implement refresh", "Add tests"],
-      open_questions: ["Cookie or header?"], active_files: ["src/auth.ts"],
-    });
-    assertIncludes(r.text, "Handoff saved");
-    assertIncludes(r.text, "Next steps: 2");
-  });
-
-  it("resume returns handoff + recent entries", async () => {
-    const r = await client.callTool("journal_resume", { dir: PROJ });
-    assertIncludes(r.text, "Latest handoff");
-    assertIncludes(r.text, "Implement refresh");
-    assertIncludes(r.text, "Cookie or header?");
-    assertIncludes(r.text, "Recent entries");
-  });
-
-  it("timeline filters by type", async () => {
-    const r = await client.callTool("journal_timeline", { dir: PROJ, type: "blocker" });
-    assertIncludes(r.text, "Refresh undecided");
-    assert(!r.text.includes("Set up auth"), "should not include done entries when filtering blocker");
-  });
-
-  it("search finds entries by keyword (offline mode)", async () => {
-    const r = await client.callTool("journal_search", { dir: PROJ, query: "auth login refresh" });
-    assertIncludes(r.text, "[keyword]");
-    assertIncludes(r.text, "Set up auth");
-  });
-
-  it("clears handoff", async () => {
-    const r = await client.callTool("journal_clear_handoff", { dir: PROJ });
-    assertIncludes(r.text, "Cleared handoff");
-    const r2 = await client.callTool("journal_resume", { dir: PROJ });
-    assert(!r2.text.includes("Latest handoff"), "handoff should be gone");
-  });
-});
-
-await client.start();
-const { fail } = await run();
-await client.stop();
-rmrf(STORE);
-process.exit(fail > 0 ? 1 : 0);

package/project-memory/test.mjs

@@ -1,72 +0,0 @@
-import { McpClient, describe, it, assert, assertIncludes, run, tmpDir, rmrf } from "../_testkit/harness.mjs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SERVER = path.join(__dirname, "server.js");
-const VAULT = tmpDir("pm-");
-const DEMO = "/tmp/pm-demo-project";
-
-// Force keyword mode (no embedding key) so the suite is deterministic/offline.
-const client = new McpClient(SERVER, { MEMORY_VAULT_DIR: VAULT, NINEROUTER_KEY: "", EMBED_KEY: "" });
-
-let savedId = "";
-
-describe("project-memory", () => {
-  it("lists expected tools", async () => {
-    const tools = await client.listTools();
-    for (const t of ["memory_save", "memory_recall", "memory_list", "memory_get", "memory_delete", "memory_reindex"])
-      assert(tools.includes(t), `missing ${t}`);
-  });
-
-  it("saves a note (keyword mode without embeddings)", async () => {
-    const r = await client.callTool("memory_save", {
-      dir: DEMO, title: "JWT login flow",
-      content: "login() issues JWT; refresh token in httpOnly cookie; clock skew bug on verify.",
-      tags: ["auth", "jwt"], kind: "decision",
-    });
-    assertIncludes(r.text, "Saved note");
-    assertIncludes(r.text, "keyword-only");
-    savedId = (r.text.match(/Saved note (\S+)/) || [])[1] || "";
-    assert(savedId, "could not parse note id");
-  });
-
-  it("recalls by keyword and tags mode label", async () => {
-    const r = await client.callTool("memory_recall", { dir: DEMO, query: "jwt auth cookie" });
-    assertIncludes(r.text, "[keyword]");
-    assertIncludes(r.text, "JWT login flow");
-  });
-
-  it("returns no-match gracefully", async () => {
-    const r = await client.callTool("memory_recall", { dir: DEMO, query: "kubernetes helm chart xyzzy" });
-    assertIncludes(r.text, "No relevant memories");
-  });
-
-  it("lists saved notes", async () => {
-    const r = await client.callTool("memory_list", { dir: DEMO });
-    assertIncludes(r.text, "JWT login flow");
-  });
-
-  it("gets full note by id", async () => {
-    const r = await client.callTool("memory_get", { dir: DEMO, id: savedId });
-    assertIncludes(r.text, "httpOnly cookie");
-  });
-
-  it("reindex reports gracefully without embeddings", async () => {
-    const r = await client.callTool("memory_reindex", { dir: DEMO });
-    assertIncludes(r.text, "failed");
-  });
-
-  it("deletes a note", async () => {
-    const r = await client.callTool("memory_delete", { dir: DEMO, id: savedId });
-    assertIncludes(r.text, "Deleted note");
-    const r2 = await client.callTool("memory_list", { dir: DEMO });
-    assertIncludes(r2.text, "No memories");
-  });
-});
-
-await client.start();
-const { fail } = await run();
-await client.stop();
-rmrf(VAULT);
-process.exit(fail > 0 ? 1 : 0);