@cmodjs/core 0.1.5 → 0.1.7

package/docs/commands.md

@@ -82,8 +82,8 @@ cmod publish [path] [--dry-run]
 
 Releases the mod at `path` (default: the current folder) at the version in its `plugin.json`:
 
-1. Builds the release from the committed files, leaving out `cli/`, `.github/`, and `.claude/`.
-2. Bundles the hooks module that `hooks/hooks.json` names, with the mod's source and packages, into one readable `.js` file, and points `hooks/hooks.json` at it. Anthropic's plugin directory reads a repository without installing its packages, so it can follow a mod only when all its code is in one file.
+1. Builds the release from the committed files, leaving out `cli/`, `.github/`, and `.claude/`. A `"files"` list in `package.json` limits the release to the paths it lists, plus the folders of the install and uninstall steps, `.claude-plugin/`, `package.json`, the README, and the license, the way `npm publish` reads it. List every folder the hooks module imports from, such as `"files": ["hooks", "src", "skills"]`, because the bundle in step 2 is built from the release.
+2. Bundles the hooks module that `hooks/hooks.json` names, with the mod's source and packages, into one readable `.js` file, writes each control character in it as a `\u` escape, and points `hooks/hooks.json` at it. Anthropic's plugin directory reads a repository without installing its packages, so it can follow a mod only when all its code is in one file.
 3. Checks the release with `claude plugin validate --strict`, and stops with the validator's message when it fails.
 4. Commits the release as the `release` branch, and builds the release archive from that commit.
 5. Builds the program `cli/` declares, and writes `SHA256SUMS` for every file of the release.
@@ -91,7 +91,7 @@ Releases the mod at `path` (default: the current folder) at the version in its `
 7. Commits that file, tags `v<version>`, pushes the tag and the `release` branch, and creates the GitHub release.
 8. Prints the link to paste as the Repository when you submit the mod at [claude.ai/directory/manage](https://claude.ai/directory/manage), such as `https://github.com/owner/greeter/tree/release`. The portal reads the branch from the link, so the directory follows `release`.
 
-The release keeps `package.json` and `bun.lock`, so Claude Code still installs the mod's packages for its install and uninstall steps. `main` keeps the source only.
+The release keeps `package.json`, so Claude Code still installs the mod's packages for its install and uninstall steps. It keeps `bun.lock` too, unless a `"files"` list leaves it out. `main` keeps the source only.
 
 It needs, and refuses to start without:
 
@@ -101,6 +101,7 @@ It needs, and refuses to start without:
 - the `claude` command, which validates the release
 - an `origin` remote on GitHub
 - a `package.json` with no dependency on a `file:` or `link:` path, which no user has
+- a `"files"` list, when `package.json` has one, whose every path matches a committed file
 - a `"program"` in the `cmod` key of `package.json` that names the program `cli/` declares, when `cli/` declares one
 - the network, to hash the CMod plugin release it lists, unless the mod is CMod itself
 - for a real publish, a working tree with no uncommitted changes, a `v<version>` tag that does not exist yet, a `git push` to `origin` that succeeds, and the `gh` command, which creates the GitHub release

package/docs/hooks.md

@@ -12,6 +12,8 @@ type ModHook<E> = (input: HookInputs[E]) => HookAnswer | void | Promise<HookAnsw
 
 Add hooks in `setup`. Each `mod.on` adds one more hook. Several hooks on one event all run.
 
