@cmetech/otto 1.1.1 → 1.2.5

package/src/resources/extensions/coworker-vault/index.test.ts

@@ -0,0 +1,82 @@
+// src/resources/extensions/coworker-vault/index.test.ts
+//
+// Unit tests for the coworker-vault production activator.
+// Verifies command registration, session_start/shutdown lifecycle, init-failure
+// gating, and that the /connect handler doesn't surface "unavailable" on a happy
+// session_start.
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import coworkerVaultExtension from './index.js';
+import { makeFakeApi, fireSessionStart, fireSessionShutdown } from './test-helpers.js';
+
+describe('coworker-vault activator', () => {
+  it('registers /connect, /datasource, /audit commands at load time', () => {
+    const api = makeFakeApi();
+    coworkerVaultExtension(api.api);
+    assert.ok(api.commands.has('connect'), 'connect command registered');
+    assert.ok(api.commands.has('datasource'), 'datasource command registered');
+    assert.ok(api.commands.has('audit'), 'audit command registered');
+  });
+
+  it('session_start constructs bundle; session_shutdown clears it', async () => {
+    const api = makeFakeApi();
+    coworkerVaultExtension(api.api);
+    const ws = mkdtempSync(join(tmpdir(), 'vault-act-'));
+    process.env.OTTO_COWORKER_GLOBAL_DIR = mkdtempSync(join(tmpdir(), 'otto-global-'));
+    try {
+      await fireSessionStart(api, { cwd: ws });
+      assert.equal(
+        api.notifyCalls.filter(c => /unavailable/.test(c.message)).length,
+        0,
+        'no failure notify on happy path',
+      );
+      await fireSessionShutdown(api);
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+    }
+  });
+
+  it('init failure notifies + leaves commands registered (handlers gate on bundle)', async () => {
+    const api = makeFakeApi();
+    coworkerVaultExtension(api.api);
+    // Force createVaultBundle to fail by pointing at a non-writable path.
+    process.env.OTTO_COWORKER_GLOBAL_DIR = '/no/such/path/should/not/exist';
+    try {
+      await fireSessionStart(api, { cwd: '/tmp' });
+      const warn = api.notifyCalls.find(c => c.level === 'warning');
+      assert.ok(warn, 'expected a warning notify');
+      assert.match(warn!.message, /vault unavailable/);
+      // Calling the connect handler should notify "vault unavailable" and not throw.
+      const connect = api.commands.get('connect')!;
+      await connect.handler('', api.commandCtx);
+      const unavail = api.notifyCalls.filter(c => /unavailable/.test(c.message));
+      assert.ok(unavail.length >= 2, `expected ≥2 unavailable notices, got ${unavail.length}`);
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+    }
+  });
+
+  it('happy path: /connect handler runs without unavailable notice', async () => {
+    const api = makeFakeApi();
+    coworkerVaultExtension(api.api);
+    const ws = mkdtempSync(join(tmpdir(), 'vault-conn-'));
+    process.env.OTTO_COWORKER_GLOBAL_DIR = mkdtempSync(join(tmpdir(), 'otto-conn-'));
+    try {
+      await fireSessionStart(api, { cwd: ws });
+      const connect = api.commands.get('connect')!;
+      await connect.handler('', api.commandCtx);
+      // No "unavailable" notice should be emitted on a successful session_start;
+      // /connect may emit a usage notice (info), which is acceptable.
+      assert.equal(
+        api.notifyCalls.find(c => /unavailable/.test(c.message)),
+        undefined,
+        'no "unavailable" notice expected when bundle is healthy',
+      );
+    } finally {
+      delete process.env.OTTO_COWORKER_GLOBAL_DIR;
+    }
+  });
+});

package/src/resources/extensions/coworker-vault/index.ts

