@cmetech/otto 1.1.1 → 1.2.4

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'];

package/packages/coworker-memory/dist/workspace-id.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceIdRecord } from './types.js';
+export declare function resolveWorkspaceId(workspaceDir: string): Promise<WorkspaceIdRecord>;
+export declare function writeWorkspaceId(workspaceDir: string, rec: WorkspaceIdRecord): Promise<void>;

package/packages/coworker-memory/dist/workspace-id.js

@@ -0,0 +1,54 @@
+// packages/coworker-memory/src/workspace-id.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, chmodSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { createHash } from 'node:crypto';
+function pathHash6(absolutePath) {
+    return createHash('sha256').update(absolutePath).digest('hex').slice(0, 6);
+}
+function deriveSlug(workspaceDir) {
+    let base = basename(workspaceDir).replace(/[^a-z0-9-]/gi, '-').replace(/^-+|-+$/g, '').toLowerCase();
+    if (!base)
+        base = 'workspace';
+    return `${base}-${pathHash6(workspaceDir)}`;
+}
+export async function resolveWorkspaceId(workspaceDir) {
+    const memDir = join(workspaceDir, '.otto', 'memory');
+    const path = join(memDir, 'workspace.json');
+    mkdirSync(memDir, { recursive: true, mode: 0o700 });
+    if (existsSync(path)) {
+        try {
+            const data = JSON.parse(readFileSync(path, 'utf8'));
+            if (data && data._schema === 1 && typeof data.id === 'string' && data.id.length > 0) {
+                return data;
+            }
+        }
+        catch { /* fall through to recreate */ }
+        // Move broken aside.
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        try {
+            renameSync(path, `${path}.broken-${stamp}`);
+        }
+        catch { /* best effort */ }
+    }
+    const fresh = {
+        _schema: 1,
+        id: deriveSlug(workspaceDir),
+        created_at: new Date().toISOString(),
+        memory_seed_applied: false,
+        memory_seed_persona: null,
+    };
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(fresh, null, 2), { mode: 0o600 });
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, path);
+    return fresh;
+}
+export async function writeWorkspaceId(workspaceDir, rec) {
+    const memDir = join(workspaceDir, '.otto', 'memory');
+    mkdirSync(memDir, { recursive: true, mode: 0o700 });
+    const path = join(memDir, 'workspace.json');
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(rec, null, 2), { mode: 0o600 });
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, path);
+}

package/packages/coworker-memory/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@otto/coworker-memory",
+  "version": "0.0.1",
+  "description": "Otto co-worker package: coworker-memory",
+  "type": "module",
+  "otto": {
+    "linkable": true,
+    "scope": "@otto",
+    "name": "coworker-memory"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@otto/coworker-utils": "*",
+    "better-sqlite3": "^11.7.0",
+    "uuid": "^11.0.0",
+    "yaml": "^2.8.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"const fs=require('fs');const path=require('path');const src='src/migrations';const dst='dist/migrations';fs.mkdirSync(dst,{recursive:true});for(const f of fs.readdirSync(src))if(f.endsWith('.sql'))fs.copyFileSync(path.join(src,f),path.join(dst,f));\"",
+    "build:publish": "tsc -p tsconfig.publish.json && node -e \"const fs=require('fs');const path=require('path');const src='src/migrations';const dst='dist/migrations';fs.mkdirSync(dst,{recursive:true});for(const f of fs.readdirSync(src))if(f.endsWith('.sql'))fs.copyFileSync(path.join(src,f),path.join(dst,f));\""
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13"
+  }
+}

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

