@cmetech/otto 1.1.1 → 1.2.5

package/packages/coworker-memory/dist/layer-a-store.js

@@ -0,0 +1,78 @@
+// packages/coworker-memory/src/layer-a-store.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { LayerAWriteBlocked, MemoryEntryMalformed } from './errors.js';
+const FILE_FOR = {
+    profile: 'profile.md',
+    rule: 'rules.md',
+    lesson: 'lessons.md',
+};
+const TITLE_FOR = {
+    profile: 'Profile',
+    rule: 'Rules',
+    lesson: 'Lessons',
+};
+export class LayerAStore {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async append(entry) {
+        const hits = this.opts.scanner.scan(entry.text);
+        if (hits.length > 0) {
+            this.opts.audit.append({
+                _schema: 1, ts: new Date().toISOString(), producer: 'memory', action: 'block', severity: 'warn',
+                detail: { scope: this.opts.scope, kind: entry.kind, reason: 'secret', secret_kind: hits[0].kind },
+            });
+            throw new LayerAWriteBlocked(hits[0].kind);
+        }
+        mkdirSync(this.opts.scopeDir, { recursive: true, mode: 0o700 });
+        const path = join(this.opts.scopeDir, FILE_FOR[entry.kind]);
+        const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
+        const { body } = existing ? this.split(existing, path) : { body: '' };
+        const addition = entry.kind === 'lesson'
+            ? `- (${entry.ts}) ${entry.text}\n`
+            : `## ${entry.ts}\n${entry.text}\n\n`;
+        const newBody = (body && !body.endsWith('\n') ? body + '\n' : body) + addition;
+        const newFile = this.composeFile(entry.kind, newBody, entry.ts, entry.source);
+        const tmp = `${path}.tmp`;
+        writeFileSync(tmp, newFile, { mode: 0o600 });
+        chmodSync(tmp, 0o600);
+        renameSync(tmp, path);
+        this.opts.audit.append({
+            _schema: 1, ts: new Date().toISOString(), producer: 'memory', action: 'write-layer-a',
+            detail: { scope: this.opts.scope, kind: entry.kind, source: entry.source, byte_count: Buffer.byteLength(entry.text, 'utf8') },
+        });
+    }
+    async read(kind) {
+        const path = join(this.opts.scopeDir, FILE_FOR[kind]);
+        if (!existsSync(path))
+            return '';
+        const raw = readFileSync(path, 'utf8');
+        const { body } = this.split(raw, path);
+        return body.trim();
+    }
+    split(raw, path) {
+        if (!raw.startsWith('---')) {
+            return { frontmatter: {}, body: raw };
+        }
+        const end = raw.indexOf('\n---\n', 4);
+        if (end < 0)
+            throw new MemoryEntryMalformed(path, 'unterminated frontmatter');
+        try {
+            const fm = parseYaml(raw.slice(4, end));
+            const body = raw.slice(end + 5);
+            return { frontmatter: fm ?? {}, body };
+        }
+        catch (err) {
+            throw new MemoryEntryMalformed(path, `frontmatter parse: ${err.message}`);
+        }
+    }
+    composeFile(kind, body, ts, source) {
+        const fm = { schema_version: 1, last_modified_at: ts, source };
+        const fmStr = stringifyYaml(fm).trimEnd();
+        const header = `---\n${fmStr}\n---\n\n# ${TITLE_FOR[kind]}\n\n`;
+        return header + body.replace(new RegExp(`^\\n?# ${TITLE_FOR[kind]}\\n\\n?`), '');
+    }
+}

package/packages/coworker-memory/dist/local-sqlite-backend.d.ts

@@ -0,0 +1,28 @@
+import type { MemoryBackend } from './memory-backend.js';
+import type { Drawer, RecallQuery, RecallResult, BackendStatus, Wing, Room } from './types.js';
+export interface LocalSqliteBackendOptions {
+    dbPath: string;
+    now?: () => string;
+    busyTimeoutMs?: number;
+}
+export declare class LocalSqliteBackend implements MemoryBackend {
+    private db;
+    private readonly path;
+    private readonly now;
+    private readonly busyTimeoutMs;
+    constructor(opts: LocalSqliteBackendOptions);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    private requireDb;
+    retain(input: Omit<Drawer, 'id' | 'created_at'>): Promise<Drawer>;
+    recall(query: RecallQuery): Promise<RecallResult[]>;
+    listRooms(wing?: Wing): Promise<Room[]>;
+    listWings(): Promise<Wing[]>;
+    status(): Promise<BackendStatus>;
+    clear(args: {
+        wing?: Wing;
+        confirm: true;
+    }): Promise<{
+        deleted: number;
+    }>;
+}

