@cmetech/otto 1.1.1 → 1.2.5

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

@@ -0,0 +1,28 @@
+// packages/coworker-artifacts/src/errors.ts
+export class ArtifactNotFound extends Error {
+  constructor(public readonly slug: string) {
+    super(`Artifact not found: ${slug}. /artifacts list to see available.`);
+    this.name = 'ArtifactNotFound';
+  }
+}
+
+export class ArtifactKindRejected extends Error {
+  constructor(public readonly kind: string) {
+    super(`Artifact kind '${kind}' is not supported. v1 ships only 'report'.`);
+    this.name = 'ArtifactKindRejected';
+  }
+}
+
+export class ArtifactUriMalformed extends Error {
+  constructor(public readonly uri: string, public readonly reason: string) {
+    super(`Bad artifact URI ${uri}: ${reason}.`);
+    this.name = 'ArtifactUriMalformed';
+  }
+}
+
+export class ArtifactSlugCollision extends Error {
+  constructor(public readonly base: string, public readonly attempts: number) {
+    super(`Slug collision: '${base}' has ${attempts} colliding suffixes (-2…-${attempts + 1}). Pick a different name.`);
+    this.name = 'ArtifactSlugCollision';
+  }
+}

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

@@ -0,0 +1,22 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import * as artifacts from './index.js';
+
+describe('@otto/coworker-artifacts barrel', () => {
+  it('exports key surface', () => {
+    assert.equal(typeof artifacts.ArtifactStore, 'function');
+    assert.equal(typeof artifacts.deriveSlug, 'function');
+    assert.equal(typeof artifacts.nextCollisionSlug, 'function');
+    assert.equal(typeof artifacts.takeSnapshot, 'function');
+    assert.equal(typeof artifacts.diffSnapshots, 'function');
+    assert.equal(typeof artifacts.resolveArtifactUri, 'function');
+    assert.equal(typeof artifacts.renderReadme, 'function');
+    assert.equal(artifacts.ARTIFACT_URI_SCHEME, 'artifact://');
+  });
+  it('exports error classes', () => {
+    assert.equal(typeof artifacts.ArtifactNotFound, 'function');
+    assert.equal(typeof artifacts.ArtifactKindRejected, 'function');
+    assert.equal(typeof artifacts.ArtifactUriMalformed, 'function');
+    assert.equal(typeof artifacts.ArtifactSlugCollision, 'function');
+  });
+});

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

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './errors.js';
+export * from './slug.js';
+export * from './dir-snapshot.js';
+export * from './resolve-uri.js';
+export * from './readme-renderer.js';
+export * from './artifact-store.js';

package/packages/coworker-artifacts/src/readme-renderer.test.ts

