dsh-tower 2.1.0 → 2.4.0

package/{lib → host}/tool-registry.js

@@ -14,8 +14,15 @@ import {
   isTowerRole,
   isUnknownRole,
 } from '../domain/vocabulary.js'
-import { git, resolveRepo, hasAnyCommit } from './git.js'
+import { git, resolveRepo, hasAnyCommit } from '../adapters/git.js'
 import { runtimeConfig } from './config.js'
+import { runDoctor } from './doctor.js'
+import { createHmrBridge } from './hmr.js'
+import { assertRuntimePreconditions } from './presets.js'
+import { readStateLock } from '../adapters/store.js'
+import { lockTiming } from '../adapters/persistence.js'
+import { acquireLease, releaseLease, inspectLeases } from '../adapters/leases.js'
+import { importLegacySnapshot, validateLegacyMap } from '../adapters/legacy.js'
 import { registerDoctorTool } from '../tools/doctor.js'
 import { registerRecoverTool } from '../tools/recover.js'
 import { registerTestTool } from '../tools/test.js'
@@ -43,17 +50,97 @@ import { registerSpawnTool } from '../tools/spawn.js'
 import { registerCompleteTool } from '../tools/complete.js'
 import { registerFindingTool } from '../tools/finding.js'
 import { registerFindingsTool } from '../tools/findings.js'
-import { readDiscoveryConfig, normalizeDiscovery, runDiscovery } from './tests.js'
+import { readDiscoveryConfig, normalizeDiscovery, runDiscovery } from '../adapters/tests.js'
 import { summarize as summarizeBatch } from '../domain/batch.js'
+import { assertPorts } from '../ports/index.js'
+import { COMPONENT_TOOLS, componentEnabled, componentReport, holdComponent, disabledReason } from './capability-registry.js'
 import path from 'node:path'
 import { fsp } from '../adapters/store-fs.js'
+import { createDefaultDeps } from '../adapters/default.js'
 import crypto from 'node:crypto'
 
 // Mutable composition state is grouped in one const object: the registration
 // aggregator is the composition root, not an ambient module-level binding.
+/**
+ * The workspace-lock hook the Host entry injects (`index.js`). Optional
+ * members are only present when the entry supplies them, so the registry and
+ * the tools that receive it declare the same shape.
+ * @typedef {object} WorkspaceHook
+ * @property {(repoRoot: string, exec: any, toolName: string) => Promise<void>} ensure
+ * @property {(exec: any) => string | null} [basePreference]
+ * @property {(exec: any) => Record<string, any> | null} [modeInfo]
+ * @property {(entry: any, key: string) => Promise<Record<string, any>>} [status]
+ */
+/** @type {{ workspaceHook: WorkspaceHook | null, hmrBridge: ReturnType<typeof createHmrBridge> | null, deps: Record<string, any> | null, definedTools: Set<string> }} */
 const runtimeState = {
   workspaceHook: null,
   hmrBridge: null,
+  // #69: the host entry builds the adapter set once and passes it in. The lazy
+  // fallback is for tests/embedders that call registerTowerTools() directly;
+  // it is still built once per process.
+  deps: null,
+  // #84/#118/#121: registered tool names are recorded before any component row
+  // decides whether its capability mounts, so the concept budget measures the
+  // full build surface (29 tools) rather than one profile's mounted subset (28
+  // with the shipped `tower-hmr` row off). `recordToolRegistration` is the one
+  // recorder: define() calls it for every definition, the Host entry calls it
+  // for the directly registered tower_mode/tower_control pair, and the host
+  // records the declared capability tools (COMPONENT_TOOLS) because those entry
+  // points only run when their row is on. The number is reported by
+  // tower_doctor and compared with the committed scripts/surface-baseline.json.
+  definedTools: new Set(),
+}
+
+/**
+ * Record one tool name in the concept-budget surface (#84, #118, #121).
+ *
+ * This is the single recorder for the *build* tool surface. `define()` calls it
+ * for every definition when a capability is mounted; the Host entry (`index.js`)
+ * calls it for the two tools it registers directly, `tower_mode` and
+ * `tower_control`; and `registerCoreTowerTools` records the declared capability
+ * tools up front so a row that ships off does not shrink the budget. One
+ * recorder means the count cannot silently miss a registration path again: #118
+ * found 27 of the 29 names because only the `define()` path was recorded.
+ */
+export function recordToolRegistration(name) {
+  if (typeof name !== 'string' || name.trim().length === 0) {
+    throw new TypeError('recordToolRegistration requires a non-empty tool name')
+  }
+  runtimeState.definedTools.add(name.trim())
+}
+
+/**
+ * The full shipped tool surface (names, sorted). It covers every tool this build
+ * can register, including capabilities whose component row is currently off.
+ */
+export function definedToolNames() {
+  return [...runtimeState.definedTools].sort()
+}
+
+/** The number of tools this build ships, used by the concept budget (#84). */
+export function definedToolCount() {
+  return runtimeState.definedTools.size
+}
+
+/** Test hook: the recorded set is process state and must be reset per fixture. */
+export function __testResetToolSurface() {
+  runtimeState.definedTools.clear()
+}
+
+/** The injected port set for the app layer (built once per process). */
+function towerDeps() {
+  if (!runtimeState.deps) runtimeState.deps = createDefaultDeps()
+  return runtimeState.deps
+}
+
+/** Compose the app Tower with the injected ports (never a bare adapter import). */
+function openTower(repoRoot) {
+  return Tower.open(repoRoot, towerDeps())
+}
+
+/** Build a Tower with an explicit config for the read-only doctor path. */
+function createTower(repo, config) {
+  return new Tower(repo, config, towerDeps())
 }
 
 function normalizeToolArgs(args, aliases = {}) {
@@ -291,15 +378,7 @@ async function ensureRepository(repoRootInput, autoGitInit) {
   }
 }
 
