dsh-tower 2.3.0 → 2.4.0

package/scripts/types-coverage.mjs

@@ -0,0 +1,184 @@
+// Type-coverage fitness rule (#115, step 1).
+//
+// The checked program must be derived from the shipped program: every runtime
+// `.js` file that `package.json` publishes has to appear in the `tsc` program,
+// otherwise "this file is unchecked" cannot even be reported. Today the
+// tsconfig `include` list is hand-written, so a new module outside it is
+// invisible by construction; this gate makes that gap a red check.
+//
+// Run: node scripts/types-coverage.mjs [--root <dir>] [--json]
+//
+// The shipped set comes from `package.json` `files` (the same list `npm pack`
+// uses; scripts/pack-manifest.txt pins the reviewed snapshot). The checked set
+// comes from `tsc --noEmit --listFiles`, so no second enumeration is involved:
+// changing the tsconfig is enough and this gate follows.
+//
+// Excluded tiers are data with a reason, not silent gaps:
+//   - `ui-bundle/**` is the optional Web client: a browser artifact with DOM
+//     types and no Node runtime, checked by tests/ui-bundle.test.mjs and the
+//     architecture client rules instead of the Node tsc program;
+//   - `scripts/**` is build/dev tooling (ESM `.mjs`, not plugin runtime).
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url))
+const SELF_ROOT = path.resolve(MODULE_DIR, '..')
+const TSC_BIN = path.join(SELF_ROOT, 'node_modules', 'typescript', 'bin', 'tsc')
+const WALK_SKIP = new Set(['node_modules', '.git', '.dsh-tower-worktrees', 'coverage', '.nyc_output'])
+
+/** Shipped `.js` tiers that are deliberately outside the Node tsc program. */
+export const NOT_CHECKED_TIERS = [
+  {
+    pattern: 'ui-bundle/**',
+    reason: 'optional Web client: browser artifact, checked by tests/ui-bundle.test.mjs and the client architecture rules',
+  },
+  {
+    pattern: 'scripts/**',
+    reason: 'build/dev tooling, not plugin runtime',
+  },
+]
+
+/** Expand one package.json `files` pattern into repo-relative paths. */
+export function globToRegExp(pattern) {
+  const source = String(pattern)
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '\u0000')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]')
+    .replace(/\u0000\//g, '(?:[^/]+/)*')
+    .replace(/\u0000/g, '.*')
+  return new RegExp(`^${source}$`)
+}
+
+function walkFiles(root, relative = '') {
+  const dir = path.join(root, relative)
+  if (!fs.existsSync(dir)) return []
+  const out = []
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (WALK_SKIP.has(entry.name)) continue
+    const next = relative ? `${relative}/${entry.name}` : entry.name
+    if (entry.isDirectory()) out.push(...walkFiles(root, next))
+    else out.push(next)
+  }
+  return out
+}
+
+/**
+ * Resolve `package.json` `files` into the repo-relative file list.
+ * A trailing slash (or a bare directory name) means the whole directory, the
+ * same reading `npm pack` gives it.
+ * @param {string[]} patterns
+ * @param {string[]} files every repo-relative file
+ * @returns {string[]}
+ */
+export function expandShipped(patterns, files) {
+  const out = new Set()
+  for (const pattern of patterns) {
+    if (typeof pattern !== 'string' || pattern.length === 0) continue
+    const normalized = pattern.endsWith('/') ? `${pattern}**` : pattern
+    const matcher = globToRegExp(normalized)
+    const directory = !/\*|\?/.test(normalized) && files.some((file) => file.startsWith(`${normalized}/`))
+    const hit = (file) => (directory ? file === normalized || file.startsWith(`${normalized}/`) : matcher.test(file))
+    for (const file of files) if (hit(file)) out.add(file)
+  }
+  return [...out].sort()
+}
+
+/**
+ * The Node-runtime slice of the shipped set: `.js` files minus the documented
+ * non-Node tiers.
+ * @param {string[]} shipped
+ * @returns {{ runtime: string[], excluded: Array<{ file: string, reason: string }> }}
+ */
+export function runtimeJavaScript(shipped) {
+  const excluded = []
+  const runtime = []
+  for (const file of shipped) {
+    if (!file.endsWith('.js')) continue
+    const tier = NOT_CHECKED_TIERS.find((entry) => globToRegExp(entry.pattern).test(file))
+    if (tier) excluded.push({ file, reason: tier.reason })
+    else runtime.push(file)
+  }
+  return { runtime: runtime.sort(), excluded }
+}
+
+/**
+ * Compare the shipped runtime set with the checked program. One direction only:
+ * a shipped file outside the program fails. Extra program files (tests/*.ts,
+ * the declaration files, fixture helpers) are expected and allowed.
+ * @param {{ runtime: string[], program: string[] }} input
+ * @returns {{ ok: boolean, missing: string[], checked: number, total: number }}
+ */
+export function evaluateCoverage({ runtime, program }) {
+  const checked = new Set(program)
+  const missing = runtime.filter((file) => !checked.has(file))
+  return { ok: missing.length === 0, missing, checked: runtime.length - missing.length, total: runtime.length }
+}
+
+/** List the project files (never node_modules) in the `tsc` program. */
+function programFiles(root) {
+  const config = path.join(root, 'tsconfig.json')
+  if (!fs.existsSync(config)) throw new Error(`no tsconfig.json under ${root}`)
+  if (!fs.existsSync(TSC_BIN)) throw new Error('typescript is not installed; run npm ci first')
+  let output
+  try {
+    output = execFileSync(process.execPath, [TSC_BIN, '--noEmit', '--listFiles', '-p', config], {
+      cwd: root,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+  } catch (error) {
+    // A program with type errors still lists its files; only a config failure
+    // (no input at all) is fatal for this gate. Keep diagnostics out of the
+    // parse by only accepting existing absolute paths.
+    output = String(error?.stdout ?? '')
+    if (!output.trim()) throw new Error(`tsc --listFiles failed: ${String(error?.stderr ?? error?.message ?? error)}`)
+  }
+  const files = new Set()
+  for (const raw of output.split('\n')) {
+    const line = raw.trim()
+    if (!line || !path.isAbsolute(line)) continue
+    if (!fs.existsSync(line)) continue
+    const relative = path.relative(root, line).split(path.sep).join('/')
+    if (!relative || relative.startsWith('..') || relative.startsWith('node_modules/')) continue
+    if (relative.includes('/node_modules/')) continue
+    files.add(relative)
+  }
+  return [...files].sort()
+}
+
+function main() {
+  const rootArg = process.argv.indexOf('--root')
+  const root = rootArg > 0 ? path.resolve(process.argv[rootArg + 1]) : SELF_ROOT
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'))
+  const shipped = expandShipped(Array.isArray(pkg.files) ? pkg.files : [], walkFiles(root))
+  const { runtime, excluded } = runtimeJavaScript(shipped)
+  let program
+  try {
+    program = programFiles(root)
+  } catch (error) {
+    console.error(`types coverage: ${String(error?.message ?? error)}`)
+    process.exit(1)
+  }
+  const result = evaluateCoverage({ runtime, program })
+  if (process.argv.includes('--json')) {
+    console.log(JSON.stringify({ ...result, program: program.length, excluded }, null, 2))
+  } else if (result.ok) {
+    console.log(
+      `types coverage: ${result.checked}/${result.total} shipped runtime .js files are in the tsc program` +
+        ` (${program.length} program files, ${excluded.length} excluded: ${[...new Set(excluded.map((entry) => entry.file.split('/')[0]))].join(', ') || 'none'})`,
+    )
+  } else {
+    console.error(
+      `types coverage: ${result.missing.length} shipped runtime .js file(s) are outside the tsc program:`,
+    )
+    for (const file of result.missing) console.error(`  - ${file}`)
+    console.error('add the file (or its directory glob) to tsconfig.json `include`')
+  }
+  process.exit(result.ok ? 0 : 1)
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (isMain) main()

package/scripts/types-strict-manifest.txt

@@ -0,0 +1,10 @@
+domain/contracts/outputs.js
+domain/contracts/tool-inputs/collaboration.js
+domain/contracts/tool-inputs/findings.js
+domain/contracts/tool-inputs/index.js
+domain/contracts/tool-inputs/integration.js
+domain/contracts/tool-inputs/missions.js
+domain/contracts/tool-inputs/ops.js
+domain/contracts/tool-inputs/shared.js
+types/cordis.d.ts
+types/index.d.ts

package/scripts/types-strict.mjs

@@ -0,0 +1,141 @@
+// Strict type ratchet (#115, step 4).
+//
+// `tsconfig.strict.json` turns `noImplicitAny: true` on for an explicit,
+// growing file list. The list is the ratchet: CI runs the strict config, and
+// this gate makes the list a reviewed artifact instead of a file that can
+// silently shrink.
+//
+// Run: node scripts/types-strict.mjs [--write] [--allow-shrink] [--root <dir>]
+//
+//   * no flag          — check: every listed file exists, every file in the
+//                        seed tier (`domain/contracts/**`) is listed, and the
+//                        reviewed snapshot (scripts/types-strict-manifest.txt)
+//                        matches the list exactly.
+//   * --write          — record the current list in the snapshot. Removing an
+//                        entry additionally needs `--allow-shrink`, so shrinking
+//                        the ratchet is a deliberate, visible decision.
+//
+// The list must stay explicit files: a glob would let a new file enter the
+// strict program without a reviewed one-line diff, which is the opposite of a
+// ratchet. `domain/contracts/**` is the seed tier: adding a file there fails
+// the check until the list and the snapshot name it.
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const SELF_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+export const MANIFEST = 'scripts/types-strict-manifest.txt'
+const SEED_DIRECTORIES = ['domain/contracts']
+
+function walk(root, relative) {
+  const dir = path.join(root, relative)
+  if (!fs.existsSync(dir)) return []
+  const out = []
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const next = `${relative}/${entry.name}`
+    if (entry.isDirectory()) out.push(...walk(root, next))
+    else out.push(next)
+  }
+  return out
+}
+
+/** Entries that are not repo-relative explicit files. @param {unknown} include */
+export function invalidEntries(include) {
+  if (!Array.isArray(include) || include.length === 0) return ['include must be a non-empty array of files']
+  const problems = []
+  for (const entry of include) {
+    if (typeof entry !== 'string' || entry.length === 0) {
+      problems.push(`${JSON.stringify(entry)} is not a non-empty path`)
+      continue
+    }
+    if (path.isAbsolute(entry) || entry.includes('\\') || entry.split('/').includes('..')) {
+      problems.push(`${entry}: use a repo-relative path with forward slashes`)
+    } else if (/[*?]/.test(entry)) {
+      problems.push(`${entry}: the strict list must name explicit files, not a glob`)
+    }
+  }
+  return problems
+}
+
+/** @param {{ include: string[], manifest: string[] }} input */
+export function compareLists({ include, manifest }) {
+  const listed = new Set(include)
+  const pinned = new Set(manifest)
+  return {
+    lost: manifest.filter((file) => !listed.has(file)).sort(),
+    grew: include.filter((file) => !pinned.has(file)).sort(),
+  }
+}
+
+/** Every seed-tier file the strict list must name. */
+function seedFiles(root) {
+  return SEED_DIRECTORIES.flatMap((directory) => walk(root, directory)).filter((file) => file.endsWith('.js')).sort()
+}
+
+function readManifest(root) {
+  const file = path.join(root, MANIFEST)
+  if (!fs.existsSync(file)) return []
+  return fs.readFileSync(file, 'utf8').split('\n').map((line) => line.trim()).filter(Boolean)
+}
+
+function fail(lines) {
+  console.error('types strict: the ratchet would shrink or drift:')
+  for (const line of lines) console.error(`  - ${line}`)
+  process.exit(1)
+}
+
+function main() {
+  const rootArg = process.argv.indexOf('--root')
+  const root = rootArg > 0 ? path.resolve(process.argv[rootArg + 1]) : SELF_ROOT
+  const write = process.argv.includes('--write')
+  const allowShrink = process.argv.includes('--allow-shrink')
+  const configFile = path.join(root, 'tsconfig.strict.json')
+
+  if (!fs.existsSync(configFile)) {
+    console.error(`types strict: ${path.relative(process.cwd(), configFile)} is missing`)
+    process.exit(1)
+  }
+  const config = JSON.parse(fs.readFileSync(configFile, 'utf8'))
+  if (config?.compilerOptions?.noImplicitAny !== true) {
+    console.error('types strict: tsconfig.strict.json must set compilerOptions.noImplicitAny: true explicitly')
+    process.exit(1)
+  }
+  const include = Array.isArray(config.include) ? config.include : []
+  const invalid = invalidEntries(include)
+  if (invalid.length > 0) fail(invalid)
+
+  const missingFiles = include.filter((file) => !fs.existsSync(path.join(root, file)))
+  if (missingFiles.length > 0) fail(missingFiles.map((file) => `${file}: listed in tsconfig.strict.json but does not exist`))
+
+  const seeds = seedFiles(root)
+  const unlistedSeeds = seeds.filter((file) => !include.includes(file))
+  if (unlistedSeeds.length > 0) {
+    fail(unlistedSeeds.map((file) => `${file}: in the seed tier but not in tsconfig.strict.json include`))
+  }
+
+  const manifest = readManifest(root)
+  const { lost, grew } = compareLists({ include, manifest })
+  if (write) {
+    if (lost.length > 0 && !allowShrink) {
+      fail([
+        ...lost.map((file) => `${file}: pinned in ${MANIFEST} but missing from tsconfig.strict.json include`),
+        'pass --allow-shrink to record a deliberate removal',
+      ])
+    }
+    fs.mkdirSync(path.join(root, 'scripts'), { recursive: true })
+    fs.writeFileSync(path.join(root, MANIFEST), `${[...include].sort().join('\n')}\n`)
+    console.log(`types strict: wrote ${include.length} files to ${MANIFEST} (${lost.length} removed, ${grew.length} added)`)
+    return
+  }
+
+  if (lost.length > 0 || grew.length > 0) {
+    fail([
+      ...lost.map((file) => `${file}: pinned in ${MANIFEST} but no longer checked (the ratchet must not shrink)`),
+      ...grew.map((file) => `${file}: newly checked but not pinned; run npm run types:strict:write to record it`),
+    ])
+  }
+  console.log(`types strict: ${include.length} files pinned, noImplicitAny over ${SEED_DIRECTORIES.join(', ')}/**`)
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (isMain) main()

package/skills.js

@@ -3,9 +3,12 @@
 // the short system-prompt sections stay authoritative for safety rules.
 import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
+import { holdComponent } from './host/capability-registry.js'
 
 export const name = 'dsh-tower/skills'
-export const inject = ['skills']
+// #121: an optional capability row still depends on the host service, so a
+// composition with the host group off cannot leave an orphan skill provider.
+export const inject = ['skills', 'tower']
 
 const ASSETS = fileURLToPath(new URL('./skills/', import.meta.url))
 
@@ -59,5 +62,9 @@ const provider = {
 }
 
 export function apply(ctx) {
+  // #121: tower-skills is an optional component row. Registering here is what
+  // lets tower_status/tower_doctor report "disabled by component tower-skills"
+  // when the row is off instead of leaving the missing catalog unexplained.
+  holdComponent(ctx, 'tower-skills')
   ctx.skills.registerProvider(() => provider)
 }

package/tools/index.js

@@ -4,7 +4,8 @@
 // - define(ctx, definition) accepts a TypeBox parameters schema;
 // - execute(args) is typed from that schema by Static<>;
 // - aliases and requiresMissionId are honored by the registry;
-// - operational switches decide whether a tool is registered;
+// - capability ownership decides whether a tool is registered; the component
+//   rows in cordis.patch.yml are the switches (#121);
 // - errors are classified to stable [tower:code] values;
 // - tools must not import node:fs or node:child_process directly.
 // 

package/tools/reload.js

@@ -1,4 +1,8 @@
 // tower_reload: dev-only HMR reload request.
+//
+// #121: this tool is the `tower-hmr` component. It is registered only by that
+// component's entry point, so the row is the switch; there is no second
+// `dev.hotReload` boolean to disagree with it.
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { TowerToolError } from '../domain/errors.js'
 import { ReloadInput } from '../domain/contracts/tool-inputs/index.js'
@@ -9,41 +13,36 @@ import { ReloadInput } from '../domain/contracts/tool-inputs/index.js'
  */
 export function registerReloadTool(ctx, deps) {
   const { define, actorFor, requireTowerActor, sharedHmrBridge, runtimeConfig, createHmrBridge } = deps
-  // Dev-only hot reload. The tool is registered whenever dev.hotReload is on;
-  // it reports reload-unavailable when the profile has no HMR service. When the
-  // Host passed a shared bridge, its status() reflects the command's reloads too.
   const dev = runtimeConfig().dev ?? {}
-  if (dev.hotReload !== false) {
-    const bridge =
-      sharedHmrBridge ??
-      createHmrBridge(ctx, {
-        requiredIds: dev.reloadRequiredIds,
-        delayMs: dev.reloadDelayMs,
-        logger: ctx.logger ?? console,
-      })
-    define(ctx, {
-      name: 'tower_reload',
-      description:
-        'Dev-only: ask DSH HMR to reconcile this profile and reload the Tower Host plugin from disk. The reload is scheduled a few milliseconds after this call returns (so the result reaches the model first). Use after editing the plugin source in a linked profile; plugin_manager install/update already triggers reconciliation by itself. Registered while dev.hotReload is on; fails with reload-unavailable when the HMR service is absent.',
-      parameters: ReloadInput,
-      output: output(SCHEMAS.reload),
-      async execute(args, exec) {
-        if (typeof args.repoRoot === 'string') {
-          const tower = await deps.openTower(args.repoRoot)
-          const actor = await actorFor(tower, exec)
-          requireTowerActor(actor, 'reload the Tower plugin')
-        }
-        if (!bridge.available) {
-          throw new TowerToolError('reload-unavailable', 'this DSH profile has no HMR service; restart DSH instead')
-        }
-        const outcome = bridge.schedule()
-        return {
-          ok: true,
-          ...outcome,
-          ...(outcome.lastError ? { error: outcome.lastError } : {}),
-          restartHint: 'If the new code does not appear, restart DSH or check the profile hmr entry.',
-        }
-      },
+  const bridge =
+    sharedHmrBridge ??
+    createHmrBridge(ctx, {
+      requiredIds: dev.reloadRequiredIds,
+      delayMs: dev.reloadDelayMs,
+      logger: ctx.logger ?? console,
     })
-  }
+  define(ctx, {
+    name: 'tower_reload',
+    description:
+      'Dev-only: ask DSH HMR to reconcile this profile and reload the Tower Host plugin from disk. Registered only while the tower-hmr component is on (the row is shipped off). The reload is scheduled a few milliseconds after this call returns (so the result reaches the model first). Use after editing the plugin source in a linked profile; plugin_manager install/update already triggers reconciliation by itself. Fails with reload-unavailable when the HMR service is absent.',
+    parameters: ReloadInput,
+    output: output(SCHEMAS.reload),
+    async execute(args, exec) {
+      if (typeof args.repoRoot === 'string') {
+        const tower = await deps.openTower(args.repoRoot)
+        const actor = await actorFor(tower, exec)
+        requireTowerActor(actor, 'reload the Tower plugin')
+      }
+      if (!bridge.available) {
+        throw new TowerToolError('reload-unavailable', 'this DSH profile has no HMR service; restart DSH instead')
+      }
+      const outcome = bridge.schedule()
+      return {
+        ok: true,
+        ...outcome,
+        ...(outcome.lastError ? { error: outcome.lastError } : {}),
+        restartHint: 'If the new code does not appear, restart DSH or check the profile hmr entry.',
+      }
+    },
+  })
 }

package/tools/status.js

@@ -13,10 +13,11 @@ import { archiveView } from '../app/archive.js'
  *   workspaceHook: any,
  *   spawnBackoffView: any,
  *   observeActivity: any,
+ *   componentReport: (ctx: any) => Promise<{ enabled: string[], disabled: Array<{ id: string, reason: string }> }>,
  * }} deps
  */
 export function registerStatusTool(ctx, deps) {
-  const { define, workspaceHook, spawnBackoffView, observeActivity } = deps
+  const { define, workspaceHook, spawnBackoffView, observeActivity, componentReport } = deps
   define(ctx, {
     name: 'tower_status',
     description:
@@ -26,6 +27,10 @@ export function registerStatusTool(ctx, deps) {
     output: output(SCHEMAS.status),
     async execute(args, exec) {
       const tower = await deps.openTower(args.repoRoot)
+      // #121: report the mounted optional components, including the exact
+      // "disabled by component <id>" reason. A capability that is off must be a
+      // visible fact of the dashboard, never a silent absence from the tools.
+      const components = await componentReport(ctx)
       const boardPath = tower.boardFile()
       const mode = workspaceHook?.modeInfo?.(exec) ?? null
       const statusState = await tower.load()
@@ -46,6 +51,7 @@ export function registerStatusTool(ctx, deps) {
           boardPath,
           mode,
           spawn,
+          components,
         }
       }
       const state = await tower.load()
@@ -90,6 +96,7 @@ export function registerStatusTool(ctx, deps) {
         boardPath,
         mode,
         spawn,
+        components,
       }
       if (isMarkdownFormat(args.format)) {
         const state = await tower.load()

package/types/index.d.ts

@@ -6,16 +6,35 @@
 // `tsc --noEmit` (checkJs). Keep this file free of value imports so consumers
 // can load it without `allowJs`.
 
+// ---------------------------------------------------------------------------
+// Generated vocabulary (#115): one declaration per runtime constant family.
+// `npm run types:generate` rewrites the marked block from ERROR_CODES,
+// MISSION_STATUSES, REVIEW_STATUSES, MERGE_VERDICTS, MISSION_KINDS,
+// REVIEW_POLICIES, FINDING_*, ROLES and PAUSE_CAUSES; the generated-types gate
+// (`npm run docs:check:generated:types`) fails when the block drifts. Do not
+// edit the block by hand.
+// generated:vocabulary:start
 export type MissionStatus = 'planned' | 'active' | 'completed' | 'blocked' | 'paused' | 'merged' | 'abandoned'
 export type MissionKind = 'build' | 'survey'
-export type ReviewStatus = 'clean' | 'p1-1items' | 'p1-2items' | 'p1-3items' | 'p1-4items' | 'p1-5items' | 'p2-1items' | 'p2-2items' | 'p2-3items' | 'p2-4items' | 'p2-5items'
+export type ReviewStatus =
+  | 'clean'
+  | 'p1-1items'
+  | 'p1-2items'
+  | 'p1-3items'
+  | 'p1-4items'
+  | 'p1-5items'
+  | 'p2-1items'
+  | 'p2-2items'
+  | 'p2-3items'
+  | 'p2-4items'
+  | 'p2-5items'
 export type MergeVerdict = 'merge' | 'fix-then-merge' | 'hold'
 export type ReviewPolicy = 'required-clean' | 'none'
 export type FindingType = 'bug' | 'improve' | 'vuln' | 'idea'
 export type FindingSeverity = 'low' | 'medium' | 'high' | 'critical'
 export type FindingStatus = 'open' | 'triaged' | 'fixed' | 'wontfix'
 export type Role = 'worker' | 'reviewer'
-
+export type PauseCause = 'user' | 'failure' | 'resource' | 'dependency'
 export type ErrorCode =
   | 'invalid-argument'
   | 'repo-invalid'
@@ -23,26 +42,22 @@ export type ErrorCode =
   | 'mission-not-found'
   | 'finding-not-found'
   | 'invalid-transition'
+  | 'stale-base'
   | 'state-locked'
   | 'state-corrupt'
+  | 'state-version-unsupported'
+  | 'state-migration-failed'
   | 'config-invalid'
   | 'config-unknown-key'
+  | 'git-failed'
   | 'git-timeout'
-  | 'merge-conflict'
-  | 'merge-hook-failed'
-  | 'merge-intent-pending'
-  | 'base-dirty'
-  | 'stale-base'
-  | 'tip-moved'
-  | 'out-of-scope'
-  | 'worker-busy'
-  | 'worker-stale'
+  | 'worktree-dirty'
   | 'spawn-unavailable'
   | 'provider-missing'
   | 'provider-cooldown'
   | 'preset-missing'
   | 'reviewer-prerequisite'
-  | 'worktree-dirty'
+  | 'not-authorized'
   | 'workspace-busy'
   | 'worker-limit'
   | 'rate-limited'
@@ -56,6 +71,7 @@ export type ErrorCode =
   | 'batch-invalid'
   | 'legacy-invalid'
   | 'tool-internal'
+// generated:vocabulary:end
 
 /** One machine-readable gate/completion blocker: a stable code plus a detail. */
 export interface Blocker {