@cmetech/otto 1.1.0 → 1.2.4

package/dist/coworker/persona-commands.d.ts

@@ -0,0 +1 @@
+export { handleList, handleCurrent, handleSwitch, handleReset, handleInstall, handleUninstall, } from '@otto/coworker-persona';

package/dist/coworker/persona-commands.js

@@ -0,0 +1,5 @@
+// /persona slash-command handlers now live in @otto/coworker-persona so they
+// can be imported from inside the src/resources extension boundary (which is
+// compiled with rootDir: src/resources and cannot import from src/ directly).
+// Re-exported here for the co-located unit test and external callers.
+export { handleList, handleCurrent, handleSwitch, handleReset, handleInstall, handleUninstall, } from '@otto/coworker-persona';

package/dist/coworker/persona-commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/coworker/persona-commands.test.js

@@ -0,0 +1,45 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { PersonaRegistry } from '@otto/coworker-persona';
+import { handleList, handleCurrent, handleSwitch } from './persona-commands.js';
+let tmpHome;
+let tmpWs;
+let registry;
+describe('persona slash commands', () => {
+    beforeEach(async () => {
+        tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), 'persona-home-'));
+        tmpWs = await fs.mkdtemp(path.join(os.tmpdir(), 'persona-ws-'));
+        await fs.mkdir(path.join(tmpHome, 'personas'), { recursive: true });
+        registry = new PersonaRegistry({ ottoHome: tmpHome });
+        await registry.ensureDefaultInstalled();
+    });
+    afterEach(async () => {
+        await fs.rm(tmpHome, { recursive: true, force: true });
+        await fs.rm(tmpWs, { recursive: true, force: true });
+    });
+    it('list returns lines including the default persona with active marker', async () => {
+        const lines = await handleList(registry, tmpWs);
+        const text = lines.join('\n');
+        assert.match(text, /default/);
+        assert.match(text, /\*/); // active marker on the active persona
+    });
+    it('current shows active persona name + display_name', async () => {
+        const lines = await handleCurrent(registry, tmpWs);
+        const text = lines.join('\n');
+        assert.match(text, /default/);
+        assert.match(text, /Default Co-Worker/);
+    });
+    it('switch updates the workspace record to the requested persona', async () => {
+        await handleSwitch(registry, tmpWs, 'default');
+        const raw = await fs.readFile(path.join(tmpWs, '.otto', 'persona.json'), 'utf8');
+        const data = JSON.parse(raw);
+        assert.equal(data.active, 'default');
+    });
+    it('switch to an unknown persona returns an error line', async () => {
+        const result = await handleSwitch(registry, tmpWs, 'nonexistent').catch((e) => e.message);
+        assert.match(result, /not installed|not found/i);
+    });
+});

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-9ee03dda8858f377
+fe239844559e7ca1

package/dist/resources/extensions/_coworker-paths.js

@@ -0,0 +1,8 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function getCoworkerGlobalDir() {
+    return process.env.OTTO_COWORKER_GLOBAL_DIR ?? join(homedir(), '.otto');
+}
+export function getScratchpadsRoot() {
+    return process.env.OTTO_SCRATCHPAD_ROOT ?? join(homedir(), '.otto', 'scratchpads');
+}

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

@@ -0,0 +1,31 @@
+import { runListArtifacts } from './list-tool.js';
+import { runOpenArtifact } from './open-tool.js';
+export async function runArtifactsCommand(store, argv) {
+    const [sub, ...rest] = argv;
+    switch (sub) {
+        case 'list':
+        case undefined: {
+            const out = await runListArtifacts(store);
+            return { message: out.markdown };
+        }
+        case 'show': {
+            const slug = rest[0];
+            if (!slug)
+                throw new Error('Usage: /artifacts show <slug>');
+            const out = await runOpenArtifact(store, { slug });
+            return { message: out.markdown };
+        }
+        case 'remove': {
+            const slug = rest.find((a) => !a.startsWith('--'));
+            const confirm = rest.includes('--confirm');
+            if (!slug)
+                throw new Error('Usage: /artifacts remove <slug> --confirm');
+            if (!confirm)
+                throw new Error('Usage: /artifacts remove <slug> --confirm');
+            await store.remove(slug, true);
+            return { message: `removed: ${slug}` };
+        }
+        default:
+            throw new Error(`Unknown /artifacts subcommand: ${sub}. Try: list, show, remove.`);
+    }
+}

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