-const OPERATIONAL_TOOLS = new Map([
-  ['tower_batch', 'exposeBatch'],
-  ['tower_resource', 'exposeLeases'],
-  ['tower_import_legacy', 'exposeImport'],
-  ['tower_legacy_map', 'exposeImport'],
-  ['tower_recover', 'exposeRecovery'],
-  ['tower_test', 'exposeTests'],
-  ['tower_doctor', 'exposeDoctor'],
-])
+const OPERATIONAL_TOOLS = new Map()
 
 function plainSchema(value) {
   return JSON.parse(JSON.stringify(value))
@@ -324,9 +403,10 @@ function plainSchema(value) {
  */
 function define(ctx, definition) {
   const { aliases, requiresMissionId, board, execute, ...rest } = definition
-  const toolsConfig = runtimeConfig().tools ?? {}
-  const flag = OPERATIONAL_TOOLS.get(rest.name)
-  if (flag && (toolsConfig.exposeOperational === false || toolsConfig[flag] === false)) return
+  // Record the definition for the concept budget. The capability that owns the
+  // tool decides whether it is registered at all (#121): the component row is
+  // the switch, so `define()` no longer consults a `tools.expose*` boolean.
+  recordToolRegistration(rest.name)
   ctx.effect(() =>
     ctx.tools.register({
       ...rest,
@@ -364,7 +444,7 @@ function define(ctx, definition) {
         }
         if (board === true && typeof normalized.repoRoot === 'string') {
           try {
-            const opened = await Tower.open(normalized.repoRoot)
+            const opened = await openTower(normalized.repoRoot)
             await opened.writeBoard()
           } catch {
             // board output is best effort
@@ -386,6 +466,12 @@ function textOf(blocks) {
 /** Read `package.json tower.testDiscovery` and run it for one mission worktree.
  * Returns `{configured:false}` when the repository has no discovery block. */
 async function runMissionDiscovery(tower, mission) {
+  // #121: test discovery is the tower-tests component. With the row off there is
+  // no tower_test tool and no receipt; never execute repository code silently
+  // because a config key still says admission complete/spawn.
+  if (!componentEnabled('tower-tests')) {
+    return { configured: false, disabledBy: 'tower-tests', reason: disabledReason('tower-tests') }
+  }
   const testsConfig = tower.config.tests ?? {}
   if (testsConfig.enabled === false || testsConfig.allowPackageDiscovery === false) {
     return { configured: false }
@@ -448,9 +534,47 @@ async function observeActivity(ctx, tower) {
   return { activity, parentStatus }
 }
 
-export function registerTowerTools(ctx, options = {}) {
+/**
+ * Register the mandatory Tower host surface (#121).
+ *
+ * The host owns planning, mode integration, the health contract
+ * (`tower_doctor`) and the recovery escape (`tower_recover`); neither is a
+ * component and neither can be switched off. The optional capabilities
+ * (batch/import/leases/tests/reload) are registered by their own entry points
+ * (`registerBatchCapability`, ...), so switching a component row off removes
+ * exactly that capability while the host keeps working.
+ */
+export function registerCoreTowerTools(ctx, options = {}) {
   runtimeState.workspaceHook = options.workspace ?? null
   runtimeState.hmrBridge = options.hmrBridge ?? null
+  // #121/#122: capability tools are part of this build even while their
+  // component row is off. A row's entry point only runs when the row is on, so
+  // record the declared capability names here — before any row gates
+  // registration — and the concept budget reports the full 29-tool build
+  // surface in every profile. `componentReport` is what names the subset that
+  // is actually mounted; this count never shrinks because a user switched a
+  // component off.
+  for (const toolIds of Object.values(COMPONENT_TOOLS)) {
+    for (const toolId of toolIds) recordToolRegistration(toolId)
+  }
+  // #69: the host entry (index.js) is the composition root. When it supplies the
+  // port set, adopt it — validated once — instead of constructing a second set
+  // here. Tests/embedders that omit deps fall back to one lazily built set.
+  // #75: the event port is bound here to the live Cordis emitter; emitting is
+  // best effort so a listener can never fail the tool that produced the fact.
+  const baseDeps = options.deps ? assertPorts(options.deps) : (runtimeState.deps ?? createDefaultDeps())
+  runtimeState.deps = {
+    ...baseDeps,
+    events: {
+      emit(name, payload) {
+        try {
+          ctx.emit?.(name, payload)
+        } catch {
+          // events are an optional side channel; never fail a tool for them
+        }
+      },
+    },
+  }
   // A lightweight roster watchdog: the authoritative activity comes from the
   // subagents catalog; a missing observation after spawn.staleMs is marked
   // stale (never silently treated as stopped) and blocks merge via the gate.
@@ -460,7 +584,7 @@ export function registerTowerTools(ctx, options = {}) {
       try {
         if (!ctx.get('subagents')) return
         for (const repoRoot of [...WATCHED_REPOS]) {
-          const tower = await Tower.open(repoRoot)
+          const tower = await openTower(repoRoot)
           const view = await tower.rosterView()
           const live = view.roster.filter((entry) => !ROSTER_INACTIVE_STATES.includes(entry.state))
           if (live.length === 0) { WATCHED_REPOS.delete(repoRoot); continue }
@@ -481,59 +605,126 @@ export function registerTowerTools(ctx, options = {}) {
   }, watchMs)
   timer.unref?.()
   ctx.effect(() => () => clearInterval(timer))
-  registerInitTool(ctx, { define, actorFor, requireTowerActor, workspaceHook: runtimeState.workspaceHook, ensureRepository })
+  registerInitTool(ctx, { openTower, define, actorFor, requireTowerActor, workspaceHook: runtimeState.workspaceHook, ensureRepository, resolveRepo, runtimeConfig })
+
+  // #121: planning validates the mounted component rows as well as the presets,
+  // so a review gate without its reviewer row is refused before work starts.
+  registerPlanTool(ctx, { openTower, define, actorFor, requireTowerActor, assertPresetsAvailable: assertRuntimePreconditions })
 
-  registerPlanTool(ctx, { define, actorFor, requireTowerActor })
+  registerMissionTool(ctx, { openTower, define, actorFor, requireKnownActor })
 
-  registerMissionTool(ctx, { define, actorFor, requireKnownActor })
+  registerStatusTool(ctx, { openTower, define, workspaceHook: runtimeState.workspaceHook, spawnBackoffView, observeActivity, componentReport })
 
-  registerStatusTool(ctx, { define, workspaceHook: runtimeState.workspaceHook, spawnBackoffView, observeActivity })
+  registerSpawnTool(ctx, { openTower, define, actorFor, requireTowerActor, enqueueSpawn, observeActivity, spawnBackoffState, recordSpawnThrottle, recordSpawnSuccess, runMissionDiscovery, textOf, inspectLeases })
 
-  registerSpawnTool(ctx, { define, actorFor, requireTowerActor, enqueueSpawn, observeActivity, spawnBackoffState, spawnBackoffView, recordSpawnThrottle, recordSpawnSuccess, runMissionDiscovery, textOf })
+  registerRosterTool(ctx, { openTower, define })
 
-  registerRosterTool(ctx, { define, workspaceHook: runtimeState.workspaceHook, observeActivity, actorFor, requireTowerActor, interruptRosterAgent })
+  registerInterruptTool(ctx, { openTower, define, actorFor, requireTowerActor, interruptRosterAgent })
 
-  registerInterruptTool(ctx, { define, actorFor, requireTowerActor, interruptRosterAgent })
+  registerDiffTool(ctx, { openTower, define })
 
-  registerDiffTool(ctx, { define, actorFor, requireTowerActor })
+  registerAdoptTool(ctx, { openTower, define, actorFor, requireTowerActor })
 
-  registerAdoptTool(ctx, { define, actorFor, requireTowerActor })
+  registerSendTool(ctx, { openTower, define, actorFor, checkSendRate })
 
-  registerSendTool(ctx, { define, actorFor, checkSendRate })
+  registerInboxTool(ctx, { openTower, define })
 
-  registerInboxTool(ctx, { define })
+  registerCompleteTool(ctx, { openTower, define, runMissionDiscovery })
 
-  registerCompleteTool(ctx, { define, runMissionDiscovery })
+  registerFindingTool(ctx, { openTower, define, actorFor, requireKnownActor })
 
-  registerFindingTool(ctx, { define, actorFor, requireKnownActor })
+  registerFindingsTool(ctx, { openTower, define, actorFor, requireKnownActor })
 
-  registerFindingsTool(ctx, { define, actorFor, requireKnownActor })
+  registerReviewTool(ctx, { openTower, define, actorFor })
 
-  registerReviewTool(ctx, { define, actorFor })
+  registerPreflightTool(ctx, { openTower, define, observeActivity })
 
-  registerPreflightTool(ctx, { define, observeActivity })
+  registerMergeTool(ctx, { openTower, define, actorFor, requireTowerActor, observeActivity })
 
-  registerMergeTool(ctx, { define, actorFor, requireTowerActor, observeActivity })
+  registerRebaseTool(ctx, { openTower, define, actorFor, requireTowerActor, observeActivity })
 
-  registerRebaseTool(ctx, { define, actorFor, requireTowerActor, observeActivity })
+  registerTeardownTool(ctx, { openTower, define, actorFor, requireTowerActor, observeActivity })
 
-  registerTeardownTool(ctx, { define, actorFor, requireTowerActor, observeActivity })
+  registerDoctorTool(ctx, {
+    openTower,
+    define,
+    createTower,
+    resolveRepo,
+    runtimeConfig,
+    runDoctor,
+    // #84/#122: the doctor reports the full registered surface. It is always
+    // registered itself, and it is the reporter that names a disabled component.
+    surface: () => ({ tools: definedToolCount() }),
+  })
 
-  registerDoctorTool(ctx, define)
+  // #122: the recovery escape is registered for every configuration. The lock it
+  // repairs can be left behind by any crashed mutation, so an off state would be
+  // worse than uninstalling the plugin.
+  registerRecoverTool(ctx, { openTower, define, actorFor, requireTowerActor, readStateLock, lockTiming })
+}
 
-  registerRecoverTool(ctx, { define, actorFor, requireTowerActor })
+/** Evidence batches — the `tower-batch` component. */
+export function registerBatchCapability(ctx) {
+  registerBatchTool(ctx, { openTower, define, actorFor, requireTowerActor, summarizeBatch, verifyBatchReceiptFiles })
+}
 
-  registerTestTool(ctx, { define, actorFor, requireKnownActor, runMissionDiscovery })
+/** Advisory leases — the `tower-leases` component. */
+export function registerLeasesCapability(ctx) {
+  registerResourceTool(ctx, { openTower, define, actorFor, requireTowerActor, acquireLease, releaseLease, inspectLeases })
+}
 
-  registerBatchTool(ctx, { define, actorFor, requireTowerActor, summarizeBatch, verifyBatchReceiptFiles })
+/** Legacy import and its audit map — the `tower-import` component. */
+export function registerImportCapability(ctx) {
+  registerImportLegacyTool(ctx, { openTower, define, actorFor, requireTowerActor, importLegacySnapshot })
+  registerLegacyMapTool(ctx, { openTower, define, actorFor, requireTowerActor, validateLegacyMap })
+}
 
-  registerResourceTool(ctx, { define, actorFor, requireTowerActor })
+/** Declared test discovery — the `tower-tests` component. */
+export function registerTestsCapability(ctx) {
+  registerTestTool(ctx, { openTower, define, actorFor, requireKnownActor, runMissionDiscovery })
+}
 
-  registerImportLegacyTool(ctx, { define, actorFor, requireTowerActor })
+/**
+ * Dev hot reload — the `tower-hmr` component (shipped off).
+ * The returned bridge is the one `/tower reload` and `tower_mode` report.
+ */
+export function registerHmrCapability(ctx, options = {}) {
+  const dev = runtimeConfig().dev ?? {}
+  const bridge =
+    options.bridge ??
+    runtimeState.hmrBridge ??
+    createHmrBridge(ctx, {
+      requiredIds: dev.reloadRequiredIds,
+      delayMs: dev.reloadDelayMs,
+      logger: ctx.logger ?? console,
+    })
+  registerReloadTool(ctx, { openTower, define, actorFor, requireTowerActor, sharedHmrBridge: bridge, runtimeConfig, createHmrBridge })
+  return bridge
+}
 
-  registerLegacyMapTool(ctx, { define, actorFor, requireTowerActor })
+/**
+ * Register every optional capability in-process. This is the aggregate used by
+ * tests and embedders; the shipped profile mounts the capability rows instead,
+ * so one row can be off without removing the rest.
+ */
+export function registerAllCapabilities(ctx, options = {}) {
+  for (const id of ['tower-batch', 'tower-import', 'tower-leases', 'tower-tests', 'tower-hmr']) holdComponent(ctx, id)
+  registerBatchCapability(ctx)
+  registerImportCapability(ctx)
+  registerLeasesCapability(ctx)
+  registerTestsCapability(ctx)
+  registerHmrCapability(ctx, options)
+}
 
-  registerReloadTool(ctx, { define, actorFor, requireTowerActor, sharedHmrBridge: runtimeState.hmrBridge })
+/**
+ * Backwards-compatible aggregate: the mandatory host surface plus every
+ * optional capability. Tests and embedders call this; the shipped composition
+ * calls `registerCoreTowerTools` and lets the component rows register their own
+ * capability.
+ */
+export function registerTowerTools(ctx, options = {}) {
+  registerCoreTowerTools(ctx, options)
+  registerAllCapabilities(ctx, options)
 }
 
 export const __testSpawnBackoff = {

package/host/tower.js

@@ -0,0 +1,32 @@
+// Default-deps binding of the Tower app service (#69).
+//
+// The composition root (index.js / host/tool-registry.js) builds one deps object
+// and injects it into the app layer. This module is the convenience binding for
+// embedders and tests that want the process-default adapters; it is the only
+// host/ module besides tool-registry.js that knows the default adapter set.
+//
+// Object layout supplied here is memoised in adapters/default.js, so every
+// caller shares the same adapter instances.
+import { Tower as InjectedTower } from '../app/tower.js'
+import { defaultDeps } from '../adapters/default.js'
+
+export class Tower extends InjectedTower {
+  /**
+   * @param {{ root: string, commonDir: string, branch?: string | null }} repo
+   * @param {import('../types/index.js').TowerConfig} [config]
+   * @param {Record<string, any>} [deps]
+   */
+  constructor(repo, config, deps = defaultDeps) {
+    super(repo, config, deps)
+  }
+
+  /**
+   * @param {string} repoRoot
+   * @param {Record<string, any>} [deps]
+   */
+  static async open(repoRoot, deps = defaultDeps) {
+    const repo = await deps.vcs.resolveRepo(repoRoot)
+    const config = await deps.config.resolveRepoConfig(repo)
+    return new Tower(repo, config, deps)
+  }
+}

package/index.js

@@ -12,21 +12,22 @@
 // plugin from disk when the HMR service is present (dev/linked installs).
 import fs from 'node:fs'
 import { randomUUID } from 'node:crypto'
-import { registerTowerTools } from './lib/tool-registry.js'
-import { loadModes, saveModes, storePath } from './lib/modeStore.js'
-import { ModeState } from './lib/modeState.js'
-import { Config as ConfigSchema, DEFAULT_DENY_TOOLS, configureRuntime, runtimeConfig } from './lib/config.js'
+import { registerCoreTowerTools, recordToolRegistration } from './host/tool-registry.js'
+import { createDefaultDeps } from './adapters/default.js'
+import { loadModes, saveModes, storePath } from './host/modeStore.js'
+import { ModeState } from './host/modeState.js'
+import { Config as ConfigSchema, DEFAULT_DENY_TOOLS, configureRuntime, runtimeConfig } from './host/config.js'
 import { TowerToolError } from './domain/errors.js'
-import { resolveRepo } from './lib/git.js'
+import { resolveRepo } from './adapters/git.js'
 import {
   acquireWorkspaceLock,
   inspectWorkspaceLock,
   releaseWorkspaceLock,
   touchWorkspaceLock,
   workspaceLockToken,
-} from './lib/workspaceLock.js'
-import { createHmrBridge } from './lib/hmr.js'
-import { assertPresetsAvailable } from './lib/presets.js'
+} from './adapters/workspaceLock.js'
+import { assertRuntimePreconditions } from './host/presets.js'
+import { currentHmrBridge } from './host/capability-registry.js'
 
 export const name = 'dsh-tower'
 export const inject = ['tools', 'systemPrompt']
@@ -255,14 +256,6 @@ export function apply(ctx, rawConfig) {
   modeState.replace(loadModes(config.mode.storePath || undefined))
   if (typeof ctx.provide === 'function') ctx.provide('tower', modeState)
   denyTools = new Set(config.mode.denyTools)
-  const hotReloadEnabled = config.dev?.hotReload !== false
-  const hmrBridge = hotReloadEnabled
-    ? createHmrBridge(ctx, {
-        requiredIds: config.dev?.reloadRequiredIds,
-        delayMs: config.dev?.reloadDelayMs,
-        logger: ctx.logger ?? console,
-      })
-    : null
 
   const workspace = {
     /** Lazily acquire the advisory workspace lock on the first repo-scoped tool. */
@@ -343,12 +336,26 @@ export function apply(ctx, rawConfig) {
     },
   }
 
-  registerTowerTools(ctx, { workspace, hmrBridge })
+  // #69: the host entry is the composition root — the adapters are constructed
+  // once here and injected into the tool layer and every Tower instance.
+  // #121: only the mandatory host surface is registered here. The optional
+  // capability rows (batch/import/leases/tests/hmr) are separate loader entries
+  // and register their own tools, so a disabled row removes exactly one
+  // capability.
+  registerCoreTowerTools(ctx, { workspace, deps: createDefaultDeps() })
+
+  // #118/#121: tower_mode/tower_control are registered directly here instead of
+  // through define(), so record them through the same recorder the registry
+  // uses. tower_control is recorded before the allowAgentControl gate: the
+  // concept budget measures the surface this build can register, not only the
+  // tools one profile exposes (#84). Together with the capability-tool names the
+  // registry records before row gating, these are the shipped 29.
+  recordToolRegistration('tower_mode')
+  recordToolRegistration('tower_control')
 
   // On dispose (including an HMR reload) release advisory workspace locks this
   // process still owns; a reloaded plugin restores the entries from modes.json.
   ctx.effect(() => () => {
-    if (hmrBridge) hmrBridge.dispose?.()
     for (const entry of modeState.values()) {
       if (entry?.lock) {
         releaseWorkspaceLock(entry.lock.commonDir, { token: entry.lock.token }).catch(() => {})
@@ -448,7 +455,12 @@ export function apply(ctx, rawConfig) {
           deniedWhileActive: [...denyTools],
           persistedAt: storePath(config.mode.storePath || undefined),
           pluginVersion: readPluginVersion(),
-          hotReload: hmrBridge ? hmrBridge.status() : { available: false, disabled: true },
+          hotReload: (() => {
+            // #121/#122: the tower-hmr component row owns the bridge. When the
+            // row is off the capability is reported, never silently absent.
+            const bridge = currentHmrBridge()
+            return bridge ? bridge.status() : { available: false, disabled: true, component: 'tower-hmr' }
+          })(),
           planMode: (() => {
             const state = planModeState(ctx, exec.agent)
             return { available: state.available, active: state.active, pending: state.pending }
@@ -504,7 +516,7 @@ export function apply(ctx, rawConfig) {
           }
           const reason = args.reason.trim()
           if (args.action === 'enter' && !modeOn(key)) {
-            await assertPresetsAvailable(ctx, config)
+            await assertRuntimePreconditions(ctx, config)
           }
           const outcome =
             args.action === 'enter'
@@ -555,20 +567,23 @@ export function apply(ctx, rawConfig) {
         }
         const parsed = parseTowerInput(rawInput)
         if (parsed.action === 'reload') {
-          if (!hotReloadEnabled) {
-            return { kind: 'error', text: 'Tower reload is disabled by dev.hotReload:false; restart DSH instead.' }
+          // #121: /tower reload is the tower-hmr component. The row is shipped
+          // off, so the error names the component instead of an invisible key.
+          const bridge = currentHmrBridge()
+          if (!bridge) {
+            return { kind: 'error', text: 'Tower reload is disabled by component tower-hmr; enable the tower-hmr row in the plugin page and restart DSH.' }
           }
-          if (!hmrBridge || !hmrBridge.available) {
+          if (!bridge.available) {
             return { kind: 'error', text: 'Tower reload is unavailable: this DSH profile has no HMR service. Restart DSH instead.' }
           }
-          const outcome = hmrBridge.schedule()
+          const outcome = bridge.schedule()
           return {
             kind: 'success',
             text: `Tower reload scheduled in ${outcome.delayMs}ms (required entries: ${outcome.requiredIds.join(', ')}). If the new code does not appear, restart DSH.`,
           }
         }
         const { active, message } = parsed
-        if (active) await assertPresetsAvailable(ctx, config)
+        if (active) await assertRuntimePreconditions(ctx, config)
         const outcome = active
           ? enterMode(ctx, key, agent, 'user', message || null)
           : await exitMode(key, 'user', message || null)

package/locale/en.json

@@ -4,25 +4,45 @@
     "description": "Mission planning, isolated worktrees, worker/reviewer agents, and review-gated merges."
   },
   "components": {
-    "tower-bundle": {
-      "title": "Tower",
-      "summary": "Mission planning, isolated worktrees, worker/reviewer agents, and merge gates.",
-      "disables": "Turns off the whole Tower bundle; no orphan preset or skill is left behind."
+    "tower": {
+      "title": "Tower host",
+      "summary": "Mission planning, worktree isolation, the mode guard, the health contract and the recovery escape.",
+      "disables": "Turns off the mandatory host; this equals uninstalling Tower: no tools, presets or skills remain."
     },
     "tower-skills": {
       "title": "Tower skills",
       "summary": "Playbooks for worker/reviewer agents and recovery after a blocked merge.",
-      "disables": "Internal section; toggled with the Tower bundle."
+      "disables": "The three Tower skills leave the catalog; the worker/reviewer protocol sections and every mission tool keep working."
     },
-    "preset-tower-worker": {
-      "title": "Tower worker",
-      "summary": "Writes code, runs verification, and commits only the files assigned to its mission.",
-      "disables": "Internal section; a missing preset is rejected before planning/mode entry."
+    "tower-batch": {
+      "title": "Evidence batches",
+      "summary": "Group missions into finite evidence batches and close them against required checks and receipts.",
+      "disables": "tower_batch is not registered; missions, gates and merges are unaffected."
+    },
+    "tower-import": {
+      "title": "Legacy import",
+      "summary": "Import a Tower Codex legacy state file and audit its snapshot-to-mission mapping.",
+      "disables": "tower_import_legacy and tower_legacy_map are not registered; new state is unaffected."
+    },
+    "tower-leases": {
+      "title": "Advisory leases",
+      "summary": "Coordinate heavy per-repository work with advisory resource leases.",
+      "disables": "tower_resource is not registered; nothing else depends on a lease."
+    },
+    "tower-tests": {
+      "title": "Test discovery",
+      "summary": "Run the worktree's declared test discovery and record a receipt for the mission tip.",
+      "disables": "tower_test is not registered and no receipt can be recorded; with gates.requireTests:true planning/mode entry is rejected with an explanation."
+    },
+    "tower-hmr": {
+      "title": "Dev hot reload",
+      "summary": "Register tower_reload and /tower reload for linked-profile development.",
+      "disables": "tower_reload and /tower reload are unavailable; a non-HMR profile behaves exactly as before. Shipped off."
     },
     "preset-tower-reviewer": {
       "title": "Tower reviewer",
-      "summary": "Read-only checks for scope and acceptance, returning a clean verdict or findings.",
-      "disables": "Internal section; a missing preset is rejected before planning/mode entry when review is required."
+      "summary": "Read-only independent review: inspect the mission diff, verify scope and acceptance, return a verdict.",
+      "disables": "The reviewer cannot be dispatched. Supported while review.requireReview is false; with the gate on planning/mode entry is locked with an explanatory error."
     }
   }
 }