@@ -0,0 +1,72 @@
+// packages/coworker-artifacts/src/readme-renderer.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { renderReadme } from './readme-renderer.js';
+import type { ArtifactMetadata, Provenance } from './types.js';
+
+const META: ArtifactMetadata = {
+  _schema: 1,
+  slug: 'rca-1',
+  kind: 'report',
+  name: 'RCA: load balancer 503',
+  created_at: '2026-06-02T14:32:00Z',
+  last_updated_at: '2026-06-02T15:18:00Z',
+  turn_count: 2,
+  primary_file: 'report.md',
+  uri: 'artifact://rca-1',
+};
+
+const PROV: Provenance = [
+  {
+    _schema: 1, ts: '2026-06-02T14:32:00Z', action: 'create',
+    turn_id: 'turn-abc', agent_turn_id: 'agent-xyz',
+    user_prompt: 'draft the RCA', scratchpad_name: 'p1',
+    files_touched: ['report.md'],
+  },
+  {
+    _schema: 1, ts: '2026-06-02T15:18:00Z', action: 'update',
+    turn_id: 'turn-def', user_prompt: 'add timeline',
+    scratchpad_name: 'p1', files_touched: ['report.md'],
+  },
+];
+
+describe('renderReadme', () => {
+  it('renders header with name + uri + dates + turn count', () => {
+    const md = renderReadme(META, PROV, [{ path: 'report.md', sizeBytes: 4200 }]);
+    assert.match(md, /^# RCA: load balancer 503/m);
+    assert.match(md, /\*\*Kind:\*\* report/);
+    assert.match(md, /\*\*URI:\*\* `artifact:\/\/rca-1`/);
+    assert.match(md, /\*\*Created:\*\* 2026-06-02T14:32:00Z/);
+    assert.match(md, /\*\*Last updated:\*\* 2026-06-02T15:18:00Z/);
+    assert.match(md, /\*\*Turns:\*\* 2/);
+  });
+  it('renders files section with human-readable sizes', () => {
+    const md = renderReadme(META, PROV, [{ path: 'report.md', sizeBytes: 4200 }]);
+    assert.match(md, /## Files/);
+    assert.match(md, /`report.md` — 4\.1 KB/);
+  });
+  it('renders provenance table', () => {
+    const md = renderReadme(META, PROV, [{ path: 'report.md', sizeBytes: 4200 }]);
+    assert.match(md, /## Provenance/);
+    assert.match(md, /\| # \| ts \| action \| turn \| prompt \|/);
+    assert.match(md, /\| 1 \| 2026-06-02T14:32:00Z \| create \| turn-abc \| draft the RCA \|/);
+    assert.match(md, /\| 2 \| 2026-06-02T15:18:00Z \| update \| turn-def \| add timeline \|/);
+  });
+  it('is deterministic — same inputs produce byte-identical output', () => {
+    const a = renderReadme(META, PROV, [{ path: 'report.md', sizeBytes: 4200 }]);
+    const b = renderReadme(META, PROV, [{ path: 'report.md', sizeBytes: 4200 }]);
+    assert.equal(a, b);
+  });
+  it('handles empty provenance', () => {
+    const md = renderReadme(META, [], [{ path: 'report.md', sizeBytes: 0 }]);
+    assert.match(md, /## Provenance/);
+    // No table rows beyond header
+    const tableRows = (md.match(/^\| \d+ \|/gm) ?? []).length;
+    assert.equal(tableRows, 0);
+  });
+  it('handles empty file stats', () => {
+    const md = renderReadme(META, PROV, []);
+    assert.match(md, /## Files/);
+    assert.match(md, /\(none\)/);
+  });
+});

package/packages/coworker-artifacts/src/readme-renderer.ts

@@ -0,0 +1,56 @@
+// packages/coworker-artifacts/src/readme-renderer.ts
+import type { ArtifactMetadata, Provenance } from './types.js';
+
+const UNITS = ['B', 'KB', 'MB', 'GB'] as const;
+
+function humanSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < UNITS.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value.toFixed(1)} ${UNITS[unit]}`;
+}
+
+function escapeMarkdownPipe(s: string): string {
+  return s.replace(/\|/g, '\\|').replace(/\n/g, ' ');
+}
+
+export function renderReadme(
+  metadata: ArtifactMetadata,
+  provenance: Provenance,
+  fileStats: Array<{ path: string; sizeBytes: number }>,
+): string {
+  const firstTurn = provenance[0]?.turn_id ?? '';
+  const lastTurn = provenance.length > 0 ? provenance[provenance.length - 1]!.turn_id : '';
+
+  const lines: string[] = [];
+  lines.push(`# ${metadata.name}`);
+  lines.push('');
+  lines.push(`**Kind:** ${metadata.kind}`);
+  lines.push(`**URI:** \`${metadata.uri}\``);
+  lines.push(`**Created:** ${metadata.created_at}${firstTurn ? ` (turn \`${firstTurn}\`)` : ''}`);
+  lines.push(`**Last updated:** ${metadata.last_updated_at}${lastTurn ? ` (turn \`${lastTurn}\`)` : ''}`);
+  lines.push(`**Turns:** ${metadata.turn_count}`);
+  lines.push('');
+  lines.push('## Files');
+  lines.push('');
+  if (fileStats.length === 0) {
+    lines.push('(none)');
+  } else {
+    for (const f of fileStats) {
+      lines.push(`- \`${f.path}\` — ${humanSize(f.sizeBytes)}`);
+    }
+  }
+  lines.push('');
+  lines.push('## Provenance');
+  lines.push('');
+  lines.push('| # | ts | action | turn | prompt |');
+  lines.push('|---|---|---|---|---|');
+  provenance.forEach((e, i) => {
+    lines.push(`| ${i + 1} | ${e.ts} | ${e.action} | ${e.turn_id} | ${escapeMarkdownPipe(e.user_prompt)} |`);
+  });
+  return lines.join('\n') + '\n';
+}

package/packages/coworker-artifacts/src/resolve-uri.test.ts

@@ -0,0 +1,46 @@
+// packages/coworker-artifacts/src/resolve-uri.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveArtifactUri, ARTIFACT_URI_SCHEME } from './resolve-uri.js';
+import { ArtifactUriMalformed } from './errors.js';
+
+describe('resolveArtifactUri', () => {
+  const ws = '/tmp/workspace';
+  it('parses simple slug', () => {
+    const r = resolveArtifactUri('artifact://rca-1', ws);
+    assert.equal(r.slug, 'rca-1');
+    assert.equal(r.dir, '/tmp/workspace/.otto/artifacts/rca-1');
+    assert.equal(r.primaryPath, '/tmp/workspace/.otto/artifacts/rca-1/report.md');
+    assert.equal(r.metadataPath, '/tmp/workspace/.otto/artifacts/rca-1/metadata.json');
+    assert.equal(r.provenancePath, '/tmp/workspace/.otto/artifacts/rca-1/provenance.json');
+    assert.equal(r.readmePath, '/tmp/workspace/.otto/artifacts/rca-1/README.md');
+  });
+  it('accepts single-char slug', () => {
+    const r = resolveArtifactUri('artifact://x', ws);
+    assert.equal(r.slug, 'x');
+  });
+  it('rejects bad scheme', () => {
+    assert.throws(() => resolveArtifactUri('memory://x', ws), ArtifactUriMalformed);
+  });
+  it('rejects uppercase slug', () => {
+    assert.throws(() => resolveArtifactUri('artifact://RCA', ws), ArtifactUriMalformed);
+  });
+  it('rejects path traversal', () => {
+    assert.throws(() => resolveArtifactUri('artifact://../escape', ws), ArtifactUriMalformed);
+  });
+  it('rejects leading dash', () => {
+    assert.throws(() => resolveArtifactUri('artifact://-foo', ws), ArtifactUriMalformed);
+  });
+  it('rejects trailing dash', () => {
+    assert.throws(() => resolveArtifactUri('artifact://foo-', ws), ArtifactUriMalformed);
+  });
+  it('rejects > 64 chars', () => {
+    assert.throws(() => resolveArtifactUri(`artifact://${'a'.repeat(65)}`, ws), ArtifactUriMalformed);
+  });
+  it('rejects empty slug', () => {
+    assert.throws(() => resolveArtifactUri('artifact://', ws), ArtifactUriMalformed);
+  });
+  it('exports scheme constant', () => {
+    assert.equal(ARTIFACT_URI_SCHEME, 'artifact://');
+  });
+});

package/packages/coworker-artifacts/src/resolve-uri.ts

@@ -0,0 +1,29 @@
+// packages/coworker-artifacts/src/resolve-uri.ts
+import { join } from 'node:path';
+import { ArtifactUriMalformed } from './errors.js';
+import type { ResolvedArtifactUri } from './types.js';
+
+export const ARTIFACT_URI_SCHEME = 'artifact://';
+const SLUG_REGEX = /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/;
+
+export function resolveArtifactUri(uri: string, workspaceDir: string): ResolvedArtifactUri {
+  if (!uri.startsWith(ARTIFACT_URI_SCHEME)) {
+    throw new ArtifactUriMalformed(uri, `must start with ${ARTIFACT_URI_SCHEME}`);
+  }
+  const slug = uri.slice(ARTIFACT_URI_SCHEME.length);
+  if (!slug) throw new ArtifactUriMalformed(uri, 'empty slug');
+  if (slug.includes('..')) throw new ArtifactUriMalformed(uri, 'path traversal');
+  if (slug.length > 64) throw new ArtifactUriMalformed(uri, 'slug exceeds 64 chars');
+  if (!SLUG_REGEX.test(slug)) {
+    throw new ArtifactUriMalformed(uri, 'slug must match ^[a-z0-9][a-z0-9-]*[a-z0-9]$');
+  }
+  const dir = join(workspaceDir, '.otto', 'artifacts', slug);
+  return {
+    slug,
+    dir,
+    primaryPath: join(dir, 'report.md'),
+    metadataPath: join(dir, 'metadata.json'),
+    provenancePath: join(dir, 'provenance.json'),
+    readmePath: join(dir, 'README.md'),
+  };
+}

package/packages/coworker-artifacts/src/slug.test.ts

@@ -0,0 +1,47 @@
+// packages/coworker-artifacts/src/slug.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { deriveSlug, nextCollisionSlug, MAX_COLLISION_ATTEMPTS } from './slug.js';
+import { ArtifactSlugCollision } from './errors.js';
+
+describe('deriveSlug', () => {
+  it('lowercases and kebab-cases simple input', () => {
+    assert.equal(deriveSlug('RCA: Load Balancer 503'), 'rca-load-balancer-503');
+  });
+  it('strips non-ASCII and punctuation', () => {
+    assert.equal(deriveSlug('résumé — final draft!'), 'resume-final-draft');
+  });
+  it('collapses runs of dashes', () => {
+    assert.equal(deriveSlug('foo --- bar'), 'foo-bar');
+  });
+  it('trims leading + trailing dashes', () => {
+    assert.equal(deriveSlug('---hello---'), 'hello');
+  });
+  it('truncates to 64 chars', () => {
+    const long = 'a'.repeat(100);
+    assert.equal(deriveSlug(long).length, 64);
+  });
+  it('produces fallback for fully-stripped input', () => {
+    assert.match(deriveSlug('!!!'), /^artifact-/);
+  });
+  it('single-char input is preserved', () => {
+    assert.equal(deriveSlug('x'), 'x');
+  });
+});
+
+describe('nextCollisionSlug', () => {
+  it('returns -2 on first collision', () => {
+    assert.equal(nextCollisionSlug('rca', new Set(['rca'])), 'rca-2');
+  });
+  it('skips already-taken numeric suffixes', () => {
+    assert.equal(nextCollisionSlug('rca', new Set(['rca', 'rca-2', 'rca-3'])), 'rca-4');
+  });
+  it('throws ArtifactSlugCollision after MAX_COLLISION_ATTEMPTS', () => {
+    const taken = new Set<string>(['rca']);
+    for (let i = 2; i <= MAX_COLLISION_ATTEMPTS + 1; i++) taken.add(`rca-${i}`);
+    assert.throws(() => nextCollisionSlug('rca', taken), ArtifactSlugCollision);
+  });
+  it('returns base if base not taken', () => {
+    assert.equal(nextCollisionSlug('rca', new Set()), 'rca');
+  });
+});

package/packages/coworker-artifacts/src/slug.ts

@@ -0,0 +1,31 @@
+// packages/coworker-artifacts/src/slug.ts
+import { ArtifactSlugCollision } from './errors.js';
+
+export const MAX_SLUG_LENGTH = 64;
+export const MAX_COLLISION_ATTEMPTS = 100;
+
+export function deriveSlug(name: string): string {
+  let s = name.toLowerCase();
+  // Strip diacritics (NFKD + remove combining marks U+0300–U+036F)
+  s = s.normalize('NFKD').replace(/[̀-ͯ]/g, '');
+  // Replace non a-z 0-9 with dash
+  s = s.replace(/[^a-z0-9]+/g, '-');
+  // Collapse runs of dashes
+  s = s.replace(/-+/g, '-');
+  // Trim leading/trailing dashes
+  s = s.replace(/^-+|-+$/g, '');
+  // Truncate
+  if (s.length > MAX_SLUG_LENGTH) s = s.slice(0, MAX_SLUG_LENGTH).replace(/-+$/, '');
+  // Fallback if empty
+  if (!s) s = `artifact-${Date.now().toString(36)}`;
+  return s;
+}
+
+export function nextCollisionSlug(base: string, taken: Set<string>): string {
+  if (!taken.has(base)) return base;
+  for (let n = 2; n <= MAX_COLLISION_ATTEMPTS + 1; n++) {
+    const candidate = `${base}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  throw new ArtifactSlugCollision(base, MAX_COLLISION_ATTEMPTS);
+}

package/packages/coworker-artifacts/src/types.ts

@@ -0,0 +1,61 @@
+// packages/coworker-artifacts/src/types.ts
+export type ArtifactKind = 'report';
+export const ARTIFACT_KINDS = ['report'] as const;
+
+export interface ArtifactHandle {
+  slug: string;
+  kind: ArtifactKind;
+  name: string;
+  dir: string;
+  uri: string;
+  primaryPath: string;
+  metadataPath: string;
+  provenancePath: string;
+  readmePath: string;
+}
+
+export interface ArtifactMetadata {
+  _schema: 1;
+  slug: string;
+  kind: ArtifactKind;
+  name: string;
+  created_at: string;
+  last_updated_at: string;
+  turn_count: number;
+  primary_file: string;
+  uri: string;
+}
+
+export interface TurnEntry {
+  _schema: 1;
+  ts: string;
+  action: 'create' | 'update';
+  turn_id: string;
+  agent_turn_id?: string;
+  user_prompt: string;
+  scratchpad_name?: string;
+  files_touched: string[];
+}
+
+export type Provenance = TurnEntry[];
+
+export interface DirSnapshotEntry {
+  mtimeNs: bigint;
+  sizeBytes: number;
+}
+
+export type DirSnapshot = Map<string, DirSnapshotEntry>;
+
+export interface FileWrite {
+  path: string;
+  content: string;
+}
+
+export interface ResolvedArtifactUri {
+  slug: string;
+  dir: string;
+  primaryPath: string;
+  metadataPath: string;
+  provenancePath: string;
+  readmePath: string;
+}

package/packages/coworker-artifacts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2022",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/packages/coworker-artifacts/tsconfig.publish.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": { "incremental": false }
+}

package/packages/coworker-memory/dist/context-injection.d.ts

@@ -0,0 +1,9 @@
+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;
+}
+export declare function buildLayerAContext(args: ContextInjectionArgs): Promise<string>;

package/packages/coworker-memory/dist/context-injection.js

@@ -0,0 +1,41 @@
+const CHARS_PER_TOKEN = 4;
+export async function buildLayerAContext(args) {
+    const charLimit = args.tokenLimit * CHARS_PER_TOKEN;
+    const readScopes = args.mode === 'global'
+        ? ['global']
+        : args.mode === 'per-project'
+            ? ['workspace']
+            : ['workspace', 'global'];
+    const sections = [];
+    const PRIORITIES = { 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 = [];
+    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/dist/errors.d.ts

@@ -0,0 +1,25 @@
+export declare class MemoryNotInitialized extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare class BackendUnavailable extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare class DrawerKindRejected extends Error {
+    readonly kind: string;
+    constructor(kind: string);
+}
+export declare class LayerAWriteBlocked extends Error {
+    readonly secretKind: string;
+    constructor(secretKind: string);
+}
+export declare class RecallQueryMalformed extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare class MemoryEntryMalformed extends Error {
+    readonly path: string;
+    readonly reason: string;
+    constructor(path: string, reason: string);
+}

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

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

package/packages/coworker-memory/dist/index.d.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/dist/index.js

@@ -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/dist/layer-a-store.d.ts

@@ -0,0 +1,16 @@
+import { AuditLog, SecretScanner } from '@otto/coworker-utils';
+import type { LayerAEntry, LayerAKind } from './types.js';
+export interface LayerAStoreOptions {
+    scopeDir: string;
+    scope: 'global' | 'workspace';
+    audit: AuditLog;
+    scanner: SecretScanner;
+}
+export declare class LayerAStore {
+    private readonly opts;
+    constructor(opts: LayerAStoreOptions);
+    append(entry: LayerAEntry): Promise<void>;
+    read(kind: LayerAKind): Promise<string>;
+    private split;
+    private composeFile;
+}