@cmetech/otto 1.1.0 → 1.2.4

package/dist/resources/extensions/coworker-memory/memory-command.js

@@ -0,0 +1,157 @@
+import { runMemorize } from './memorize-tool.js';
+import { runRecall } from './recall-tool.js';
+export async function runMemoryCommand(bundle, argv) {
+    const [sub, ...rest] = argv;
+    switch (sub) {
+        case 'note': {
+            const text = rest.join(' ').trim();
+            if (!text)
+                throw new Error('Usage: /memory note <text>');
+            await runMemorize(bundle, { text, kind: 'lesson', scope: 'workspace' });
+            return { message: `lesson stored in workspace.` };
+        }
+        case 'status': {
+            const status = await bundle.backend.status();
+            return {
+                message: [
+                    `scope_mode: ${bundle.scopeMode}`,
+                    `workspace_wing: ${bundle.workspaceWing}`,
+                    `drawer_count: ${status.drawer_count}`,
+                    `layer_b_db_path: ${status.layer_b_db_path}`,
+                    `schema_version: ${status.schema_version}`,
+                ].join('\n'),
+            };
+        }
+        case 'clear': {
+            let wing;
+            let confirm = false;
+            for (let i = 0; i < rest.length; i++) {
+                if (rest[i] === '--wing' && rest[i + 1]) {
+                    wing = rest[++i];
+                }
+                else if (rest[i] === '--confirm') {
+                    confirm = true;
+                }
+            }
+            if (!confirm)
+                throw new Error('Usage: /memory clear --wing <wing> --confirm');
+            const out = await bundle.backend.clear({ wing, confirm: true });
+            return { message: `deleted: ${out.deleted}` };
+        }
+        case 'wing':
+        case 'room': {
+            // Session overrides — caller manages state; this is a placeholder return acknowledging.
+            const target = rest.join(' ').trim();
+            if (!target)
+                throw new Error(`Usage: /memory ${sub} <name>`);
+            return { message: `${sub} override: ${target}` };
+        }
+        case 'seed': {
+            // Caller wires this to applyPersonaSeed via session-hooks; here we just acknowledge the request.
+            return { message: 're-seed will run on next session_start; flip workspace.json.memory_seed_applied=false and reattach.' };
+        }
+        case 'show': {
+            let target = 'all';
+            let scopeOverride = null;
+            for (let i = 0; i < rest.length; i++) {
+                const t = rest[i];
+                if (t === '--scope' && rest[i + 1]) {
+                    const s = rest[++i];
+                    if (s !== 'workspace' && s !== 'global')
+                        throw new Error(`Usage: /memory show [profile|rules|lessons] [--scope workspace|global]`);
+                    scopeOverride = s;
+                }
+                else if (t === 'profile') {
+                    target = 'profile';
+                }
+                else if (t === 'rule' || t === 'rules') {
+                    target = 'rule';
+                }
+                else if (t === 'lesson' || t === 'lessons') {
+                    target = 'lesson';
+                }
+                else if (t === 'all') {
+                    target = 'all';
+                }
+                else {
+                    throw new Error(`Usage: /memory show [profile|rules|lessons] [--scope workspace|global]`);
+                }
+            }
+            const kinds = target === 'all' ? ['profile', 'rule', 'lesson'] : [target];
+            // Determine scopes: --scope override wins; otherwise derive from bundle.scopeMode.
+            const scopes = [];
+            if (scopeOverride === 'workspace') {
+                scopes.push({ name: 'workspace', store: bundle.workspaceLayerA });
+            }
+            else if (scopeOverride === 'global') {
+                scopes.push({ name: 'global', store: bundle.globalLayerA });
+            }
+            else if (bundle.scopeMode === 'global') {
+                scopes.push({ name: 'global', store: bundle.globalLayerA });
+            }
+            else if (bundle.scopeMode === 'per-project') {
+                scopes.push({ name: 'workspace', store: bundle.workspaceLayerA });
+            }
+            else {
+                // per-project-tagged: workspace first, then global
+                scopes.push({ name: 'workspace', store: bundle.workspaceLayerA });
+                scopes.push({ name: 'global', store: bundle.globalLayerA });
+            }
+            const TITLE_FOR = { profile: 'Profile', rule: 'Rules', lesson: 'Lessons' };
+            const sections = [];
+            for (const k of kinds) {
+                for (const scope of scopes) {
+                    const body = await scope.store.read(k);
+                    sections.push(`## ${TITLE_FOR[k]} (${scope.name})\n${body || '(none)'}`);
+                }
+            }
+            return { message: sections.join('\n\n') };
+        }
+        case 'recall': {
+            // First flag/positional split: gather positional tokens for the query;
+            // recognize --kind, --room, --wing, --limit, --days_back.
+            const flags = {};
+            const queryTokens = [];
+            for (let i = 0; i < rest.length; i++) {
+                const t = rest[i];
+                if (t === '--kind' && rest[i + 1]) {
+                    flags.kind = rest[++i];
+                }
+                else if (t === '--room' && rest[i + 1]) {
+                    flags.room = rest[++i];
+                }
+                else if (t === '--wing' && rest[i + 1]) {
+                    flags.wing = rest[++i];
+                }
+                else if (t === '--limit' && rest[i + 1]) {
+                    const n = parseInt(rest[++i], 10);
+                    if (Number.isFinite(n))
+                        flags.limit = n;
+                }
+                else if (t === '--days_back' && rest[i + 1]) {
+                    const n = parseInt(rest[++i], 10);
+                    if (Number.isFinite(n))
+                        flags.days_back = n;
+                }
+                else {
+                    queryTokens.push(t);
+                }
+            }
+            const query = queryTokens.join(' ').trim();
+            if (!query)
+                throw new Error('Usage: /memory recall <query> [--kind <k>] [--room <r>] [--wing <w>] [--limit N] [--days_back N]');
+            // Defer to the same runRecall the LLM tool uses for parity.
+            const out = await runRecall(bundle, {
+                query,
+                kind: flags.kind, // runRecall accepts string; backend validates
+                room: flags.room,
+                wing: flags.wing,
+                max_results: flags.limit,
+                days_back: flags.days_back,
+            });
+            return { message: out.markdown };
+        }
+        default:
+            throw new Error(`Unknown /memory subcommand: ${sub}. Try: note, status, clear, wing, room, seed, show, recall.`);
+    }
+}

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

