@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.4

package/packages/agent-hooks/src/deploy/lock.ts

@@ -0,0 +1,65 @@
+/**
+ * `<repo>/.agents/agent-hooks.lock.json` — the record of what a hooks deploy
+ * itself wrote, mirroring packages/agent-skills' manifest.ts. deploy.ts
+ * consults it to know which entries in a target file are its own (so a
+ * later run can remove a command dropped from assets/hooks.json without
+ * touching anything a user or another tool wrote); doctor.ts and list.ts
+ * read it to report ownership.
+ *
+ * For a json-hooks surface (claude-settings / codex-hooks / cursor-hooks-v1),
+ * "owned" is recorded per surface event name as the exact rendered command
+ * strings (already carrying --host=<surface>) this deploy wrote there. For
+ * the opencode-plugin surface, the whole file is wholly adl-owned (H3) —
+ * `owned: true` records that fact rather than a per-command breakdown.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+export const LOCK_RELATIVE_PATH = '.agents/agent-hooks.lock.json'
+
+export interface JsonHooksLockEntry {
+  readonly format: 'claude-settings' | 'codex-hooks' | 'cursor-hooks-v1'
+  /** Surface event name -> the exact command strings (with --host) this deploy wrote into that event's array. */
+  readonly ownedCommands: Readonly<Record<string, readonly string[]>>
+}
+
+export interface OpencodePluginLockEntry {
+  readonly format: 'opencode-plugin'
+  readonly owned: true
+}
+
+export type HookLockEntry = JsonHooksLockEntry | OpencodePluginLockEntry
+
+export interface HookLock {
+  readonly version: 1
+  /** Target file (repo-relative, e.g. ".claude/settings.json") -> what this deploy wrote there. */
+  readonly entries: Readonly<Record<string, HookLockEntry>>
+}
+
+export function lockPathFor(targetRepo: string): string {
+  return join(targetRepo, LOCK_RELATIVE_PATH)
+}
+
+const EMPTY_LOCK: HookLock = { version: 1, entries: {} }
+
+export function readLock(targetRepo: string): HookLock {
+  const path = lockPathFor(targetRepo)
+  if (!existsSync(path)) return EMPTY_LOCK
+  let doc: unknown
+  try {
+    doc = JSON.parse(readFileSync(path, 'utf8'))
+  } catch (cause) {
+    throw new Error(`agent-hooks lock is not valid JSON: ${path} (${(cause as Error).message})`)
+  }
+  const record = doc as Partial<HookLock> | null
+  if (typeof record !== 'object' || record === null || record.version !== 1 || typeof record.entries !== 'object' || record.entries === null) {
+    throw new Error(`agent-hooks lock has an unrecognized shape: ${path}`)
+  }
+  return { version: 1, entries: record.entries as Record<string, HookLockEntry> }
+}
+
+export function writeLock(targetRepo: string, lock: HookLock): void {
+  const path = lockPathFor(targetRepo)
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, `${JSON.stringify(lock, null, 2)}\n`)
+}

package/packages/agent-hooks/src/deploy/opencode-template.ts