+A hook on `PreToolUse` or `PermissionRequest` takes part in Claude Code's permission check, so the mod's `hooks/register.ts` calls `registerPermissionCheck(addHook)` after `registerMod` ([mod.md](mod.md)). Without it the mod does not start.
+
 ```ts
 import { defineMod } from '../node_modules/@cmodjs/core/mod.js'
 

package/docs/index.md

@@ -15,7 +15,7 @@ my-mod/
 ├── .gitignore                          node_modules/ and .claude-plugin/types/
 ├── .oxlintrc.json                      leaves .claude-plugin/types/ out of the lint
 ├── hooks/hooks.json                    names hooks/register.ts as the hooks module
-├── hooks/register.ts                   connect(on, myMod), and nothing else
+├── hooks/register.ts                   registerMod(addHook, myMod), and nothing else
 ├── src/mod.tsx                         defineMod: the state, the setup, the hooks, the panes
 ├── src/state.ts                        the starting state
 ├── src/panes/prompts.tsx               one definePane per file
@@ -70,11 +70,11 @@ A mod imports from the files below, and every other file in this package is inte
 
 | Import | Exports | Docs |
 | --- | --- | --- |
-| `mod.js` | `defineMod`, `ModDefinition`, `Mod`, `PartContext`, `Part`, `ProgressStep`, `PaneHandle`, `longestMs`, `messageOf` | [mod.md](mod.md), [jobs.md](jobs.md), [ui.md](ui.md) |
+| `mod.js` | `defineMod`, `ModDefinition`, `Mod`, `JobContext`, `Job`, `ProgressStep`, `PaneHandle`, `longestMs`, `messageOf` | [mod.md](mod.md), [jobs.md](jobs.md), [ui.md](ui.md) |
 | `mod.js` | `Claude`, `RoutedEvent`, `RoutedHook`, `ToolCalls` | [jobs.md](jobs.md) |
 | `mod.js` | `ModEvent`, `ModHook`, `HookAnswer` | [hooks.md](hooks.md) |
 | `mod.js` | `notInstalled` | [dependencies.md](dependencies.md) |
-| `connect.js` | `connect` | [mod.md](mod.md) |
+| `register.js` | `registerMod`, `registerPermissionCheck` | [mod.md](mod.md) |
 | `testing.js` | `testMod`, `TestOptions`, `TestInput`, `TestedMod`, `Fakes`, `Shown`, `TestCall` | [testing.md](testing.md) |
 | `ui/define-pane.js` | `definePane`, `Pane` | [ui.md](ui.md) |
 | `ui/elements.js` | `Box`, `Text`, `Button`, `Link`, `Code`, `Markdown`, `Input`, `Select`, `Image`, `drawWith` | [ui.md](ui.md) |
@@ -87,7 +87,7 @@ A mod imports from the files below, and every other file in this package is inte
 | `jobs/prompt.js` | `prompt` | [jobs.md](jobs.md) |
 | `jobs/status-line.js` | `statusLine`, `Usage` | [jobs.md](jobs.md) |
 | `jobs/program.js` | `program`, `Program` | [jobs.md](jobs.md) |
-| `jobs/part-context.js` | `afterCall`, `modWithin`, `modOf`, `workspaceReader` | [jobs.md](jobs.md) |
+| `jobs/context.js` | `afterCall`, `modWithin`, `modOf`, `workspaceReader` | [jobs.md](jobs.md) |
 | `jobs/permissions/decide-permission.js` | `decidePermission`, `stricterVerdict`, `Rule`, `PermissionRules`, `Decision`, `Verdict` | [jobs.md](jobs.md) |
 | `jobs/permissions/find-project-scope.js` | `findProjectScope`, `ProjectScope`, `Workspace` | [jobs.md](jobs.md) |
 

package/docs/jobs.md

@@ -1,16 +1,16 @@
 # Jobs
 
-A job is a ready-made part of a mod: a slash command, a tool, permission rules, a check, a prompt, a status line, or a background program. Add each in `setup` with `mod.use`.
+A job is a ready-made feature of a mod: a slash command, a tool, permission rules, a check, a prompt, a status line, or a background program. Add each in `setup` with `mod.use`.
 
 ```ts
-mod.use<Handle>(part: Part<Handle, State>): Handle
+mod.use<Handle>(job: Job<Handle, State>): Handle
 
-type Part<Handle, State> = (context: PartContext<State>) => Handle
+type Job<Handle, State> = (context: JobContext<State>) => Handle
 ```
 
-Each job function, such as `slashCommand(options)`, returns a `Part`. `mod.use` runs the part and returns its handle. A job that has nothing to hand back returns `void`.
+Each job function, such as `slashCommand(options)`, returns a `Job`. `mod.use` runs the job and returns its handle. A job that has nothing to hand back returns `void`.
 
-A job's bad options throw at one of two times. `check`, `permissions`, and `prompt` check their options when the job function is called. `slashCommand`, `tool`, `statusLine`, and `program` check theirs inside the part, at `mod.use`, so the error surfaces as `its setup function threw: …`.
+A job's bad options throw at one of two times. `check`, `permissions`, and `prompt` check their options when the job function is called. `slashCommand`, `tool`, `statusLine`, and `program` check theirs when the job runs, at `mod.use`, so the error surfaces as `its setup function threw: …`.
 
 | Job | Import | Adds |
 | --- | --- | --- |
@@ -48,7 +48,7 @@ slashCommand<State>(options: {
   readonly argumentHint?: string
   readonly immediate?: true
   readonly reply: (input: { args: string; positionals: string[] }, mod: Mod<State>) => Reply | void | Promise<Reply | void>
-}): Part<void, State>
+}): Job<void, State>
 
 type Reply = string | { text?: string; context?: string } | undefined
 ```
@@ -94,7 +94,7 @@ tool<Schema, State>(options: {
   readonly description: string
   readonly inputSchema?: Schema
   readonly execute: (input: FromSchema<Schema>, mod: Mod<State>) => unknown
-}): Part<{ readonly name: string }, State>
+}): Job<{ readonly name: string }, State>
 ```
 
 - `name` is 1 to 64 letters, digits, `_`, or `-`. Claude sees the tool as `mcp__<plugin name>__<name>`, and the handle's `name` is that full name.
@@ -160,7 +160,7 @@ A `command` pattern is not a glob. CMod splits it into words the way it splits a
 ## permissions
 
 ```ts
