dsh-tower 1.3.0 → 2.0.0

package/index.js

@@ -6,10 +6,24 @@
 // forwarded to the model as the next user message. With
 // config.allowAgentControl the model may also enter or leave the mode through
 // `tower_control` when the user intent or task state clearly calls for it.
+//
+// `/tower reload` asks DSH HMR to reconcile this profile and reload the Tower
+// plugin from disk when the HMR service is present (dev/linked installs).
+import fs from 'node:fs'
 import { randomUUID } from 'node:crypto'
 import { registerTowerTools } from './lib/tools.js'
 import { loadModes, saveModes, storePath } from './lib/modeStore.js'
 import { Config as ConfigSchema, DEFAULT_DENY_TOOLS, configureRuntime, runtimeConfig } from './lib/config.js'
+import { TowerToolError } from './lib/errors.js'
+import { resolveRepo } from './lib/git.js'
+import {
+  acquireWorkspaceLock,
+  inspectWorkspaceLock,
+  releaseWorkspaceLock,
+  touchWorkspaceLock,
+  workspaceLockToken,
+} from './lib/workspaceLock.js'
+import { createHmrBridge } from './lib/hmr.js'
 
 export const name = 'dsh-tower'
 export const inject = ['tools', 'systemPrompt']
@@ -17,6 +31,14 @@ export const Config = ConfigSchema
 
 let MODE = new Map()
 let denyTools = new Set(DEFAULT_DENY_TOOLS)
