@cmodjs/core 0.1.4 → 0.1.6

package/README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/heyJordanParker/cmod/main/.claude-plugin/icon.png" alt="Claude Mod Manager" width="128">
+</p>
+
 # @cmodjs/core
 
 The library every Claude Mod Manager mod imports. Claude Mod Manager (CMod) installs, tries, builds, checks, and publishes Claude Code mods: plugins with hooks, panes, slash commands, tools, permission rules, and an install step that runs with your consent.

package/connect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["src/connect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoD,EAAE,EAAE,MAAM,aAAa,CAAA;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AA2E7C,wBAAgB,OAAO,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,IAAI,CA8B5F"}
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["src/connect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoD,EAAE,EAAE,MAAM,aAAa,CAAA;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAwE7C,wBAAgB,OAAO,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,IAAI,CA8B5F"}

package/connect.js

@@ -1,14 +1,7 @@
 import { createLifecycle, readPlugin } from './runtime/lifecycle.js';
 let lifecycle;
-async function start($, e, next) {
-    await lifecycle.start(claudeOf($), readPlugin);
-    return next(e);
-}
-function route(_$, e, next) {
-    return lifecycle.route(next.event, e, (passed) => next(passed));
-}
-function claudeOf($) {
-    return {
+async function startMod($, eventInput, passOn) {
+    const claude = {
         plugin: { name: $.plugin.name, root: $.plugin.root },
         ui: {
             toast: (text, options) => $.ui.toast(text, options),
@@ -64,35 +57,40 @@ function claudeOf($) {
         },
         cmod: { call: (input) => $.cmod.call(input) },
     };
+    await lifecycle.start(claude, readPlugin);
+    return passOn(eventInput);
+}
+function routeToMod(_$, eventInput, passOn) {
+    return lifecycle.route(passOn.event, eventInput, (passed) => passOn(passed));
 }
 export function connect(on, definition) {
     lifecycle = createLifecycle(definition);
-    on('session.start', start);
-    on('classic.SessionStart', route);
-    on('classic.SessionEnd', route);
-    on('classic.UserPromptSubmit', route);
-    on('classic.InstructionsLoaded', route);
-    on('classic.PreToolUse', route);
-    on('classic.PermissionRequest', route);
-    on('classic.PermissionDenied', route);
-    on('classic.PostToolUse', route);
-    on('classic.PostToolUseFailure', route);
-    on('classic.PostToolBatch', route);
-    on('classic.SubagentStart', route);
-    on('classic.SubagentStop', route);
-    on('classic.Notification', route);
-    on('classic.PreCompact', route);
-    on('classic.Stop', route);
-    on('classic.StopFailure', route);
-    on('tool.check', route);
-    on('tool.call', route);
-    on('prompt.submit', route);
-    on('prompt.context', route);
-    on('command.run', route);
-    on('session.measure', route);
-    on('skill.prompt', route);
-    on('ui.render', route);
-    on('ui.press', route);
-    on('ui.close', route);
-    on('cmod.call', route);
+    on('session.start', startMod);
+    on('classic.SessionStart', routeToMod);
+    on('classic.SessionEnd', routeToMod);
+    on('classic.UserPromptSubmit', routeToMod);
+    on('classic.InstructionsLoaded', routeToMod);
+    on('classic.PreToolUse', routeToMod);
+    on('classic.PermissionRequest', routeToMod);
+    on('classic.PermissionDenied', routeToMod);
+    on('classic.PostToolUse', routeToMod);
+    on('classic.PostToolUseFailure', routeToMod);
+    on('classic.PostToolBatch', routeToMod);
+    on('classic.SubagentStart', routeToMod);
+    on('classic.SubagentStop', routeToMod);
+    on('classic.Notification', routeToMod);
+    on('classic.PreCompact', routeToMod);
+    on('classic.Stop', routeToMod);
+    on('classic.StopFailure', routeToMod);
+    on('tool.check', routeToMod);
+    on('tool.call', routeToMod);
+    on('prompt.submit', routeToMod);
+    on('prompt.context', routeToMod);
+    on('command.run', routeToMod);
+    on('session.measure', routeToMod);
+    on('skill.prompt', routeToMod);
+    on('ui.render', routeToMod);
+    on('ui.press', routeToMod);
+    on('ui.close', routeToMod);
+    on('cmod.call', routeToMod);
 }

package/docs/commands.md

@@ -82,22 +82,31 @@ 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 archive from the committed files with `git archive`, leaving out `cli/`.
-2. Builds the program `cli/` declares.
-3. Writes `SHA256SUMS` for every file of the release.
-4. Writes `.claude-plugin/marketplace.json`, listing the archive and the CMod plugin.
-5. Commits that file, tags `v<version>`, pushes, and creates the GitHub release.
+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 `.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, 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.
+6. Writes `.claude-plugin/marketplace.json`, listing the archive and the CMod plugin.
+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`, 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:
 
 - the mod's folder as the root of a git repository with at least one commit, because `git archive` builds from `HEAD`
+- `node_modules` in the mod's folder, from `bun install`, when the hooks module imports a package
+- a `register` declared as a function in the hooks module, as `cmod new` writes it, because the validator refuses a bundled `register` that is not one
+- 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
 
-`--dry-run` builds and writes everything, and pushes nothing. It allows uncommitted changes and an existing tag, and builds from the last commit.
+`--dry-run` builds and writes everything, and pushes nothing. It allows uncommitted changes and an existing tag, and builds from the last commit. It prints the folder that holds the release, so you can read what the directory will read.
 
 ## Install mods
 

package/docs/index.md

@@ -30,7 +30,7 @@ my-mod/
 
 The template is a working example to replace. It counts the prompts of the session in `state.session.prompts`, shows the count in a pane titled with the mod's name and above the prompt, and tests both. Replace the counter, the pane, the component, the Skill, and the tests with the mod's own.
 
-A mod imports `@cmodjs/core` by path, such as `../node_modules/@cmodjs/core/mod.js`, because Claude Code loads a plugin's own files only. Types such as `RenderElement` and `Register` come from the `claude-code` module.
+A mod imports `@cmodjs/core` by path, such as `../node_modules/@cmodjs/core/mod.js`, because Claude Code loads a plugin's own files only. Types such as `RenderElement` and `On` come from the `claude-code` module.
 
 ## Type-check after the first session
 
@@ -70,7 +70,7 @@ 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) |
@@ -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>
@@ -211,7 +211,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 +241,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 +277,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 +303,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 +345,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
@@ -367,9 +367,9 @@ type PartContext<State> = {
 - `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.
 
 ```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 +436,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

@@ -59,11 +59,11 @@ Each of these says `Fix it, then run /reload-plugins.`
 `hooks/hooks.json` names `hooks/register.ts` as the plugin's hooks module. `register.ts` calls `connect` and does nothing else:
 
 ```ts
-import type { Register } from 'claude-code'
+import type { On } from 'claude-code'
 import { connect } from '../node_modules/@cmodjs/core/connect.js'
 import { greeter } from '../src/mod.js'
 
-export const register: Register = (on) => {
+export function register(on: On): void {
   connect(on, greeter)
 }
 ```
@@ -72,7 +72,7 @@ export const register: Register = (on) => {
 connect<State>(on: On, definition: ModDefinition<State>): 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.
+`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.
 
 ## What `mod` can call
 
@@ -86,7 +86,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 [];