@cmetech/otto 1.1.1 → 1.2.4

package/src/resources/extensions/coworker-memory/index.test.ts

@@ -0,0 +1,137 @@
+// src/resources/extensions/coworker-memory/index.test.ts
+//
+// Unit tests for the coworker-memory production activator.
+// Covers barrel surface preservation (replaces the Phase 3 Task 12 spot-check
+// stub), lifecycle wiring (session_start/shutdown), command + tool registration,
+// before_agent_start + agent_start round-trip recording a turn drawer,
+// Layer A context injection, and init-failure gating.
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import coworkerMemoryExtension, { getMemoryRecorder, createMemoryBundle } from './index.js';
+import {
+  makeFakeApi, fireSessionStart, fireSessionShutdown,
+  fireBeforeAgentStart, fireAgentStart,
+} from '../coworker-vault/test-helpers.js';
+
+describe('coworker-memory activator', () => {
+  it('barrel still exports key surface (preserves Task 12 spot-check)', () => {
+    assert.equal(typeof createMemoryBundle, 'function');
+    assert.equal(typeof getMemoryRecorder, 'function');
+    assert.equal(typeof coworkerMemoryExtension, 'function');
+  });
+
+  it('getMemoryRecorder returns null before session_start', () => {
+    assert.equal(getMemoryRecorder(), null);
+  });
+
+  it('registers memorize + recall tools and /memory command', () => {
+    const api = makeFakeApi();
+    coworkerMemoryExtension(api.api);
+    assert.ok(api.tools.has('memorize'));
+    assert.ok(api.tools.has('recall'));
+    assert.ok(api.commands.has('memory'));
+  });
+
+  it('session_start constructs bundle; getMemoryRecorder returns recorder', async () => {
+    const api = makeFakeApi();
+    coworkerMemoryExtension(api.api);
+    const ws = mkdtempSync(join(tmpdir(), 'mem-act-'));
+    const global = mkdtempSync(join(tmpdir(), 'mem-act-global-'));
+    process.env.OTTO_COWORKER_GLOBAL_DIR = global;
+    process.env.OTTO_SCRATCHPAD_ROOT = mkdtempSync(join(tmpdir(), 'mem-act-sp-'));
+    try {
+      await fireSessionStart(api, { cwd: ws });
+      assert.equal(api.notifyCalls.find(c => /unavailable/.test(c.message)), undefined);
+      assert.ok(getMemoryRecorder(), 'recorder should be set after session_start');
+      await fireSessionShutdown(api);
+      assert.equal(getMemoryRecorder(), null, 'recorder cleared after session_shutdown');
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+      delete process.env.OTTO_SCRATCHPAD_ROOT;
+    }
+  });
+
+  it('before_agent_start + agent_start round-trip records a turn drawer', async () => {
+    const api = makeFakeApi();
+    coworkerMemoryExtension(api.api);
+    const ws = mkdtempSync(join(tmpdir(), 'mem-rt-'));
+    process.env.OTTO_COWORKER_GLOBAL_DIR = mkdtempSync(join(tmpdir(), 'mem-rt-g-'));
+    process.env.OTTO_SCRATCHPAD_ROOT = mkdtempSync(join(tmpdir(), 'mem-rt-sp-'));
+    try {
+      await fireSessionStart(api, { cwd: ws });
+      const result = await fireBeforeAgentStart(api, 'what happened last night', 'YOU ARE OTTO');
+      // No Layer A content yet → no augmentation expected.
+      assert.equal(result?.systemPrompt, undefined);
+      await fireAgentStart(api, 'sess-1', 'turn-1');
+      // Verify via a fresh peek bundle reading the same DB.
+      const peek = await createMemoryBundle({
+        globalDir: process.env.OTTO_COWORKER_GLOBAL_DIR!,
+        workspaceDir: ws,
+        scopeMode: 'per-project-tagged',
+        currentScratchpadName: () => null,
+      });
+      try {
+        const results = await peek.backend.recall({ query: 'happened' });
+        assert.equal(results.length, 1);
+        assert.equal(results[0]!.drawer.kind, 'turn');
+        assert.match(results[0]!.drawer.content, /what happened last night/);
+      } finally {
+        await peek.dispose();
+      }
+      await fireSessionShutdown(api);
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+      delete process.env.OTTO_SCRATCHPAD_ROOT;
+    }
+  });
+
+  it('before_agent_start injects Layer A block when Layer A has content', async () => {
+    const api = makeFakeApi();
+    coworkerMemoryExtension(api.api);
+    const ws = mkdtempSync(join(tmpdir(), 'mem-la-'));
+    process.env.OTTO_COWORKER_GLOBAL_DIR = mkdtempSync(join(tmpdir(), 'mem-la-g-'));
+    process.env.OTTO_SCRATCHPAD_ROOT = mkdtempSync(join(tmpdir(), 'mem-la-sp-'));
+    try {
+      await fireSessionStart(api, { cwd: ws });
+      // Seed a lesson into the workspace Layer A store through a fresh bundle.
+      const seed = await createMemoryBundle({
+        globalDir: process.env.OTTO_COWORKER_GLOBAL_DIR!,
+        workspaceDir: ws, scopeMode: 'per-project-tagged',
+        currentScratchpadName: () => null,
+      });
+      try {
+        await seed.workspaceLayerA.append({
+          kind: 'lesson', text: 'always check ttl', source: 'user',
+          ts: '2026-06-02T00:00:00Z',
+        });
+      } finally { await seed.dispose(); }
+      const result = await fireBeforeAgentStart(api, 'q', 'BASE PROMPT');
+      assert.match(result?.systemPrompt ?? '', /BASE PROMPT/);
+      assert.match(result?.systemPrompt ?? '', /always check ttl/);
+      await fireSessionShutdown(api);
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+      delete process.env.OTTO_SCRATCHPAD_ROOT;
+    }
+  });
+
+  it('init failure notifies + gates commands', async () => {
+    const api = makeFakeApi();
+    coworkerMemoryExtension(api.api);
+    process.env.OTTO_COWORKER_GLOBAL_DIR = '/no/such/path/should/not/exist';
+    process.env.OTTO_SCRATCHPAD_ROOT = '/no/such/path/should/not/exist';
+    try {
+      await fireSessionStart(api, { cwd: '/no/such/path' });
+      assert.ok(api.notifyCalls.find(c => /memory unavailable/.test(c.message)));
+      const mem = api.commands.get('memory')!;
+      await mem.handler('status', api.commandCtx);
+      assert.ok(api.notifyCalls.filter(c => /unavailable/.test(c.message)).length >= 2);
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+      delete process.env.OTTO_SCRATCHPAD_ROOT;
+    }
+  });
+});

