@cmetech/otto 1.1.0 → 1.2.4

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

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

@@ -0,0 +1,49 @@
+// Persona manifest parser. See spec §2.5.
+import { parse as parseYaml } from 'yaml';
+
+export interface PersonaStatusLine {
+  label: string;
+  color: string;     // hex
+  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;
+}
+
+// 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: Array<keyof PersonaManifest> = [
+  'name', 'version', 'display_name', 'description', 'author',
+  'otto_version_required', 'steering', 'status_line',
+];
+
+export function parsePersonaManifest(yamlText: string): PersonaManifest {
+  const raw = parseYaml(yamlText) as Record<string, unknown> | null;
+  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 as unknown as PersonaManifest;
+}

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

@@ -0,0 +1,89 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { PersonaRegistry } from './registry.js';
+
+let tmpHome: string;
+
+describe('PersonaRegistry', () => {
+  beforeEach(async () => {
+    tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), 'persona-test-'));
+    await fs.mkdir(path.join(tmpHome, 'personas'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpHome, { recursive: true, force: true });
+  });
+
+  it('list returns built-in default persona on a fresh registry', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    const installed = await r.list();
+    assert.ok(installed.find(p => p.name === 'default'), 'default persona should be installed');
+  });
+
+  it('install copies a bundle directory into ~/.otto/personas/<name>', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    // Stage a fake persona bundle
+    const bundle = await fs.mkdtemp(path.join(os.tmpdir(), 'fake-bundle-'));
+    await fs.mkdir(path.join(bundle, 'steering'), { recursive: true });
+    await fs.writeFile(path.join(bundle, 'manifest.yaml'),
+      'name: noc-ops\ndisplay_name: NOC\nversion: 1.0.0\ndescription: x\nauthor: x\notto_version_required: ">=2.0.0"\nsteering: [steering/identity.md]\nstatus_line: { label: NOC, color: "#FAD22D", icon: "🛡" }\n');
+    await fs.writeFile(path.join(bundle, 'steering', 'identity.md'), 'noc identity');
+
+    await r.installFromPath(bundle);
+    const installed = await r.list();
+    assert.ok(installed.find(p => p.name === 'noc-ops'));
+    await fs.rm(bundle, { recursive: true, force: true });
+  });
+
+  it('install rejects a bundle missing manifest.yaml', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    const bad = await fs.mkdtemp(path.join(os.tmpdir(), 'bad-bundle-'));
+    await assert.rejects(() => r.installFromPath(bad), /manifest\.yaml/);
+    await fs.rm(bad, { recursive: true, force: true });
+  });
+
+  it('activateInWorkspace writes <workspace>/.otto/persona.json', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    const ws = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-'));
+    await r.activateInWorkspace(ws, 'default');
+    const raw = await fs.readFile(path.join(ws, '.otto', 'persona.json'), 'utf8');
+    const data = JSON.parse(raw);
+    assert.equal(data.active, 'default');
+    assert.equal(typeof data.activated_at, 'string');
+    assert.equal(data.memory_seed_applied, false);
+    await fs.rm(ws, { recursive: true, force: true });
+  });
+
+  it('activeInWorkspace returns "default" when no persona.json exists', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    const ws = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-'));
+    const active = await r.activeInWorkspace(ws);
+    assert.equal(active.name, 'default');
+    await fs.rm(ws, { recursive: true, force: true });
+  });
+
+  it('uninstall refuses if persona is currently active in any tracked workspace', async () => {
+    const r = new PersonaRegistry({ ottoHome: tmpHome });
+    await r.ensureDefaultInstalled();
+    // Stage + install a second persona, then activate it
+    const bundle = await fs.mkdtemp(path.join(os.tmpdir(), 'fake-bundle-'));
+    await fs.mkdir(path.join(bundle, 'steering'), { recursive: true });
+    await fs.writeFile(path.join(bundle, 'manifest.yaml'),
+      'name: noc-ops\ndisplay_name: NOC\nversion: 1.0.0\ndescription: x\nauthor: x\notto_version_required: ">=2.0.0"\nsteering: [steering/identity.md]\nstatus_line: { label: NOC, color: "#FAD22D", icon: "🛡" }\n');
+    await fs.writeFile(path.join(bundle, 'steering', 'identity.md'), 'noc');
+    await r.installFromPath(bundle);
+
+    const ws = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-'));
+    await r.activateInWorkspace(ws, 'noc-ops');
+    await assert.rejects(() => r.uninstall('noc-ops', { trackedWorkspaces: [ws] }), /active/);
+
+    await fs.rm(bundle, { recursive: true, force: true });
+    await fs.rm(ws, { recursive: true, force: true });
+  });
+});

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

