@cmodjs/core 0.3.0 → 1.5.0

package/runtime/conversations.js

@@ -0,0 +1,563 @@
+import { consentPath, dataFolder, isObject, parseConsent } from '../records.js';
+import { Message, rowOfAppend } from '../session/context/turn/message/message.js';
+import { Note } from '../session/context/turn/message/note.js';
+import { Person } from '../session/context/turn/message/sender.js';
+import { createConversation, emptyConversation } from '../session/conversation.js';
+import { Session, UsageChange } from '../session/session.js';
+import { GoalChange } from '../session/goal/goal.js';
+import { receivedMatcher } from '../utils/matcher.js';
+import { ifMissing } from '../utils/paths.js';
+import { formatExit, messageOf } from '../utils/text.js';
+import { foldAnswers, installBefore, relayOf } from './before.js';
+import { cmodPluginName } from './dependencies.js';
+import { readLines, runCmod } from './programs.js';
+import { actPermission, beforePermission, conversationMethods, everySession, isAct, isHeardBy, resultOf, usageOf } from './sessions.js';
+const bufferedTaskRows = 200;
+const beforeDeadlineMs = 5000;
+const livenessMs = 5000;
+export function serveConversations({ claude, router, store, project, report }) {
+    const folder = dataFolder(store, cmodPluginName);
+    const goals = `${folder}/goals`;
+    const watches = `${folder}/before`;
+    const heard = new Map();
+    const asked = new Map();
+    const ownWatches = new Map();
+    let watchers = [];
+    let watching = Promise.resolve();
+    let published = new Set();
+    let publishing = Promise.resolve();
+    let session = '';
+    let asks = 0;
+    let conversation = createConversation(emptyConversation(''));
+    let starting = Promise.resolve();
+    let live = [];
+    const liveIds = new Set();
+    const waitingRows = new Map();
+    let follower;
+    const json = async (args) => JSON.parse(await runCmod(claude, [...args, '--json', '--project', project()], session === '' ? await claude.session.id() : session));
+    const isGranted = async (caller, item) => {
+        if (caller === cmodPluginName)
+            return true;
+        if (caller === undefined)
+            return false;
+        const path = consentPath(store);
+        const text = await claude.fs.read(path).catch(ifMissing('{}'));
+        return (parseConsent(JSON.parse(text), path)[caller] ?? []).includes(item);
+    };
+    const ended = (id) => new Error(`session ${id} has ended`);
+    const isRunning = async (id) => (await json(['history', 'sessions', '--running', '--all'])).some((each) => each.id === id);
+    const dispatch = (to, changes, isInProject = true) => {
+        for (const change of changes) {
+            if (change.type === Message && !liveIds.has(change.message.id) && to === session) {
+                live.push(change.message);
+                liveIds.add(change.message.id);
+            }
+            for (const [mod, sessions] of heard) {
+                const subscriptions = [...(sessions.get(to) ?? []), ...(isInProject ? (sessions.get(everySession) ?? []) : [])];
+                if (!subscriptions.some(({ event, matcher }) => isHeardBy(event, matcher, change)))
+                    continue;
+                void claude.cmod.call({ to: mod, method: conversationMethods.changed, input: { session: to, change, isInProject } }).catch((error) => report(`changed:${mod}`, `Could not tell ${mod} about session ${to}`, error));
+            }
+        }
+    };
+    const restartFollower = async () => {
+        const wantsEvery = [...heard.values()].some((sessions) => (sessions.get(everySession) ?? []).length > 0);
+        const named = [...heard.values()].flatMap((sessions) => [...sessions].filter(([id, list]) => id !== session && id !== everySession && list.length > 0).map(([id]) => id));
+        const others = [...new Set(named)].sort();
+        const args = [...others, ...(wantsEvery ? ['--running'] : [])];
+        const wanted = [session, project(), ...args].join(' ');
+        if (follower?.sessions === wanted)
+            return;
+        follower?.stop();
+        follower = undefined;
+        if (args.length === 0)
+            return;
+        const stream = claude.process.spawn({ argv: ['cmod', 'history', 'follow', ...args, '--json', '--project', project()], env: { CLAUDE_CODE_SESSION_ID: session } });
+        const started = { sessions: wanted, stop: () => void stream.return(undefined) };
+        follower = started;
+        void readLines(stream, (line) => {
+            if (line.trim() === '')
+                return;
+            const parsed = JSON.parse(line);
+            dispatch(parsed.session, [parsed.change], parsed.isInProject);
+        })
+            .then(({ code, lastError }) => {
+            if (follower === started)
+                throw new Error(`cmod history follow ${formatExit(code, lastError)}`);
+        })
+            .catch((error) => {
+            if (follower !== started)
+                return;
+            follower = undefined;
+            report('follow', 'Stopped hearing the other sessions', error);
+        });
+    };
+    const follow = () => void restartFollower().catch((error) => report('follow', 'Stopped hearing the other sessions', error));
+    const post = async (to, relay) => {
+        const sent = await claude.session.send({ to: { sessionId: to }, text: `<cmod-relay>${JSON.stringify(relay)}</cmod-relay>` });
+        if (sent.isDelivered !== true)
+            throw ended(to);
+    };
+    const ask = (to, relay, deadlineMs) => new Promise((resolve, reject) => {
+        const id = `${session}:${(asks += 1)}`;
+        const timer = deadlineMs === undefined
+            ? claude.clock.every(livenessMs, () => {
+                void isRunning(to).then((isLive) => {
+                    if (!isLive)
+                        settle.reject(ended(to));
+                });
+            })
+            : claude.clock.after(deadlineMs, () => settle.reject(new Error(`session ${to} did not answer within ${deadlineMs / 1000} s`)));
+        const settle = {
+            resolve(value) {
+                if (asked.delete(id))
+                    timer.cancel();
+                resolve(value);
+            },
+            reject(error) {
+                if (asked.delete(id))
+                    timer.cancel();
+                reject(error);
+            },
+        };
+        asked.set(id, settle);
+        post(to, { ...relay, id, from: session }).catch((error) => settle.reject(error instanceof Error ? error : new Error(messageOf(error))));
+    });
+    const publishWatches = (isEnding = false) => {
+        const next = publishing.then(() => publishNow(isEnding));
+        publishing = next.catch((error) => claude.ui.log(`cmod: publishing before listeners failed: ${messageOf(error)}`, { to: 'debug' }));
+        return next;
+    };
+    const publishNow = async (isEnding) => {
+        if (session === '')
+            return;
+        const list = isEnding ? [] : [...ownWatches.values()].filter((watch) => watch.events.length > 0);
+        await claude.fs.write(`${watches}/${session}.json`, JSON.stringify(list));
+        const targets = new Set([...published, ...list.map((watch) => watch.target)]);
+        published = new Set(list.map((watch) => watch.target));
+        const running = targets.has(everySession) ? (await json(['history', 'sessions', '--running'])).map((each) => each.id) : [];
+        const told = new Set([...running, ...targets].filter((id) => id !== everySession && id !== session));
+        await Promise.all([...told].map((id) => post(id, { kind: 'watch' }).catch((error) => claude.ui.log(`cmod: session ${id} did not hear of a before listener: ${messageOf(error)}`, { to: 'debug' }))));
+    };
+    const readWatchers = async () => {
+        const files = await claude.fs.list(watches).catch(ifMissing([]));
+        const found = [];
+        for (const file of files) {
+            const from = file.name.replace(/\.json$/, '');
+            if (from === session || !file.name.endsWith('.json'))
+                continue;
+            const list = JSON.parse(await claude.fs.read(`${watches}/${file.name}`).catch(ifMissing('[]')));
+            found.push(...list.filter((watch) => watch.target === session || (watch.target === everySession && watch.project === project())).map((watch) => ({ ...watch, from })));
+        }
+        watchers = found;
+    };
+    const changeGoal = (task, text) => dispatch(session, task === undefined ? conversation.changeGoal(text) : [{ type: GoalChange, goal: { text, task } }]);
+    const reloadWatchers = () => {
+        watching = readWatchers().catch((error) => report('before', 'Kept the other sessions’ before listeners from before', error));
+    };
+    const place = () => {
+        const { context, contextOpenedAt, turn, tasks, taskTurns } = conversation.state;
+        return { session, context, contextOpenedAt, ...(turn === undefined ? {} : { turn }), tasks, taskTurns };
+    };
+    const deciders = (event) => {
+        const all = [...[...ownWatches.values()].filter((watch) => watch.target === session || watch.target === everySession).map((watch) => ({ ...watch, from: session })), ...watchers];
+        return [...new Map(all.filter((watcher) => watcher.events.includes(event)).map((watcher) => [`${watcher.from}\n${watcher.mod}`, watcher])).values()];
+    };
+    const askHere = async (mod, event, change, from = session, isInProject = true) => {
+        for (const needed of ['conversation', beforePermission(event)])
+            if (!(await isGranted(mod, needed)))
+                throw new Error(`${mod} needs the ${needed} permission for before(${event}). Turn it on in /mods ${mod}.`);
+        return claude.cmod.call({ to: mod, method: conversationMethods.before, input: { session: from, event, change, isInProject } });
+    };
+    const askAway = async (watcher, event, change) => {
+        try {
+            return await ask(watcher.from, { kind: 'before', mod: watcher.mod, event, change, project: project() }, beforeDeadlineMs);
+        }
+        catch (error) {
+            if (await isRunning(watcher.from))
+                throw error;
+            watchers = watchers.filter((each) => each.from !== watcher.from);
+            claude.ui.log(`cmod: session ${watcher.from} ended without clearing its before listeners, so they are cleared now`, { to: 'debug' });
+            await claude.fs.write(`${watches}/${watcher.from}.json`, '[]');
+            return undefined;
+        }
+    };
+    installBefore({
+        claude,
+        router,
+        hooks: {
+            place: async () => {
+                await starting;
+                return place();
+            },
+            wants: async (event) => {
+                await Promise.all([starting, watching]);
+                return deciders(event).length > 0;
+            },
+            decide: (event, change) => foldAnswers(event, change, deciders(event).map((watcher) => (latest) => (watcher.from === session ? askHere(watcher.mod, event, latest) : askAway(watcher, event, latest))), (error) => report(`before:${event}`, `Passed the ${event} on without a mod's answer`, error)),
+        },
+    });
+    const start = (id, source) => {
+        if (id === session)
+            return;
+        const previous = session;
+        session = id;
+        live = [];
+        liveIds.clear();
+        waitingRows.clear();
+        conversation = createConversation(emptyConversation(id));
+        starting =
+            source === 'startup' || source === 'clear'
+                ? Promise.resolve(dispatch(id, conversation.startContext(new Date().toISOString())))
+                : json(['history', 'state', id]).then((state) => {
+                    if (session === id)
+                        conversation = createConversation({ ...emptyConversation(id), ...state });
+                }, (error) => report('state', `Starts session ${id} without its earlier turns`, error));
+        follow();
+        reloadWatchers();
+        if (ownWatches.size === 0)
+            return;
+        void Promise.all([previous === '' ? undefined : claude.fs.write(`${watches}/${previous}.json`, '[]'), publishWatches()]).catch((error) => report('before', 'Kept its before listeners on the session from before', error));
+    };
+    const take = async (row, task) => {
+        await starting;
+        if (task !== undefined && conversation.state.tasks[task] === undefined) {
+            const waiting = waitingRows.get(task) ?? [];
+            waiting.push(row);
+            waitingRows.set(task, waiting);
+            if (waiting.length < bufferedTaskRows)
+                return;
+            waitingRows.delete(task);
+            dispatch(session, conversation.startTask({ id: task, title: '', agentType: 'general-purpose', openedBy: '', openedAt: row.at }));
+            for (const each of waiting)
+                dispatch(session, conversation.add(each, task));
+            return;
+        }
+        dispatch(session, conversation.add(row, task));
+    };
+    router.add('classic.SessionStart', async (e, next) => {
+        start(e.session_id, e.source);
+        return next(e);
+    });
+    router.add('classic.SessionEnd', async (e, next) => {
+        if (ownWatches.size > 0)
+            await publishWatches(true).catch((error) => report('before', 'Left its before listeners registered', error));
+        return next(e);
+    });
+    router.add('session.append', async (e, next) => {
+        const kept = await next(e);
+        if (kept.deny !== undefined || session === '')
+            return kept;
+        const cwd = e.message.type === 'assistant' ? await claude.session.cwd() : '';
+        void take(rowOfAppend({ uuid: kept.uuid, door: e.door, origin: e.origin, message: kept.message }, new Date().toISOString(), cwd), e.agentId).catch((error) => report('append', 'Missed a message', error));
+        return kept;
+    });
+    router.add('session.compact', async (e, next) => {
+        const compacted = await next(e);
+        if (e.trigger === 'precompute' || compacted.skip !== undefined || session === '')
+            return compacted;
+        const at = new Date().toISOString();
+        const boundary = { id: `compact:${e.agentId ?? session}:${at}`, at, type: 'system', name: 'compact_boundary', isMeta: false, isSummary: false, content: [] };
+        void take(boundary, e.agentId).catch((error) => report('compact', 'Missed a compaction', error));
+        return compacted;
+    });
+    router.add('session.measure', async (e, next) => {
+        const measured = await next(e);
+        if (session !== '')
+            dispatch(session, [{ type: UsageChange, usage: await usageOf(claude) }]);
+        return measured;
+    });
+    router.add('agent.spawn', async (e, next) => {
+        const spawned = await next(e);
+        if (spawned.deny !== undefined || spawned.agentId === undefined)
+            return spawned;
+        const id = spawned.agentId;
+        const opened = { id, title: e.description, agentType: e.subagentType, model: spawned.model, openedBy: e.tool_use_id, openedAt: new Date().toISOString(), ...(e.parentAgentId === undefined ? {} : { parent: e.parentAgentId }) };
+        await starting;
+        dispatch(session, conversation.startTask(opened));
+        const waiting = waitingRows.get(id) ?? [];
+        waitingRows.delete(id);
+        for (const row of waiting)
+            dispatch(session, conversation.add(row, id));
+        return spawned;
+    });
+    router.add('session.receive', async (e, next) => {
+        const sent = relayOf(e);
+        if (sent === undefined)
+            return next(e);
+        const relay = JSON.parse(sent);
+        claude.clock.after(0, () => void received(relay).catch((error) => report('relay', 'Could not answer another session', error)));
+        return { consumed: 'cmod relay' };
+    });
+    const received = async (relay) => {
+        if (relay.kind === 'answer') {
+            const waiting = asked.get(relay.id);
+            if (relay.deny === undefined)
+                waiting?.resolve(relay.value);
+            else
+                waiting?.reject(new Error(relay.deny));
+            return;
+        }
+        if (relay.kind === 'watch')
+            return readWatchers();
+        if (relay.kind === 'goal') {
+            await starting;
+            changeGoal(relay.task, relay.text);
+            return;
+        }
+        const answered = async (run) => {
+            try {
+                await post(relay.from, { kind: 'answer', id: relay.id, value: (await run()) ?? null });
+            }
+            catch (error) {
+                await post(relay.from, { kind: 'answer', id: relay.id, deny: messageOf(error) });
+            }
+        };
+        if (relay.kind === 'act')
+            return answered(() => perform(relay.caller, relay.action, relay.input, relay.task));
+        return answered(() => askHere(relay.mod, relay.event, relay.change, relay.from, relay.project === project()));
+    };
+    const checkAct = async (caller, action, input) => {
+        const needed = actPermission(action, input);
+        if (needed !== undefined && !(await isGranted(caller, needed)))
+            throw new Error(`${caller} needs the ${needed} permission for ${action}. Turn it on in /mods ${caller}.`);
+    };
+    const perform = async (caller, action, input, task) => {
+        await checkAct(caller, action, input);
+        await starting;
+        if (task !== undefined)
+            return performInTask(action, input, task);
+        if (action === 'usage')
+            return usageOf(claude);
+        if (action === 'clients')
+            return [...(await claude.session.surfaces())];
+        if (action === 'send') {
+            const { type, text, as } = input;
+            if (as === Session)
+                throw new Error(`session ${session} cannot send as itself to itself.`);
+            const delivered = type === Note ? await claude.session.append({ message: { type: 'user', content: [{ type: 'text', text }] } }) : await claude.prompt.submit({ text, ...(as === Person ? { asUser: true } : {}) });
+            if ('deny' in delivered && typeof delivered.deny === 'string')
+                throw new Error(`Claude Code refused the note: ${delivered.deny}`);
+            if ('drop' in delivered && typeof delivered.drop === 'string')
+                throw new Error(`Claude Code dropped the prompt: ${delivered.drop}`);
+            return null;
+        }
+        if (action === 'startTask') {
+            const args = input;
+            const started = await claude.agent.spawn({
+                prompt: args.prompt,
+                ...(args.name === undefined ? {} : { description: args.name, name: args.name }),
+                ...(args.agentType === undefined ? {} : { subagentType: args.agentType }),
+                ...(args.model === undefined ? {} : { model: args.model }),
+                ...(args.cwd === undefined ? {} : { cwd: args.cwd }),
+            });
+            if (started.deny !== undefined)
+                throw new Error(`Claude Code refused the task: ${started.deny}`);
+            return { id: started.agentId ?? '', title: args.name ?? '', agentType: args.agentType ?? 'general-purpose', model: started.model, openedBy: '', openedAt: new Date().toISOString() };
+        }
+        const { name, input: toolInput } = input;
+        return resultOf(place(), await claude.tool.call({ ...toolInput, tool: name }));
+    };
+    const performInTask = async (action, input, task) => {
+        const running = conversation.state.tasks[task];
+        if (action === 'usage')
+            return json(['history', 'usage', session, '--task', task]);
+        if (action === 'clients')
+            return running === undefined || running.closedAt !== undefined ? [] : [...(await claude.session.surfaces())];
+        if (action !== 'send')
+            throw new Error(`cmod: ${action} runs only on a session's own main loop.`);
+        if (running === undefined || running.closedAt !== undefined)
+            throw ended(task);
+        const sent = await claude.session.send({ to: { agentId: task }, text: input.text });
+        if (sent.isDelivered !== true)
+            throw ended(task);
+        return null;
+    };
+    const actElsewhere = async (caller, target, action, input, task) => {
+        await checkAct(caller, action, input);
+        const isLive = await isRunning(target);
+        if (!isLive && action === 'usage')
+            return json(['history', 'usage', target, ...(task === undefined ? [] : ['--task', task])]);
+        if (!isLive && action === 'clients')
+            return [];
+        if (!isLive)
+            throw ended(task ?? target);
+        if (action === 'send' && task === undefined && input.as === Session) {
+            const sent = await claude.session.send({ to: { sessionId: target }, text: input.text });
+            if (sent.isDelivered !== true)
+                throw ended(target);
+            return null;
+        }
+        return ask(target, { kind: 'act', caller, action, input, ...(task === undefined ? {} : { task }) });
+    };
+    const merged = (saved, kept, key) => {
+        const keptKeys = new Set(kept.map(key));
+        return [...saved.filter((item) => !keptKeys.has(key(item))), ...kept];
+    };
+    const liveTurns = (task) => {
+        const turn = typeof task === 'string' ? conversation.state.taskTurns[task] : conversation.state.turn;
+        return turn === undefined ? [] : [turn];
+    };
+    const liveTasks = () => Object.values(conversation.state.tasks).map((task) => ({
+        id: task.id,
+        title: task.title,
+        agentType: task.agentType,
+        ...(task.model === undefined ? {} : { model: task.model }),
+        openedBy: task.openedBy,
+        openedAt: task.openedAt,
+        ...(task.closedAt === undefined ? {} : { closedAt: task.closedAt }),
+        ...(task.parent === undefined ? {} : { parent: task.parent }),
+    }));
+    const liveContext = (task) => {
+        if (typeof task === 'string') {
+            const running = conversation.state.tasks[task];
+            return running === undefined ? [] : [{ number: running.context, openedAt: running.contextOpenedAt ?? running.openedAt, task, ...(running.closedAt === undefined ? {} : { closedAt: running.closedAt }) }];
+        }
+        const { context, contextOpenedAt } = conversation.state;
+        return context === 0 ? [] : [{ number: context, openedAt: contextOpenedAt }];
+    };
+    const lastOf = (items, last) => (typeof last === 'number' ? items.slice(-last) : [...items]);
+    const methods = {
+        async [conversationMethods.sessions](request) {
+            const found = await json(['history', 'sessions', ...scopeArgs(request), ...(request['running'] === true ? ['--running'] : [])]);
+            return found.map((each) => (each.id === session ? { ...each, isRunning: true } : each));
+        },
+        async [conversationMethods.search](request) {
+            const before = isObject(request['before']) ? request['before'] : undefined;
+            const record = [...textArg('--session', request['session']), ...textArg('--task', request['task']), ...textArg('--turn', request['turn']), ...countArg('--context', request['context']), ...(request['isGoal'] === true ? ['--goal'] : [])];
+            return json(['history', 'search', String(request['text']), ...scopeArgs(request), ...record, ...(request['running'] === true ? ['--running'] : []), ...countArg('--limit', request['limit']), ...(before === undefined ? [] : ['--before', `${String(before['session'])}:${String(before['id'])}`])]);
+        },
+        async [conversationMethods.messages](request) {
+            const id = String(request['session']);
+            const filters = [...textArg('--turn', request['turn']), ...textArg('--task', request['task']), ...textArg('--after', request['after'])];
+            const saved = await json(['history', 'messages', id, ...filters, ...countArg('--last', request['last'])]);
+            if (id !== session)
+                return saved;
+            await starting;
+            const fits = (message) => (request['turn'] === undefined || message.turn === request['turn']) && message.task === request['task'];
+            const after = typeof request['after'] === 'string' ? live.findIndex((message) => message.id === request['after']) : -1;
+            const kept = live.slice(after + 1).filter(fits);
+            return lastOf(merged(saved, kept, (message) => message.id), request['last']);
+        },
+        async [conversationMethods.turns](request) {
+            const id = String(request['session']);
+            const saved = await json(['history', 'turns', id, ...textArg('--task', request['task']), ...countArg('--context', request['context']), ...countArg('--last', request['last'])]);
+            if (id !== session)
+                return saved;
+            await starting;
+            const kept = liveTurns(request['task']).filter((turn) => request['context'] === undefined || turn.context === request['context']);
+            return lastOf(merged(saved, kept, (turn) => turn.prompt.id), request['last']);
+        },
+        async [conversationMethods.contexts](request) {
+            const id = String(request['session']);
+            const saved = await json(['history', 'contexts', id, ...textArg('--task', request['task'])]).catch((error) => {
+                if (id === session && typeof request['task'] === 'string')
+                    return [];
+                throw error;
+            });
+            if (id !== session)
+                return saved;
+            await starting;
+            return merged(saved, liveContext(request['task']), (context) => String(context.number));
+        },
+        async [conversationMethods.tasks](request) {
+            const id = String(request['session']);
+            const isNested = request['all'] === true;
+            const saved = await json(['history', 'tasks', id, ...(isNested ? ['--nested'] : textArg('--task', request['task']))]);
+            if (id !== session)
+                return saved;
+            await starting;
+            const kept = liveTasks().filter((task) => isNested || task.parent === request['task']);
+            return merged(saved, kept, (task) => task.id);
+        },
+        async [conversationMethods.goal](request) {
+            const id = String(request['session']);
+            const task = typeof request['task'] === 'string' ? request['task'] : undefined;
+            if (id === session && task === undefined) {
+                await starting;
+                const text = conversation.state.goal;
+                if (text !== undefined)
+                    return { text };
+            }
+            return json(['history', 'goal', id, ...textArg('--task', task)]);
+        },
+        async [conversationMethods.updateGoal](request) {
+            const id = String(request['session']);
+            const task = typeof request['task'] === 'string' ? request['task'] : undefined;
+            const text = String(request['text']);
+            await claude.fs.write(`${goals}/${task ?? id}.txt`, text);
+            await starting;
+            if (id === session)
+                changeGoal(task, text);
+            else {
+                dispatch(id, [{ type: GoalChange, goal: { text, ...(task === undefined ? {} : { task }) } }]);
+                await post(id, { kind: 'goal', ...(task === undefined ? {} : { task }), text }).catch((error) => claude.ui.log(`cmod: session ${id} keeps its goal until it starts again: ${messageOf(error)}`, { to: 'debug' }));
+            }
+            return null;
+        },
+        async [conversationMethods.subscribe](request, caller) {
+            if (caller === undefined)
+                throw new Error('cmod hears no caller for this subscription.');
+            const id = String(request['session']);
+            const list = Array.isArray(request['subscriptions']) ? request['subscriptions'] : [];
+            const sessions = heard.get(caller) ?? new Map();
+            sessions.set(id, list.map(({ event, matcher }) => ({ event, matcher: matcher === undefined ? undefined : receivedMatcher(matcher) })));
+            heard.set(caller, sessions);
+            follow();
+            return null;
+        },
+        async [conversationMethods.watchBefore](request, caller) {
+            if (caller === undefined)
+                throw new Error('cmod hears no caller for this before listener.');
+            const target = String(request['session']);
+            const list = Array.isArray(request['subscriptions']) ? request['subscriptions'] : [];
+            ownWatches.set(`${caller}\n${target}`, { mod: caller, target, project: project(), events: [...new Set(list.map(({ event }) => event))] });
+            await publishWatches();
+            return null;
+        },
+        async [conversationMethods.act](request, caller) {
+            if (caller === undefined)
+                throw new Error('cmod hears no caller for this action.');
+            const target = String(request['session']);
+            const action = String(request['action']);
+            const task = typeof request['task'] === 'string' ? request['task'] : undefined;
+            if (!isAct(action))
+                throw new Error(`cmod takes no action named ${action}.`);
+            if (target === session)
+                return perform(caller, action, request['input'], task);
+            return actElsewhere(caller, target, action, request['input'], task);
+        },
+    };
+    return {
+        moved() {
+            for (const [key, watch] of ownWatches)
+                ownWatches.set(key, { ...watch, project: project() });
+            void publishWatches().catch((error) => report('before', 'Kept its before listeners on the project from before', error));
+            reloadWatchers();
+            follow();
+        },
+        async answer(e) {
+            const method = methods[e.method];
+            if (method === undefined)
+                return undefined;
+            const input = isObject(e.input) ? e.input : {};
+            if (e.method !== conversationMethods.act && !(await isGranted(e.caller, 'conversation')))
+                return { deny: `${e.caller ?? 'A mod'} reads your conversations without your grant. Turn it on in /mods ${e.caller ?? ''}.`.trim() };
+            try {
+                return { value: await method(input, e.caller) };
+            }
+            catch (error) {
+                return { deny: messageOf(error) };
+            }
+        },
+    };
+}
+function scopeArgs(request) {
+    return [...(typeof request['since'] === 'string' ? ['--since', request['since']] : []), ...(request['everyProject'] === true ? ['--all'] : [])];
+}
+function countArg(flag, value) {
+    return typeof value === 'number' ? [flag, String(value)] : [];
+}
+function textArg(flag, value) {
+    return typeof value === 'string' ? [flag, value] : [];
+}