package/src/resources/extensions/coworker-memory/index.ts

@@ -0,0 +1,257 @@
+// src/resources/extensions/coworker-memory/index.ts
+//
+// Coworker Memory production activator. Wires the Phase 3 memory primitives
+// (createMemoryBundle, runMemorize, runRecall, runMemoryCommand, buildLayerAContext)
+// into pi's ExtensionAPI so /memory, memorize+recall tools, before_agent_start
+// Layer A injection, and agent_start auto-retain of user turns all light up in a
+// live Otto session. Closes Phase 3 Task 20 (recordTurn auto-retain).
+//
+// Cross-pillar surface: the scratchpad activator imports getMemoryRecorder()
+// from this module to gate its onDataLoad → recordFileLoad hop (Phase 3.1 Task 4).
+import type { ExtensionAPI } from '@otto/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+import {
+  buildLayerAContext,
+  type MemoryRecorder,
+  type LayerAKind,
+  type DrawerKind,
+} from '@otto/coworker-memory';
+import { createMemoryBundle, type MemoryBundle, type MemoryBundleOptions } from './memory-singleton.js';
+import { runMemorize } from './memorize-tool.js';
+import { runRecall, type RecallToolArgs } from './recall-tool.js';
+import { runMemoryCommand } from './memory-command.js';
+import { onSessionShutdown } from './session-hooks.js';
+import { createCurrentScratchpadProvider } from '../coworker-scratchpad/sp-command.js';
+import { getCoworkerGlobalDir, getScratchpadsRoot } from '../_coworker-paths.js';
+
+export { createMemoryBundle };
+export type { MemoryBundle, MemoryBundleOptions };
+
+// Cross-pillar export. Scratchpad's onDataLoad closure imports this and calls
+// it lazily — returns null before session_start or after session_shutdown,
+// which is the correct "no-op" signal.
+let activeRecorder: MemoryRecorder | null = null;
+export function getMemoryRecorder(): MemoryRecorder | null {
+  return activeRecorder;
+}
+
+const MEMORIZE_PARAMS = Type.Object({
+  text: Type.String({ description: 'The note text to store in Layer A memory.' }),
+  kind: Type.Union(
+    [Type.Literal('profile'), Type.Literal('rule'), Type.Literal('lesson')],
+    { description: "Layer A kind: 'profile' (about the user), 'rule' (must-do), or 'lesson' (learned)." },
+  ),
+  scope: Type.Optional(Type.Union(
+    [Type.Literal('global'), Type.Literal('workspace')],
+    { description: "Defaults to 'workspace' when omitted." },
+  )),
+});
+
+const RECALL_PARAMS = Type.Object({
+  query: Type.String({ description: 'Free-text query to search verbatim drawers.' }),
+  kind: Type.Optional(Type.Union([
+    Type.Literal('turn'), Type.Literal('paste'), Type.Literal('file_load'),
+    Type.Literal('ticket'), Type.Literal('email'), Type.Literal('rca'), Type.Literal('note'),
+  ])),
+  wing: Type.Optional(Type.String()),
+  room: Type.Optional(Type.String()),
+  days_back: Type.Optional(Type.Number()),
+  max_results: Type.Optional(Type.Number()),
+});
+
+export default function coworkerMemoryExtension(api: ExtensionAPI): void {
+  let bundle: MemoryBundle | null = null;
+  let unavailable = false;
+  let pendingPrompt: string | undefined;
+  // One notify per session covers both before_agent_start inject failures and
+  // agent_start recordTurn failures — both are best-effort and must not break
+  // the chat loop. Spec §3.7.
+  let writeFailureNotified = false;
+
+  api.on('session_start', async (_event, ctx) => {
+    try {
+      bundle = await createMemoryBundle({
+        globalDir: getCoworkerGlobalDir(),
+        workspaceDir: ctx.cwd,
+        scopeMode: 'per-project-tagged',
+        currentScratchpadName: createCurrentScratchpadProvider({
+          scratchpadsRoot: getScratchpadsRoot(),
+        }),
+      });
+      activeRecorder = bundle.recorder;
+      unavailable = false;
+    } catch (err) {
+      unavailable = true;
+      bundle = null;
+      activeRecorder = null;
+      ctx.ui.notify(`memory unavailable: ${(err as Error).message}`, 'warning');
+    }
+  });
+
+  api.on('before_agent_start', async (event, ctx) => {
+    if (!bundle) return undefined;
+    // Capture the prompt for the paired agent_start so we can record it even
+    // when there is no Layer A content to inject (block.length === 0).
+    pendingPrompt = event.prompt;
+    try {
+      const block = await buildLayerAContext({
+        mode: bundle.scopeMode,
+        globalStore: bundle.globalLayerA,
+        workspaceStore: bundle.workspaceLayerA,
+        tokenLimit: 3000,
+      });
+      if (block.length === 0) return undefined;
+      return { systemPrompt: event.systemPrompt + '\n\n' + block };
+    } catch (err) {
+      if (!writeFailureNotified) {
+        ctx.ui.notify(`memory context inject failed: ${(err as Error).message}`, 'warning');
+        writeFailureNotified = true;
+      }
+      return undefined;
+    }
+  });
+
+  api.on('agent_start', async (event, ctx) => {
+    if (!bundle || !pendingPrompt || !event.sessionId || !event.turnId) {
+      pendingPrompt = undefined;
+      return;
+    }
+    const userText = pendingPrompt;
+    const sessionId = event.sessionId;
+    const turnId = event.turnId;
+    pendingPrompt = undefined;
+    try {
+      await bundle.recorder.recordTurn({ sessionId, userText, turnId });
+    } catch (err) {
+      if (!writeFailureNotified) {
+        ctx.ui.notify(`memory write failed: ${(err as Error).message}`, 'warning');
+        writeFailureNotified = true;
+      }
+    }
+  });
+
+  // Union TDetails so TS accepts both error and success branches of execute().
+  type MemorizeDetails =
+    | { error: string; stored?: false }
+    | { error?: undefined; stored: true; layer_a_file: string };
+
+  api.registerTool<typeof MEMORIZE_PARAMS, MemorizeDetails>({
+    name: 'memorize',
+    label: 'Memorize',
+    description: 'Save a profile note, rule, or lesson into Layer A memory.',
+    parameters: MEMORIZE_PARAMS,
+    async execute(_toolCallId, params) {
+      if (!bundle) {
+        return {
+          content: [{ type: 'text', text: 'memory unavailable; cannot memorize.' }],
+          details: { error: 'memory unavailable' },
+        };
+      }
+      try {
+        const out = await runMemorize(bundle, {
+          text: params.text,
+          kind: params.kind as LayerAKind,
+          scope: params.scope as 'global' | 'workspace' | undefined,
+        });
+        return {
+          content: [{ type: 'text', text: `stored in ${out.layer_a_file}` }],
+          details: out,
+        };
+      } catch (err) {
+        return {
+          content: [{ type: 'text', text: `memorize failed: ${(err as Error).message}` }],
+          details: { error: (err as Error).message },
+        };
+      }
+    },
+  });
+
+  type RecallDetails =
+    | { error: string; result_count?: undefined }
+    | { error?: undefined; result_count: number };
+
+  api.registerTool<typeof RECALL_PARAMS, RecallDetails>({
+    name: 'recall',
+    label: 'Recall',
+    description: 'Search verbatim drawers in memory (Layer B). Returns markdown with drawer URIs.',
+    parameters: RECALL_PARAMS,
+    async execute(_toolCallId, params) {
+      if (!bundle) {
+        return {
+          content: [{ type: 'text', text: 'memory unavailable; cannot recall.' }],
+          details: { error: 'memory unavailable' },
+        };
+      }
+      try {
+        const args: RecallToolArgs = {
+          query: params.query,
+          kind: params.kind as DrawerKind | undefined,
+          wing: params.wing,
+          room: params.room,
+          days_back: params.days_back,
+          max_results: params.max_results,
+        };
+        const out = await runRecall(bundle, args);
+        return {
+          content: [{ type: 'text', text: out.markdown }],
+          details: { result_count: out.results.length },
+        };
+      } catch (err) {
+        return {
+          content: [{ type: 'text', text: `recall failed: ${(err as Error).message}` }],
+          details: { error: (err as Error).message },
+        };
+      }
+    },
+  });
+
+  api.registerCommand('memory', {
+    description: 'Inspect and manage co-worker memory (Layer A rules/lessons + Layer B drawers).',
+    getArgumentCompletions: (prefix) => {
+      const subcommands = [
+        { label: 'note', description: 'Append a lesson: /memory note <text>' },
+        { label: 'show', description: 'Show Layer A: /memory show [profile|rules|lessons] [--scope workspace|global]' },
+        { label: 'recall', description: 'Search Layer B drawers: /memory recall <query> [--kind|--room|--wing|--limit|--days_back]' },
+        { label: 'status', description: 'Show workspace_wing, drawer_count, db path' },
+        { label: 'clear', description: 'Clear drawers: /memory clear --wing <wing> --confirm' },
+        { label: 'wing', description: 'Set session wing override: /memory wing <name>' },
+        { label: 'room', description: 'Set session room override: /memory room <name>' },
+        { label: 'seed', description: 'Re-apply persona seed on next session_start' },
+      ];
+      return subcommands
+        .filter((s) => s.label.startsWith(prefix))
+        .map((s) => ({ value: s.label, label: s.label, description: s.description }));
+    },
+    handler: async (args, ctx) => {
+      if (!bundle) {
+        ctx.ui.notify(
+          unavailable ? 'memory unavailable; chat continues without it.' : 'memory not ready yet.',
+          'warning',
+        );
+        return;
+      }
+      const argv = args.trim().split(/\s+/).filter(Boolean);
+      try {
+        const result = await runMemoryCommand(bundle, argv);
+        ctx.ui.notify(result.message, 'info');
+      } catch (err) {
+        ctx.ui.notify(`/memory failed: ${(err as Error).message}`, 'error');
+      }
+    },
+  });
+
+  api.on('session_shutdown', async () => {
+    if (bundle) {
+      try {
+        await onSessionShutdown(bundle);
+      } catch {
+        // dispose is best-effort; LocalSqliteBackend.close() handles double-close.
+      }
+    }
+    bundle = null;
+    activeRecorder = null;
+    pendingPrompt = undefined;
+    // writeFailureNotified persists across sessions intentionally — one notify
+    // per Otto process lifetime is enough to avoid spam.
+  });
+}

