@cmetech/otto 1.1.0 → 1.2.4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,61 @@
+// packages/coworker-memory/src/types.ts
+export type Wing = string;
+export type Room = string;
+
+export const DRAWER_KINDS = ['turn', 'paste', 'file_load', 'ticket', 'email', 'rca', 'note', 'artifact'] as const;
+export type DrawerKind = typeof DRAWER_KINDS[number];
+
+export const LAYER_A_KINDS = ['profile', 'rule', 'lesson'] as const;
+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/src/workspace-id.test.ts

@@ -0,0 +1,48 @@
+// packages/coworker-memory/src/workspace-id.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveWorkspaceId } from './workspace-id.js';
+
+function tmp(): string { return mkdtempSync(join(tmpdir(), 'wsid-')); }
+
+describe('resolveWorkspaceId', () => {
+  it('creates workspace.json on first call with basename + 6-hex slug', async () => {
+    const root = tmp();
+    const ws = join(root, 'acme-noc');
+    mkdirSync(ws, { recursive: true });
+    const rec = await resolveWorkspaceId(ws);
+    assert.match(rec.id, /^acme-noc-[0-9a-f]{6}$/);
+    assert.equal(rec.memory_seed_applied, false);
+    assert.equal(rec.memory_seed_persona, null);
+    assert.ok(existsSync(join(ws, '.otto', 'memory', 'workspace.json')));
+  });
+  it('returns existing id on second call (idempotent)', async () => {
+    const root = tmp();
+    const ws = join(root, 'acme-noc');
+    mkdirSync(ws, { recursive: true });
+    const a = await resolveWorkspaceId(ws);
+    const b = await resolveWorkspaceId(ws);
+    assert.equal(a.id, b.id);
+    assert.equal(a.created_at, b.created_at);
+  });
+  it('falls back to path-hash when workspace.json is corrupted', async () => {
+    const root = tmp();
+    const ws = join(root, 'broken');
+    mkdirSync(join(ws, '.otto', 'memory'), { recursive: true });
+    writeFileSync(join(ws, '.otto', 'memory', 'workspace.json'), 'not json');
+    const rec = await resolveWorkspaceId(ws);
+    assert.match(rec.id, /^broken-[0-9a-f]{6}$/);
+    assert.ok(existsSync(join(ws, '.otto', 'memory', 'workspace.json.broken-')) ||
+              readFileSync(join(ws, '.otto', 'memory', 'workspace.json'), 'utf8').includes('"_schema"'));
+  });
+  it('uses workspace fallback when basename is empty', async () => {
+    // synthesize via an explicit path with weird basename
+    const root = tmp();
+    const ws = root; // root-of-tmp has a basename like 'wsid-xxxxxx', fine
+    const rec = await resolveWorkspaceId(ws);
+    assert.ok(rec.id.length > 0);
+  });
+});

package/packages/coworker-memory/src/workspace-id.ts

