@cmodjs/core 0.3.0 → 1.0.0

package/src/register.ts

@@ -3,6 +3,7 @@ import type { ModDefinition } from './mod.js'
 import type { Options } from './options.js'
 import type { Claude } from './runtime/claude.js'
 import type { RoutedEvent } from './runtime/hooks.js'
+import { cmodPluginName } from './runtime/dependencies.js'
 import { createLifecycle, readPlugin, type Lifecycle } from './runtime/lifecycle.js'
 
 let lifecycle: Lifecycle<object>
@@ -19,7 +20,6 @@ async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.sta
   const claude: Claude = {
     plugin: { name: $.plugin.name, root: $.plugin.root },
     ui: {
-      toast: (text, options) => $.ui.toast(text, options),
       status: (text) => $.ui.status(text),
       log: (text, options) => $.ui.log(text, options),
       notice: (toolUseId, text) => $.ui.notice(toolUseId, text),
@@ -29,6 +29,7 @@ async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.sta
       close: (pane) => $.ui.close(pane),
       panes: () => $.ui.panes(),
       scroll: (args) => $.ui.scroll(args),
+      copy: (args) => $.ui.copy(args),
       resolve: (render) => $.ui.resolve(render),
     },
     process: {
@@ -65,11 +66,12 @@ async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.sta
       surfaces: () => $.session.surfaces(),
       messages: ((args?: Parameters<Claude['session']['messages']>[0]) => (args === undefined ? $.session.messages() : $.session.messages(args))) as Claude['session']['messages'],
       append: (args) => $.session.append(args),
+      send: (args) => $.session.send(args),
     },
     prompt: { submit: (args) => $.prompt.submit(args) },
     model: { complete: (request, options) => $.model.complete(request, options) },
     command: { register: (command) => $.command.register(command) },
-    tool: { register: (tool) => $.tool.register(tool), call: ((input: ToolCallArgs) => $.tool.call(input)) as Claude['tool']['call'] },
+    tool: { register: (tool) => $.tool.register(tool), call: (input: ToolCallArgs) => $.tool.call(input) },
     agent: {
       list: () => $.agent.list(),
       spawn: (args) => $.agent.spawn(args),
@@ -81,14 +83,19 @@ async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.sta
     },
     cmod: { call: (input) => $.cmod.call(input) },
   }
-  await lifecycle.start(claude, readPlugin)
-  return passOn(eventInput)
+  const [, answer] = await Promise.all([lifecycle.start(claude, readPlugin), passOn(eventInput)])
+  return answer
 }
 
 function routeToMod<N extends RoutedEvent>(_$: EngineInterface, eventInput: Frozen<Args<N>>, passOn: Next<N>): Promise<EventResult<N>> {
   return lifecycle.route(passOn.event, eventInput, (passed: unknown) => passOn(passed as Args<N>) as Promise<EventResult<N>>)
 }
 