package/src/resources/extensions/coworker-memory/memorize-tool.test.ts

@@ -0,0 +1,41 @@
+// src/resources/extensions/coworker-memory/memorize-tool.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createMemoryBundle } from './memory-singleton.js';
+import { runMemorize } from './memorize-tool.js';
+
+async function bundleFor(scope: 'global'|'per-project'|'per-project-tagged') {
+  return createMemoryBundle({
+    globalDir: mkdtempSync(join(tmpdir(), 'mt-home-')),
+    workspaceDir: mkdtempSync(join(tmpdir(), 'mt-ws-')),
+    scopeMode: scope, currentScratchpadName: () => null,
+  });
+}
+
+describe('memorize tool', () => {
+  it('writes lesson to workspace by default', async () => {
+    const b = await bundleFor('per-project-tagged');
+    await runMemorize(b, { text: 'MTTR target 30m', kind: 'lesson' });
+    const body = await b.workspaceLayerA.read('lesson');
+    assert.match(body, /MTTR target 30m/);
+    assert.equal((await b.globalLayerA.read('lesson')), '');
+    await b.dispose();
+  });
+  it('honors scope: global', async () => {
+    const b = await bundleFor('per-project-tagged');
+    await runMemorize(b, { text: 'use polars', kind: 'profile', scope: 'global' });
+    assert.match(await b.globalLayerA.read('profile'), /use polars/);
+    await b.dispose();
+  });
+  it('throws LayerAWriteBlocked on secret content', async () => {
+    const b = await bundleFor('per-project-tagged');
+    await assert.rejects(
+      () => runMemorize(b, { text: 'token AKIAABCDEFGHIJKLMNOP', kind: 'rule' }),
+      /VAULT|secret-shaped|Refused/,
+    );
+    await b.dispose();
+  });
+});

