@cmodjs/core 1.0.0 → 1.5.0

package/runtime/sessions.d.ts

@@ -1,11 +1,14 @@
+import { ToolResult } from '../session/context/turn/message/tool-result.js';
 import type { SessionChange, SessionData } from '../session/conversation.js';
-import { type SessionEvent, type Sessions, type Usage } from '../session/session.js';
+import { type BeforeEvent, type SessionEvent, type Sessions, type Usage } from '../session/session.js';
 import { type SentMatcher } from '../utils/matcher.js';
+import { type Place } from './before.js';
 import type { Claude } from './claude.js';
 export type Subscription = {
     readonly event: SessionEvent;
     readonly matcher: SentMatcher | undefined;
 };
+export declare const everySession = "*";
 export declare const conversationMethods: {
     readonly sessions: 'cmod:sessions';
     readonly search: 'cmod:search';
@@ -15,22 +18,41 @@ export declare const conversationMethods: {
     readonly tasks: 'cmod:tasks';
     readonly goal: 'cmod:goal';
     readonly updateGoal: 'cmod:updateGoal';
+    readonly usage: 'cmod:usage';
     readonly subscribe: 'cmod:subscribe';
-    readonly send: 'cmod:send';
+    readonly watchBefore: 'cmod:watchBefore';
+    readonly act: 'cmod:act';
     readonly changed: 'cmod:changed';
+    readonly before: 'cmod:before';
+};
+export type Act = 'send' | 'startTask' | 'callTool' | 'usage' | 'clients';
+export declare const beforePermission: (event: BeforeEvent) => string;
+export declare const isAct: (action: string) => action is Act;
+export declare function toolPermission(tool: string): string | undefined;
+export declare function actPermission(action: Act, input: unknown): string | undefined;
+export type Scope = {
+    readonly session?: string;
+    readonly context?: number;
+    readonly turn?: string;
+    readonly task?: string;
+    readonly isGoal?: true;
 };
 export type SessionsClient = {
     readonly sessions: Sessions;
-    changed(session: string, change: SessionChange): void;
+    changed(session: string, change: SessionChange, isInProject: boolean): void;
+    answerBefore(session: string, event: BeforeEvent, change: SessionChange, isInProject: boolean): Promise<unknown>;
     /** An empty title keeps the title the session already has. */
     follow(current: Omit<SessionData, 'isRunning' | 'lastAt'>): void;
 };
 export declare function usageOf(claude: Pick<Claude, 'session'>): Promise<Usage>;
 export declare function payloadOf(change: SessionChange): unknown;
 export declare function isHeardBy(event: SessionEvent, matcher: unknown, change: SessionChange): boolean;
-export declare function createSessionsClient({ name, claude, report }: {
+export declare function isInScope(scope: Scope, session: string, change: SessionChange, isUnder: (task: string, ancestor: string) => boolean): boolean;
+export declare function createSessionsClient({ name, claude, report, isGranted }: {
     readonly name: string;
     readonly claude: Claude;
     readonly report: (id: string, message: string, error: unknown) => void;
+    readonly isGranted: (permission: string) => boolean;
 }): SessionsClient;
+export declare function resultOf(where: Pick<Place, 'session' | 'context' | 'turn'>, answered: Awaited<ReturnType<Claude['tool']['call']>>): ToolResult;
 //# sourceMappingURL=sessions.d.ts.map

package/runtime/sessions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../src/runtime/sessions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAyB,aAAa,EAAE,WAAW,EAAsB,MAAM,4BAA4B,CAAA;AAGvH,OAAO,EAAW,KAAK,YAAY,EAAuC,KAAK,QAAQ,EAAsB,KAAK,KAAK,EAAE,MAAM,uBAAuB,CAAA;AACtJ,OAAO,EAAwB,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGzC,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,CAAA;CAAE,CAAA;AAEtG,eAAO,MAAM,mBAAmB;aAC9B,QAAQ,EAAE,eAAe;aACzB,MAAM,EAAE,aAAa;aACrB,QAAQ,EAAE,eAAe;aACzB,KAAK,EAAE,YAAY;aACnB,QAAQ,EAAE,eAAe;aACzB,KAAK,EAAE,YAAY;aACnB,IAAI,EAAE,WAAW;aACjB,UAAU,EAAE,iBAAiB;aAC7B,SAAS,EAAE,gBAAgB;aAC3B,IAAI,EAAE,WAAW;aACjB,OAAO,EAAE,cAAc;CACf,CAAA;AAEV,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAAA;IACrD,8DAA8D;IAC9D,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,QAAQ,CAAC,GAAG,IAAI,CAAA;CACjE,CAAA;AAID,wBAAsB,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAI7E;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAMxD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAG/F;AAED,wBAAgB,oBAAoB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,GAAG,cAAc,CAuLzM"}
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../src/runtime/sessions.ts"],"names":[],"mappings":"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"}

package/runtime/sessions.js

@@ -1,9 +1,16 @@
+import { ContextEnd, ContextStart } from '../session/context/context.js';
 import { Message } 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 { ToolResult } from '../session/context/turn/message/tool-result.js';
+import { TurnEnd, TurnStart } from '../session/context/turn/turn.js';
+import { GoalChange } from '../session/goal/goal.js';
+import { TaskEnd, TaskStart } from '../session/goal/task.js';
 import { Session } from '../session/session.js';
 import { matches, sentMatcher } from '../utils/matcher.js';
+import { foldAnswers } from './before.js';
 import { cmodPluginName } from './dependencies.js';
+export const everySession = '*';
 export const conversationMethods = {
     sessions: 'cmod:sessions',
     search: 'cmod:search',
@@ -13,10 +20,25 @@ export const conversationMethods = {
     tasks: 'cmod:tasks',
     goal: 'cmod:goal',
     updateGoal: 'cmod:updateGoal',
+    usage: 'cmod:usage',
     subscribe: 'cmod:subscribe',
-    send: 'cmod:send',
+    watchBefore: 'cmod:watchBefore',
+    act: 'cmod:act',
     changed: 'cmod:changed',
+    before: 'cmod:before',
 };
+const actPermissions = { send: 'prompt', startTask: 'tasks', usage: 'conversation', clients: 'conversation' };
+const startsTurns = ['CronCreate'];
+const ownSchedule = ['CronDelete', 'CronList'];
+export const beforePermission = (event) => (event === 'toolCall' ? 'tools' : event === TaskStart || event === TaskEnd ? 'tasks' : 'prompt');
+export const isAct = (action) => action === 'callTool' || action in actPermissions;
+export function toolPermission(tool) {
+    return startsTurns.includes(tool) ? 'prompt' : ownSchedule.includes(tool) ? undefined : 'tools';
+}
+export function actPermission(action, input) {
+    return action === 'callTool' ? (toolPermission(String(input?.name)) ?? 'tools') : actPermissions[action];
+}
+const asked = (action) => `cmod: ${action} runs only on a session's own main loop, and Claude Code gives a subagent's tasks no way to start a task or run a tool.`;
 export async function usageOf(claude) {
     const [model, usage] = await Promise.all([claude.session.model(), claude.session.usage()]);
     const { tokens, window, percent } = usage.context;
@@ -29,65 +51,233 @@ export function payloadOf(change) {
         return change.turn;
     if ('context' in change)
         return change.context;
-    if ('task' in change)
-        return change.task;
+    if ('task' in change) {
+        const { id, title, agentType, model, openedBy, openedAt, closedAt } = change.task;
+        return { id, title, openedBy, openedAt, ...(closedAt === undefined ? {} : { closedAt }), owner: { id, title, agentType, ...(model === undefined ? {} : { model }), startedAt: openedAt } };
+    }
+    if ('usage' in change)
+        return change.usage;
     return change.goal;
 }
 export function isHeardBy(event, matcher, change) {
-    const named = change.type === Message ? (event === Message || event === change.message.type) : event === change.type;
+    const named = change.type === Message ? event === Message || event === change.message.type : event === change.type;
     return named && (matcher === undefined || matches(payloadOf(change), matcher));
 }
-export function createSessionsClient({ name, claude, report }) {
+function taskOfChange(change) {
+    if (change.type === Message)
+        return change.message.task;
+    if (change.type === TaskStart || change.type === TaskEnd)
+        return change.task.id === '' ? change.task.parent : change.task.id;
+    if (change.type === TurnStart || change.type === TurnEnd)
+        return change.turn.prompt.task;
+    if (change.type === ContextStart || change.type === ContextEnd)
+        return change.context.task;
+    if (change.type === GoalChange)
+        return change.goal.task;
+    return undefined;
+}
+function ownerOfChange(change) {
+    if (change.type === TaskStart || change.type === TaskEnd)
+        return change.task.parent;
+    return taskOfChange(change);
+}
+function contextOfChange(change) {
+    if (change.type === Message)
+        return change.message.context;
+    if (change.type === TurnStart || change.type === TurnEnd)
+        return change.turn.context;
+    if (change.type === ContextStart || change.type === ContextEnd)
+        return change.context.number;
+    if (change.type === TaskStart || change.type === TaskEnd)
+        return change.task.context;
+    return undefined;
+}
+export function isInScope(scope, session, change, isUnder) {
+    if (scope.session !== undefined && scope.session !== session)
+        return false;
+    const task = taskOfChange(change);
+    if (scope.task !== undefined && (task === undefined || !isUnder(task, scope.task)))
+        return false;
+    if (scope.isGoal === true && change.type !== GoalChange && change.type !== TaskStart && (task === undefined || task === scope.task))
+        return false;
+    if (scope.context !== undefined && (contextOfChange(change) !== scope.context || ownerOfChange(change) !== scope.task))
+        return false;
+    if (scope.turn === undefined)
+        return true;
+    if (change.type === Message)
+        return change.message.turn === scope.turn;
+    return (change.type === TurnStart || change.type === TurnEnd) && change.turn.prompt.id === scope.turn;
+}
+export function createSessionsClient({ name, claude, report, isGranted }) {
     const call = (method, input) => claude.cmod.call({ to: cmodPluginName, method, input });
     const listening = new Map();
+    const deciding = new Map();
     const queued = new Set();
+    const parents = new Map();
+    const known = new Map();
     let current = { id: '', title: '', project: '', cwd: '', model: '', startedAt: '', lastAt: '', isRunning: true };
-    const subscribe = (session) => {
-        if (queued.has(session))
+    const keyOf = (scope) => scope.session ?? everySession;
+    const subscribe = (key) => {
+        if (queued.has(key))
             return;
-        queued.add(session);
+        queued.add(key);
         void Promise.resolve().then(async () => {
-            queued.delete(session);
-            const subscriptions = [...(listening.get(session) ?? [])].map(({ event, matcher }) => ({ event, matcher: matcher === undefined ? undefined : sentMatcher(matcher) }));
-            await call(conversationMethods.subscribe, { session, subscriptions }).catch((error) => report(`sessions:${session}`, `Hears nothing from session ${session}`, error));
+            queued.delete(key);
+            const heard = (from) => [...(from.get(key) ?? [])].map(({ event, matcher }) => ({ event, matcher: matcher === undefined ? undefined : sentMatcher(matcher) }));
+            const tracksTasks = [...(listening.get(key) ?? []), ...(deciding.get(key) ?? [])].some(({ scope }) => scope.task !== undefined || scope.isGoal === true);
+            const subscriptions = [...heard(listening), ...(tracksTasks ? [{ event: TaskStart }] : [])];
+            await call(conversationMethods.subscribe, { session: key, subscriptions }).catch((error) => report(`sessions:${key}`, `Hears nothing from ${key === everySession ? 'the other sessions' : `session ${key}`}`, error));
+            await call(conversationMethods.watchBefore, { session: key, subscriptions: heard(deciding) }).catch((error) => report(`before:${key}`, `Changes nothing in ${key === everySession ? 'the other sessions' : `session ${key}`}`, error));
         });
     };
-    const isCurrent = (id) => id === current.id;
-    const refuseElsewhere = (id, what) => {
-        throw new Error(`${name}: ${what} works on the session this mod runs in, and ${id} runs elsewhere or has ended.`);
+    const learnTasks = async (session) => {
+        if (parents.has(session))
+            return;
+        const tree = new Map();
+        parents.set(session, tree);
+        for (const task of await call(conversationMethods.tasks, { session, all: true }))
+            tree.set(task.id, task.parent);
+    };
+    const isUnderIn = (session) => (task, ancestor) => {
+        const tree = parents.get(session);
+        for (let at = task, steps = 0; at !== undefined && steps < 64; at = tree?.get(at), steps += 1)
+            if (at === ancestor)
+                return true;
+        return false;
     };
-    const turnOf = (session, data) => ({ ...data, messages: () => call(conversationMethods.messages, { session, turn: data.prompt.id }) });
-    const contextOf = (session, data) => ({
-        ...data,
-        turns: async () => (await call(conversationMethods.turns, { session, context: data.number })).map((turn) => turnOf(session, turn)),
+    const remember = (session, change) => {
+        if (change.type === TaskStart)
+            parents.get(session)?.set(change.task.id, change.task.parent);
+    };
+    const add = (into, scope, event, matcherOrListener, maybeListener, onChange) => {
+        const listener = (maybeListener ?? matcherOrListener);
+        const matcher = maybeListener === undefined ? undefined : matcherOrListener;
+        const key = keyOf(scope);
+        const entry = { scope, event, matcher, listener };
+        const set = into.get(key) ?? new Set();
+        set.add(entry);
+        into.set(key, set);
+        if (scope.task !== undefined || scope.isGoal === true)
+            void learnTasks(scope.session ?? current.id).catch((error) => report(`tasks:${key}`, 'Could not read the tasks it listens under', error));
+        onChange(key);
+        return {
+            dispose() {
+                for (const [at, held] of into) {
+                    if (!held.delete(entry))
+                        continue;
+                    if (held.size === 0)
+                        into.delete(at);
+                    onChange(at);
+                    return;
+                }
+            },
+        };
+    };
+    const combined = async (session, event, change, isInProject) => {
+        const askers = [...(deciding.get(session) ?? []), ...(isInProject ? (deciding.get(everySession) ?? []) : [])]
+            .filter((entry) => entry.event === event)
+            .map((entry) => async (latest) => {
+            if (!isInScope(entry.scope, session, latest, isUnderIn(session)))
+                return undefined;
+            if (entry.matcher !== undefined && !matches(payloadOf(latest), entry.matcher))
+                return undefined;
+            const answer = await entry.listener(payloadFor(session, latest));
+            if (answer === undefined || isGranted(beforePermission(event)))
+                return answer;
+            throw new Error(`Its before(${event}) answer changes nothing until ${beforePermission(event)} is turned on for ${name} in /mods.`);
+        });
+        return foldAnswers(event, change, askers, (error) => report(`before:${event}`, `The before(${event}) listener failed`, error));
+    };
+    const recordPart = (scope) => ({
+        search: (text, options = {}) => call(conversationMethods.search, { text, ...scope, ...optionsOf(options) }),
+        on: (event, matcherOrListener, maybeListener) => add(listening, scope, event, matcherOrListener, maybeListener, subscribe),
+        before: (event, matcherOrListener, maybeListener) => add(deciding, scope, event, matcherOrListener, maybeListener, subscribe),
     });
+    const turnOf = (scope, data) => {
+        const task = data.prompt.task ?? scope.task;
+        return {
+            ...data,
+            ...recordPart({ ...scope, ...(task === undefined ? {} : { task }), turn: data.prompt.id }),
+            messages: () => call(conversationMethods.messages, { session: scope.session, turn: data.prompt.id, ...(task === undefined ? {} : { task }) }),
+        };
+    };
+    const contextOf = (scope, data) => {
+        const owned = { ...(scope.session === undefined ? {} : { session: scope.session }), ...(data.task === undefined ? {} : { task: data.task }) };
+        return {
+            ...data,
+            ...recordPart({ ...owned, context: data.number }),
+            turns: async () => (await call(conversationMethods.turns, { ...owned, context: data.number })).map((turn) => turnOf(owned, turn)),
+        };
+    };
     const taskOf = (session, data) => ({
-        ...data,
-        messages: () => call(conversationMethods.messages, { session, task: data.id }),
+        id: data.id,
+        title: data.title,
+        openedBy: data.openedBy,
+        openedAt: data.openedAt,
+        ...(data.closedAt === undefined ? {} : { closedAt: data.closedAt }),
+        owner: ownerOf(session, data),
+        ...recordPart({ session, task: data.id }),
         tasks: async () => (await call(conversationMethods.tasks, { session, task: data.id })).map((task) => taskOf(session, task)),
+        messages: () => call(conversationMethods.messages, { session, task: data.id }),
     });
-    const goalOf = (session, data) => ({
+    const goalOf = (scope, data) => ({
         ...data,
+        ...recordPart({ ...scope, isGoal: true }),
+        tasks: async () => (await call(conversationMethods.tasks, { session: scope.session, ...(scope.task === undefined ? {} : { task: scope.task }) })).map((task) => taskOf(scope.session ?? current.id, task)),
         update: async ({ text }) => {
             if (text.trim() === '')
                 throw new Error(`${name}: a goal needs text.`);
-            await call(conversationMethods.updateGoal, { session, text });
+            await call(conversationMethods.updateGoal, { session: scope.session ?? current.id, ...(scope.task === undefined ? {} : { task: scope.task }), text });
         },
-        tasks: async () => (await call(conversationMethods.tasks, { session })).map((task) => taskOf(session, task)),
     });
     const payloadFor = (session, change) => {
+        const scope = { session };
         if (change.type === Message)
             return change.message;
         if ('turn' in change)
-            return turnOf(session, change.turn);
+            return turnOf(scope, change.turn);
         if ('context' in change)
-            return contextOf(session, change.context);
+            return contextOf(scope, change.context);
         if ('task' in change)
             return taskOf(session, change.task);
-        return goalOf(session, change.goal);
+        if ('usage' in change)
+            return change.usage;
+        return goalOf({ session, ...(change.goal.task === undefined ? {} : { task: change.goal.task }) }, { text: change.goal.text });
+    };
+    const act = (session, action, input, owned) => call(conversationMethods.act, { session: owned?.session ?? session, action, input, ...(owned === undefined ? {} : { task: owned.task }) });
+    const sendHere = async ({ type, text, as }) => {
+        if (type === Note) {
+            if (as !== undefined)
+                throw new Error(`${name}: a Note is always from this mod, so it takes no as.`);
+            const added = await claude.session.append({ message: { type: 'user', content: [{ type: 'text', text }] } });
+            if (added.deny !== undefined)
+                throw new Error(`${name}: Claude Code refused the note: ${added.deny}`);
+            return;
+        }
+        const submitted = await claude.prompt.submit({ text, ...(as === Person ? { asUser: true } : {}) });
+        if ('drop' in submitted && typeof submitted.drop === 'string')
+            throw new Error(`${name}: Claude Code dropped the prompt: ${submitted.drop}`);
     };
-    const sessionOf = (read) => {
+    const startHere = async (task) => {
+        const started = await claude.agent.spawn({
+            prompt: task.prompt,
+            ...(task.name === undefined ? {} : { description: task.name, name: task.name }),
+            ...(task.agentType === undefined ? {} : { subagentType: task.agentType }),
+            ...(task.model === undefined ? {} : { model: task.model }),
+            ...(task.cwd === undefined ? {} : { cwd: task.cwd }),
+        });
+        if (started.deny !== undefined)
+            throw new Error(`${name}: Claude Code refused the task: ${started.deny}`);
+        return taskOf(current.id, { id: started.agentId ?? '', title: task.name ?? '', agentType: task.agentType ?? 'general-purpose', model: started.model, openedBy: '', openedAt: new Date().toISOString() });
+    };
+    const clientsHere = async () => [...(await claude.session.surfaces())];
+    const sessionOf = (read, owned) => {
         const id = () => read().id;
+        const isHere = () => owned === undefined && id() === current.id;
+        const scope = () => (owned === undefined ? { session: id() } : { session: owned.session, task: owned.task });
+        const where = () => (owned === undefined ? { session: id() } : { session: owned.session, task: owned.task });
+        const turnsOf = async (options = {}) => (await call(conversationMethods.turns, { ...where(), ...options })).map((turn) => turnOf(scope(), turn));
+        const contextsOf = async () => (await call(conversationMethods.contexts, where())).map((context) => contextOf(scope(), context));
         const session = {
             get id() {
                 return read().id;
@@ -98,12 +288,18 @@ export function createSessionsClient({ name, claude, report }) {
             get project() {
                 return read().project;
             },
-            get cwd() {
-                return read().cwd;
+            get agentType() {
+                return read().agentType;
             },
             get model() {
                 return read().model;
             },
+            get cwd() {
+                return read().cwd;
+            },
+            get isRunning() {
+                return read().isRunning;
+            },
             get startedAt() {
                 return read().startedAt;
             },
@@ -113,123 +309,125 @@ export function createSessionsClient({ name, claude, report }) {
             get forkedFrom() {
                 return read().forkedFrom;
             },
-            get isRunning() {
-                return read().isRunning;
+            search: (text, options = {}) => recordPart(scope()).search(text, options),
+            on: (event, matcherOrListener, maybeListener) => recordPart(scope()).on(event, matcherOrListener, maybeListener),
+            before: (event, matcherOrListener, maybeListener) => recordPart(scope()).before(event, matcherOrListener, maybeListener),
+            goal: async () => goalOf(scope(), await call(conversationMethods.goal, where())),
+            context: async () => {
+                const all = await contextsOf();
+                const last = all.at(-1);
+                if (last === undefined)
+                    throw new Error(`${name}: session ${id()} has no context yet.`);
+                return last;
+            },
+            contexts: contextsOf,
+            turn: async () => {
+                const [last] = await turnsOf({ last: 1 });
+                return last?.closedAt === undefined ? last : undefined;
             },
-            async usage() {
-                if (!isCurrent(id()))
-                    refuseElsewhere(id(), 'usage()');
-                return usageOf(claude);
-            },
-            on(event, matcherOrListener, maybeListener) {
-                const listener = (maybeListener ?? matcherOrListener);
-                const matcher = maybeListener === undefined ? undefined : matcherOrListener;
-                const owner = id();
-                const heard = { event, matcher, listener };
-                const set = listening.get(owner) ?? new Set();
-                set.add(heard);
-                listening.set(owner, set);
-                subscribe(owner);
-                return {
-                    dispose() {
-                        if (!set.delete(heard))
-                            return;
-                        if (set.size === 0)
-                            listening.delete(owner);
-                        subscribe(owner);
-                    },
-                };
-            },
-            async send({ type, text, as }) {
-                if (text.trim() === '')
+            turns: turnsOf,
+            messages: (options = {}) => call(conversationMethods.messages, { ...where(), ...options }),
+            usage: async () => (isHere() ? usageOf(claude) : act(id(), 'usage', null, owned)),
+            clients: async () => (isHere() ? clientsHere() : act(id(), 'clients', null, owned)),
+            async send(message) {
+                if (message.text.trim() === '')
                     throw new Error(`${name}: send needs text.`);
-                if (isCurrent(id())) {
-                    if (as === Session)
-                        throw new Error(`${name}: send with as: Session messages another session, and this one runs this mod.`);
-                    if (type === Note) {
-                        if (as !== undefined)
-                            throw new Error(`${name}: a Note is always from this mod, so it takes no as.`);
-                        const added = await claude.session.append({ message: { type: 'user', content: [{ type: 'text', text }] } });
-                        if (added.deny !== undefined)
-                            throw new Error(`${name}: Claude Code refused the note: ${added.deny}`);
-                        return;
-                    }
-                    const submitted = await claude.prompt.submit({ text, ...(as === Person ? { asUser: true } : {}) });
-                    if ('drop' in submitted && typeof submitted.drop === 'string')
-                        throw new Error(`${name}: Claude Code dropped the prompt: ${submitted.drop}`);
-                    return;
-                }
-                if (!read().isRunning)
-                    throw new Error(`${name}: session ${id()} has ended, so it takes no messages.`);
-                if (as === Session) {
-                    if (type === Note)
-                        throw new Error(`${name}: a message from this session reaches Claude as a Prompt, so send it with type: Prompt.`);
-                    const sent = await claude.session.send({ to: { sessionId: id() }, text });
-                    if (sent.isDelivered !== true)
-                        throw new Error(`${name}: Claude Code could not deliver the message to session ${id()}.`);
-                    return;
-                }
-                await call(conversationMethods.send, { session: id(), type, text, ...(as === undefined ? {} : { as }) });
+                if (isHere() && message.as !== Session)
+                    return sendHere(message);
+                await act(id(), 'send', message, owned);
             },
             async startTask(task) {
-                if (!isCurrent(id()))
-                    refuseElsewhere(id(), 'startTask()');
-                const started = await claude.agent.spawn({
-                    prompt: task.prompt,
-                    ...(task.name === undefined ? {} : { description: task.name, name: task.name }),
-                    ...(task.agentType === undefined ? {} : { subagentType: task.agentType }),
-                    ...(task.model === undefined ? {} : { model: task.model }),
-                    ...(task.cwd === undefined ? {} : { cwd: task.cwd }),
-                });
-                if (started.deny !== undefined)
-                    throw new Error(`${name}: Claude Code refused the task: ${started.deny}`);
-                const data = { id: started.agentId ?? '', title: task.name ?? '', agentType: task.agentType ?? 'general-purpose', model: started.model, openedBy: '', openedAt: new Date().toISOString() };
-                return taskOf(id(), data);
-            },
-            messages: (options = {}) => call(conversationMethods.messages, { session: id(), ...options }),
-            turns: async (options = {}) => (await call(conversationMethods.turns, { session: id(), ...options })).map((turn) => turnOf(id(), turn)),
-            contexts: async () => (await call(conversationMethods.contexts, { session: id() })).map((context) => contextOf(id(), context)),
-            goal: async () => goalOf(id(), await call(conversationMethods.goal, { session: id() })),
+                if (owned !== undefined)
+                    throw new Error(asked('startTask'));
+                if (isHere())
+                    return startHere(task);
+                const started = await act(id(), 'startTask', task);
+                return taskOf(id(), started);
+            },
+            async callTool(toolCall) {
+                if (owned !== undefined)
+                    throw new Error(asked('callTool'));
+                return act(id(), 'callTool', toolCall);
+            },
         };
         return session;
     };
+    const ownerOf = (session, data) => {
+        const parent = session === current.id ? current : known.get(session);
+        return sessionOf(() => ({
+            id: data.id,
+            title: data.title,
+            project: parent?.project ?? '',
+            agentType: data.agentType,
+            model: data.model ?? '',
+            cwd: parent?.cwd ?? '',
+            isRunning: data.closedAt === undefined && (parent?.isRunning ?? true),
+            startedAt: data.openedAt,
+            lastAt: data.closedAt ?? data.openedAt,
+        }), { session, task: data.id });
+    };
     const currentSession = sessionOf(() => current);
+    const every = recordPart({});
+    const answerBefore = async (session, event, change, isInProject) => (isGranted('conversation') ? combined(session, event, change, isInProject) : undefined);
     return {
         sessions: {
             get current() {
                 return currentSession;
             },
             list: async (scope = {}) => (await call(conversationMethods.sessions, scope)).map((data) => {
-                if (data.id !== current.id)
-                    return sessionOf(() => data);
+                if (data.id !== current.id) {
+                    known.set(data.id, data);
+                    return sessionOf(() => known.get(data.id) ?? data);
+                }
                 if (current.title === '')
                     current = { ...current, title: data.title };
                 return currentSession;
             }),
-            search: (text, options = {}) => call(conversationMethods.search, { text, ...options, ...(options.before === undefined ? {} : { before: { session: options.before.session, id: options.before.id } }) }),
+            search: (text, options = {}) => call(conversationMethods.search, { text, ...optionsOf(options), ...(options.running === undefined ? {} : { running: options.running }), ...(options.since === undefined ? {} : { since: options.since }), ...(options.everyProject === undefined ? {} : { everyProject: options.everyProject }) }),
+            on: every.on,
+            before: every.before,
         },
-        changed(session, change) {
-            for (const { event, matcher, listener } of listening.get(session) ?? []) {
-                if (!isHeardBy(event, matcher, change))
-                    continue;
-                void Promise.resolve()
-                    .then(() => listener(payloadFor(session, change)))
-                    .catch((error) => report(`session:${event}`, `The ${event} listener failed`, error));
+        changed(session, change, isInProject) {
+            remember(session, change);
+            for (const key of isInProject ? [session, everySession] : [session]) {
+                for (const { scope, event, matcher, listener } of listening.get(key) ?? []) {
+                    if (!isHeardBy(event, matcher, change) || !isInScope(scope, session, change, isUnderIn(session)))
+                        continue;
+                    void Promise.resolve()
+                        .then(() => listener(payloadFor(session, change)))
+                        .catch((error) => report(`session:${event}`, `The ${event} listener failed`, error));
+                }
             }
         },
+        answerBefore,
         follow(next) {
             const moved = next.id !== current.id && current.id !== '';
             const previous = current.id;
             current = { ...next, title: next.title || (next.id === current.id ? current.title : ''), isRunning: true, lastAt: new Date().toISOString() };
             if (!moved)
                 return;
-            const kept = listening.get(previous);
-            if (kept === undefined)
-                return;
-            listening.delete(previous);
-            listening.set(current.id, kept);
+            for (const into of [listening, deciding]) {
+                const kept = into.get(previous);
+                if (kept === undefined)
+                    continue;
+                into.delete(previous);
+                for (const entry of kept)
+                    if (entry.scope.session === previous)
+                        entry.scope = { ...entry.scope, session: current.id };
+                into.set(current.id, new Set([...(into.get(current.id) ?? []), ...kept]));
+            }
+            parents.delete(previous);
             subscribe(previous);
             subscribe(current.id);
         },
     };
 }
+export function resultOf(where, answered) {
+    const base = { id: '', type: ToolResult, at: new Date().toISOString(), session: where.session, context: where.context, ...(where.turn === undefined ? {} : { turn: where.turn.prompt.id }), callId: '' };
+    if (answered.deny !== undefined)
+        return { ...base, text: answered.deny, isError: true };
+    return { ...base, text: answered.text ?? JSON.stringify(answered.result), isError: answered.isError === true };
+}
+function optionsOf(options) {
+    return { ...(options.limit === undefined ? {} : { limit: options.limit }), ...(options.before === undefined ? {} : { before: { session: options.before.session, id: options.before.id } }) };
+}

package/runtime/toaster.d.ts

@@ -1,5 +1,5 @@
 import type { ElementTable, RenderElement, RenderPropsOf } from 'claude-code';
-import type { Mod, Toast, ToastId, ToastType } from '../mod.js';
+import type { Toast, ToastId, ToastType } from '../mod.js';
 import type { Claude } from './claude.js';
 export type ShownToast = {
     readonly type: ToastType;
@@ -11,21 +11,14 @@ export type Failure = {
     readonly message: string;
     readonly error?: unknown;
     readonly description?: string;
+    readonly retry?: () => unknown;
 };
 export type Toaster = {
     readonly toast: Toast;
     copy(text: string): Promise<void>;
+    fail(failure: Failure): ToastId;
     readonly shown: readonly ShownToast[];
-    draw(drawn: RenderElement, table: ElementTable, band: RenderPropsOf['AbovePrompt']): RenderElement;
+    draw(drawn: RenderElement, table: ElementTable, band: RenderPropsOf['AbovePrompt'], bandId: string): RenderElement;
 };
-export declare function createToaster(claude: Claude, name: string): Toaster;
-export type FailureTarget = {
-    readonly name: string;
-    readonly ui: Pick<Mod['ui'], 'toast' | 'copy'>;
-    readonly claude: {
-        readonly plugin: Claude['plugin'];
-        readonly fs: Pick<Claude['fs'], 'read'>;
-    };
-};
-export declare function showFailure({ name, ui, claude }: FailureTarget, { id, message, error, description }: Failure): ToastId;
+export declare function createToaster(claude: Claude, name: string, version: () => string | undefined): Toaster;
 //# sourceMappingURL=toaster.d.ts.map