@@ -0,0 +1,55 @@
+// src/resources/extensions/coworker-memory/memory-singleton.ts
+//
+// Factory that constructs the layered memory collaborators (LayerAStore x2,
+// LocalSqliteBackend, MemoryRecorder) plus shared audit + secret scanner for
+// given roots. Mirrors the coworker-vault singleton pattern. Pure beyond what
+// the underlying constructors already perform (dir creation, db open, etc.).
+import { join } from 'node:path';
+import { AuditLog, SecretScanner } from '@otto/coworker-utils';
+import { LayerAStore, LocalSqliteBackend, MemoryRecorder, resolveScope, resolveWorkspaceId, } from '@otto/coworker-memory';
+export async function createMemoryBundle(opts) {
+    const audit = new AuditLog({ path: join(opts.globalDir, 'audit.jsonl') });
+    const scanner = new SecretScanner();
+    const wsRecord = await resolveWorkspaceId(opts.workspaceDir);
+    const scope = resolveScope({ mode: opts.scopeMode, workspaceId: wsRecord.id });
+    const globalLayerA = new LayerAStore({
+        scopeDir: join(opts.globalDir, 'memory'),
+        scope: 'global',
+        audit,
+        scanner,
+    });
+    const workspaceLayerA = new LayerAStore({
+        scopeDir: join(opts.workspaceDir, '.otto', 'memory'),
+        scope: 'workspace',
+        audit,
+        scanner,
+    });
+    const backend = new LocalSqliteBackend({
+        dbPath: join(opts.workspaceDir, '.otto', 'memory', 'layer-b.db'),
+    });
+    await backend.open();
+    const recorder = new MemoryRecorder({
+        backend,
+        scanner,
+        audit,
+        writeWing: scope.writeWing,
+        currentScratchpadName: opts.currentScratchpadName,
+    });
+    return {
+        globalLayerA,
+        workspaceLayerA,
+        backend,
+        recorder,
+        audit,
+        scanner,
+        workspaceWing: wsRecord.id,
+        writeWing: scope.writeWing,
+        readWings: scope.readWings,
+        scopeMode: opts.scopeMode,
+        workspaceRecord: wsRecord,
+        workspaceDir: opts.workspaceDir,
+        async dispose() {
+            await backend.close();
+        },
+    };
+}

package/dist/resources/extensions/coworker-memory/recall-tool.js