package/src/resources/extensions/coworker-memory/memorize-tool.ts

@@ -0,0 +1,20 @@
+// src/resources/extensions/coworker-memory/memorize-tool.ts
+import type { MemoryBundle } from './memory-singleton.js';
+import type { LayerAKind } from '@otto/coworker-memory';
+
+export interface MemorizeArgs {
+  text: string;
+  kind: LayerAKind;
+  scope?: 'global' | 'workspace';
+}
+
+export async function runMemorize(bundle: MemoryBundle, args: MemorizeArgs): Promise<{ stored: true; layer_a_file: string }> {
+  const scope = args.scope ?? 'workspace';
+  const store = scope === 'global' ? bundle.globalLayerA : bundle.workspaceLayerA;
+  const ts = new Date().toISOString();
+  await store.append({ kind: args.kind, text: args.text, source: 'user', ts });
+  return {
+    stored: true,
+    layer_a_file: args.kind === 'lesson' ? 'lessons.md' : args.kind === 'rule' ? 'rules.md' : 'profile.md',
+  };
+}

package/src/resources/extensions/coworker-memory/memory-command.test.ts

@@ -0,0 +1,134 @@
+// src/resources/extensions/coworker-memory/memory-command.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createMemoryBundle } from './memory-singleton.js';
+import { runMemoryCommand } from './memory-command.js';
+
+async function setup() {
+  const home = mkdtempSync(join(tmpdir(), 'mc-home-'));
+  const ws = mkdtempSync(join(tmpdir(), 'mc-ws-'));
+  mkdirSync(ws, { recursive: true });
+  return createMemoryBundle({
+    globalDir: home, workspaceDir: ws,
+    scopeMode: 'per-project-tagged', currentScratchpadName: () => null,
+  });
+}
+
+describe('/memory command', () => {
+  it('note appends a lesson', async () => {
+    const b = await setup();
+    const out = await runMemoryCommand(b, ['note', 'P1 includes MTTR']);
+    assert.match(out.message, /lesson stored/i);
+    assert.match(await b.workspaceLayerA.read('lesson'), /P1 includes MTTR/);
+    await b.dispose();
+  });
+  it('status reports workspace_wing + drawer_count', async () => {
+    const b = await setup();
+    await b.recorder.recordTurn({ sessionId: 's', userText: 'x', turnId: 't' });
+    const out = await runMemoryCommand(b, ['status']);
+    assert.match(out.message, /workspace_wing:/);
+    assert.match(out.message, /drawer_count: 1/);
+    await b.dispose();
+  });
+  it('clear --wing deletes drawers', async () => {
+    const b = await setup();
+    await b.recorder.recordTurn({ sessionId: 's', userText: 'x', turnId: 't' });
+    const out = await runMemoryCommand(b, ['clear', '--wing', b.writeWing, '--confirm']);
+    assert.match(out.message, /deleted: 1/);
+    await b.dispose();
+  });
+  it('clear without --confirm errors', async () => {
+    const b = await setup();
+    await assert.rejects(() => runMemoryCommand(b, ['clear', '--wing', 'x']));
+    await b.dispose();
+  });
+});
+
+describe('/memory show (Phase 3.1 follow-up: issue #73)', () => {
+  it('show with no args dumps profile + rules + lessons for read scopes (per-project-tagged → workspace first then global)', async () => {
+    const b = await setup();
+    await b.workspaceLayerA.append({ kind: 'lesson', text: 'mttr is 30m', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    await b.workspaceLayerA.append({ kind: 'rule', text: 'escalate P1 to mgr', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    await b.globalLayerA.append({ kind: 'profile', text: 'prefer polars', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    const out = await runMemoryCommand(b, ['show']);
+    assert.match(out.message, /## Lessons \(workspace\)/);
+    assert.match(out.message, /mttr is 30m/);
+    assert.match(out.message, /## Rules \(workspace\)/);
+    assert.match(out.message, /escalate P1 to mgr/);
+    assert.match(out.message, /## Profile \(global\)/);
+    assert.match(out.message, /prefer polars/);
+    // workspace appears before global
+    assert.ok(out.message.indexOf('workspace') < out.message.indexOf('global'));
+    await b.dispose();
+  });
+  it('show lessons dumps only lessons.md', async () => {
+    const b = await setup();
+    await b.workspaceLayerA.append({ kind: 'lesson', text: 'l1', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    await b.workspaceLayerA.append({ kind: 'rule', text: 'r1', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    const out = await runMemoryCommand(b, ['show', 'lessons']);
+    assert.match(out.message, /l1/);
+    assert.equal(out.message.includes('r1'), false);
+    await b.dispose();
+  });
+  it('show with --scope global reads global only', async () => {
+    const b = await setup();
+    await b.workspaceLayerA.append({ kind: 'lesson', text: 'ws-only', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    await b.globalLayerA.append({ kind: 'lesson', text: 'global-only', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    const out = await runMemoryCommand(b, ['show', 'lessons', '--scope', 'global']);
+    assert.match(out.message, /global-only/);
+    assert.equal(out.message.includes('ws-only'), false);
+    await b.dispose();
+  });
+  it('show missing layer outputs "(none)"', async () => {
+    const b = await setup();
+    // No appends — both stores empty
+    const out = await runMemoryCommand(b, ['show', 'rules']);
+    assert.match(out.message, /\(none\)/);
+    await b.dispose();
+  });
+  it('show with invalid kind errors with usage', async () => {
+    const b = await setup();
+    await assert.rejects(() => runMemoryCommand(b, ['show', 'banana']));
+    await b.dispose();
+  });
+});
+
+describe('/memory recall (Phase 3.1 follow-up: issue #73)', () => {
+  it('recall <query> returns formatted markdown matching the recall LLM tool', async () => {
+    const b = await setup();
+    await b.recorder.recordPaste({
+      sessionId: 's', content: 'load balancer returned 503s around 14:00 UTC', turnId: 't1',
+    });
+    const out = await runMemoryCommand(b, ['recall', 'load', 'balancer']);
+    assert.match(out.message, /Memory recall \(1 matches\)/);
+    assert.match(out.message, /<mark>/);
+    assert.match(out.message, /drawer:\/\//);
+    await b.dispose();
+  });
+  it('recall with no args errors with usage notice', async () => {
+    const b = await setup();
+    await assert.rejects(() => runMemoryCommand(b, ['recall']));
+    await b.dispose();
+  });
+  it('recall --kind paste filters to paste drawers', async () => {
+    const b = await setup();
+    await b.recorder.recordTurn({ sessionId: 's', userText: 'short alpha', turnId: 't1' });
+    await b.recorder.recordPaste({ sessionId: 's', content: 'long alpha paste body', turnId: 't2' });
+    const out = await runMemoryCommand(b, ['recall', 'alpha', '--kind', 'paste']);
+    assert.match(out.message, /Memory recall \(1 matches\)/);
+    await b.dispose();
+  });
+  it('recall --limit clamps to [1, 64]', async () => {
+    const b = await setup();
+    for (let i = 0; i < 10; i++) {
+      await b.recorder.recordTurn({ sessionId: 's', userText: `apple ${i}`, turnId: `t${i}` });
+    }
+    const out = await runMemoryCommand(b, ['recall', 'apple', '--limit', '3']);
+    // Markdown header reports actual count, which should be 3 due to clamp
+    assert.match(out.message, /Memory recall \(3 matches\)/);
+    await b.dispose();
+  });
+});