package/packages/coworker-memory/dist/local-sqlite-backend.js

@@ -0,0 +1,167 @@
+// packages/coworker-memory/src/local-sqlite-backend.ts
+import Database from 'better-sqlite3';
+import { readFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { v4 as uuid } from 'uuid';
+import { RecallQueryMalformed, BackendUnavailable } from './errors.js';
+function migrationDir() {
+    return join(dirname(fileURLToPath(import.meta.url)), 'migrations');
+}
+function escapeFts5(q) {
+    // Wrap each word containing special chars in double quotes; doubled internal quotes.
+    // Empty query → throw upstream.
+    const tokens = q.match(/\S+/g) ?? [];
+    return tokens.map(t => `"${t.replace(/"/g, '""')}"`).join(' OR ');
+}
+export class LocalSqliteBackend {
+    db = null;
+    path;
+    now;
+    busyTimeoutMs;
+    constructor(opts) {
+        this.path = opts.dbPath;
+        this.now = opts.now ?? (() => new Date().toISOString());
+        this.busyTimeoutMs = opts.busyTimeoutMs ?? 2000;
+    }
+    async open() {
+        if (this.db)
+            return;
+        mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+        try {
+            this.db = new Database(this.path);
+            this.db.pragma(`busy_timeout = ${this.busyTimeoutMs}`);
+            const dir = migrationDir();
+            const migrations = [
+                { version: 1, file: '001-init.sql' },
+                { version: 2, file: '002-artifact-kind.sql' },
+            ];
+            const userVersion = this.db.pragma('user_version', { simple: true });
+            for (const m of migrations) {
+                if (userVersion < m.version) {
+                    const sql = readFileSync(join(dir, m.file), 'utf8');
+                    this.db.exec(sql);
+                }
+            }
+        }
+        catch (err) {
+            throw new BackendUnavailable(`open failed: ${err.message}`);
+        }
+    }
+    async close() {
+        this.db?.close();
+        this.db = null;
+    }
+    requireDb() {
+        if (!this.db)
+            throw new BackendUnavailable('not opened');
+        return this.db;
+    }
+    async retain(input) {
+        const db = this.requireDb();
+        const id = uuid();
+        const created_at = this.now();
+        const stmt = db.prepare(`
+      INSERT INTO drawers (id, wing, room, kind, content, metadata_json, parent_id, redacted, created_at)
+      VALUES (@id, @wing, @room, @kind, @content, @metadata_json, @parent_id, @redacted, @created_at)
+    `);
+        stmt.run({
+            id, wing: input.wing, room: input.room, kind: input.kind, content: input.content,
+            metadata_json: JSON.stringify(input.metadata ?? {}),
+            parent_id: input.parent_id ?? null,
+            redacted: input.redacted ? 1 : 0,
+            created_at,
+        });
+        return { id, created_at, ...input };
+    }
+    async recall(query) {
+        if (!query.query || !query.query.trim())
+            throw new RecallQueryMalformed('empty query');
+        const db = this.requireDb();
+        const matchExpr = escapeFts5(query.query.trim());
+        const conditions = ['drawers_fts MATCH ?'];
+        const params = [matchExpr];
+        if (query.wing) {
+            if (Array.isArray(query.wing)) {
+                conditions.push(`d.wing IN (${query.wing.map(() => '?').join(',')})`);
+                params.push(...query.wing);
+            }
+            else {
+                conditions.push('d.wing = ?');
+                params.push(query.wing);
+            }
+        }
+        if (query.room) {
+            conditions.push('d.room = ?');
+            params.push(query.room);
+        }
+        if (query.kind) {
+            const kinds = Array.isArray(query.kind) ? query.kind : [query.kind];
+            conditions.push(`d.kind IN (${kinds.map(() => '?').join(',')})`);
+            params.push(...kinds);
+        }
+        if (query.days_back && query.days_back > 0) {
+            const cutoff = new Date(Date.now() - query.days_back * 86400_000).toISOString();
+            conditions.push('d.created_at >= ?');
+            params.push(cutoff);
+        }
+        const limit = Math.min(Math.max(query.max_results ?? 8, 1), 64);
+        params.push(limit);
+        const sql = `
+      SELECT d.id, d.wing, d.room, d.kind, d.content, d.metadata_json, d.parent_id, d.redacted, d.created_at,
+             bm25(drawers_fts) AS rank,
+             snippet(drawers_fts, 0, '<mark>', '</mark>', '...', 16) AS snippet
+      FROM drawers_fts
+      JOIN drawers d ON d.rowid = drawers_fts.rowid
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY rank
+      LIMIT ?
+    `;
+        const rows = db.prepare(sql).all(...params);
+        return rows.map(r => ({
+            drawer: {
+                id: r.id, wing: r.wing, room: r.room, kind: r.kind, content: r.content,
+                metadata: JSON.parse(r.metadata_json),
+                parent_id: r.parent_id ?? undefined, redacted: r.redacted === 1,
+                created_at: r.created_at,
+            },
+            score: -r.rank, // BM25 lower=better in sqlite; invert for descending
+            snippet: r.snippet,
+        }));
+    }
+    async listRooms(wing) {
+        const db = this.requireDb();
+        const sql = wing
+            ? `SELECT DISTINCT room FROM drawers WHERE wing = ? ORDER BY room`
+            : `SELECT DISTINCT room FROM drawers ORDER BY room`;
+        const rows = wing ? db.prepare(sql).all(wing) : db.prepare(sql).all();
+        return rows.map(r => r.room);
+    }
+    async listWings() {
+        const db = this.requireDb();
+        const rows = db.prepare(`SELECT DISTINCT wing FROM drawers ORDER BY wing`).all();
+        return rows.map(r => r.wing);
+    }
+    async status() {
+        const db = this.requireDb();
+        const { c } = db.prepare(`SELECT COUNT(*) AS c FROM drawers`).get();
+        const { user_version } = db.prepare(`PRAGMA user_version`).get();
+        return {
+            ready: true,
+            workspace_wing: '', // caller (memory-singleton) overlays this from scope info
+            drawer_count: c,
+            layer_b_db_path: this.path,
+            schema_version: user_version,
+        };
+    }
+    async clear(args) {
+        if (args.confirm !== true)
+            throw new RecallQueryMalformed('confirm must be true');
+        const db = this.requireDb();
+        const stmt = args.wing
+            ? db.prepare(`DELETE FROM drawers WHERE wing = ?`)
+            : db.prepare(`DELETE FROM drawers`);
+        const result = args.wing ? stmt.run(args.wing) : stmt.run();
+        return { deleted: result.changes };
+    }
+}

package/packages/coworker-memory/dist/memory-backend.d.ts

@@ -0,0 +1,14 @@
+import type { Drawer, RecallQuery, RecallResult, BackendStatus, Wing, Room } from './types.js';
+export interface MemoryBackend {
+    recall(query: RecallQuery): Promise<RecallResult[]>;
+    retain(input: Omit<Drawer, 'id' | 'created_at'>): Promise<Drawer>;
+    listRooms(wing?: Wing): Promise<Room[]>;
+    listWings(): Promise<Wing[]>;
+    status(): Promise<BackendStatus>;
+    clear(args: {
+        wing?: Wing;
+        confirm: true;
+    }): Promise<{
+        deleted: number;
+    }>;
+}

package/packages/coworker-memory/dist/memory-backend.js

@@ -0,0 +1 @@
+export {};

package/packages/coworker-memory/dist/memory-recorder.d.ts

@@ -0,0 +1,50 @@
+import { AuditLog, SecretScanner } from '@otto/coworker-utils';
+import type { MemoryBackend } from './memory-backend.js';
+import type { Wing, Room, Drawer } from './types.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 declare class MemoryRecorder {
+    private readonly opts;
+    constructor(opts: MemoryRecorderOptions);
+    recordTurn(args: {
+        sessionId: string;
+        userText: string;
+        turnId: string;
+        room?: Room;
+    }): Promise<Drawer>;
+    recordPaste(args: {
+        sessionId: string;
+        content: string;
+        turnId: string;
+        room?: Room;
+    }): Promise<Drawer>;
+    recordFileLoad(args: {
+        scratchpadName: string;
+        collector: string;
+        uri: string;
+        bytes: number;
+        rows_loaded?: number;
+        schema?: object;
+        turnId: string;
+    }): Promise<Drawer>;
+    recordArtifact(args: {
+        scratchpadName: string;
+        slug: string;
+        kind: string;
+        uri: string;
+        turnId: string;
+    }): Promise<Drawer>;
+    private writeDrawer;
+}

