dsh-tower 2.1.0-beta.1 → 2.3.0

package/scripts/surface-baseline.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// Concept-budget gate (#84): compare the live surface with the committed
+// baseline and require evidence for growth.
+//
+// The surface is three counts the user has to hold at once:
+//   config keys   leaf keys in domain/config/schema.js (one level deep)
+//   sections      object groups in that schema
+//   tools         tool definitions registered by host/tool-registry.js
+//
+// `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
+// docs/adr/ or deletions that no longer exist in the live surface. The same
+// file supplies the date and counts printed in the generated config/tools
+// reference headers, so growth is visible in a diff.
+//
+// Usage:
+//   node scripts/surface-baseline.mjs [--root <dir>] [--json]
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { configSurface } from '../domain/config/schema.js'
+import { SURFACE_CLASSIFICATION_FILE, SURFACE_BASELINE_FILE, surfaceLine } from '../domain/surface.js'
+import { registerTowerTools } from '../tools/index.js'
+import { definedToolNames } from '../host/tool-registry.js'
+import { checkSurfaceBudget } from './lib/surface.mjs'
+import { parseArgs, runMain } from './lib/cli.mjs'
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const USAGE = `usage: node scripts/surface-baseline.mjs [--root <dir>] [--json]
+
+  --root   repository root to check (default: this package)
+  --json   print the report as JSON
+  --help   print this text
+
+Growth is refused by default. To grow a count, update ${SURFACE_BASELINE_FILE}
+with a decision that names an existing docs/adr/ ADR or deletions that are no
+longer in the live surface. The classification table in
+${SURFACE_CLASSIFICATION_FILE} must cover every key and tool exactly once.`
+
+/** Register the real tool surface against a minimal mock context. */
+function liveToolNames() {
+  const ctx = {
+    get() {
+      return undefined
+    },
+    effect(fn) {
+      const dispose = fn()
+      return typeof dispose === 'function' ? dispose : () => {}
+    },
+    systemPrompt: { section() {} },
+    tools: {
+      register() {
+        return () => {}
+      },
+      guard() {
+        return () => {}
+      },
+      restrict() {
+        return () => {}
+      },
+    },
+  }
+  registerTowerTools(ctx)
+  return definedToolNames()
+}
+
+/**
+ * The live surface used by the gate. Exported so tests can compare the counts
+ * with the generated references without spawning the CLI.
+ */
+export function liveSurface() {
+  const config = configSurface()
+  const tools = liveToolNames()
+  return {
+    configKeys: config.count,
+    sections: config.sections.length,
+    tools: tools.length,
+    liveNames: {
+      configKeys: config.keys,
+      sections: config.sections,
+      tools,
+    },
+  }
+}
+
+function main(argv) {
+  const options = parseArgs(argv, {
+    initial: { root: PACKAGE_ROOT, json: false, help: false },
+    values: { '--root': { key: 'root', parse: path.resolve } },
+    flags: { '--json': 'json', '--help': 'help', '-h': 'help' },
+  })
+  if (options.help) {
+    console.log(USAGE)
+    return 0
+  }
+  const root = path.resolve(options.root)
+  if (!fs.existsSync(path.join(root, SURFACE_BASELINE_FILE))) {
+    console.error(`surface: ${SURFACE_BASELINE_FILE} is missing under ${root}`)
+    return 2
+  }
+  const current = liveSurface()
+  const result = checkSurfaceBudget({ root, current })
+  if (options.json) {
+    console.log(JSON.stringify({ root, current, ...result }, null, 2))
+    return result.ok ? 0 : 1
+  }
+  console.log(`surface: ${surfaceLine(current)}`)
+  if (result.baseline) console.log(`surface: baseline ${result.baseline.date} (${SURFACE_BASELINE_FILE})`)
+  if (result.classification) {
+    const configRows = result.classification.entries.filter((entry) => entry.kind === 'config').length
+    const toolRows = result.classification.entries.filter((entry) => entry.kind === 'tools').length
+    console.log(`surface: classified ${configRows} config keys and ${toolRows} tools (${SURFACE_CLASSIFICATION_FILE})`)
+  }
+  for (const finding of result.findings) console.log(`surface: ${finding.level} [${finding.code}] ${finding.message}`)
+  if (result.ok) console.log('surface: ok — counts match the committed baseline and every entry is classified')
+  else console.log(`surface: ${result.findings.length} problem(s); growth needs an ADR or a matching deletion`)
+  return result.ok ? 0 : 1
+}
+
+await runMain(import.meta.url, () => main(process.argv.slice(2)), { errorPrefix: 'surface', usage: USAGE })

