dsh-tower 2.4.1 → 2.5.0

package/scripts/mount-smoke/surface.mjs

@@ -29,7 +29,9 @@ 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-archive',
   'tower-batch',
+  'tower-board',
   'tower-hmr',
   'tower-import',
   'tower-leases',
@@ -55,11 +57,30 @@ export function defaultOffToolIds() {
   return ids
 }
 
+/**
+ * The two preset rows the bundle declares. Each row mounts a Tower-owned
+ * declaration module (`dsh-tower/preset-*`) whose config the agent-preset
+ * registry registers; the label and the read-only reviewer surface are part of
+ * the contract, so the smoke compares the loaded `agentPresets.list()` entries
+ * against this table (#121).
+ */
+export const PRESET_ROWS = Object.freeze([
+  Object.freeze({ id: 'tower-worker', specifier: 'preset-worker', name: 'Tower Worker', order: 60 }),
+  Object.freeze({ id: 'tower-reviewer', specifier: 'preset-reviewer', name: 'Tower Reviewer', order: 61 }),
+])
+
 /** Presets the bundle declares for its worker and reviewer roles. */
-export const PRESET_IDS = ['tower-reviewer', 'tower-worker']
+export const PRESET_IDS = PRESET_ROWS.map((row) => row.id).sort()
+
+/** Module specifiers the two preset rows mount; each owns its Plugins-page label. */
+export const PRESET_SPECIFIERS = PRESET_ROWS.map((row) => `dsh-tower/${row.specifier}`)
 
 /** Cordis fiber state 2: mounted and active. */
 const FIBER_ACTIVE = 2
+/** Cordis fiber state 3: the plugin failed to activate. */
+const FIBER_FAILED = 3
+/** Cordis fiber state 1: activation is still in flight (the boot has not settled). */
+const FIBER_PENDING = 1
 
 const OWNED_ROW_IDS = new Set([BUNDLE_ID, ...BUNDLE_CHILD_IDS, ...OPTIONAL_ROW_IDS])
 
@@ -128,6 +149,128 @@ export function compareIds(label, expectedIds, loadedIds) {
   return failures
 }
 