@@ -0,0 +1,147 @@
+// PersonaRegistry — install / list / activate / switch. Spec §2.5.
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parsePersonaManifest, type PersonaManifest } from './manifest.js';
+
+export interface RegistryOptions {
+  ottoHome: string;            // typically ~/.otto
+}
+
+export interface ActiveRecord {
+  active: string;
+  activated_at: string;
+  memory_seed_applied: boolean;
+}
+
+async function dirExists(p: string): Promise<boolean> {
+  try {
+    const s = await fs.stat(p);
+    return s.isDirectory();
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return false;
+    throw err;
+  }
+}
+
+async function copyDir(src: string, dst: string): Promise<void> {
+  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: string;
+
+  constructor(opts: RegistryOptions) {
+    this.#personasDir = path.join(opts.ottoHome, 'personas');
+  }
+
+  async ensureDefaultInstalled(): Promise<void> {
+    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(): Promise<PersonaManifest[]> {
+    if (!(await dirExists(this.#personasDir))) return [];
+    const entries = await fs.readdir(this.#personasDir, { withFileTypes: true });
+    const out: PersonaManifest[] = [];
+    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: string): Promise<PersonaManifest> {
+    const manifestPath = path.join(bundlePath, 'manifest.yaml');
+    let raw: string;
+    try {
+      raw = await fs.readFile(manifestPath, 'utf8');
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).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: string, name: string): Promise<void> {
+    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: ActiveRecord = {
+      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: string): Promise<PersonaManifest> {
+    const recordPath = path.join(workspaceRoot, '.otto', 'persona.json');
+    try {
+      const raw = await fs.readFile(recordPath, 'utf8');
+      const record = JSON.parse(raw) as ActiveRecord;
+      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: string): Promise<PersonaManifest | null> {
+    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: string, opts: { trackedWorkspaces: string[] }): Promise<void> {
+    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) as ActiveRecord;
+        if (record.active === name) {
+          throw new Error(`persona ${name} is active in workspace ${ws}; switch first`);
+        }
+      } catch (err: unknown) {
+        if ((err as NodeJS.ErrnoException).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/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-persona/tsconfig.publish.json

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

package/packages/coworker-scratchpad/dist/cell-archive.d.ts

@@ -0,0 +1,39 @@
+export declare const CELLS_SCHEMA_VERSION = 1;
+export interface CellEntry {
+    id: number;
+    parentId: number | null;
+    code: string;
+    ok: boolean;
+    value?: unknown;
+    error?: {
+        name: string;
+        message: string;
+    };
+    stdout: string;
+    ts: string;
+}
+export interface AppendInput {
+    code: string;
+    ok: boolean;
+    value?: unknown;
+    error?: {
+        name: string;
+        message: string;
+    };
+    stdout: string;
+}
+export declare class CellArchive {
+    #private;
+    private readonly dir;
+    private readonly now;
+    private readonly path;
+    private nextId;
+    constructor(dir: string, now?: () => number);
+    private scan;
+    private ensureHeader;
+    append(input: AppendInput): CellEntry;
+    get lastId(): number | null;
+    get leafId(): number | null;
+    setLeaf(id: number | null): void;
+    reset(): void;
+}