package/tools/adopt.js

@@ -1,5 +1,4 @@
 // tower_adopt: reconcile the roster with the subagent catalog.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { TowerToolError } from '../domain/errors.js'
 import { AdoptInput } from '../domain/contracts/tool-inputs/index.js'
@@ -7,7 +6,7 @@ import { PARENT_STATUS_OK, ROSTER_ACTIVITY, ROSTER_STATE } from '../domain/vocab
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any }} deps
  */
 export function registerAdoptTool(ctx, deps) {
   const { define, actorFor, requireTowerActor } = deps
@@ -19,7 +18,7 @@ export function registerAdoptTool(ctx, deps) {
     aliases: { retire_missing: ['retireMissing'] },
     output: output(SCHEMAS.adopt),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireTowerActor(actor, 'adopt the roster')
       const view = await tower.rosterView()

package/tools/batch.js

@@ -1,5 +1,4 @@
 // tower_batch: finite evidence batches.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { TowerToolError } from '../domain/errors.js'
 import { BatchInput } from '../domain/contracts/tool-inputs/index.js'
@@ -7,7 +6,7 @@ import { BATCH_ACTION } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any, summarizeBatch: any, verifyBatchReceiptFiles: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any, summarizeBatch: any, verifyBatchReceiptFiles: any }} deps
  */
 export function registerBatchTool(ctx, deps) {
   const { define, actorFor, requireTowerActor, summarizeBatch, verifyBatchReceiptFiles } = deps
@@ -19,7 +18,7 @@ export function registerBatchTool(ctx, deps) {
     board: true,
     output: output(SCHEMAS.batch),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       if (args.action === BATCH_ACTION.status) {
         const state = await tower.load()

package/tools/complete.js

@@ -1,5 +1,4 @@
 // tower_complete: worker completion admission.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { TowerToolError } from '../domain/errors.js'
 import { CompleteInput } from '../domain/contracts/tool-inputs/index.js'
@@ -7,21 +6,21 @@ import { isCompleteAdmission } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, runMissionDiscovery: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, runMissionDiscovery: any }} deps
  */
 export function registerCompleteTool(ctx, deps) {
   const { define, runMissionDiscovery } = deps
   define(ctx, {
     name: 'tower_complete',
     description:
-      'Worker-only: report mission completion. Enforced by the store: every task done or dropped, no blockers, the current owner, the mission branch has at least one commit since its spawn base, and no unread inbox messages. checks records verifiable evidence (name/command/exitCode/evidence); gates.requireChecks can require at least one before merge. Stores the full report; completion means ready for preflight and optional review, not merged.',
+      'Worker-only: report mission completion. Enforced by the store: every task done or dropped, no blockers, the current owner, the mission branch has at least one commit since its spawn base, and no unread inbox messages. checks records verifiable evidence (name/command/exitCode/evidence); gates.requireChecks can require at least one before merge. Stores the full report, capped at gates.maxReportBytes (default 32768 UTF-8 bytes); a larger report is rejected with invalid-argument and an actionable nextAction, never truncated. Persists reportBytes on the stored report. completion means ready for preflight and optional review, not merged.',
     parameters: CompleteInput,
     aliases: {"missionId":["id"]},
     requiresMissionId: true,
     board: true,
     output: output(SCHEMAS.complete),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       // Validate authorization/state before executing repository-controlled
       // test code or writing a test receipt.
       await tower.checkCompletion({

package/tools/diff.js

@@ -13,15 +13,15 @@
 // The patch cap is enforced by the pure read projection.
 // See docs/reference/tools.generated.md for the public shape.
 // tower_diff: read-only mission branch view.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { DiffInput } from '../domain/contracts/tool-inputs/index.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any }} deps
  */
 export function registerDiffTool(ctx, deps) {
+  // openTower is injected by the composition root (#69).
   const { define } = deps
   define(ctx, {
     name: 'tower_diff',
@@ -32,7 +32,7 @@ export function registerDiffTool(ctx, deps) {
     requiresMissionId: true,
     output: output(SCHEMAS.diff),
     async execute(args) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       return tower.diff({ missionId: args.missionId, maxBytes: args.maxBytes })
     },
   })

package/tools/doctor.js

@@ -1,36 +1,33 @@
 // tower_doctor: read-only health check.
-import { Tower } from '../app/tower.js'
-import { resolveRepo } from '../lib/git.js'
-import { runtimeConfig } from '../lib/config.js'
-import { runDoctor } from '../lib/doctor.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { DoctorInput } from '../domain/contracts/tool-inputs/index.js'
 import { DOCTOR_STATUS } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {import('../types/index.js').DefineTool} define
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, createTower: any, resolveRepo: any, runtimeConfig: any, runDoctor: any, surface?: () => { tools?: number } }} deps
  */
-export function registerDoctorTool(ctx, define) {
+export function registerDoctorTool(ctx, deps) {
+  const { define, createTower, resolveRepo, runtimeConfig, runDoctor } = deps
   define(ctx, {
     name: 'tower_doctor',
     description:
-      'Read-only environment and repository health check: git, state schema, config, presets/subagents/HMR, workspace lock, roster staleness, worktree ownership, test discovery, leases. Returns checks with pass/warn/fail and an environment contract. Never writes state.',
+'Read-only\ environment\ and\ repository\ health\ check:\ the\ concept-budget\ surface\ \(config\ keys/sections/tools\),\ git,\ state\ schema,\ case-sensitivity\ detection\ \(caseInsensitive\ and\ the\ active\ scope\ comparison\ mode\),\ config,\ presets/subagents/HMR,\ the\ state\ lock\ age/heartbeat\ freshness,\ the\ repo-scoped\ git\ lock\ holder\ \(gitLock:\ \{held,pid,phase,heldMs\}\),\ workspace\ lock,\ roster\ staleness,\ worktree\ ownership,\ test\ discovery,\ leases,\ and\ the\ terminal-mission\ archive\ \(count,\ bytes,\ years,\ unreadable\ diagnostics\ and\ the\ configured\ afterDays/maxMissions\ policy\)\.\ Returns\ checks\ with\ pass/warn/fail,\ state-lock\ and\ git-lock\ reports\ and\ an\ environment\ contract\.\ Never\ writes\ state\ and\ never\ probes\ the\ filesystem\.',
     parameters: DoctorInput,
     output: output(SCHEMAS.doctor),
     async execute(args, exec) {
       let tower
       let configError = null
       try {
-        tower = await Tower.open(args.repoRoot)
+        tower = await deps.openTower(args.repoRoot)
       } catch (error) {
         const message = String(error?.message ?? error)
         if (error?.code !== 'config-invalid' && error?.code !== 'config-unknown-key') throw error
         configError = message
         const repo = await resolveRepo(args.repoRoot)
-        tower = new Tower(repo, { ...runtimeConfig(), configPath: null, repoConfigPresent: true })
+        tower = deps.createTower(repo, { ...runtimeConfig(), configPath: null, repoConfigPresent: true })
       }
-      const report = await runDoctor(/** @type {any} */ ({ tower, ctx, agent: exec.agent }))
+      const report = await runDoctor(/** @type {any} */ ({ tower, ctx, agent: exec.agent, surface: deps.surface?.() }))
       if (!configError) return report
       return {
         ...report,

package/tools/finding.js

@@ -1,12 +1,11 @@
 // tower_finding: file one structured finding.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { FindingInput } from '../domain/contracts/tool-inputs/index.js'
 import { ROLE } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireKnownActor: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireKnownActor: any }} deps
  */
 export function registerFindingTool(ctx, deps) {
   const { define, actorFor, requireKnownActor } = deps
@@ -19,7 +18,7 @@ export function registerFindingTool(ctx, deps) {
     board: true,
     output: output(SCHEMAS.finding),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireKnownActor(actor, 'tower_finding')
       const view = await tower.rosterView()

package/tools/findings.js

@@ -1,14 +1,14 @@
 // tower_findings: list, read, or update findings.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { FindingsInput } from '../domain/contracts/tool-inputs/index.js'
 import { ROLE } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireKnownActor: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireKnownActor: any }} deps
  */
 export function registerFindingsTool(ctx, deps) {
+  // openTower is injected by the composition root (#69).
   const { define, actorFor, requireKnownActor } = deps
   define(ctx, {
     name: 'tower_findings',
@@ -18,7 +18,7 @@ export function registerFindingsTool(ctx, deps) {
     aliases: {"missionId":["mission_id"]},
     output: output(SCHEMAS.findings),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireKnownActor(actor, 'tower_findings')
       const view = await tower.rosterView()

package/tools/import-legacy.js

@@ -8,17 +8,15 @@
 // Pure legacy validation lives in domain and never runs fs.
 // See docs/reference/tools.generated.md for the public shape.
 // tower_import_legacy: read-only legacy snapshot import.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
-import { importLegacySnapshot } from '../lib/legacy.js'
 import { ImportLegacyInput } from '../domain/contracts/tool-inputs/index.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any, importLegacySnapshot: any }} deps
  */
 export function registerImportLegacyTool(ctx, deps) {
-  const { define, actorFor, requireTowerActor } = deps
+  const { define, actorFor, requireTowerActor, importLegacySnapshot } = deps
   define(ctx, {
     name: 'tower_import_legacy',
     description:
@@ -27,7 +25,7 @@ export function registerImportLegacyTool(ctx, deps) {
     board: true,
     output: output(SCHEMAS.importLegacy),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireTowerActor(actor, 'import a legacy snapshot')
       const imported = await importLegacySnapshot({

package/tools/inbox.js

@@ -10,16 +10,16 @@
 // The unread calculation is a pure domain/collab projection.
 // See docs/reference/tools.generated.md for the public shape.
 // tower_inbox: read and acknowledge inbound messages.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { InboxInput } from '../domain/contracts/tool-inputs/index.js'
 import { ROLE } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any }} deps
  */
 export function registerInboxTool(ctx, deps) {
+  // openTower is injected by the composition root (#69).
   const { define } = deps
   define(ctx, {
     name: 'tower_inbox',
@@ -29,7 +29,7 @@ export function registerInboxTool(ctx, deps) {
     aliases: {"include_read":["includeRead"]},
     output: output(SCHEMAS.inbox),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const view = await tower.rosterView()
       const self = view.roster.find((entry) => entry.agentId === String(exec.agent.id))
       const reader = self ? self.name : ROLE.tower

package/tools/index.js

@@ -9,9 +9,9 @@
 // - tools must not import node:fs or node:child_process directly.
 // 
 // Tests import this module for the public surface; they may also
-// import lib/tool-registry.js for low-level test hooks.
+// import host/tool-registry.js for low-level test hooks.
 // 
-// Packaging: package.json ships tools/*.js and lib/tool-registry.js.
+// Packaging: package.json ships tools/*.js and host/tool-registry.js.
 // The file intentionally stays tiny so handler modules remain the
 // only place where a tool is defined.
 // Keep this comment and the re-export list in sync when adding tools.
@@ -20,7 +20,7 @@
 // 
 // The registration aggregator, guards, rate limits, spawn backoff,
 // repository preparation, discovery helpers, and verb helpers live in
-// lib/tool-registry.js. This module only re-exports the public entry
+// host/tool-registry.js. This module only re-exports the public entry
 // points consumed by the Host plugin, tests, and docs generators.
 // 
 // Design rules:
@@ -30,10 +30,10 @@
 // - no business logic in this file;
 // - keep the surface stable for index.js and tests.
 // 
-// See docs/architecture/overview.md and lib/tool-registry.js.
+// See docs/architecture/overview.md and host/tool-registry.js.
 // Tower tool surface: thin public wiring (#56 P5).
-// Registration and shared machinery live in lib/tool-registry.js; one handler
+// Registration and shared machinery live in host/tool-registry.js; one handler
 // module per tool lives under tools/. This file only exposes the public entry
 // points consumed by the Host plugin, tests, and documentation generators.
-export { registerTowerTools, __testSpawnBackoff } from '../lib/tool-registry.js'
-export { workerBriefing, reviewerBriefing } from '../lib/briefing.js'
+export { registerTowerTools, __testSpawnBackoff } from '../host/tool-registry.js'
+export { workerBriefing, reviewerBriefing } from '../app/briefing.js'

package/tools/init.js

@@ -1,22 +1,19 @@
 // tower_init: repository initialization.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { TowerToolError } from '../domain/errors.js'
-import { resolveRepo } from '../lib/git.js'
-import { runtimeConfig } from '../lib/config.js'
 import { InitInput } from '../domain/contracts/tool-inputs/index.js'
 import { isTowerRole, isUnknownRole } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any, workspaceHook: any, ensureRepository: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any, workspaceHook: any, ensureRepository: any, resolveRepo: any, runtimeConfig: any }} deps
  */
 export function registerInitTool(ctx, deps) {
-  const { define, actorFor, requireTowerActor, workspaceHook, ensureRepository } = deps
+  const { define, actorFor, requireTowerActor, workspaceHook, ensureRepository, resolveRepo, runtimeConfig } = deps
   define(ctx, {
     name: 'tower_init',
     description:
-      'Initialize Tower mission state for a repository (absolute repoRoot). Creates <git-common-dir>/dsh-tower/state.json and an activity log; idempotent on an existing workspace. Options: autoGitInit (git init + empty initial commit when the directory is not a repository), snapshotDirty (snapshot uncommitted work into a dangling commit used as the mission baseline), reanchor (change base when every mission is merged/abandoned). Only the tower may initialize.',
+      'Initialize Tower mission state for a repository (absolute repoRoot). Creates <git-common-dir>/dsh-tower/state.json and an activity log; idempotent on an existing workspace. Probes whether the checkout filesystem folds case and records caseInsensitive once, so scope matching follows the real filesystem (a skipped probe records null and keeps the safe case-sensitive comparison). Options: autoGitInit (git init + empty initial commit when the directory is not a repository), snapshotDirty (snapshot uncommitted work into a dangling commit used as the mission baseline), reanchor (change base when every mission is merged/abandoned). Only the tower may initialize.',
     parameters: InitInput,
     aliases: { auto_git_init: ['autoGitInit'], snapshot_dirty: ['snapshotDirty'] },
     board: true,
@@ -31,7 +28,7 @@ export function registerInitTool(ctx, deps) {
           args.autoGitInit === true || (args.autoGitInit === undefined && profileInit.autoGitInit === true)
         repo = await ensureRepository(args.repoRoot, autoGitInit)
       }
-      const tower = await Tower.open(repo.root)
+      const tower = await deps.openTower(repo.root)
       const initConfig = tower.config.init ?? {}
       const snapshotDirty =
         args.snapshotDirty === true || (args.snapshotDirty === undefined && initConfig.snapshotDirty === true)

package/tools/interrupt.js

@@ -8,14 +8,13 @@
 // Roster state policy is pure and lives in domain/collab.
 // See docs/reference/tools.generated.md for the public shape.
 // tower_interrupt: interrupt one running roster agent.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { TowerToolError } from '../domain/errors.js'
 import { InterruptInput } from '../domain/contracts/tool-inputs/index.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any, interruptRosterAgent: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any, interruptRosterAgent: any }} deps
  */
 export function registerInterruptTool(ctx, deps) {
   const { define, actorFor, requireTowerActor, interruptRosterAgent } = deps
@@ -27,7 +26,7 @@ export function registerInterruptTool(ctx, deps) {
     aliases: { agentId: ['agent_id'] },
     output: output(SCHEMAS.interrupt),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireTowerActor(actor, 'interrupt tower agents')
       if (!args.to && !args.agentId) throw new TowerToolError('invalid-argument', 'tower_interrupt requires to (roster name) or agentId')

package/tools/legacy-map.js

@@ -8,19 +8,17 @@
 // Pure mapping validation lives in the domain legacy layer.
 // See docs/reference/tools.generated.md for the public shape.
 // tower_legacy_map: audit-only legacy snapshot mapping.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { TowerToolError } from '../domain/errors.js'
-import { validateLegacyMap } from '../lib/legacy.js'
 import { LegacyMapInput } from '../domain/contracts/tool-inputs/index.js'
 import { LEGACY_MAP_ACTION } from '../domain/vocabulary.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any, validateLegacyMap: any }} deps
  */
 export function registerLegacyMapTool(ctx, deps) {
-  const { define, actorFor, requireTowerActor } = deps
+  const { define, actorFor, requireTowerActor, validateLegacyMap } = deps
   define(ctx, {
     name: 'tower_legacy_map',
     description:
@@ -28,7 +26,7 @@ export function registerLegacyMapTool(ctx, deps) {
     parameters: LegacyMapInput,
     output: output(SCHEMAS.legacyMap),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       const state = await tower.load()
       if (args.action === LEGACY_MAP_ACTION.status) {

package/tools/merge.js

@@ -9,15 +9,15 @@
 // The pure intent/shape decisions live in domain/integration.
 // See docs/reference/tools.generated.md for the public shape.
 // tower_merge: merge a mission branch into the recorded base.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { MergeInput } from '../domain/contracts/tool-inputs/index.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any, observeActivity: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any, observeActivity: any }} deps
  */
 export function registerMergeTool(ctx, deps) {
+  // openTower is injected by the composition root (#69).
   const { define, actorFor, requireTowerActor, observeActivity } = deps
   define(ctx, {
     name: 'tower_merge',
@@ -29,7 +29,7 @@ export function registerMergeTool(ctx, deps) {
     board: true,
     output: output(SCHEMAS.merge),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireTowerActor(actor, 'merge missions')
       const { activity, parentStatus } = await observeActivity(ctx, tower)

package/tools/mission.js

@@ -1,12 +1,11 @@
 // tower_mission: mission lifecycle updates.
-import { Tower } from '../app/tower.js'
 import { TowerToolError } from '../domain/errors.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { MissionInput } from '../domain/contracts/tool-inputs/index.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireKnownActor: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireKnownActor: any }} deps
  */
 export function registerMissionTool(ctx, deps) {
   const { define, actorFor, requireKnownActor } = deps
@@ -19,7 +18,7 @@ export function registerMissionTool(ctx, deps) {
     board: true,
     output: output(SCHEMAS.mission),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireKnownActor(actor, 'tower_mission')
       return tower.mission({

package/tools/plan.js

@@ -10,26 +10,27 @@
 // Pure normalization and DAG policy live in domain/missions.
 // See docs/reference/tools.generated.md for the public shape.
 // tower_plan: create missions.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
-import { assertPresetsAvailable } from '../lib/presets.js'
 import { PlanInput } from '../domain/contracts/tool-inputs/index.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, actorFor: any, requireTowerActor: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, actorFor: any, requireTowerActor: any, assertPresetsAvailable: any }} deps
  */
 export function registerPlanTool(ctx, deps) {
-  const { define, actorFor, requireTowerActor } = deps
+  // #70: preset validation is injected by the composition root, so this tool
+  // never imports host/ or adapters/ directly.
+  // openTower is injected by the composition root (#69).
+  const { define, actorFor, requireTowerActor, assertPresetsAvailable } = deps
   define(ctx, {
     name: 'tower_plan',
     description:
-      'Plan one or more missions in an initialized repository. Each mission has a printable-ASCII title, relative scope globs, optional task checklist, optional mission-id dependencies, and kind build|survey. Assigns M1.. ids and auto-adds a dependency when build scopes overlap (serializes merges); rejects dependency cycles.',
+      'Plan one or more missions in an initialized repository. Each mission has a printable-Unicode title (NFC-normalized, at most 120 characters), relative scope globs, optional task checklist, optional mission-id dependencies, and kind build|survey. Assigns M1.. ids and auto-adds a dependency when build scopes overlap (serializes merges); rejects dependency cycles.',
     parameters: PlanInput,
     board: true,
     output: output(SCHEMAS.plan),
     async execute(args, exec) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const actor = await actorFor(tower, exec)
       requireTowerActor(actor, 'plan missions')
       await assertPresetsAvailable(ctx, tower.config)

package/tools/preflight.js

@@ -1,12 +1,11 @@
 // tower_preflight: read-only merge gate digest.
-import { Tower } from '../app/tower.js'
 import { SCHEMAS, output } from '../domain/contracts/outputs.js'
 import { classifyError } from '../domain/errors.js'
 import { PreflightInput } from '../domain/contracts/tool-inputs/index.js'
 
 /**
  * @param {any} ctx
- * @param {{ define: import('../types/index.js').DefineTool, observeActivity: any }} deps
+ * @param {{ define: import('../types/index.js').DefineTool, openTower: any, observeActivity: any }} deps
  */
 export function registerPreflightTool(ctx, deps) {
   const { define, observeActivity } = deps
@@ -19,7 +18,7 @@ export function registerPreflightTool(ctx, deps) {
     requiresMissionId: true,
     output: output(SCHEMAS.preflight),
     async execute(args) {
-      const tower = await Tower.open(args.repoRoot)
+      const tower = await deps.openTower(args.repoRoot)
       const { activity, parentStatus } = await observeActivity(ctx, tower)
       const gate = await tower.evaluateGate({ missionId: args.missionId, activity, parentStatus })
       return {
@@ -38,6 +37,7 @@ export function registerPreflightTool(ctx, deps) {
               reviewedCommit: gate.review.reviewedCommit,
             }
           : null,
+        ...(gate.archived ? { archived: true } : {}),
       }
     },
   })