@cmetech/otto 1.1.1 → 1.2.4

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

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

@@ -0,0 +1,142 @@
+// PersonaRegistry — install / list / activate / switch. Spec §2.5.
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parsePersonaManifest } from './manifest.js';
+async function dirExists(p) {
+    try {
+        const s = await fs.stat(p);
+        return s.isDirectory();
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return false;
+        throw err;
+    }
+}
+async function copyDir(src, dst) {
+    await fs.mkdir(dst, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const e of entries) {
+        const s = path.join(src, e.name);
+        const d = path.join(dst, e.name);
+        if (e.isDirectory()) {
+            await copyDir(s, d);
+        }
+        else {
+            await fs.copyFile(s, d);
+        }
+    }
+}
+export class PersonaRegistry {
+    #personasDir;
+    constructor(opts) {
+        this.#personasDir = path.join(opts.ottoHome, 'personas');
+    }
+    async ensureDefaultInstalled() {
+        const target = path.join(this.#personasDir, 'default');
+        if (await dirExists(target))
+            return;
+        // Source: bundled defaults shipped with this package
+        const here = path.dirname(new URL(import.meta.url).pathname);
+        const source = path.join(here, 'defaults');
+        await copyDir(source, target);
+    }
+    async list() {
+        if (!(await dirExists(this.#personasDir)))
+            return [];
+        const entries = await fs.readdir(this.#personasDir, { withFileTypes: true });
+        const out = [];
+        for (const e of entries) {
+            if (!e.isDirectory())
+                continue;
+            const manifestPath = path.join(this.#personasDir, e.name, 'manifest.yaml');
+            try {
+                const raw = await fs.readFile(manifestPath, 'utf8');
+                out.push(parsePersonaManifest(raw));
+            }
+            catch {
+                // skip malformed bundles
+            }
+        }
+        return out;
+    }
+    async installFromPath(bundlePath) {
+        const manifestPath = path.join(bundlePath, 'manifest.yaml');
+        let raw;
+        try {
+            raw = await fs.readFile(manifestPath, 'utf8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                throw new Error(`bundle missing manifest.yaml at ${manifestPath}`);
+            }
+            throw err;
+        }
+        const manifest = parsePersonaManifest(raw);
+        const target = path.join(this.#personasDir, manifest.name);
+        await fs.rm(target, { recursive: true, force: true });
+        await copyDir(bundlePath, target);
+        return manifest;
+    }
+    async activateInWorkspace(workspaceRoot, name) {
+        const persona = await this.get(name);
+        if (!persona)
+            throw new Error(`persona not installed: ${name}`);
+        const wsOtto = path.join(workspaceRoot, '.otto');
+        await fs.mkdir(wsOtto, { recursive: true });
+        const record = {
+            active: name,
+            activated_at: new Date().toISOString(),
+            memory_seed_applied: false,
+        };
+        await fs.writeFile(path.join(wsOtto, 'persona.json'), JSON.stringify(record, null, 2));
+    }
+    async activeInWorkspace(workspaceRoot) {
+        const recordPath = path.join(workspaceRoot, '.otto', 'persona.json');
+        try {
+            const raw = await fs.readFile(recordPath, 'utf8');
+            const record = JSON.parse(raw);
+            const m = await this.get(record.active);
+            if (m)
+                return m;
+        }
+        catch {
+            // fall through to default
+        }
+        const def = await this.get('default');
+        if (!def)
+            throw new Error('default persona not installed');
+        return def;
+    }
+    async get(name) {
+        const manifestPath = path.join(this.#personasDir, name, 'manifest.yaml');
+        try {
+            const raw = await fs.readFile(manifestPath, 'utf8');
+            return parsePersonaManifest(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async uninstall(name, opts) {
+        if (name === 'default') {
+            throw new Error('cannot uninstall the built-in default persona');
+        }
+        for (const ws of opts.trackedWorkspaces) {
+            try {
+                const raw = await fs.readFile(path.join(ws, '.otto', 'persona.json'), 'utf8');
+                const record = JSON.parse(raw);
+                if (record.active === name) {
+                    throw new Error(`persona ${name} is active in workspace ${ws}; switch first`);
+                }
+            }
+            catch (err) {
+                if (err.code === 'ENOENT')
+                    continue;
+                if (err instanceof Error && err.message.startsWith('persona '))
+                    throw err;
+            }
+        }
+        await fs.rm(path.join(this.#personasDir, name), { recursive: true, force: true });
+    }
+}

package/packages/coworker-persona/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@otto/coworker-persona",
+  "version": "0.0.1",
+  "description": "Persona registry, manifest parser, and built-in default persona for Otto co-worker",
+  "type": "module",
+  "otto": {
+    "linkable": true,
+    "scope": "@otto",
+    "name": "coworker-persona"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-defaults.cjs",
+    "build:publish": "tsc -p tsconfig.publish.json && node scripts/copy-defaults.cjs"
+  },
+  "files": ["dist"],
+  "dependencies": {
+    "@otto/coworker-utils": "*",
+    "yaml": "^2.4.0"
+  }
+}

package/packages/coworker-persona/scripts/copy-defaults.cjs

@@ -0,0 +1,17 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+
+function copyDir(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const e of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, e.name);
+    const d = path.join(dst, e.name);
+    e.isDirectory() ? copyDir(s, d) : fs.copyFileSync(s, d);
+  }
+}
+
+const src = path.resolve(__dirname, '..', 'src', 'defaults');
+const dst = path.resolve(__dirname, '..', 'dist', 'defaults');
+copyDir(src, dst);
+console.log(`Copied persona defaults: ${src} → ${dst}`);

package/packages/coworker-persona/src/commands.ts

@@ -0,0 +1,47 @@
+// /persona slash-command handlers. Spec §2.5 + §5.2.
+// Pure functions over a PersonaRegistry — UI adapters live in otto-cli.
+import { PersonaRegistry } from './registry.js';
+
+export async function handleList(registry: PersonaRegistry, workspaceRoot: string): Promise<string[]> {
+  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: PersonaRegistry, workspaceRoot: string): Promise<string[]> {
+  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: PersonaRegistry, workspaceRoot: string, name: string): Promise<string[]> {
+  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: PersonaRegistry, workspaceRoot: string): Promise<string[]> {
+  await registry.activateInWorkspace(workspaceRoot, 'default');
+  return ['Persona reset to default'];
+}
+
+export async function handleInstall(registry: PersonaRegistry, source: string): Promise<string[]> {
+  // 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: PersonaRegistry,
+  name: string,
+  trackedWorkspaces: string[],
+): Promise<string[]> {
+  await registry.uninstall(name, { trackedWorkspaces });
+  return [`Uninstalled persona: ${name}`];
+}

package/packages/coworker-persona/src/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/src/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/src/index.ts

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

package/packages/coworker-persona/src/manifest.test.ts

@@ -0,0 +1,67 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { parsePersonaManifest, type PersonaManifest } from './manifest.js';
+
+describe('persona manifest', () => {
+  it('parses a minimum-valid manifest', () => {
+    const yaml = `
+name: noc-ops
+display_name: "NOC / IT Ops Analyst"
+version: 1.0.0
+description: "NOC analyst co-worker"
+author: "@cmetech"
+otto_version_required: ">=2.0.0"
+steering:
+  - steering/identity.md
+status_line:
+  label: NOC
+  color: "#FAD22D"
+  icon: "🛡"
+`;
+    const m: PersonaManifest = parsePersonaManifest(yaml);
+    assert.equal(m.name, 'noc-ops');
+    assert.equal(m.steering.length, 1);
+    assert.equal(m.status_line.label, 'NOC');
+  });
+
+  it('rejects manifest missing required name', () => {
+    const yaml = 'version: 1.0.0';
+    assert.throws(() => parsePersonaManifest(yaml), /name/);
+  });
+
+  it('rejects manifest missing version', () => {
+    const yaml = 'name: noc-ops';
+    assert.throws(() => parsePersonaManifest(yaml), /version/);
+  });
+
+  it('defaults memory_seed.apply_on_first_activation to false when absent', () => {
+    const yaml = `
+name: x
+display_name: x
+version: 1.0.0
+description: x
+author: x
+otto_version_required: ">=2.0.0"
+steering: []
+status_line: { label: X, color: "#000000", icon: "x" }
+`;
+    const m = parsePersonaManifest(yaml);
+    assert.equal(m.memory_seed?.apply_on_first_activation ?? false, false);
+  });
+
+  it('parses artifact_kinds list when provided', () => {
+    const yaml = `
+name: x
+display_name: x
+version: 1.0.0
+description: x
+author: x
+otto_version_required: ">=2.0.0"
+steering: []
+status_line: { label: X, color: "#000", icon: "x" }
+artifact_kinds: [report, workbook, inventory_report]
+`;
+    const m = parsePersonaManifest(yaml);
+    assert.deepEqual(m.artifact_kinds, ['report', 'workbook', 'inventory_report']);
+  });
+});