@@ -0,0 +1,141 @@
+// packages/coworker-memory/src/activator-integration.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 type { DataLoadDrawer } from '@otto/coworker-scratchpad';
+
+import coworkerVaultExtension from '../../../src/resources/extensions/coworker-vault/index.js';
+import coworkerMemoryExtension, {
+  getMemoryRecorder, createMemoryBundle,
+} from '../../../src/resources/extensions/coworker-memory/index.js';
+import coworkerScratchpadExtension from '../../../src/resources/extensions/coworker-scratchpad/index.js';
+import {
+  makeFakeApi, fireSessionStart, fireSessionShutdown,
+  fireBeforeAgentStart, fireAgentStart,
+} from '../../../src/resources/extensions/coworker-vault/test-helpers.js';
+
+describe('Phase 3.1 — cross-extension activator integration', () => {
+  it('vault + memory + scratchpad activate, recordTurn fires, recall returns drawer', async () => {
+    const global = mkdtempSync(join(tmpdir(), 'p31-g-'));
+    const ws = mkdtempSync(join(tmpdir(), 'p31-w-'));
+    const sp = mkdtempSync(join(tmpdir(), 'p31-sp-'));
+    mkdirSync(ws, { recursive: true });
+    process.env.OTTO_COWORKER_GLOBAL_DIR = global;
+    process.env.OTTO_SCRATCHPAD_ROOT = sp;
+    try {
+      // Each ext gets its own fake API in this integration shape — they don't
+      // need to share an API instance; what they share is filesystem state.
+      const vaultApi = makeFakeApi();
+      const memApi = makeFakeApi();
+      const spApi = makeFakeApi();
+
+      coworkerVaultExtension(vaultApi.api);
+      coworkerMemoryExtension(memApi.api);
+      coworkerScratchpadExtension(spApi.api);
+
+      await fireSessionStart(vaultApi, { cwd: ws });
+      await fireSessionStart(memApi, { cwd: ws });
+      await fireSessionStart(spApi, { cwd: ws });
+
+      assert.equal(vaultApi.notifyCalls.find(c => /unavailable/.test(c.message)), undefined);
+      assert.equal(memApi.notifyCalls.find(c => /unavailable/.test(c.message)), undefined);
+      assert.equal(spApi.notifyCalls.find(c => /unavailable/.test(c.message)), undefined);
+
+      assert.ok(getMemoryRecorder(), 'memory recorder live after session_start');
+
+      // before_agent_start + agent_start round-trip
+      await fireBeforeAgentStart(memApi, 'load balancer started returning 503s', 'BASE');
+      await fireAgentStart(memApi, 'sess-1', 'turn-1');
+
+      // Verify the drawer landed via a fresh read.
+      const peek = await createMemoryBundle({
+        globalDir: global, workspaceDir: ws,
+        scopeMode: 'per-project-tagged', currentScratchpadName: () => null,
+      });
+      try {
+        const r = await peek.backend.recall({ query: 'load balancer' });
+        assert.equal(r.length, 1);
+        assert.equal(r[0]!.drawer.kind, 'turn');
+        assert.match(r[0]!.drawer.content, /load balancer started returning 503s/);
+      } finally { await peek.dispose(); }
+
+      await fireSessionShutdown(memApi);
+      await fireSessionShutdown(spApi);
+      await fireSessionShutdown(vaultApi);
+      assert.equal(getMemoryRecorder(), null, 'recorder cleared');
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+      delete process.env.OTTO_SCRATCHPAD_ROOT;
+    }
+  });
+
+  it('onDataLoad closure produces a file_load drawer when memory is live', async () => {
+    const global = mkdtempSync(join(tmpdir(), 'p31-fl-g-'));
+    const ws = mkdtempSync(join(tmpdir(), 'p31-fl-w-'));
+    const sp = mkdtempSync(join(tmpdir(), 'p31-fl-sp-'));
+    process.env.OTTO_COWORKER_GLOBAL_DIR = global;
+    process.env.OTTO_SCRATCHPAD_ROOT = sp;
+    try {
+      const memApi = makeFakeApi();
+      coworkerMemoryExtension(memApi.api);
+      await fireSessionStart(memApi, { cwd: ws });
+      const recorder = getMemoryRecorder()!;
+      assert.ok(recorder);
+
+      // Simulate the kernel emitting a data_load event by directly invoking
+      // recorder.recordFileLoad with the shape the closure would translate to.
+      // (Driving an actual kernel subprocess is overkill for this integration
+      // test; the closure logic is locked in Task 4's unit test.)
+      await recorder.recordFileLoad({
+        scratchpadName: 'p1', collector: 'file', uri: 'file:///x.csv',
+        bytes: 1024, rows_loaded: 50, turnId: '',
+      });
+
+      const peek = await createMemoryBundle({
+        globalDir: global, workspaceDir: ws,
+        scopeMode: 'per-project-tagged', currentScratchpadName: () => null,
+      });
+      try {
+        const r = await peek.backend.recall({ query: 'file', kind: 'file_load' });
+        assert.equal(r.length, 1);
+        const parsed = JSON.parse(r[0]!.drawer.content);
+        assert.equal(parsed.collector, 'file');
+        assert.equal(parsed.uri, 'file:///x.csv');
+        assert.equal(parsed.rows_loaded, 50);
+        assert.equal(r[0]!.drawer.room, 'p1');
+      } finally { await peek.dispose(); }
+
+      await fireSessionShutdown(memApi);
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+      delete process.env.OTTO_SCRATCHPAD_ROOT;
+    }
+  });
+
+  it('memory init failure does not break vault or scratchpad', async () => {
+    // Point only memory at a bad path; vault + scratchpad get good paths.
+    const goodGlobal = mkdtempSync(join(tmpdir(), 'p31-mix-'));
+    const ws = mkdtempSync(join(tmpdir(), 'p31-mix-ws-'));
+    const sp = mkdtempSync(join(tmpdir(), 'p31-mix-sp-'));
+    process.env.OTTO_COWORKER_GLOBAL_DIR = goodGlobal;
+    process.env.OTTO_SCRATCHPAD_ROOT = sp;
+    try {
+      const vaultApi = makeFakeApi();
+      const spApi = makeFakeApi();
+      coworkerVaultExtension(vaultApi.api);
+      coworkerScratchpadExtension(spApi.api);
+      await fireSessionStart(vaultApi, { cwd: ws });
+      await fireSessionStart(spApi, { cwd: ws });
+      assert.equal(vaultApi.notifyCalls.find(c => /unavailable/.test(c.message)), undefined);
+      assert.equal(spApi.notifyCalls.find(c => /unavailable/.test(c.message)), undefined);
+      // Memory's onDataLoad path returns null recorder → scratchpad swallows. No crash.
+      await fireSessionShutdown(spApi);
+      await fireSessionShutdown(vaultApi);
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+      delete process.env.OTTO_SCRATCHPAD_ROOT;
+    }
+  });
+});