@@ -0,0 +1,18 @@
+import { formatRecall } from '@otto/coworker-memory';
+export async function runRecall(bundle, args) {
+    const wings = args.wing ? [args.wing, ...bundle.readWings.filter(w => w !== args.wing)] : bundle.readWings;
+    const limit = args.max_results === undefined ? 8 : Math.min(Math.max(args.max_results, 1), 64);
+    const results = await bundle.backend.recall({
+        query: args.query, wing: wings, room: args.room, kind: args.kind,
+        days_back: args.days_back, max_results: limit,
+    });
+    bundle.audit.append({
+        _schema: 1, ts: new Date().toISOString(), producer: 'memory', action: 'recall',
+        detail: {
+            wing_filter: wings, room_filter: args.room ?? null,
+            kind_filter: args.kind ?? null, days_back: args.days_back ?? null,
+            result_count: results.length,
+        },
+    });
+    return { results, markdown: formatRecall(results) };
+}

package/dist/resources/extensions/coworker-memory/session-hooks.js

@@ -0,0 +1,45 @@
+// src/resources/extensions/coworker-memory/session-hooks.ts
+//
+// Session lifecycle seams for the coworker-memory extension.
+// - onSessionStart: applies a one-shot persona seed (if pending) and returns
+//   the Layer A context block ready for system-prompt injection.
+// - onSessionShutdown: closes the backend (Layer B). Safe to double-call —
+//   LocalSqliteBackend.close() nulls its db handle so a second close is a no-op.
+import { buildLayerAContext, applyPersonaSeed, writeWorkspaceId } from '@otto/coworker-memory';
+export async function onSessionStart(bundle, opts = {}) {
+    let seed = { copied: [], blocked: [] };
+    if (opts.persona && !bundle.workspaceRecord.memory_seed_applied) {
+        seed = await applyPersonaSeed({
+            personaId: opts.persona.id,
+            personaDir: opts.persona.personaDir,
+            store: bundle.workspaceLayerA,
+        });
+        if (seed.copied.length > 0 || seed.blocked.length > 0) {
+            bundle.workspaceRecord.memory_seed_applied = true;
+            bundle.workspaceRecord.memory_seed_persona = opts.persona.id;
+            await writeWorkspaceId(bundle.workspaceDir, bundle.workspaceRecord);
+            bundle.audit.append({
+                _schema: 1,
+                ts: new Date().toISOString(),
+                producer: 'memory',
+                action: 'seed-applied',
+                detail: {
+                    persona_id: opts.persona.id,
+                    files_copied: seed.copied,
+                    files_blocked: seed.blocked,
+                },
+            });
+        }
+    }
+    const contextBlock = await buildLayerAContext({
+        mode: bundle.scopeMode,
+        globalStore: bundle.globalLayerA,
+        workspaceStore: bundle.workspaceLayerA,
+        tokenLimit: opts.tokenLimit ?? 3000,
+    });
+    return { contextBlock, seed };
+}
+export async function onSessionShutdown(bundle) {
+    // WAL checkpoint happens on backend close; this is the seam.
+    await bundle.dispose();
+}

package/dist/resources/extensions/coworker-scratchpad/attach-banners.js

