@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.12 → 0.1.28

package/packages/agent-hooks/src/cli/doctor.ts

@@ -13,13 +13,10 @@
  *          signal for that lives now, since UserPromptSubmit only WARNS -- an
  *          empty corpus has an innocent explanation once it is per-host and
  *          per-extension, and a dead prompt is worse than a missing hint);
- *          `lean-ctx` not on PATH or `--version` failing (briefing and the
- *          lean-ctx hooks shell out to it); `code-review-graph` not on PATH
- *          (the crg hooks shell out to it).
+ *          `code-review-graph` not on PATH (the crg hooks shell out to it).
  *   warn — unmanaged repo (hooks no-op by design); `[hooks] enabled = false`;
  *          embedding model missing/corrupt (user-prompt-submit falls back to
- *          BM25-only, never fatal); vector half disabled; lean-ctx allowlist
- *          count not readable.
+ *          BM25-only, never fatal); vector half disabled.
  *
  * The vector half is "effectively disabled by cosineFloor" when the floor
  * exceeds 1: a vector hit must reach `cosine >= cosineFloor` to enter fusion
@@ -36,8 +33,6 @@ import { scanSkills } from '../hooks/user-prompt-submit/skills.ts'
 import { loadTokenizer } from '../hooks/user-prompt-submit/tokenizer.ts'
 import { loadVectorHalf, resolveGlobalArtifactDir } from '../hooks/user-prompt-submit/vector.ts'
 import { HOOKS_DENY_LOG_REL, HOOKS_LOG_REL } from '../hooks/log.ts'
-import { DEFAULT_LEAN_CTX_DIR, leanCtxEnv } from '../lean-ctx/env.ts'
-import { spawnWithTimeout } from '../lib/spawn-with-timeout.ts'
 import { buildEngineContext } from '../rules/engine.ts'
 import { liveEnv, liveRepoIndex } from '../rules/ports.ts'
 import { BUILTIN_RULES, requireRegistered } from '../rules/registry.ts'
