dsh-tower 1.1.2 → 1.3.0

package/lib/modeStore.js

@@ -1,29 +1,32 @@
 // Tower mode persistence.
 //
 // The session-projection route needs zod schemas, which this bundle cannot
-// resolve from the DSH installation; a small atomic JSON store under
-// DSH_HOME/tower-mode keeps the mode across restarts without adding a
-// dependency or touching profile state.
+// resolve from the DSH installation on every deployment; a small atomic JSON
+// store under DSH_HOME/tower-mode keeps the mode across restarts.
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 
-const MAX_ENTRIES = 200
+const DEFAULT_MAX_ENTRIES = 200
 
-function storeDir() {
+function defaultStoreDir() {
   const home = process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
   return path.join(home, 'tower-mode')
 }
 
-function storeFile() {
-  return path.join(storeDir(), 'modes.json')
+function storeDir(baseDir) {
+  return baseDir && String(baseDir).trim() ? path.resolve(String(baseDir)) : defaultStoreDir()
+}
+
+function storeFile(baseDir) {
+  return path.join(storeDir(baseDir), 'modes.json')
 }
 
 /** Read persisted modes into a Map keyed by agent/session id. */
-export function loadModes() {
+export function loadModes(baseDir) {
   const modes = new Map()
   try {
-    const raw = fs.readFileSync(storeFile(), 'utf8')
+    const raw = fs.readFileSync(storeFile(baseDir), 'utf8')
     const parsed = JSON.parse(raw)
     const entries = parsed && typeof parsed === 'object' && parsed.modes && typeof parsed.modes === 'object'
       ? parsed.modes
@@ -45,15 +48,16 @@ export function loadModes() {
 }
 
 /** Persist the current modes atomically; failures never break the command. */
-export function saveModes(modes) {
+export function saveModes(modes, baseDir, maxEntries = DEFAULT_MAX_ENTRIES) {
   try {
-    const dir = storeDir()
+    const dir = storeDir(baseDir)
     fs.mkdirSync(dir, { recursive: true })
+    const limit = Number.isInteger(maxEntries) && maxEntries > 0 ? maxEntries : DEFAULT_MAX_ENTRIES
     const entries = [...modes.entries()]
       .sort((a, b) => (Number(b[1]?.at) || 0) - (Number(a[1]?.at) || 0))
-      .slice(0, MAX_ENTRIES)
+      .slice(0, limit)
     const payload = { version: 1, modes: Object.fromEntries(entries) }
-    const file = storeFile()
+    const file = storeFile(baseDir)
     const tmp = `${file}.tmp-${process.pid}`
     fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8')
     fs.renameSync(tmp, file)
@@ -63,6 +67,6 @@ export function saveModes(modes) {
   }
 }
 
-export function storePath() {
-  return storeFile()
+export function storePath(baseDir) {
+  return storeFile(baseDir)
 }

package/lib/tools.js

@@ -1,5 +1,6 @@
 // Tower tools: init, plan, mission, status, spawn, roster, adopt.
 import { Tower } from './tower.js'
+import { runtimeConfig } from './config.js'
 
 const OUTPUT = {
   schema: { type: 'object' },
@@ -251,7 +252,7 @@ export function registerTowerTools(ctx) {
   define(ctx, {
     name: 'tower_spawn',
     description:
-      'Spawn a worker or reviewer for a mission. Provisions (or reuses) the mission git worktree and branch, generates a self-contained briefing (mission tasks, scope, deps, context, rules), and starts a background tower-worker subagent in that worktree. Records the agent in the roster and marks the mission active. Returns immediately unless wait=true.',
+      'Spawn a worker or reviewer for a mission. Workers use the tower-worker preset; reviewers require a completed mission and use the read-only tower-reviewer preset. Provisions (or reuses) the mission git worktree and branch, generates a self-contained briefing, and starts a background subagent in that worktree. The child final report is delivered back to this session; tower_roster shows authoritative activity. Records the agent in the roster; reviewer spawns record the branch tip so a reviewer that modifies the branch cannot submit a review. Returns immediately unless wait=true.',
     parameters: {
       type: 'object',
       properties: {
@@ -272,9 +273,17 @@ export function registerTowerTools(ctx) {
       const tower = await Tower.open(args.repoRoot)
       const role = args.role ?? 'worker'
       if (!ROLE_ENUM.includes(role)) fail(`role must be one of ${ROLE_ENUM.join('|')}`)
+      const config = runtimeConfig()
+      const preset = role === 'reviewer' ? config.spawn.reviewerPreset : config.spawn.workerPreset
+      const model = role === 'reviewer' ? config.spawn.reviewerModel : config.spawn.workerModel
       const context = await tower.missionContext(args.missionId)
-      if (role === 'reviewer' && !context.mission.worktree) {
-        fail('reviewer needs an existing mission worktree; spawn a worker first')
+      if (role === 'reviewer') {
+        if (!context.mission.worktree) {
+          fail('reviewer needs an existing mission worktree; spawn a worker first')
+        }
+        if (context.mission.status !== 'completed') {
+          fail(`reviewer requires a completed mission awaiting review; ${context.mission.id} is ${context.mission.status}`)
+        }
       }
       const provisioned = await tower.provision({
         missionId: args.missionId,
@@ -311,25 +320,35 @@ export function registerTowerTools(ctx) {
       const subagents = ctx.get('subagents')
       if (!subagents) fail('subagents service is unavailable; cannot spawn')
       const providers = subagents.list()
-      const provider = providers.includes('spawn') ? 'spawn' : providers[0]
+      const provider = config.spawn.provider || (providers.includes('spawn') ? 'spawn' : providers[0])
       if (!provider) fail('no subagent provider is registered')
+      const presets = ctx.get('agentPresets')
+      if (presets && typeof presets.list === 'function') {
+        const available = await presets.list()
+        if (!available.some((entry) => String(entry.id) === preset)) {
+          fail(`agent preset "${preset}" is not registered; check the Tower bundle's preset rows and restart DSH`)
+        }
+      }
+
+      const agentOptions = {}
+      for (const key of ['provider', 'model', 'reasoningEffort', 'maxTokens']) {
+        if (model && model[key] !== undefined && model[key] !== null && model[key] !== '') agentOptions[key] = model[key]
+      }
 
       const activation = await subagents.startActivation({
         provider,
         label: name,
         request: {
           cwd: worktree.path,
-          agentPreset: 'tower-worker',
+          agentPreset: preset,
           prompt: [{ type: 'text', text: briefing }],
           parent: exec.agent,
-          maxDepth: 1,
+          maxDepth: config.spawn.maxDepth ?? 1,
+          ...(Object.keys(agentOptions).length > 0 ? { agentOptions } : {}),
         },
         signal: exec.signal,
         delivery: 'parent',
       })
-      if (activation.result && typeof activation.result.catch === 'function') {
-        activation.result.catch(() => {})
-      }
 
       const agentId = String(activation.childId)
       const entry = await tower.recordSpawn({
@@ -342,16 +361,22 @@ export function registerTowerTools(ctx) {
         branch: worktree.branch,
       })
 
+      const recordOutcome = (state, detail) =>
+        tower.recordSpawnOutcome({ missionId: mission.id, name, state, detail }).catch(() => {})
+
       const report = {
         name,
         agentId,
         role,
         missionId: mission.id,
+        preset,
+        provider,
+        maxDepth: config.spawn.maxDepth ?? 1,
+        ...(Object.keys(agentOptions).length > 0 ? { agentOptions } : {}),
         worktree: { path: worktree.path, branch: worktree.branch, baseCommit: worktree.baseCommit },
         created: provisioned.created,
         briefingChars: briefing.length,
         rosterEntry: entry,
-        provider,
       }
 
       if (args.wait === true) {
@@ -363,16 +388,32 @@ export function registerTowerTools(ctx) {
         let result
         try {
           result = await Promise.race([activation.result, timeout])
+        } catch (error) {
+          report.stopReason = 'failed'
+          report.diagnostic = String(error?.message ?? error)
+          await recordOutcome('failed', report.diagnostic)
+          throw error
         } finally {
           clearTimeout(timer)
         }
         if (result && result.__timeout) {
           report.timedOut = true
+          recordOutcome('unknown', 'spawn wait timed out; check tower_roster')
         } else {
           report.stopReason = result?.stopReason ?? null
           report.output = textOf(result?.output)
           report.diagnostic = result?.diagnostic ?? null
+          const state = report.stopReason === 'completed' ? 'inactive' : 'failed'
+          if (state === 'failed') report.diagnostic = report.diagnostic ?? report.stopReason
+          await recordOutcome(state, report.diagnostic ?? null)
         }
+      } else {
+        activation.result
+          .then((result) => {
+            const state = result?.stopReason === 'completed' ? 'inactive' : 'failed'
+            return recordOutcome(state, result?.diagnostic ?? result?.stopReason ?? null)
+          })
+          .catch((error) => recordOutcome('failed', String(error?.message ?? error)))
       }
       return report
     },
@@ -423,6 +464,27 @@ export function registerTowerTools(ctx) {
     },
   })
 
+  define(ctx, {
+    name: 'tower_diff',
+    description:
+      'Read-only view of a mission branch for review: merge base, changed files, commits, and a capped patch against the recorded base. Safe for reviewers; it never modifies the repository.',
+    parameters: {
+      type: 'object',
+      properties: {
+        repoRoot: { type: 'string', description: 'Absolute path to the main checkout root.' },
+        missionId: { type: 'string', description: 'Mission id, e.g. M1.' },
+        maxBytes: { type: 'integer', minimum: 1024, description: 'Patch cap in bytes (default 65536).' },
+      },
+      required: ['repoRoot', 'missionId'],
+      additionalProperties: false,
+    },
+    output: OUTPUT,
+    async execute(args) {
+      const tower = await Tower.open(args.repoRoot)
+      return tower.diff({ missionId: args.missionId, maxBytes: args.maxBytes })
+    },
+  })
+
   define(ctx, {
     name: 'tower_adopt',
     description:
@@ -732,12 +794,17 @@ export function registerTowerTools(ctx) {
   define(ctx, {
     name: 'tower_merge',
     description:
-      'Merge a mission branch into the recorded base branch with --no-ff, after the hard gate passes. Verifies the two merge parents and records the mission as merged. A failed gate returns stable blocker codes instead of merging; a Git conflict aborts the merge and marks the mission blocked.',
+      'Merge a mission branch into the recorded base branch with --no-ff, after the hard gate passes. Verifies the two merge parents and records the mission as merged. If the merge commit already landed (manual merge, crashed or slow pre-merge hook), it detects the merge commit and records it as reconciled instead of merging again. A failed gate returns stable blocker codes without merging; a hook failure aborts cleanly and returns "merge-hook-failed" while a real content conflict returns "merge-conflict".',
     parameters: {
       type: 'object',
       properties: {
         repoRoot: { type: 'string', description: 'Absolute path inside the target Git repository.' },
         missionId: { type: 'string', description: 'Mission id, e.g. M1.' },
+        timeoutMs: {
+          type: 'integer',
+          minimum: 1000,
+          description: 'Optional timeout for the merge command in milliseconds, including pre-merge hooks (default 15 minutes).',
+        },
       },
       required: ['repoRoot', 'missionId'],
       additionalProperties: false,
@@ -746,14 +813,14 @@ export function registerTowerTools(ctx) {
     async execute(args) {
       const tower = await Tower.open(args.repoRoot)
       const { activity } = await observeActivity(ctx, tower)
-      return tower.merge({ missionId: args.missionId, activity })
+      return tower.merge({ missionId: args.missionId, activity, timeoutMs: args.timeoutMs })
     },
   })
 
   define(ctx, {
     name: 'tower_rebase',
     description:
-      'Rebase a mission branch onto the current base tip inside its own worktree. Refuses while its worker is running or the worktree is dirty. A clean conflict-free rebase waives re-review for the old review; a conflict is aborted and the mission is marked blocked.',
+      'Rebase a mission branch onto the current base tip inside its own worktree. Refuses while its worker is running or the worktree is dirty. A clean conflict-free rebase waives re-review for the old review; a conflict is aborted and the mission is marked blocked. If the branch is already contained in the base, it returns alreadyMerged and leaves the branch untouched so tower_merge can record the landed merge.',
     parameters: {
       type: 'object',
       properties: {