+/** Read one localized field: DSH reports `{ en, zh }` maps, a bare string, or nothing. */
+function localizedField(value, lang) {
+  if (typeof value === 'string') return value.trim() || undefined
+  if (value && typeof value === 'object' && typeof value[lang] === 'string') return value[lang].trim() || undefined
+  return undefined
+}
+
+/**
+ * Assert the two preset rows resolve distinct Plugins-page labels. The defect
+ * this mission fixes was two rows sharing `@deepseek-ai/dsh-agent-preset`, so
+ * both rendered that module's single title; the smoke now reads the same
+ * `readPluginMeta` the page uses and requires a distinct title and description
+ * per specifier (#121).
+ * @param {Record<string, { title?: unknown, description?: unknown, error?: string } | null>} labels
+ *   module specifier -> label metadata from `readPluginMeta`.
+ * @returns {string[]} one message per missing, failed or indistinguishable label.
+ */
+export function checkPresetLabels(labels) {
+  const failures = []
+  const byLanguage = { en: new Map(), zh: new Map() }
+  for (const row of PRESET_ROWS) {
+    const specifier = `dsh-tower/${row.specifier}`
+    const label = labels?.[specifier]
+    if (label === undefined) {
+      failures.push(`label: no label reported for ${specifier}`)
+      continue
+    }
+    if (label === null) {
+      failures.push(`label: ${specifier} resolves no locale metadata`)
+      continue
+    }
+    if (label.error) {
+      failures.push(`label: ${specifier}: ${label.error}`)
+      continue
+    }
+    for (const lang of ['en', 'zh']) {
+      const title = localizedField(label.title, lang)
+      const description = localizedField(label.description, lang)
+      if (!title) {
+        failures.push(`label: ${specifier} has no ${lang} title`)
+        continue
+      }
+      if (!description) failures.push(`label: ${specifier} has no ${lang} description`)
+      if (title === specifier) failures.push(`label: ${specifier} falls back to the module specifier as its ${lang} title`)
+      if (!title.includes(row.name)) failures.push(`label: ${specifier} ${lang} title does not name ${row.name}`)
+      byLanguage[lang].set(specifier, { title, description })
+    }
+  }
+  for (const lang of ['en', 'zh']) {
+    const entries = [...byLanguage[lang].entries()]
+    if (entries.length < 2) continue
+    const [first] = entries
+    for (const [specifier, entry] of entries.slice(1)) {
+      if (entry.title === first[1].title) {
+        failures.push(`label: ${first[0]} and ${specifier} share the same ${lang} title`)
+      }
+      if (entry.description !== undefined && entry.description === first[1].description) {
+        failures.push(`label: ${first[0]} and ${specifier} share the same ${lang} description`)
+      }
+    }
+  }
+  return failures
+}
+
+/**
+ * Compare the loaded preset definitions against {@link PRESET_ROWS}. A missing
+ * preset, a changed display name/order, or an activation diagnostic (`broken`)
+ * is a failed claim: a preset row that mounts but never activates is exactly the
+ * regression the smoke exists to catch.
+ * @param {Array<{ id?: string, name?: string, order?: number, broken?: string }>} entries
+ * @returns {string[]} one message per violated preset claim.
+ */
+export function checkPresetRows(entries) {
+  const list = Array.isArray(entries) ? entries : []
+  const byId = new Map(list.map((entry) => [String(entry?.id), entry]))
+  const failures = []
+  for (const row of PRESET_ROWS) {
+    const entry = byId.get(row.id)
+    if (!entry) {
+      failures.push(`preset: missing ${row.id}`)
+      continue
+    }
+    if (entry.name !== row.name) {
+      failures.push(`preset: ${row.id} name ${JSON.stringify(entry.name)}, expected ${JSON.stringify(row.name)}`)
+    }
+    if (entry.order !== row.order) {
+      failures.push(`preset: ${row.id} order ${JSON.stringify(entry.order)}, expected ${row.order}`)
+    }
+    if (entry.broken) failures.push(`preset: ${row.id} failed to mount: ${entry.broken}`)
+  }
+  return failures
+}
+
+/** Entry ids whose fiber reported an activation error (state 3). */
+export function failedEntryStates(entryStates = {}) {
+  return Object.entries(entryStates)
+    .filter(([, state]) => state === FIBER_FAILED)
+    .map(([id]) => id)
+    .sort()
+}
+
+/** Entry ids still loading when the boot returned (state 1). */
+export function pendingEntryStates(entryStates = {}) {
+  return Object.entries(entryStates)
+    .filter(([, state]) => state === FIBER_PENDING)
+    .map(([id]) => id)
+    .sort()
+}
+
+/**
+ * No row may fail or stay pending in a green smoke: the bundle is supposed to
+ * compose a working profile, not merely register the ids it claims.
+ * @param {Record<string, number | null | undefined>} entryStates
+ * @returns {string[]} one message per failed or pending row.
+ */
+export function checkRowStates(entryStates = {}) {
+  const failures = []
+  for (const id of failedEntryStates(entryStates)) failures.push(`row: ${id} failed to mount (entry state 3)`)
+  for (const id of pendingEntryStates(entryStates)) failures.push(`row: ${id} is still pending (entry state 1)`)
+  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

package/scripts/mount-smoke.mjs

@@ -25,6 +25,9 @@ import {
   INDEX_TOOL_IDS,
   PRESET_IDS,
   checkBundleRow,
+  checkPresetLabels,
+  checkPresetRows,
+  checkRowStates,
   compareIds,
   expectedSkillIds,
   expectedToolIds,
@@ -163,13 +166,29 @@ function verifySurface(surface, root) {
   if (loadedSkills) failures.push(...compareIds('skill', expectedSkills, loadedSkills.tower))
 
   const loadedPresets = area(surface, 'presets', 'preset', failures)
-  if (loadedPresets) failures.push(...compareIds('preset', PRESET_IDS, loadedPresets))
+  if (loadedPresets) {
+    failures.push(...compareIds('preset', PRESET_IDS, loadedPresets.ids ?? []))
+    // Both preset rows must still activate: ids, display names/orders and no
+    // registry activation diagnostic (#121).
+    failures.push(...checkPresetRows(loadedPresets.entries ?? []))
+  }
+
+  // The Plugins page reads the label through `readPluginMeta`; the two preset
+  // rows used to share one module and rendered the same title. Prove the
+  // installed package now resolves a distinct label per row (#121).
+  const loadedLabels = area(surface, 'labels', 'label', failures)
+  if (loadedLabels) failures.push(...checkPresetLabels(loadedLabels))
 
   const loadedCommands = area(surface, 'commands', 'command', failures)
   if (loadedCommands && !loadedCommands.includes('tower')) failures.push('command: /tower is not registered in the loaded command registry')
 
   const tree = area(surface, 'tree', 'bundle', failures)
-  if (tree) failures.push(...checkBundleRow(tree.top, tree.states))
+  if (tree) {
+    failures.push(...checkBundleRow(tree.top, tree.states))
+    // The bundle was replaced row-by-row (#121); prove no row failed to activate
+    // or is still waiting, not only that the expected rows are active.
+    failures.push(...checkRowStates(tree.states))
+  }
 
   return failures
 }
@@ -179,10 +198,11 @@ function summarize(surface, root) {
   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 presets = Array.isArray(surface?.presets?.value?.ids) ? surface.presets.value.ids.length : '?'
+  const labels = surface?.labels?.value && typeof surface.labels.value === 'object' ? Object.keys(surface.labels.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} 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`
+  return `${tools} of ${expected} tower tools (${modules} modules + ${INDEX_TOOL_IDS.length} entry tools; ${DEFAULT_OFF_ROW_IDS.join(', ')} off), ${skills} skills, ${presets} presets (${labels} distinct labels), /tower ${commands === 1 ? 'present' : 'missing'}, ${rows} top-level bundle row`
 }
 
 function reportFailure(state, pin, options, error) {

package/scripts/pack-manifest.txt

@@ -1,6 +1,7 @@
 CHANGELOG.md
 COMPATIBILITY.md
 CONTRIBUTING.md
+GLOSSARY.md
 LICENSE
 PRINCIPLES.md
 README.en.md
@@ -102,6 +103,7 @@ domain/collab/batch.js
 domain/collab/messages.js
 domain/collab/roster.js
 domain/collab/spawn.js
+domain/component-rules.js
 domain/components.js
 domain/config/schema.js
 domain/contracts/outputs.js
@@ -145,7 +147,9 @@ domain/state/semantics.js
 domain/summary.js
 domain/surface.js
 domain/vocabulary.js
+host/capability-archive.js
 host/capability-batch.js
+host/capability-board.js
 host/capability-hmr.js
 host/capability-import.js
 host/capability-leases.js
@@ -157,13 +161,19 @@ host/doctor.js
 host/hmr.js
 host/modeState.js
 host/modeStore.js
+host/preset-reviewer.js
+host/preset-worker.js
 host/presets.js
 host/tool-registry.js
 host/tower.js
 icon.svg
 index.js
+locale/archive/en.json
+locale/archive/zh.json
 locale/batch/en.json
 locale/batch/zh.json
+locale/board/en.json
+locale/board/zh.json
 locale/en.json
 locale/hmr/en.json
 locale/hmr/zh.json
@@ -171,6 +181,10 @@ locale/import/en.json
 locale/import/zh.json
 locale/leases/en.json
 locale/leases/zh.json
+locale/preset-reviewer/en.json
+locale/preset-reviewer/zh.json
+locale/preset-worker/en.json
+locale/preset-worker/zh.json
 locale/skills/en.json
 locale/skills/zh.json
 locale/tests/en.json
@@ -219,6 +233,7 @@ scripts/mount-smoke/surface.mjs
 scripts/pack-manifest.txt
 scripts/regression-audit.mjs
 scripts/release-check.mjs
+scripts/release-notes.mjs
 scripts/surface-baseline.json
 scripts/surface-baseline.mjs
 scripts/types-coverage.mjs

package/scripts/release-notes.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+// Cumulative Release notes.
+//
+// Policy: every GitHub Release aggregates every CHANGELOG section since the
+// previous GitHub Release, not just the section that names its own version.
+// Tag-only versions have no Release, so their sections roll into the next
+// Release. Example: when 2.1.0 was the previous Release, the 2.3.0 Release
+// includes 2.1.1, 2.1.2, 2.2.0 and 2.3.0; 2.1.0-beta.1 is older than 2.1.0 and
+// stays out of the window.
+//
+// The script is the authority for a Release body: it reads `<root>/CHANGELOG.md`
+// and emits
+//
+//   # dsh-tower <version>
+//
+//   > <provenance line naming the previous Release>
+//
+//   ---
+//
+//   <CHANGELOG section> --- <CHANGELOG section> ...
+//
+// in ascending SemVer order (`1.0.0-beta.2 < 1.0.0-beta.10 < 1.0.0`). The
+// window is `since < v <= version`. `--check <file>` compares an existing notes
+// file byte-for-byte with the generated text so a published Release body can be
+// re-verified.
+//
+// Usage:
+//   node scripts/release-notes.mjs --version <semver> --since <semver> \
+//     [--output <file>] [--check <file>] [--root <dir>]
+//
+// Exit codes: 0 success or matching --check; 1 --check mismatch; 2 bad
+// arguments, an unreadable CHANGELOG, `since >= version`, or an empty window.
+import fs from 'node:fs'
+import path from 'node:path'
+import { compareVersions } from '../host/compatibility.js'
+import { parseArgs, runMain, UsageError } from './lib/cli.mjs'
+
+const USAGE = `usage: node scripts/release-notes.mjs --version <semver> --since <semver>
+                                     [--output <file>] [--check <file>] [--root <dir>] [--help]
+
+  --version  release version to generate notes for (required, e.g. 2.3.0)
+  --since    previous GitHub Release version, exclusive (required, e.g. 2.1.0)
+  --output   write the notes to this file instead of stdout
+  --check    compare the generated notes with this file byte-for-byte
+  --root     repository root that holds CHANGELOG.md (default: current directory)
+  --help     print this text
+
+A version may be written with or without its "v" tag prefix. The window
+(since, version] is emitted in ascending SemVer order, so tag-only versions
+between the two Releases are included.`
+
+// SemVer 2.0.0 without build metadata: X.Y.Z with an optional pre-release.
+// Numeric core and numeric pre-release identifiers have no leading zeros, so
+// "2.3.0" is a version and "2.3" or "2.3.0-01" are not.
+const SEMVER =
+  /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?$/
+
+// A level-2 heading whose first token is a version. The loose token keeps the
+// pre-release suffix intact (`2.1.0-beta.1`, not `2.1.0`); SEMVER then rejects
+// a heading such as `## Unreleased`. `### Added` never matches: the third `#`
+// is not whitespace.
+const HEADING = /^##[ \t]+(?:\[[ \t]*)?v?([0-9A-Za-z.-]+)/
+
+function usageError(message) {
+  const error = new UsageError(message)
+  error.showUsage = true
+  return error
+}
+
+function normalizeVersion(value, flag) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw usageError(`${flag} <semver> is required`)
+  }
+  const text = value.trim().replace(/^v/, '')
+  if (!SEMVER.test(text)) {
+    throw usageError(`${flag} ${JSON.stringify(value)} is not a SemVer version (expected X.Y.Z or X.Y.Z-pre)`)
+  }
+  return text
+}
+
+/**
+ * Read every `## <version>` section from CHANGELOG text, in file order.
+ *
+ * The body ends at the next level-2 heading. Leading and trailing blank lines
+ * are dropped, so a section touched by the next heading without an intervening
+ * blank line (the real CHANGELOG has a few) still produces stable output.
+ * Duplicate version headings are a malformed changelog, not a choice.
+ */
+export function extractSections(changelog) {
+  const lines = String(changelog ?? '').split(/\r?\n/)
+  const sections = []
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = HEADING.exec(lines[index])
+    if (!match || !SEMVER.test(match[1])) continue
+    const body = []
+    let cursor = index + 1
+    while (cursor < lines.length && !/^##[ \t]/.test(lines[cursor])) {
+      body.push(lines[cursor])
+      cursor += 1
+    }
+    while (body.length > 0 && body[0].trim() === '') body.shift()
+    while (body.length > 0 && body[body.length - 1].trim() === '') body.pop()
+    const heading = lines[index].trimEnd()
+    sections.push({
+      version: match[1],
+      heading,
+      body: body.join('\n'),
+      text: body.length > 0 ? `${heading}\n\n${body.join('\n')}` : heading,
+    })
+    index = cursor - 1
+  }
+  const seen = new Set()
+  for (const section of sections) {
+    if (seen.has(section.version)) {
+      throw new Error(`CHANGELOG.md has more than one section for version ${section.version}`)
+    }
+    seen.add(section.version)
+  }
+  return sections
+}
+
+/**
+ * Build the cumulative Release body for `version`, containing every CHANGELOG
+ * section with `since < v <= version` in ascending SemVer order.
+ */
+export function generateReleaseNotes({ changelog, version, since }) {
+  const target = normalizeVersion(version, '--version')
+  const previous = normalizeVersion(since, '--since')
+  const relation = compareVersions(target, previous)
+  if (relation !== null && relation <= 0) {
+    throw usageError(`--since ${previous} must be older than --version ${target}`)
+  }
+  const sections = extractSections(changelog)
+    .filter((section) => {
+      const afterSince = compareVersions(section.version, previous)
+      const atOrBeforeTarget = compareVersions(section.version, target)
+      return afterSince > 0 && atOrBeforeTarget <= 0
+    })
+    .sort((left, right) => compareVersions(left.version, right.version))
+
+  if (sections.length === 0) {
+    throw usageError(
+      `no CHANGELOG section falls in the window (${previous}, ${target}]; ` +
+        'bump the changelog or check --since (it is the previous GitHub Release, not the previous tag)',
+    )
+  }
+
+  const versions = sections.map((section) => section.version)
+  const quote =
+    versions.length === 1
+      ? `> 自上一个 Release \`v${previous}\` 起的变更。`
+      : `> 本 Release 包含自上一个 Release \`v${previous}\` 以来的全部变更：${versions.join('、')}。`
+  const text = `# dsh-tower ${target}\n\n${quote}\n\n---\n\n${sections
+    .map((section) => section.text)
+    .join('\n\n---\n\n')}\n`
+  return { version: target, since: previous, versions, sections, text }
+}
+
+function firstDifference(expected, actual) {
+  const expectedLines = expected.split('\n')
+  const actualLines = actual.split('\n')
+  const limit = Math.max(expectedLines.length, actualLines.length)
+  for (let index = 0; index < limit; index += 1) {
+    if (expectedLines[index] !== actualLines[index]) {
+      return {
+        line: index + 1,
+        expected: expectedLines[index] ?? '<end of file>',
+        actual: actualLines[index] ?? '<end of file>',
+      }
+    }
+  }
+  return null
+}
+
+function compareWithFile(file, result) {
+  const expected = Buffer.from(result.text, 'utf8')
+  let existing
+  try {
+    existing = fs.readFileSync(file)
+  } catch (error) {
+    console.error(`release-notes: cannot read ${file}: ${error?.message ?? error}`)
+    return 2
+  }
+  if (existing.equals(expected)) {
+    console.log(
+      `release-notes: ${file} matches the generated notes for ${result.version} ` +
+        `(${result.versions.length} section(s): ${result.versions.join(', ')})`,
+    )
+    return 0
+  }
+  const found = existing.toString('utf8')
+  const difference = firstDifference(result.text, found)
+  console.error(`release-notes: ${file} does not match the generated notes for ${result.version}`)
+  if (difference) {
+    console.error(`  first difference at line ${difference.line}: expected ${JSON.stringify(difference.expected)}`)
+    console.error(`  found ${JSON.stringify(difference.actual)}`)
+  }
+  console.error(`  expected ${expected.length} bytes, found ${existing.length} bytes`)
+  return 1
+}
+
+function cli(argv) {
+  const options = parseArgs(argv, {
+    initial: { version: null, since: null, output: null, check: null, root: null, help: false },
+    values: {
+      '--version': 'version',
+      '--since': 'since',
+      '--output': 'output',
+      '--check': 'check',
+      '--root': 'root',
+    },
+    flags: { '--help': 'help', '-h': 'help' },
+  })
+  if (options.help) {
+    console.log(USAGE)
+    return 0
+  }
+  if (options.output && options.check) {
+    throw usageError('--output and --check are mutually exclusive')
+  }
+
+  const root = path.resolve(options.root ?? process.cwd())
+  const changelogPath = path.join(root, 'CHANGELOG.md')
+  let changelog
+  try {
+    changelog = fs.readFileSync(changelogPath, 'utf8')
+  } catch (error) {
+    console.error(`release-notes: cannot read ${changelogPath}: ${error?.message ?? error}`)
+    return 2
+  }
+
+  let result
+  try {
+    result = generateReleaseNotes({ changelog, version: options.version, since: options.since })
+  } catch (error) {
+    // UsageError messages already name the offending flag; file/data errors are
+    // reported with the same prefix and exit 2 (never a partial Release).
+    console.error(`release-notes: ${error?.message ?? error}`)
+    if (error?.showUsage) console.error(USAGE)
+    return 2
+  }
+
+  if (options.check) return compareWithFile(path.resolve(options.check), result)
+  if (options.output) {
+    const outputPath = path.resolve(options.output)
+    fs.writeFileSync(outputPath, result.text, 'utf8')
+    console.log(
+      `release-notes: wrote ${outputPath} (${result.versions.length} section(s): ${result.versions.join(', ')})`,
+    )
+    return 0
+  }
+  process.stdout.write(result.text)
+  return 0
+}
+
+await runMain(import.meta.url, () => cli(process.argv.slice(2)), { errorPrefix: 'release-notes', usage: USAGE })

