@cmetech/otto 1.1.0 → 1.2.4

package/dist/resources/extensions/coworker-vault/audit-command.js

@@ -0,0 +1,35 @@
+const DURATION_RE = /^(\d+)([smhd])$/;
+const MS = {
+    s: 1000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+function resolveSince(token) {
+    if (!token)
+        return undefined;
+    const m = DURATION_RE.exec(token);
+    if (m) {
+        const n = parseInt(m[1], 10);
+        const unit = m[2];
+        return new Date(Date.now() - n * MS[unit]).toISOString();
+    }
+    return token; // treat as ISO-8601
+}
+export async function runAudit(bundle, q) {
+    const since = resolveSince(q.since);
+    const limit = q.limit ?? 50;
+    const out = [];
+    for await (const r of bundle.audit.read({
+        since,
+        producer: q.producer,
+        action: q.action,
+        severity: q.severity,
+        engineId: q.engine,
+    })) {
+        out.push(r);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}

package/dist/resources/extensions/coworker-vault/connect-command.js

@@ -0,0 +1,42 @@
+// src/resources/extensions/coworker-vault/connect-command.ts
+//
+// Programmatic /connect wizard. Walks an engine's fields via a `promptProvider`
+// callback, handles VAULT_KEEP sentinel for edits, validates required fields,
+// and writes through LocalDataVault.set. No TUI dependencies — the TUI binding
+// (clack/prompts) is wired separately and passes a clack-based provider.
+import { mergeWithSentinel, assertNoSentinelInCreate, VAULT_KEEP, VaultEntryNotFound, } from '@otto/coworker-vault';
+export async function runConnect(bundle, opts) {
+    const engine = bundle.registry.require(opts.engineId);
+    let existing;
+    try {
+        const got = await bundle.vault.get({ engine: opts.engineId, name: opts.entryName });
+        existing = got.fields;
+    }
+    catch (err) {
+        if (!(err instanceof VaultEntryNotFound))
+            throw err;
+    }
+    const submitted = {};
+    for (const f of engine.fields) {
+        const defaultValue = existing && f.secret
+            ? VAULT_KEEP
+            : (existing?.[f.name] ?? f.default ?? '');
+        const value = await opts.promptProvider(f.name, {
+            label: f.label,
+            secret: f.secret,
+            required: f.required,
+            defaultValue,
+        });
+        if (f.required && value.trim() === '') {
+            throw new Error(`Field "${f.name}" is required.`);
+        }
+        submitted[f.name] = value;
+    }
+    if (!existing) {
+        assertNoSentinelInCreate(engine.fields, submitted);
+    }
+    const merged = existing
+        ? mergeWithSentinel(engine.fields, existing, submitted)
+        : submitted;
+    await bundle.vault.set({ engine: opts.engineId, name: opts.entryName }, merged, { forceWorkspace: opts.forceWorkspace });
+}

package/dist/resources/extensions/coworker-vault/datasource-command.js

@@ -0,0 +1,50 @@
+// src/resources/extensions/coworker-vault/datasource-command.ts
+//
+// Programmatic /datasource list|remove|test commands. `edit` is wired at the
+// routing layer (Task 16) as an alias for runConnect and does not need its own
+// function here. No TUI dependencies.
+import { LocalDataVault, envVarName } from '@otto/coworker-vault';
+export async function runDatasourceList(bundle, filter) {
+    const all = await bundle.vault.list();
+    const out = [];
+    for (const row of all) {
+        if (filter.engine && row.engine !== filter.engine)
+            continue;
+        const engine = bundle.registry.get(row.engine);
+        let fields = [];
+        if (engine) {
+            const entry = await bundle.vault.get({ engine: row.engine, name: row.name });
+            fields = engine.fields
+                .map((f) => ({
+                name: f.name,
+                secret: f.secret,
+                display: f.secret ? '••••••' : (entry.fields[f.name] ?? ''),
+            }))
+                .filter((f) => row.fields_set.includes(f.name));
+        }
+        else {
+            fields = row.fields_set.map((n) => ({ name: n, secret: false, display: '' }));
+        }
+        out.push({
+            engine: row.engine,
+            name: row.name,
+            scope: row.scope,
+            fields,
+            last_modified_at: row.last_modified_at,
+        });
+    }
+    return out;
+}
+export async function runDatasourceRemove(bundle, args) {
+    const ref = LocalDataVault.parseRef(args.ref);
+    await bundle.vault.remove(ref);
+}
+export async function runDatasourceTest(bundle, args) {
+    const ref = LocalDataVault.parseRef(args.ref);
+    const entry = await bundle.vault.get(ref);
+    return {
+        ref: args.ref,
+        engine: ref.engine,
+        envVarNames: Object.keys(entry.fields).map((f) => envVarName(ref.engine, ref.name, f)),
+    };
+}

package/dist/resources/extensions/coworker-vault/extension-manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "coworker-vault",
+  "name": "Co-worker Vault",
+  "version": "1.0.0",
+  "description": "Credential vault: /connect wizard, /datasource manager, /audit reader",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "commands": ["connect", "datasource", "audit"],
+    "hooks": ["session_shutdown"]
+  }
+}