package/packages/coworker-memory/src/context-injection.test.ts

@@ -0,0 +1,72 @@
+// packages/coworker-memory/src/context-injection.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 { LayerAStore } from './layer-a-store.js';
+import { buildLayerAContext } from './context-injection.js';
+
+async function makeStores() {
+  const root = mkdtempSync(join(tmpdir(), 'ci-'));
+  const audit = new AuditLog({ path: join(root, 'audit.jsonl') });
+  const scanner = new SecretScanner();
+  const globalStore = new LayerAStore({ scopeDir: join(root, 'g'), scope: 'global', audit, scanner });
+  const workspaceStore = new LayerAStore({ scopeDir: join(root, 'w'), scope: 'workspace', audit, scanner });
+  return { root, globalStore, workspaceStore };
+}
+
+describe('buildLayerAContext', () => {
+  it('returns empty when no Layer A files exist', async () => {
+    const { globalStore, workspaceStore } = await makeStores();
+    const md = await buildLayerAContext({
+      mode: 'per-project-tagged', globalStore, workspaceStore, tokenLimit: 3000,
+    });
+    assert.equal(md, '');
+  });
+  it('global mode reads global only', async () => {
+    const { globalStore, workspaceStore } = await makeStores();
+    await globalStore.append({ kind: 'profile', text: 'global profile', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    await workspaceStore.append({ kind: 'profile', text: 'workspace profile', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    const md = await buildLayerAContext({
+      mode: 'global', globalStore, workspaceStore, tokenLimit: 3000,
+    });
+    assert.match(md, /global profile/);
+    assert.equal(md.includes('workspace profile'), false);
+  });
+  it('per-project mode reads workspace only', async () => {
+    const { globalStore, workspaceStore } = await makeStores();
+    await globalStore.append({ kind: 'profile', text: 'global profile', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    await workspaceStore.append({ kind: 'profile', text: 'workspace profile', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    const md = await buildLayerAContext({
+      mode: 'per-project', globalStore, workspaceStore, tokenLimit: 3000,
+    });
+    assert.match(md, /workspace profile/);
+    assert.equal(md.includes('global profile'), false);
+  });
+  it('per-project-tagged includes both with workspace first', async () => {
+    const { globalStore, workspaceStore } = await makeStores();
+    await globalStore.append({ kind: 'rule', text: 'global rule', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    await workspaceStore.append({ kind: 'rule', text: 'workspace rule', source: 'user', ts: '2026-06-02T00:00:00Z' });
+    const md = await buildLayerAContext({
+      mode: 'per-project-tagged', globalStore, workspaceStore, tokenLimit: 3000,
+    });
+    const wsIdx = md.indexOf('workspace rule');
+    const gIdx = md.indexOf('global rule');
+    assert.ok(wsIdx > 0 && gIdx > 0);
+    assert.ok(wsIdx < gIdx, 'workspace should appear before global');
+  });
+  it('truncates lower-priority files when token limit exceeded', async () => {
+    const { globalStore, workspaceStore } = await makeStores();
+    await workspaceStore.append({ kind: 'profile', text: 'p'.repeat(1000), source: 'user', ts: '2026-06-02T00:00:00Z' });
+    await workspaceStore.append({ kind: 'rule',    text: 'r'.repeat(1000), source: 'user', ts: '2026-06-02T00:00:00Z' });
+    await workspaceStore.append({ kind: 'lesson',  text: 'l'.repeat(1000), source: 'user', ts: '2026-06-02T00:00:00Z' });
+    const md = await buildLayerAContext({
+      mode: 'per-project', globalStore, workspaceStore, tokenLimit: 300, // ~1200 chars
+    });
+    assert.ok(md.includes('p'.repeat(50)));
+    // lessons should be dropped because lowest priority
+    assert.equal(md.includes('l'.repeat(900)), false);
+  });
+});

package/packages/coworker-memory/src/context-injection.ts

@@ -0,0 +1,57 @@
+// packages/coworker-memory/src/context-injection.ts
+import type { ScopeMode } from './types.js';
+import type { LayerAStore } from './layer-a-store.js';
+
+export interface ContextInjectionArgs {
+  mode: ScopeMode;
+  globalStore: LayerAStore;
+  workspaceStore: LayerAStore;
+  tokenLimit: number;     // approx 4 chars per token
+}
+
+const CHARS_PER_TOKEN = 4;
+
+export async function buildLayerAContext(args: ContextInjectionArgs): Promise<string> {
+  const charLimit = args.tokenLimit * CHARS_PER_TOKEN;
+
+  const readScopes: Array<'workspace' | 'global'> = args.mode === 'global'
+    ? ['global']
+    : args.mode === 'per-project'
+      ? ['workspace']
+      : ['workspace', 'global'];
+
+  type Section = { title: string; body: string; priority: number };
+  const sections: Section[] = [];
+
+  const PRIORITIES: Record<string, number> = { profile: 0, rules: 1, lessons: 2 };
+
+  for (const scope of readScopes) {
+    const store = scope === 'global' ? args.globalStore : args.workspaceStore;
+    const profile = await store.read('profile');
+    const rules = await store.read('rule');
+    const lessons = await store.read('lesson');
+    if (profile) sections.push({ title: `Profile (${scope})`, body: profile, priority: PRIORITIES.profile! });
+    if (rules) sections.push({ title: `Rules (${scope})`, body: rules, priority: PRIORITIES.rules! });
+    if (lessons) sections.push({ title: `Recent lessons (${scope})`, body: lessons, priority: PRIORITIES.lessons! });
+  }
+
+  if (sections.length === 0) return '';
+
+  // workspace comes first because we iterated readScopes in that order; stable sort by priority.
+  sections.sort((a, b) => a.priority - b.priority);
+
+  let total = 0;
+  const include: Section[] = [];
+  for (const s of sections) {
+    const cost = s.title.length + s.body.length + 10;
+    if (total + cost > charLimit && include.length > 0) break;
+    include.push(s);
+    total += cost;
+  }
+
+  const lines = ['## Memory (Layer A)\n'];
+  for (const s of include) {
+    lines.push(`### ${s.title}\n${s.body}\n`);
+  }
+  return lines.join('\n');
+}