package/scripts/surface-baseline.json

@@ -4,8 +4,16 @@
   "surfaces": {
     "configKeys": {
       "seed": 64,
-      "value": 56,
-      "decisions": []
+      "value": 53,
+      "decisions": [
+        {
+          "from": 64,
+          "to": 53,
+          "date": "2026-11-03",
+          "adr": "docs/adr/0005-component-surface.md",
+          "note": "Recorded contraction, not a free ratchet (#138). #121 removed the seven tools.expose* keys plus dev.hotReload, #136 replaced tests.enabled with the tower-tests row, and #133/#135 replaced docs.board/archive.enabled with the tower-board/tower-archive rows. The chain now continues here: the config-key surface is two-way like components, so any later increase or decrease needs its own dated decision."
+        }
+      ]
     },
     "sections": {
       "seed": 15,
@@ -30,7 +38,7 @@
     },
     "components": {
       "seed": 4,
-      "value": 8,
+      "value": 11,
       "decisions": [
         {
           "from": 4,
@@ -45,6 +53,27 @@
           "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."
+        },
+        {
+          "from": 8,
+          "to": 9,
+          "date": "2026-11-02",
+          "adr": "docs/adr/0005-component-surface.md",
+          "note": "#133: `docs.board` was a capability wearing a tuning-key costume. The visible tower-board row owns the MISSIONS.md board now; `docs.boardLocation` stays tuning. Off writes no board."
+        },
+        {
+          "from": 9,
+          "to": 10,
+          "date": "2026-11-02",
+          "adr": "docs/adr/0005-component-surface.md",
+          "note": "#135: `archive.enabled` was the same costume. The visible tower-archive row owns archival now; `afterDays`/`maxMissions` stay tuning. Off keeps terminal missions hot, so state keeps growing."
+        },
+        {
+          "from": 10,
+          "to": 11,
+          "date": "2026-11-02",
+          "adr": "docs/adr/0005-component-surface.md",
+          "note": "#134: the gate reads every shipped cordis.patch.yml, so the tower-ui row in ui-bundle/cordis.patch.yml joins the counted surface. The row was always shipped and unclassified; counting it is not new surface, it is the existing surface becoming visible to the policy."
         }
       ]
     }

package/scripts/surface-baseline.mjs

@@ -8,8 +8,9 @@
 //   tools         every tool the Host entry registers, including the
 //                 tower_mode/tower_control pair that index.js registers
 //                 directly rather than through define() (#118)
-//   components    user-visible rows in cordis.patch.yml (#120), so the 2.3.0
-//                 4 -> 1 contraction and any future move need a written decision
+//   components    user-visible rows in every shipped cordis.patch.yml (#120,
+//                 #134), so the 2.3.0 4 -> 1 contraction and any future move
+//                 need a written decision
 //
 // `scripts/surface-baseline.json` freezes those counts. A PR that grows a count
 // fails here until the baseline carries a decision with either an ADR under
@@ -24,7 +25,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { configSurface } from '../domain/config/schema.js'
-import { parseCordisPatch } from '../domain/components.js'
+import { COMPONENT_PATCH_FILES, mergeCordisPatches, parseCordisPatch } from '../domain/components.js'
 import { SURFACE_CLASSIFICATION_FILE, SURFACE_BASELINE_FILE, surfaceLine } from '../domain/surface.js'
 import { loadShippedToolSurface } from './lib/tool-surface.mjs'
 import { checkSurfaceBudget } from './lib/surface.mjs'
@@ -42,7 +43,8 @@ with a decision that names an existing docs/adr/ ADR, deletions that are no
 longer in the live surface, or a measurement-correction record with a reason and
 date. The classification table in
 ${SURFACE_CLASSIFICATION_FILE} must cover every key and tool exactly once, and
-the component count comes from the visible rows in cordis.patch.yml.`
+the component count comes from the visible rows in every shipped
+cordis.patch.yml.`
 
 /**
  * The live tool names: apply the shipped Host entry so every registration path
@@ -65,7 +67,15 @@ function liveToolNames() {
 export function liveSurface(root = PACKAGE_ROOT) {
   const config = configSurface()
   const tools = liveToolNames()
-  const patch = parseCordisPatch(fs.readFileSync(path.join(root, 'cordis.patch.yml'), 'utf8'))
+  // #134: the counted component surface is every shipped patch, not only the
+  // root one; `ui-bundle/cordis.patch.yml` ships the tower-ui row.
+  const patches = {}
+  for (const file of COMPONENT_PATCH_FILES) {
+    const patchFile = path.join(root, file)
+    if (!fs.existsSync(patchFile)) continue
+    patches[file] = parseCordisPatch(fs.readFileSync(patchFile, 'utf8'))
+  }
+  const patch = mergeCordisPatches(patches)
   return {
     configKeys: config.count,
     sections: config.sections.length,

package/skills.js

@@ -66,5 +66,8 @@ export function apply(ctx) {
   // 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)
+  // #139: the provider must be unregistered with the plugin, so the catalog stops
+  // serving after unload/reload instead of keeping a dead provider alive. Host
+  // registries may or may not return a disposer; `ctx.effect` accepts both.
+  ctx.effect(() => ctx.skills.registerProvider(() => provider))
 }

package/tools/complete.js

@@ -31,7 +31,9 @@ export function registerCompleteTool(ctx, deps) {
       const context = await tower.missionContext(args.missionId)
       const checks = [...(Array.isArray(args.checks) ? args.checks : [])]
       const testsConfig = /** @type {any} */ (tower.config.tests ?? {})
-      if (testsConfig.enabled !== false && isCompleteAdmission(testsConfig.admission)) {
+      // #136: the `tower-tests` component row is the only switch; admission
+      // decides when discovery runs, not whether it may run.
+      if (isCompleteAdmission(testsConfig.admission)) {
         const discovery = await runMissionDiscovery(tower, { id: args.missionId, worktree: context.mission.worktree })
         if (discovery.configured && discovery.receipt.ok !== true) {
           throw new TowerToolError('tests-failed', `test discovery failed for ${args.missionId}: ${discovery.receipt.error}`)