package/runtime/deadline.d.ts

@@ -2,7 +2,6 @@ import type { Claude } from './claude.js';
 export type Deadline = {
     readonly ms: number;
     readonly job?: string;
-    readonly longestMs?: number;
 };
 export declare const longestMs = 600000;
 export declare const toolDeadline: Deadline;

package/runtime/deadline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../src/runtime/deadline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAElG,eAAO,MAAM,SAAS,SAAU,CAAA;AAEhC,eAAO,MAAM,YAAY,EAAE,QAAgD,CAAA;AAE3E,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAe/H"}
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../src/runtime/deadline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAErE,eAAO,MAAM,SAAS,SAAU,CAAA;AAEhC,eAAO,MAAM,YAAY,EAAE,QAAqC,CAAA;AAEhE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAe/H"}

package/runtime/deadline.js

@@ -1,5 +1,5 @@
 export const longestMs = 600_000;
-export const toolDeadline = { ms: 30000, longestMs, job: 'tool' };
+export const toolDeadline = { ms: 30000, job: 'tool' };
 export function beforeDeadline(claude, { ms, job }, call, task) {
     return new Promise((resolve, reject) => {
         const passed = job === undefined ? `its ${ms / 1000} s deadline` : `the ${ms / 1000} s deadline of ${job}`;

package/runtime/dependencies.d.ts

@@ -1,8 +1,10 @@
 import type { Args, CmodDependencies, EventResult, Frozen } from 'claude-code';
 import type { Claude } from './claude.js';
+export declare const cmodPluginName = "cmod";
 export declare function answerCall(name: string, api: {
     readonly [method: string]: (input: never) => unknown;
 }, e: Frozen<Args<'cmod.call'>>): Promise<EventResult<'cmod.call'>>;
 export declare function dependencyCalls(claude: Claude, within: (call: string, task: Promise<unknown>) => Promise<unknown>): CmodDependencies;
+export declare function withBareRefusals(claude: Claude): Claude;
 export declare function notInstalled(name: string): string;
 //# sourceMappingURL=dependencies.d.ts.map

package/runtime/dependencies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dependencies.d.ts","sourceRoot":"","sources":["../src/runtime/dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAE9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE;IAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAA;CAAE,EAAE,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAQ7K;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,gBAAgB,CAOpI;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD"}
+{"version":3,"file":"dependencies.d.ts","sourceRoot":"","sources":["../src/runtime/dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAE9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,eAAO,MAAM,cAAc,SAAS,CAAA;AAEpC,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE;IAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAA;CAAE,EAAE,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAQ7K;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,gBAAgB,CAOpI;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAQvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD"}

package/runtime/dependencies.js

@@ -1,4 +1,5 @@
 import { messageOf } from '../utils/text.js';
+export const cmodPluginName = 'cmod';
 export async function answerCall(name, api, e) {
     const method = Object.hasOwn(api, e.method) ? api[e.method] : undefined;
     if (method === undefined)
@@ -14,6 +15,14 @@ export function dependencyCalls(claude, within) {
     const methodsOf = (to) => new Proxy({}, { get: (_methods, method) => (typeof method === 'string' && method !== 'then' ? (input) => within(`mod.dependencies.${to}.${method}`, claude.cmod.call({ to, method, input })) : undefined) });
     return new Proxy({}, { get: (_dependencies, to) => (typeof to === 'string' && to !== 'then' ? methodsOf(to) : undefined) });
 }
+export function withBareRefusals(claude) {
+    const prefix = `${claude.plugin.name}: $.cmod.call: `;
+    const call = (input) => claude.cmod.call(input).catch((error) => {
+        const message = messageOf(error);
+        throw message.startsWith(prefix) ? new Error(message.slice(prefix.length), { cause: error }) : error;
+    });
+    return { ...claude, cmod: { call } };
+}
 export function notInstalled(name) {
-    return `${name} is not installed. Run cmod install ${name}.`;
+    return `${name} is not installed. Add it with /plugin.`;
 }

package/runtime/engine.d.ts

@@ -0,0 +1,13 @@
+import type { Claude } from './claude.js';
+import type { Router } from './router.js';
+import type { Failure } from './toaster.js';
+import type { ToolCalls } from './tool-calls.js';
+export type Engine = {
+    readonly claude: Claude;
+    readonly router: Router;
+    readonly toolCalls: ToolCalls;
+    readonly report: (failure: Failure) => void;
+};
+export declare function keepEngine(mod: object, engine: Engine): void;
+export declare function engineOf(mod: object): Engine;
+//# sourceMappingURL=engine.d.ts.map

package/runtime/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/runtime/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;CAC5C,CAAA;AAID,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI5C"}

package/runtime/engine.js

@@ -0,0 +1,10 @@
+const engines = new WeakMap();
+export function keepEngine(mod, engine) {
+    engines.set(mod, engine);
+}
+export function engineOf(mod) {
+    const engine = engines.get(mod);
+    if (engine === undefined)
+        throw new Error('This mod has not started, so it reaches no Claude Code calls yet.');
+    return engine;
+}