dsh-tower 2.1.0-beta.1 → 2.3.0

package/app/merge.js

@@ -17,10 +17,11 @@
 // from. A writer that slipped in between observation and write makes the
 // prepare stale, so the whole prepare is retried, never partially applied.
 import path from 'node:path'
-import { withLock, withGitLock, writeJsonAtomic, appendJsonl, exists } from '../lib/store.js'
 import { validateState } from '../domain/state.js'
 import {
   alreadyMergedResult,
+  applyLandedMerge,
+  applyMergeSuccess,
   buildMergeIntent,
   classifyCommitOutcome,
   gateTipDrift,
@@ -37,7 +38,6 @@ import {
   mergeIntentEvidence,
   mergeIntentReconcileNote,
   mergeShapeDetail,
-  mergeSuccessNote,
   missionMissingResult,
   pendingMergeIntentResult,
   staleBaseResult,
@@ -83,7 +83,7 @@ async function observeMergeIntent(tower, state, mission) {
   } catch {
     return null
   }
-  const mergeInProgress = await exists(path.join(tower.commonDir, 'MERGE_HEAD'))
+  const mergeInProgress = await tower.deps.store.exists(path.join(tower.commonDir, 'MERGE_HEAD'))
   if (mergeInProgress) return null
   if (head === intent.baseTip) return mergeIntentEvidence({ head, baseTip: intent.baseTip, mergeInProgress, landed: null })
   const tips = new Set([intent.branchTip, intent.baseTip].filter(Boolean))
@@ -98,7 +98,7 @@ async function observeMergeIntent(tower, state, mission) {
  * the new state instead of overwriting it.
  */
 async function applyMergeIntentReconcile(tower, stateRevision, missionId, evidence) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== stateRevision) return { retry: true }
     const mission = state.missions.find((entry) => entry.id === missionId)
@@ -108,8 +108,8 @@ async function applyMergeIntentReconcile(tower, stateRevision, missionId, eviden
     delete state.mergeIntent
     state.revision += 1
     state.updatedAt = now
-    await writeJsonAtomic(tower.paths.state, state)
-    await appendJsonl(tower.paths.activity, {
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.appendJsonl(tower.paths.activity, {
       at: now,
       type: 'merge',
       missionId: mission.id,
@@ -173,31 +173,30 @@ async function observeLandedMerge(tower, state, mission) {
 
 /** Locked write half of `reconcileLandedMerge`, guarded by the revision CAS. */
 async function applyLandedMergeReconcile(tower, stateRevision, missionId, observed) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== stateRevision) return { retry: true }
     const mission = state.missions.find((entry) => entry.id === missionId)
     if (!mission) return { result: missionMissingResult(missionId) }
     const now = Date.now()
     if (state.mergeIntent?.missionId === mission.id) delete state.mergeIntent
-    mission.status = 'merged'
-    mission.mergedAt = now
-    mission.mergedCommit = observed.mergedCommit
-    mission.blockers = []
-    mission.notes.push(
-      landedMergeNote({ found: observed.found, mergedCommit: observed.mergedCommit, base: state.base }),
-    )
-    mission.updatedAt = now
+    const applied = applyLandedMerge({
+      mission,
+      mergedCommit: observed.mergedCommit,
+      note: landedMergeNote({ found: observed.found, mergedCommit: observed.mergedCommit, base: state.base }),
+      now,
+    })
     state.revision += 1
     state.updatedAt = now
     validateState(state, tower.paths.state)
-    await writeJsonAtomic(tower.paths.state, state)
-    await appendJsonl(tower.paths.activity, {
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.appendJsonl(tower.paths.activity, {
       at: now,
       type: 'merge',
       missionId: mission.id,
       text: `reconciled already-landed ${observed.mergedCommit.slice(0, 7)} on ${state.base}`,
     })
+    tower.emitEvents(applied.events, { revision: state.revision, at: now })
     return { result: landedMergeResult(observed) }
   })
 }
@@ -232,6 +231,12 @@ async function prepareFromState(tower, input, deps) {
   const { mergeTimeoutMs, MERGE_MAX_BUFFER } = deps
   let state = await tower.load()
   let mission = state.missions.find((entry) => entry.id === input.missionId)
+  if (!mission) {
+    // An archived terminal mission still answers `alreadyMerged` (or the same
+    // blockers) instead of turning into mission-missing after the move (#73).
+    const archived = await tower.archivedMission(input.missionId)
+    if (archived.ok && archived.entry) mission = archived.entry.mission
+  }
   if (!mission) return { result: missionMissingResult(input.missionId) }
 
   // Reconcile a stale merge intent: Git runs here, outside every state lock.
@@ -296,7 +301,7 @@ async function prepareFromState(tower, input, deps) {
  * next tower_merge/preflight instead of leaving an unexplained base tip.
  */
 async function recordMergeIntent(tower, plan) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     // State revision policy: the plan was built from `plan.stateRevision`; a
     // writer that slipped in before any Git mutation makes the plan stale and
@@ -330,7 +335,7 @@ async function recordMergeIntent(tower, plan) {
     })
     state.revision += 1
     state.updatedAt = now
-    await writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
     return { intent: state.mergeIntent, intentRevision: state.revision }
   })
 }
@@ -355,7 +360,7 @@ async function runMergeGit(tower, plan, intent, deps) {
   }
 
   const newTip = await tower.revParse(tower.root, 'HEAD')
-  const parents = await commitParents(tower.root, newTip)
+  const parents = await commitParents(tower, tower.root, newTip)
   const expectedShape = isExpectedMergeShape(parents, intent.baseTip, intent.branchTip)
   const warnings = []
 
@@ -378,12 +383,12 @@ async function runMergeGit(tower, plan, intent, deps) {
     const conflict = unmerged.trim().length > 0
     let cleanup = 'none'
     const mergeHeadPath = path.join(tower.commonDir, 'MERGE_HEAD')
-    if (await exists(mergeHeadPath)) {
+    if (await tower.deps.store.exists(mergeHeadPath)) {
       try {
         await tower.git(tower.root, ['merge', '--abort'])
         cleanup = 'aborted'
       } catch {
-        await removeStaleGitLocks(tower.commonDir)
+        await removeStaleGitLocks(tower, tower.commonDir)
         try {
           await tower.git(tower.root, ['merge', '--abort'])
           cleanup = 'aborted-after-lock-cleanup'
@@ -405,7 +410,7 @@ async function runMergeGit(tower, plan, intent, deps) {
     if (dirtyAfter.length > 0) {
       const changed = new Set(plan.changedFiles)
       if (newTip === intent.baseTip && dirtyAfter.every((file) => changed.has(file))) {
-        await removeStaleGitLocks(tower.commonDir)
+        await removeStaleGitLocks(tower, tower.commonDir)
         await tower.git(tower.root, ['reset', '--hard', intent.baseTip]).catch(() => {})
         cleanup = cleanup === 'none' ? 'reset' : `${cleanup}+reset`
       } else {
@@ -429,7 +434,7 @@ async function runMergeGit(tower, plan, intent, deps) {
 
 /** Phase 3: apply the observed outcome under a short state lock. */
 async function commitMerge(tower, plan, recorded, outcome) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     const mission = state.missions.find((entry) => entry.id === plan.missionId)
     if (!mission) return missionMissingResult(plan.missionId)
@@ -457,21 +462,24 @@ async function commitMerge(tower, plan, recorded, outcome) {
     if (kind === 'merged') {
       const now = Date.now()
       if (intentActive) delete state.mergeIntent
-      mission.status = 'merged'
-      mission.mergedAt = now
-      mission.mergedCommit = outcome.newTip
-      mission.updatedAt = now
-      mission.notes.push(mergeSuccessNote(recorded.intent.branchTip, state.base, outcome.newTip))
+      const applied = applyMergeSuccess({
+        mission,
+        branchTip: recorded.intent.branchTip,
+        base: state.base,
+        newTip: outcome.newTip,
+        now,
+      })
       state.revision += 1
       state.updatedAt = now
       validateState(state, tower.paths.state)
-      await writeJsonAtomic(tower.paths.state, state)
-      await appendJsonl(tower.paths.activity, {
+      await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+      await tower.deps.store.appendJsonl(tower.paths.activity, {
         at: now,
         type: 'merge',
         missionId: mission.id,
         text: `${recorded.intent.branchTip.slice(0, 7)} -> ${outcome.newTip.slice(0, 7)} on ${state.base}`,
       })
+      tower.emitEvents(applied.events, { revision: state.revision, at: now })
       return {
         ok: true,
         mergedCommit: outcome.newTip,
@@ -491,8 +499,8 @@ async function commitMerge(tower, plan, recorded, outcome) {
         state.mergeIntent.problem = { code: 'merge-shape', newTip: outcome.newTip, parents: outcome.parents, at: Date.now() }
         state.revision += 1
         state.updatedAt = Date.now()
-        await writeJsonAtomic(tower.paths.state, state)
-        await appendJsonl(tower.paths.activity, {
+        await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+        await tower.deps.store.appendJsonl(tower.paths.activity, {
           at: state.updatedAt,
           type: 'merge',
           missionId: mission.id,
@@ -522,8 +530,8 @@ async function commitMerge(tower, plan, recorded, outcome) {
     mission.updatedAt = now
     state.revision += 1
     state.updatedAt = now
-    await writeJsonAtomic(tower.paths.state, state)
-    await appendJsonl(tower.paths.activity, {
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.appendJsonl(tower.paths.activity, {
       at: now,
       type: 'merge',
       missionId: mission.id,
@@ -544,23 +552,28 @@ export async function merge(tower, input, deps) {
   const plan = await prepareMerge(tower, input, deps)
   if (plan.result) return plan.result
 
-  const acted = await withGitLock(tower.paths, async () => {
-    // No Git mutation has happened yet: a base that moved after prepare is a
-    // clean retryable stale-base rejection, with no intent left behind.
-    const head = await tower.revParse(tower.root, 'HEAD')
-    if (head !== plan.baseTip) {
-      return {
-        result: staleBaseResult(
-          plan.missionId,
-          `base moved after gate (${plan.baseTip.slice(0, 7)} -> ${head.slice(0, 7)}); re-run preflight`,
-        ),
+  const acted = await tower.deps.store.withGitLock(
+    tower.paths,
+    async () => {
+      // No Git mutation has happened yet: a base that moved after prepare is a
+      // clean retryable stale-base rejection, with no intent left behind.
+      const head = await tower.revParse(tower.root, 'HEAD')
+      if (head !== plan.baseTip) {
+        return {
+          result: staleBaseResult(
+            plan.missionId,
+            `base moved after gate (${plan.baseTip.slice(0, 7)} -> ${head.slice(0, 7)}); re-run preflight`,
+          ),
+        }
       }
-    }
-    const recorded = await recordMergeIntent(tower, plan)
-    if (recorded.result) return recorded
-    const outcome = await runMergeGit(tower, plan, recorded.intent, deps)
-    return { recorded, outcome }
-  })
+      const recorded = await recordMergeIntent(tower, plan)
+      if (recorded.result) return recorded
+      const outcome = await runMergeGit(tower, plan, recorded.intent, deps)
+      return { recorded, outcome }
+    },
+    // The merge itself may hold the mutex for plan.timeoutMs (#93).
+    tower.gitMutexOptions({ phase: 'merge', mergeTimeoutMs: plan.timeoutMs }),
+  )
   if (acted.result) return acted.result
 
   return commitMerge(tower, plan, acted.recorded, acted.outcome)

package/app/messages.js

@@ -1,5 +1,4 @@
 // Inbox/message use cases.
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
 import { validateState } from '../domain/state.js'
 import { TowerToolError } from '../domain/errors.js'
 import {
@@ -14,7 +13,7 @@ function fail(message) {
 }
 
 export async function recordMessage(tower, input) {
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       if (!Array.isArray(state.messages)) state.messages = []
       assertMessageRecipient({ roster: state.roster ?? [], to: input.to, from: input.from })
@@ -27,8 +26,8 @@ export async function recordMessage(tower, input) {
       state.updatedAt = now
 
       validateState(state, tower.paths.state)
-      await writeJsonAtomic(tower.paths.state, state)
-      await appendJsonl(tower.paths.activity, {
+      await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+      await tower.deps.store.appendJsonl(tower.paths.activity, {
         at: now,
         type: 'message',
         text: `${input.from} -> ${input.to}: ${input.subject}`,
@@ -38,20 +37,20 @@ export async function recordMessage(tower, input) {
   }
 
   export async function recordDelivery(tower, messageId, results) {
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const message = (state.messages ?? []).find((entry) => entry.id === messageId)
       if (!message) fail(`unknown message "${messageId}"`)
       addDelivery(message, results)
       state.revision += 1
       state.updatedAt = Date.now()
-      await writeJsonAtomic(tower.paths.state, state)
+      await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
       return message.delivery
     })
   }
 
   export async function inbox(tower, input) {
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const now = Date.now()
       const { payload, changed } = inboxView(state.messages ?? [], input, now)
@@ -59,7 +58,7 @@ export async function recordMessage(tower, input) {
         state.revision += 1
         state.updatedAt = now
         validateState(state, tower.paths.state)
-        await writeJsonAtomic(tower.paths.state, state)
+        await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
       }
       return payload
     })

package/app/mission.js

@@ -3,7 +3,7 @@ import { TowerToolError } from '../domain/errors.js'
 import { applyMissionUpdate } from '../domain/missions/lifecycle.js'
 import { validateState } from '../domain/state.js'
 import { fullMission } from '../domain/summary.js'
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
+import { sweepArchive } from './archive.js'
 
 function fail(message, code = 'invalid-argument') {
   throw new TowerToolError(code, message)
@@ -12,24 +12,26 @@ function fail(message, code = 'invalid-argument') {
 export async function updateMission(tower, input = {}) {
   const missionId = typeof input.id === 'string' ? input.id.trim() : input.id
   if (typeof missionId !== 'string' || missionId.length === 0) fail('tower_mission requires id')
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     const mission = state.missions.find((entry) => entry.id === missionId)
     if (!mission) fail(`unknown mission "${missionId}"`, 'mission-not-found')
-    const { changes } = applyMissionUpdate({ mission, state, input, config: tower.config })
+    const { changes, events } = applyMissionUpdate({ mission, state, input, config: tower.config })
     const now = Date.now()
     mission.updatedAt = now
+    await sweepArchive(tower, state, { now })
     state.revision += 1
     state.updatedAt = now
 
     validateState(state, tower.paths.state)
-    await writeJsonAtomic(tower.paths.state, state)
-    await appendJsonl(tower.paths.activity, {
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.appendJsonl(tower.paths.activity, {
       at: now,
       type: 'mission',
       missionId: mission.id,
       text: changes.join('; '),
     })
+    tower.emitEvents(events, { revision: state.revision, at: now })
     return { revision: state.revision, mission: fullMission(mission) }
   })
 }

package/app/plan.js

@@ -5,38 +5,49 @@ import {
   assignMissionIds,
   assertKnownDependencies,
   newMission,
+  applyPlan,
 } from '../domain/missions/plan.js'
 import { validateState } from '../domain/state.js'
 import { fullMission } from '../domain/summary.js'
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
+import { sweepArchive } from './archive.js'
 
 export async function plan(tower, input = {}) {
   const prepared = normalizePlanMissions(input)
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     const now = Date.now()
-    const assigned = assignMissionIds(prepared, nextMissionNumber(state.missions))
+    // Archived ids stay in the known set: a new mission must not reuse an id
+    // and a merged dependency may live in the archive index (#73).
+    const archive = await tower.archiveIndex()
+    const known = [...state.missions, ...(archive.ok ? archive.missions : [])]
+    const assigned = assignMissionIds(prepared, nextMissionNumber(known))
 
-    assertKnownDependencies(assigned, state.missions)
+    assertKnownDependencies(assigned, known)
 
-    addAutoDeps(assigned, state.missions)
-    assertAcyclic([...state.missions, ...assigned])
+    addAutoDeps(assigned, known, { caseInsensitive: state.caseInsensitive === true })
+    assertAcyclic([...known, ...assigned])
 
     const created = assigned.map((mission) => newMission(mission.id, mission, now))
-    state.missions.push(...created)
+    const applied = applyPlan(state, created)
+    const swept = await sweepArchive(tower, state, { now })
     state.revision += 1
     state.updatedAt = now
 
     validateState(state, tower.paths.state)
-    await writeJsonAtomic(tower.paths.state, state)
-    await appendJsonl(tower.paths.activity, {
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.appendJsonl(tower.paths.activity, {
       at: now,
       type: 'plan',
       text: `created ${created.map((mission) => mission.id).join(', ')}`,
     })
+    // Persist first, then describe: the event carries the revision the caller
+    // can read back from state.json (#75).
+    tower.emitEvents(applied.events, { revision: state.revision, at: now })
     return {
       revision: state.revision,
       missions: created.map((mission) => fullMission(mission)),
+      ...(swept.archived.length > 0 ? { archived: swept.archived } : {}),
+      ...(swept.error ? { archiveError: swept.error } : {}),
     }
   })
 }

package/app/provision.js

@@ -7,9 +7,7 @@
 //             mission still has no worktree, then records it. A rejected
 //             commit rolls the created worktree/branch back outside the lock.
 import path from 'node:path'
-import { withLock, withGitLock, exists, ensureDir, writeJsonAtomic, appendJsonl, shortHash } from '../lib/store.js'
 import { validateState } from '../domain/state.js'
-import { canonicalPath } from '../lib/worktreeOwnership.js'
 import { TowerToolError } from '../domain/errors.js'
 import {
   baseCommitChoice,
@@ -53,13 +51,13 @@ async function prepareProvision(tower, input) {
     worktreeRoot: input.worktreeRoot,
     configuredRoot: tower.config.worktrees.root,
     repoRoot: tower.root,
-    commonDirHash: shortHash(tower.commonDir),
+    commonDirHash: tower.deps.ids.shortHash(tower.commonDir),
   })
   if (!path.isAbsolute(root)) fail('worktreeRoot must be an absolute path')
   tower.assertOutside(root)
-  await ensureDir(root)
+  await tower.deps.store.ensureDir(root)
   const wtPath = worktreePath(root, mission.id)
-  if (await exists(wtPath)) fail(`worktree path already exists: ${wtPath}`)
+  if (await tower.deps.store.exists(wtPath)) fail(`worktree path already exists: ${wtPath}`)
   if ((await tower.tryGit(tower.root, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`])) !== null) {
     fail(`branch already exists: ${branch}`)
   }
@@ -68,7 +66,7 @@ async function prepareProvision(tower, input) {
 
 /** Phase 2 of `Tower.provision` (#51): no state lock, worktree add under the git mutex. */
 async function actProvision(tower, prepared) {
-  return withGitLock(tower.paths, async () => {
+  return tower.deps.store.withGitLock(tower.paths, async () => {
     let fresh
     try {
       fresh = await tower.load()
@@ -84,7 +82,7 @@ async function actProvision(tower, prepared) {
       await tower.assertWorktree(mission.worktree)
       return { phase: 'existing', mission, worktree: mission.worktree }
     }
-    if (await exists(prepared.wtPath)) fail(`worktree path already exists: ${prepared.wtPath}`)
+    if (await tower.deps.store.exists(prepared.wtPath)) fail(`worktree path already exists: ${prepared.wtPath}`)
     if ((await tower.tryGit(tower.root, ['show-ref', '--verify', '--quiet', `refs/heads/${prepared.branch}`])) !== null) {
       fail(`branch already exists: ${prepared.branch}`)
     }
@@ -95,15 +93,15 @@ async function actProvision(tower, prepared) {
       branch: prepared.branch,
       baseCommit: prepared.baseCommit,
       createdAt: Date.now(),
-      realPath: await canonicalPath(prepared.wtPath),
+      realPath: await tower.deps.ownership.canonicalPath(prepared.wtPath),
     })
     return { phase: 'created', worktree }
-  })
+  }, tower.gitMutexOptions({ phase: 'provision' }))
 }
 
 /** Phase 3 of `Tower.provision` (#51): record the worktree under a short lock. */
 async function commitProvision(tower, prepared, acted) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     const mission = state.missions.find((entry) => entry.id === prepared.missionId)
     if (!mission) throw new TowerToolError('mission-not-found', `unknown mission "${prepared.missionId}"`)
@@ -119,11 +117,11 @@ async function commitProvision(tower, prepared, acted) {
     state.updatedAt = now
     try {
       validateState(state, tower.paths.state)
-      await writeJsonAtomic(tower.paths.state, state)
+      await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
     } catch (error) {
       return { phase: 'persist-error', error }
     }
-    await appendJsonl(tower.paths.activity, {
+    await tower.deps.store.appendJsonl(tower.paths.activity, {
       at: now,
       type: 'worktree',
       missionId: prepared.missionId,
@@ -135,10 +133,10 @@ async function commitProvision(tower, prepared, acted) {
 
 /** Undo a created worktree/branch outside the state lock (git mutex only). */
 async function rollbackProvision(tower, prepared) {
-  await withGitLock(tower.paths, async () => {
+  await tower.deps.store.withGitLock(tower.paths, async () => {
     await tower.git(tower.root, ['worktree', 'remove', '--force', prepared.wtPath]).catch(() => {})
     await tower.git(tower.root, ['branch', '-D', prepared.branch]).catch(() => {})
-  })
+  }, tower.gitMutexOptions({ phase: 'provision' }))
 }
 
 /** #51 two-phase provision: prepare/act/commit with rollback on rejection. */

package/app/read.js

@@ -1,30 +1,89 @@
 // Read-only dashboard/detail use cases.
 import { TowerToolError } from '../domain/errors.js'
 import { diffView, missionDetailView, statusView } from '../domain/read/views.js'
-import { readActivityTail } from '../lib/store.js'
+import { archiveView, archivedSummary } from './archive.js'
 
 function fail(message, code = 'invalid-argument') {
   throw new TowerToolError(code, message)
 }
 
+/**
+ * Full detail for one mission. A mission that was archived is reconstructed
+ * from its year file, including the reviews, findings and activity that left
+ * state.json with it. An unreadable archive is a diagnostic, never a throw:
+ * `tower_status` must keep rendering the hot state.
+ */
 export async function missionDetail(tower, missionId) {
   const state = await tower.load()
   const mission = state.missions.find((entry) => entry.id === missionId)
-  if (!mission) fail(`unknown mission "${missionId}"`, 'mission-not-found')
-  const activity = await readActivityTail(tower.paths.activity, 200)
-  return missionDetailView({ state, mission, activity })
+  const activity = await tower.deps.store.readActivityTail(tower.paths.activity, 200)
+  if (mission) return missionDetailView({ state, mission, activity })
+
+  const archived = await tower.archivedMission(missionId)
+  if (archived.ok && archived.entry) {
+    const entry = archived.entry
+    const hotFindings = (state.findings ?? []).filter((finding) => finding.missionId === missionId)
+    const byId = new Map()
+    for (const finding of [...(entry.findings ?? []), ...hotFindings]) {
+      if (finding && typeof finding.id === 'string') byId.set(finding.id, finding)
+    }
+    return {
+      ...missionDetailView({
+        state: /** @type {any} */ ({ reviews: entry.reviews ?? [], findings: [...byId.values()] }),
+        mission: /** @type {any} */ (entry.mission),
+        activity,
+      }),
+      archived: true,
+      archivedAt: entry.archivedAt,
+      archivedYear: entry.archivedYear,
+      branch: entry.branch ?? null,
+    }
+  }
+  if (archived.unreadable) {
+    return {
+      archived: true,
+      archivedAt: null,
+      branch: null,
+      mission: null,
+      reviews: [],
+      findings: [],
+      activity: [],
+      error: archived.error ?? `tower archive is unreadable; mission ${missionId} cannot be loaded`,
+    }
+  }
+  return fail(`unknown mission "${missionId}"`, 'mission-not-found')
 }
 
 export async function status(tower, input = {}) {
   const state = await tower.load()
-  const activity = await readActivityTail(tower.paths.activity, 12)
+  const activity = await tower.deps.store.readActivityTail(tower.paths.activity, 12)
+  // The repo-scoped git mutex can be held for a whole merge; expose the
+  // holder so "the tower is stuck" has a visible cause (#93).
+  const gitLock = tower.deps.store.gitLockView(await tower.deps.store.readGitLock(tower.paths))
+  const index = await tower.archiveIndex()
+  const activeIds = new Set(state.missions.map((mission) => mission.id))
+  const wanted = Array.isArray(input.missionIds) ? new Set(input.missionIds) : null
+  // An explicit missionId lookup includes its archived summary; the dashboard
+  // includes them only on demand. Archived summaries never carry report bodies.
+  const includeArchived = input.includeArchived === true || wanted !== null
+  const missions = await tower.enrichedMissions(state, input.missionIds)
+  if (includeArchived && index.ok) {
+    for (const entry of index.missions) {
+      if (activeIds.has(entry.id)) continue
+      if (wanted !== null && !wanted.has(entry.id)) continue
+      missions.push(archivedSummary(entry))
+    }
+  }
   return statusView({
     state,
     statePath: tower.paths.state,
     activity,
     unreadTower: tower.unreadFor(state, 'tower').length,
     config: tower.config,
-    missions: await tower.enrichedMissions(state, input.missionIds),
+    missions,
+    archivedMissions: index.ok ? index.missions.length : null,
+    archive: archiveView(index),
+    gitLock,
   })
 }