-permissions<State>(rules: { deny?: Rule<State>[]; ask?: Rule<State>[] }): Part<void, State>
+permissions<State>(rules: { deny?: Rule<State>[]; ask?: Rule<State>[] }): Job<void, State>
 
 type Rule<State> = Target & {
   when?: (call: <the call of the target's key>, mod: Mod<State>) => boolean | Promise<boolean>
@@ -174,6 +174,7 @@ type Rule<State> = Target & {
 - When CMod cannot read the call or the session, it denies the call with the reason.
 - For a PowerShell command, or a Bash command CMod cannot fully parse, a `command` rule matches when every word of its pattern appears in the command line. A `read` or `write` rule matches when the command line holds the last segment of its pattern, after the last `/`, and only when that segment holds none of `*?[]{}`. So `{ write: 'Domain.md' }` matches such a command that names `Domain.md`, and `{ write: '**/.env*' }` never matches one.
 - `permissions({})` throws `permissions: give it a deny or an ask rule, or remove it from setup.`
+- A mod that uses `permissions` calls `registerPermissionCheck(addHook)` after `registerMod` in `hooks/register.ts` ([mod.md](mod.md)). Without it the mod does not start.
 
 `when` gets the call, typed by the target's key. `jobs/permissions.js` exports each type:
 
@@ -211,7 +212,7 @@ export const guard = defineMod({
 ## check
 
 ```ts
-check<State>(options: { readonly after: Target | Target[]; readonly run: readonly string[]; readonly timeoutMs?: number }): Part<void, State>
+check<State>(options: { readonly after: Target | Target[]; readonly run: readonly string[]; readonly timeoutMs?: number }): Job<void, State>
 ```
 
 - After each call that matches `after` and succeeds, CMod runs `run`. A call that was denied or failed runs nothing.
@@ -241,7 +242,7 @@ prompt<State>(options: {
   prompt: string | ((input: { userPrompt?: string; call?: ToolCall }, mod: Mod<State>) => string | undefined | Promise<string | undefined>)
   when?: RegExp | ((userPrompt: string) => boolean)
   after?: Target | Target[]
-}): Part<void, State>
+}): Job<void, State>
 ```
 
 `prompt` adds text that Claude reads. `when` and `after` pick when:
@@ -277,7 +278,7 @@ export const conventions = defineMod({
 statusLine<State>(options: {
   readonly text: (usage: Usage, mod: Mod<State>) => string | undefined | Promise<string | undefined>
   readonly interval?: number
-}): Part<void, State>
+}): Job<void, State>
 
 type Usage = { model: string; context: { tokens?: number; window: number; percent?: number }; cost?: { usd: number } }
 ```
@@ -303,7 +304,7 @@ export const usage = defineMod({
 ## program
 
 ```ts
-program(options: { readonly command: readonly string[]; readonly environment?: Record<string, string> }): Part<Program>
+program(options: { readonly command: readonly string[]; readonly environment?: Record<string, string> }): Job<Program>
 
 type Program = {
   readonly state: 'stopped' | 'starting' | 'running' | 'backoff' | 'fatal'
@@ -345,10 +346,10 @@ export const preview = defineMod({
 
 ## Write a job of your own
 
-A `Part` is a function. `mod.use` calls it with a `PartContext` and returns what it returns:
+A `Job` is a function. `mod.use` calls it with a `JobContext` and returns what it returns:
 
 ```ts
-type PartContext<State> = {
+type JobContext<State> = {
   readonly mod: Mod<State>
   readonly claude: Claude
   on<N extends RoutedEvent>(event: N, hook: RoutedHook<N>): void
@@ -360,16 +361,16 @@ type PartContext<State> = {
 
 - `claude` reaches Claude Code itself. [The claude members](#the-claude-members) lists each one.
 - `claude.store` is where CMod saves `mod.state`, under keys that start with `<mod>.`, such as `<mod>.<key>`. A job of your own never writes those keys, or it changes the mod's state behind CMod's back.
-- `on` adds a Claude Code hook-module handler, `(e, next) => …`, on a `classic.<ModEvent>` event or on `tool.check`, `tool.call`, `prompt.submit`, `prompt.context`, `command.run`, `session.measure`, `skill.prompt`, `ui.render`, `ui.press`, `ui.close`, or `cmod.call`. The handler calls `next(e)` to pass the event on.
+- `on` adds a Claude Code hook-module handler, `(e, next) => …`, on a `classic.<ModEvent>` event or on `tool.check`, `tool.call`, `prompt.submit`, `prompt.context`, `command.run`, `session.measure`, `skill.prompt`, `ui.render`, `ui.press`, `ui.close`, or `cmod.call`. The handler calls `next(e)` to pass the event on. A job with a handler on `tool.check`, `classic.PreToolUse`, or `classic.PermissionRequest` needs `registerPermissionCheck` in `hooks/register.ts` ([mod.md](mod.md)).
 - `announce` adds a phrase to the list CMod logs when the mod first starts.
 - `reserveName` throws `taken` when the mod already reserved that `kind` and `name`. A job calls it to refuse a duplicate.
 - `toolCalls.agentOf(toolUseId)` resolves `{ agentId?, agentType? }`, the subagent behind a call.
-- `toolCalls.cwdOf(toolUseId)` returns the working folder at the call's `PreToolUse`, or `undefined` once its `PostToolUse` or `PostToolUseFailure` has run. CMod keeps the folders of the last 100 calls.
+- `toolCalls.cwdOf(toolUseId)` returns the working folder when the call ran, or `undefined` once its `PostToolUse` or `PostToolUseFailure` has run. CMod keeps the folders of the last 100 calls.
 
 ```ts
-import { defineMod, type Part } from '../node_modules/@cmodjs/core/mod.js'
+import { defineMod, type Job } from '../node_modules/@cmodjs/core/mod.js'
 
-const clock: Part<{ now(): Promise<number> }> = ({ claude, announce }) => {
+const clock: Job<{ now(): Promise<number> }> = ({ claude, announce }) => {
   announce('a clock')
   return { now: () => claude.clock.now() }
 }
@@ -436,10 +437,10 @@ The built-in jobs are written from these building blocks, which a job of your ow
 
 | Import | Export | What it does |
 | --- | --- | --- |
-| `jobs/part-context.js` | `afterCall(part, contextAfter, failed)` | Runs `contextAfter` after each call that succeeds, and adds the lines it returns to the call's result. |
-| `jobs/part-context.js` | `modWithin(part, deadline, workTree?)` | A `mod` whose calls fail at `deadline`, `{ ms, job?, longestMs? }`. |
-| `jobs/part-context.js` | `modOf(part, { call?, folder }, workspace, deadline)` | `modWithin`, with `mod.process` calls run in the call's work tree. |
-| `jobs/part-context.js` | `workspaceReader(part)` | A function that reads the session's `projectRoot`, `cwd`, `home`, file access, and project scope. |
+| `jobs/context.js` | `afterCall(job, contextAfter, failed)` | Runs `contextAfter` after each call that succeeds, and adds the lines it returns to the call's result. |
+| `jobs/context.js` | `modWithin(job, deadline, workTree?)` | A `mod` whose calls fail at `deadline`, `{ ms, job?, longestMs? }`. |
+| `jobs/context.js` | `modOf(job, { call?, folder }, workspace, deadline)` | `modWithin`, with `mod.process` calls run in the call's work tree. |
+| `jobs/context.js` | `workspaceReader(job)` | A function that reads the session's `projectRoot`, `cwd`, `home`, file access, and project scope. |
 | `jobs/permissions/decide-permission.js` | `decidePermission`, `stricterVerdict`, and the types `Rule`, `PermissionRules`, `Decision`, `Verdict` | Decides a call against permission rules. |
 | `jobs/permissions/find-project-scope.js` | `findProjectScope`, and the types `ProjectScope`, `Workspace` | Finds the repository a project plugin belongs to. |
 

package/docs/mod.md

@@ -1,6 +1,6 @@
 # Define a mod
 
-`defineMod` describes a mod: its name, its state, the methods it offers other mods, and the `setup` function that attaches everything to Claude Code. `connect` hands the definition to Claude Code.
+`defineMod` describes a mod: its name, its state, the methods it offers other mods, and the `setup` function that attaches everything to Claude Code. `registerMod` registers the definition with Claude Code.
 
 ## defineMod
 
@@ -51,28 +51,43 @@ When a step fails, the mod does not start. Its progress line above the prompt na
 - `its state did not load: <error>` when reading the saved values or a `state.json` fails.
 - `its setup function threw: <error>` when `setup` throws or rejects.
 - `its open panes did not load: <error>` when Claude Code cannot list the open panes.
+- `it decides permissions on <events>, so hooks/register.ts must call registerPermissionCheck(addHook) after registerMod` when `setup` adds a hook on `PreToolUse` or `PermissionRequest`, or a job that decides permissions, and `register.ts` does not register the permission check.
 
 Each of these says `Fix it, then run /reload-plugins.`
 
-## Connect the mod to Claude Code
+## Register the mod with Claude Code
 
-`hooks/hooks.json` names `hooks/register.ts` as the plugin's hooks module. `register.ts` calls `connect` and does nothing else:
+`hooks/hooks.json` names `hooks/register.ts` as the plugin's hooks module. `register.ts` calls `registerMod` and does nothing else:
 
 ```ts
 import type { On } from 'claude-code'
-import { connect } from '../node_modules/@cmodjs/core/connect.js'
+import { registerMod } from '../node_modules/@cmodjs/core/register.js'
 import { greeter } from '../src/mod.js'
 
-export function register(on: On): void {
-  connect(on, greeter)
+export function register(addHook: On): void {
+  registerMod(addHook, greeter)
 }
 ```
 
 ```ts
-connect<State>(on: On, definition: ModDefinition<State>): void
+registerMod<State>(addHook: On, definition: ModDefinition<State>): void
+registerPermissionCheck(addHook: On): void
 ```
 
-`connect` registers one handler per Claude Code event the mod can use, and routes each event to the mod. Keep `register.ts` this small. Claude Code checks a hooks module before it loads it, and refuses some shapes, such as a `$` passed to a function in another module. Declare `register` as a function, as here: `cmod publish` bundles the hooks module into one file, and Claude Code refuses a bundled `register` that is not one.
+`registerMod` registers one handler per Claude Code event the mod can use, and routes each event to the mod. It leaves out Claude Code's permission check, the events `tool.check`, `PreToolUse`, and `PermissionRequest`.
+
+A mod that decides permissions calls `registerPermissionCheck` after `registerMod`. That covers a hook on `PreToolUse` or `PermissionRequest`, the `permissions` job, and a job of your own on `tool.check`:
+
+```ts
+export function register(addHook: On): void {
+  registerMod(addHook, guard)
+  registerPermissionCheck(addHook)
+}
+```
+
+A mod without it has no part in Claude Code's permission check, so the plugin directory reads it as one that never answers a permission. A mod that decides permissions without it does not start, and its progress line names the line to add.
+
+Keep `register.ts` this small. Claude Code checks a hooks module before it loads it, and refuses some shapes, such as a `$` passed to a function in another module. The plugin directory reads the bundled module too, and flags it when the name of `register`'s first parameter is declared anywhere else in the bundle. `@cmodjs/core` declares `on` as the method `mod.on`, so name that parameter `addHook`. Declare `register` as a function, as here: `cmod publish` bundles the hooks module into one file, and Claude Code refuses a bundled `register` that is not one.
 
 ## What `mod` can call
 
@@ -86,7 +101,7 @@ type Mod<State> = {
   readonly projectRoot: string
   readonly cwd: string
   on(event, hook): void
-  use(part): Handle
+  use(job): Handle
   readonly ui: { pane, render, toast, progress, ask }
   readonly process: { run, spawn }
   readonly fs: { read, write, list }

package/docs/testing.md

@@ -69,7 +69,7 @@ type TestedMod<State> = {
 
 ### start
 
-Starts the mod: loads its state, runs `setup`, and adds its parts. `fire`, `lines`, `type`, `callTool`, `press`, and `moveTo` start the mod first, so a test calls `start` only before it reads `state` or `shown` with nothing else to run. It rejects with the reason when the mod does not start.
+Starts the mod: loads its state, runs `setup`, and adds its hooks, panes, and jobs. `fire`, `lines`, `type`, `callTool`, `press`, and `moveTo` start the mod first, so a test calls `start` only before it reads `state` or `shown` with nothing else to run. It rejects with the reason when the mod does not start.
 
 ### fire
 

package/jobs/check.d.ts

@@ -1,8 +1,8 @@
-import type { Part } from '../mod.js';
+import type { Job } from '../mod.js';
 import { type Target } from './permissions/match-target.js';
 export declare function check<State extends object = Record<never, never>>(options: {
     readonly after: Target | Target[];
     readonly run: readonly string[];
     readonly timeoutMs?: number;
-}): Part<void, State>;
+}): Job<void, State>;
 //# sourceMappingURL=check.d.ts.map

package/jobs/check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../src/jobs/check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAOrC,OAAO,EAAyB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAIlF,wBAAgB,KAAK,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CA4BlM"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../src/jobs/check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAOpC,OAAO,EAAyB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAIlF,wBAAgB,KAAK,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CA4BjM"}

package/jobs/check.js

@@ -2,7 +2,7 @@ import { longestMs } from '../runtime/deadline.js';
 import { callEffects } from '../utils/call-effects.js';
 import { parentOf } from '../utils/paths.js';
 import { listed, messageOf } from '../utils/text.js';
-import { afterCall, modOf, targetWords } from './part-context.js';
+import { afterCall, modOf, targetWords } from './context.js';
 import { matchTarget, targetOf } from './permissions/match-target.js';
 const defaultMs = 60_000;
 export function check(options) {
@@ -18,21 +18,21 @@ export function check(options) {
     if (!(timeoutMs > 0 && timeoutMs <= longestMs))
         throw new Error(`check: the ${named} has timeoutMs ${timeoutMs}. Set it above 0 and at most ${longestMs} (${longestMs / 60_000} minutes).`);
     const deadline = { ms: timeoutMs, job: 'check' };
-    return (context) => {
-        afterCall(context, async (use, workspace) => {
+    return (job) => {
+        afterCall(job, async (use, workspace) => {
             const triggered = await triggeredRun(targets, run, use, workspace);
             if (triggered === undefined)
                 return [];
             try {
                 const { command, folder } = triggered;
-                const { exitCode, stdout, stderr } = await modOf(context, { folder }, workspace, deadline).process.run(command);
+                const { exitCode, stdout, stderr } = await modOf(job, { folder }, workspace, deadline).process.run(command);
                 return exitCode === 0 ? [] : [`${command.join(' ')} exited with ${exitCode}:\n${`${stdout}${stderr}`.trim()}`];
             }
             catch (error) {
                 return [`The ${named} failed: ${messageOf(error)}`];
             }
         }, (error) => [`The check job failed, so the ${named} did not run: ${messageOf(error)}`]);
-        context.announce(`a ${named}`);
+        job.announce(`a ${named}`);
     };
 }
 async function triggeredRun(after, run, use, workspace) {

package/jobs/context.d.ts

@@ -0,0 +1,14 @@
+import type { JobContext, Mod } from '../mod.js';
+import { type Deadline } from '../runtime/deadline.js';
+import type { ToolCall, ToolUse } from '../utils/call-effects.js';
+import { type Workspace } from './permissions/find-project-scope.js';
+import { type Target } from './permissions/match-target.js';
+export declare function workspaceReader({ claude }: JobContext): () => Promise<Workspace>;
+export declare function afterCall<State extends object>(job: JobContext<State>, contextAfter: (use: ToolUse, workspace: Workspace) => Promise<readonly string[]>, failed: (error: unknown) => readonly string[]): void;
+export declare function modOf<State extends object>(job: JobContext<State>, { call, folder }: {
+    readonly call?: ToolCall;
+    readonly folder: string;
+}, workspace: Workspace, deadline: Deadline): Mod<State>;
+export declare function modWithin<State extends object>({ mod, claude }: JobContext<State>, deadline: Deadline, workTree?: () => Promise<string | undefined>): Mod<State>;
+export declare function targetWords(target: Target): string;
+//# sourceMappingURL=context.d.ts.map

package/jobs/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/jobs/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAEhD,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAItE,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,qCAAqC,CAAA;AACtF,OAAO,EAAY,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAOrE,wBAAgB,eAAe,CAAC,EAAE,MAAM,EAAE,EAAE,UAAU,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,CAOhF;AAaD,wBAAgB,SAAS,CAAC,KAAK,SAAS,MAAM,EAC5C,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,EACtB,YAAY,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,KAAK,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,EAChF,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,MAAM,EAAE,GAC5C,IAAI,CAUN;AAMD,wBAAgB,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,CAEjM;AAED,wBAAgB,SAAS,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,GAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAyB,GAAG,GAAG,CAAC,KAAK,CAAC,CAwBvL;AAwBD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASlD"}

package/jobs/{part-context.js → context.js}

@@ -23,10 +23,10 @@ async function readSession(claude) {
         throw new Error('HOME is not set, so ~ in a path has no meaning. Start Claude Code with HOME set.');
     return { home, fs, scope: await findProjectScope(claude.plugin.root, home, fs) };
 }
-export function afterCall(part, contextAfter, failed) {
-    const readWorkspace = workspaceReader(part);
-    part.on('tool.call', async (e, next) => {
-        const before = Promise.all([useOf(part, e), readWorkspace()]);
+export function afterCall(job, contextAfter, failed) {
+    const readWorkspace = workspaceReader(job);
+    job.on('tool.call', async (e, next) => {
+        const before = Promise.all([useOf(job, e), readWorkspace()]);
         await before.catch(() => undefined);
         const result = await next(e);
         if (result.deny !== undefined || result.isError === true)
@@ -38,8 +38,8 @@ export function afterCall(part, contextAfter, failed) {
 async function useOf({ toolCalls }, e) {
     return { tool: e.tool, input: toolInputOf(e), ...(await toolCalls.agentOf(e.tool_use_id)) };
 }
-export function modOf(context, { call, folder }, workspace, deadline) {
-    return modWithin(context, deadline, async () => workspace.scope?.workTreeOf(call !== undefined && 'path' in call ? call.path : folder));
+export function modOf(job, { call, folder }, workspace, deadline) {
+    return modWithin(job, deadline, async () => workspace.scope?.workTreeOf(call !== undefined && 'path' in call ? call.path : folder));
 }
 export function modWithin({ mod, claude }, deadline, workTree = async () => undefined) {
     const within = (call, task) => beforeDeadline(claude, deadline, call, task);

package/jobs/permissions.d.ts

@@ -1,8 +1,8 @@
-import type { Mod, Part } from '../mod.js';
+import type { Job, Mod } from '../mod.js';
 import { type PermissionRules as RulesFor, type Rule as RuleFor } from './permissions/decide-permission.js';
 export type { CommandCall, FetchCall, FileCall, ToolCall } from '../utils/call-effects.js';
 export type { Target } from './permissions/match-target.js';
 export type Rule<State extends object = Record<never, never>> = RuleFor<Mod<State>>;
 export type PermissionRules<State extends object = Record<never, never>> = RulesFor<Mod<State>>;
-export declare function permissions<State extends object = Record<never, never>>(rules: PermissionRules<State>): Part<void, State>;
+export declare function permissions<State extends object = Record<never, never>>(rules: PermissionRules<State>): Job<void, State>;
 //# sourceMappingURL=permissions.d.ts.map

package/jobs/permissions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../src/jobs/permissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAG1C,OAAO,EAAqC,KAAK,eAAe,IAAI,QAAQ,EAAE,KAAK,IAAI,IAAI,OAAO,EAAgB,MAAM,oCAAoC,CAAA;AAK5J,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAC1F,YAAY,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAC3D,MAAM,MAAM,IAAI,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;AACnF,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;AAI/F,wBAAgB,WAAW,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAwBzH"}
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../src/jobs/permissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAGzC,OAAO,EAAqC,KAAK,eAAe,IAAI,QAAQ,EAAE,KAAK,IAAI,IAAI,OAAO,EAAgB,MAAM,oCAAoC,CAAA;AAK5J,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAC1F,YAAY,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAC3D,MAAM,MAAM,IAAI,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;AACnF,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;AAI/F,wBAAgB,WAAW,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAwBxH"}

package/jobs/permissions.js

@@ -1,7 +1,7 @@
 import { decidePermission, stricterVerdict } from './permissions/decide-permission.js';
 import { targetOf } from './permissions/match-target.js';
 import { messageOf } from '../utils/text.js';
-import { modOf, workspaceReader } from './part-context.js';
+import { modOf, workspaceReader } from './context.js';
 const deadline = { ms: 2000, job: 'permissions' };
 export function permissions(rules) {
     const count = (rules.deny?.length ?? 0) + (rules.ask?.length ?? 0);
@@ -9,22 +9,22 @@ export function permissions(rules) {
         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 (context) => {
-        const readWorkspace = workspaceReader(context);
+    return (job) => {
+        const readWorkspace = workspaceReader(job);
         const verdictOf = async (e) => {
             try {
-                const [agent, workspace] = await Promise.all([context.toolCalls.agentOf(e.tool_use_id), readWorkspace()]);
+                const [agent, workspace] = await Promise.all([job.toolCalls.agentOf(e.tool_use_id), readWorkspace()]);
                 const use = { tool: e.tool, input: e.input, ...agent };
-                return await decidePermission(rules, use, workspace, (call, folder) => modOf(context, { call, folder }, workspace, deadline));
+                return await decidePermission(rules, use, 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)}` };
             }
         };
-        context.on('tool.check', async (e, next) => {
+        job.on('tool.check', async (e, next) => {
             const [below, ours] = await Promise.all([next(e), verdictOf(e)]);
             return ours === undefined ? below : stricterVerdict(below, ours);
         });
-        context.announce(`${count} permission rule${count === 1 ? '' : 's'}`);
+        job.announce(`${count} permission rule${count === 1 ? '' : 's'}`);
     };
 }

package/jobs/program.d.ts

@@ -1,4 +1,4 @@
-import type { Part } from '../mod.js';
+import type { Job } from '../mod.js';
 export type Program = {
     readonly state: 'stopped' | 'starting' | 'running' | 'backoff' | 'fatal';
     ready(): Promise<{
@@ -9,5 +9,5 @@ export type Program = {
 export declare function program(options: {
     readonly command: readonly string[];
     readonly environment?: Record<string, string>;
-}): Part<Program>;
+}): Job<Program>;
 //# sourceMappingURL=program.d.ts.map

package/jobs/program.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/jobs/program.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGrC,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;IACxE,KAAK,IAAI,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACvD,CAAA;AAMD,wBAAgB,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAyEtI"}
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/jobs/program.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAGpC,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;IACxE,KAAK,IAAI,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACvD,CAAA;AAMD,wBAAgB,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,GAAG,CAAC,OAAO,CAAC,CAyErI"}

package/jobs/prompt.d.ts

@@ -1,4 +1,4 @@
-import type { Mod, Part } from '../mod.js';
+import type { Job, Mod } from '../mod.js';
 import { type ToolCall } from '../utils/call-effects.js';
 import { type Target } from './permissions/match-target.js';
 type PromptInput = {
@@ -11,6 +11,6 @@ type PromptOptions<State extends object> = {
     when?: RegExp | ((userPrompt: string) => boolean);
     after?: Target | Target[];
 };
-export declare function prompt<State extends object = Record<never, never>>({ name, prompt: text, when, after }: PromptOptions<State>): Part<void, State>;
+export declare function prompt<State extends object = Record<never, never>>({ name, prompt: text, when, after }: PromptOptions<State>): Job<void, State>;
 export {};
 //# sourceMappingURL=prompt.d.ts.map

package/jobs/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../src/jobs/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAe,MAAM,WAAW,CAAA;AAGvD,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AACrE,OAAO,EAAyB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAGlF,KAAK,WAAW,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE3D,KAAK,aAAa,CAAC,KAAK,SAAS,MAAM,IAAI;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;IAC5G,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,CAAA;IACjD,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1B,CAAA;AAID,wBAAgB,MAAM,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAoChJ"}
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../src/jobs/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAc,GAAG,EAAE,MAAM,WAAW,CAAA;AAGrD,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AACrE,OAAO,EAAyB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAGlF,KAAK,WAAW,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE3D,KAAK,aAAa,CAAC,KAAK,SAAS,MAAM,IAAI;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;IAC5G,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,CAAA;IACjD,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1B,CAAA;AAID,wBAAgB,MAAM,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAoC/I"}

package/jobs/prompt.js

@@ -2,7 +2,7 @@ import { longestMs } from '../runtime/deadline.js';
 import { listed, messageOf } from '../utils/text.js';
 import { callEffects } from '../utils/call-effects.js';
 import { matchTarget, targetOf } from './permissions/match-target.js';
-import { afterCall, modOf, modWithin, targetWords } from './part-context.js';
+import { afterCall, modOf, modWithin, targetWords } from './context.js';
 const deadline = { ms: 5000, longestMs, job: 'prompt' };
 export function prompt({ name, prompt: text, when, after }) {
     if (name.trim() === '')
@@ -12,9 +12,9 @@ export function prompt({ name, prompt: text, when, after }) {
     const targets = after === undefined ? [] : Array.isArray(after) ? after : [after];
     for (const target of targets)
         targetOf(target);
-    return (part) => {
-        part.reserveName('prompt', name, `prompt: ${part.mod.name} adds the name "${name}" two times. Give each prompt its own name.`);
-        const log = (reason) => part.claude.ui.log(`prompt "${name}" added nothing: ${reason}`, { to: 'debug' });
+    return (job) => {
+        job.reserveName('prompt', name, `prompt: ${job.mod.name} adds the name "${name}" two times. Give each prompt its own name.`);
+        const log = (reason) => job.claude.ui.log(`prompt "${name}" added nothing: ${reason}`, { to: 'debug' });
         const textFor = async (input, mod) => {
             try {
                 const value = typeof text === 'string' ? text : await text(input, mod);
@@ -30,21 +30,21 @@ export function prompt({ name, prompt: text, when, after }) {
             return value === undefined ? undefined : `# ${name}\n${value}`;
         };
         if (when !== undefined) {
-            addAfterUserPrompts(part, when, (userPrompt) => headedText({ userPrompt }, modWithin(part, deadline)), log);
-            part.announce(`the ${name} prompt after matching user prompts`);
+            addAfterUserPrompts(job, when, (userPrompt) => headedText({ userPrompt }, modWithin(job, deadline)), log);
+            job.announce(`the ${name} prompt after matching user prompts`);
         }
         else if (targets.length > 0) {
-            addAfterCalls(part, targets, headedText, log);
-            part.announce(`the ${name} prompt after ${listed(targets.map(targetWords))}`);
+            addAfterCalls(job, targets, headedText, log);
+            job.announce(`the ${name} prompt after ${listed(targets.map(targetWords))}`);
         }
         else {
-            addOncePerConversation(part, name, () => textFor({}, modWithin(part, deadline)), log);
-            part.announce(`the ${name} prompt`);
+            addOncePerConversation(job, name, () => textFor({}, modWithin(job, deadline)), log);
+            job.announce(`the ${name} prompt`);
         }
     };
 }
-function addOncePerConversation(part, name, textFor, log) {
-    part.on('prompt.context', async (e, next) => {
+function addOncePerConversation(job, name, textFor, log) {
+    job.on('prompt.context', async (e, next) => {
         const below = await next(e);
         if (below.blocks.some((block) => block.name === name)) {
             log(`a block named "${name}" is already in the context`);
@@ -54,8 +54,8 @@ function addOncePerConversation(part, name, textFor, log) {
         return value === undefined ? below : { ...below, blocks: [...below.blocks, { name, text: value }] };
     });
 }
-function addAfterUserPrompts(part, when, textFor, log) {
-    part.on('prompt.submit', async (e, next) => {
+function addAfterUserPrompts(job, when, textFor, log) {
+    job.on('prompt.submit', async (e, next) => {
         let value;
         try {
             if (typeof when === 'function' ? when(e.text) : e.text.search(when) >= 0)
@@ -67,14 +67,14 @@ function addAfterUserPrompts(part, when, textFor, log) {
         return next(value === undefined ? e : { ...e, context: [...(e.context ?? []), value] });
     });
 }
-function addAfterCalls(part, targets, textFor, log) {
-    afterCall(part, async (use, workspace) => {
+function addAfterCalls(job, targets, textFor, log) {
+    afterCall(job, async (use, workspace) => {
         const effects = callEffects(use, workspace);
         for (const target of targets) {
             const [matched] = await matchTarget(target, use, effects, workspace);
             if (matched === undefined)
                 continue;
-            const value = await textFor({ call: matched.call }, modOf(part, matched, workspace, deadline));
+            const value = await textFor({ call: matched.call }, modOf(job, matched, workspace, deadline));
             return value === undefined ? [] : [value];
         }
         return [];

package/jobs/slash-command.d.ts

@@ -1,4 +1,4 @@
-import type { Mod, Part } from '../mod.js';
+import type { Job, Mod } from '../mod.js';
 export type Reply = string | {
     text?: string;
     context?: string;
@@ -12,5 +12,5 @@ export declare function slashCommand<State extends object = Record<never, never>
         args: string;
         positionals: string[];
     }, mod: Mod<State>) => Reply | void | Promise<Reply | void>;
-}): Part<void, State>;
+}): Job<void, State>;
 //# sourceMappingURL=slash-command.d.ts.map

package/jobs/slash-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slash-command.d.ts","sourceRoot":"","sources":["../src/jobs/slash-command.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAM1C,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAA;AAM5E,wBAAgB,YAAY,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE;IACjF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAAA;CAC1H,GAAG,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CA4BpB"}
+{"version":3,"file":"slash-command.d.ts","sourceRoot":"","sources":["../src/jobs/slash-command.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAMzC,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAA;AAM5E,wBAAgB,YAAY,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE;IACjF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAAA;CAC1H,GAAG,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CA4BnB"}