dsh-tower 2.3.0 → 2.4.1

package/scripts/generate-types.mjs

@@ -0,0 +1,127 @@
+// Generate the published type vocabulary from the runtime constants (#115).
+//
+// `types/index.d.ts` is the shipped type surface (`package.json` `types`). Its
+// status/type/role/error unions used to be a hand-copied second declaration of
+// constants that live in domain/; this generator makes the runtime the single
+// source: the marked block is rewritten from ERROR_CODES, MISSION_STATUSES,
+// REVIEW_STATUSES, MERGE_VERDICTS, MISSION_KINDS, REVIEW_POLICIES, FINDING_*,
+// ROLES and PAUSE_CAUSES. It is the type-surface sibling of the four
+// `docs:generate:*` generators and shares their `--check` contract.
+//
+// Usage: node scripts/generate-types.mjs [--check]
+//
+// The block is delimited by `// generated:vocabulary:start` / `:end` in
+// types/index.d.ts; the prose around it is hand-written. A missing marker is a
+// configuration error, not a silent no-op.
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { ERROR_CODES } from '../domain/errors.js'
+import {
+  FINDING_SEVERITIES,
+  FINDING_STATUSES,
+  FINDING_TYPES,
+  MERGE_VERDICTS,
+  MISSION_STATUSES,
+  PAUSE_CAUSES,
+  REVIEW_STATUSES,
+} from '../domain/mission.js'
+import { MISSION_KINDS, REVIEW_POLICIES, ROLES } from '../domain/vocabulary.js'
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const TARGET = path.join(root, 'types', 'index.d.ts')
+export const START = '// generated:vocabulary:start'
+export const END = '// generated:vocabulary:end'
+
+/** One published alias per runtime constant family, in declaration order. */
+const DECLARATIONS = [
+  { key: 'missionStatuses', name: 'MissionStatus' },
+  { key: 'missionKinds', name: 'MissionKind' },
+  { key: 'reviewStatuses', name: 'ReviewStatus', multiline: true },
+  { key: 'mergeVerdicts', name: 'MergeVerdict' },
+  { key: 'reviewPolicies', name: 'ReviewPolicy' },
+  { key: 'findingTypes', name: 'FindingType' },
+  { key: 'findingSeverities', name: 'FindingSeverity' },
+  { key: 'findingStatuses', name: 'FindingStatus' },
+  { key: 'roles', name: 'Role' },
+  { key: 'pauseCauses', name: 'PauseCause' },
+  { key: 'errorCodes', name: 'ErrorCode', multiline: true },
+]
+
+/** The runtime data the block is generated from. `--check` compares this exact input. */
+export function vocabularyData() {
+  return {
+    missionStatuses: [...MISSION_STATUSES],
+    missionKinds: [...MISSION_KINDS],
+    reviewStatuses: [...REVIEW_STATUSES],
+    mergeVerdicts: [...MERGE_VERDICTS],
+    reviewPolicies: [...REVIEW_POLICIES],
+    findingTypes: [...FINDING_TYPES],
+    findingSeverities: [...FINDING_SEVERITIES],
+    findingStatuses: [...FINDING_STATUSES],
+    roles: [...ROLES],
+    pauseCauses: [...PAUSE_CAUSES],
+    errorCodes: Object.keys(ERROR_CODES),
+  }
+}
+
+function renderDeclaration({ name, values, multiline = false }) {
+  const quoted = values.map((value) => `'${String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`)
+  const inline = `export type ${name} = ${quoted.join(' | ')}`
+  if (!multiline && inline.length <= 120) return inline
+  return [`export type ${name} =`, ...quoted.map((value) => `  | ${value}`)].join('\n')
+}
+
+/**
+ * Render the marked block (markers excluded) for one vocabulary input.
+ * @param {Record<string, string[]>} data
+ * @returns {string}
+ */
+export function vocabularyBlock(data) {
+  return DECLARATIONS.map((declaration) =>
+    renderDeclaration({ ...declaration, values: data[declaration.key] }),
+  ).join('\n')
+}
+
+/**
+ * Replace the marked block in a declaration file. Removing or reordering the
+ * markers is a hard error: a generated block that cannot be found would
+ * otherwise pass every check while drifting.
+ * @param {string} source
+ * @param {string} block
+ * @returns {string}
+ */
+export function injectVocabulary(source, block) {
+  const start = source.indexOf(START)
+  const end = source.indexOf(END)
+  if (start === -1 || end === -1 || end < start) {
+    throw new Error(`types/index.d.ts is missing the ${START} / ${END} markers`)
+  }
+  return `${source.slice(0, start + START.length)}\n${block}\n${source.slice(end)}`
+}
+
+function main() {
+  const source = fs.readFileSync(TARGET, 'utf8')
+  const expected = injectVocabulary(source, vocabularyBlock(vocabularyData()))
+  const codes = Object.keys(ERROR_CODES).length
+  if (process.argv.includes('--check')) {
+    if (source !== expected) {
+      console.error('published type vocabulary is stale; run npm run types:generate')
+      process.exit(1)
+    }
+    console.log(`type vocabulary: ${DECLARATIONS.length} aliases (${codes} error codes) in sync`)
+  } else {
+    fs.writeFileSync(TARGET, expected)
+    console.log(`wrote ${path.relative(root, TARGET)} (${DECLARATIONS.length} aliases, ${codes} error codes)`)
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (isMain) {
+  try {
+    main()
+  } catch (error) {
+    console.error(`type vocabulary: ${String(error?.message ?? error)}`)
+    process.exit(1)
+  }
+}

package/scripts/lib/tool-surface.mjs

@@ -0,0 +1,85 @@
+// The shipped tool surface, derived from the Host entry (#118).
+//
+// `scripts/surface-baseline.mjs` and `scripts/generate-tools-reference.mjs` must
+// measure the tools the plugin actually registers — including `tower_mode` and
+// `tower_control`, which `index.js` registers directly instead of through the
+// `define()` path. Loading the real `apply()` with a minimal Cordis context
+// means the measurement cannot drift from the shipped surface again.
+import os from 'node:os'
+import path from 'node:path'
+import { apply } from '../../index.js'
+import { definedToolNames, registerAllCapabilities, __testResetToolSurface } from '../../host/tool-registry.js'
+
+/**
+ * Apply the real Host entry against a recording mock context.
+ *
+ * @returns {{
+ *   names: string[],
+ *   definitions: Map<string, any>,
+ *   dispose: () => void,
+ * }}
+ *   `names` is the recorded surface (the same source `tower_doctor` reads);
+ *   `definitions` is every tool the default profile actually registered.
+ */
+export function loadShippedToolSurface() {
+  const definitions = new Map()
+  const disposers = []
+  const ctx = {
+    effect(fn) {
+      const dispose = fn()
+      if (typeof dispose === 'function') disposers.push(dispose)
+      return () => {}
+    },
+    get() {
+      return undefined
+    },
+    provide() {},
+    inject(_deps, callback) {
+      callback(ctx)
+    },
+    on() {
+      return () => {}
+    },
+    logger: { warn() {} },
+    tools: {
+      register(definition) {
+        if (definition && typeof definition.name === 'string') definitions.set(definition.name, definition)
+        return () => {}
+      },
+      guard() {
+        return () => {}
+      },
+      restrict() {
+        return () => {}
+      },
+    },
+    systemPrompt: { section() {} },
+    commands: {
+      register() {
+        return () => {}
+      },
+    },
+  }
+  // Keep the mode store out of the operator's real $DSH_HOME. The path is only
+  // read (a missing modes.json is an empty mode set); nothing is written.
+  // #121: the host entry registers only the mandatory surface; the shipped
+  // profile mounts the optional capability rows. The concept budget measures the
+  // *build* surface, so the all-capabilities aggregate is applied on top.
+  __testResetToolSurface()
+  apply(ctx, { mode: { storePath: path.join(os.tmpdir(), 'dsh-tower-surface-check') } })
+  registerAllCapabilities(ctx)
+  const names = definedToolNames()
+  return {
+    names,
+    definitions,
+    dispose() {
+      for (const dispose of disposers.reverse()) {
+        try {
+          dispose()
+        } catch {
+          // a recorder fixture must still exit when a disposer fails
+        }
+      }
+    },
+  }
+}

package/scripts/mount-smoke/fixtures.mjs

@@ -67,19 +67,19 @@ const fixtures = [
   },
   {
     name: 'dropped-skills-section',
-    what: 'the tower-skills row is removed from the bundle patch',
+    what: 'the optional tower-skills row is removed from the bundle patch',
     seed(root) {
       const file = path.join(root, 'cordis.patch.yml')
       const text = fs.readFileSync(file, 'utf8')
       const next = replaceOnce(
         text,
-        /\n {8}- id: tower-skills\n {10}name: 'dsh-tower\/skills'/,
+        /\n {4}- id: tower-skills\n {6}name: 'dsh-tower\/skills'/,
         '',
         'cordis.patch.yml tower-skills row',
       )
       fs.writeFileSync(file, next)
     },
-    expect: ['skill: missing tower-worker-protocol', 'bundle: tower-bundle is missing child tower-skills'],
+    expect: ['skill: missing tower-worker-protocol', 'bundle: missing optional top-level row tower-skills'],
   },
 ]
 

package/scripts/mount-smoke/surface.mjs

@@ -1,4 +1,4 @@
-// The expected loaded surface of the dsh-tower bundle (#95).
+// The expected loaded surface of the dsh-tower bundle (#95, #121).
 //
 // Pure derivation and comparison only: the mount smoke boots a throwaway
 // profile, and these helpers turn the checked-in source of truth into the ids
@@ -7,17 +7,53 @@
 //
 // The oracle is deliberately source-derived where the source is unambiguous:
 // one tool id per tool module, one skill id per bundled skill file. The bundle
-// children and presets come from `cordis.patch.yml` and are stated here as the
-// contract the #66 invariant protects.
+// rows and presets come from `cordis.patch.yml` and are stated here as the
+// contract the component policy protects: one mandatory host group plus
+// individually switchable optional top-level rows (#121). Tools owned by a row
+// that ships off (today only `tower-hmr` -> `tower_reload`) are trimmed from the
+// expected surface using the same ownership table the runtime reports, so the
+// shipped default profile (28 tools) and the all-rows-on build surface (29)
+// cannot be confused again.
+
+import { COMPONENT_TOOLS } from '../../host/capability-registry.js'
 
 /** Tools registered by index.js rather than by a handler module under tools/. */
 export const INDEX_TOOL_IDS = ['tower_control', 'tower_mode']
 
-/** The single top-level row the bundle is allowed to contribute (#66). */
-export const BUNDLE_ID = 'tower-bundle'
+/** The mandatory host group row: off equals uninstalling. */
+export const BUNDLE_ID = 'tower'
 
 /** Rows that must stay nested inside {@link BUNDLE_ID}. */
-export const BUNDLE_CHILD_IDS = ['preset-tower-reviewer', 'preset-tower-worker', 'tower', 'tower-skills']
+export const BUNDLE_CHILD_IDS = ['preset-tower-worker', 'tower-host']
+
+/** The optional capability rows that sit at the top level beside the host. */
+export const OPTIONAL_ROW_IDS = [
+  'preset-tower-reviewer',
+  'tower-batch',
+  'tower-hmr',
+  'tower-import',
+  'tower-leases',
+  'tower-skills',
+  'tower-tests',
+]
+
+/** Rows shipped off: the mount smoke must not expect them to be active. */
+export const DEFAULT_OFF_ROW_IDS = ['tower-hmr']
+
+/**
+ * Tool ids owned by the rows in {@link DEFAULT_OFF_ROW_IDS}. The ownership table
+ * is the one `host/capability-registry.js` uses to report a disabled component,
+ * so the oracle cannot drift from the runtime: turning a row's default off in
+ * `cordis.patch.yml` automatically removes its tools from the expected surface.
+ * @returns {Set<string>} the tool ids a default profile does not register.
+ */
+export function defaultOffToolIds() {
+  const ids = new Set()
+  for (const rowId of DEFAULT_OFF_ROW_IDS) {
+    for (const toolId of COMPONENT_TOOLS[rowId] ?? []) ids.add(toolId)
+  }
+  return ids
+}
 
 /** Presets the bundle declares for its worker and reviewer roles. */
 export const PRESET_IDS = ['tower-reviewer', 'tower-worker']
@@ -25,7 +61,7 @@ export const PRESET_IDS = ['tower-reviewer', 'tower-worker']
 /** Cordis fiber state 2: mounted and active. */
 const FIBER_ACTIVE = 2
 
-const OWNED_ROW_IDS = new Set([BUNDLE_ID, ...BUNDLE_CHILD_IDS])
+const OWNED_ROW_IDS = new Set([BUNDLE_ID, ...BUNDLE_CHILD_IDS, ...OPTIONAL_ROW_IDS])
 
 /**
  * Map one tools/ file name to the tool id its module must register.
@@ -42,14 +78,25 @@ export function toolIdForModule(fileName) {
 
 /**
  * @param {string[]} moduleFiles - file names under tools/.
+ * @param {{ enabledRows?: string[] }} [options] - rows enabled in the profile
+ *   under test. Defaults to the shipped profile: every optional row except the
+ *   ones in {@link DEFAULT_OFF_ROW_IDS}. Pass every row id to pin the full
+ *   build surface (29 tools with the shipped sources).
  * @returns {string[]} sorted tool ids the loaded profile must register.
  */
-export function expectedToolIds(moduleFiles) {
+export function expectedToolIds(moduleFiles, options = {}) {
+  const enabledRows = options.enabledRows === undefined ? null : new Set(options.enabledRows)
+  const skipped = new Set()
+  for (const rowId of DEFAULT_OFF_ROW_IDS) {
+    if (enabledRows !== null && enabledRows.has(rowId)) continue
+    for (const toolId of COMPONENT_TOOLS[rowId] ?? []) skipped.add(toolId)
+  }
   const ids = new Set(INDEX_TOOL_IDS)
   for (const file of moduleFiles) {
     const id = toolIdForModule(file)
     if (id !== null) ids.add(id)
   }
+  for (const id of skipped) ids.delete(id)
   return [...ids].sort()
 }
 
@@ -81,46 +128,55 @@ export function compareIds(label, expectedIds, loadedIds) {
   return failures
 }
 
+/** Effective loader id for a nested row (`group:child`), falling back to the raw id. */
+function stateKey(id, entryStates) {
+  if (entryStates[id] !== undefined) return id
+  const nested = `${BUNDLE_ID}:${id}`
+  if (entryStates[nested] !== undefined) return nested
+  return id
+}
+
 /**
- * Assert the bundle contributes exactly one top-level group row (#66) and that
- * every composed section actually mounted.
- * @param {Array<{ id?: string, name?: string, group?: boolean, config?: unknown[] }>} topRows -
- *   the composed rows at the root of the loaded profile tree.
+ * Assert the bundle ships one mandatory host group plus the optional rows and
+ * that every expected row actually mounted (the `tower-hmr` row is shipped off).
+ * @param {Array<{ id?: string, name?: string, group?: boolean, config?: unknown[], childIds?: unknown[] }>} topRows
  * @param {Record<string, number | undefined>} [entryStates] - fiber state per entry id.
  * @returns {string[]} one message per violated invariant.
  */
 export function checkBundleRow(topRows, entryStates = {}) {
   const rows = Array.isArray(topRows) ? topRows.filter(Boolean) : []
   const failures = []
-  const bundleRows = rows.filter((row) => row.id === BUNDLE_ID)
-  if (bundleRows.length !== 1) {
+  const hostRows = rows.filter((row) => row.id === BUNDLE_ID)
+  if (hostRows.length !== 1) {
     failures.push(
-      bundleRows.length === 0
-        ? `bundle: no top-level ${BUNDLE_ID} row; the bundle did not compose`
-        : `bundle: found ${bundleRows.length} top-level ${BUNDLE_ID} rows, expected exactly 1`,
+      hostRows.length === 0
+        ? `bundle: no top-level ${BUNDLE_ID} host row; the bundle did not compose`
+        : `bundle: found ${hostRows.length} top-level ${BUNDLE_ID} rows, expected exactly 1`,
     )
-    if (bundleRows.length === 0) return failures
+    if (hostRows.length === 0) return failures
   }
 
-  const leaked = new Set()
+  const topIds = new Set(rows.map((row) => String(row.id)))
+  for (const id of OPTIONAL_ROW_IDS) {
+    if (!topIds.has(id)) failures.push(`bundle: missing optional top-level row ${id}`)
+  }
   for (const row of rows) {
     if (row.id === BUNDLE_ID) continue
     const name = typeof row.name === 'string' ? row.name : ''
     const ownedName = name === 'dsh-tower' || name.startsWith('dsh-tower/')
     if (!OWNED_ROW_IDS.has(String(row.id)) && !ownedName) continue
-    if (leaked.has(String(row.id))) continue
-    leaked.add(String(row.id))
+    if (OPTIONAL_ROW_IDS.includes(String(row.id))) continue
     failures.push(`bundle: ${row.id} is a top-level row; it must stay nested in ${BUNDLE_ID}`)
   }
 
-  const bundleRow = bundleRows[0]
-  if (bundleRow.name !== 'cordis:group' || bundleRow.group !== true) {
+  const hostRow = hostRows[0]
+  if (hostRow.name !== 'cordis:group' || hostRow.group !== true) {
     failures.push(
-      `bundle: ${BUNDLE_ID} is not a cordis:group row (name ${JSON.stringify(bundleRow.name)}, group ${JSON.stringify(bundleRow.group)})`,
+      `bundle: ${BUNDLE_ID} is not a cordis:group row (name ${JSON.stringify(hostRow.name)}, group ${JSON.stringify(hostRow.group)})`,
     )
   }
 
-  const rawChildren = Array.isArray(bundleRow.childIds) ? bundleRow.childIds : Array.isArray(bundleRow.config) ? bundleRow.config : []
+  const rawChildren = Array.isArray(hostRow.childIds) ? hostRow.childIds : Array.isArray(hostRow.config) ? hostRow.config : []
   const children = rawChildren
     .map((child) =>
       child && typeof child === 'object' && child.id !== undefined ? String(child.id) : typeof child === 'string' ? child : null,
@@ -131,8 +187,21 @@ export function checkBundleRow(topRows, entryStates = {}) {
   for (const id of children) if (!expectedChildren.includes(id)) failures.push(`bundle: ${BUNDLE_ID} has unexpected child ${id}`)
   if (new Set(children).size !== children.length) failures.push(`bundle: ${BUNDLE_ID} has duplicate child rows`)
 
-  for (const id of [BUNDLE_ID, ...BUNDLE_CHILD_IDS]) {
-    const state = entryStates?.[id]
+  for (const id of [BUNDLE_ID, ...OPTIONAL_ROW_IDS]) {
+    if (DEFAULT_OFF_ROW_IDS.includes(id)) {
+      const state = entryStates[id]
+      if (state === FIBER_ACTIVE) failures.push(`bundle: ${id} ships disabled but is active`)
+      continue
+    }
+    const key = stateKey(id, entryStates)
+    const state = entryStates[key]
+    if (state !== FIBER_ACTIVE) {
+      failures.push(`bundle: entry ${id} is not active (entry state ${state === undefined ? 'missing' : state})`)
+    }
+  }
+  for (const id of BUNDLE_CHILD_IDS) {
+    const key = stateKey(id, entryStates)
+    const state = entryStates[key]
     if (state !== FIBER_ACTIVE) {
       failures.push(`bundle: entry ${id} is not active (entry state ${state === undefined ? 'missing' : state})`)
     }

package/scripts/mount-smoke.mjs

@@ -21,6 +21,7 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import {
   BUNDLE_ID,
+  DEFAULT_OFF_ROW_IDS,
   INDEX_TOOL_IDS,
   PRESET_IDS,
   checkBundleRow,
@@ -175,12 +176,13 @@ function verifySurface(surface, root) {
 
 function summarize(surface, root) {
   const modules = toolModuleNames(root).filter((name) => name !== 'index.js').length
+  const expected = expectedToolIds(toolModuleNames(root)).length
   const tools = Array.isArray(surface?.tools?.value) ? surface.tools.value.filter((name) => name.startsWith('tower_')).length : '?'
   const skills = Array.isArray(surface?.skills?.value?.tower) ? surface.skills.value.tower.length : '?'
   const presets = Array.isArray(surface?.presets?.value) ? surface.presets.value.length : '?'
   const commands = Array.isArray(surface?.commands?.value) ? surface.commands.value.filter((name) => name === 'tower').length : '?'
   const rows = Array.isArray(surface?.tree?.value?.top) ? surface.tree.value.top.filter((row) => row.id === BUNDLE_ID).length : '?'
-  return `${tools} tower tools (${modules} modules + ${INDEX_TOOL_IDS.length} entry tools), ${skills} skills, ${presets} presets, /tower ${commands === 1 ? 'present' : 'missing'}, ${rows} top-level bundle row`
+  return `${tools} of ${expected} tower tools (${modules} modules + ${INDEX_TOOL_IDS.length} entry tools; ${DEFAULT_OFF_ROW_IDS.join(', ')} off), ${skills} skills, ${presets} presets, /tower ${commands === 1 ? 'present' : 'missing'}, ${rows} top-level bundle row`
 }
 
 function reportFailure(state, pin, options, error) {

package/scripts/pack-manifest.txt

@@ -51,6 +51,7 @@ docs/adr/0001-ports-adapters-as-data.md
 docs/adr/0002-single-state-json.md
 docs/adr/0003-allow-agent-control-default-true.md
 docs/adr/0004-surface-budget.md
+docs/adr/0005-component-surface.md
 docs/adr/README.md
 docs/agents/domain.md
 docs/agents/issue-tracker.md
@@ -69,6 +70,7 @@ docs/operations/incident.md
 docs/operations/runbook.md
 docs/operations/security.md
 docs/reference/blockers.md
+docs/reference/component-surface.md
 docs/reference/config.generated.md
 docs/reference/config.md
 docs/reference/doctor.md
@@ -100,6 +102,7 @@ domain/collab/batch.js
 domain/collab/messages.js
 domain/collab/roster.js
 domain/collab/spawn.js
+domain/components.js
 domain/config/schema.js
 domain/contracts/outputs.js
 domain/contracts/tool-inputs/collaboration.js
@@ -142,6 +145,12 @@ domain/state/semantics.js
 domain/summary.js
 domain/surface.js
 domain/vocabulary.js
+host/capability-batch.js
+host/capability-hmr.js
+host/capability-import.js
+host/capability-leases.js
+host/capability-registry.js
+host/capability-tests.js
 host/compatibility.js
 host/config.js
 host/doctor.js
@@ -153,7 +162,19 @@ host/tool-registry.js
 host/tower.js
 icon.svg
 index.js
+locale/batch/en.json
+locale/batch/zh.json
 locale/en.json
+locale/hmr/en.json
+locale/hmr/zh.json
+locale/import/en.json
+locale/import/zh.json
+locale/leases/en.json
+locale/leases/zh.json
+locale/skills/en.json
+locale/skills/zh.json
+locale/tests/en.json
+locale/tests/zh.json
 locale/zh.json
 package.json
 ports/archive.js
@@ -171,19 +192,25 @@ ports/vcs.js
 reviewer.js
 scripts/architecture-waivers.json
 scripts/architecture.mjs
+scripts/check-components.mjs
 scripts/check-docs.mjs
 scripts/check-pack.mjs
 scripts/check-philosophy.mjs
+scripts/component-surface.json
 scripts/domain-metrics.mjs
 scripts/enable-dev-hmr.mjs
+scripts/generate-capability-locale.mjs
+scripts/generate-component-surface.mjs
 scripts/generate-config-reference.mjs
 scripts/generate-error-reference.mjs
 scripts/generate-events-reference.mjs
 scripts/generate-tools-reference.mjs
+scripts/generate-types.mjs
 scripts/issue-audit.mjs
 scripts/lib/cli.mjs
 scripts/lib/surface.mjs
 scripts/lib/tmp.mjs
+scripts/lib/tool-surface.mjs
 scripts/mount-smoke.mjs
 scripts/mount-smoke/fixtures.mjs
 scripts/mount-smoke/host.json
@@ -194,6 +221,9 @@ scripts/regression-audit.mjs
 scripts/release-check.mjs
 scripts/surface-baseline.json
 scripts/surface-baseline.mjs
+scripts/types-coverage.mjs
+scripts/types-strict-manifest.txt
+scripts/types-strict.mjs
 skills.js
 skills/tower-recovery.md
 skills/tower-review.md

package/scripts/surface-baseline.json

@@ -4,18 +4,49 @@
   "surfaces": {
     "configKeys": {
       "seed": 64,
-      "value": 64,
+      "value": 56,
       "decisions": []
     },
     "sections": {
       "seed": 15,
-      "value": 15,
+      "value": 14,
       "decisions": []
     },
     "tools": {
       "seed": 27,
-      "value": 27,
-      "decisions": []
+      "value": 29,
+      "decisions": [
+        {
+          "from": 27,
+          "to": 29,
+          "date": "2026-10-23",
+          "correction": {
+            "reason": "Measurement correction, not surface growth: the 2.3.0 baseline recorded only define()-registered tools. tower_mode and tower_control are registered directly by index.js, so the shipped surface was always 29 (#118). The recorder in host/tool-registry.js now covers both paths.",
+            "date": "2026-10-23",
+            "ref": "docs/adr/0004-surface-budget.md"
+          }
+        }
+      ]
+    },
+    "components": {
+      "seed": 4,
+      "value": 8,
+      "decisions": [
+        {
+          "from": 4,
+          "to": 1,
+          "date": "2026-10-23",
+          "adr": "docs/adr/0005-component-surface.md",
+          "note": "The component surface joins the budget with its history. 2.0.4 shipped four top-level rows (tower, tower-skills, preset-tower-worker, preset-tower-reviewer); 2.3.0 replaced them with one tower-bundle group row that still mounts the same four sections. This is a recorded contraction, not a free ratchet: the seed stays at 4 so any further move -- including the #121 growth back to individually toggleable optional rows -- must extend this chain with a dated decision."
+        },
+        {
+          "from": 1,
+          "to": 8,
+          "date": "2026-10-23",
+          "adr": "docs/adr/0005-component-surface.md",
+          "note": "#121 restores the #65 policy from ADR 0005: the one tower-bundle group becomes a mandatory tower host anchor plus seven individually switchable optional rows (tower-skills, tower-batch, tower-import, tower-leases, tower-tests, tower-hmr shipped off, preset-tower-reviewer conditional). The host anchor and preset-tower-worker stay mandatory; tower_doctor and tower_recover stay mandatory with the host (#122), so they are not rows. configKeys and sections shrank in the same wave because the seven tools.expose* keys and dev.hotReload became rows."
+        }
+      ]
     }
   }
 }