package/packages/coworker-memory/dist/memory-recorder.js

@@ -0,0 +1,69 @@
+import { detectPaste } from './paste-detector.js';
+export class MemoryRecorder {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async recordTurn(args) {
+        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) {
+        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) {
+        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) {
+        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 },
+        });
+    }
+    async writeDrawer(input) {
+        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/dist/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/dist/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/dist/paste-detector.d.ts

@@ -0,0 +1,5 @@
+export interface PasteDetectorOptions {
+    lengthThreshold?: number;
+    newlineThreshold?: number;
+}
+export declare function detectPaste(text: string, opts?: PasteDetectorOptions): 'turn' | 'paste';

package/packages/coworker-memory/dist/paste-detector.js

@@ -0,0 +1,14 @@
+const DEFAULT_LENGTH = 500;
+const DEFAULT_NEWLINES = 10;
+export function detectPaste(text, opts = {}) {
+    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/dist/persona-seed.d.ts

@@ -0,0 +1,10 @@
+import type { LayerAStore } from './layer-a-store.js';
+export interface SeedResult {
+    copied: string[];
+    blocked: string[];
+}
+export declare function applyPersonaSeed(args: {
+    personaId: string;
+    personaDir: string;
+    store: LayerAStore;
+}): Promise<SeedResult>;

package/packages/coworker-memory/dist/persona-seed.js

@@ -0,0 +1,38 @@
+// packages/coworker-memory/src/persona-seed.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { LayerAWriteBlocked } from './errors.js';
+const FILE_MAP = [
+    { name: 'profile.md', kind: 'profile' },
+    { name: 'rules.md', kind: 'rule' },
+    { name: 'lessons.md', kind: 'lesson' },
+];
+export async function applyPersonaSeed(args) {
+    const seedDir = join(args.personaDir, 'memory-seed');
+    if (!existsSync(seedDir))
+        return { copied: [], blocked: [] };
+    const ts = new Date().toISOString();
+    const copied = [];
+    const blocked = [];
+    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/dist/recall-formatter.d.ts

@@ -0,0 +1,2 @@
+import type { RecallResult } from './types.js';
+export declare function formatRecall(results: RecallResult[]): string;

package/packages/coworker-memory/dist/recall-formatter.js

@@ -0,0 +1,14 @@
+export function formatRecall(results) {
+    const header = `### Memory recall (${results.length} matches)\n`;
+    if (results.length === 0)
+        return header;
+    const lines = [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/dist/scope-resolver.d.ts

@@ -0,0 +1,9 @@
+import type { ScopeMode, Wing } from './types.js';
+export interface ResolvedScope {
+    writeWing: Wing;
+    readWings: Wing[];
+}
+export declare function resolveScope(args: {
+    mode: ScopeMode;
+    workspaceId: Wing;
+}): ResolvedScope;

package/packages/coworker-memory/dist/scope-resolver.js

@@ -0,0 +1,10 @@
+export function resolveScope(args) {
+    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'] };
+    }
+}

package/packages/coworker-memory/dist/types.d.ts

@@ -0,0 +1,51 @@
+export type Wing = string;
+export type Room = string;
+export declare const DRAWER_KINDS: readonly ["turn", "paste", "file_load", "ticket", "email", "rca", "note", "artifact"];
+export type DrawerKind = typeof DRAWER_KINDS[number];
+export declare const LAYER_A_KINDS: readonly ["profile", "rule", "lesson"];
+export type LayerAKind = typeof LAYER_A_KINDS[number];
+export type ScopeMode = 'global' | 'per-project' | 'per-project-tagged';
+export interface Drawer {
+    id: string;
+    wing: Wing;
+    room: Room;
+    kind: DrawerKind;
+    content: string;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    parent_id?: string;
+    redacted: boolean;
+}
+export interface RecallQuery {
+    query: string;
+    wing?: Wing | Wing[];
+    room?: Room;
+    kind?: DrawerKind | DrawerKind[];
+    days_back?: number;
+    max_results?: number;
+}
+export interface RecallResult {
+    drawer: Drawer;
+    score: number;
+    snippet: string;
+}
+export interface BackendStatus {
+    ready: boolean;
+    workspace_wing: Wing;
+    drawer_count: number;
+    layer_b_db_path: string;
+    schema_version: number;
+}
+export interface LayerAEntry {
+    kind: LayerAKind;
+    text: string;
+    source: 'user' | 'persona-seed';
+    ts: string;
+}
+export interface WorkspaceIdRecord {
+    _schema: 1;
+    id: string;
+    created_at: string;
+    memory_seed_applied: boolean;
+    memory_seed_persona: string | null;
+}

package/packages/coworker-memory/dist/types.js

@@ -0,0 +1,2 @@
+export const DRAWER_KINDS = ['turn', 'paste', 'file_load', 'ticket', 'email', 'rca', 'note', 'artifact'];
+export const LAYER_A_KINDS = ['profile', 'rule', 'lesson'];