package/dist/resources/extensions/coworker-vault/index.js

@@ -0,0 +1,171 @@
+import { createVaultBundle } from './vault-singleton.js';
+import { runConnect } from './connect-command.js';
+import { runDatasourceList, runDatasourceRemove, runDatasourceTest, } from './datasource-command.js';
+import { runAudit } from './audit-command.js';
+import { getCoworkerGlobalDir } from '../_coworker-paths.js';
+export { createVaultBundle };
+export default function coworkerVaultExtension(api) {
+    let bundle = null;
+    let unavailable = false;
+    api.on('session_start', async (_event, ctx) => {
+        try {
+            bundle = await createVaultBundle({
+                globalDir: getCoworkerGlobalDir(),
+                workspaceDir: ctx.cwd,
+            });
+            unavailable = false;
+        }
+        catch (err) {
+            unavailable = true;
+            bundle = null;
+            ctx.ui.notify(`vault unavailable: ${err.message}`, 'warning');
+        }
+    });
+    api.registerCommand('connect', {
+        description: 'Add or edit a credential entry. Usage: /connect <engine> <name> [--workspace]',
+        handler: async (args, ctx) => {
+            if (!bundle) {
+                ctx.ui.notify(unavailable ? 'vault unavailable; chat continues without it.' : 'vault not ready yet.', 'warning');
+                return;
+            }
+            const tokens = args.trim().split(/\s+/).filter(Boolean);
+            const flags = new Set(tokens.filter(t => t.startsWith('--')));
+            const positional = tokens.filter(t => !t.startsWith('--'));
+            const [engineId, entryName] = positional;
+            if (!engineId || !entryName) {
+                ctx.ui.notify('Usage: /connect <engine> <name> [--workspace]', 'info');
+                return;
+            }
+            const forceWorkspace = flags.has('--workspace');
+            // Wire ctx.ui.input as the prompt provider. If hasUI is false (print/RPC
+            // mode), surface a non-error notice and bail rather than throwing.
+            if (!ctx.hasUI) {
+                ctx.ui.notify('interactive /connect requires a TTY session.', 'warning');
+                return;
+            }
+            const promptProvider = async (field, opts) => {
+                const placeholder = opts.defaultValue ?? '';
+                const title = `${opts.label}${opts.required ? ' *' : ''}${opts.secret ? ' (hidden)' : ''}`;
+                const result = await ctx.ui.input(title, placeholder);
+                return result ?? '';
+            };
+            try {
+                await runConnect(bundle, { engineId, entryName, forceWorkspace, promptProvider });
+                ctx.ui.notify(`saved ${engineId}:${entryName}`, 'success');
+            }
+            catch (err) {
+                ctx.ui.notify(`/connect failed: ${err.message}`, 'error');
+            }
+        },
+    });
+    api.registerCommand('datasource', {
+        description: '/datasource list [engine] | remove <engine:name> | test <engine:name>',
+        handler: async (args, ctx) => {
+            if (!bundle) {
+                ctx.ui.notify(unavailable ? 'vault unavailable; chat continues without it.' : 'vault not ready yet.', 'warning');
+                return;
+            }
+            const tokens = args.trim().split(/\s+/).filter(Boolean);
+            const [sub, ...rest] = tokens;
+            try {
+                switch (sub) {
+                    case undefined:
+                    case 'list': {
+                        const engineFilter = rest[0];
+                        const rows = await runDatasourceList(bundle, engineFilter ? { engine: engineFilter } : {});
+                        const lines = rows.length === 0
+                            ? ['no datasources configured']
+                            : rows.map(r => `  ${r.engine}:${r.name} (${r.scope})`);
+                        ctx.ui.notify(lines.join('\n'), 'info');
+                        return;
+                    }
+                    case 'remove': {
+                        const ref = rest.join(' ').trim();
+                        if (!ref) {
+                            ctx.ui.notify('Usage: /datasource remove <engine:name>', 'info');
+                            return;
+                        }
+                        await runDatasourceRemove(bundle, { ref });
+                        ctx.ui.notify(`removed: ${ref}`, 'success');
+                        return;
+                    }
+                    case 'test': {
+                        const ref = rest.join(' ').trim();
+                        if (!ref) {
+                            ctx.ui.notify('Usage: /datasource test <engine:name>', 'info');
+                            return;
+                        }
+                        const preview = await runDatasourceTest(bundle, { ref });
+                        ctx.ui.notify(`Would inject: ${preview.envVarNames.join(', ')}`, 'info');
+                        return;
+                    }
+                    default:
+                        ctx.ui.notify(`Unknown /datasource subcommand: ${sub}. Try: list, remove, test.`, 'warning');
+                }
+            }
+            catch (err) {
+                ctx.ui.notify(`/datasource failed: ${err.message}`, 'error');
+            }
+        },
+    });
+    api.registerCommand('audit', {
+        description: '/audit [--since 1h|24h|7d|ISO] [--producer P] [--engine E] [--action A] [--severity info|warn] [--limit N]',
+        handler: async (args, ctx) => {
+            if (!bundle) {
+                ctx.ui.notify(unavailable ? 'vault unavailable; chat continues without it.' : 'vault not ready yet.', 'warning');
+                return;
+            }
+            const tokens = args.trim().split(/\s+/).filter(Boolean);
+            const q = {};
+            for (let i = 0; i < tokens.length; i++) {
+                const t = tokens[i];
+                const next = tokens[i + 1];
+                if (t === '--since' && next) {
+                    q.since = next;
+                    i++;
+                }
+                else if (t === '--producer' && next) {
+                    q.producer = next;
+                    i++;
+                }
+                else if (t === '--engine' && next) {
+                    q.engine = next;
+                    i++;
+                }
+                else if (t === '--action' && next) {
+                    q.action = next;
+                    i++;
+                }
+                else if (t === '--severity' && next) {
+                    if (next === 'info' || next === 'warn') {
+                        q.severity = next;
+                    }
+                    i++;
+                }
+                else if (t === '--limit' && next) {
+                    const n = parseInt(next, 10);
+                    if (Number.isFinite(n) && n > 0)
+                        q.limit = n;
+                    i++;
+                }
+            }
+            try {
+                const rows = await runAudit(bundle, q);
+                const lines = rows.length === 0
+                    ? ['no audit records match']
+                    : rows.map(r => {
+                        const engine = typeof r.detail?.engine === 'string' ? r.detail.engine : undefined;
+                        return `  [${r.ts}] ${r.producer}/${r.action}${engine ? ` engine=${engine}` : ''}`;
+                    });
+                ctx.ui.notify(lines.join('\n'), 'info');
+            }
+            catch (err) {
+                ctx.ui.notify(`/audit failed: ${err.message}`, 'error');
+            }
+        },
+    });
+    api.on('session_shutdown', async () => {
+        // Phase 2 VaultBundle has no async dispose path; clearing the reference is enough.
+        bundle = null;
+    });
+}

