@cmodjs/core 0.1.11 → 0.1.13

package/runtime/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/runtime/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAiE,MAAM,aAAa,CAAA;AAC3H,OAAO,KAAK,EAAa,GAAG,EAAE,aAAa,EAAqB,MAAM,WAAW,CAAA;AAIjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGzC,OAAO,EAAsG,KAAK,WAAW,EAAE,MAAM,YAAY,CAAA;AACjJ,OAAO,EAA6B,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAKxE,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,KAAK,GAAG,UAAU,GAAG,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEtG,MAAM,MAAM,SAAS,CAAC,KAAK,SAAS,MAAM,IAAI;IAC5C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/E,KAAK,CAAC,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;CACzG,CAAA;AAiCD,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBhE;AAkCD,wBAAgB,eAAe,CAAC,KAAK,SAAS,MAAM,EAAE,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,iBAAiB,GAAE,MAAM,OAAoB,GAAG,SAAS,CAAC,KAAK,CAAC,CAkOvJ"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/runtime/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAiE,MAAM,aAAa,CAAA;AAC3H,OAAO,KAAK,EAAa,GAAG,EAAE,aAAa,EAAqB,MAAM,WAAW,CAAA;AAIjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGzC,OAAO,EAAsG,KAAK,WAAW,EAAE,MAAM,YAAY,CAAA;AACjJ,OAAO,EAA6B,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAKxE,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAChD,CAAA;AAED,MAAM,MAAM,KAAK,GAAG,UAAU,GAAG,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEtG,MAAM,MAAM,SAAS,CAAC,KAAK,SAAS,MAAM,IAAI;IAC5C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/E,KAAK,CAAC,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;CACzG,CAAA;AAkCD,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBhE;AAkCD,wBAAgB,eAAe,CAAC,KAAK,SAAS,MAAM,EAAE,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,iBAAiB,GAAE,MAAM,OAAoB,GAAG,SAAS,CAAC,KAAK,CAAC,CAiPvJ"}

package/runtime/lifecycle.js

@@ -1,4 +1,4 @@
-import { dataFolder, isAtLeast, parseEvent, readRecord, readSteps, scriptsSha256, storeFolder } from '../records.js';
+import { dataFolder, isAtLeast, oldestCmodFor, parseEvent, readRecord, readSteps, scriptsSha256, storeFolder } from '../records.js';
 import { relativePath } from '../utils/paths.js';
 import { formatExit, listed, messageOf } from '../utils/text.js';
 import { beforeDeadline } from './deadline.js';