@@ -0,0 +1,74 @@
+/**
+ * Fills assets/opencode-plugin.template.ts with the rendered hook arrays
+ * (render.ts's renderOpencodeSlots), the profile's pluginName, and the
+ * identifier derived from it — reproducing this repo's own committed
+ * `.opencode/plugins/adl-repo.ts` byte-for-byte for the current
+ * deploy-profile.json + assets/hooks.json, except the header's first two
+ * lines (see the template's own header comment for why).
+ */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { HookSurface } from './profile.ts'
+import { OPENCODE_SLOTS, type RenderedOpencodeEntry, renderOpencodeSlots } from './render.ts'
+import type { CanonicalHooksDoc } from './source.ts'
+
+/** kebab-case -> camelCase, e.g. "adl-repo" -> "adlRepo". Ported from the deleted generator's toIdentifier (git show 5b34d10:packages/agent-skills/src/create/opencode.ts). */
+function toCamelCase(pluginName: string): string {
+  return pluginName
+    .split('-')
+    .map((part, index) => (index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+    .join('')
+}
+
+function serializeEntry(entry: RenderedOpencodeEntry): string {
+  const fields: string[] = [`command: ${JSON.stringify(entry.command)}`]
+  if (entry.matcher !== undefined) fields.push(`matcher: ${JSON.stringify(entry.matcher)}`)
+  fields.push(`timeoutMs: ${entry.timeoutMs}`)
+  if (entry.fallbackFor !== undefined) fields.push(`fallbackFor: ${JSON.stringify(entry.fallbackFor)}`)
+  return `  { ${fields.join(', ')} },`
+}
+
+function serializeSlot(entries: readonly RenderedOpencodeEntry[]): string {
+  return entries.map(serializeEntry).join('\n')
+}
+
+export interface RenderOpencodePluginOptions {
+  readonly assetsDir: string
+  readonly surface: HookSurface
+  readonly hooksDoc: CanonicalHooksDoc
+}
+
+/** Renders the complete OpenCode plugin file content (with a trailing newline, matching every other rendered surface file). */
+export function renderOpencodePlugin(options: RenderOpencodePluginOptions): string {
+  const { assetsDir, surface, hooksDoc } = options
+  if (surface.template === undefined) throw new Error(`surface "${surface.name}" has no template`)
+  if (surface.pluginName === undefined) throw new Error(`surface "${surface.name}" has no pluginName`)
+
+  const templatePath = join(assetsDir, surface.template)
+  let template: string
+  try {
+    template = readFileSync(templatePath, 'utf8')
+  } catch (cause) {
+    throw new Error(`opencode plugin template not found: ${templatePath} (${(cause as Error).message})`)
+  }
+
+  if (!template.includes('__ADL_FALLBACK_ENTRIES__')) throw new Error(`opencode plugin template is missing marker __ADL_FALLBACK_ENTRIES__: ${templatePath}`)
+  const fallbackEntries = Object.entries(surface.eventFallback ?? {})
+  let out = template.replace('__ADL_FALLBACK_ENTRIES__', fallbackEntries.map(([from, to]) => `//   - ${from} -> ${to}`).join('\n'))
+
+  const slots = renderOpencodeSlots(hooksDoc, surface)
+  for (const slot of OPENCODE_SLOTS) {
+    const marker = `__ADL_ARRAY_${slot}__`
+    if (!out.includes(marker)) throw new Error(`opencode plugin template is missing marker ${marker}: ${templatePath}`)
+    out = out.replace(marker, serializeSlot(slots.get(slot) ?? []))
+  }
+
+  if (!out.includes('__ADL_PLUGIN_NAME__')) throw new Error(`opencode plugin template is missing marker __ADL_PLUGIN_NAME__: ${templatePath}`)
+  out = out.split('__ADL_PLUGIN_NAME__').join(surface.pluginName)
+
+  const identifier = `${toCamelCase(surface.pluginName)}Plugin`
+  if (!out.includes('__ADL_PLUGIN_IDENTIFIER__')) throw new Error(`opencode plugin template is missing marker __ADL_PLUGIN_IDENTIFIER__: ${templatePath}`)
+  out = out.split('__ADL_PLUGIN_IDENTIFIER__').join(identifier)
+
+  return out
+}

package/packages/agent-hooks/src/deploy/profile.ts

@@ -0,0 +1,117 @@
+/**
+ * The hook deploy profile: for each surface, which repo-relative file the
+ * hook wiring is written to, in what wire format, and how assets/hooks.json's
+ * canonical event names / matchers / timeouts translate for that surface.
+ * Mirrors packages/agent-skills/src/profile.ts's shape (skills D2) exactly,
+ * ajv included: deploy-profile.schema.json (package root, never under src/
+ * — D7) is the ONLY definition of the profile's shape. This module adds only
+ * the two cross-field checks a JSON Schema cannot express on its own —
+ * duplicate surface `name`, duplicate surface `file` across the array —
+ * everything else (required fields, the opencode-plugin surface's
+ * template/pluginName requirement and the other formats' rejection of them,
+ * string/number record shapes, unknown fields) is the schema's job, enforced
+ * by ajv below.
+ */
+import Ajv, { type ErrorObject, type ValidateFunction } from 'ajv'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+export type HookWireFormat = 'claude-settings' | 'codex-hooks' | 'cursor-hooks-v1' | 'opencode-plugin'
+export const HOOK_WIRE_FORMATS: readonly HookWireFormat[] = ['claude-settings', 'codex-hooks', 'cursor-hooks-v1', 'opencode-plugin']
+
+export type UnmappedMatcherPolicy = 'keep' | 'drop'
+export type TimeoutUnit = 's' | 'ms'
+
+export interface HookSurface {
+  readonly name: string
+  readonly format: HookWireFormat
+  readonly file: string
+  readonly hostSuffix: string
+  readonly eventNames?: Readonly<Record<string, string>>
+  readonly matchers?: Readonly<Record<string, string>>
+  readonly unmappedMatcher?: UnmappedMatcherPolicy
+  readonly timeoutOverrides?: Readonly<Record<string, number>>
+  readonly timeoutUnit?: TimeoutUnit
+  /** opencode-plugin only. */
+  readonly template?: string
+  /** opencode-plugin only. */
+  readonly pluginName?: string
+  /** opencode-plugin only. */
+  readonly eventFallback?: Readonly<Record<string, string>>
+}
+
+export interface HookDeployProfile {
+  readonly source: string
+  readonly surfaces: readonly HookSurface[]
+  /** Repo-relative path to the pre-agent-hooks engine's own install lock, if this repo may still carry one (see deploy-profile.schema.json). */
+  readonly legacyLock?: string
+}
+
+export const DEFAULT_PROFILE_PATH = fileURLToPath(new URL('../../deploy-profile.json', import.meta.url))
+export const DEFAULT_PROFILE_SCHEMA_PATH = fileURLToPath(new URL('../../deploy-profile.schema.json', import.meta.url))
+
+export interface ProfileIssue {
+  readonly path: string
+  readonly message: string
+}
+
+function compileValidator(schemaPath: string): ValidateFunction {
+  const schema = JSON.parse(readFileSync(schemaPath, 'utf8'))
+  const ajv = new Ajv({ allErrors: true, strict: true })
+  return ajv.compile(schema)
+}
+
+/** Folds ajv's params (the field ajv's own `.message` text leaves out) into a readable message: which field was missing or unexpected. */
+function formatAjvError(error: ErrorObject): ProfileIssue {
+  const path = error.instancePath.length > 0 ? error.instancePath : '/'
+  const params = error.params as Record<string, unknown>
+  const detail =
+    error.keyword === 'additionalProperties'
+      ? `: unexpected field "${params.additionalProperty}"`
+      : error.keyword === 'required'
+        ? `: missing "${params.missingProperty}"`
+        : ''
+  return { path, message: `${path} ${error.message ?? 'is invalid'}${detail}`.trim() }
+}
+
+/**
+ * Validates a parsed deploy-profile document: JSON Schema shape (ajv,
+ * against `schemaPath`), plus the two semantic checks the schema itself
+ * cannot express — every surface `name` and every surface `file` must be
+ * unique. Pure: never throws for a structurally-wrong `doc` (returns issues
+ * instead); only a missing/malformed `schemaPath` throws.
+ */
+export function validateProfileDocument(doc: unknown, schemaPath: string = DEFAULT_PROFILE_SCHEMA_PATH): readonly ProfileIssue[] {
+  const validate = compileValidator(schemaPath)
+  if (!validate(doc)) {
+    return (validate.errors ?? []).map(formatAjvError)
+  }
+
+  const { surfaces } = doc as HookDeployProfile
+  const issues: ProfileIssue[] = []
+  const names = new Set<string>()
+  const files = new Set<string>()
+  surfaces.forEach((surface, index) => {
+    const p = `/surfaces/${index}`
+    if (names.has(surface.name)) issues.push({ path: `${p}/name`, message: `duplicate surface name: ${surface.name}` })
+    names.add(surface.name)
+    if (files.has(surface.file)) issues.push({ path: `${p}/file`, message: `duplicate surface file: ${surface.file}` })
+    files.add(surface.file)
+  })
+  return issues
+}
+
+/** Reads and validates a deploy profile from disk. Throws (fails loud) when the JSON is malformed or the document is invalid — deploy.ts has no way to proceed without a valid profile. */
+export function loadProfile(path: string = DEFAULT_PROFILE_PATH, schemaPath: string = DEFAULT_PROFILE_SCHEMA_PATH): HookDeployProfile {
+  let doc: unknown
+  try {
+    doc = JSON.parse(readFileSync(path, 'utf8'))
+  } catch (cause) {
+    throw new Error(`deploy profile is not valid JSON: ${path} (${(cause as Error).message})`)
+  }
+  const issues = validateProfileDocument(doc, schemaPath)
+  if (issues.length > 0) {
+    throw new Error(`deploy profile is invalid: ${path}\n${issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join('\n')}`)
+  }
+  return doc as HookDeployProfile
+}

package/packages/agent-hooks/src/deploy/render.ts

@@ -0,0 +1,162 @@
+/**
+ * Renders the canonical hooks document (source.ts) into each surface's own
+ * wire shape, per that surface's HookSurface entry in the deploy profile —
+ * every host suffix, event name, matcher translation and timeout comes from
+ * the profile, never hard-coded here. Pure functions: no filesystem I/O,
+ * no ownership/merge policy (json-merge.ts, opencode-template.ts own that).
+ */
+import type { CanonicalHookCommand, CanonicalHookGroup, CanonicalHooksDoc } from './source.ts'
+import type { HookSurface } from './profile.ts'
+
+function withHost(command: string, hostSuffix: string): string {
+  return `${command} --host=${hostSuffix}`
+}
+
+function resolveTimeout(baseCommand: string, sourceTimeoutSeconds: number, surface: HookSurface): number {
+  const overrideSeconds = surface.timeoutOverrides?.[baseCommand] ?? sourceTimeoutSeconds
+  return surface.timeoutUnit === 'ms' ? overrideSeconds * 1000 : overrideSeconds
+}
+
+function resolveMatcher(sourceMatcher: string | undefined, surface: HookSurface): string | undefined {
+  if (sourceMatcher === undefined) return undefined
+  const mapped = surface.matchers?.[sourceMatcher]
+  if (mapped !== undefined) return mapped
+  return (surface.unmappedMatcher ?? 'keep') === 'drop' ? undefined : sourceMatcher
+}
+
+// ---------------------------------------------------------------------------
+// claude-settings / codex-hooks: {hooks: {Event: [{matcher?, hooks:[...]}]}}
+// ---------------------------------------------------------------------------
+
+export interface RenderedHookCommand {
+  readonly type: string
+  readonly command: string
+  readonly statusMessage: string
+  readonly timeout: number
+}
+
+export interface RenderedGroup {
+  readonly matcher?: string
+  readonly hooks: readonly RenderedHookCommand[]
+}
+
+function renderGroup(group: CanonicalHookGroup, surface: HookSurface): RenderedGroup {
+  const matcher = resolveMatcher(group.matcher, surface)
+  const hooks = group.hooks.map((hook) => renderCommand(hook, surface))
+  return matcher === undefined ? { hooks } : { matcher, hooks }
+}
+
+function renderCommand(hook: CanonicalHookCommand, surface: HookSurface): RenderedHookCommand {
+  return {
+    type: hook.type,
+    command: withHost(hook.command, surface.hostSuffix),
+    statusMessage: hook.statusMessage,
+    timeout: resolveTimeout(hook.command, hook.timeout, surface),
+  }
+}
+
+/** For `claude-settings` / `codex-hooks` surfaces: canonical event name -> that surface's own rendered groups, in source order. */
+export function renderJsonHooksGroups(doc: CanonicalHooksDoc, surface: HookSurface): ReadonlyMap<string, readonly RenderedGroup[]> {
+  const eventName = (canonical: string): string => surface.eventNames?.[canonical] ?? canonical
+  const out = new Map<string, readonly RenderedGroup[]>()
+  for (const [event, groups] of doc) {
+    out.set(eventName(event), groups.map((g) => renderGroup(g, surface)))
+  }
+  return out
+}
+
+// ---------------------------------------------------------------------------
+// cursor-hooks-v1: {version: 1, hooks: {event: [{command, statusMessage, timeout, matcher?}]}}
+// ---------------------------------------------------------------------------
+
+export interface RenderedCursorEntry {
+  readonly command: string
+  readonly statusMessage: string
+  readonly timeout: number
+  readonly matcher?: string
+}
+
+/** For the `cursor-hooks-v1` surface: its own event name -> flat entry list, in source order. Requires `surface.eventNames` (Cursor's event names are not the canonical ones). */
+export function renderCursorEntries(doc: CanonicalHooksDoc, surface: HookSurface): ReadonlyMap<string, readonly RenderedCursorEntry[]> {
+  const out = new Map<string, readonly RenderedCursorEntry[]>()
+  for (const [event, groups] of doc) {
+    const surfaceEvent = surface.eventNames?.[event]
+    if (surfaceEvent === undefined) throw new Error(`surface "${surface.name}" has no eventNames mapping for "${event}"`)
+    const entries: RenderedCursorEntry[] = []
+    for (const group of groups) {
+      const matcher = resolveMatcher(group.matcher, surface)
+      for (const hook of group.hooks) {
+        const base: RenderedCursorEntry = {
+          command: withHost(hook.command, surface.hostSuffix),
+          statusMessage: hook.statusMessage,
+          timeout: resolveTimeout(hook.command, hook.timeout, surface),
+        }
+        entries.push(matcher === undefined ? base : { ...base, matcher })
+      }
+    }
+    out.set(surfaceEvent, entries)
+  }
+  return out
+}
+
+// ---------------------------------------------------------------------------
+// opencode-plugin: five fixed HookCommandSpec[] template slots
+// ---------------------------------------------------------------------------
+
+export interface RenderedOpencodeEntry {
+  readonly command: string
+  readonly matcher?: string
+  readonly timeoutMs: number
+  readonly fallbackFor?: string
+}
+
+/**
+ * Canonical event -> the opencode-plugin.template.ts array slot it fills.
+ * This correspondence is inherent to that one fixed, committed template
+ * (H3) — not per-repo policy — so it is the one piece of hook-shape
+ * knowledge kept in code rather than in deploy-profile.json.
+ */
+const OPENCODE_SLOT_FOR_EVENT: Readonly<Record<string, string>> = {
+  PreToolUse: 'HOOKS_TOOL_EXECUTE_BEFORE',
+  PostToolUse: 'HOOKS_TOOL_EXECUTE_AFTER',
+  UserPromptSubmit: 'HOOKS_CHAT_MESSAGE',
+  SessionStart: 'HOOKS_EVENT_SESSION_CREATED',
+  SessionEnd: 'HOOKS_EVENT_SESSION_IDLE',
+}
+
+export const OPENCODE_SLOTS: readonly string[] = [
+  'HOOKS_TOOL_EXECUTE_BEFORE',
+  'HOOKS_TOOL_EXECUTE_AFTER',
+  'HOOKS_CHAT_MESSAGE',
+  'HOOKS_EVENT_SESSION_CREATED',
+  'HOOKS_EVENT_SESSION_IDLE',
+]
+
+/** slot name -> rendered entries, in source order. Every event in `doc` must have a known slot (see OPENCODE_SLOT_FOR_EVENT). */
+export function renderOpencodeSlots(doc: CanonicalHooksDoc, surface: HookSurface): ReadonlyMap<string, readonly RenderedOpencodeEntry[]> {
+  const out = new Map<string, RenderedOpencodeEntry[]>()
+  for (const slot of OPENCODE_SLOTS) out.set(slot, [])
+  for (const [event, groups] of doc) {
+    const slot = OPENCODE_SLOT_FOR_EVENT[event]
+    if (slot === undefined) throw new Error(`opencode-plugin has no template slot for canonical event "${event}"`)
+    // `fallbackFor` names the CANONICAL event being substituted (e.g.
+    // "SessionEnd"), not the OpenCode event it is projected onto (the
+    // `eventFallback` map's value, e.g. "SessionIdle") — only its presence
+    // as a key in `eventFallback` decides whether this event was projected.
+    const fallbackFor = surface.eventFallback?.[event] !== undefined ? event : undefined
+    const bucket = out.get(slot)!
+    for (const group of groups) {
+      const matcher = resolveMatcher(group.matcher, surface)
+      for (const hook of group.hooks) {
+        const entry: RenderedOpencodeEntry = {
+          command: withHost(hook.command, surface.hostSuffix),
+          ...(matcher === undefined ? {} : { matcher }),
+          timeoutMs: resolveTimeout(hook.command, hook.timeout, surface),
+          ...(fallbackFor === undefined ? {} : { fallbackFor }),
+        }
+        bucket.push(entry)
+      }
+    }
+  }
+  return out
+}

package/packages/agent-hooks/src/deploy/source.ts

@@ -0,0 +1,84 @@
+/**
+ * Reads assets/hooks.json — the hook commands, in Claude's own wire format,
+ * no --host suffix — into the canonical structure every renderer in
+ * render.ts starts from. Pure: parses, never mutates its input, and
+ * preserves the source file's own event-key order (PreToolUse,
+ * UserPromptSubmit, SessionStart, PostToolUse, SessionEnd) since that order
+ * is what a fresh deploy must reproduce byte-for-byte.
+ */
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+export interface CanonicalHookCommand {
+  readonly type: string
+  readonly command: string
+  readonly statusMessage: string
+  readonly timeout: number
+}
+
+export interface CanonicalHookGroup {
+  readonly matcher?: string
+  readonly hooks: readonly CanonicalHookCommand[]
+}
+
+export type CanonicalHooksDoc = ReadonlyMap<string, readonly CanonicalHookGroup[]>
+
+export const DEFAULT_HOOKS_SOURCE_PATH = fileURLToPath(new URL('../../assets/hooks.json', import.meta.url))
+
+function isHookCommand(value: unknown): value is CanonicalHookCommand {
+  if (typeof value !== 'object' || value === null) return false
+  const v = value as Record<string, unknown>
+  return typeof v.type === 'string' && typeof v.command === 'string' && typeof v.statusMessage === 'string' && typeof v.timeout === 'number'
+}
+
+function isHookGroup(value: unknown): value is CanonicalHookGroup {
+  if (typeof value !== 'object' || value === null) return false
+  const v = value as Record<string, unknown>
+  if (v.matcher !== undefined && typeof v.matcher !== 'string') return false
+  return Array.isArray(v.hooks) && v.hooks.every(isHookCommand)
+}
+
+/** Loads and validates assets/hooks.json (or a fixture at another path). Throws (fails loud) on malformed JSON or an unrecognized shape. */
+export function loadHooksSource(path: string = DEFAULT_HOOKS_SOURCE_PATH): CanonicalHooksDoc {
+  let doc: unknown
+  try {
+    doc = JSON.parse(readFileSync(path, 'utf8'))
+  } catch (cause) {
+    throw new Error(`hooks source is not valid JSON: ${path} (${(cause as Error).message})`)
+  }
+  const hooks = (doc as { hooks?: unknown } | null)?.hooks
+  if (typeof hooks !== 'object' || hooks === null || Array.isArray(hooks)) {
+    throw new Error(`hooks source has no "hooks" object: ${path}`)
+  }
+  const map = new Map<string, readonly CanonicalHookGroup[]>()
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups) || !groups.every(isHookGroup)) {
+      throw new Error(`hooks source event "${event}" is not a valid group array: ${path}`)
+    }
+    map.set(event, groups)
+  }
+  return map
+}
+
+/** One hook command, with which event/group it came from. Used by list.ts/doctor.ts to enumerate "one line per hook." */
+export interface SourceHookRef {
+  readonly event: string
+  readonly matcher: string | undefined
+  readonly command: CanonicalHookCommand
+}
+
+/** Every hook command in the source, in file order. */
+export function flattenSourceHooks(doc: CanonicalHooksDoc): readonly SourceHookRef[] {
+  const out: SourceHookRef[] = []
+  for (const [event, groups] of doc) {
+    for (const group of groups) {
+      for (const hook of group.hooks) out.push({ event, matcher: group.matcher, command: hook })
+    }
+  }
+  return out
+}
+
+/** The base command name for listing/lock purposes: "adl hook X" with the "adl hook " prefix stripped, e.g. "pre-tool-use", "crg pre-commit". */
+export function hookLabel(command: string): string {
+  return command.startsWith('adl hook ') ? command.slice('adl hook '.length) : command
+}