package/dist/resources/extensions/coworker-vault/test-helpers.js

@@ -0,0 +1,86 @@
+// src/resources/extensions/coworker-vault/test-helpers.ts
+//
+// Shared fake ExtensionAPI used by the coworker-vault, coworker-memory, and
+// (eventually) cross-extension integration tests. Captures every command +
+// tool registration + event handler so tests can fire lifecycle events and
+// inspect ui.notify calls.
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export function makeFakeApi() {
+    const commands = new Map();
+    const tools = new Map();
+    const handlers = new Map();
+    const notifyCalls = [];
+    const ui = {
+        notify: (message, level) => {
+            notifyCalls.push({ message, level: level ?? 'info' });
+        },
+        confirm: async () => true,
+        input: async () => '',
+        select: async () => undefined,
+    };
+    const ctx = {
+        cwd: tmpdir(),
+        hasUI: true,
+        ui,
+        sessionManager: {
+            getSessionFile: () => join(tmpdir(), 'session.jsonl'),
+        },
+        isIdle: () => true,
+        abort: () => { },
+        hasPendingMessages: () => false,
+        shutdown: () => { },
+        getContextUsage: () => undefined,
+        compact: () => { },
+        getSystemPrompt: () => '',
+        setCompactionThresholdOverride: () => { },
+    };
+    const commandCtx = ctx;
+    const api = {
+        on(event, handler) {
+            if (!handlers.has(event))
+                handlers.set(event, []);
+            handlers.get(event).push(handler);
+        },
+        registerCommand(name, options) {
+            commands.set(name, { name, ...options });
+        },
+        registerTool(tool) {
+            tools.set(tool.name, tool);
+        },
+        sendMessage() { },
+    };
+    return { api, commands, tools, handlers, notifyCalls, ctx, commandCtx };
+}
+export async function fireSessionStart(fake, opts) {
+    const evt = { type: 'session_start' };
+    // Mutate the fake.ctx so handlers see the requested cwd.
+    fake.ctx.cwd = opts.cwd;
+    const list = fake.handlers.get('session_start') ?? [];
+    for (const h of list)
+        await h(evt, fake.ctx);
+}
+export async function fireSessionShutdown(fake) {
+    const evt = { type: 'session_shutdown' };
+    const list = fake.handlers.get('session_shutdown') ?? [];
+    for (const h of list)
+        await h(evt, fake.ctx);
+}
+export async function fireBeforeAgentStart(fake, prompt, systemPrompt) {
+    const evt = { type: 'before_agent_start', prompt, systemPrompt };
+    const list = fake.handlers.get('before_agent_start') ?? [];
+    let result;
+    for (const h of list) {
+        const r = await h(evt, fake.ctx);
+        if (r && typeof r === 'object' && 'systemPrompt' in r) {
+            result = r;
+        }
+    }
+    return result;
+}
+export async function fireAgentStart(fake, sessionId, turnId) {
+    const evt = { type: 'agent_start', sessionId, turnId };
+    const list = fake.handlers.get('agent_start') ?? [];
+    for (const h of list)
+        await h(evt, fake.ctx);
+}