@@ -0,0 +1,53 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function showRecoveryNotesBanner(name, rootDir, ui) {
+    const metaPath = join(rootDir, name, 'meta.json');
+    if (!existsSync(metaPath))
+        return { unseenCount: 0, markSeen: false };
+    let meta;
+    try {
+        meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+    }
+    catch {
+        return { unseenCount: 0, markSeen: false };
+    }
+    const notes = Array.isArray(meta.recovery_notes) ? meta.recovery_notes : [];
+    if (notes.length === 0)
+        return { unseenCount: 0, markSeen: false };
+    const seenAt = typeof meta.recovery_notes_seen_at === 'string' ? meta.recovery_notes_seen_at : null;
+    const unseen = notes.filter((n) => seenAt === null || n.at > seenAt);
+    if (unseen.length === 0)
+        return { unseenCount: 0, markSeen: false };
+    const head = unseen.slice(0, 5).map(formatNoteLine).join('\n');
+    const tail = unseen.length > 5 ? `\n+ ${unseen.length - 5} more (run /sp notes)` : '';
+    ui.notify(`⚠ ${unseen.length} unread recovery notes:\n${head}${tail}`, 'warning');
+    return { unseenCount: unseen.length, markSeen: true };
+}
+export function showDivergenceBanner(name, rootDir, ui) {
+    const metaPath = join(rootDir, name, 'meta.json');
+    if (!existsSync(metaPath))
+        return { diverged: false };
+    let meta;
+    try {
+        meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+    }
+    catch {
+        return { diverged: false };
+    }
+    const leaf = typeof meta.cell_leaf_id === 'number' ? meta.cell_leaf_id : null;
+    const kernel = typeof meta.kernel_at_cell_id === 'number' ? meta.kernel_at_cell_id : null;
+    if (leaf === null || kernel === null || leaf === kernel)
+        return { diverged: false };
+    ui.notify(`ℹ kernel state is at cell #${kernel}; view is at cell #${leaf} (run /sp tree to inspect)`, 'info');
+    return { diverged: true };
+}
+export function formatNoteLine(n) {
+    const ts = n.at.slice(0, 19);
+    switch (n.kind) {
+        case 'snapshot-failed': return `  • [${ts}] snapshot-failed: ${n.message}`;
+        case 'cells-since-snapshot': return `  • [${ts}] ${n.n} cells since last snapshot`;
+        case 'namespace-corrupt': return `  • [${ts}] namespace-corrupt: ${n.message}`;
+        case 'namespace-absent': return `  • [${ts}] namespace-absent`;
+        default: return `  • [${ts}] ${n.kind}`;
+    }
+}

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

@@ -0,0 +1,13 @@
+{
+  "id": "coworker-scratchpad",
+  "name": "Co-worker Scratchpad",
+  "version": "1.0.0",
+  "description": "Persistent TypeScript scratchpad kernel: /sp slash commands and cw_scratchpad tool with MIME bundle responses",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["cw_scratchpad"],
+    "commands": ["sp"],
+    "hooks": ["session_start", "session_shutdown"]
+  }
+}

package/dist/resources/extensions/coworker-scratchpad/format-age.js

@@ -0,0 +1,9 @@
+export function formatRelativeAge(ageMs) {
+    if (ageMs < 30_000)
+        return 'active';
+    if (ageMs < 60 * 60_000)
+        return `idle ${Math.floor(ageMs / 60_000)}m`;
+    if (ageMs < 24 * 60 * 60_000)
+        return `idle ${Math.floor(ageMs / (60 * 60_000))}h`;
+    return `idle ${Math.floor(ageMs / (24 * 60 * 60_000))}d`;
+}

