@cmetech/otto 1.1.1 → 1.2.4

package/packages/coworker-memory/src/memory-integration.test.ts

@@ -0,0 +1,89 @@
+// packages/coworker-memory/src/memory-integration.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createMemoryBundle } from '../../../src/resources/extensions/coworker-memory/memory-singleton.js';
+import { runMemorize } from '../../../src/resources/extensions/coworker-memory/memorize-tool.js';
+import { runRecall } from '../../../src/resources/extensions/coworker-memory/recall-tool.js';
+import { onSessionStart, onSessionShutdown } from '../../../src/resources/extensions/coworker-memory/session-hooks.js';
+
+describe('Memory integration — Day-2 verbatim recall', () => {
+  it('paste Monday → recall Tuesday in a fresh session', async () => {
+    const homeMon = mkdtempSync(join(tmpdir(), 'mem-home-mon-'));
+    const ws = mkdtempSync(join(tmpdir(), 'mem-ws-mon-'));
+    mkdirSync(ws, { recursive: true });
+
+    // ===== MONDAY =====
+    const monBundle = await createMemoryBundle({
+      globalDir: homeMon, workspaceDir: ws,
+      scopeMode: 'per-project-tagged',
+      currentScratchpadName: () => 'p1-1234',
+    });
+    await monBundle.recorder.recordPaste({
+      sessionId: 'sess-mon',
+      content: 'customer says the load balancer started returning 503s around 14:00 UTC; the on-call escalated to the network team at 14:18',
+      turnId: 't1',
+    });
+    await onSessionShutdown(monBundle);
+
+    // Simulate a different Otto process by re-creating the bundle with the same workspace.
+    // ===== TUESDAY =====
+    const tueBundle = await createMemoryBundle({
+      globalDir: homeMon /* same as Monday */, workspaceDir: ws,
+      scopeMode: 'per-project-tagged',
+      currentScratchpadName: () => null,
+    });
+    const start = await onSessionStart(tueBundle, { tokenLimit: 3000 });
+    // Layer A was empty Monday, so the inject is empty on Tuesday.
+    assert.equal(start.contextBlock, '');
+    const r = await runRecall(tueBundle, { query: 'load balancer' });
+    assert.equal(r.results.length, 1);
+    assert.match(r.results[0]!.drawer.content, /load balancer started returning 503s around 14:00 UTC/);
+    assert.equal(r.results[0]!.drawer.room, 'p1-1234');
+    assert.match(r.markdown, /drawer:\/\//);
+    await onSessionShutdown(tueBundle);
+  });
+  it('memorize lessons → next session_start injects them', async () => {
+    const home = mkdtempSync(join(tmpdir(), 'mem-home-A-'));
+    const ws = mkdtempSync(join(tmpdir(), 'mem-ws-A-'));
+    mkdirSync(ws, { recursive: true });
+    const b1 = await createMemoryBundle({
+      globalDir: home, workspaceDir: ws,
+      scopeMode: 'per-project-tagged', currentScratchpadName: () => null,
+    });
+    await runMemorize(b1, { text: 'MTTR target is 30 minutes for P1', kind: 'lesson' });
+    await runMemorize(b1, { text: 'Always escalate to mgr within 5 min on customer-facing P1', kind: 'rule' });
+    await onSessionShutdown(b1);
+
+    const b2 = await createMemoryBundle({
+      globalDir: home, workspaceDir: ws,
+      scopeMode: 'per-project-tagged', currentScratchpadName: () => null,
+    });
+    const start = await onSessionStart(b2, { tokenLimit: 3000 });
+    assert.match(start.contextBlock, /MTTR target is 30 minutes/);
+    assert.match(start.contextBlock, /Always escalate to mgr/);
+    await onSessionShutdown(b2);
+  });
+  it('secret in paste is redacted; recall surrounding context still works', async () => {
+    const home = mkdtempSync(join(tmpdir(), 'mem-home-B-'));
+    const ws = mkdtempSync(join(tmpdir(), 'mem-ws-B-'));
+    mkdirSync(ws, { recursive: true });
+    const b = await createMemoryBundle({
+      globalDir: home, workspaceDir: ws,
+      scopeMode: 'per-project-tagged', currentScratchpadName: () => null,
+    });
+    await b.recorder.recordPaste({
+      sessionId: 's',
+      content: 'login token AKIAABCDEFGHIJKLMNOP, used for Datadog API',
+      turnId: 't',
+    });
+    const r = await runRecall(b, { query: 'Datadog' });
+    assert.equal(r.results.length, 1);
+    assert.match(r.results[0]!.drawer.content, /\[REDACTED:aws_access_key_id\]/);
+    assert.equal(r.results[0]!.drawer.content.includes('AKIAABCDEFGHIJKLMNOP'), false);
+    assert.equal(r.results[0]!.drawer.redacted, true);
+    await onSessionShutdown(b);
+  });
+});

package/packages/coworker-memory/src/memory-recorder.test.ts

@@ -0,0 +1,101 @@
+// packages/coworker-memory/src/memory-recorder.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 { AuditLog, SecretScanner } from '@otto/coworker-utils';
+import { LocalSqliteBackend } from './local-sqlite-backend.js';
+import { MemoryRecorder } from './memory-recorder.js';
+
+async function ctx() {
+  const dir = mkdtempSync(join(tmpdir(), 'mr-'));
+  const audit = new AuditLog({ path: join(dir, 'audit.jsonl') });
+  const scanner = new SecretScanner();
+  const backend = new LocalSqliteBackend({ dbPath: join(dir, 'layer-b.db') });
+  await backend.open();
+  return { dir, audit, scanner, backend };
+}
+
+describe('MemoryRecorder', () => {
+  it('recordTurn writes kind:turn drawer for short text', async () => {
+    const c = await ctx();
+    const recorder = new MemoryRecorder({
+      backend: c.backend, scanner: c.scanner, audit: c.audit,
+      writeWing: 'global', currentScratchpadName: () => null,
+    });
+    await recorder.recordTurn({ sessionId: 's', userText: 'hi', turnId: 't1' });
+    const wings = await c.backend.listWings();
+    assert.deepEqual(wings, ['global']);
+    const rooms = await c.backend.listRooms('global');
+    assert.deepEqual(rooms, ['inbox']);
+    await c.backend.close();
+  });
+  it('recordTurn writes kind:paste drawer for long text', async () => {
+    const c = await ctx();
+    const recorder = new MemoryRecorder({
+      backend: c.backend, scanner: c.scanner, audit: c.audit,
+      writeWing: 'global', currentScratchpadName: () => 'p1',
+    });
+    // Use whitespace-separated tokens so FTS5 can index/match (single huge token wouldn't match 'x').
+    const longText = 'lorem ipsum '.repeat(60); // > 500 chars, tokenizable
+    await recorder.recordTurn({ sessionId: 's', userText: longText, turnId: 't1' });
+    const r = await c.backend.recall({ query: 'lorem' });
+    assert.equal(r[0]!.drawer.kind, 'paste');
+    assert.equal(r[0]!.drawer.room, 'p1');
+    await c.backend.close();
+  });
+  it('redacts secret content and sets redacted=true', async () => {
+    const c = await ctx();
+    const recorder = new MemoryRecorder({
+      backend: c.backend, scanner: c.scanner, audit: c.audit,
+      writeWing: 'global', currentScratchpadName: () => null,
+    });
+    await recorder.recordPaste({ sessionId: 's', content: 'token AKIAABCDEFGHIJKLMNOP', turnId: 't1' });
+    const r = await c.backend.recall({ query: 'token' });
+    assert.equal(r[0]!.drawer.redacted, true);
+    assert.match(r[0]!.drawer.content, /\[REDACTED:aws_access_key_id\]/);
+    const rows: { action: string }[] = [];
+    for await (const x of c.audit.read({ producer: 'memory', action: 'redact' })) rows.push(x as never);
+    assert.equal(rows.length, 1);
+    await c.backend.close();
+  });
+  it('recordFileLoad stores structured JSON in content', async () => {
+    const c = await ctx();
+    const recorder = new MemoryRecorder({
+      backend: c.backend, scanner: c.scanner, audit: c.audit,
+      writeWing: 'global', currentScratchpadName: () => 'p1',
+    });
+    await recorder.recordFileLoad({
+      scratchpadName: 'p1', collector: 'file', uri: 'file:///x.csv',
+      bytes: 1000, rows_loaded: 50, schema: { cols: ['a','b'] }, turnId: 't1',
+    });
+    const r = await c.backend.recall({ query: 'file' });
+    assert.equal(r[0]!.drawer.kind, 'file_load');
+    const parsed = JSON.parse(r[0]!.drawer.content);
+    assert.equal(parsed.uri, 'file:///x.csv');
+    assert.equal(parsed.rows_loaded, 50);
+    await c.backend.close();
+  });
+});
+
+describe('MemoryRecorder.recordArtifact (Phase 4 Task 8)', () => {
+  it('writes a kind:artifact drawer with slug/kind/uri JSON content', async () => {
+    const c = await ctx();
+    const recorder = new MemoryRecorder({
+      backend: c.backend, scanner: c.scanner, audit: c.audit,
+      writeWing: 'global', currentScratchpadName: () => null,
+    });
+    await recorder.recordArtifact({
+      scratchpadName: 'p1', slug: 'rca-1', kind: 'report',
+      uri: 'artifact://rca-1', turnId: 't1',
+    });
+    const r = await c.backend.recall({ query: 'rca', kind: 'artifact' });
+    assert.equal(r.length, 1);
+    const parsed = JSON.parse(r[0]!.drawer.content);
+    assert.equal(parsed.slug, 'rca-1');
+    assert.equal(parsed.uri, 'artifact://rca-1');
+    assert.equal(r[0]!.drawer.room, 'p1');
+    await c.backend.close();
+  });
+});

package/packages/coworker-memory/src/memory-recorder.ts

@@ -0,0 +1,95 @@
+// packages/coworker-memory/src/memory-recorder.ts
+import { AuditLog, SecretScanner } from '@otto/coworker-utils';
+import type { MemoryBackend } from './memory-backend.js';
+import type { Wing, Room, Drawer } from './types.js';
+import { detectPaste } from './paste-detector.js';
+
+export interface CurrentScratchpadProvider {
+  (sessionId: string): string | null;
+}
+
+export interface MemoryRecorderOptions {
+  backend: MemoryBackend;
+  scanner: SecretScanner;
+  audit: AuditLog;
+  writeWing: Wing;
+  currentScratchpadName: CurrentScratchpadProvider;
+  pasteOptions?: { lengthThreshold?: number; newlineThreshold?: number };
+}
+
+export class MemoryRecorder {
+  constructor(private readonly opts: MemoryRecorderOptions) {}
+
+  async recordTurn(args: { sessionId: string; userText: string; turnId: string; room?: Room }): Promise<Drawer> {
+    const kind = detectPaste(args.userText, this.opts.pasteOptions);
+    const room = args.room ?? this.opts.currentScratchpadName(args.sessionId) ?? 'inbox';
+    return this.writeDrawer({
+      wing: this.opts.writeWing, room, kind,
+      content: args.userText, metadata: { turn_id: args.turnId, session_id: args.sessionId },
+    });
+  }
+
+  async recordPaste(args: { sessionId: string; content: string; turnId: string; room?: Room }): Promise<Drawer> {
+    const room = args.room ?? this.opts.currentScratchpadName(args.sessionId) ?? 'inbox';
+    return this.writeDrawer({
+      wing: this.opts.writeWing, room, kind: 'paste',
+      content: args.content, metadata: { turn_id: args.turnId, session_id: args.sessionId },
+    });
+  }
+
+  async recordFileLoad(args: {
+    scratchpadName: string; collector: string; uri: string;
+    bytes: number; rows_loaded?: number; schema?: object; turnId: string;
+  }): Promise<Drawer> {
+    const content = JSON.stringify({
+      collector: args.collector, uri: args.uri, bytes: args.bytes,
+      rows_loaded: args.rows_loaded, schema: args.schema,
+    });
+    return this.writeDrawer({
+      wing: this.opts.writeWing, room: args.scratchpadName, kind: 'file_load',
+      content, metadata: { turn_id: args.turnId, scratchpad: args.scratchpadName },
+    });
+  }
+
+  async recordArtifact(args: {
+    scratchpadName: string; slug: string; kind: string; uri: string;
+    turnId: string;
+  }): Promise<Drawer> {
+    const content = JSON.stringify({
+      slug: args.slug, kind: args.kind, uri: args.uri,
+    });
+    return this.writeDrawer({
+      wing: this.opts.writeWing, room: args.scratchpadName, kind: 'artifact',
+      content, metadata: { turn_id: args.turnId, scratchpad: args.scratchpadName },
+    });
+  }
+
+  private async writeDrawer(input: Omit<Drawer, 'id' | 'created_at' | 'redacted'>): Promise<Drawer> {
+    const hits = this.opts.scanner.scan(input.content);
+    let content = input.content;
+    let redacted = false;
+    if (hits.length > 0) {
+      content = this.opts.scanner.redact(input.content);
+      redacted = true;
+      const ts = new Date().toISOString();
+      for (const h of hits) {
+        this.opts.audit.append({
+          _schema: 1, ts, producer: 'memory', action: 'redact', severity: 'warn',
+          detail: {
+            wing: input.wing, room: input.room, kind: input.kind,
+            secret_kind: h.kind, offset: h.start, length: h.end - h.start,
+          },
+        });
+      }
+    }
+    const drawer = await this.opts.backend.retain({ ...input, content, redacted });
+    this.opts.audit.append({
+      _schema: 1, ts: new Date().toISOString(), producer: 'memory', action: 'write-drawer',
+      detail: {
+        wing: drawer.wing, room: drawer.room, kind: drawer.kind,
+        byte_count: Buffer.byteLength(content, 'utf8'), redacted,
+      },
+    });
+    return drawer;
+  }
+}

package/packages/coworker-memory/src/migrations/001-init.sql

@@ -0,0 +1,38 @@
+-- packages/coworker-memory/src/migrations/001-init.sql
+PRAGMA journal_mode = WAL;
+PRAGMA user_version = 1;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS drawers (
+  id TEXT PRIMARY KEY,
+  wing TEXT NOT NULL,
+  room TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('turn','paste','file_load','ticket','email','rca','note')),
+  content TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  parent_id TEXT REFERENCES drawers(id) ON DELETE SET NULL,
+  redacted INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_drawers_wing_room ON drawers (wing, room);
+CREATE INDEX IF NOT EXISTS idx_drawers_kind ON drawers (kind);
+CREATE INDEX IF NOT EXISTS idx_drawers_created_at ON drawers (created_at);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS drawers_fts USING fts5 (
+  content,
+  content='drawers',
+  content_rowid='rowid',
+  tokenize='unicode61 remove_diacritics 2'
+);
+
+CREATE TRIGGER IF NOT EXISTS drawers_ai AFTER INSERT ON drawers BEGIN
+  INSERT INTO drawers_fts (rowid, content) VALUES (new.rowid, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS drawers_ad AFTER DELETE ON drawers BEGIN
+  INSERT INTO drawers_fts (drawers_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+END;
+CREATE TRIGGER IF NOT EXISTS drawers_au AFTER UPDATE ON drawers BEGIN
+  INSERT INTO drawers_fts (drawers_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+  INSERT INTO drawers_fts (rowid, content) VALUES (new.rowid, new.content);
+END;

package/packages/coworker-memory/src/migrations/002-artifact-kind.sql

@@ -0,0 +1,50 @@
+-- packages/coworker-memory/src/migrations/002-artifact-kind.sql
+-- Adds 'artifact' to the drawers.kind CHECK constraint. SQLite can't ALTER
+-- constraints, so the table is rebuilt. Dropping the old table also drops
+-- its triggers, so we recreate them. The FTS index is rebuilt from the
+-- new drawers table to keep rowid alignment.
+
+BEGIN;
+
+CREATE TABLE drawers_new (
+  id TEXT PRIMARY KEY,
+  wing TEXT NOT NULL,
+  room TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN
+    ('turn','paste','file_load','ticket','email','rca','note','artifact')),
+  content TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  parent_id TEXT REFERENCES drawers_new(id) ON DELETE SET NULL,
+  redacted INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+INSERT INTO drawers_new (id, wing, room, kind, content, metadata_json, parent_id, redacted, created_at)
+SELECT id, wing, room, kind, content, metadata_json, parent_id, redacted, created_at FROM drawers;
+
+DROP TABLE drawers;
+ALTER TABLE drawers_new RENAME TO drawers;
+
+-- Recreate indexes (the rename preserves rowids but not separately-named indexes).
+CREATE INDEX IF NOT EXISTS idx_drawers_wing_room ON drawers (wing, room);
+CREATE INDEX IF NOT EXISTS idx_drawers_kind ON drawers (kind);
+CREATE INDEX IF NOT EXISTS idx_drawers_created_at ON drawers (created_at);
+
+-- Recreate triggers (dropped when the old drawers table was dropped).
+CREATE TRIGGER IF NOT EXISTS drawers_ai AFTER INSERT ON drawers BEGIN
+  INSERT INTO drawers_fts (rowid, content) VALUES (new.rowid, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS drawers_ad AFTER DELETE ON drawers BEGIN
+  INSERT INTO drawers_fts (drawers_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+END;
+CREATE TRIGGER IF NOT EXISTS drawers_au AFTER UPDATE ON drawers BEGIN
+  INSERT INTO drawers_fts (drawers_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
+  INSERT INTO drawers_fts (rowid, content) VALUES (new.rowid, new.content);
+END;
+
+-- Rebuild FTS index so rowids align with the new drawers table.
+INSERT INTO drawers_fts (drawers_fts) VALUES ('rebuild');
+
+PRAGMA user_version = 2;
+
+COMMIT;

package/packages/coworker-memory/src/paste-detector.test.ts

@@ -0,0 +1,23 @@
+// packages/coworker-memory/src/paste-detector.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { detectPaste } from './paste-detector.js';
+
+describe('detectPaste', () => {
+  it('returns turn for short single-line', () => {
+    assert.equal(detectPaste('what servers had alerts last night?'), 'turn');
+  });
+  it('returns paste when length >= 500', () => {
+    assert.equal(detectPaste('x'.repeat(500)), 'paste');
+  });
+  it('returns paste on triple-backtick fence', () => {
+    assert.equal(detectPaste('look at this:\n```ts\nconst x = 1;\n```'), 'paste');
+  });
+  it('returns paste on > 10 newlines', () => {
+    assert.equal(detectPaste('a\n'.repeat(11)), 'paste');
+  });
+  it('respects custom thresholds', () => {
+    assert.equal(detectPaste('x'.repeat(100), { lengthThreshold: 50 }), 'paste');
+    assert.equal(detectPaste('a\n'.repeat(5), { newlineThreshold: 3 }), 'paste');
+  });
+});

package/packages/coworker-memory/src/paste-detector.ts

@@ -0,0 +1,18 @@
+// packages/coworker-memory/src/paste-detector.ts
+export interface PasteDetectorOptions {
+  lengthThreshold?: number;     // default 500
+  newlineThreshold?: number;    // default 10
+}
+
+const DEFAULT_LENGTH = 500;
+const DEFAULT_NEWLINES = 10;
+
+export function detectPaste(text: string, opts: PasteDetectorOptions = {}): 'turn' | 'paste' {
+  const lengthThreshold = opts.lengthThreshold ?? DEFAULT_LENGTH;
+  const newlineThreshold = opts.newlineThreshold ?? DEFAULT_NEWLINES;
+  if (/```/.test(text)) return 'paste';
+  if (text.length >= lengthThreshold) return 'paste';
+  const newlines = (text.match(/\n/g) ?? []).length;
+  if (newlines > newlineThreshold) return 'paste';
+  return 'turn';
+}

package/packages/coworker-memory/src/persona-seed.test.ts

@@ -0,0 +1,57 @@
+// packages/coworker-memory/src/persona-seed.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { AuditLog, SecretScanner } from '@otto/coworker-utils';
+import { LayerAStore } from './layer-a-store.js';
+import { applyPersonaSeed } from './persona-seed.js';
+
+function setup() {
+  const root = mkdtempSync(join(tmpdir(), 'ps-'));
+  const audit = new AuditLog({ path: join(root, 'audit.jsonl') });
+  const scanner = new SecretScanner();
+  const scopeDir = join(root, 'memory');
+  const personaDir = join(root, 'persona-noc');
+  const seedDir = join(personaDir, 'memory-seed');
+  mkdirSync(seedDir, { recursive: true });
+  const store = new LayerAStore({ scopeDir, scope: 'workspace', audit, scanner });
+  return { root, audit, store, personaDir, seedDir };
+}
+
+describe('applyPersonaSeed', () => {
+  it('copies profile.md/rules.md/lessons.md from persona memory-seed', async () => {
+    const c = setup();
+    writeFileSync(join(c.seedDir, 'profile.md'), 'Persona NOC profile baseline.');
+    writeFileSync(join(c.seedDir, 'rules.md'), 'Always escalate P1 to mgr.');
+    writeFileSync(join(c.seedDir, 'lessons.md'), 'Datadog API uses pagination.');
+    const out = await applyPersonaSeed({
+      personaId: 'noc-ops', personaDir: c.personaDir, store: c.store,
+    });
+    assert.deepEqual(out.copied.sort(), ['lessons.md', 'profile.md', 'rules.md']);
+    assert.match(await c.store.read('profile'), /Persona NOC profile baseline/);
+    assert.match(await c.store.read('rule'), /Always escalate P1 to mgr/);
+    assert.match(await c.store.read('lesson'), /Datadog API uses pagination/);
+  });
+  it('blocks files containing secrets but copies remaining', async () => {
+    const c = setup();
+    writeFileSync(join(c.seedDir, 'profile.md'), 'Persona baseline.');
+    writeFileSync(join(c.seedDir, 'rules.md'), 'use AKIAABCDEFGHIJKLMNOP for telemetry');
+    const out = await applyPersonaSeed({
+      personaId: 'noc-ops', personaDir: c.personaDir, store: c.store,
+    });
+    assert.deepEqual(out.copied, ['profile.md']);
+    assert.deepEqual(out.blocked, ['rules.md']);
+    assert.equal(await c.store.read('rule'), '');
+  });
+  it('returns empty result when persona has no memory-seed dir', async () => {
+    const c = setup();
+    // No files written; remove seedDir
+    const out = await applyPersonaSeed({
+      personaId: 'plain', personaDir: join(c.root, 'no-such-persona'), store: c.store,
+    });
+    assert.deepEqual(out.copied, []);
+    assert.deepEqual(out.blocked, []);
+  });
+});

package/packages/coworker-memory/src/persona-seed.ts

@@ -0,0 +1,46 @@
+// packages/coworker-memory/src/persona-seed.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { LayerAStore } from './layer-a-store.js';
+import type { LayerAKind } from './types.js';
+import { LayerAWriteBlocked } from './errors.js';
+
+const FILE_MAP: Array<{ name: string; kind: LayerAKind }> = [
+  { name: 'profile.md', kind: 'profile' },
+  { name: 'rules.md', kind: 'rule' },
+  { name: 'lessons.md', kind: 'lesson' },
+];
+
+export interface SeedResult {
+  copied: string[];
+  blocked: string[];
+}
+
+export async function applyPersonaSeed(args: {
+  personaId: string;
+  personaDir: string;
+  store: LayerAStore;
+}): Promise<SeedResult> {
+  const seedDir = join(args.personaDir, 'memory-seed');
+  if (!existsSync(seedDir)) return { copied: [], blocked: [] };
+  const ts = new Date().toISOString();
+  const copied: string[] = [];
+  const blocked: string[] = [];
+  for (const entry of FILE_MAP) {
+    const path = join(seedDir, entry.name);
+    if (!existsSync(path)) continue;
+    const text = readFileSync(path, 'utf8').trim();
+    if (!text) continue;
+    try {
+      await args.store.append({ kind: entry.kind, text, source: 'persona-seed', ts });
+      copied.push(entry.name);
+    } catch (err) {
+      if (err instanceof LayerAWriteBlocked) {
+        blocked.push(entry.name);
+      } else {
+        throw err;
+      }
+    }
+  }
+  return { copied, blocked };
+}

package/packages/coworker-memory/src/recall-formatter.test.ts

@@ -0,0 +1,34 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { formatRecall } from './recall-formatter.js';
+
+describe('formatRecall', () => {
+  it('returns empty header for zero results', () => {
+    const md = formatRecall([]);
+    assert.match(md, /### Memory recall \(0 matches\)/);
+    assert.equal(md.includes('drawer://'), false);
+  });
+  it('renders match metadata + snippet + drawer URI', () => {
+    const md = formatRecall([{
+      drawer: {
+        id: 'abc123', wing: 'global', room: 'inbox', kind: 'paste',
+        content: 'full content', metadata: {}, created_at: '2026-06-01T14:22:00Z',
+        redacted: false,
+      },
+      score: 5.21, snippet: 'paste content <mark>matched</mark> terms',
+    }]);
+    assert.match(md, /\[global\/inbox\/paste · 2026-06-01 14:22\] \(score 5\.21\)/);
+    assert.match(md, /<mark>matched<\/mark>/);
+    assert.match(md, /drawer:\/\/abc123/);
+  });
+  it('flags redacted drawers', () => {
+    const md = formatRecall([{
+      drawer: {
+        id: 'r1', wing: 'g', room: 'inbox', kind: 'paste', content: 'x',
+        metadata: {}, created_at: '2026-06-01T00:00:00Z', redacted: true,
+      },
+      score: 1, snippet: 'x',
+    }]);
+    assert.match(md, /\(redacted\)/);
+  });
+});

package/packages/coworker-memory/src/recall-formatter.ts

@@ -0,0 +1,15 @@
+import type { RecallResult } from './types.js';
+
+export function formatRecall(results: RecallResult[]): string {
+  const header = `### Memory recall (${results.length} matches)\n`;
+  if (results.length === 0) return header;
+  const lines: string[] = [header];
+  results.forEach((r, i) => {
+    const ts = r.drawer.created_at.replace('T', ' ').slice(0, 16);
+    const redacted = r.drawer.redacted ? ' (redacted)' : '';
+    lines.push(`\n${i + 1}. [${r.drawer.wing}/${r.drawer.room}/${r.drawer.kind} · ${ts}] (score ${r.score.toFixed(2)})${redacted}`);
+    lines.push(`   > ${r.snippet}`);
+    lines.push(`   drawer://${r.drawer.id}`);
+  });
+  return lines.join('\n');
+}

package/packages/coworker-memory/src/scope-resolver.test.ts

@@ -0,0 +1,23 @@
+// packages/coworker-memory/src/scope-resolver.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveScope } from './scope-resolver.js';
+
+describe('resolveScope', () => {
+  const wing = 'acme-noc-7f3a9c';
+  it('global → write global, read [global]', () => {
+    const r = resolveScope({ mode: 'global', workspaceId: wing });
+    assert.equal(r.writeWing, 'global');
+    assert.deepEqual(r.readWings, ['global']);
+  });
+  it('per-project → write workspace, read [workspace]', () => {
+    const r = resolveScope({ mode: 'per-project', workspaceId: wing });
+    assert.equal(r.writeWing, wing);
+    assert.deepEqual(r.readWings, [wing]);
+  });
+  it('per-project-tagged → write workspace, read [workspace, global]', () => {
+    const r = resolveScope({ mode: 'per-project-tagged', workspaceId: wing });
+    assert.equal(r.writeWing, wing);
+    assert.deepEqual(r.readWings, [wing, 'global']);
+  });
+});

package/packages/coworker-memory/src/scope-resolver.ts

@@ -0,0 +1,18 @@
+// packages/coworker-memory/src/scope-resolver.ts
+import type { ScopeMode, Wing } from './types.js';
+
+export interface ResolvedScope {
+  writeWing: Wing;
+  readWings: Wing[];
+}
+
+export function resolveScope(args: { mode: ScopeMode; workspaceId: Wing }): ResolvedScope {
+  switch (args.mode) {
+    case 'global':
+      return { writeWing: 'global', readWings: ['global'] };
+    case 'per-project':
+      return { writeWing: args.workspaceId, readWings: [args.workspaceId] };
+    case 'per-project-tagged':
+      return { writeWing: args.workspaceId, readWings: [args.workspaceId, 'global'] };
+  }
+}