@cmetech/otto 1.1.1 → 1.2.5

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');
+}

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

@@ -0,0 +1,45 @@
+// packages/coworker-memory/src/errors.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  MemoryNotInitialized, BackendUnavailable, DrawerKindRejected,
+  LayerAWriteBlocked, RecallQueryMalformed, MemoryEntryMalformed,
+} from './errors.js';
+
+describe('memory errors', () => {
+  it('MemoryNotInitialized carries reason', () => {
+    const e = new MemoryNotInitialized('workspace.json corrupted');
+    assert.equal(e.name, 'MemoryNotInitialized');
+    assert.equal(e.reason, 'workspace.json corrupted');
+    assert.ok(e.message.includes('workspace.json corrupted'));
+  });
+  it('BackendUnavailable carries reason', () => {
+    const e = new BackendUnavailable('SQLITE_BUSY after retries');
+    assert.equal(e.name, 'BackendUnavailable');
+    assert.equal(e.reason, 'SQLITE_BUSY after retries');
+  });
+  it('DrawerKindRejected carries kind', () => {
+    const e = new DrawerKindRejected('mystery');
+    assert.equal(e.name, 'DrawerKindRejected');
+    assert.equal(e.kind, 'mystery');
+    assert.ok(e.message.includes('mystery'));
+  });
+  it('LayerAWriteBlocked carries secret_kind', () => {
+    const e = new LayerAWriteBlocked('anthropic_api_key');
+    assert.equal(e.name, 'LayerAWriteBlocked');
+    assert.equal(e.secretKind, 'anthropic_api_key');
+    assert.ok(e.message.includes('anthropic_api_key'));
+    assert.ok(e.message.includes('/connect'));
+  });
+  it('RecallQueryMalformed carries reason', () => {
+    const e = new RecallQueryMalformed('empty query');
+    assert.equal(e.name, 'RecallQueryMalformed');
+    assert.equal(e.reason, 'empty query');
+  });
+  it('MemoryEntryMalformed carries path', () => {
+    const e = new MemoryEntryMalformed('/tmp/profile.md', 'bad frontmatter');
+    assert.equal(e.name, 'MemoryEntryMalformed');
+    assert.equal(e.path, '/tmp/profile.md');
+    assert.equal(e.reason, 'bad frontmatter');
+  });
+});

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

@@ -0,0 +1,42 @@
+// packages/coworker-memory/src/errors.ts
+export class MemoryNotInitialized extends Error {
+  constructor(public readonly reason: string) {
+    super(`Memory not initialized: ${reason}. /memory status to inspect.`);
+    this.name = 'MemoryNotInitialized';
+  }
+}
+
+export class BackendUnavailable extends Error {
+  constructor(public readonly reason: string) {
+    super(`Memory backend unavailable: ${reason}.`);
+    this.name = 'BackendUnavailable';
+  }
+}
+
+export class DrawerKindRejected extends Error {
+  constructor(public readonly kind: string) {
+    super(`Drawer kind '${kind}' is not in v1 vocabulary. Allowed: turn, paste, file_load, ticket, email, rca, note.`);
+    this.name = 'DrawerKindRejected';
+  }
+}
+
+export class LayerAWriteBlocked extends Error {
+  constructor(public readonly secretKind: string) {
+    super(`Refused to store: contains secret-shaped value (kind: ${secretKind}). Remove the secret and retry. Vault entries should land in /connect, not memorize.`);
+    this.name = 'LayerAWriteBlocked';
+  }
+}
+
+export class RecallQueryMalformed extends Error {
+  constructor(public readonly reason: string) {
+    super(`Bad recall query: ${reason}.`);
+    this.name = 'RecallQueryMalformed';
+  }
+}
+
+export class MemoryEntryMalformed extends Error {
+  constructor(public readonly path: string, public readonly reason: string) {
+    super(`Layer A file ${path} is malformed: ${reason}. Move it aside and re-create.`);
+    this.name = 'MemoryEntryMalformed';
+  }
+}

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

@@ -0,0 +1,21 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import * as memory from './index.js';
+
+describe('@otto/coworker-memory barrel', () => {
+  it('exports the key surface', () => {
+    assert.equal(typeof memory.LocalSqliteBackend, 'function');
+    assert.equal(typeof memory.LayerAStore, 'function');
+    assert.equal(typeof memory.MemoryRecorder, 'function');
+    assert.equal(typeof memory.resolveWorkspaceId, 'function');
+    assert.equal(typeof memory.resolveScope, 'function');
+    assert.equal(typeof memory.detectPaste, 'function');
+    assert.equal(typeof memory.formatRecall, 'function');
+    assert.equal(typeof memory.buildLayerAContext, 'function');
+    assert.equal(typeof memory.applyPersonaSeed, 'function');
+  });
+  it('exports error classes', () => {
+    assert.equal(typeof memory.LayerAWriteBlocked, 'function');
+    assert.equal(typeof memory.RecallQueryMalformed, 'function');
+  });
+});

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

@@ -0,0 +1,12 @@
+export * from './types.js';
+export * from './errors.js';
+export * from './memory-backend.js';
+export * from './workspace-id.js';
+export * from './scope-resolver.js';
+export * from './paste-detector.js';
+export * from './layer-a-store.js';
+export * from './local-sqlite-backend.js';
+export * from './memory-recorder.js';
+export * from './recall-formatter.js';
+export * from './context-injection.js';
+export * from './persona-seed.js';

package/packages/coworker-memory/src/layer-a-store.test.ts