+function routeCallToMod(_$: EngineInterface, eventInput: Frozen<Args<'cmod.call'>>, passOn: Next<'cmod.call'>): Promise<EventResult<'cmod.call'>> {
+  const called = { ...eventInput, caller: passOn.origin.plugin } as Frozen<Args<'cmod.call'>>
+  return lifecycle.route('cmod.call', called, (passed) => passOn(Object.fromEntries(Object.entries(passed).filter(([key]) => key !== 'caller')) as Args<'cmod.call'>))
+}
+
 export function registerMod<State extends object, Declared extends Options>(addHook: On, definition: ModDefinition<State, string, Declared>, options: PluginOptions): void {
   checksPermissions = false
   registered = definition as ModDefinition<object>
@@ -119,7 +126,12 @@ export function registerMod<State extends object, Declared extends Options>(addH
   addHook('ui.press', routeToMod)
   addHook('ui.scroll', routeToMod)
   addHook('ui.close', routeToMod)
-  addHook('cmod.call', routeToMod)
+  addHook('cmod.call', routeCallToMod)
+  if (definition.name !== cmodPluginName) return
+  addHook('session.append', routeToMod)
+  addHook('session.compact', routeToMod)
+  addHook('session.receive', routeToMod)
+  addHook('agent.spawn', routeToMod)
 }
 
 export function registerPermissionCheck(addHook: On): void {

package/src/runtime/announce.ts

@@ -0,0 +1,74 @@
+import { changelogPage, isObject, marketplaceOf, permissionWords } from '../records.js'
+import { changeLines, changelogSections, unreleased } from '../utils/changelog.js'
+import { ifMissing } from '../utils/paths.js'
+import { listed } from '../utils/text.js'
+import type { Claude } from './claude.js'
+import { cmodPluginName } from './dependencies.js'
+import type { Plugin } from './lifecycle.js'
+
+export type Announced = { readonly version: string; readonly added: readonly string[] }
+
+export type Announcement = { readonly message: string; readonly description?: string; readonly action?: { readonly label: string; readonly onClick: () => unknown } }
+
+export const announcementMs = 10_000
+
+const shownChanges = 3
+
+export function announcedOf(saved: unknown): Announced | undefined {
+  if (typeof saved === 'string') return { version: saved, added: [] }
+  if (!isObject(saved) || typeof saved['version'] !== 'string') return undefined
+  return { version: saved['version'], added: Array.isArray(saved['added']) ? saved['added'].map(String) : [] }
+}
+
+export async function announcementOf(claude: Claude, plugin: Plugin, granted: ReadonlySet<string>, added: readonly string[], previous: Announced | undefined): Promise<Announcement> {
+  const read = (path: string) => claude.fs.read(`${plugin.root}/${path}`).catch(ifMissing(undefined))
+  const manifest = jsonOf(await read('.claude-plugin/plugin.json'))
+  const field = (key: string) => (isObject(manifest) && typeof manifest[key] === 'string' ? manifest[key] : undefined)
+  const open = (page?: string) => () => claude.cmod.call({ to: cmodPluginName, method: 'openSettings', input: { mod: plugin.name, ...(page === undefined ? {} : { page }) } })
+  if (previous === undefined) {
+    const { program, keys } = plugin.steps
+    const lines = [
+      field('description'),
+      added.length > 0 ? `Adds ${listed(added)}.` : undefined,
+      program === undefined ? undefined : `Installed the ${program} program.`,
+      ...Object.entries(keys ?? {}).map(([key, command]) => `Binds ${key} to /${command}.`),
+      ...[...granted].map((item) => `${permissionWords(item)}.`),
+    ]
+    return { message: 'Installed', ...described(lines), action: { label: 'Settings', onClick: open() } }
+  }
+  const version = plugin.version ?? ''
+  const isCheckout = marketplaceOf(plugin.root, plugin.name) === undefined
+  const sections = changelogSections((await read('CHANGELOG.md')) ?? '')
+  const section = sections.find((each) => each.version === version) ?? (isCheckout ? sections.find((each) => each.version === unreleased) : undefined)
+  const changes = section === undefined ? [] : changeLines(section.text)
+  const nowAdded = added.filter((each) => !previous.added.includes(each))
+  const gone = previous.added.filter((each) => !added.includes(each))
+  const fallback = previous.added.length === 0 ? [] : [nowAdded.length > 0 ? `Now adds ${listed(nowAdded)}.` : undefined, gone.length > 0 ? `No longer adds ${listed(gone)}.` : undefined]
+  const home = await claude.env.home()
+  const folder = home !== undefined && plugin.root.startsWith(`${home}/`) ? `~${plugin.root.slice(home.length)}` : plugin.root
+  const repository = field('repository')
+  const lines = [
+    ...(changes.length === 0 ? fallback : changes.length > shownChanges ? [...changes.slice(0, shownChanges), '…'] : changes),
+    `From ${previous.version}${isCheckout ? `, loaded from ${folder}` : ''}.`,
+    repository === undefined || isCheckout ? undefined : `Release notes: ${repository.replace(/\/$/, '')}/releases/tag/v${version}`,
+  ]
+  return {
+    message: `Updated to ${version}`,
+    ...described(lines),
+    ...(sections.length > 0 ? { action: { label: 'Changelog', onClick: open(changelogPage) } } : {}),
+  }
+}
+
+function jsonOf(text: string | undefined): unknown {
+  try {
+    return text === undefined ? undefined : JSON.parse(text)
+  } catch (error) {
+    if (error instanceof SyntaxError) return undefined
+    throw error
+  }
+}
+
+function described(lines: readonly (string | undefined)[]): { readonly description?: string } {
+  const kept = lines.filter((line) => line !== undefined)
+  return kept.length === 0 ? {} : { description: kept.join('\n') }
+}

package/src/runtime/bound.ts

@@ -0,0 +1,12 @@
+import type { Imports } from '../mod.js'
+
+let current: Imports | undefined
+
+export function bind(imports: Imports): void {
+  current = imports
+}
+
+export function bound(): Imports {
+  if (current === undefined) throw new Error("A mod's imports work once its setup runs. Call them from setup or from a hook, never at the top of a module.")
+  return current
+}

package/src/runtime/claude.ts

@@ -28,8 +28,9 @@ import type {
   Settings,
   SettingsReadArgs,
   Timer,
-  ToastOptions,
   ToolSpec,
+  UiCopyArgs,
+  UiCopyResult,
   UiLogOptions,
   UiOpenResult,
   UiPane,
@@ -40,7 +41,6 @@ import type {
 export type Claude = {
   readonly plugin: { readonly name: string; readonly root: string }
   readonly ui: {
-    toast(text: string, options?: ToastOptions): void
     status(text: string | undefined): void
     log(text: string, options?: UiLogOptions): void
     notice(toolUseId: string, text: string | undefined): void
@@ -50,6 +50,7 @@ export type Claude = {
     close(pane: PaneCloseArgs): Promise<void>
     panes(): Promise<readonly UiPane[]>
     scroll(args: UiScrollArgs): Promise<UiScrollResult>
+    copy(args: UiCopyArgs): Promise<UiCopyResult>
     resolve(e: ResolveInput): ElementTable<RenderSurface>
   }
   readonly process: {
@@ -86,6 +87,7 @@ export type Claude = {
     surfaces(): Promise<readonly RenderSurface[]>
     messages: EngineInterface['session']['messages']
     append: EngineInterface['session']['append']
+    send: EngineInterface['session']['send']
   }
   readonly prompt: { submit: EngineInterface['prompt']['submit'] }
   readonly model: { complete: EngineInterface['model']['complete'] }

package/src/runtime/conversations.ts

@@ -0,0 +1,302 @@
+import type { Args, EventResult, Frozen } from 'claude-code'
+import { consentPath, dataFolder, isObject, parseConsent } from '../records.js'
+import { Message, rowOfAppend, type Row } from '../session/context/turn/message/message.js'
+import { Note } from '../session/context/turn/message/note.js'
+import { Prompt } from '../session/context/turn/message/prompt.js'
+import { Person } from '../session/context/turn/message/sender.js'
+import { createConversation, emptyConversation, type Conversation, type ConversationState, type ContextData, type SessionChange, type SessionData, type TaskData, type TurnData } from '../session/conversation.js'
+import { receivedMatcher } from '../utils/matcher.js'
+import { ifMissing } from '../utils/paths.js'
+import { formatExit, messageOf } from '../utils/text.js'
+import type { Claude } from './claude.js'
+import { cmodPluginName } from './dependencies.js'
+import { readLines, runCmod } from './programs.js'
+import type { Router } from './router.js'
+import { conversationMethods, isHeardBy, type Subscription } from './sessions.js'
+
+type Request = Readonly<Record<string, unknown>>
+
+type Heard = { readonly event: Subscription['event']; readonly matcher: unknown }
+
+const delivery = /^<cmod-delivery>([\s\S]*)<\/cmod-delivery>$/
+
+const bufferedTaskRows = 200
+
+export type Conversations = {
+  answer(e: Frozen<Args<'cmod.call'>> & { readonly caller?: string }): Promise<EventResult<'cmod.call'> | undefined>
+}
+
+export function serveConversations({ claude, router, store, project, report }: { readonly claude: Claude; readonly router: Router; readonly store: string; readonly project: () => string; readonly report: (id: string, message: string, error: unknown) => void }): Conversations {
+  const goals = `${dataFolder(store, cmodPluginName)}/goals`
+  const heard = new Map<string, Map<string, readonly Heard[]>>()
+  let session = ''
+  let conversation: Conversation = createConversation(emptyConversation(''))
+  let starting: Promise<void> = Promise.resolve()
+  let live: Message[] = []
+  const liveIds = new Set<string>()
+  const waitingRows = new Map<string, Row[]>()
+  let follower: { readonly sessions: string; stop(): void } | undefined
+
+  const json = async <Value>(args: readonly string[]): Promise<Value> => JSON.parse(await runCmod(claude, [...args, '--json', '--project', project()], session === '' ? await claude.session.id() : session)) as Value
+
+  const isGranted = async (caller: string | undefined, item: string) => {
+    if (caller === cmodPluginName) return true
+    if (caller === undefined) return false
+    const path = consentPath(store)
+    const text = await claude.fs.read(path).catch(ifMissing('{}'))
+    return (parseConsent(JSON.parse(text), path)[caller] ?? []).includes(item)
+  }
+
+  const dispatch = (to: string, changes: readonly SessionChange[]) => {
+    for (const change of changes) {
+      if (change.type === Message && !liveIds.has(change.message.id) && to === session) {
+        live.push(change.message)
+        liveIds.add(change.message.id)
+      }
+      for (const [mod, sessions] of heard) {
+        const subscriptions = sessions.get(to) ?? []
+        if (!subscriptions.some(({ event, matcher }) => isHeardBy(event, matcher, change))) continue
+        void claude.cmod.call({ to: mod, method: conversationMethods.changed, input: { session: to, change } }).catch((error: unknown) => report(`changed:${mod}`, `Could not tell ${mod} about session ${to}`, error))
+      }
+    }
+  }
+
+  const restartFollower = () => {
+    const others = [...new Set([...heard.values()].flatMap((sessions) => [...sessions].filter(([id, list]) => id !== session && list.length > 0).map(([id]) => id)))].sort()
+    const wanted = others.join(' ')
+    if (follower?.sessions === wanted) return
+    follower?.stop()
+    follower = undefined
+    if (others.length === 0) return
+    const stream = claude.process.spawn({ argv: ['cmod', 'history', 'follow', ...others, '--json', '--project', project()], env: { CLAUDE_CODE_SESSION_ID: session } })
+    const started = { sessions: wanted, stop: () => void stream.return(undefined as never) }
+    follower = started
+    void readLines(stream, (line) => {
+      if (line.trim() === '') return
+      const parsed = JSON.parse(line) as { readonly session: string; readonly change: SessionChange }
+      dispatch(parsed.session, [parsed.change])
+    })
+      .then(({ code, lastError }) => {
+        if (follower === started) throw new Error(`cmod history follow ${formatExit(code, lastError)}`)
+      })
+      .catch((error: unknown) => {
+        if (follower !== started) return
+        follower = undefined
+        report('follow', 'Stopped hearing the other sessions', error)
+      })
+  }
+
+  const start = (id: string, source: string) => {
+    if (id === session && source !== 'compact') return
+    if (id === session && source === 'compact') {
+      dispatch(session, conversation.startContext(new Date().toISOString()))
+      return
+    }
+    session = id
+    live = []
+    liveIds.clear()
+    waitingRows.clear()
+    conversation = createConversation(emptyConversation(id))
+    starting =
+      source === 'startup' || source === 'clear'
+        ? Promise.resolve(dispatch(id, conversation.startContext(new Date().toISOString())))
+        : json<ConversationState>(['history', 'state', id]).then(
+            (state) => {
+              if (session === id) conversation = createConversation(state)
+            },
+            (error: unknown) => report('state', `Starts session ${id} without its earlier turns`, error),
+          )
+    restartFollower()
+  }
+
+  const take = async (row: Row, task: string | undefined) => {
+    await starting
+    if (task !== undefined && conversation.state.tasks[task] === undefined) {
+      const waiting = waitingRows.get(task) ?? []
+      waiting.push(row)
+      waitingRows.set(task, waiting)
+      if (waiting.length < bufferedTaskRows) return
+      waitingRows.delete(task)
+      dispatch(session, conversation.startTask({ id: task, title: '', agentType: 'general-purpose', openedBy: '', openedAt: row.at }))
+      for (const each of waiting) dispatch(session, conversation.add(each, task))
+      return
+    }
+    dispatch(session, conversation.add(row, task))
+  }
+
+  router.add('classic.SessionStart', async (e, next) => {
+    start(e.session_id, e.source)
+    return next(e)
+  })
+
+  router.add('session.append', async (e, next) => {
+    const kept = await next(e)
+    if (kept.deny !== undefined || session === '') return kept
+    const cwd = e.message.type === 'assistant' ? await claude.session.cwd() : ''
+    void take(rowOfAppend({ uuid: kept.uuid, door: e.door, origin: e.origin, message: kept.message }, new Date().toISOString(), cwd), e.agentId).catch((error: unknown) => report('append', 'Missed a message', error))
+    return kept
+  })
+
+  router.add('session.compact', async (e, next) => {
+    const compacted = await next(e)
+    if (e.agentId === undefined && e.trigger !== 'precompute' && compacted.skip === undefined) {
+      await starting
+      dispatch(session, conversation.endContext(new Date().toISOString()))
+    }
+    return compacted
+  })
+
+  router.add('agent.spawn', async (e, next) => {
+    const spawned = await next(e)
+    if (spawned.deny !== undefined || spawned.agentId === undefined) return spawned
+    const id = spawned.agentId
+    const opened: TaskData = { id, title: e.description, agentType: e.subagentType, model: spawned.model, openedBy: e.tool_use_id, openedAt: new Date().toISOString(), ...(e.parentAgentId === undefined ? {} : { parent: e.parentAgentId }) }
+    await starting
+    dispatch(session, conversation.startTask(opened))
+    const waiting = waitingRows.get(id) ?? []
+    waitingRows.delete(id)
+    for (const row of waiting) dispatch(session, conversation.add(row, id))
+    return spawned
+  })
+
+  router.add('session.receive', async (e, next) => {
+    const isFromCmod = e.origin.kind === 'peer' && !('teammate' in e.origin) && e.origin.plugin === cmodPluginName
+    const sent = isFromCmod ? delivery.exec(e.text)?.[1] : undefined
+    if (sent === undefined) return next(e)
+    const parsed: unknown = JSON.parse(sent)
+    if (!isObject(parsed) || typeof parsed['text'] !== 'string') return next(e)
+    const { type, text, as } = parsed
+    claude.clock.after(0, () => {
+      const delivered = type === Note ? claude.session.append({ message: { type: 'user', content: [{ type: 'text', text }] } }) : claude.prompt.submit({ text, ...(as === Person ? { asUser: true } : {}) })
+      void delivered.catch((error: unknown) => report('delivery', 'Could not deliver a message from another session', error))
+    })
+    return { consumed: 'cmod delivery' }
+  })
+
+  const merged = <Item>(saved: readonly Item[], kept: readonly Item[], key: (item: Item) => string): Item[] => {
+    const keptKeys = new Set(kept.map(key))
+    return [...saved.filter((item) => !keptKeys.has(key(item))), ...kept]
+  }
+
+  const liveTurns = (): TurnData[] => {
+    const turn = conversation.state.turn
+    return turn === undefined ? [] : [turn]
+  }
+
+  const liveTasks = (): TaskData[] => Object.values(conversation.state.tasks).map(({ context: _context, ...task }) => task)
+
+  const liveContext = (): ContextData[] => {
+    const { context, contextOpenedAt } = conversation.state
+    return context === 0 ? [] : [{ number: context, openedAt: contextOpenedAt }]
+  }
+
+  const lastOf = <Item>(items: readonly Item[], last: unknown): Item[] => (typeof last === 'number' ? items.slice(-last) : [...items])
+
+  const methods: Readonly<Record<string, (request: Request, caller: string | undefined) => Promise<unknown>>> = {
+    async [conversationMethods.sessions](request) {
+      const found = await json<SessionData[]>(['history', 'sessions', ...scopeArgs(request), ...(request['running'] === true ? ['--running'] : [])])
+      return found.map((each) => (each.id === session ? { ...each, isRunning: true } : each))
+    },
+    async [conversationMethods.search](request) {
+      const before = isObject(request['before']) ? request['before'] : undefined
+      return json(['history', 'search', String(request['text']), ...scopeArgs(request), ...(request['running'] === true ? ['--running'] : []), ...countArg('--limit', request['limit']), ...(before === undefined ? [] : ['--before', `${String(before['session'])}:${String(before['id'])}`])])
+    },
+    async [conversationMethods.messages](request) {
+      const id = String(request['session'])
+      const filters = [...textArg('--turn', request['turn']), ...textArg('--task', request['task']), ...textArg('--after', request['after'])]
+      const saved = await json<Message[]>(['history', 'messages', id, ...filters, ...countArg('--last', request['last'])])
+      if (id !== session) return saved
+      await starting
+      const fits = (message: Message) => (request['turn'] === undefined || message.turn === request['turn']) && message.task === request['task']
+      const after = typeof request['after'] === 'string' ? live.findIndex((message) => message.id === request['after']) : -1
+      const kept = live.slice(after + 1).filter(fits)
+      return lastOf(merged(saved, kept, (message) => message.id), request['last'])
+    },
+    async [conversationMethods.turns](request) {
+      const id = String(request['session'])
+      const saved = await json<TurnData[]>(['history', 'turns', id, ...countArg('--context', request['context']), ...countArg('--last', request['last'])])
+      if (id !== session) return saved
+      await starting
+      const kept = liveTurns().filter((turn) => request['context'] === undefined || turn.context === request['context'])
+      return lastOf(merged(saved, kept, (turn) => turn.prompt.id), request['last'])
+    },
+    async [conversationMethods.contexts](request) {
+      const id = String(request['session'])
+      const saved = await json<ContextData[]>(['history', 'contexts', id])
+      if (id !== session) return saved
+      await starting
+      return merged(saved, liveContext(), (context) => String(context.number))
+    },
+    async [conversationMethods.tasks](request) {
+      const id = String(request['session'])
+      const saved = await json<TaskData[]>(['history', 'tasks', id, ...textArg('--task', request['task'])])
+      if (id !== session) return saved
+      await starting
+      const kept = liveTasks().filter((task) => task.parent === request['task'])
+      return merged(saved, kept, (task) => task.id)
+    },
+    async [conversationMethods.goal](request) {
+      const id = String(request['session'])
+      if (id === session) {
+        await starting
+        const text = conversation.state.goal
+        if (text !== undefined) return { text }
+      }
+      return json(['history', 'goal', id])
+    },
+    async [conversationMethods.updateGoal](request) {
+      const id = String(request['session'])
+      const text = String(request['text'])
+      await claude.fs.write(`${goals}/${id}.txt`, text)
+      if (id === session) {
+        await starting
+        dispatch(session, conversation.changeGoal(text))
+      }
+      return null
+    },
+    async [conversationMethods.subscribe](request, caller) {
+      if (caller === undefined) throw new Error('cmod hears no caller for this subscription.')
+      const id = String(request['session'])
+      const list = Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Subscription[]) : []
+      const sessions = heard.get(caller) ?? new Map<string, readonly Heard[]>()
+      sessions.set(id, list.map(({ event, matcher }) => ({ event, matcher: matcher === undefined ? undefined : receivedMatcher(matcher) })))
+      heard.set(caller, sessions)
+      restartFollower()
+      return null
+    },
+    async [conversationMethods.send](request, caller) {
+      if (!(await isGranted(caller, 'prompt'))) throw new Error(`${caller ?? 'A mod'} sends to another session without your grant to send prompts.`)
+      const type = request['type'] === Note ? Note : Prompt
+      const sent = await claude.session.send({ to: { sessionId: String(request['session']) }, text: `<cmod-delivery>${JSON.stringify({ type, text: request['text'], as: request['as'] })}</cmod-delivery>` })
+      if (sent.isDelivered !== true) throw new Error(`Claude Code could not deliver the message to session ${String(request['session'])}.`)
+      return null
+    },
+  }
+
+  return {
+    async answer(e) {
+      const method = methods[e.method]
+      if (method === undefined) return undefined
+      const input = isObject(e.input) ? e.input : {}
+      if (e.method !== conversationMethods.send && !(await isGranted(e.caller, 'conversation'))) return { deny: `${e.caller ?? 'A mod'} reads your conversations without your grant. Turn it on in /mods ${e.caller ?? ''}.`.trim() }
+      try {
+        return { value: await method(input, e.caller) }
+      } catch (error) {
+        return { deny: messageOf(error) }
+      }
+    },
+  }
+}
+
+function scopeArgs(request: Request): string[] {
+  return [...(typeof request['since'] === 'string' ? ['--since', request['since']] : []), ...(request['everyProject'] === true ? ['--all'] : [])]
+}
+
+function countArg(flag: string, value: unknown): string[] {
+  return typeof value === 'number' ? [flag, String(value)] : []
+}
+
+function textArg(flag: string, value: unknown): string[] {
+  return typeof value === 'string' ? [flag, value] : []
+}
+

package/src/runtime/deadline.ts

@@ -1,10 +1,10 @@
 import type { Claude } from './claude.js'
 
-export type Deadline = { readonly ms: number; readonly job?: string; readonly longestMs?: number }
+export type Deadline = { readonly ms: number; readonly job?: string }
 
 export const longestMs = 600_000
 
-export const toolDeadline: Deadline = { ms: 30000, longestMs, job: 'tool' }
+export const toolDeadline: Deadline = { ms: 30000, job: 'tool' }
 
 export function beforeDeadline<Value>(claude: Claude, { ms, job }: Deadline, call: string, task: Promise<Value>): Promise<Value> {
   return new Promise<Value>((resolve, reject) => {

package/src/runtime/dependencies.ts

@@ -2,6 +2,8 @@ import type { Args, CmodDependencies, EventResult, Frozen } from 'claude-code'
 import { messageOf } from '../utils/text.js'
 import type { Claude } from './claude.js'
 
+export const cmodPluginName = 'cmod'
+
 export async function answerCall(name: string, api: { readonly [method: string]: (input: never) => unknown }, e: Frozen<Args<'cmod.call'>>): Promise<EventResult<'cmod.call'>> {
   const method = Object.hasOwn(api, e.method) ? api[e.method] : undefined
   if (method === undefined) return { deny: `${name} has no method ${e.method}.` }
@@ -21,6 +23,16 @@ export function dependencyCalls(claude: Claude, within: (call: string, task: Pro
   return new Proxy({}, { get: (_dependencies, to) => (typeof to === 'string' && to !== 'then' ? methodsOf(to) : undefined) }) as CmodDependencies
 }
 
+export function withBareRefusals(claude: Claude): Claude {
+  const prefix = `${claude.plugin.name}: $.cmod.call: `
+  const call: Claude['cmod']['call'] = (input) =>
+    claude.cmod.call(input).catch((error: unknown) => {
+      const message = messageOf(error)
+      throw message.startsWith(prefix) ? new Error(message.slice(prefix.length), { cause: error }) : error
+    })
+  return { ...claude, cmod: { call } }
+}
+
 export function notInstalled(name: string): string {
   return `${name} is not installed. Run cmod install ${name}.`
 }

package/src/runtime/engine.ts

@@ -0,0 +1,22 @@
+import type { Claude } from './claude.js'
+import type { Router } from './router.js'
+import type { ToolCalls } from './tool-calls.js'
+
+export type Engine = {
+  readonly claude: Claude
+  readonly router: Router
+  readonly toolCalls: ToolCalls
+  readonly report: (failure: { readonly id: string; readonly message: string; readonly error?: unknown; readonly description?: string }) => void
+}
+
+const engines = new WeakMap<object, Engine>()
+
+export function keepEngine(mod: object, engine: Engine): void {
+  engines.set(mod, engine)
+}
+
+export function engineOf(mod: object): Engine {
+  const engine = engines.get(mod)
+  if (engine === undefined) throw new Error('This mod has not started, so it reaches no Claude Code calls yet.')
+  return engine
+}