@cmodjs/core 0.3.0 → 1.5.0

package/runtime/sessions.js

@@ -0,0 +1,433 @@
+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',
+    messages: 'cmod:messages',
+    turns: 'cmod:turns',
+    contexts: 'cmod:contexts',
+    tasks: 'cmod:tasks',
+    goal: 'cmod:goal',
+    updateGoal: 'cmod:updateGoal',
+    usage: 'cmod:usage',
+    subscribe: 'cmod:subscribe',
+    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;
+    return { model, context: { ...(tokens === undefined ? {} : { tokens }), window, ...(percent === undefined ? {} : { percent }) }, ...(usage.cost === undefined ? {} : { cost: { usd: usage.cost.usd } }) };
+}
+export function payloadOf(change) {
+    if (change.type === Message)
+        return change.message;
+    if ('turn' in change)
+        return change.turn;
+    if ('context' in change)
+        return change.context;
+    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;
+    return named && (matcher === undefined || matches(payloadOf(change), matcher));
+}
+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 keyOf = (scope) => scope.session ?? everySession;
+    const subscribe = (key) => {
+        if (queued.has(key))
+            return;
+        queued.add(key);
+        void Promise.resolve().then(async () => {
+            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 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 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) => ({
+        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 = (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: scope.session ?? current.id, ...(scope.task === undefined ? {} : { task: scope.task }), text });
+        },
+    });
+    const payloadFor = (session, change) => {
+        const scope = { session };
+        if (change.type === Message)
+            return change.message;
+        if ('turn' in change)
+            return turnOf(scope, change.turn);
+        if ('context' in change)
+            return contextOf(scope, change.context);
+        if ('task' in change)
+            return taskOf(session, change.task);
+        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 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;
+            },
+            get title() {
+                return read().title;
+            },
+            get project() {
+                return read().project;
+            },
+            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;
+            },
+            get lastAt() {
+                return read().lastAt;
+            },
+            get forkedFrom() {
+                return read().forkedFrom;
+            },
+            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;
+            },
+            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 (isHere() && message.as !== Session)
+                    return sendHere(message);
+                await act(id(), 'send', message, owned);
+            },
+            async startTask(task) {
+                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) {
+                    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, ...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, 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;
+            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/state.d.ts

@@ -1,12 +1,15 @@
 import type { ClassicHookInputs } from 'claude-code';
 import type { Claude } from './claude.js';
+import type { Failure } from './toaster.js';
 export type StateOptions = {
     readonly name: string;
     readonly initial: object;
     readonly session: string;
     readonly root: string;
     readonly claude: Claude;
+    readonly report: (failure: Failure) => void;
     readonly changed: () => void;
+    readonly forkParent: () => Promise<string | undefined>;
 };
 export type ModState<State extends object> = {
     readonly state: State;
@@ -14,8 +17,9 @@ export type ModState<State extends object> = {
     changed(): void;
     load(): Promise<void>;
     moveTo(root: string): Promise<void>;
-    switchSession(session: string, source: ClassicHookInputs['SessionStart']['source']): Promise<void>;
+    switchSession(session: string, source: ClassicHookInputs['SessionStart']['source'], transcript: string): Promise<void>;
 };
 export declare function onStateChange(state: object, listener: () => void): void;
-export declare function createState<State extends object>({ name, initial, session, root, claude, changed: redraw }: StateOptions): ModState<State>;
+export declare function sessionsWith(claude: Pick<Claude, 'store'>, name: string, key: string, value: unknown): Promise<string[]>;
+export declare function createState<State extends object>({ name, initial, session, root, claude, report, changed: redraw, forkParent }: StateOptions): ModState<State>;
 //# sourceMappingURL=state.d.ts.map

package/runtime/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/runtime/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAQzC,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,MAAM,IAAI;IAC3C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,OAAO,IAAI,IAAI,CAAA;IACf,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACnG,CAAA;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAIvE;AAED,wBAAgB,WAAW,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,CAoF1I"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/runtime/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAQ3C,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CACvD,CAAA;AAED,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,MAAM,IAAI;IAC3C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,OAAO,IAAI,IAAI,CAAA;IACf,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACvH,CAAA;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAIvE;AAED,wBAAsB,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAO9H;AAED,wBAAgB,WAAW,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,CA6G9J"}

package/runtime/state.js

@@ -1,13 +1,21 @@
-import { messageOf } from '../utils/text.js';
 const lifetimes = ['memory', 'session', 'project', 'global'];
-const keptPerValue = 20;
+const keptProjects = 20;
 const listeners = new WeakMap();
 export function onStateChange(state, listener) {
     const own = listeners.get(state) ?? new Set();
     own.add(listener);
     listeners.set(state, own);
 }
-export function createState({ name, initial, session, root, claude, changed: redraw }) {
+export async function sessionsWith(claude, name, key, value) {
+    const prefix = `${name}.${key}.sessions.`;
+    const found = [];
+    for (const stored of (await claude.store.keys()).filter((each) => each.startsWith(prefix))) {
+        if ((await claude.store.get(stored)) === value)
+            found.push(stored.slice(prefix.length));
+    }
+    return found;
+}
+export function createState({ name, initial, session, root, claude, report, changed: redraw, forkParent }) {
     const changed = () => {
         redraw();
         for (const listener of listeners.get(state) ?? [])
@@ -20,21 +28,36 @@ export function createState({ name, initial, session, root, claude, changed: red
     let turn = Promise.resolve();
     const inTurn = (task) => {
         const run = turn.then(task);
-        turn = run.catch(() => undefined);
+        turn = Promise.allSettled([run]);
         return run;
     };
     const ownersKey = (lifetime, key) => `${name}.${key}.${lifetime === 'project' ? 'projects' : 'sessions'}.`;
     const storeKey = (lifetime, key, owner) => (lifetime === 'global' ? `${name}.${key}` : `${ownersKey(lifetime, key)}${owner}`);
     const read = (lifetime, key, owner) => claude.store.get(storeKey(lifetime, key, owner));
     const write = async (lifetime, key, value, owner) => {
-        if (lifetime === 'global')
+        if (lifetime !== 'project')
             return claude.store.set(storeKey(lifetime, key, owner), value);
         await claude.store.delete(storeKey(lifetime, key, owner));
         await claude.store.set(storeKey(lifetime, key, owner), value);
         const owners = (await claude.store.keys()).filter((stored) => stored.startsWith(ownersKey(lifetime, key)));
-        for (const oldest of owners.slice(0, -keptPerValue))
+        for (const oldest of owners.slice(0, -keptProjects))
             await claude.store.delete(oldest);
     };
+    const transcriptsKey = `${name}.$transcripts.`;
+    const forgetEndedSessions = async (current) => {
+        const stored = await claude.store.keys();
+        for (const recorded of stored.filter((key) => key.startsWith(transcriptsKey))) {
+            const owner = recorded.slice(transcriptsKey.length);
+            if (owner === current)
+                continue;
+            const transcript = await claude.store.get(recorded);
+            if (typeof transcript === 'string' && (await claude.fs.exists(transcript)))
+                continue;
+            for (const value of stored.filter((key) => key.startsWith(`${name}.`) && key.endsWith(`.sessions.${owner}`)))
+                await claude.store.delete(value);
+            await claude.store.delete(recorded);
+        }
+    };
     const loadGroups = async (only, next) => {
         const loaded = [];
         for (const lifetime of only) {
@@ -47,13 +70,14 @@ export function createState({ name, initial, session, root, claude, changed: red
             current[lifetime][key] = saved === undefined ? declared[lifetime][key] : frozen(name, `${lifetime}.${key}`, saved);
         changed();
     };
-    const copySession = async (nextSession) => {
+    const copySession = async (from, to) => {
         for (const key of Object.keys(declared.session)) {
-            const saved = await read('session', key, sessionId);
+            const saved = await read('session', key, from);
             if (saved !== undefined)
-                await write('session', key, saved, nextSession);
+                await write('session', key, saved, to);
         }
     };
+    const hasSaved = async (owner) => (await claude.store.keys()).some((key) => key.startsWith(`${name}.`) && key.endsWith(`.sessions.${owner}`));
     const group = (lifetime) => new Proxy(current[lifetime], {
         set(target, key, value) {
             if (typeof key !== 'string')
@@ -66,7 +90,7 @@ export function createState({ name, initial, session, root, claude, changed: red
             if (lifetime !== 'memory') {
                 const owner = lifetime === 'project' ? projectRoot : sessionId;
                 inTurn(() => write(lifetime, key, value, owner)).catch((error) => {
-                    claude.ui.log(`${name} could not keep state.${lifetime}.${key}: ${messageOf(error)}. Keep only JSON data in mod.state.`);
+                    report({ id: `state:${lifetime}.${key}`, message: `Could not keep state.${lifetime}.${key}. Keep only JSON data in mod.state`, error });
                 });
             }
             changed();
@@ -80,13 +104,22 @@ export function createState({ name, initial, session, root, claude, changed: red
             return projectRoot;
         },
         changed,
-        load: () => inTurn(() => loadGroups(lifetimes, { root: projectRoot, session: sessionId })),
+        load: () => inTurn(async () => {
+            if (Object.keys(declared.session).length > 0 && !(await hasSaved(sessionId))) {
+                const parent = await forkParent();
+                if (parent !== undefined)
+                    await copySession(parent, sessionId);
+            }
+            return loadGroups(lifetimes, { root: projectRoot, session: sessionId });
+        }),
         moveTo: (nextRoot) => inTurn(async () => (nextRoot === projectRoot ? undefined : loadGroups(['project'], { root: nextRoot, session: sessionId }))),
-        switchSession: (nextSession, source) => inTurn(async () => {
+        switchSession: (nextSession, source, transcript) => inTurn(async () => {
+            await claude.store.set(`${transcriptsKey}${nextSession}`, transcript);
+            await forgetEndedSessions(nextSession);
             if (nextSession === sessionId)
                 return;
             if (source === 'fork')
-                await copySession(nextSession);
+                await copySession(sessionId, nextSession);
             return loadGroups(['memory', 'session'], { root: projectRoot, session: nextSession });
         }),
     };

package/runtime/toaster.d.ts

@@ -0,0 +1,24 @@
+import type { ElementTable, RenderElement, RenderPropsOf } from 'claude-code';
+import type { Toast, ToastId, ToastType } from '../mod.js';
+import type { Claude } from './claude.js';
+export type ShownToast = {
+    readonly type: ToastType;
+    readonly message: string;
+    readonly description?: string;
+};
+export type Failure = {
+    readonly id: string;
+    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'], bandId: string): RenderElement;
+};
+export declare function createToaster(claude: Claude, name: string, version: () => string | undefined): Toaster;
+//# sourceMappingURL=toaster.d.ts.map

package/runtime/toaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toaster.d.ts","sourceRoot":"","sources":["../src/runtime/toaster.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAS,MAAM,aAAa,CAAA;AACpF,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAgB,SAAS,EAAE,MAAM,WAAW,CAAA;AAIxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,MAAM,MAAM,UAAU,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9G,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,OAAO,CAAA;CAAE,CAAA;AAEhK,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACjC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAA;IACrC,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAAA;CACnH,CAAA;AAsCD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,MAAM,GAAG,SAAS,GAAG,OAAO,CAwOtG"}