@@ -0,0 +1,85 @@
+// packages/coworker-memory/src/layer-a-store.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, existsSync, mkdirSync, writeFileSync } 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 { LayerAWriteBlocked, MemoryEntryMalformed } from './errors.js';
+
+function ctx() {
+  const root = mkdtempSync(join(tmpdir(), 'la-'));
+  return {
+    root,
+    audit: new AuditLog({ path: join(root, 'audit.jsonl') }),
+    scanner: new SecretScanner(),
+    dir: join(root, 'memory'),
+  };
+}
+
+describe('LayerAStore', () => {
+  it('append lesson creates lessons.md with frontmatter and bullet', async () => {
+    const c = ctx();
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    await store.append({ kind: 'lesson', text: 'MTTR target is 30 minutes for P1', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    const md = readFileSync(join(c.dir, 'lessons.md'), 'utf8');
+    assert.match(md, /^---\nschema_version: 1\n/);
+    assert.match(md, /- \(2026-06-02T10:00:00Z\) MTTR target is 30 minutes for P1/);
+  });
+  it('append profile uses timestamped section', async () => {
+    const c = ctx();
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    await store.append({ kind: 'profile', text: 'Prefers polars over pandas.', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    const md = readFileSync(join(c.dir, 'profile.md'), 'utf8');
+    assert.match(md, /## 2026-06-02T10:00:00Z\nPrefers polars over pandas\./);
+  });
+  it('throws LayerAWriteBlocked when text contains a secret pattern', async () => {
+    const c = ctx();
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    await assert.rejects(
+      () => store.append({ kind: 'rule', text: 'use AKIAABCDEFGHIJKLMNOP', source: 'user', ts: '2026-06-02T10:00:00Z' }),
+      LayerAWriteBlocked,
+    );
+    assert.equal(existsSync(join(c.dir, 'rules.md')), false);
+  });
+  it('read returns parsed content with frontmatter stripped', async () => {
+    const c = ctx();
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    await store.append({ kind: 'rule', text: 'Always include MTTR in RCA.', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    const body = await store.read('rule');
+    assert.match(body, /Always include MTTR in RCA\./);
+    assert.equal(body.startsWith('---'), false);
+  });
+  it('read returns empty string when file missing', async () => {
+    const c = ctx();
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    assert.equal(await store.read('lesson'), '');
+  });
+  it('emits write-layer-a audit on success', async () => {
+    const c = ctx();
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    await store.append({ kind: 'lesson', text: 'short lesson', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    const rows: { action: string }[] = [];
+    for await (const r of c.audit.read({ producer: 'memory', action: 'write-layer-a' })) rows.push(r as never);
+    assert.equal(rows.length, 1);
+  });
+  it('re-appending to the same kind does not duplicate the title heading', async () => {
+    const c = ctx();
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    await store.append({ kind: 'lesson', text: 'first lesson', source: 'user', ts: '2026-06-02T10:00:00Z' });
+    await store.append({ kind: 'lesson', text: 'second lesson', source: 'user', ts: '2026-06-02T10:05:00Z' });
+    const raw = readFileSync(join(c.dir, 'lessons.md'), 'utf8');
+    const titleCount = (raw.match(/^# Lessons$/gm) ?? []).length;
+    assert.equal(titleCount, 1, 'duplicate title heading after re-append');
+    assert.match(raw, /first lesson/);
+    assert.match(raw, /second lesson/);
+  });
+  it('read throws MemoryEntryMalformed on unterminated frontmatter', async () => {
+    const c = ctx();
+    mkdirSync(c.dir, { recursive: true, mode: 0o700 });
+    writeFileSync(join(c.dir, 'rules.md'), '---\nbroken-yaml: [\n', { mode: 0o600 });
+    const store = new LayerAStore({ scopeDir: c.dir, scope: 'workspace', audit: c.audit, scanner: c.scanner });
+    await assert.rejects(() => store.read('rule'), MemoryEntryMalformed);
+  });
+});

package/packages/coworker-memory/src/layer-a-store.ts

@@ -0,0 +1,88 @@
+// 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 { AuditLog, SecretScanner } from '@otto/coworker-utils';
+import type { LayerAEntry, LayerAKind } from './types.js';
+import { LayerAWriteBlocked, MemoryEntryMalformed } from './errors.js';
+
+const FILE_FOR: Record<LayerAKind, string> = {
+  profile: 'profile.md',
+  rule: 'rules.md',
+  lesson: 'lessons.md',
+};
+
+const TITLE_FOR: Record<LayerAKind, string> = {
+  profile: 'Profile',
+  rule: 'Rules',
+  lesson: 'Lessons',
+};
+
+export interface LayerAStoreOptions {
+  scopeDir: string;             // absolute path to scope's memory dir
+  scope: 'global' | 'workspace';
+  audit: AuditLog;
+  scanner: SecretScanner;
+}
+
+export class LayerAStore {
+  constructor(private readonly opts: LayerAStoreOptions) {}
+
+  async append(entry: LayerAEntry): Promise<void> {
+    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: LayerAKind): Promise<string> {
+    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();
+  }
+
+  private split(raw: string, path: string): { frontmatter: Record<string, unknown>; body: string } {
+    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)) as Record<string, unknown>;
+      const body = raw.slice(end + 5);
+      return { frontmatter: fm ?? {}, body };
+    } catch (err) {
+      throw new MemoryEntryMalformed(path, `frontmatter parse: ${(err as Error).message}`);
+    }
+  }
+
+  private composeFile(kind: LayerAKind, body: string, ts: string, source: LayerAEntry['source']): string {
+    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?`), '');
+  }
+}