@@ -0,0 +1,56 @@
+// 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';
+import type { WorkspaceIdRecord } from './types.js';
+
+function pathHash6(absolutePath: string): string {
+  return createHash('sha256').update(absolutePath).digest('hex').slice(0, 6);
+}
+
+function deriveSlug(workspaceDir: string): string {
+  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: string): Promise<WorkspaceIdRecord> {
+  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')) as WorkspaceIdRecord;
+      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: WorkspaceIdRecord = {
+    _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: string, rec: WorkspaceIdRecord): Promise<void> {
+  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/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-memory/tsconfig.publish.json

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

package/packages/coworker-persona/dist/commands.d.ts

@@ -0,0 +1,7 @@
+import { PersonaRegistry } from './registry.js';
+export declare function handleList(registry: PersonaRegistry, workspaceRoot: string): Promise<string[]>;
+export declare function handleCurrent(registry: PersonaRegistry, workspaceRoot: string): Promise<string[]>;
+export declare function handleSwitch(registry: PersonaRegistry, workspaceRoot: string, name: string): Promise<string[]>;
+export declare function handleReset(registry: PersonaRegistry, workspaceRoot: string): Promise<string[]>;
+export declare function handleInstall(registry: PersonaRegistry, source: string): Promise<string[]>;
+export declare function handleUninstall(registry: PersonaRegistry, name: string, trackedWorkspaces: string[]): Promise<string[]>;

package/packages/coworker-persona/dist/commands.js

@@ -0,0 +1,35 @@
+export async function handleList(registry, workspaceRoot) {
+    const installed = await registry.list();
+    const active = await registry.activeInWorkspace(workspaceRoot);
+    return installed.map(p => `${p.name === active.name ? '*' : ' '} ${p.name} — ${p.display_name} (v${p.version})`);
+}
+export async function handleCurrent(registry, workspaceRoot) {
+    const active = await registry.activeInWorkspace(workspaceRoot);
+    return [
+        `Active persona: ${active.name}`,
+        `Display name:   ${active.display_name}`,
+        `Version:        ${active.version}`,
+        `Description:    ${active.description}`,
+        `Author:         ${active.author}`,
+    ];
+}
+export async function handleSwitch(registry, workspaceRoot, name) {
+    const persona = await registry.get(name);
+    if (!persona)
+        throw new Error(`persona "${name}" is not installed; run /persona list to see installed personas`);
+    await registry.activateInWorkspace(workspaceRoot, name);
+    return [`Switched to persona: ${name} (${persona.display_name})`];
+}
+export async function handleReset(registry, workspaceRoot) {
+    await registry.activateInWorkspace(workspaceRoot, 'default');
+    return ['Persona reset to default'];
+}
+export async function handleInstall(registry, source) {
+    // For Phase 0 we only support local-path install. Npm + git install come in Phase 6.
+    const manifest = await registry.installFromPath(source);
+    return [`Installed persona: ${manifest.name} (${manifest.display_name})`];
+}
+export async function handleUninstall(registry, name, trackedWorkspaces) {
+    await registry.uninstall(name, { trackedWorkspaces });
+    return [`Uninstalled persona: ${name}`];
+}

package/packages/coworker-persona/dist/defaults/manifest.yaml

@@ -0,0 +1,12 @@
+name: default
+display_name: "Default Co-Worker"
+version: 1.0.0
+description: "Generic co-worker with no domain specialization. Auto-activates when no persona is set."
+author: "@cmetech"
+otto_version_required: ">=2.0.0"
+steering:
+  - steering/identity.md
+status_line:
+  label: "default"
+  color: "#6B6B7C"
+  icon: "⚙"

package/packages/coworker-persona/dist/defaults/steering/identity.md

@@ -0,0 +1,3 @@
+You are Otto — a co-worker that helps the user run analyses, build reports, query their data,
+and remember context across sessions. Be direct, accurate, and concise. When in doubt, ask
+the user rather than guess. Cite memory and data sources verbatim when relevant.

package/packages/coworker-persona/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './manifest.js';
+export * from './registry.js';
+export * from './commands.js';

package/packages/coworker-persona/dist/index.js

@@ -0,0 +1,3 @@
+export * from './manifest.js';
+export * from './registry.js';
+export * from './commands.js';

package/packages/coworker-persona/dist/manifest.d.ts

@@ -0,0 +1,24 @@
+export interface PersonaStatusLine {
+    label: string;
+    color: string;
+    icon: string;
+}
+export interface PersonaMemorySeed {
+    apply_on_first_activation: boolean;
+    scope?: 'global' | 'per-project' | 'per-project-tagged';
+}
+export interface PersonaManifest {
+    name: string;
+    display_name: string;
+    version: string;
+    description: string;
+    author: string;
+    otto_version_required: string;
+    steering: string[];
+    memory_seed?: PersonaMemorySeed;
+    engines?: string;
+    artifact_kinds?: string[];
+    skills_path?: string;
+    status_line: PersonaStatusLine;
+}
+export declare function parsePersonaManifest(yamlText: string): PersonaManifest;

package/packages/coworker-persona/dist/manifest.js

@@ -0,0 +1,21 @@
+// Persona manifest parser. See spec §2.5.
+import { parse as parseYaml } from 'yaml';
+// Order matters: tests assert the FIRST missing field reported, and the
+// "missing version" case supplies only `name`, so `version` must be checked
+// before `display_name`.
+const REQUIRED = [
+    'name', 'version', 'display_name', 'description', 'author',
+    'otto_version_required', 'steering', 'status_line',
+];
+export function parsePersonaManifest(yamlText) {
+    const raw = parseYaml(yamlText);
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('persona manifest must be a YAML object');
+    }
+    for (const field of REQUIRED) {
+        if (!(field in raw)) {
+            throw new Error(`persona manifest missing required field: ${field}`);
+        }
+    }
+    return raw;
+}

package/packages/coworker-persona/dist/registry.d.ts

@@ -0,0 +1,22 @@
+import { type PersonaManifest } from './manifest.js';
+export interface RegistryOptions {
+    ottoHome: string;
+}
+export interface ActiveRecord {
+    active: string;
+    activated_at: string;
+    memory_seed_applied: boolean;
+}
+export declare class PersonaRegistry {
+    #private;
+    constructor(opts: RegistryOptions);
+    ensureDefaultInstalled(): Promise<void>;
+    list(): Promise<PersonaManifest[]>;
+    installFromPath(bundlePath: string): Promise<PersonaManifest>;
+    activateInWorkspace(workspaceRoot: string, name: string): Promise<void>;
+    activeInWorkspace(workspaceRoot: string): Promise<PersonaManifest>;
+    get(name: string): Promise<PersonaManifest | null>;
+    uninstall(name: string, opts: {
+        trackedWorkspaces: string[];
+    }): Promise<void>;
+}