package/dist/resources/extensions/coworker-vault/vault-singleton.js

@@ -0,0 +1,24 @@
+// src/resources/extensions/coworker-vault/vault-singleton.ts
+//
+// Factory that constructs the three vault collaborators (LocalDataVault, AuditLog,
+// EngineRegistry) for given roots. Pure: side-effects are limited to whatever the
+// underlying constructors already perform (dir creation, orphan sweeps, etc.).
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { AuditLog } from '@otto/coworker-utils';
+import { LocalDataVault, EngineRegistry } from '@otto/coworker-vault';
+export async function createVaultBundle(opts = {}) {
+    const globalDir = opts.globalDir ?? join(homedir(), '.otto');
+    const auditPath = join(globalDir, 'audit.jsonl');
+    const audit = new AuditLog({ path: auditPath });
+    const vault = new LocalDataVault({
+        globalDir,
+        workspaceDir: opts.workspaceDir,
+        audit,
+    });
+    const registry = await EngineRegistry.load({
+        userDir: join(globalDir, 'engines'),
+        workspaceDir: opts.workspaceDir ? join(opts.workspaceDir, 'engines') : undefined,
+    });
+    return { vault, audit, registry, globalDir, workspaceDir: opts.workspaceDir };
+}

package/dist/resources/extensions/otto/commands/release-notes/_data.js

@@ -3,7 +3,89 @@
 //
 // To add or correct release notes, edit CHANGELOG.md and rebuild. Editing this
 // file directly will be clobbered on the next build.