package/dist/resources/extensions/coworker-scratchpad/helpers.js

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const SCRATCHPAD_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+export function validateName(name) {
+    if (!SCRATCHPAD_NAME_REGEX.test(name)) {
+        throw new Error(`invalid scratchpad name: ${JSON.stringify(name)} (must match ${SCRATCHPAD_NAME_REGEX})`);
+    }
+}
+export function readCellsJsonl(dir) {
+    const path = join(dir, 'cells.jsonl');
+    if (!existsSync(path))
+        return { cells: [], total_cells: 0 };
+    const cells = [];
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (typeof obj.id === 'number')
+                cells.push(obj);
+        }
+        catch {
+            // header line or trailing corrupt line -> skip (same tolerance as CellArchive.scan)
+        }
+    }
+    return { cells, total_cells: cells.length };
+}
+export function readPersistedLeaf(metaPath) {
+    if (!existsSync(metaPath))
+        return null;
+    try {
+        const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+        return typeof meta.cell_leaf_id === 'number' ? meta.cell_leaf_id : null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,199 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { ScratchpadManager } from '@otto/coworker-scratchpad';
+import { getScratchpadsRoot } from '../_coworker-paths.js';
+import { getMemoryRecorder } from '../coworker-memory/index.js';
+import { getArtifactStore } from '../coworker-artifacts/index.js';
+import { registerSpCommand } from './sp-command.js';
+import { registerScratchpadTool } from './scratchpad-tool.js';
+import { sessionSidecarPath, readSessionSidecar, deleteSessionSidecar, sweepStaleSidecars } from './session-sidecar.js';
+import { detectWorkspaceRoot } from './workspace-root.js';
+import { workspaceHash, workspacePointerPath, readWorkspacePointer, isPointerFresh } from './workspace-pointer.js';
+import { formatRelativeAge } from './format-age.js';
+function deriveSessionId(ctx) {
+    const file = ctx.sessionManager.getSessionFile();
+    if (!file)
+        return 'default';
+    const base = basename(file);
+    return base.endsWith('.jsonl') ? base.slice(0, -6) : base;
+}
+/**
+ * Computes restore precedence with sidecar-fallback. Returns the scratchpad to restore
+ * (if any) and the notice string to surface to the user. Does NOT call ctx.ui.notify —
+ * the caller does.
+ *
+ * Side-effect: deletes a broken sidecar (one whose referenced scratchpad no longer
+ * exists) so subsequent fresh sessions don't repeatedly re-check it. Not a pure
+ * function — a cleanup-closure refactor was considered and rejected as over-engineering
+ * for a single in-process call site.
+ *
+ * Precedence:
+ *   (a) per-session sidecar — wins when its scratchpad still exists on disk.
+ *   (b) broken sidecar — silently deleted, falls through to (c).
+ *   (c) workspace pointer — fresh (≤ 7d) AND its scratchpad still exists on disk.
+ *   (d) no restore.
+ */
+export function tryRestoreCurrentName(root, sessionId, cwd, now) {
+    // (a) Sidecar restore
+    const sidecarPath = sessionSidecarPath(root, sessionId);
+    const sidecar = readSessionSidecar(sidecarPath);
+    if (sidecar) {
+        const meta = join(root, sidecar.current_name, 'meta.json');
+        if (existsSync(meta)) {
+            return { name: sidecar.current_name, notice: `attached to ${sidecar.current_name} (restored)` };
+        }
+        deleteSessionSidecar(sidecarPath); // broken sidecar — clean up silently and fall through
+    }
+    // (b) Workspace-pointer fallback
+    const wsRoot = detectWorkspaceRoot(cwd);
+    const ptr = readWorkspacePointer(workspacePointerPath(root, workspaceHash(wsRoot)));
+    if (ptr && isPointerFresh(ptr, now)) {
+        const meta = join(root, ptr.last_current_name, 'meta.json');
+        if (existsSync(meta)) {
+            const rel = formatRelativeAge(now - Date.parse(ptr.last_attached_at));
+            return {
+                name: ptr.last_current_name,
+                notice: `attached to ${ptr.last_current_name} (from workspace, last used ${rel})`,
+            };
+        }
+    }
+    // (c) No restore
+    return { name: null, notice: null };
+}
+const SUBAGENT_NAME_REGEX = /^subagent-[a-z0-9-]+$/;
+/**
+ * Phase 4.5: When the OTTO_SUBAGENT_SCRATCHPAD env var is set, force-attach
+ * to the named scratchpad (creating it if needed) BEFORE the sidecar/pointer
+ * restore path runs. Idempotent: re-running with same name attaches without
+ * overwriting existing state.
+ */
+export function forceSubagentAttach(name, scratchpadsRoot) {
+    if (!SUBAGENT_NAME_REGEX.test(name) || name.length > 80) {
+        return { ok: false, reason: `invalid subagent scratchpad name: ${name}` };
+    }
+    const dir = join(scratchpadsRoot, name);
+    try {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+        const metaPath = join(dir, 'meta.json');
+        if (!existsSync(metaPath)) {
+            const meta = {
+                name,
+                schema_version: 1,
+                created_at: new Date().toISOString(),
+                source: 'subagent-dispatch',
+            };
+            writeFileSync(metaPath, JSON.stringify(meta, null, 2), { mode: 0o600 });
+        }
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, reason: err.message };
+    }
+}
+export default function coworkerScratchpadExtension(pi) {
+    let manager = null;
+    let workspaceCwd = null;
+    let sessionId = null;
+    let currentName = null;
+    const root = getScratchpadsRoot();
+    const getManager = () => {
+        if (!manager) {
+            if (!workspaceCwd)
+                throw new Error('scratchpad: manager requested before session_start');
+            manager = new ScratchpadManager({
+                workspace: workspaceCwd,
+                root,
+                sessionId: sessionId ?? 'default',
+                // Phase 4 Task 11/12: lazy getter for the artifact store — returns null
+                // before artifacts session_start or after session_shutdown. Cross-pillar
+                // wiring is one-way (scratchpad → artifacts), so activator load order
+                // is indifferent.
+                getArtifactStore,
+                // Phase 3.1 Task 4: production hop into memory. `getMemoryRecorder()` is
+                // called lazily on each event so activator load order is indifferent —
+                // returns null before memory session_start or after session_shutdown,
+                // which is the correct no-op signal. Failures are swallowed silently
+                // (spec §3.8): file loads are frequent and a memory backend hiccup must
+                // not break the kernel runtime; surfaces in /audit instead.
+                onDataLoad: (drawer, scratchpadName) => {
+                    const recorder = getMemoryRecorder();
+                    if (!recorder)
+                        return;
+                    void recorder.recordFileLoad({
+                        scratchpadName,
+                        collector: drawer.collector,
+                        uri: drawer.uri,
+                        bytes: drawer.bytes ?? 0,
+                        rows_loaded: drawer.rows_loaded ?? undefined,
+                        schema: drawer.schema ?? undefined,
+                        turnId: '',
+                    }).catch(() => { });
+                },
+                // Phase 4 Task 12: production hop into memory for artifact-create events.
+                // Mirrors the onDataLoad pattern: lazy recorder lookup, silent failures
+                // (spec §3.9). drawer.artifact_kind is the actual artifact kind
+                // (e.g. 'report'); drawer.kind is the discriminator literal 'artifact'.
+                onArtifactCreate: (drawer, scratchpadName) => {
+                    const recorder = getMemoryRecorder();
+                    if (!recorder)
+                        return;
+                    void recorder.recordArtifact({
+                        scratchpadName,
+                        slug: drawer.slug,
+                        kind: drawer.artifact_kind,
+                        uri: drawer.uri,
+                        turnId: '',
+                    }).catch(() => { });
+                },
+            });
+        }
+        return manager;
+    };
+    const getCurrentName = () => currentName;
+    const setCurrentName = (n) => { currentName = n; };
+    const rootDir = () => root;
+    const getSessionId = () => sessionId ?? 'default';
+    const getWorkspaceCwd = () => workspaceCwd ?? process.cwd();
+    registerSpCommand(pi, { getManager, getCurrentName, setCurrentName, rootDir, getSessionId, getWorkspaceCwd });
+    registerScratchpadTool(pi, { getManager, getCurrentName, setCurrentName, rootDir });
+    pi.on('session_start', async (_event, ctx) => {
+        workspaceCwd = ctx.cwd;
+        sessionId = deriveSessionId(ctx);
+        // Phase 4.5: force-attach to subagent scratchpad if OTTO_SUBAGENT_SCRATCHPAD is set.
+        const subagentName = process.env.OTTO_SUBAGENT_SCRATCHPAD;
+        if (subagentName) {
+            const result = forceSubagentAttach(subagentName, root);
+            if (result.ok) {
+                currentName = subagentName;
+                ctx.ui.notify(`attached to ${subagentName} (subagent dispatch)`, 'info');
+                try {
+                    sweepStaleSidecars(root, sessionId, Date.now());
+                }
+                catch { /* silent */ }
+                return;
+            }
+            ctx.ui.notify(`subagent scratchpad attach failed: ${result.reason}; continuing without`, 'warning');
+            // fall through to normal restore
+        }
+        const restore = tryRestoreCurrentName(root, sessionId, ctx.cwd ?? process.cwd(), Date.now());
+        if (restore.name) {
+            currentName = restore.name;
+            ctx.ui.notify(restore.notice, 'info');
+        }
+        // When neither sidecar nor fresh pointer resolves to an existing scratchpad,
+        // we stay silent — the user gets a clean session_start with no noise.
+        try {
+            sweepStaleSidecars(root, sessionId, Date.now());
+        }
+        catch { /* sweep failures are silent */ }
+    });
+    pi.on('session_shutdown', async () => {
+        if (manager) {
+            await manager.disposeAll();
+            manager = null;
+        }
+        // Sidecar deliberately NOT deleted here — survives so /resume restores.
+    });
+}

package/dist/resources/extensions/coworker-scratchpad/mime-bundle.js

@@ -0,0 +1,20 @@
+export function deriveMimeBundle(value, stdout) {
+    const bundle = {};
+    if (stdout.length > 0)
+        bundle['text/plain'] = stdout;
+    if (value !== undefined && value !== null)
+        bundle['application/json'] = value;
+    if (typeof value === 'string' && looksLikeMarkdown(value)) {
+        bundle['text/markdown'] = value;
+    }
+    return bundle;
+}
+function looksLikeMarkdown(s) {
+    const trimmed = s.trimStart();
+    if (trimmed.startsWith('#') || trimmed.startsWith('|'))
+        return true;
+    // GFM table separator row: a line that is just |---|---|...
+    if (/\n\s*\|[-:|\s]+\|\s*\n/.test(s))
+        return true;
+    return false;
+}