@@ -0,0 +1,17 @@
+// src/resources/extensions/coworker-artifacts/artifacts-singleton.ts
+//
+// Factory for the per-session ArtifactStore bundle. Mirrors the Phase 3
+// memory-singleton pattern so the activator can construct/dispose state in
+// one place. dispose() is a no-op in v1 (ArtifactStore holds no async
+// resources) but kept for pattern symmetry with memory + scratchpad bundles.
+import { ArtifactStore } from '@otto/coworker-artifacts';
+export async function createArtifactsBundle(opts) {
+    const store = new ArtifactStore({ workspaceDir: opts.workspaceDir, now: opts.now });
+    return {
+        store,
+        workspaceDir: opts.workspaceDir,
+        async dispose() {
+            /* no async resources in v1 */
+        },
+    };
+}

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

@@ -0,0 +1,13 @@
+{
+  "id": "coworker-artifacts",
+  "name": "Co-worker Artifacts",
+  "version": "1.0.0",
+  "description": "Workspace-scoped artifact store: artifact://<slug> URIs, /artifacts slash, list_artifacts + open_artifact tools",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["list_artifacts", "open_artifact"],
+    "commands": ["artifacts"],
+    "hooks": ["session_start", "session_shutdown"]
+  }
+}

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

@@ -0,0 +1,125 @@
+import { Type } from '@sinclair/typebox';
+import { createArtifactsBundle } from './artifacts-singleton.js';
+import { runListArtifacts } from './list-tool.js';
+import { runOpenArtifact } from './open-tool.js';
+import { runArtifactsCommand } from './artifacts-command.js';
+export { createArtifactsBundle };
+// Cross-pillar export — null before session_start or after session_shutdown.
+let activeStore = null;
+export function getArtifactStore() {
+    return activeStore;
+}
+const LIST_PARAMS = Type.Object({});
+const OPEN_PARAMS = Type.Object({
+    slug: Type.String({ description: 'The artifact slug (e.g. "report" or "report-2") to read.' }),
+});
+export default function coworkerArtifactsExtension(api) {
+    let bundle = null;
+    let unavailable = false;
+    api.on('session_start', async (_event, ctx) => {
+        try {
+            bundle = await createArtifactsBundle({ workspaceDir: ctx.cwd });
+            activeStore = bundle.store;
+            unavailable = false;
+        }
+        catch (err) {
+            unavailable = true;
+            bundle = null;
+            activeStore = null;
+            ctx.ui.notify(`artifacts unavailable: ${err.message}`, 'warning');
+        }
+    });
+    api.registerTool({
+        name: 'list_artifacts',
+        label: 'List artifacts',
+        description: 'List all artifacts in the current workspace.',
+        parameters: LIST_PARAMS,
+        async execute() {
+            if (!bundle) {
+                return {
+                    content: [{ type: 'text', text: 'artifacts unavailable' }],
+                    details: { error: 'unavailable' },
+                };
+            }
+            try {
+                const out = await runListArtifacts(bundle.store);
+                return {
+                    content: [{ type: 'text', text: out.markdown }],
+                    details: { result_count: out.artifacts.length },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `list failed: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    });
+    api.registerTool({
+        name: 'open_artifact',
+        label: 'Open artifact',
+        description: 'Read the contents of an artifact by slug. Returns markdown body + recent provenance.',
+        parameters: OPEN_PARAMS,
+        async execute(_toolCallId, params) {
+            if (!bundle) {
+                return {
+                    content: [{ type: 'text', text: 'artifacts unavailable' }],
+                    details: { error: 'unavailable' },
+                };
+            }
+            try {
+                const out = await runOpenArtifact(bundle.store, params);
+                return {
+                    content: [{ type: 'text', text: out.markdown }],
+                    details: { slug: params.slug },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `open failed: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    });
+    api.registerCommand('artifacts', {
+        description: 'Inspect artifacts: /artifacts list | show <slug> | remove <slug> --confirm',
+        getArgumentCompletions: (prefix) => {
+            const subs = [
+                { label: 'list', description: 'List all artifacts' },
+                { label: 'show', description: 'Show artifact body + provenance: /artifacts show <slug>' },
+                { label: 'remove', description: 'Delete artifact: /artifacts remove <slug> --confirm' },
+            ];
+            return subs
+                .filter((s) => s.label.startsWith(prefix))
+                .map((s) => ({ value: s.label, label: s.label, description: s.description }));
+        },
+        handler: async (args, ctx) => {
+            if (!bundle) {
+                ctx.ui.notify(unavailable ? 'artifacts unavailable; chat continues without it.' : 'artifacts not ready yet.', 'warning');
+                return;
+            }
+            const argv = args.trim().split(/\s+/).filter(Boolean);
+            try {
+                const result = await runArtifactsCommand(bundle.store, argv);
+                ctx.ui.notify(result.message, 'info');
+            }
+            catch (err) {
+                ctx.ui.notify(`/artifacts failed: ${err.message}`, 'error');
+            }
+        },
+    });
+    api.on('session_shutdown', async () => {
+        if (bundle) {
+            try {
+                await bundle.dispose();
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        bundle = null;
+        activeStore = null;
+    });
+}

package/dist/resources/extensions/coworker-artifacts/list-tool.js

@@ -0,0 +1,27 @@
+export async function runListArtifacts(store) {
+    const handles = await store.list();
+    // We need the metadata fields not on the handle — re-read each metadata.json.
+    const { readFileSync } = await import('node:fs');
+    const rows = handles.map((h) => {
+        const meta = JSON.parse(readFileSync(h.metadataPath, 'utf8'));
+        return {
+            slug: h.slug,
+            kind: h.kind,
+            name: h.name,
+            uri: h.uri,
+            created_at: meta.created_at,
+            last_updated_at: meta.last_updated_at,
+            turn_count: meta.turn_count,
+        };
+    });
+    if (rows.length === 0) {
+        return { artifacts: [], markdown: '### Artifacts (0)\n' };
+    }
+    const lines = [`### Artifacts (${rows.length})`, ''];
+    lines.push('| slug | kind | turns | last updated | uri |');
+    lines.push('|---|---|---|---|---|');
+    for (const r of rows) {
+        lines.push(`| ${r.slug} | ${r.kind} | ${r.turn_count} | ${r.last_updated_at} | \`${r.uri}\` |`);
+    }
+    return { artifacts: rows, markdown: lines.join('\n') + '\n' };
+}

package/dist/resources/extensions/coworker-artifacts/open-tool.js

@@ -0,0 +1,25 @@
+import { ArtifactNotFound } from '@otto/coworker-artifacts';
+export async function runOpenArtifact(store, args) {
+    const handle = await store.get(args.slug);
+    if (!handle)
+        throw new ArtifactNotFound(args.slug);
+    const { readFileSync } = await import('node:fs');
+    const body = readFileSync(handle.primaryPath, 'utf8');
+    const provRaw = readFileSync(handle.provenancePath, 'utf8');
+    const prov = JSON.parse(provRaw);
+    const tail = prov.slice(-5);
+    const lines = [];
+    lines.push(`### ${handle.name} (\`${handle.uri}\`)`);
+    lines.push('');
+    lines.push('```markdown');
+    lines.push(body);
+    lines.push('```');
+    lines.push('');
+    if (tail.length > 0) {
+        lines.push('**Recent provenance:**');
+        for (const e of tail) {
+            lines.push(`- ${e.ts} · ${e.action} · turn \`${e.turn_id}\` · ${e.user_prompt}`);
+        }
+    }
+    return { markdown: lines.join('\n') + '\n' };
+}

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

@@ -0,0 +1,13 @@
+{
+  "id": "coworker-memory",
+  "name": "Co-worker Memory",
+  "version": "1.0.0",
+  "description": "Layered memory: Layer A (markdown rules/lessons) + Layer B (verbatim SQLite drawers) with /memory commands and memorize/recall tools",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["memorize", "recall"],
+    "commands": ["memory"],
+    "hooks": ["session_start", "session_shutdown"]
+  }
+}

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

@@ -0,0 +1,219 @@
+import { Type } from '@sinclair/typebox';
+import { buildLayerAContext, } from '@otto/coworker-memory';
+import { createMemoryBundle } from './memory-singleton.js';
+import { runMemorize } from './memorize-tool.js';
+import { runRecall } from './recall-tool.js';
+import { runMemoryCommand } from './memory-command.js';
+import { onSessionShutdown } from './session-hooks.js';
+import { createCurrentScratchpadProvider } from '../coworker-scratchpad/sp-command.js';
+import { getCoworkerGlobalDir, getScratchpadsRoot } from '../_coworker-paths.js';
+export { createMemoryBundle };
+// Cross-pillar export. Scratchpad's onDataLoad closure imports this and calls
+// it lazily — returns null before session_start or after session_shutdown,
+// which is the correct "no-op" signal.
+let activeRecorder = null;
+export function getMemoryRecorder() {
+    return activeRecorder;
+}
+const MEMORIZE_PARAMS = Type.Object({
+    text: Type.String({ description: 'The note text to store in Layer A memory.' }),
+    kind: Type.Union([Type.Literal('profile'), Type.Literal('rule'), Type.Literal('lesson')], { description: "Layer A kind: 'profile' (about the user), 'rule' (must-do), or 'lesson' (learned)." }),
+    scope: Type.Optional(Type.Union([Type.Literal('global'), Type.Literal('workspace')], { description: "Defaults to 'workspace' when omitted." })),
+});
+const RECALL_PARAMS = Type.Object({
+    query: Type.String({ description: 'Free-text query to search verbatim drawers.' }),
+    kind: Type.Optional(Type.Union([
+        Type.Literal('turn'), Type.Literal('paste'), Type.Literal('file_load'),
+        Type.Literal('ticket'), Type.Literal('email'), Type.Literal('rca'), Type.Literal('note'),
+    ])),
+    wing: Type.Optional(Type.String()),
+    room: Type.Optional(Type.String()),
+    days_back: Type.Optional(Type.Number()),
+    max_results: Type.Optional(Type.Number()),
+});
+export default function coworkerMemoryExtension(api) {
+    let bundle = null;
+    let unavailable = false;
+    let pendingPrompt;
+    // One notify per session covers both before_agent_start inject failures and
+    // agent_start recordTurn failures — both are best-effort and must not break
+    // the chat loop. Spec §3.7.
+    let writeFailureNotified = false;
+    api.on('session_start', async (_event, ctx) => {
+        try {
+            bundle = await createMemoryBundle({
+                globalDir: getCoworkerGlobalDir(),
+                workspaceDir: ctx.cwd,
+                scopeMode: 'per-project-tagged',
+                currentScratchpadName: createCurrentScratchpadProvider({
+                    scratchpadsRoot: getScratchpadsRoot(),
+                }),
+            });
+            activeRecorder = bundle.recorder;
+            unavailable = false;
+        }
+        catch (err) {
+            unavailable = true;
+            bundle = null;
+            activeRecorder = null;
+            ctx.ui.notify(`memory unavailable: ${err.message}`, 'warning');
+        }
+    });
+    api.on('before_agent_start', async (event, ctx) => {
+        if (!bundle)
+            return undefined;
+        // Capture the prompt for the paired agent_start so we can record it even
+        // when there is no Layer A content to inject (block.length === 0).
+        pendingPrompt = event.prompt;
+        try {
+            const block = await buildLayerAContext({
+                mode: bundle.scopeMode,
+                globalStore: bundle.globalLayerA,
+                workspaceStore: bundle.workspaceLayerA,
+                tokenLimit: 3000,
+            });
+            if (block.length === 0)
+                return undefined;
+            return { systemPrompt: event.systemPrompt + '\n\n' + block };
+        }
+        catch (err) {
+            if (!writeFailureNotified) {
+                ctx.ui.notify(`memory context inject failed: ${err.message}`, 'warning');
+                writeFailureNotified = true;
+            }
+            return undefined;
+        }
+    });
+    api.on('agent_start', async (event, ctx) => {
+        if (!bundle || !pendingPrompt || !event.sessionId || !event.turnId) {
+            pendingPrompt = undefined;
+            return;
+        }
+        const userText = pendingPrompt;
+        const sessionId = event.sessionId;
+        const turnId = event.turnId;
+        pendingPrompt = undefined;
+        try {
+            await bundle.recorder.recordTurn({ sessionId, userText, turnId });
+        }
+        catch (err) {
+            if (!writeFailureNotified) {
+                ctx.ui.notify(`memory write failed: ${err.message}`, 'warning');
+                writeFailureNotified = true;
+            }
+        }
+    });
+    api.registerTool({
+        name: 'memorize',
+        label: 'Memorize',
+        description: 'Save a profile note, rule, or lesson into Layer A memory.',
+        parameters: MEMORIZE_PARAMS,
+        async execute(_toolCallId, params) {
+            if (!bundle) {
+                return {
+                    content: [{ type: 'text', text: 'memory unavailable; cannot memorize.' }],
+                    details: { error: 'memory unavailable' },
+                };
+            }
+            try {
+                const out = await runMemorize(bundle, {
+                    text: params.text,
+                    kind: params.kind,
+                    scope: params.scope,
+                });
+                return {
+                    content: [{ type: 'text', text: `stored in ${out.layer_a_file}` }],
+                    details: out,
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `memorize failed: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    });
+    api.registerTool({
+        name: 'recall',
+        label: 'Recall',
+        description: 'Search verbatim drawers in memory (Layer B). Returns markdown with drawer URIs.',
+        parameters: RECALL_PARAMS,
+        async execute(_toolCallId, params) {
+            if (!bundle) {
+                return {
+                    content: [{ type: 'text', text: 'memory unavailable; cannot recall.' }],
+                    details: { error: 'memory unavailable' },
+                };
+            }
+            try {
+                const args = {
+                    query: params.query,
+                    kind: params.kind,
+                    wing: params.wing,
+                    room: params.room,
+                    days_back: params.days_back,
+                    max_results: params.max_results,
+                };
+                const out = await runRecall(bundle, args);
+                return {
+                    content: [{ type: 'text', text: out.markdown }],
+                    details: { result_count: out.results.length },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `recall failed: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    });
+    api.registerCommand('memory', {
+        description: 'Inspect and manage co-worker memory (Layer A rules/lessons + Layer B drawers).',
+        getArgumentCompletions: (prefix) => {
+            const subcommands = [
+                { label: 'note', description: 'Append a lesson: /memory note <text>' },
+                { label: 'show', description: 'Show Layer A: /memory show [profile|rules|lessons] [--scope workspace|global]' },
+                { label: 'recall', description: 'Search Layer B drawers: /memory recall <query> [--kind|--room|--wing|--limit|--days_back]' },
+                { label: 'status', description: 'Show workspace_wing, drawer_count, db path' },
+                { label: 'clear', description: 'Clear drawers: /memory clear --wing <wing> --confirm' },
+                { label: 'wing', description: 'Set session wing override: /memory wing <name>' },
+                { label: 'room', description: 'Set session room override: /memory room <name>' },
+                { label: 'seed', description: 'Re-apply persona seed on next session_start' },
+            ];
+            return subcommands
+                .filter((s) => s.label.startsWith(prefix))
+                .map((s) => ({ value: s.label, label: s.label, description: s.description }));
+        },
+        handler: async (args, ctx) => {
+            if (!bundle) {
+                ctx.ui.notify(unavailable ? 'memory unavailable; chat continues without it.' : 'memory not ready yet.', 'warning');
+                return;
+            }
+            const argv = args.trim().split(/\s+/).filter(Boolean);
+            try {
+                const result = await runMemoryCommand(bundle, argv);
+                ctx.ui.notify(result.message, 'info');
+            }
+            catch (err) {
+                ctx.ui.notify(`/memory failed: ${err.message}`, 'error');
+            }
+        },
+    });
+    api.on('session_shutdown', async () => {
+        if (bundle) {
+            try {
+                await onSessionShutdown(bundle);
+            }
+            catch {
+                // dispose is best-effort; LocalSqliteBackend.close() handles double-close.
+            }
+        }
+        bundle = null;
+        activeRecorder = null;
+        pendingPrompt = undefined;
+        // writeFailureNotified persists across sessions intentionally — one notify
+        // per Otto process lifetime is enough to avoid spam.
+    });
+}

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

@@ -0,0 +1,10 @@
+export async function runMemorize(bundle, args) {
+    const scope = args.scope ?? 'workspace';
+    const store = scope === 'global' ? bundle.globalLayerA : bundle.workspaceLayerA;
+    const ts = new Date().toISOString();
+    await store.append({ kind: args.kind, text: args.text, source: 'user', ts });
+    return {
+        stored: true,
+        layer_a_file: args.kind === 'lesson' ? 'lessons.md' : args.kind === 'rule' ? 'rules.md' : 'profile.md',
+    };
+}