+const READ_ONLY_TOOL_NAMES = new Set([
+  'tower_status',
+  'tower_roster',
+  'tower_diff',
+  'tower_preflight',
+  'tower_doctor',
+])
+let pluginVersion = null
 
 const BASE_REMINDER = [
   'Tower mode is active for this session. You are the control tower: plan missions, spawn workers and reviewers, and integrate only through the Tower tools.',
@@ -28,6 +50,17 @@ const BASE_REMINDER = [
 const AGENT_CONTROL_NOTE =
   'If tower_control is available you may also enter or leave Tower mode yourself when the user intent or task state clearly calls for it, and you must state a concrete reason.'
 
+function readPluginVersion() {
+  if (pluginVersion !== null) return pluginVersion
+  try {
+    const pkg = JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8'))
+    pluginVersion = typeof pkg.version === 'string' ? pkg.version : null
+  } catch {
+    pluginVersion = null
+  }
+  return pluginVersion
+}
+
 function agentKey(agent) {
   if (!agent) return null
   const key = agent.id ?? agent.session
@@ -53,9 +86,10 @@ function persistModes() {
 /** Parse `/tower` arguments: bare and free text both mean "ensure on". */
 function parseTowerInput(rawInput) {
   const raw = String(rawInput ?? '').trim()
+  if (/^reload$/i.test(raw)) return { action: 'reload' }
   const match = /^(on|off)(?:\s+([\s\S]*))?$/i.exec(raw)
-  if (match) return { active: match[1].toLowerCase() === 'on', message: (match[2] ?? '').trim() }
-  return { active: true, message: raw }
+  if (match) return { action: 'mode', active: match[1].toLowerCase() === 'on', message: (match[2] ?? '').trim() }
+  return { action: 'mode', active: true, message: raw }
 }
 
 /**
@@ -87,9 +121,44 @@ function pauseActiveGoal(ctx, agent) {
   }
 }
 
+function planModeState(ctx, agent) {
+  const service = ctx.get?.('planMode')
+  if (!service || !agent) return { available: false, active: false, pending: false, service: null }
+  try {
+    const state = service.get(agent) ?? {}
+    return { available: true, active: state.active === true, pending: state.pending === true, service }
+  } catch {
+    return { available: false, active: false, pending: false, service: null }
+  }
+}
+
+/** Tower and plan mode are mutually exclusive; clearing is the default policy. */
+function clearPlanModeForTower(ctx, agent) {
+  const state = planModeState(ctx, agent)
+  if (!state.available || (!state.active && !state.pending)) {
+    return { attempted: state.available, cleared: false, refused: false, result: null }
+  }
+  if (runtimeConfig().mode.planModePolicy === 'refuse') {
+    return { attempted: true, cleared: false, refused: true, result: null }
+  }
+  try {
+    const result = state.service.set(agent, false)
+    return { attempted: true, cleared: true, refused: false, result }
+  } catch (error) {
+    return { attempted: true, cleared: false, refused: false, error: String(error?.message ?? error) }
+  }
+}
+
 function enterMode(ctx, key, agent, by, reason) {
   const previous = MODE.get(key)
   const wasOn = Boolean(previous && previous.on)
+  const plan = clearPlanModeForTower(ctx, agent)
+  if (plan.refused) {
+    throw new TowerToolError(
+      'invalid-transition',
+      'plan mode is active and mode.planModePolicy is "refuse"; exit plan mode before entering Tower',
+    )
+  }
   const autoPauseGoal = runtimeConfig().mode.autoPauseGoal !== false
   let pausedGoal = previous?.pausedGoal ?? null
   let goalNote = null
@@ -105,18 +174,24 @@ function enterMode(ctx, key, agent, by, reason) {
   MODE.set(key, {
     on: true,
     pausedGoal,
+    lock: previous?.lock ?? null,
+    baseBranch: previous?.baseBranch ?? null,
+    planModeCleared: plan.cleared,
     lastChange: { by, action: 'on', reason: reason ?? null, at: now },
     at: now,
   })
   persistModes()
-  return { wasOn, pausedGoal, goalNote }
+  return { wasOn, pausedGoal, goalNote, planModeCleared: plan.cleared, planModeResult: plan.result ?? null }
 }
 
-function exitMode(key, by, reason) {
+async function exitMode(key, by, reason) {
   const previous = MODE.get(key)
   if (!previous) return { wasOn: false, pausedGoal: null, goalNote: null }
   MODE.delete(key)
   persistModes()
+  if (previous.lock) {
+    await releaseWorkspaceLock(previous.lock.commonDir, { token: previous.lock.token }).catch(() => {})
+  }
   return { wasOn: true, pausedGoal: previous.pausedGoal ?? null, goalNote: null, by, reason: reason ?? null }
 }
 
@@ -164,7 +239,87 @@ export function apply(ctx, rawConfig) {
   const reminder = configSection(config, allowAgentControl)
   MODE = loadModes(config.mode.storePath || undefined)
   denyTools = new Set(config.mode.denyTools)
-  registerTowerTools(ctx)
+  const hotReloadEnabled = config.dev?.hotReload !== false
+  const hmrBridge = hotReloadEnabled
+    ? createHmrBridge(ctx, {
+        requiredIds: config.dev?.reloadRequiredIds,
+        delayMs: config.dev?.reloadDelayMs,
+        logger: ctx.logger ?? console,
+      })
+    : null
+
+  const workspace = {
+    /** Lazily acquire the advisory workspace lock on the first repo-scoped tool. */
+    async ensure(repoRoot, exec, toolName) {
+      if (runtimeConfig().mode.workspaceLock !== true) return
+      if (runtimeConfig().mode.workspaceLockScope === 'mutations' && READ_ONLY_TOOL_NAMES.has(toolName)) return
+      const key = agentKey(exec?.agent)
+      if (!key) return
+      const entry = MODE.get(key)
+      if (!entry) return
+      const repo = await resolveRepo(repoRoot)
+      const existing = entry.lock
+      if (existing && existing.commonDir !== repo.commonDir) {
+        throw new TowerToolError(
+          'workspace-busy',
+          `this Tower session already owns ${existing.commonDir}; /tower off before switching repositories`,
+        )
+      }
+      const result = await acquireWorkspaceLock(repo.commonDir, {
+        token: existing?.token ?? workspaceLockToken(),
+        sessionId: key,
+        agentId: key,
+        staleMs: Number(runtimeConfig().mode.workspaceStaleMs) || 300000,
+      })
+      if (!result.acquired) {
+        const holder = result.holder
+          ? `session ${String(result.holder.sessionId).slice(0, 12)} (since ${
+              Number.isFinite(Number(result.holder.at))
+                ? new Date(Number(result.holder.at)).toISOString()
+                : 'unknown'
+            })`
+          : 'an unreadable lock'
+        throw new TowerToolError(
+          'workspace-busy',
+          `workspace ${repo.root} is locked by ${holder}; another Tower session must /tower off or set mode.workspaceLock:false`,
+        )
+      }
+      entry.lock = { token: result.record.token, commonDir: repo.commonDir }
+      persistModes()
+    },
+    async status(entry, key) {
+      if (!entry?.lock) return { enabled: runtimeConfig().mode.workspaceLock === true, held: false }
+      const info = await inspectWorkspaceLock(entry.lock.commonDir, {
+        sessionId: key ?? null,
+        staleMs: Number(runtimeConfig().mode.workspaceStaleMs) || 300000,
+      }).catch(() => null)
+      return {
+        enabled: runtimeConfig().mode.workspaceLock === true,
+        held: info?.held === true,
+        commonDir: entry.lock.commonDir,
+        self: info?.self === true,
+        stale: info?.stale === true || info === null,
+        holder: info?.holder ?? null,
+      }
+    },
+    basePreference(exec) {
+      const key = agentKey(exec?.agent)
+      return key ? MODE.get(key)?.baseBranch ?? null : null
+    },
+  }
+
+  registerTowerTools(ctx, { workspace, hmrBridge })
+
+  // On dispose (including an HMR reload) release advisory workspace locks this
+  // process still owns; a reloaded plugin restores the entries from modes.json.
+  ctx.effect(() => () => {
+    if (hmrBridge) hmrBridge.dispose?.()
+    for (const entry of MODE.values()) {
+      if (entry?.lock) {
+        releaseWorkspaceLock(entry.lock.commonDir, { token: entry.lock.token }).catch(() => {})
+      }
+    }
+  })
 
   ctx.effect(() =>
     ctx.tools.guard((execution) => {
@@ -183,20 +338,66 @@ export function apply(ctx, rawConfig) {
     }),
   )
 
+  // Plan mode and Tower mode are mutually exclusive. Clearing at entry covers
+  // the normal path; this pre-step listener also clears a plan activated later
+  // in the same session, before the next step can run plan-policy tooling.
+  ctx.effect(() =>
+    typeof ctx.on === 'function'
+      ? ctx.on('agent/pre-step', (payload, next) => {
+          const key = agentKey(payload?.agent)
+          if (key && MODE.has(key)) {
+            // Once Tower is active, Tower wins regardless of entry policy: clear
+            // any plan state so the two policies cannot coexist.
+            const state = planModeState(ctx, payload.agent)
+            if (state.available && (state.active || state.pending)) state.service.set(payload.agent, false)
+          }
+          return next()
+        })
+      : () => {},
+  )
+
   ctx.systemPrompt.section({
     name: 'tower:mode',
     order: 15000,
     text: (context) => (context && MODE.has(agentKey(context.agent)) ? reminder : ''),
   })
 
+  // Workspace-lock heartbeat; only sessions holding a lock do I/O.
+  ctx.effect(() => {
+    const timer = setInterval(() => {
+      for (const entry of MODE.values()) {
+        if (!entry?.lock) continue
+        touchWorkspaceLock(entry.lock.commonDir, { token: entry.lock.token }).catch(() => {})
+      }
+    }, Math.max(1000, Number(config.mode.heartbeatMs) || 10000))
+    if (typeof timer.unref === 'function') timer.unref()
+    return () => clearInterval(timer)
+  })
+
   ctx.effect(() =>
     ctx.tools.register({
       name: 'tower_mode',
       description:
-        'Report whether Tower mode is active for the calling agent, who changed it last, whether the model may toggle it, and any goal paused on entry.',
+        'Report whether Tower mode is active for the calling agent, who changed it last, whether the model may toggle it, any goal paused on entry, the workspace lock, HMR availability and the plugin version.',
       parameters: { type: 'object', properties: {}, additionalProperties: false },
       output: {
-        schema: { type: 'object' },
+        schema: {
+          type: 'object',
+          properties: {
+            mode: { type: 'string', enum: ['on', 'off', 'unknown'] },
+            agentId: {},
+            allowAgentControl: { type: 'boolean' },
+            lastChange: {},
+            pausedGoal: {},
+            deniedWhileActive: { type: 'array', items: { type: 'string' } },
+            persistedAt: { type: 'string' },
+            pluginVersion: {},
+            hotReload: {},
+            workspaceLock: {},
+          },
+          required: ['mode', 'allowAgentControl', 'deniedWhileActive'],
+          additionalProperties: true,
+        },
         render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
       },
       async execute(_args, exec) {
@@ -210,6 +411,16 @@ export function apply(ctx, rawConfig) {
           pausedGoal: entry?.pausedGoal ?? null,
           deniedWhileActive: [...denyTools],
           persistedAt: storePath(config.mode.storePath || undefined),
+          pluginVersion: readPluginVersion(),
+          hotReload: hmrBridge ? hmrBridge.status() : { available: false, disabled: true },
+          planMode: (() => {
+            const state = planModeState(ctx, exec.agent)
+            return { available: state.available, active: state.active, pending: state.pending }
+          })(),
+          baseBranch: entry?.baseBranch ?? null,
+          workspaceLock: entry
+            ? await workspace.status(entry, key)
+            : { enabled: config.mode.workspaceLock === true, held: false },
         }
       },
     }),
@@ -231,7 +442,22 @@ export function apply(ctx, rawConfig) {
           additionalProperties: false,
         },
         output: {
-          schema: { type: 'object' },
+          schema: {
+            type: 'object',
+            properties: {
+              ok: { type: 'boolean' },
+              action: { type: 'string', enum: ['enter', 'exit'] },
+              mode: { type: 'string', enum: ['on', 'off'] },
+              changed: { type: 'boolean' },
+              changedBy: { type: 'string', enum: ['agent', 'user'] },
+              reason: { type: 'string' },
+              pausedGoal: {},
+              goalNote: {},
+              error: { type: 'string' },
+            },
+            required: ['ok'],
+            additionalProperties: true,
+          },
           render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
         },
         async execute(args, exec) {
@@ -244,7 +470,7 @@ export function apply(ctx, rawConfig) {
           const outcome =
             args.action === 'enter'
               ? enterMode(ctx, key, exec.agent, 'agent', reason)
-              : exitMode(key, 'agent', reason)
+              : await exitMode(key, 'agent', reason)
           return {
             ok: true,
             action: args.action,
@@ -263,15 +489,37 @@ export function apply(ctx, rawConfig) {
   ctx.inject(['commands'], (commandCtx) => {
     commandCtx.commands.register({
       name: 'tower',
-      description: 'Enter or leave Tower mode, optionally carrying a user instruction',
-      input: { hint: '[on|off] [message]', attachments: true },
+      description: 'Enter or leave Tower mode, optionally carrying a user instruction; /tower reload reloads via HMR; /tower base <branch> sets the next init base',
+      input: { hint: '[on|off|reload|base <branch>] [message]', attachments: true },
       handler: async ({ agent, rawInput, attachments }) => {
         const key = agentKey(agent)
         if (!key) return { kind: 'error', text: 'Tower mode requires a live agent.' }
-        const { active, message } = parseTowerInput(rawInput)
+        const baseMatch = String(rawInput ?? '').trim().match(/^base\s+(\S+)\s*$/i)
+        if (baseMatch) {
+          const entry = MODE.get(key)
+          if (!entry) return { kind: 'error', text: 'Run /tower on first, then /tower base <branch>.' }
+          entry.baseBranch = baseMatch[1]
+          persistModes()
+          return { kind: 'success', text: `Tower base preference set to "${entry.baseBranch}"; tower_init without an explicit base will use it.` }
+        }
+        const parsed = parseTowerInput(rawInput)
+        if (parsed.action === 'reload') {
+          if (!hotReloadEnabled) {
+            return { kind: 'error', text: 'Tower reload is disabled by dev.hotReload:false; restart DSH instead.' }
+          }
+          if (!hmrBridge || !hmrBridge.available) {
+            return { kind: 'error', text: 'Tower reload is unavailable: this DSH profile has no HMR service. Restart DSH instead.' }
+          }
+          const outcome = hmrBridge.schedule()
+          return {
+            kind: 'success',
+            text: `Tower reload scheduled in ${outcome.delayMs}ms (required entries: ${outcome.requiredIds.join(', ')}). If the new code does not appear, restart DSH.`,
+          }
+        }
+        const { active, message } = parsed
         const outcome = active
           ? enterMode(ctx, key, agent, 'user', message || null)
-          : exitMode(key, 'user', message || null)
+          : await exitMode(key, 'user', message || null)
 
         let forwarded = false
         try {