+//
+// Bundled releases are capped (default 20, override via OTTO_RELEASE_NOTES_CAP
+// at build time). Older releases stay in CHANGELOG.md and on GitHub; the
+// runtime command surfaces a link when a requested version isn't bundled.
+export const RELEASE_NOTES_MANIFEST = {
+    truncated: false,
+    total: 13,
+    oldestBundled: '1.0.0',
+    newestBundled: '1.2.4',
+    historyUrl: 'https://github.com/cmetech/otto-cli/blob/main/CHANGELOG.md',
+};
 export const RELEASE_NOTES = [
+    {
+        version: '1.2.4',
+        date: '2026-06-02',
+        headline: 'Co-worker pillars go live: persistent memory (Layer A rules/lessons + Layer B verbatim drawers with FTS5 recall), workspace-scoped artifact store with `artifact://` URIs and two-turn provenance, vault\'s `/connect` `/datasource` `/audit` slash surface, and per-subagent dedicated scratchpads. Day-2 milestone — paste an incident note Monday → recall the exact words Tuesday — works end-to-end.',
+        added: [
+            '**`@otto/coworker-memory` Layer A + Layer B (Phase 3).** Workspace-scoped SQLite store at `<workspace>/.otto/memory/layer-b.db` with FTS5 BM25 ranking + WAL journaling; markdown Layer A files at `<workspace>/.otto/memory/{profile,rules,lessons}.md` with YAML frontmatter and atomic writes. Three scoping modes (global, per-project, per-project-tagged). SecretScanner split policy: Layer A blocks writes containing secrets (`LayerAWriteBlocked`); Layer B redacts (`[REDACTED:<kind>]`) and sets `redacted:true`. Persona-seed helper for one-shot bootstrap from `<persona>/memory-seed/`.',
+            '**Production activators wire memory + vault + scratchpad to Otto\'s `ExtensionAPI` (Phase 3.1).** Vault\'s `/connect <engine> <name>` interactive wizard, `/datasource list|remove|test`, and `/audit [--producer|--action|--limit|--since|--engine|--severity]` now register at extension activation — first time these are reachable in a live chat. Memory activator captures `event.prompt` in `before_agent_start`, calls `recorder.recordTurn(...)` in `agent_start` (one-time warning on failure, then silent). `/memory note <text>` appends a workspace lesson; `/memory status` reports `workspace_wing`, `drawer_count`, db path; `/memory clear --wing <w> --confirm` deletes drawers. `memorize` and `recall` LLM tools are model-callable. Layer A injects into the system prompt on `session_start` (3000-token cap; sections sorted profile → rules → lessons → truncate lowest-priority on overflow).',
+            '**`/memory show` + `/memory recall` slash surface (closes #73).** `/memory show [profile|rules|lessons] [--scope workspace|global]` dumps Layer A markdown inline; defaults to all three for per-project-tagged scope (workspace first, then global). `/memory recall <query> [--kind|--room|--wing|--limit|--days_back]` searches Layer B drawers directly from chat without going through the model\'s tool call. Memory command tab-completion lists all 8 subcommands.',
+            '**`@otto/coworker-artifacts` workspace-scoped store (Phase 4).** `report` artifact kind (markdown v1; workbook + dataset deferred). `ArtifactStore` with slug derivation (`deriveSlug` lowercase ASCII kebab, max 64 chars) + collision suffixing (`-2`, `-3`, … up to 100). Atomic writes (tmp → chmod → rename), mode 0o700 dir / 0o600 files. `DirSnapshot` (nanosecond mtime + size_bytes) drives per-turn `files_touched` via before/after diff. Append-only `provenance.json` records `{ts, action: create|update, turn_id, agent_turn_id?, user_prompt, scratchpad_name?, files_touched}` per turn. Deterministic `README.md` re-renders on every save. `resolveArtifactUri(uri, workspaceDir)` validates `^artifact://[a-z0-9][a-z0-9-]*[a-z0-9]$|^artifact://[a-z0-9]$`, rejects `..` traversal + length > 64 + non-ASCII. Production activator registers `/artifacts list|show|remove --confirm` (flag-order-agnostic) + `list_artifacts` + `open_artifact` LLM tools. Kernel-side `otto.artifact.create(kind, name)` + `otto.artifact.spillIfLarge(value, opts?)` (10 KB default threshold) via bidirectional NDJSON RPC over stdio. `kind:\'artifact\'` drawer in memory (migration 002 rebuilds the `drawers.kind` CHECK constraint) tagged with the scratchpad name as `room`, so `/memory recall <q> --kind artifact` finds them.',
+            '**Subagent-scratchpad scoping (Phase 4.5).** Subagent dispatcher mints `subagent-<sanitized-agent>-<6-hex>` per child process; the spawned `pi` reads `OTTO_SUBAGENT_SCRATCHPAD` env var at `session_start` and force-attaches before sidecar/pointer restore (validated against `^subagent-[a-z0-9-]+$`, max 80 chars). Scratchpads persist after subagent exit — parent can `/sp attach subagent-<id>` post-hoc to inspect kernel state, cells, namespace globals. Failure (invalid name, disk error) emits a warning and falls through to normal restore; never crashes `session_start`.',
+        ],
+        fixed: [
+            '**Strict-tsc compatibility for activator tool registrations.** `api.registerTool<TParams, TDetails>(...)` generics are explicit union types so success-vs-error result shapes both satisfy `AgentToolResult<TDetails>`. Caught at Phase 3.1 build-gate; not at test-compile (which uses esbuild). All Phase 3.1 + Phase 4 + Phase 4.5 activators carry the pattern.',
+            '**Strict `pi` kernel-entry main loop no longer deadlocks on artifact RPC.** `await runCell(req.code)` inside the `for await (const raw of readNdjson(stdin))` loop blocked the iterator from receiving its own RPC responses. Now fire-and-forget; manager already serializes cell submissions.',
+            '**Memory migration 002 rebuilds FTS5 triggers + virtual-table rowids** after the `drawers` table rename. Without this, `recall()` on existing v1 databases would return zero results post-upgrade.',
+            '**Memory recorder `byte_count` audit field** now uses `Buffer.byteLength(content, \'utf8\')` instead of character count.',
+            '**`LayerAStore` write-then-read round-trip preserves the section heading** on subsequent appends. Title-dedup regex tolerates leading newline left by frontmatter split.',
+            '**`optionalDependencies.@cmetech/otto-engine-*` pins synced to root version.** `version-sync.test.ts` asserts equality on every build; root publish would fail npm resolution otherwise.',
+        ],
+        changed: [
+            '**Memory backend `local-sqlite-backend` runs migrations conditionally.** `open()` checks `PRAGMA user_version` and applies `001-init.sql` (if version < 1) then `002-artifact-kind.sql` (if version < 2). Migration 002 rebuilds the `drawers` table with `\'artifact\'` added to the kind CHECK and re-runs FTS5 contentless-rowid alignment.',
+            '**Memory drawer kinds vocabulary** now includes `\'artifact\'`. Existing kinds (`turn`, `paste`, `file_load`, `ticket`, `email`, `rca`, `note`) unchanged.',
+            '**`/memory` command** description is a sentence; `getArgumentCompletions` lists all 8 subcommands with one-line descriptions of each.',
+            '**Audit log gains three new producers**: `memory` (write-layer-a, write-drawer, redact, block, recall, seed-applied), `vault` (set, remove, test, inject, inject-skipped — Phase 2 already had these but now reachable via slash), and `artifacts` (write, remove). All land in the shared `~/.otto/audit.jsonl`.',
+        ],
+        notes: [
+            'Phase 5 (Layer C entity graph + ACC + Cerebellum + Consolidator + daily digest + `memory://` URI resolver) is the next phase — depends on Phase 3 + Phase 4 (both shipped here). Phase 6 (NOC persona bundle, integration testing, time-to-first-artifact < 5 min) follows.',
+            'Smoke checklists for the four shipped phases live at `docs/superpowers/notes/2026-06-02-{phase-2-vault,phase-3-memory,phase-4-artifacts,phase-4.5-subagent-scratchpad}-smoke.md`. Each carries a PENDING verified-live placeholder — fill in after end-to-end TUI walkthrough.',
+            'Spec + plan artifacts at `docs/superpowers/specs/2026-06-02-*` and `docs/superpowers/plans/2026-06-02-*` for every phase shipped here.',
+        ],
+    },
+    {
+        version: '1.2.0',
+        date: '2026-06-01',
+        headline: 'Co-worker scratchpad Phase 1.5 polish wave: typing `otto` in a workspace where you previously attached a scratchpad now auto-restores it without `--resume`; `/sp evict` and idle-age display land; `otto.duckdb.registerDf` drops polars→DuckDB from ~8 LLM cells to 2.',
+        added: [
+            '**Workspace-pointer auto-restore (Issue #6).** New `~/.otto/scratchpads/_workspaces/<sha256-16>.json` keyed on git toplevel (else cwd). On `session_start`, when no per-session sidecar matches, falls back to the workspace pointer. The spec\'s canonical day-2 RCA scenario now works without `--resume` — typing `otto` in the same workspace surfaces `attached to <name> (from workspace, last used <relative>)`. 7-day staleness threshold; cross-workspace isolation; restored scratchpads cold-restart from disk via Phase 1\'s existing snapshot path.',
+            '**`/sp list` idle-age column (Issue #4).** Warm entries now show `active` (cell running) or `idle Xm` / `idle Xh` / `idle Xd` (floored minutes/hours/days since last use). Cold entries unchanged.',
+            '**`/sp evict <name> [--force]` slash command (Issue #4).** Releases a warm kernel without deleting the scratchpad — on-disk state (kernel.db, namespace.json, cells.jsonl) remains for cold-restart on next attach. Refuses on active cell unless `--force`. `--force` reuses the existing `runtime.cancel()` SIGINT→SIGTERM→SIGKILL escalation; skips snapshot since the kernel is dead post-cancel.',
+            '**`otto.duckdb.registerDf(name, input, opts?)` (Issue #1).** Duck-typed input detection for polars DataFrames, Arrow Tables, and arrays of records. First-10-rows null-walk schema inference covers sparse leading rows. Optional `opts.schema` override (accepts `Record<string, type>` or `Array<[col, type]>`). All-or-nothing semantics: partial-row failure drops the partial table so retries don\'t hit "Table already exists." Per-column failure attribution in error messages. `cw_scratchpad` `promptGuidelines` updated so the LLM reaches for the helper instead of API discovery — polars→DuckDB drops from ~8 cells to 2.',
+            '**Stale sidecar GC on init (Issue #67).** `sweepStaleSidecars` runs once at `session_start`. Deletes foreign-session sidecars where the referenced scratchpad is gone OR sidecar mtime is > 7 days old. Per-file try/catch isolation; current session\'s sidecar always protected.',
+        ],
+        fixed: [
+            '**`meta.json` on fresh `/sp new` reflects post-spawn disk state (Issue #2).** Previously showed `kernel_db.present: false` and `size_bytes: 0` because the initial `writeMeta` fired before `kernel.db` existed on disk. Added a second `writeMeta` call after `spawnRuntime` succeeds; the first call still preserves the lock-acquire side-effect.',
+        ],
+        changed: [
+            '**`/sp attach <name>` errors on typo (Issue #5).** Previously, `/sp attach <typo>` silently spawned a phantom scratchpad. Now errors with `scratchpad not found: <name>. Use /sp new <name> to create it.` Library `manager.getOrAttach` and the LLM tool path (`cw_scratchpad` action=exec) remain permissive — the asymmetry is intentional (LLM-passed names should auto-create; user-typed names should fail loud).',
+            '**Session sidecar filename format (Issue #66).** Renamed from `<sessionId>.json` to `sidecar_<sessionId>.json` for visual scan and `sidecar_*` glob. Old-format files become inert orphans (the sweep ignores anything without the `sidecar_` prefix). Users upgrading can manually `rm ~/.otto/scratchpads/_sessions/*.json` once if they want a clean slate; otherwise old files are harmless and persistent.',
+            '**`ScratchpadInfo` interface gains `hasActiveCell: boolean`.** Workspace-private package change with two internal consumers; no out-of-tree breakage.',
+        ],
+        notes: [
+            'Phase 1.5 closes the open known-issues backlog from `docs/superpowers/notes/2026-06-01-coworker-phase-1-known-issues.md` (Issues #1, #2, #4, #5, #6) and GH #66, #67.',
+            'Five follow-up items filed as #68–#72 for post-merge polish (workspace-pointer GC, `/sp evict <current>` sidecar question, `formatRelativeAge`/`hasActiveCell` overlap, `detectWorkspaceRoot` memoization, and dual-`writeMeta` doc comment).',
+            'Issue #3 (LLM "ask if unsure" reliability) remains accepted as inherent LLM behavior; revisited in Phase 6 (NOC persona polish).',
+            'See the Phase 1.5 re-verify section in `docs/superpowers/notes/2026-06-01-coworker-phase-1-human-tests.md` for the 11-scenario sign-off checklist.',
+        ],
+    },
+    {
+        version: '1.1.1',
+        date: '2026-05-29',
+        headline: 'Windows `otto update` no longer emits EPERM cleanup warnings or leaves orphan `.otto-*` staging dirs.',
+        added: [
+            '`update-status.json` written to `~/.otto/agent/` on every `otto update` — tracks `startedAt`, `completedAt`, `fromVersion`, `toVersion`, and `exitCode`. The next `otto update` prints "Last update: vX.Y.Z → vA.B.C at … (✓ success / ✗ exit N)" before checking the registry, so you can see whether a previous background update finished.',
+        ],
+        fixed: [
+            '`otto update` on Windows would log `EPERM: operation not permitted, unlink` warnings against `duckdb.dll`, `sharp.dll`, and `otto_engine.win32-x64.node` because the running otto.exe still held DLL handles. The install still succeeded but left orphan `.otto-RouGtD54`-style staging directories under `%APPDATA%\\npm\\node_modules\\@cmetech\\`. `otto update` now spawns a detached PowerShell bootstrap in a visible "OTTO Updater" console window that waits for the parent otto.exe to exit (max 30s), runs the install with locks released, sweeps the orphan staging dirs, and writes a completion status to `~/.otto/agent/update-status.json` that the next `otto update` surfaces. macOS / Linux behavior unchanged — POSIX inode semantics handle live-process replacement without the lock issue.',
+        ],
+        changed: [
+            '`/release-notes` data is now capped at the last 20 releases per npm tarball (override at build time via `OTTO_RELEASE_NOTES_CAP=<n>`; set `0` for unlimited). `CHANGELOG.md` stays the canonical full history; the runtime command shows a footer like "Bundled here: v1.0.5 → v1.2.0 (20 of 35 total). Older releases: github.com/cmetech/otto-cli/blob/main/CHANGELOG.md" when truncation is active. Keeps the shipped data file from growing unbounded as the project ages.',
+        ],
+    },
     {
         version: '1.1.0',
         date: '2026-05-29',

package/dist/resources/extensions/otto/commands/release-notes/command.js

@@ -11,7 +11,7 @@
  * count badge per entry, then full detail on selection. Output is written
  * to stdout so it lands in the chat transcript.
  */
-import { RELEASE_NOTES, countItems, findReleaseByVersion, getLatestRelease, } from "./_data.js";
+import { RELEASE_NOTES, RELEASE_NOTES_MANIFEST, countItems, findReleaseByVersion, getLatestRelease, } from "./_data.js";
 const USAGE = `Usage:
   /release-notes               Browse all releases interactively
   /release-notes <version>     Show a specific release (e.g. 1.0.7)
@@ -29,6 +29,13 @@ function renderSection(title, items) {
     const bulleted = items.map((line) => `- ${line}`).join("\n");
     return `\n### ${title}\n${bulleted}\n`;
 }
+function renderCapFooter() {
+    const m = RELEASE_NOTES_MANIFEST;
+    if (!m.truncated) {
+        return `${RELEASE_NOTES.length} releases tracked.`;
+    }
+    return `Bundled here: v${m.oldestBundled} → v${m.newestBundled} (${RELEASE_NOTES.length} of ${m.total} total).\nOlder releases: ${m.historyUrl}`;
+}
 function renderRelease(release) {
     const header = `# OTTO v${release.version} — ${release.date}`;
     const headline = release.headline ? `\n_${release.headline}_\n` : "";
@@ -38,7 +45,7 @@ function renderRelease(release) {
         renderSection("Changed", release.changed),
         renderSection("Notes", release.notes),
     ].join("");
-    const tail = `\n---\n${RELEASE_NOTES.length} releases tracked. Use \`/release-notes\` to browse, \`/release-notes <version>\` for any other release.`;
+    const tail = `\n---\n${renderCapFooter()}\nUse \`/release-notes\` to browse, \`/release-notes <version>\` for any other release.`;
     return `${header}${headline}${body}${tail}\n`;
 }
 function renderIndex() {
@@ -48,7 +55,7 @@ function renderIndex() {
         const headline = r.headline ? ` — ${r.headline}` : "";
         return `- v${r.version}  (${r.date}, ${badge})${headline}`;
     }).join("\n");
-    return `# OTTO release index\n\n${rows}\n\nView any release with \`/release-notes <version>\`.\n`;
+    return `# OTTO release index\n\n${rows}\n\n${renderCapFooter()}\nView any release with \`/release-notes <version>\`.\n`;
 }
 function findByVersionToken(token) {
     if (token === "latest")
@@ -71,7 +78,11 @@ export function registerReleaseNotesCommand(pi) {
             if (trimmed && trimmed !== "list") {
                 const match = findByVersionToken(trimmed);
                 if (!match) {
-                    postToChat(pi, `**No release found for \`${trimmed}\`**\n\nKnown versions: ${RELEASE_NOTES.map((r) => `v${r.version}`).join(", ")}`);
+                    const m = RELEASE_NOTES_MANIFEST;
+                    const truncationHint = m.truncated
+                        ? `\n\nThis OTTO build bundles ${RELEASE_NOTES.length} of ${m.total} total releases (v${m.oldestBundled} → v${m.newestBundled}). For older releases, see ${m.historyUrl}`
+                        : "";
+                    postToChat(pi, `**No release found for \`${trimmed}\`**\n\nKnown versions: ${RELEASE_NOTES.map((r) => `v${r.version}`).join(", ")}${truncationHint}`);
                     return;
                 }
                 postToChat(pi, renderRelease(match));

package/dist/resources/extensions/subagent/index.js

@@ -29,7 +29,7 @@ import { registerWorker, updateWorker } from "./worker-registry.js";
 import { loadEffectiveGSDPreferences } from "../workflow/preferences.js";
 import { emitJournalEvent } from "../workflow/journal.js";
 import { CmuxClient, shellEscape } from "../cmux/index.js";
-import { buildShellEnvAssignments, createSubagentLaunchPlan, isSubagentChildProcess, } from "./launch.js";
+import { buildShellEnvAssignments, createSubagentLaunchPlan, isSubagentChildProcess, mintSubagentScratchpadName, } from "./launch.js";
 import { SubagentRunStore, createInitialRunRecord, createSubagentTrackingName, deriveRunStatus, } from "./run-store.js";
 export { buildSubagentProcessArgs } from "./launch.js";
 const MAX_PARALLEL_TASKS = 8;
@@ -259,6 +259,7 @@ function resultToChildArtifact(result, index, cwd) {
         index,
         agent: result.agent,
         trackingName: result.trackingName,
+        scratchpadName: result.scratchpadName,
         task: result.task,
         status: running ? "running" : resultStatus(result),
         exitCode: result.exitCode,
@@ -365,6 +366,8 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             tmpPromptDir = tmp.dir;
             tmpPromptPath = tmp.filePath;
         }
+        const scratchpadName = mintSubagentScratchpadName(agent.name);
+        currentResult.scratchpadName = scratchpadName;
         const launch = createSubagentLaunchPlan({
             agent,
             task,
@@ -375,6 +378,7 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             session: sessionOverride,
             cwd,
             defaultCwd,
+            scratchpadName,
         });
         if (launch.session.mode === "fork")
             currentResult.sessionFile = launch.session.sessionFile;
@@ -493,6 +497,8 @@ async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defau
         }
         const bundledPaths = ((process.env.OTTO_BUNDLED_EXTENSION_PATHS ?? process.env.OTTO_BUNDLED_EXTENSION_PATHS) ?? "").split(path.delimiter).map((s) => s.trim()).filter(Boolean);
         const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
+        const scratchpadName = mintSubagentScratchpadName(agent.name);
+        currentResult.scratchpadName = scratchpadName;
         const launch = createSubagentLaunchPlan({
             agent,
             task,
@@ -503,6 +509,7 @@ async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defau
             session: sessionOverride,
             cwd,
             defaultCwd,
+            scratchpadName,
         });
         if (launch.session.mode === "fork")
             currentResult.sessionFile = launch.session.sessionFile;