@@ -46,6 +41,9 @@ import { type CliResult, type LoadedRepo, cliError, loadRepo, parseArgs, unmanag
 type Status = 'ok' | 'warn' | 'FAIL' | 'skip' | 'info'
 type Env = Readonly<Record<string, string | undefined>>
 
+/** Reserved for callers that previously supplied process-check timeouts. */
+export interface DoctorOptions { readonly timeoutMs?: number }
+
 interface Check {
   readonly status: Status
   readonly text: string
@@ -53,13 +51,6 @@ interface Check {
 
 const check = (status: Status, name: string, detail: string): Check => ({ status, text: `${name}: ${detail}` })
 
-export interface DoctorOptions {
-  /** Per-subprocess timeout for `lean-ctx --version` / `lean-ctx doctor --json`. */
-  readonly timeoutMs?: number
-}
-
-const DEFAULT_TIMEOUT_MS = 10_000
-
 /** Config + rule resolution, and the config the downstream checks use (null when unusable). */
 function repoChecks(loaded: LoadedRepo): { readonly checks: Check[]; readonly config: AdlRepoConfig | null } {
   const { state } = loaded
@@ -148,48 +139,6 @@ function modelAndVector(env: Env): Check[] {
   return [model, vector]
 }
 
-async function leanCtxChecks(
-  loaded: LoadedRepo,
-  config: AdlRepoConfig | null,
-  env: Env,
-  timeoutMs: number,
-): Promise<Check[]> {
-  const path = Bun.which('lean-ctx', { PATH: env.PATH ?? '' })
-  const skipAllowlist = check('skip', 'lean-ctx allowlist', 'lean-ctx not usable')
-  if (path === null) return [check('FAIL', 'lean-ctx', `not found on PATH (${env.PATH ?? ''})`), skipAllowlist]
-  const version = await spawnWithTimeout(path, ['--version'], { env, timeoutMs })
-  if (version.exitCode !== 0) {
-    const reason = version.timedOut ? `timed out after ${timeoutMs}ms` : `exited ${version.exitCode}: ${version.stderr.trim()}`
-    return [check('FAIL', 'lean-ctx', `${path} --version ${reason}`), skipAllowlist]
-  }
-  const binary = check('ok', 'lean-ctx', `${path} (${version.stdout.trim().split('\n')[0]})`)
-
-  // Same env the hooks give lean-ctx: repo-rooted LEAN_CTX_* in a managed repo, lean-ctx's own defaults otherwise (mcp.ts).
-  // `config` is the value `repoChecks` already decoded — reusing it keeps an invalid
-  // `adl-config.toml` reported by the `config` check above rather than thrown from here.
-  const root = loaded.state.managed && config !== null ? (loaded.state.root as string) : null
-  const childEnv = root === null ? { ...env } : leanCtxEnv(root, env, config?.hooks.leanCtxDir ?? DEFAULT_LEAN_CTX_DIR)
-  const scope = root === null ? 'lean-ctx defaults; LEAN_CTX_CONFIG_DIR unset' : `LEAN_CTX_CONFIG_DIR=${childEnv.LEAN_CTX_CONFIG_DIR}`
-  const unavailable = (reason: string): Check[] => [binary, check('warn', 'lean-ctx allowlist', `unavailable (${reason})`)]
-  const doctor = await spawnWithTimeout(path, ['doctor', '--json'], { env: childEnv, timeoutMs, ...(root === null ? {} : { cwd: root }) })
-  if (doctor.timedOut) return unavailable(`lean-ctx doctor --json timed out after ${timeoutMs}ms`)
-  // A non-zero exit alone is not a failure: lean-ctx 3.10.1 exits 1 whenever any of its OWN checks fail
-  // (e.g. no shell aliases) while still printing the full report. Only a report we cannot read is.
-  let parsed: { readonly checks?: readonly { readonly name?: string }[] }
-  try {
-    parsed = JSON.parse(doctor.stdout) as typeof parsed
-  } catch {
-    return unavailable(
-      doctor.exitCode === 0
-        ? 'lean-ctx doctor --json printed invalid JSON'
-        : `lean-ctx doctor --json exited ${doctor.exitCode}: ${doctor.stderr.trim()}`,
-    )
-  }
-  const count = (parsed.checks ?? []).map((entry) => /Shell allowlist\s+(\d+) command/.exec(entry.name ?? '')?.[1]).find((n) => n !== undefined)
-  if (count === undefined) return unavailable('no "Shell allowlist" check in lean-ctx doctor --json')
-  return [binary, check('ok', 'lean-ctx allowlist', `${count} command(s) enforced (${scope})`)]
-}
-
 /** Both hook logs: path, row count, and for the deny log its last 5 rows. JSON Lines (docs/architecture/cli-design.md §5a): every line is a record, there is no header row to skip. */
 function logChecks(loaded: LoadedRepo): Check[] {
   if (!loaded.state.managed) return [check('skip', 'logs', 'not a managed repo (hooks log nothing here)')]
@@ -216,7 +165,7 @@ function crgCheck(env: Env): Check {
 }
 
 /** `argv` is everything after `doctor`. */
-export async function runDoctor(argv: readonly string[], cwd: string, env: Env, options: DoctorOptions = {}): Promise<CliResult> {
+export async function runDoctor(argv: readonly string[], cwd: string, env: Env, _options: DoctorOptions = {}): Promise<CliResult> {
   const parsed = parseArgs(argv, false)
   if ('error' in parsed) return cliError(parsed.error)
   if (parsed.positionals.length > 0) return cliError(`unexpected argument '${parsed.positionals[0]}'`)
@@ -228,7 +177,6 @@ export async function runDoctor(argv: readonly string[], cwd: string, env: Env,
     ...repo.checks,
     ...hooksAndSkills(loaded, repo.config),
     ...modelAndVector(env),
-    ...(await leanCtxChecks(loaded, repo.config, env, options.timeoutMs ?? DEFAULT_TIMEOUT_MS)),
     crgCheck(env),
     ...logChecks(loaded),
   ]

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

@@ -23,7 +23,6 @@ import {
   readLegacyLock,
   sha256Hex,
   stripLegacyOwnership,
-  unionOwnedCommands,
 } from './legacy-lock.ts'
 import { type HookLockEntry, lockPathFor, readLock, writeLock } from './lock.ts'
 import { type HookDeployProfile, type HookSurface, loadProfile } from './profile.ts'
@@ -51,13 +50,13 @@ export interface DeployHooksOptions {
   readonly dryRun?: boolean
 }
 
-export interface HookConflict {
+interface HookConflict {
   readonly file: string
   readonly reason: string
 }
 
 /** One hook healed via the PAIR fallback (not hash, not the legacy channel) this run — see json-merge.ts's `RestoredHook` for the full rationale (2026-09-30, round 5, finding 2). */
-export interface RestoredHookReport {
+interface RestoredHookReport {
   readonly file: string
   readonly event: string
   readonly command: string
@@ -78,17 +77,6 @@ export interface DeployHooksResult {
   readonly unchanged: readonly string[]
   readonly conflicts: readonly HookConflict[]
   readonly lockPath: string
-  /**
-   * Surface files whose lock entry moved from the legacy
-   * (`ownedCommands`-only) shape to the content-addressed one
-   * (`ownedEntries`) on THIS run (independent review, 2026-09-30, finding
-   * 7). This can be non-empty even when the surface's own `written`/
-   * `unchanged` outcome looks like nothing happened — the deployed JSON
-   * file can stay byte-identical while the LOCK itself is rewritten, and
-   * that rewrite deserves its own truthful line in the CLI's output
-   * rather than being folded silently into "unchanged".
-   */
-  readonly lockMigrated: readonly string[]
   /** Hooks healed via the pair fallback this run, named explicitly (round 5, finding 2) so deploy's own output, doctor's preview, and `adl install` can all say "restored adl hook <event>/<matcher>/<command> — local changes to it were replaced". */
   readonly restored: readonly RestoredHookReport[]
 }
@@ -134,12 +122,11 @@ export function deployHooks(options: DeployHooksOptions): DeployHooksResult {
   const written: string[] = []
   const unchanged: string[] = []
   const conflicts: HookConflict[] = []
-  const lockMigrated: string[] = []
   const restored: RestoredHookReport[] = []
   const takeover = { any: false }
 
   for (const surface of profile.surfaces) {
-    deploySurface(surface, { assetsDir, targetRepo, hooksDoc, lock, legacyDoc, takeover, newEntries, written, unchanged, conflicts, lockMigrated, restored, dryRun })
+    deploySurface(surface, { assetsDir, targetRepo, hooksDoc, lock, legacyDoc, takeover, newEntries, written, unchanged, conflicts, restored, dryRun })
   }
 
   if (!dryRun) writeLock(targetRepo, { version: 1, entries: newEntries })
@@ -158,7 +145,6 @@ export function deployHooks(options: DeployHooksOptions): DeployHooksResult {
     unchanged: unchanged.sort(),
     conflicts: conflicts.sort((a, b) => a.file.localeCompare(b.file)),
     lockPath: lockPathFor(targetRepo),
-    lockMigrated: lockMigrated.sort(),
     restored,
   }
 }
@@ -176,7 +162,6 @@ interface DeploySurfaceContext {
   readonly written: string[]
   readonly unchanged: string[]
   readonly conflicts: HookConflict[]
-  readonly lockMigrated: string[]
   readonly restored: RestoredHookReport[]
   readonly dryRun: boolean
 }
@@ -212,38 +197,24 @@ function deploySurface(surface: HookSurface, ctx: DeploySurfaceContext): void {
   // Ownership is content-addressed (json-merge.ts's own header, second
   // independent review 2026-09-29): `recordedEntries` is THIS package's own
   // prior write, read straight from the lock as hash+command pairs, never
-  // derived from command text alone. A lock with no `ownedEntries` at all
-  // (every repo enrolled before this fix) has no hashes to give — for
-  // exactly this one transitional deploy, its OLD `ownedCommands` feeds the
-  // command-anywhere fallback channel instead, unioned with
-  // `legacyTakeover.ownedByEvent` (the pre-agent-hooks engine's own
-  // hash-verified takeover signal — a different legacy source, same
-  // "command text is the only proof we have" shape).
+  // derived from command text alone. `readLock` (lock.ts) has already
+  // refused any entry without `ownedEntries` (Tarun, 2026-10-01: the legacy
+  // `ownedCommands`-only shape is no longer migrated). The command-anywhere
+  // channel below is fed ONLY by `legacyTakeover.ownedByEvent` — the
+  // pre-agent-hooks engine's own hash-verified takeover signal, a different
+  // legacy source that is deliberately kept.
   const sameFormatPrev = prevEntry !== undefined && prevEntry.format === surface.format ? prevEntry : undefined
-  const isLegacyShapedLock = sameFormatPrev !== undefined && sameFormatPrev.ownedEntries === undefined
-  // Independent review, 2026-09-30, finding 7: this transitional deploy
-  // rewrites the LOCK from the legacy (`ownedCommands`-only) shape to the
-  // content-addressed one — report it, since the deployed JSON file can
-  // stay byte-identical while that rewrite happens underneath it.
-  if (isLegacyShapedLock) ctx.lockMigrated.push(surface.file)
   const recordedEntries = sameFormatPrev?.ownedEntries ?? {}
-  const ownCommandsLegacyFallback = isLegacyShapedLock ? sameFormatPrev.ownedCommands : {}
   const existingRaw = readExistingJson(targetAbs)
   const legacyTakeover = legacyTakeoverForJsonHooksSurface(existingRaw, ctx.legacyDoc, surface.file)
   if (legacyTakeover.matched) ctx.takeover.any = true
-  const legacyCommandsAnywhere = unionOwnedCommands(ownCommandsLegacyFallback, legacyTakeover.ownedByEvent)
+  const legacyCommandsAnywhere = legacyTakeover.ownedByEvent
 
   if (surface.format === 'cursor-hooks-v1') {
     const desired = renderCursorEntries(ctx.hooksDoc, surface)
     const { fileContent, ownedCommands, ownedEntries, changed, restored, ambiguousConflicts } = mergeCursorHooksFile(existingRaw, desired, recordedEntries, legacyCommandsAnywhere)
     writeJsonIfChanged(targetAbs, fileContent, changed, ctx.dryRun)
-    // Independent review, 2026-09-30, round 5, finding 4: a legacy lock
-    // migration rewrites the LOCK for real even when this surface's own
-    // deployed content stays byte-identical — count that as "written",
-    // not "unchanged", so a caller reading these two arrays (which is
-    // exactly what "up to date (no changes)" and "written: N" do) never
-    // reports a pure no-op when something real did change on disk.
-    ;(changed || isLegacyShapedLock ? ctx.written : ctx.unchanged).push(surface.file)
+    ;(changed ? ctx.written : ctx.unchanged).push(surface.file)
     ctx.newEntries[surface.file] = { format: 'cursor-hooks-v1', ownedCommands, ownedEntries }
     for (const hook of restored) ctx.restored.push(makeRestoredReport(surface.file, hook))
     for (const conflict of ambiguousConflicts) ctx.conflicts.push({ file: surface.file, reason: ambiguousConflictReason(conflict) })
@@ -254,7 +225,7 @@ function deploySurface(surface: HookSurface, ctx: DeploySurfaceContext): void {
   const desired = renderJsonHooksGroups(ctx.hooksDoc, surface)
   const { fileContent, ownedCommands, ownedEntries, changed, restored, ambiguousConflicts } = mergeJsonHooksFile(existingRaw, desired, recordedEntries, legacyCommandsAnywhere)
   writeJsonIfChanged(targetAbs, fileContent, changed, ctx.dryRun)
-  ;(changed || isLegacyShapedLock ? ctx.written : ctx.unchanged).push(surface.file)
+  ;(changed ? ctx.written : ctx.unchanged).push(surface.file)
   ctx.newEntries[surface.file] = { format: surface.format, ownedCommands, ownedEntries }
   for (const hook of restored) ctx.restored.push(makeRestoredReport(surface.file, hook))
   for (const conflict of ambiguousConflicts) ctx.conflicts.push({ file: surface.file, reason: ambiguousConflictReason(conflict) })

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

@@ -29,7 +29,7 @@ import {
 import { renderCursorEntries, renderJsonHooksGroups } from './render.ts'
 import { type CanonicalHooksDoc, loadHooksSource } from './source.ts'
 
-export interface DoctorIssue {
+interface DoctorIssue {
   readonly severity: 'error' | 'info'
   readonly path: string
   readonly reason: string
@@ -44,7 +44,7 @@ function toResult(issues: readonly DoctorIssue[]): DoctorResult {
   return { ok: issues.every((issue) => issue.severity !== 'error'), issues }
 }
 
-export { validateProfileDocument }
+
 
 export interface DoctorDeploymentOptions {
   readonly assetsDir: string
@@ -71,13 +71,10 @@ function doctorJsonSurface(surface: HookSurface, targetRepo: string, hooksDoc: C
   const targetAbs = join(targetRepo, surface.file)
   const exists = existsSync(targetAbs)
   const lockEntry = lock.entries[surface.file]?.format === surface.format ? (lock.entries[surface.file] as JsonHooksLockEntry) : undefined
-  // Same fallback deploy.ts itself uses: a lock with no ownedEntries at all
-  // (every repo enrolled before the content-hash fix) has no hashes to
-  // give, so its OLD ownedCommands feeds the command-anywhere channel
-  // instead -- otherwise doctor would report drift for every currently-
-  // enrolled repo's untouched content that deploy itself recognizes fine.
+  // `readLock` has already refused any entry without `ownedEntries`
+  // (Tarun, 2026-10-01: the legacy `ownedCommands`-only shape is no longer
+  // migrated), so ownership here is always the content-addressed record.
   const recordedEntries = lockEntry?.ownedEntries ?? {}
-  const legacyCommandsAnywhere = lockEntry !== undefined && lockEntry.ownedEntries === undefined ? lockEntry.ownedCommands : {}
 
   let parseFailed = false
   if (exists) {
@@ -92,8 +89,8 @@ function doctorJsonSurface(surface: HookSurface, targetRepo: string, hooksDoc: C
   const existingRaw = readExistingJson(targetAbs)
   const merged =
     surface.format === 'cursor-hooks-v1'
-      ? mergeCursorHooksFile(existingRaw, renderCursorEntries(hooksDoc, surface), recordedEntries, legacyCommandsAnywhere)
-      : mergeJsonHooksFile(existingRaw, renderJsonHooksGroups(hooksDoc, surface), recordedEntries, legacyCommandsAnywhere)
+      ? mergeCursorHooksFile(existingRaw, renderCursorEntries(hooksDoc, surface), recordedEntries)
+      : mergeJsonHooksFile(existingRaw, renderJsonHooksGroups(hooksDoc, surface), recordedEntries)
 
   if (!exists) {
     return [{ severity: 'error', path: surface.file, reason: 'expected hook wiring has not been deployed' }]
@@ -144,7 +141,7 @@ function doctorJsonSurface(surface: HookSurface, targetRepo: string, hooksDoc: C
         severity: 'error' as const,
         path: `${surface.file}#${event}`,
         reason:
-          recordedEntries[event] !== undefined || legacyCommandsAnywhere[event] !== undefined
+          recordedEntries[event] !== undefined
             ? 'deploy-written hook entries were modified since deploy, or assets/hooks.json changed since; run deploy to update'
             : 'expected hook wiring for this event has not been deployed',
       }

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

@@ -1,17 +1,17 @@
-export { deployHooks, type DeployHooksOptions, type DeployHooksResult, type HookConflict } from './deploy.ts'
-export { doctorDeployment, type DoctorDeploymentOptions, type DoctorIssue, type DoctorResult } from './doctor.ts'
-export { formatHookLine, listHooks, type HookListing, type HookListingEntry, type HookOwner, type ListHooksOptions } from './list.ts'
-export { type HookLock, type HookLockEntry, LOCK_RELATIVE_PATH, lockPathFor, readLock, writeLock } from './lock.ts'
+export { deployHooks,  type DeployHooksResult,  } from './deploy.ts'
+export { doctorDeployment,   type DoctorResult } from './doctor.ts'
+export { formatHookLine, listHooks,     } from './list.ts'
+
 export {
-  DEFAULT_PROFILE_PATH,
-  DEFAULT_PROFILE_SCHEMA_PATH,
-  type HookDeployProfile,
-  HOOK_WIRE_FORMATS,
-  type HookSurface,
-  type HookWireFormat,
+  
+  
+  
+  
+  
+  
   loadProfile,
-  type ProfileIssue,
-  validateProfileDocument,
+  
+  
 } from './profile.ts'
-export { renderCursorEntries, renderJsonHooksGroups, renderOpencodeSlots } from './render.ts'
-export { DEFAULT_HOOKS_SOURCE_PATH, flattenSourceHooks, hookLabel, loadHooksSource, type CanonicalHooksDoc } from './source.ts'
+
+

package/packages/agent-hooks/src/deploy/json-merge.ts

@@ -44,14 +44,13 @@
  * position; adl's slot is restored separately, right there — never
  * deleted, never duplicated.
  *
- * A lock recording no hashes at all (`ownedEntries` absent — every repo
- * enrolled before this fix; closes (a)) falls back, for exactly this one
- * transitional deploy, to command-anywhere matching against the lock's OLD
- * `ownedCommands` — the only signal that data has — via the SAME
- * `legacyOwnedCommands` channel the pre-agent-hooks engine's own takeover
- * already used (both are "we have no better proof than an exact command
- * string" signals). This run then persists real content hashes
- * (`ownedEntries`), so every later deploy uses the full contract.
+ * The `legacyOwnedCommands` channel ("command text is the only proof we
+ * have") is fed ONLY by the pre-agent-hooks engine's own hash-verified
+ * takeover (legacy-lock.ts). It used to ALSO carry a one-deploy transitional
+ * fallback for a lock with no hashes at all (`ownedEntries` absent — every
+ * repo enrolled before this fix; closed (a)); that transition is over
+ * (Tarun, 2026-10-01): lock.ts's `readLock` now refuses such an entry
+ * outright, so every deploy here uses the full content-addressed contract.
  *
  * THIRD independent review (2026-09-30) found the fallback ITSELF still
  * leaked through raw array position, in two ways:

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

@@ -61,13 +61,13 @@ export function stableStringify(value: unknown): string {
 /** Content hash of a JSON value, exactly as the legacy engine recorded it. */
 export const legacyValueHash = (value: unknown): string => sha256Hex(stableStringify(value))
 
-export interface LegacyJsonMergeEntry {
+interface LegacyJsonMergeEntry {
   readonly type: string
   readonly path: readonly (string | number)[]
   readonly sha256: string
 }
 
-export interface LegacyMergedRecord {
+interface LegacyMergedRecord {
   readonly entries?: readonly LegacyJsonMergeEntry[]
 }
 

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

@@ -10,7 +10,7 @@ import { type HookLockEntry, readLock } from './lock.ts'
 import { type HookDeployProfile, type HookSurface, loadProfile } from './profile.ts'
 import { flattenSourceHooks, hookLabel, loadHooksSource, type CanonicalHooksDoc } from './source.ts'
 
-export type HookOwner = 'adl' | 'user' | 'conflict' | '-'
+type HookOwner = 'adl' | 'user' | 'conflict' | '-'
 
 export interface HookListingEntry {
   readonly name: string

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

@@ -7,8 +7,12 @@
  * 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
+ * "owned" is recorded per surface event name as content-addressed hook
+ * entries (`ownedEntries`: hash + command + matcher), alongside the exact
+ * rendered command strings (`ownedCommands`, already carrying
+ * --host=<surface>; informational, read by list.ts). `readLock` refuses an
+ * entry without `ownedEntries` (the older `ownedCommands`-only shape is no
+ * longer migrated — Tarun, 2026-10-01). For
  * the opencode-plugin surface, the whole file is wholly adl-owned (H3) —
  * `owned: true` records that fact rather than a per-command breakdown.
  */
@@ -29,7 +33,7 @@ export const LOCK_RELATIVE_PATH = '.agents/agent-hooks.lock.json'
  * never by array position/index, which the second independent review
  * already ruled unreliable.
  */
-export interface OwnedHookEntry {
+interface OwnedHookEntry {
   readonly hash: string
   readonly command: string
   readonly matcher?: string
@@ -37,7 +41,7 @@ export interface OwnedHookEntry {
 
 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 — informational only (list.ts); ownership itself is `ownedEntries`, below. */
+  /** Surface event name -> the exact command strings (with --host) this deploy wrote into that event's array — informational only (list.ts reads it to label what is adl's); ownership itself is `ownedEntries`, below. */
   readonly ownedCommands: Readonly<Record<string, readonly string[]>>
   /**
    * Surface event name -> this deploy's own written hooks, content-
@@ -45,16 +49,14 @@ export interface JsonHooksLockEntry {
    * pure array-index tracking, broke the moment a user inserted or
    * removed an entry before adl's own block, and could not express
    * "split a group" when a user hook was appended inside one — see
-   * json-merge.ts's header for the corrected rule). Absent on a lock
-   * written before EITHER ownership fix existed (every repo enrolled
-   * before this one) — every reader treats that as "derive ownership
-   * once from `ownedCommands` by exact command match, then persist real
-   * entries here," never as malformed.
+   * json-merge.ts's header for the corrected rule). Required: `readLock`
+   * refuses an entry without it (Tarun, 2026-10-01: the transitional
+   * rewrite of the older `ownedCommands`-only shape is gone).
    */
-  readonly ownedEntries?: Readonly<Record<string, readonly OwnedHookEntry[]>>
+  readonly ownedEntries: Readonly<Record<string, readonly OwnedHookEntry[]>>
 }
 
-export interface OpencodePluginLockEntry {
+interface OpencodePluginLockEntry {
   readonly format: 'opencode-plugin'
   readonly owned: true
 }
@@ -86,7 +88,24 @@ export function readLock(targetRepo: string): HookLock {
   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> }
+  const entries = record.entries as Record<string, HookLockEntry>
+  // Tarun, 2026-10-01: the legacy (`ownedCommands` without `ownedEntries`) ->
+  // content-addressed migration is over. Reading such an entry as "owns
+  // nothing" would duplicate every adl hook already in the file, and
+  // guessing ownership from command text is the very thing content-
+  // addressing replaced — so refuse, loudly, and say how to recover.
+  for (const [file, entry] of Object.entries(entries)) {
+    if (typeof entry !== 'object' || entry === null || entry.format === 'opencode-plugin') continue
+    const ownedEntries: unknown = (entry as { ownedEntries?: unknown }).ownedEntries
+    if (typeof ownedEntries !== 'object' || ownedEntries === null || Array.isArray(ownedEntries)) {
+      throw new Error(
+        `agent-hooks lock entry for ${file} has no usable \`ownedEntries\` (the older \`ownedCommands\`-only shape is no longer migrated): ${path}. ` +
+          `Recover by removing the adl-written hook commands listed under that entry's \`ownedCommands\` from ${file}, deleting that entry from the lock (or deleting the lock file), ` +
+          `then running \`adl hooks deploy --repo ${targetRepo}\` to re-enrol.`,
+      )
+    }
+  }
+  return { version: 1, entries }
 }
 
 /** Skips the write entirely when the serialized content is already byte-identical (independent review, 2026-09-29, finding 8: a genuine no-op run must not touch the lock file's mtime either). */

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

@@ -16,11 +16,10 @@ 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']
+type HookWireFormat = 'claude-settings' | 'codex-hooks' | 'cursor-hooks-v1' | 'opencode-plugin'
 
-export type UnmappedMatcherPolicy = 'keep' | 'drop'
-export type TimeoutUnit = 's' | 'ms'
+type UnmappedMatcherPolicy = 'keep' | 'drop'
+type TimeoutUnit = 's' | 'ms'
 
 export interface HookSurface {
   readonly name: string

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

@@ -23,7 +23,7 @@ export interface CanonicalHookGroup {
 
 export type CanonicalHooksDoc = ReadonlyMap<string, readonly CanonicalHookGroup[]>
 
-export const DEFAULT_HOOKS_SOURCE_PATH = fileURLToPath(new URL('../../assets/hooks.json', import.meta.url))
+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

package/packages/agent-hooks/src/gating/config.ts

@@ -10,8 +10,9 @@
  * `adl-config.toml` is shared with other tools at the same root: adl hook
  * owns `[hooks]`, `[rules]`, and `[repo]`; `adl-repo-controls` owns
  * `[controls]`; `adl-extensions` owns `[extensions]` (and, before its
- * HARDCUT, `[skills]`). `[controls]` and `[skills]` are recognized root tables
- * this module accepts and never reads into.
+ * HARDCUT, `[skills]`). `[azdo]` is reserved for shared Azure DevOps
+ * configuration. `[controls]`, `[skills]`, and `[azdo]` are recognized root
+ * tables this module accepts and never reads into.
  *
  * `[extensions]` is the one exception, and a deliberate one: its sub-table
  * KEYS are decoded into `AdlRepoConfig.extensions`. Since adl-extensions
@@ -27,13 +28,6 @@
  *                              # (pre-tool-use, user-prompt-submit, briefing,
  *                              # crg) for this repo: exit 0, empty stdout/stderr.
  *   skills_dir = ".agents/skills"  # optional; see src/hooks/user-prompt-submit
- *   lean_ctx_dir = ".agents/lean-ctx"  # optional; repo-relative root for
- *                              # lean-ctx's own config/data/state/cache dirs
- *                              # (see src/lean-ctx/env.ts). A throwaway repo
- *                              # — a binary test fixture, say — sets this so
- *                              # lean-ctx's state, and any daemon it starts
- *                              # off that state, lands somewhere disposable
- *                              # instead of the default.
  *
  *   [rules]
  *   default = "on"             # "on" | "off"; baseline for rules with no
@@ -69,7 +63,7 @@
 
 import { MARKER } from './root.ts'
 
-export interface RuleSection {
+interface RuleSection {
   readonly enabled: boolean
 }
 
@@ -79,11 +73,9 @@ export interface RulesConfig {
   readonly byId: Readonly<Record<string, RuleSection>>
 }
 
-export interface HooksConfig {
+interface HooksConfig {
   readonly enabled: boolean
   readonly skillsDir: string | undefined
-  /** Repo-relative root for lean-ctx's config/data/state/cache; see `../lean-ctx/env.ts`. */
-  readonly leanCtxDir: string | undefined
 }
 
 /**
@@ -185,7 +177,7 @@ const DEFAULT_AGENT: AgentSection = {
 }
 
 const DEFAULT_CONFIG: AdlRepoConfig = {
-  hooks: { enabled: true, skillsDir: undefined, leanCtxDir: undefined },
+  hooks: { enabled: true, skillsDir: undefined },
   rules: { default: 'on', unsafeAllowUncertain: false, byId: {} },
   repo: DEFAULT_REPO,
   agent: DEFAULT_AGENT,
@@ -222,13 +214,15 @@ function rejectUnknownKeys(
  * Top-level keys `decodeConfig` recognizes. `version` is accepted (and
  * ignored) only so the marker file's own minimal `version = 1\n` convention
  * stays valid — this package has no schema migrations to gate on it.
- * controls/skills: see module header for ownership.
+ * controls/skills/azdo: see module header for ownership.
  */
 /**
  * Root tables this module accepts. It owns `version`/`hooks`/`rules`/`repo`
  * and never reads the rest — they belong to the other tools sharing this file:
- * `controls` to adl-repo-controls, and `extensions` (formerly `skills`) to
- * adl-extensions.
+ * `controls` to adl-repo-controls, `extensions` (formerly `skills`) to
+ * adl-extensions, `azdo` to shared Azure DevOps configuration, and `dispatch`
+ * to adl-dispatcher (the integration-base ref + per-checkout selector the
+ * dispatcher reads; this package neither reads nor validates its schema).
  *
  * `skills` is retained alongside `extensions` on purpose. adl-extensions
  * HARDCUT to `[extensions]` because an extension owns its skills rather than
@@ -237,7 +231,7 @@ function rejectUnknownKeys(
  * here would fail exactly those repos, the ones nobody has touched yet.
  */
 const KNOWN_ROOT_KEYS: ReadonlySet<string> = new Set([
-  'version', 'hooks', 'rules', 'repo', 'agent', 'controls', 'skills', 'extensions',
+  'version', 'hooks', 'rules', 'repo', 'agent', 'controls', 'skills', 'extensions', 'azdo', 'dispatch',
 ])
 
 /**
@@ -314,17 +308,11 @@ function decodeHooks(value: unknown): { ok: true; value: HooksConfig } | { ok: f
     return { ok: false, issue: { pointer: '/hooks/skills_dir', message: 'expected a string' } }
   }
 
-  const leanCtxDirRaw = value.lean_ctx_dir
-  if (leanCtxDirRaw !== undefined && typeof leanCtxDirRaw !== 'string') {
-    return { ok: false, issue: { pointer: '/hooks/lean_ctx_dir', message: 'expected a string' } }
-  }
-
   return {
     ok: true,
     value: {
       enabled: enabledRaw ?? true,
       skillsDir: skillsDirRaw,
-      leanCtxDir: leanCtxDirRaw,
     },
   }
 }

package/packages/agent-hooks/src/gating/root.ts

@@ -28,7 +28,7 @@ import { dirname, join } from 'node:path'
 import { statSync } from 'node:fs'
 
 /** Guard against a symlink loop or a pathological mount turning the walk into a hang. */
-export const MAX_WALK_DEPTH = 128
+const MAX_WALK_DEPTH = 128
 
 /** The repo marker + settings file (docs/architecture/adl-config.md). Hard cut (Tarun, 2026-09-27): no fallback read of the old `adl-config.toml` name. */
 export const MARKER = 'adl-config.toml'
@@ -40,7 +40,7 @@ export interface RootIO {
   readonly cwd: () => string
 }
 
-export interface GitRootResult {
+interface GitRootResult {
   readonly root: string | null
   readonly searched: readonly string[]
 }
@@ -50,7 +50,7 @@ export interface GitRootResult {
  * Stops at the first one found, at the filesystem root, or after
  * `MAX_WALK_DEPTH` levels — whichever comes first.
  */
-export function findGitRoot(io: RootIO, startDir: string): GitRootResult {
+function findGitRoot(io: RootIO, startDir: string): GitRootResult {
   const searched: string[] = []
   let current = startDir
 

package/packages/agent-hooks/src/hooks/briefing/handler.ts

@@ -13,9 +13,9 @@
  */
 
 import type { HookInvocation, HookResult } from '../contract.ts'
-import { bunRunner, createBriefingHandler } from './index.ts'
+import { createBriefingHandler } from './index.ts'
 
-const briefingHandler = createBriefingHandler({ run: bunRunner })
+const briefingHandler = createBriefingHandler()
 
 export async function handleBriefing(inv: HookInvocation): Promise<HookResult> {
   return briefingHandler(inv)