@@ -30,12 +30,12 @@ export async function readPlugin(claude) {
     const manifest = (await readJson(read, `${root}/.claude-plugin/plugin.json`));
     const version = typeof manifest?.version === 'string' ? manifest.version : undefined;
     const store = storeFolder({ HOME: await claude.env.home(), XDG_DATA_HOME: await claude.env.dataHome() });
-    const plugin = { name, root, version, store };
     if (name === cmodPluginName) {
         const installed = await cmodVersion(claude);
-        return { ...plugin, isInstalled: version !== undefined && installed !== undefined && isAtLeast(installed, version), shouldRecord: false };
+        return { name, root, version, store, keys: {}, isInstalled: version !== undefined && installed !== undefined && isAtLeast(installed, version), shouldRecord: false };
     }
     const steps = readSteps(await readJson(read, `${root}/package.json`)) ?? {};
+    const plugin = { name, root, version, store, keys: steps.keys ?? {} };
     const record = await readRecord(read, store, name);
     if (Object.keys(steps).length === 0)
         return { ...plugin, isInstalled: true, shouldRecord: record?.version !== version };
@@ -136,7 +136,7 @@ export function createLifecycle(definition, checksPermissions = () => true) {
         if (runtime === undefined || plugin === undefined)
             return;
         const activeRouter = createRouter();
-        const active = await createMod(definition, { ...runtime, router: activeRouter, dataFolder: dataFolder(plugin.store, plugin.name), checksPermissions }).catch((error) => {
+        const active = await createMod(definition, { ...runtime, router: activeRouter, dataFolder: dataFolder(plugin.store, plugin.name), keys: plugin.keys, checksPermissions }).catch((error) => {
             fail(messageOf(error), 'Fix it, then run /reload-plugins.');
             throw error;
         });
@@ -171,8 +171,12 @@ export function createLifecycle(definition, checksPermissions = () => true) {
             return;
         }
         showLine().wait('Waiting for your answer');
-        const removal = event.uninstall === '' ? '' : `, and ${event.uninstall} when you remove it`;
-        const answer = await claude().ui.ask(`${name} runs ${event.install} to install${removal}. Run it now?`, { options: ['Install', 'Not now'], header: 'Install' });
+        const actions = [
+            ...(event.install === '' ? [] : [`runs ${event.install} to install`]),
+            ...(event.uninstall === '' ? [] : [`runs ${event.uninstall} when you remove it`]),
+            ...(event.keys === '' ? [] : [`binds ${event.keys}`]),
+        ];
+        const answer = await claude().ui.ask(`${name} ${listed(actions)}. Install it now?`, { options: ['Install', 'Not now'], header: 'Install' });
         if (answer === 'Install')
             return install(event.sha256);
         phase = 'declined';
@@ -185,8 +189,9 @@ export function createLifecycle(definition, checksPermissions = () => true) {
         if (plugin.name === cmodPluginName)
             return bootstrap(plugin.root);
         phase = 'installing';
-        if ((await cmodVersion(claude())) === undefined)
-            return waitForcmod();
+        const found = await cmodVersion(claude());
+        if (!fits(found))
+            return waitForcmod(found);
         endLine();
         const progress = showLine();
         let outcome;
@@ -205,9 +210,11 @@ export function createLifecycle(definition, checksPermissions = () => true) {
         const reason = outcome?.kind === 'failed' ? outcome.message : `cmod setup ${formatExit(code, lastError)}`;
         fail(reason, `Fix the cause, then run: cmod install ${definition.name}`);
     };
-    const waitForcmod = () => {
+    const fits = (found) => found !== undefined && isAtLeast(found, oldestCmodFor(plugin?.keys ?? {}));
+    const waitForcmod = (found) => {
         phase = 'waiting';
         showLine().wait('Waiting for cmod');
+        let latest = found;
         let check;
         const stop = () => {
             timer.cancel();
@@ -217,7 +224,8 @@ export function createLifecycle(definition, checksPermissions = () => true) {
             check ??= cmodVersion(claude())
                 .then((version) => {
                 check = undefined;
-                if (version === undefined)
+                latest = version;
+                if (!fits(version))
                     return;
                 stop();
                 return install();
@@ -227,7 +235,9 @@ export function createLifecycle(definition, checksPermissions = () => true) {
                 report(error);
             });
         });
-        const longWait = claude().clock.after(cmodWaitMs, () => showLine().wait("Still waiting for cmod to download cmod. See cmod's own line."));
+        const longWait = claude().clock.after(cmodWaitMs, () => showLine().wait(latest === undefined
+            ? "Still waiting for cmod to download cmod. See cmod's own line."
+            : `PATH finds cmod ${latest}, and ${definition.name} needs cmod ${oldestCmodFor(plugin?.keys ?? {})} or later. Run npm i -g @cmodjs/cli, or put ~/.local/bin ahead of the old cmod on PATH.`));
     };
     const bootstrap = async (root) => {
         const progress = showLine();
@@ -320,7 +330,8 @@ export function createLifecycle(definition, checksPermissions = () => true) {
     };
 }
 async function createMod(definition, runtime) {
-    const { claude, router, progress } = runtime;
+    const { router, progress } = runtime;
+    const claude = checkingKeys(runtime.claude, definition.name, runtime.keys);
     const added = [];
     const hookEvents = [];
     const announce = (feature) => {
@@ -337,15 +348,30 @@ async function createMod(definition, runtime) {
         name: definition.name,
         state: modState.state,
         dataFolder: runtime.dataFolder,
-        on(event, hook) {
+        on(event, hook, options) {
+            const bounded = options?.timeoutMs === undefined ? hook : timedHook(definition.name, event, hook, checkedMs(definition.name, `the ${event} hook's timeoutMs`, options.timeoutMs), claude);
             if (!hookEvents.includes(event))
                 hookEvents.push(event);
             if (event === 'PreToolUse')
-                router.add('tool.call', preToolUseHook(definition.name, hook, claude, agents, held));
+                router.add('tool.call', preToolUseHook(definition.name, bounded, claude, agents, held));
             else
-                router.add(`classic.${event}`, classicHook(definition.name, event, hook, claude, agents));
+                router.add(`classic.${event}`, classicHook(definition.name, event, bounded, claude, agents));
         },
         use: (job) => job({ mod, claude, on: (event, hook) => router.add(event, hook), announce, reserveName, toolCalls: agents }),
+        every(ms, hook) {
+            let isRunning = false;
+            return claude.clock.every(checkedMs(definition.name, 'mod.every', ms), () => {
+                if (isRunning)
+                    return;
+                isRunning = true;
+                void Promise.resolve()
+                    .then(hook)
+                    .catch((error) => claude.ui.log(`${definition.name}: the every ${ms} ms hook failed: ${messageOf(error)}`))
+                    .finally(() => {
+                    isRunning = false;
+                });
+            });
+        },
         ui: area.ui,
         process: {
             run: (argv, init) => claude.process.run(argv, init),
@@ -360,8 +386,21 @@ async function createMod(definition, runtime) {
         },
         http: { fetch: (url, init) => claude.http.fetch(url, init) },
         settings: { read: (args) => claude.settings.read(args) },
-        session: { messages: claude.session.messages },
+        session: {
+            messages: claude.session.messages,
+            async append(text) {
+                const added = await claude.session.append({ message: { type: 'user', content: [{ type: 'text', text }] } });
+                if (added.deny !== undefined)
+                    throw new Error(`${definition.name}: Claude Code refused the note: ${added.deny}`);
+            },
+            async submit(text) {
+                const submitted = await claude.prompt.submit({ text });
+                if ('drop' in submitted && typeof submitted.drop === 'string')
+                    throw new Error(`${definition.name}: Claude Code dropped the prompt: ${submitted.drop}`);
+            },
+        },
         agent: { spawn: (args) => claude.agent.spawn(args) },
+        model: { complete: (request, options) => claude.model.complete(request, options) },
         get projectRoot() {
             return modState.root;
         },
@@ -448,6 +487,43 @@ async function createMod(definition, runtime) {
         added.push(`${hookEvents.length === 1 ? 'a hook' : 'hooks'} on ${listed(hookEvents)}`);
     return { mod, added };
 }
+function checkingKeys(claude, name, keys) {
+    const bound = Object.entries(keys);
+    if (bound.length === 0)
+        return claude;
+    const register = (command) => {
+        for (const [key, commandName] of bound) {
+            if (commandName === command.name && command.immediate !== true) {
+                claude.ui.log(`${name}: ${key} runs /${command.name}, which waits for Claude's turn to end and adds a row to the conversation. Give /${command.name} immediate: true.`);
+            }
+        }
+        return claude.command.register(command);
+    };
+    return { ...claude, command: { ...claude.command, register } };
+}
+const longestTimerMs = 2_147_483_647;
+function checkedMs(name, subject, ms) {
+    if (!Number.isInteger(ms) || ms <= 0 || ms > longestTimerMs)
+        throw new Error(`${name}: ${subject} is ${ms}. Give a whole number of milliseconds above 0 and at most ${longestTimerMs}.`);
+    return ms;
+}
+function timedHook(name, event, hook, ms, claude) {
+    return (input) => new Promise((resolve, reject) => {
+        const timer = claude.clock.after(ms, () => {
+            claude.ui.log(`${name}: the ${event} hook passed its ${ms / 1000} s timeout`);
+            resolve(undefined);
+        });
+        Promise.resolve()
+            .then(() => hook(input))
+            .then((answer) => {
+            timer.cancel();
+            resolve(answer);
+        }, (error) => {
+            timer.cancel();
+            reject(error);
+        });
+    });
+}
 async function failsAs(subject, step) {
     try {
         await step();

package/runtime/state.d.ts

@@ -15,5 +15,6 @@ export type ModState<State extends object> = {
     moveTo(root: string): Promise<void>;
     switchSession(session: string, source: ClassicHookInputs['SessionStart']['source']): Promise<void>;
 };
-export declare function createState<State extends object>({ name, initial, session, root, claude, changed }: StateOptions): ModState<State>;
+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>;
 //# 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;AAGpD,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,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,WAAW,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,CAqIlI"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/runtime/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAGpD,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,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;AAUD,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,CAyI1I"}

package/runtime/state.js

@@ -3,7 +3,18 @@ import { messageOf } from '../utils/text.js';
 const lifetimes = ['memory', 'session', 'project', 'global'];
 const savedLifetimes = ['session', 'project', 'global'];
 const keptPerValue = 20;
-export function createState({ name, initial, session, root, claude, changed }) {
+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 }) {
+    const changed = () => {
+        redraw();
+        for (const listener of listeners.get(state) ?? [])
+            listener();
+    };
     const declared = declaredGroups(name, initial);
     const current = copied(declared);
     let defaults = declared;

package/src/jobs/check.ts

@@ -1,6 +1,6 @@
 import type { Job } from '../mod.js'
 import { longestMs, type Deadline } from '../runtime/deadline.js'
-import { callEffects, type ToolUse } from '../utils/call-effects.js'
+import { callEffects, type ToolCall } from '../utils/call-effects.js'
 import { dirname } from '../vendor.js'
 import { listed, messageOf } from '../utils/text.js'
 import { afterCall, modOf, targetWords } from './context.js'
@@ -39,7 +39,7 @@ export function check<State extends object = Record<never, never>>(options: { re
   }
 }
 
-async function triggeredRun(after: readonly Target[], run: readonly string[], use: ToolUse, workspace: Workspace): Promise<{ command: string[]; folder: string } | undefined> {
+async function triggeredRun(after: readonly Target[], run: readonly string[], use: ToolCall, workspace: Workspace): Promise<{ command: string[]; folder: string } | undefined> {
   const effects = callEffects(use, workspace)
   const paths = new Set<string>()
   let commandFolder: string | undefined

package/src/jobs/context.ts

@@ -5,7 +5,7 @@ import { beforeDeadline, type Deadline } from '../runtime/deadline.js'
 import { dependencyCalls } from '../runtime/dependencies.js'
 import { toolInputOf } from '../runtime/tool-calls.js'
 import { listed } from '../utils/text.js'
-import type { ToolCall, ToolUse } from '../utils/call-effects.js'
+import type { ToolCall } from '../utils/call-effects.js'
 import { findProjectScope, type Workspace } from './permissions/find-project-scope.js'
 import { targetOf, type Target } from './permissions/match-target.js'
 import type { FileSystem } from '../utils/paths.js'
@@ -36,7 +36,7 @@ async function readSession(claude: Claude): Promise<Session> {
 
 export function afterCall<State extends object>(
   job: JobContext<State>,
-  contextAfter: (use: ToolUse, workspace: Workspace) => Promise<readonly string[]>,
+  contextAfter: (call: ToolCall, workspace: Workspace) => Promise<readonly string[]>,
   failed: (error: unknown) => readonly string[],
 ): void {
   const readWorkspace = workspaceReader(job)
@@ -50,7 +50,7 @@ export function afterCall<State extends object>(
   })
 }
 
-async function useOf({ toolCalls }: JobContext, e: Frozen<Args<'tool.call'>>): Promise<ToolUse> {
+async function useOf({ toolCalls }: JobContext, e: Frozen<Args<'tool.call'>>): Promise<ToolCall> {
   return { tool: e.tool, input: toolInputOf(e), ...(await toolCalls.agentOf(e.tool_use_id)) }
 }
 
@@ -109,8 +109,8 @@ function spawnWithin(claude: Claude, deadline: Deadline, started: Promise<Stream
 }
 
 export function targetWords(target: Target): string {
-  const { key, patterns } = targetOf(target)
-  const named = listed(patterns)
+  const { key, patterns, exclusions } = targetOf(target)
+  const named = exclusions.length === 0 ? listed(patterns) : `${listed(patterns)} except ${listed(exclusions)}`
   if (key === 'command') return patterns.includes('*') ? 'every shell command' : named
   if (key === 'write') return `edits to ${named}`
   if (key === 'read') return `reads of ${named}`

package/src/jobs/permissions/decide-permission.ts

@@ -1,6 +1,6 @@
 import { strictness } from '../../runtime/hooks.js'
 import { messageOf } from '../../utils/text.js'
-import { callBaseOf, callEffects, type CallEffects, type ToolCall, type ToolUse } from '../../utils/call-effects.js'
+import { callBaseOf, callEffects, type CallEffects, type ToolCall } from '../../utils/call-effects.js'
 import type { Workspace } from './find-project-scope.js'
 import { folderInScope, matchTarget, targetOf, type MatchedCall, type Target, type TargetCalls, type TargetKey, type TargetOf } from './match-target.js'
 import { resolve } from '../../vendor.js'
@@ -22,7 +22,7 @@ export function stricterVerdict<Result extends Verdict>(first: Result, second: R
   return strictness.indexOf(second.decision) > strictness.indexOf(first.decision) ? second : first
 }
 
-export async function decidePermission<Mod>(rules: PermissionRules<Mod>, use: ToolUse, workspace: Workspace, modOf: (call: ToolCall, folder: string) => Mod): Promise<Verdict | undefined> {
+export async function decidePermission<Mod>(rules: PermissionRules<Mod>, use: ToolCall, workspace: Workspace, modOf: (call: ToolCall, folder: string) => Mod): Promise<Verdict | undefined> {
   try {
     const effects = callEffects(use, workspace)
     for (const decision of ['deny', 'ask'] as const) {
@@ -39,7 +39,7 @@ export async function decidePermission<Mod>(rules: PermissionRules<Mod>, use: To
   }
 }
 
-async function ruleOutcome<Mod>(rule: Rule<Mod>, use: ToolUse, effects: CallEffects, workspace: Workspace, modOf: (call: ToolCall, folder: string) => Mod): Promise<{ failure: string | undefined } | undefined> {
+async function ruleOutcome<Mod>(rule: Rule<Mod>, use: ToolCall, effects: CallEffects, workspace: Workspace, modOf: (call: ToolCall, folder: string) => Mod): Promise<{ failure: string | undefined } | undefined> {
   const matched = await matchTarget(rule, use, effects, workspace)
   const calls = matched.length > 0 ? matched : await unparsedMatches(rule, use, effects, workspace)
   if (calls.length === 0) return undefined
@@ -56,7 +56,7 @@ async function ruleOutcome<Mod>(rule: Rule<Mod>, use: ToolUse, effects: CallEffe
   return undefined
 }
 
-async function unparsedMatches(target: Target, use: ToolUse, effects: CallEffects, workspace: Workspace): Promise<MatchedCall[]> {
+async function unparsedMatches(target: Target, use: ToolCall, effects: CallEffects, workspace: Workspace): Promise<MatchedCall[]> {
   const shell = effects.shell
   if (shell === undefined || shell.isFullyParsed) return []
   const { key, patterns } = targetOf(target)

package/src/jobs/permissions/match-target.ts

@@ -1,6 +1,6 @@
 import { matchesGlob } from '../../utils/matches-glob.js'
 import { parseShell } from '../../utils/parse-shell.js'
-import { callBaseOf, type CallBase, type CallEffects, type CommandCall, type FetchCall, type FileAccess, type FileCall, type ToolCall, type ToolUse } from '../../utils/call-effects.js'
+import { callBaseOf, type CallBase, type CallEffects, type CommandCall, type FetchCall, type FileAccess, type FileCall, type ToolCall } from '../../utils/call-effects.js'
 import type { Workspace } from './find-project-scope.js'
 import { realPathOf, relativePath } from '../../utils/paths.js'
 import { basename } from '../../vendor.js'
@@ -13,45 +13,53 @@ export type MatchedCall = { call: ToolCall; access: FileAccess | undefined; fold
 
 const targetKeys: readonly TargetKey[] = ['command', 'read', 'write', 'fetch', 'subagent', 'tool']
 
-export function targetOf(target: Target): { key: TargetKey; patterns: string[] } {
+export function targetOf(target: Target): { key: TargetKey; patterns: string[]; exclusions: string[] } {
   const keys = targetKeys.filter((key) => key in target)
   const key = keys[0]
   const value: unknown = key === undefined ? undefined : (target as Partial<Record<TargetKey, unknown>>)[key]
   if (key === undefined || keys.length > 1 || !(typeof value === 'string' || (Array.isArray(value) && value.every((pattern) => typeof pattern === 'string')))) {
     throw new Error(`A rule names exactly one of ${targetKeys.join(', ')} with a pattern or a list of patterns; this one names ${keys.join(' and ') || 'none'}.`)
   }
-  return { key, patterns: typeof value === 'string' ? [value] : value }
+  const all = typeof value === 'string' ? [value] : value
+  const patterns = all.filter((pattern) => !pattern.startsWith('!'))
+  if (patterns.length === 0) throw new Error(`A ${key} target needs a pattern without "!" for its "!" patterns to leave calls out of, such as ['**', ${all.map((pattern) => `'${pattern}'`).join(', ')}].`)
+  return { key, patterns, exclusions: all.filter((pattern) => pattern.startsWith('!')).map((pattern) => pattern.slice(1)) }
 }
 
-export async function matchTarget(target: Target, use: ToolUse, effects: CallEffects, workspace: Workspace): Promise<MatchedCall[]> {
-  const { key, patterns } = targetOf(target)
-  const base = callBaseOf(use)
-  const only = (call: ToolCall, folder = workspace.cwd): MatchedCall[] => [{ call, access: undefined, folder }]
+export async function matchTarget(target: Target, call: CallBase, effects: CallEffects, workspace: Workspace): Promise<MatchedCall[]> {
+  const { key, patterns, exclusions } = targetOf(target)
+  const base = callBaseOf(call)
+  const only = (matched: ToolCall, folder = workspace.cwd): MatchedCall[] => [{ call: matched, access: undefined, folder }]
+  const isNamed = (value: string) => matchesAny(value, patterns) && !matchesAny(value, exclusions)
   if (key === 'read' || key === 'write') {
     const matched: MatchedCall[] = []
     for (const access of key === 'read' ? effects.reads : effects.writes) {
       const path = await matchedPath(patterns, access.path, workspace)
-      if (path !== undefined) matched.push({ call: { ...base, path }, access, folder: workspace.cwd })
+      const isExcluded = path !== undefined && exclusions.length > 0 && (await matchedPath(exclusions, access.path, workspace)) !== undefined
+      if (path !== undefined && !isExcluded) matched.push({ call: { ...base, path }, access, folder: workspace.cwd })
     }
     return matched
   }
   if (key === 'command') {
     const shell = effects.shell
     if (shell === undefined) return []
-    const call = { ...base, commands: shell.commands.map((command) => command.argv), isFullyParsed: shell.isFullyParsed }
-    if (patterns.includes('*')) {
+    const commandCall = { ...base, commands: shell.commands.map((command) => command.argv), isFullyParsed: shell.isFullyParsed }
+    const isEvery = patterns.includes('*')
+    if (isEvery && exclusions.length === 0) {
       const folder = await folderInScope(shell, workspace)
-      return folder === undefined ? [] : only(call, folder)
+      return folder === undefined ? [] : only(commandCall, folder)
     }
-    const wanted = patterns.map(commandPattern)
+    const wanted = patterns.filter((pattern) => pattern !== '*').map(commandPattern)
+    const unwanted = exclusions.map(commandPattern)
     for (const command of shell.commands) {
-      if (wanted.some((pattern) => commandMatches(pattern, command.argv)) && (await isInScope(command.folder, workspace))) return only(call, command.folder)
+      const isWanted = isEvery || wanted.some((pattern) => commandMatches(pattern, command.argv))
+      if (isWanted && !unwanted.some((pattern) => commandMatches(pattern, command.argv)) && (await isInScope(command.folder, workspace))) return only(commandCall, command.folder)
     }
     return []
   }
-  if (key === 'fetch') return effects.urls.filter((url) => matchesAny(url, patterns)).map((url) => ({ call: { ...base, url }, access: undefined, folder: workspace.cwd }))
-  if (key === 'subagent') return effects.subagent !== undefined && matchesAny(effects.subagent, patterns) ? only(base) : []
-  return matchesAny(use.tool, patterns) ? only(base) : []
+  if (key === 'fetch') return effects.urls.filter(isNamed).map((url) => ({ call: { ...base, url }, access: undefined, folder: workspace.cwd }))
+  if (key === 'subagent') return effects.subagent !== undefined && isNamed(effects.subagent) ? only(base) : []
+  return isNamed(call.tool) ? only(base) : []
 }
 
 function commandPattern(pattern: string): [string, ...string[]] {

package/src/jobs/permissions.ts

@@ -1,7 +1,7 @@
 import type { Args, Frozen } from 'claude-code'
 import type { Job, Mod } from '../mod.js'
 import type { Deadline } from '../runtime/deadline.js'
-import type { ToolUse } from '../utils/call-effects.js'
+import { inputOf } from '../utils/call-effects.js'
 import { decidePermission, stricterVerdict, type PermissionRules as RulesFor, type Rule as RuleFor, type Verdict } from './permissions/decide-permission.js'
 import { targetOf } from './permissions/match-target.js'
 import { messageOf } from '../utils/text.js'
@@ -14,19 +14,24 @@ export type PermissionRules<State extends object = Record<never, never>> = Rules
 
 const deadline: Deadline = { ms: 2000, job: 'permissions' }
 
-export function permissions<State extends object = Record<never, never>>(rules: PermissionRules<State>): Job<void, State> {
-  const count = (rules.deny?.length ?? 0) + (rules.ask?.length ?? 0)
+export function permissions<State extends object = Record<never, never>>(rules: PermissionRules<State> | ((state: State) => PermissionRules<State>)): Job<void, State> {
+  const count = typeof rules === 'function' ? undefined : checkedCount(rules)
   if (count === 0) throw new Error('permissions: give it a deny or an ask rule, or remove it from setup.')
-  for (const rule of [...(rules.deny ?? []), ...(rules.ask ?? [])]) targetOf(rule)
 
   return (job) => {
     const readWorkspace = workspaceReader(job)
 
     const verdictOf = async (e: Frozen<Args<'tool.check'>>): Promise<Verdict | undefined> => {
+      let current: PermissionRules<State>
+      try {
+        current = typeof rules === 'function' ? rules(job.mod.state as State) : rules
+        checkedCount(current)
+      } catch (error) {
+        return { decision: 'deny', reason: `The permission rules of ${job.mod.name} failed, so it denies the call: ${messageOf(error)}` }
+      }
       try {
         const [agent, workspace] = await Promise.all([job.toolCalls.agentOf(e.tool_use_id), readWorkspace()])
-        const use: ToolUse = { tool: e.tool, input: e.input, ...agent }
-        return await decidePermission(rules, use, workspace, (call, folder) => modOf(job, { call, folder }, workspace, deadline))
+        return await decidePermission(current, { tool: e.tool, input: inputOf(e.input), ...agent }, workspace, (call, folder) => modOf(job, { call, folder }, workspace, deadline))
       } catch (error) {
         return { decision: 'deny', reason: `The permissions job could not read the session, so it denies the call: ${messageOf(error)}` }
       }
@@ -36,6 +41,12 @@ export function permissions<State extends object = Record<never, never>>(rules:
       const [below, ours] = await Promise.all([next(e), verdictOf(e)])
       return ours === undefined ? below : stricterVerdict<Verdict>(below, ours)
     })
-    job.announce(`${count} permission rule${count === 1 ? '' : 's'}`)
+    job.announce(count === undefined ? 'permission rules from its state' : `${count} permission rule${count === 1 ? '' : 's'}`)
   }
 }
+
+function checkedCount<Mod>(rules: RulesFor<Mod>): number {
+  const all = [...(rules.deny ?? []), ...(rules.ask ?? [])]
+  for (const rule of all) targetOf(rule)
+  return all.length
+}

package/src/jobs/prompt.ts

@@ -1,5 +1,6 @@
 import type { Job, JobContext, Mod } from '../mod.js'
 import { longestMs, type Deadline } from '../runtime/deadline.js'
+import { onStateChange } from '../runtime/state.js'
 import { listed, messageOf } from '../utils/text.js'
 import { callEffects, type ToolCall } from '../utils/call-effects.js'
 import { matchTarget, targetOf, type Target } from './permissions/match-target.js'
@@ -48,21 +49,48 @@ export function prompt<State extends object = Record<never, never>>({ name, prom
       addAfterCalls(job, targets, headedText, log)
       job.announce(`the ${name} prompt after ${listed(targets.map(targetWords))}`)
     } else {
-      addOncePerConversation(job, name, () => textFor({}, modWithin(job, deadline)), log)
+      addKeptCurrent(job, name, () => textFor({}, modWithin(job, deadline)), log)
       job.announce(`the ${name} prompt`)
     }
   }
 }
 
-function addOncePerConversation(job: JobContext, name: string, textFor: () => Promise<string | undefined>, log: (reason: string) => void): void {
+function addKeptCurrent<State extends object>(job: JobContext<State>, name: string, textFor: () => Promise<string | undefined>, log: (reason: string) => void): void {
+  let given: string | undefined
+  let hasStarted = false
+  let isQueued = false
+  let updates = Promise.resolve()
+
+  job.on('classic.SessionStart', (e, next) => {
+    hasStarted = e.source === 'resume' || e.source === 'compact'
+    if (!hasStarted) given = undefined
+    return next(e)
+  })
   job.on('prompt.context', async (e, next) => {
     const below = await next(e)
+    hasStarted = true
     if (below.blocks.some((block) => block.name === name)) {
       log(`a block named "${name}" is already in the context`)
       return below
     }
+    given = await textFor()
+    return given === undefined ? below : { ...below, blocks: [...below.blocks, { name, text: given }] }
+  })
+
+  const update = async () => {
+    isQueued = false
+    if (!hasStarted) return
     const value = await textFor()
-    return value === undefined ? below : { ...below, blocks: [...below.blocks, { name, text: value }] }
+    if (value === undefined || value === given) return
+    given = value
+    await job.claude.session.append({ message: { type: 'user', content: [{ type: 'text', text: `# ${name}\n${value}` }] } }).then((added) => {
+      if (added.deny !== undefined) log(`Claude Code refused the new text: ${added.deny}`)
+    })
+  }
+  onStateChange(job.mod.state, () => {
+    if (isQueued) return
+    isQueued = true
+    updates = updates.then(update).catch((error: unknown) => log(messageOf(error)))
   })
 }
 

package/src/jobs/schedule.ts

@@ -0,0 +1,65 @@
+import type { Job } from '../mod.js'
+import { onStateChange } from '../runtime/state.js'
+import { messageOf } from '../utils/text.js'
+
+export type Schedule = { readonly cron: string; readonly prompt: string }
+
+const scheduleCounts = new WeakMap<object, number>()
+
+export function schedule<State extends object = Record<never, never>>(entry: Schedule | ((state: State) => Schedule | undefined)): Job<void, State> {
+  if (typeof entry !== 'function') checked(entry)
+
+  return (job) => {
+    const { mod, claude } = job
+    const order = scheduleCounts.get(mod) ?? 0
+    scheduleCounts.set(mod, order + 1)
+    const storeKey = `cmod:schedule:${order}`
+    const log = (reason: string) => claude.ui.log(`${mod.name}: the schedule ${reason}`)
+    let current: { readonly id: string; readonly wanted: string } | undefined
+    let isQueued = false
+
+    const remove = async (id: string) => {
+      await claude.tool.call({ tool: 'CronDelete', id }).catch(() => undefined)
+      await claude.store.delete(storeKey)
+    }
+
+    const update = async () => {
+      isQueued = false
+      let next: Schedule | undefined
+      try {
+        next = typeof entry === 'function' ? entry(mod.state as State) : entry
+        if (next !== undefined) checked(next)
+      } catch (error) {
+        log(`kept its last cron: ${messageOf(error)}`)
+        return
+      }
+      const wanted = next === undefined ? undefined : JSON.stringify([next.cron, next.prompt])
+      if (wanted === current?.wanted) return
+      if (current !== undefined) await remove(current.id)
+      current = undefined
+      if (next === undefined) return
+      const answer = await claude.tool.call({ tool: 'CronCreate', cron: next.cron, prompt: next.prompt, recurring: true })
+      if (answer.deny !== undefined) return log(`was refused: ${answer.deny}`)
+      if (answer.isError === true) return log(`failed: ${answer.text ?? 'CronCreate answered an error'}`)
+      current = { id: answer.result.id, wanted: wanted as string }
+      await claude.store.set(storeKey, current.id)
+    }
+
+    let updates = claude.store
+      .get(storeKey)
+      .then((left) => (typeof left === 'string' ? remove(left) : undefined))
+      .then(update)
+      .catch((error: unknown) => log(`failed: ${messageOf(error)}`))
+    onStateChange(mod.state, () => {
+      if (isQueued) return
+      isQueued = true
+      updates = updates.then(update).catch((error: unknown) => log(`failed: ${messageOf(error)}`))
+    })
+    job.announce(typeof entry === 'function' ? 'a schedule from its state' : `a schedule at ${entry.cron}`)
+  }
+}
+
+function checked(entry: Schedule): void {
+  if (entry.cron.trim() === '') throw new Error('schedule: give it a cron, such as "*/10 * * * *" for every 10 minutes.')
+  if (entry.prompt.trim() === '') throw new Error('schedule: give it the prompt Claude gets at each fire.')
+}