qualia-framework 6.14.0 → 7.0.0

package/tests/runner.js

@@ -105,6 +105,62 @@ Goal: Test goal
   fs.writeFileSync(path.join(dir, ".planning", `phase-${phase}-plan.md`), plan);
 }
 
+// Helper: write a compiled machine contract + passing machine evidence.
+// v7 kernel: `planned` requires phase-N-contract.json and `verified(pass)`
+// requires passing evidence at evidence/phase-N-contract-run.json. Tests that
+// exercise the ABSENCE of these (MISSING_CONTRACT/MISSING_FILE) must NOT call
+// this. Mirrors make_valid_contract in tests/state.test.sh.
+function makeValidContract(dir, phase) {
+  phase = phase || 1;
+  const planning = path.join(dir, ".planning");
+  const contract = {
+    version: 1,
+    phase,
+    goal: "Test goal",
+    why: "Exercise machine evidence",
+    generated_at: "2026-05-23T00:00:00.000Z",
+    generated_by: "manual",
+    source_plan_hash: "",
+    success_criteria: ["Machine check passes"],
+    tasks: [
+      {
+        id: "T1",
+        title: "Machine check",
+        wave: 1,
+        depends_on: [],
+        persona: "none",
+        files_modify: [],
+        files_create: [],
+        files_delete: [],
+        acceptance_criteria: ["Node command exits 0"],
+        action: "Run deterministic evidence check",
+        context_files: [],
+        verification: [
+          {
+            type: "command-exit",
+            command: "node",
+            args: ["-e", "process.exit(0)"],
+            expected_exit: 0,
+            timeout_ms: 5000,
+          },
+        ],
+      },
+    ],
+  };
+  fs.writeFileSync(path.join(planning, `phase-${phase}-contract.json`), JSON.stringify(contract, null, 2));
+  fs.mkdirSync(path.join(planning, "evidence"), { recursive: true });
+  fs.writeFileSync(
+    path.join(planning, "evidence", `phase-${phase}-contract-run.json`),
+    '{"ok":true,"checks":[]}\n'
+  );
+}
+
+// Helper: plan + contract + evidence in one call (the common happy-path setup).
+function makePlannablePhase(dir, phase) {
+  makeValidPlan(dir, phase);
+  makeValidContract(dir, phase);
+}
+
 // Helper: strip ANSI escape codes
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
@@ -274,8 +330,11 @@ describe("CLI", () => {
   it("set-erp-key saves key and enables ERP", () => {
     const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-cli-"));
     try {
-      const r = run("cli.js", ["set-erp-key", "test-erp-key-12345"], {
+      // v5.0: the key is read from stdin, not a positional arg (positional
+      // args leak into shell history). Pipe it in.
+      const r = run("cli.js", ["set-erp-key"], {
         env: { HOME: tmpHome, USERPROFILE: tmpHome },
+        input: "test-erp-key-12345",
       });
       assert.equal(r.status, 0);
       const keyPath = path.join(tmpHome, ".claude", ".erp-api-key");
@@ -308,9 +367,12 @@ describe("State Machine", () => {
 
   it("init creates state and tracking files", () => {
     withTempPlanning((tmpDir) => {
+      // `test-proj` trips the SUSPICIOUS_NAME guard (test-like name). This test
+      // intentionally uses a test name, so --force past the guard. (The name is
+      // still echoed back verbatim, so the project assertion is unchanged.)
       const r = spawnSync(NODE, [
         path.join(BIN, "state.js"), "init",
-        "--project", "test-proj",
+        "--project", "test-proj", "--force",
         "--phases", '[{"name":"Foundation","goal":"Auth"}]',
       ], { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       assert.equal(r.status, 0);
@@ -389,7 +451,7 @@ describe("State Machine", () => {
   it("setup -> planned succeeds with plan file", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       const r = runState(["transition", "--to", "planned"], tmpDir);
       assert.equal(r.status, 0);
       const out = JSON.parse(r.stdout);
@@ -404,7 +466,7 @@ describe("State Machine", () => {
   it("planned -> built records tasks_done/tasks_total", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       runState(["transition", "--to", "planned"], tmpDir);
       const r = runState(["transition", "--to", "built", "--tasks-done", "5", "--tasks-total", "5"], tmpDir);
       assert.equal(r.status, 0);
@@ -422,7 +484,7 @@ describe("State Machine", () => {
   it("built -> verified(pass) auto-advances to phase 2", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       runState(["transition", "--to", "planned"], tmpDir);
       runState(["transition", "--to", "built", "--tasks-done", "5", "--tasks-total", "5"], tmpDir);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "pass");
@@ -440,7 +502,7 @@ describe("State Machine", () => {
   it("built -> verified(fail) stays on same phase", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       runState(["transition", "--to", "planned"], tmpDir);
       runState(["transition", "--to", "built", "--tasks-done", "3", "--tasks-total", "5"], tmpDir);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "fail");
@@ -459,7 +521,7 @@ describe("State Machine", () => {
   it("planned -> verified fails (requires built)", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       runState(["transition", "--to", "planned"], tmpDir);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "");
       const r = runState(["transition", "--to", "verified", "--verification", "pass"], tmpDir);
@@ -487,7 +549,7 @@ describe("State Machine", () => {
   it("built -> verified fails without verification file", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       runState(["transition", "--to", "planned"], tmpDir);
       runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
       const r = runState(["transition", "--to", "verified", "--verification", "pass"], tmpDir);
@@ -503,7 +565,7 @@ describe("State Machine", () => {
   it("built -> verified without --verification -> MISSING_ARG", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       runState(["transition", "--to", "planned"], tmpDir);
       runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "");
@@ -650,7 +712,7 @@ waves: 1
   it("gap cycle circuit breaker blocks after limit", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "");
 
       // Cycle 1: planned -> built -> verified(fail) -> planned
@@ -685,7 +747,7 @@ waves: 1
   it("verified(pass) resets gap_cycles to 0", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "");
 
       // One fail cycle
@@ -710,7 +772,7 @@ waves: 1
   it("configurable gap_cycle_limit allows more cycles", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "");
 
       // Set custom limit
@@ -969,7 +1031,7 @@ waves: 1
   it("transition leaves no .tmp file on success (atomic write)", () => {
     const tmpDir = makeProject();
     try {
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       const r = runState(["transition", "--to", "planned"], tmpDir);
       assert.equal(r.status, 0);
       const planning = path.join(tmpDir, ".planning");
@@ -1115,6 +1177,8 @@ waves: 1
 **Acceptance Criteria:**
 - ok
 `);
+        // v7 kernel: planned needs a contract, verified(pass) needs evidence.
+        makeValidContract(tmpDir, phase);
         const verFile = path.join(tmpDir, ".planning", `phase-${phase}-verification.md`);
         // Plan → built → verified
         let r = spawnSync(NODE, [path.join(BIN, "state.js"), "transition", "--to", "planned", "--phase", String(phase)],
@@ -1164,6 +1228,8 @@ waves: 1
 **Acceptance Criteria:**
 - ok
 `);
+      // v7 kernel: planned requires a compiled machine contract.
+      makeValidContract(tmpDir, 1);
       spawnSync(NODE, [path.join(BIN, "state.js"), "transition", "--to", "planned", "--phase", "1"],
         { encoding: "utf8", cwd: tmpDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
       const r = spawnSync(NODE, [path.join(BIN, "state.js"), "transition", "--to", "built", "--phase", "1", "--tasks-done", "1", "--tasks-total", "1"],
@@ -1229,13 +1295,13 @@ waves: 1
     const tmpDir = makeProject();
     try {
       // Walk both phases through verified, then polished, then shipped.
-      makeValidPlan(tmpDir, 1);
+      makePlannablePhase(tmpDir, 1);
       runState(["transition", "--to", "planned"], tmpDir);
       runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-1-verification.md"), "# pass\n");
       runState(["transition", "--to", "verified", "--verification", "pass"], tmpDir);
 
-      makeValidPlan(tmpDir, 2);
+      makePlannablePhase(tmpDir, 2);
       runState(["transition", "--to", "planned"], tmpDir);
       runState(["transition", "--to", "built", "--tasks-done", "1", "--tasks-total", "1"], tmpDir);
       fs.writeFileSync(path.join(tmpDir, ".planning", "phase-2-verification.md"), "# pass\n");
@@ -1837,7 +1903,10 @@ describe("Hooks", () => {
     }
   });
 
-  it("branch-guard: EMPLOYEE on main -> blocked", () => {
+  // v6.10 policy: EMPLOYEE pushing to main is ALLOWED + recorded (accountability,
+  // not a hard block). The hook exits 0, emits a notice, and writes a per-employee
+  // tally to .claude/.main-push-events.json. (Matches tests/hooks.test.sh.)
+  it("branch-guard: EMPLOYEE on main -> allowed + recorded + notice", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
     try {
       const projDir = path.join(tmpDir, "proj");
@@ -1851,8 +1920,10 @@ describe("Hooks", () => {
         env: { ...process.env, HOME: tmpDir, USERPROFILE: tmpDir },
         stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 2);
-      assert.match(r.stdout, /BLOCKED/);
+      assert.equal(r.status, 0);
+      assert.match(r.stdout + r.stderr, /main-push/);
+      const events = JSON.parse(fs.readFileSync(path.join(tmpDir, ".claude", ".main-push-events.json"), "utf8"));
+      assert.equal(events.events[0].type, "employee_main_push");
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -1878,68 +1949,72 @@ describe("Hooks", () => {
     }
   });
 
-  it("branch-guard: missing config -> blocked (fails closed)", () => {
+  // v6.10: the hook never blocks now — missing config means no known role, so
+  // it allows and does not record. (Matches tests/hooks.test.sh.)
+  it("branch-guard: missing config -> allowed (never blocks)", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
     try {
       const projDir = path.join(tmpDir, "proj");
       fs.mkdirSync(projDir, { recursive: true });
       spawnSync("git", ["init", "-q"], { cwd: projDir });
-      spawnSync("git", ["checkout", "-b", "feature/x", "-q"], { cwd: projDir, stdio: "pipe" });
+      spawnSync("git", ["checkout", "-b", "main", "-q"], { cwd: projDir, stdio: "pipe" });
       // No .claude/.qualia-config.json
       const r = spawnSync(NODE, [path.join(HOOKS, "branch-guard.js")], {
         encoding: "utf8", cwd: projDir, timeout: 5000,
         env: { ...process.env, HOME: tmpDir, USERPROFILE: tmpDir },
         stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 2);
+      assert.equal(r.status, 0);
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
 
-  it("branch-guard: malformed config JSON -> blocked", () => {
+  it("branch-guard: malformed config JSON -> allowed", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
     try {
       const projDir = path.join(tmpDir, "proj");
       fs.mkdirSync(projDir, { recursive: true });
       fs.mkdirSync(path.join(tmpDir, ".claude"), { recursive: true });
       spawnSync("git", ["init", "-q"], { cwd: projDir });
-      spawnSync("git", ["checkout", "-b", "feature/x", "-q"], { cwd: projDir, stdio: "pipe" });
+      spawnSync("git", ["checkout", "-b", "main", "-q"], { cwd: projDir, stdio: "pipe" });
       fs.writeFileSync(path.join(tmpDir, ".claude", ".qualia-config.json"), "not json{");
       const r = spawnSync(NODE, [path.join(HOOKS, "branch-guard.js")], {
         encoding: "utf8", cwd: projDir, timeout: 5000,
         env: { ...process.env, HOME: tmpDir, USERPROFILE: tmpDir },
         stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 2);
+      assert.equal(r.status, 0);
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
 
-  it("branch-guard: empty role field -> blocked", () => {
+  // Empty role → allowed AND not recorded (not a known EMPLOYEE).
+  it("branch-guard: empty role field -> allowed, not recorded", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
     try {
       const projDir = path.join(tmpDir, "proj");
       fs.mkdirSync(projDir, { recursive: true });
       fs.mkdirSync(path.join(tmpDir, ".claude"), { recursive: true });
       spawnSync("git", ["init", "-q"], { cwd: projDir });
-      spawnSync("git", ["checkout", "-b", "feature/x", "-q"], { cwd: projDir, stdio: "pipe" });
+      spawnSync("git", ["checkout", "-b", "main", "-q"], { cwd: projDir, stdio: "pipe" });
       fs.writeFileSync(path.join(tmpDir, ".claude", ".qualia-config.json"), JSON.stringify({ role: "" }));
       const r = spawnSync(NODE, [path.join(HOOKS, "branch-guard.js")], {
         encoding: "utf8", cwd: projDir, timeout: 5000,
         env: { ...process.env, HOME: tmpDir, USERPROFILE: tmpDir },
         stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 2);
+      assert.equal(r.status, 0);
+      assert.equal(fs.existsSync(path.join(tmpDir, ".claude", ".main-push-events.json")), false);
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
 
-  // v3.5.0: refspec bypass — EMPLOYEE on a feature branch trying to push
-  // `feature/x:main` MUST be blocked, even though current branch isn't main.
-  it("branch-guard: EMPLOYEE refspec push to main -> blocked", () => {
+  // v6.10: a refspec push to :main from a feature branch is detected and
+  // RECORDED (not blocked). EMPLOYEE → exit 0 + tally written.
+  it("branch-guard: EMPLOYEE refspec push to main -> allowed + recorded", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
     try {
       const projDir = path.join(tmpDir, "proj");
@@ -1958,13 +2033,15 @@ describe("Hooks", () => {
         input: payload,
         stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 2, "refspec push to main must be blocked for EMPLOYEE");
+      assert.equal(r.status, 0, "refspec push to main is recorded, not blocked");
+      const events = JSON.parse(fs.readFileSync(path.join(tmpDir, ".claude", ".main-push-events.json"), "utf8"));
+      assert.equal(events.events[0].type, "employee_main_push");
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
 
-  it("branch-guard: EMPLOYEE refspec push to master -> blocked", () => {
+  it("branch-guard: EMPLOYEE refspec push to master -> allowed + recorded", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-bg-"));
     try {
       const projDir = path.join(tmpDir, "proj");
@@ -1982,7 +2059,7 @@ describe("Hooks", () => {
         input: payload,
         stdio: ["pipe", "pipe", "pipe"],
       });
-      assert.equal(r.status, 2, "refspec push to master must be blocked for EMPLOYEE");
+      assert.equal(r.status, 0, "refspec push to master is recorded, not blocked");
     } finally {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -2822,3 +2899,256 @@ describe("install.js", () => {
     }
   });
 });
+
+// ─── Memory MCP server ─────────────────────────────────────
+describe("memory-mcp server", () => {
+  const SERVER = path.join(ROOT, "mcp", "memory-mcp", "server.js");
+
+  // Drive the server through line-delimited JSON-RPC frames synchronously.
+  // Returns an array of parsed responses in order.
+  function rpc(frames, env = {}) {
+    const input = frames.map((f) => JSON.stringify(f)).join("\n") + "\n";
+    const r = spawnSync(process.execPath, [SERVER], {
+      encoding: "utf8",
+      timeout: 8000,
+      input,
+      env: { ...process.env, ...env },
+    });
+    return (r.stdout || "")
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  }
+
+  it("responds to initialize with protocol + serverInfo", () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-"));
+    try {
+      fs.mkdirSync(path.join(tmpRoot, "wiki"), { recursive: true });
+      const out = rpc(
+        [{ jsonrpc: "2.0", id: 1, method: "initialize" }],
+        { QUALIA_MEMORY_ROOT: tmpRoot },
+      );
+      assert.equal(out[0].id, 1);
+      assert.equal(out[0].result.serverInfo.name, "qualia-memory");
+      assert.ok(out[0].result.protocolVersion);
+      assert.ok(out[0].result.capabilities.tools);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("tools/list advertises three read-only tools", () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-"));
+    try {
+      fs.mkdirSync(path.join(tmpRoot, "wiki"), { recursive: true });
+      const out = rpc(
+        [{ jsonrpc: "2.0", id: 1, method: "tools/list" }],
+        { QUALIA_MEMORY_ROOT: tmpRoot },
+      );
+      const names = out[0].result.tools.map((t) => t.name).sort();
+      assert.deepEqual(names, ["memory.list", "memory.read", "memory.search"]);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("memory.search finds matches and returns file:line:snippet", () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-"));
+    try {
+      const wiki = path.join(tmpRoot, "wiki");
+      fs.mkdirSync(path.join(wiki, "concepts"), { recursive: true });
+      fs.writeFileSync(
+        path.join(wiki, "concepts", "alpha.md"),
+        "# Alpha\nSakani Properties uses Mapbox.\nUnrelated line.\n",
+      );
+      const out = rpc(
+        [
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: "memory.search", arguments: { query: "Mapbox" } },
+          },
+        ],
+        { QUALIA_MEMORY_ROOT: tmpRoot },
+      );
+      const payload = JSON.parse(out[0].result.content[0].text);
+      assert.equal(payload.total, 1);
+      assert.equal(payload.hits[0].path, "concepts/alpha.md");
+      assert.equal(payload.hits[0].line, 2);
+      assert.match(payload.hits[0].snippet, /Mapbox/);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("memory.read returns file content under the wiki", () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-"));
+    try {
+      const wiki = path.join(tmpRoot, "wiki");
+      fs.mkdirSync(wiki, { recursive: true });
+      fs.writeFileSync(path.join(wiki, "hot.md"), "recent context");
+      const out = rpc(
+        [
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: "memory.read", arguments: { path: "hot.md" } },
+          },
+        ],
+        { QUALIA_MEMORY_ROOT: tmpRoot },
+      );
+      const payload = JSON.parse(out[0].result.content[0].text);
+      assert.equal(payload.content, "recent context");
+      assert.equal(payload.truncated, false);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("memory.read rejects path traversal outside wiki/", () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-"));
+    try {
+      fs.mkdirSync(path.join(tmpRoot, "wiki"), { recursive: true });
+      // Sibling secret outside wiki/ — must not be reachable via ..
+      fs.writeFileSync(path.join(tmpRoot, "secret.txt"), "shhh");
+      const out = rpc(
+        [
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: "memory.read", arguments: { path: "../secret.txt" } },
+          },
+        ],
+        { QUALIA_MEMORY_ROOT: tmpRoot },
+      );
+      assert.ok(out[0].error, "expected error response");
+      assert.match(out[0].error.message, /escapes wiki root/);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("memory.list returns directories first, then files", () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-"));
+    try {
+      const wiki = path.join(tmpRoot, "wiki");
+      fs.mkdirSync(path.join(wiki, "concepts"), { recursive: true });
+      fs.writeFileSync(path.join(wiki, "index.md"), "i");
+      const out = rpc(
+        [
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: "memory.list", arguments: {} },
+          },
+        ],
+        { QUALIA_MEMORY_ROOT: tmpRoot },
+      );
+      const payload = JSON.parse(out[0].result.content[0].text);
+      assert.equal(payload.entries[0].type, "dir");
+      assert.equal(payload.entries[0].name, "concepts");
+      assert.ok(payload.entries.some((e) => e.name === "index.md" && e.type === "file"));
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("unknown tool returns JSON-RPC -32601", () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-"));
+    try {
+      fs.mkdirSync(path.join(tmpRoot, "wiki"), { recursive: true });
+      const out = rpc(
+        [
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: "memory.delete", arguments: {} },
+          },
+        ],
+        { QUALIA_MEMORY_ROOT: tmpRoot },
+      );
+      assert.equal(out[0].error.code, -32601);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  // ── Access control (honors wiki/_meta/access.md, shared with recall.js) ──
+  // Seed a vault with an access manifest: one OWNER_ONLY page + one ALL_ROLES page.
+  function seedGatedVault() {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memory-mcp-acl-"));
+    const wiki = path.join(tmpRoot, "wiki");
+    fs.mkdirSync(path.join(wiki, "concepts"), { recursive: true });
+    fs.mkdirSync(path.join(wiki, "_meta"), { recursive: true });
+    fs.writeFileSync(path.join(wiki, "concepts", "pub.md"), "Public lesson: gizmo retries.\n");
+    fs.writeFileSync(
+      path.join(wiki, "_meta", "access.md"),
+      "# Vault Access Manifest\n## OWNER_ONLY\n| `Clients/*.md` | x |\n| `wiki/_meta/access.md` | gizmo marker |\n## ALL_ROLES\n| `wiki/concepts/` | ok |\n",
+    );
+    return tmpRoot;
+  }
+
+  it("memory.search filters OWNER_ONLY hits for non-OWNER", () => {
+    const tmpRoot = seedGatedVault();
+    try {
+      const out = rpc(
+        [{ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "memory.search", arguments: { query: "gizmo" } } }],
+        { QUALIA_MEMORY_ROOT: tmpRoot, QUALIA_ROLE: "EMPLOYEE" },
+      );
+      const payload = JSON.parse(out[0].result.content[0].text);
+      const paths = payload.hits.map((h) => h.path);
+      assert.ok(paths.includes("concepts/pub.md"), "ALL_ROLES hit present");
+      assert.ok(!paths.includes("_meta/access.md"), "OWNER_ONLY hit filtered");
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("memory.search shows OWNER_ONLY hits for OWNER", () => {
+    const tmpRoot = seedGatedVault();
+    try {
+      const out = rpc(
+        [{ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "memory.search", arguments: { query: "gizmo" } } }],
+        { QUALIA_MEMORY_ROOT: tmpRoot, QUALIA_ROLE: "OWNER" },
+      );
+      const payload = JSON.parse(out[0].result.content[0].text);
+      const paths = payload.hits.map((h) => h.path);
+      assert.ok(paths.includes("_meta/access.md"), "OWNER sees OWNER_ONLY hit");
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("memory.read denies OWNER_ONLY path for non-OWNER", () => {
+    const tmpRoot = seedGatedVault();
+    try {
+      const out = rpc(
+        [{ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "memory.read", arguments: { path: "_meta/access.md" } } }],
+        { QUALIA_MEMORY_ROOT: tmpRoot, QUALIA_ROLE: "EMPLOYEE" },
+      );
+      assert.ok(out[0].error, "expected error");
+      assert.match(out[0].error.message, /OWNER-only/);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("memory.list hides OWNER_ONLY entries for non-OWNER", () => {
+    const tmpRoot = seedGatedVault();
+    try {
+      const out = rpc(
+        [{ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "memory.list", arguments: { folder: "_meta" } } }],
+        { QUALIA_MEMORY_ROOT: tmpRoot, QUALIA_ROLE: "EMPLOYEE" },
+      );
+      const payload = JSON.parse(out[0].result.content[0].text);
+      assert.ok(!payload.entries.some((e) => e.name === "access.md"), "access.md hidden from non-OWNER listing");
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+});