@@ -0,0 +1,181 @@
+// src/resources/extensions/coworker-vault/index.ts
+//
+// Coworker Vault production activator. Wires the Phase 2 command runners
+// (runConnect, runDatasourceList/Remove/Test, runAudit) into pi's
+// ExtensionAPI as /connect, /datasource, and /audit slash commands. Closes
+// the Phase 2 "Phase 2.1+ deferral" — vault commands are now reachable from
+// a live Otto session.
+import type { ExtensionAPI } from '@otto/pi-coding-agent';
+import { createVaultBundle, type VaultBundle, type VaultBundleOptions } from './vault-singleton.js';
+import { runConnect, type PromptFieldOptions } from './connect-command.js';
+import {
+  runDatasourceList,
+  runDatasourceRemove,
+  runDatasourceTest,
+} from './datasource-command.js';
+import { runAudit, type AuditQuery } from './audit-command.js';
+import { getCoworkerGlobalDir } from '../shared/coworker-paths.js';
+
+export { createVaultBundle };
+export type { VaultBundle, VaultBundleOptions };
+
+export default function coworkerVaultExtension(api: ExtensionAPI): void {
+  let bundle: VaultBundle | null = 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 as Error).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: string, opts: PromptFieldOptions): Promise<string> => {
+        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 as Error).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 as Error).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: AuditQuery = {};
+      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 as Error).message}`, 'error');
+      }
+    },
+  });
+
+  api.on('session_shutdown', async () => {
+    // Phase 2 VaultBundle has no async dispose path; clearing the reference is enough.
+    bundle = null;
+  });
+}

package/src/resources/extensions/coworker-vault/test-helpers.ts

@@ -0,0 +1,120 @@
+// 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';
+import type {
+  ExtensionAPI, ExtensionContext, ExtensionCommandContext, RegisteredCommand,
+  SessionStartEvent, SessionShutdownEvent, BeforeAgentStartEvent, AgentStartEvent,
+  ToolDefinition,
+} from '@otto/pi-coding-agent';
+
+export interface NotifyCall {
+  message: string;
+  level: 'info' | 'warning' | 'error' | 'success';
+}
+
+export interface FakeApi {
+  api: ExtensionAPI;
+  commands: Map<string, RegisteredCommand>;
+  tools: Map<string, ToolDefinition>;
+  handlers: Map<string, Array<(event: unknown, ctx: ExtensionContext) => Promise<unknown> | unknown>>;
+  notifyCalls: NotifyCall[];
+  ctx: ExtensionContext;
+  commandCtx: ExtensionCommandContext;
+}
+
+export function makeFakeApi(): FakeApi {
+  const commands = new Map<string, RegisteredCommand>();
+  const tools = new Map<string, ToolDefinition>();
+  const handlers = new Map<string, Array<(event: unknown, ctx: ExtensionContext) => Promise<unknown> | unknown>>();
+  const notifyCalls: NotifyCall[] = [];
+
+  const ui = {
+    notify: (message: string, level?: 'info' | 'warning' | 'error' | 'success'): void => {
+      notifyCalls.push({ message, level: level ?? 'info' });
+    },
+    confirm: async (): Promise<boolean> => true,
+    input: async (): Promise<string | undefined> => '',
+    select: async (): Promise<string | string[] | undefined> => undefined,
+  } as unknown as ExtensionContext['ui'];
+
+  const ctx = {
+    cwd: tmpdir(),
+    hasUI: true,
+    ui,
+    sessionManager: {
+      getSessionFile: (): string | undefined => join(tmpdir(), 'session.jsonl'),
+    },
+    isIdle: (): boolean => true,
+    abort: (): void => {},
+    hasPendingMessages: (): boolean => false,
+    shutdown: (): void => {},
+    getContextUsage: (): undefined => undefined,
+    compact: (): void => {},
+    getSystemPrompt: (): string => '',
+    setCompactionThresholdOverride: (): void => {},
+  } as unknown as ExtensionContext;
+
+  const commandCtx = ctx as unknown as ExtensionCommandContext;
+
+  const api = {
+    on(event: string, handler: (event: unknown, ctx: ExtensionContext) => Promise<unknown> | unknown): void {
+      if (!handlers.has(event)) handlers.set(event, []);
+      handlers.get(event)!.push(handler);
+    },
+    registerCommand(name: string, options: Omit<RegisteredCommand, 'name'>): void {
+      commands.set(name, { name, ...options });
+    },
+    registerTool(tool: ToolDefinition): void {
+      tools.set(tool.name, tool);
+    },
+    sendMessage(): void {},
+  } as unknown as ExtensionAPI;
+
+  return { api, commands, tools, handlers, notifyCalls, ctx, commandCtx };
+}
+
+export async function fireSessionStart(fake: FakeApi, opts: { cwd: string }): Promise<void> {
+  const evt: SessionStartEvent = { type: 'session_start' };
+  // Mutate the fake.ctx so handlers see the requested cwd.
+  (fake.ctx as { cwd: string }).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: FakeApi): Promise<void> {
+  const evt: SessionShutdownEvent = { 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: FakeApi,
+  prompt: string,
+  systemPrompt: string,
+): Promise<{ systemPrompt?: string } | undefined> {
+  const evt: BeforeAgentStartEvent = { type: 'before_agent_start', prompt, systemPrompt };
+  const list = fake.handlers.get('before_agent_start') ?? [];
+  let result: { systemPrompt?: string } | undefined;
+  for (const h of list) {
+    const r = await h(evt, fake.ctx);
+    if (r && typeof r === 'object' && 'systemPrompt' in r) {
+      result = r as { systemPrompt?: string };
+    }
+  }
+  return result;
+}
+
+export async function fireAgentStart(
+  fake: FakeApi,
+  sessionId: string,
+  turnId: string,
+): Promise<void> {
+  const evt: AgentStartEvent = { type: 'agent_start', sessionId, turnId };
+  const list = fake.handlers.get('agent_start') ?? [];
+  for (const h of list) await h(evt, fake.ctx);
+}

package/src/resources/extensions/coworker-vault/vault-singleton.test.ts

@@ -0,0 +1,27 @@
+// src/resources/extensions/coworker-vault/vault-singleton.test.ts
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createVaultBundle } from './vault-singleton.js';
+
+describe('vault singleton bundle', () => {
+  it('constructs vault, audit, and registry for given roots', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'vault-bundle-'));
+    const b = await createVaultBundle({ globalDir: join(root, 'global'), workspaceDir: undefined });
+    assert.ok(b.vault);
+    assert.ok(b.audit);
+    assert.ok(b.registry);
+    assert.ok(b.registry.get('jira'));
+  });
+
+  it('honors workspace dir when provided', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'vault-bundle-ws-'));
+    const b = await createVaultBundle({
+      globalDir: join(root, 'global'),
+      workspaceDir: join(root, 'workspace'),
+    });
+    assert.deepEqual(await b.vault.list(), []);
+  });
+});

package/src/resources/extensions/coworker-vault/vault-singleton.ts

@@ -0,0 +1,40 @@
+// 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 interface VaultBundleOptions {
+  /** Defaults to ~/.otto */
+  globalDir?: string;
+  /** Optional workspace root (NOT including .otto suffix). */
+  workspaceDir?: string;
+}
+
+export interface VaultBundle {
+  vault: LocalDataVault;
+  audit: AuditLog;
+  registry: EngineRegistry;
+  globalDir: string;
+  workspaceDir?: string;
+}
+
+export async function createVaultBundle(opts: VaultBundleOptions = {}): Promise<VaultBundle> {
+  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/src/resources/extensions/otto/commands/release-notes/_data.ts

@@ -3,6 +3,10 @@
 //
 // 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 interface ReleaseNote {
 	version: string;
@@ -14,7 +18,97 @@ export interface ReleaseNote {
 	notes?: string[];
 }
 
+export interface ReleaseNotesManifest {
+	/** True when older releases exist in CHANGELOG.md but weren't bundled. */
+	truncated: boolean;
+	/** Total releases in CHANGELOG.md at build time (incl. truncated ones). */
+	total: number;
+	/** Oldest version included in the bundle. */
+	oldestBundled: string;
+	/** Newest version included in the bundle. */
+	newestBundled: string;
+	/** Where to read full history when the bundle has been truncated. */
+	historyUrl: string;
+}
+
+export const RELEASE_NOTES_MANIFEST: ReleaseNotesManifest = {
+	truncated: false,
+	total: 14,
+	oldestBundled: '1.0.0',
+	newestBundled: '1.2.5',
+	historyUrl: 'https://github.com/cmetech/otto-cli/blob/main/CHANGELOG.md',
+};
+
 export const RELEASE_NOTES: ReleaseNote[] = [
+	{
+		version: '1.2.5',
+		date: '2026-06-03',
+		headline: 'Windows-install hotfix: silences three startup errors that fired the first time `otto` launched after a global npm install, and stops the otto extension from racing the TUI welcome banner with raw stderr writes.',
+		fixed: [
+			'**`_coworker-paths.js` "Extension does not export a valid factory function".** The shared helper module sat at the top of `src/resources/extensions/` so the pi-coding-agent extension discovery (`discoverExtensionsInDir`) walked it as an extension candidate. Moved to `src/resources/extensions/shared/coworker-paths.{ts,test.ts}` (subdir is skipped by `resolveExtensionEntries` because it has no `index.ts`/`package.json`). The three coworker-{memory,scratchpad,vault}/index.ts importers were updated in lockstep.',
+			'**`Cannot find module \'better-sqlite3\'` on global install.** `better-sqlite3` was declared only in `packages/coworker-memory/package.json`. Because npm only resolves the root manifest for end users of a published tarball, the native module was never installed and `@otto/coworker-memory`\'s eager re-export of `local-sqlite-backend.js` blew up at first import. Hoisted `better-sqlite3@^11.7.0` into root `dependencies`.',
+			'**`/audit` slash-command conflict between coworker-vault and slash-commands.** Both extensions registered the same id; the vault command (the real Phase 2 reader) supersedes, but the conflict warning fired every launch. Renamed the slash-commands command to `/audit-codebase` (file + manifest + dispatch updated).',
+			'**Otto session_start bled raw stderr into the TUI welcome banner.** The gateway + langflow probes wrote ANSI-colored status lines directly to `process.stderr` while the pi TUI was still painting; on Windows the rendered output collided with the yellow `─` rule and overwrote the prompt area. Now routes status through `ctx.ui.setStatus("otto-gateway"|"otto-langflow", ...)` when `ctx.hasUI` is true; falls back to stderr only in headless/RPC modes.',
+			'**Duplicate "OTTO" brand on the no-project landing.** The `gsd-health` widget\'s no-project line began with `"  OTTO  No project loaded — …"`, which appeared alongside the ASCII OTTO logo in the welcome header — looking like the brand was loading twice. Dropped the `OTTO ` prefix; the header already brands the session.',
+		],
+	},
+	{
+		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',
@@ -25,6 +119,9 @@ export const RELEASE_NOTES: ReleaseNote[] = [
 		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',

package/src/resources/extensions/otto/commands/release-notes/command.ts

@@ -15,6 +15,7 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@otto/pi-coding-agent";
 import {
 	RELEASE_NOTES,
+	RELEASE_NOTES_MANIFEST,
 	countItems,
 	findReleaseByVersion,
 	getLatestRelease,
@@ -40,6 +41,14 @@ function renderSection(title: string, items: string[] | undefined): string {
 	return `\n### ${title}\n${bulleted}\n`;
 }
 
+function renderCapFooter(): string {
+	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: ReleaseNote): string {
 	const header = `# OTTO v${release.version} — ${release.date}`;
 	const headline = release.headline ? `\n_${release.headline}_\n` : "";
@@ -49,7 +58,7 @@ function renderRelease(release: ReleaseNote): string {
 		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`;
 }
 
@@ -60,7 +69,7 @@ function renderIndex(): string {
 		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: string): ReleaseNote | undefined {
@@ -87,9 +96,13 @@ export function registerReleaseNotesCommand(pi: ExtensionAPI): void {
 			if (trimmed && trimmed !== "list") {
 				const match = findByVersionToken(trimmed);
 				if (!match) {
+					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(", ")}`,
+						`**No release found for \`${trimmed}\`**\n\nKnown versions: ${RELEASE_NOTES.map((r) => `v${r.version}`).join(", ")}${truncationHint}`,
 					);
 					return;
 				}