dsh-tower 2.1.0-beta.1 → 2.3.0

package/app/rebase.js

@@ -6,8 +6,6 @@
 // The durable `state.rebaseIntent` lets a crash between act and commit be
 // reconciled by the next tower_rebase, and `mission.rebase` keeps the
 // reviewed-tip waiver semantics the merge gate depends on.
-import crypto from 'node:crypto'
-import { withLock, withGitLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
 import { validateState } from '../domain/state.js'
 import { TowerToolError } from '../domain/errors.js'
 import { liveAgentFor } from '../domain/integration/liveness.js'
@@ -150,7 +148,7 @@ async function reconcileRebaseIntent(tower) {
     if (inspection.action === 'ambiguous') {
       throw stale(ambiguousRebaseIntentMessage(intent, inspection.tip))
     }
-    const applied = await withLock(tower.paths, async () => {
+    const applied = await tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       if (state.revision !== snapshot.revision) return false
       const current = state.rebaseIntent
@@ -168,8 +166,8 @@ async function reconcileRebaseIntent(tower) {
         mission.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: 'rebase',
         missionId: intent.missionId,
@@ -197,9 +195,9 @@ export async function rebase(tower, input) {
 
   // Record the intent before touching Git: a crash between the rebase and the
   // commit leaves a durable marker instead of an unexplained moved branch.
-  const token = crypto.randomUUID()
+  const token = tower.deps.ids.uuid()
   const startedAt = Date.now()
-  const intentRevision = await withLock(tower.paths, async () => {
+  const intentRevision = await tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== prepared.stateRevision) throw stale(STALE_PREPARE)
     const mission = findMission(state, prepared.missionId)
@@ -216,13 +214,13 @@ export async function rebase(tower, input) {
     })
     state.revision += 1
     state.updatedAt = startedAt
-    await writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
     return state.revision
   })
 
   // Phase 2 (#51): the long git work runs under the git lock and never under
   // the state lock. Re-verify the snapshot right before rewriting the branch.
-  const outcome = await withGitLock(tower.paths, async () => {
+  const outcome = await tower.deps.store.withGitLock(tower.paths, async () => {
     const currentTip = await tower.revParse(worktree.path, 'HEAD')
     const currentBase = await tower.revParse(tower.root, prepared.base)
     if (rebaseTipsMoved({ oldTip: prepared.oldTip, baseTip: prepared.baseTip, currentTip, currentBase })) {
@@ -244,11 +242,11 @@ export async function rebase(tower, input) {
     }
     const newTip = await tower.revParse(worktree.path, 'HEAD')
     return { phase: 'done', newTip }
-  })
+  }, tower.gitMutexOptions({ phase: 'rebase' }))
 
   // Phase 3 (#51): re-read state and revalidate the revision computed by the
   // intent write; the lock only holds the state mutation, never a subprocess.
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== intentRevision) throw stale(STALE_ACT)
     const mission = findMission(state, prepared.missionId)
@@ -262,7 +260,7 @@ export async function rebase(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)
       throw stale(outcome.detail)
     }
 
@@ -274,8 +272,8 @@ export async function rebase(tower, input) {
       state.revision += 1
       state.updatedAt = now
       validateState(state, tower.paths.state)
-      await writeJsonAtomic(tower.paths.state, state)
-      await appendJsonl(tower.paths.activity, { at: now, type: 'rebase', missionId: mission.id, text: 'conflict' })
+      await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+      await tower.deps.store.appendJsonl(tower.paths.activity, { at: now, type: 'rebase', missionId: mission.id, text: 'conflict' })
       return rebaseConflictResult(outcome.detail)
     }
 
@@ -290,8 +288,8 @@ export async function rebase(tower, input) {
     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: 'rebase',
       missionId: mission.id,

package/app/recording.js

@@ -1,14 +1,13 @@
 // State recording use cases for test receipts and imported legacy snapshots.
 import { TowerToolError } from '../domain/errors.js'
 import { validateState } from '../domain/state.js'
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
 
 function fail(message, code = 'invalid-argument') {
   throw new TowerToolError(code, message)
 }
 
 export async function recordTestRun(tower, input = {}) {
-  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 === input.missionId)
     if (!mission) fail(`unknown mission "${input.missionId}"`)
@@ -28,8 +27,8 @@ export async function recordTestRun(tower, input = {}) {
     state.revision += 1
     state.updatedAt = Date.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: Date.now(),
       type: 'test',
       missionId: mission.id,
@@ -40,7 +39,7 @@ export async function recordTestRun(tower, input = {}) {
 }
 
 export async function recordLegacySnapshot(tower, snapshot) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (!Array.isArray(state.legacySnapshots)) state.legacySnapshots = []
     const existing = state.legacySnapshots.find((entry) => entry.sourceHash === snapshot.sourceHash)
@@ -49,13 +48,13 @@ export async function recordLegacySnapshot(tower, snapshot) {
     state.revision += 1
     state.updatedAt = Date.now()
     validateState(state, tower.paths.state)
-    await writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
     return { snapshot, duplicate: false }
   })
 }
 
 export async function recordLegacyMap(tower, map) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (!Array.isArray(state.legacyMaps)) state.legacyMaps = []
     const existing = state.legacyMaps.find(
@@ -66,7 +65,7 @@ export async function recordLegacyMap(tower, map) {
     state.revision += 1
     state.updatedAt = Date.now()
     validateState(state, tower.paths.state)
-    await writeJsonAtomic(tower.paths.state, state)
+    await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
     return { map, duplicate: false }
   })
 }

package/app/review.js

@@ -1,5 +1,5 @@
 // Independent review submission use case.
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
+import { sweepArchive } from './archive.js'
 import { validateState } from '../domain/state.js'
 import { TowerToolError } from '../domain/errors.js'
 import {
@@ -7,9 +7,11 @@ import {
   resolveReviewActor,
   normalizeReviewVerdict,
   assertReviewerSpawnTip,
+  reviewAdmission,
   reviewRound,
   reviewOutcome,
   reviewRecord,
+  applyReviewOutcome,
 } from '../domain/missions/review.js'
 
 function fail(message, code = 'invalid-argument') {
@@ -36,7 +38,7 @@ async function prepareReview(tower, input) {
     breakGlassReason: input.breakGlassReason,
   })
 
-  if (mission.status !== 'completed') {
+  if (!['completed', 'active'].includes(mission.status)) {
     fail(`mission ${mission.id} is ${mission.status}; only a completed mission can be reviewed`)
   }
   const verdict = normalizeReviewVerdict(input)
@@ -45,11 +47,15 @@ async function prepareReview(tower, input) {
   const tip = await tower.revParse(mission.worktree.path, 'HEAD')
   const branch = mission.worktree.branch
   assertReviewerSpawnTip(caller, tip)
+  // #108: a later route may append to the round that returned the mission to
+  // active, but only for the tip that round reviewed.
+  const admission = reviewAdmission({ mission, reviews: state.reviews, branch, tip })
   const { reviewerRounds, round } = reviewRound({
     reviews: state.reviews,
     branch,
     reviewerName,
     maxRoundsPerReviewer: tower.config.review.maxRoundsPerReviewer,
+    round: admission.round,
   })
 
   return {
@@ -66,6 +72,7 @@ async function prepareReview(tower, input) {
     reviewerRole,
     reviewerRounds,
     round,
+    appended: admission.appended,
     breakGlassReason: reviewerRole === 'tower' ? input.breakGlassReason.trim() : undefined,
   }
 }
@@ -76,7 +83,7 @@ export async function submitReview(tower, input) {
   for (let attempt = 0; attempt < 2; attempt += 1) {
     const prepared = await prepareReview(tower, input)
     try {
-      return await withLock(tower.paths, async () => {
+      return await tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== prepared.stateRevision) {
       throw new TowerToolError('stale-base', 'tower state changed while the review was being prepared; retry')
@@ -113,26 +120,28 @@ export async function submitReview(tower, input) {
       merge: prepared.merge,
       round: prepared.round,
       reviewerName: prepared.reviewerName,
+      appended: prepared.appended,
     })
-    if (outcome.returnToActive) mission.status = 'active'
-    mission.notes.push(outcome.note)
-    mission.updatedAt = now
+    const applied = applyReviewOutcome({ mission, outcome, 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: 'review',
       missionId: mission.id,
       text: `round ${prepared.round} ${prepared.reviewerName}: ${prepared.status} / ${prepared.merge} @ ${prepared.tip.slice(0, 12)}`,
     })
+    tower.emitEvents(applied.events, { revision: state.revision, at: now })
     return {
       review,
       branchTip: prepared.tip,
       missionStatus: mission.status,
       round: prepared.round,
+      appended: prepared.appended,
       reviewerRounds: prepared.reviewerRounds + 1,
     }
       })

package/app/roster.js

@@ -1,5 +1,4 @@
 // Roster observation and retirement use cases.
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
 import { validateState } from '../domain/state.js'
 import {
   recordRosterObservations as recordObservations,
@@ -11,7 +10,7 @@ import {
 import { unreadMessages } from '../domain/collab/messages.js'
 
 export async function recordRosterObservations(tower, { present = [], absent = [], confirmations = 2 }) {
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const now = Date.now()
       const { candidates, changed } = recordObservations(
@@ -23,7 +22,7 @@ export async function recordRosterObservations(tower, { present = [], absent = [
         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 { candidates }
     })
@@ -31,7 +30,7 @@ export async function recordRosterObservations(tower, { present = [], absent = [
 
   /** Release live roster slots whose catalog activity is explicitly inactive. */
   export async function reconcileObservedInactive(tower, activity = {}) {
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const now = Date.now()
       const { released } = reconcileInactive(state.roster ?? [], activity, now)
@@ -39,8 +38,8 @@ export async function recordRosterObservations(tower, { present = [], absent = [
         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: 'roster',
           text: `released inactive slots: ${released.join(', ')}`,
@@ -52,7 +51,7 @@ export async function recordRosterObservations(tower, { present = [], absent = [
 
   export async function markRetired(tower, agentIds) {
     if (!Array.isArray(agentIds) || agentIds.length === 0) return { retired: [] }
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const now = Date.now()
       const { retired } = retireEntries(state.roster ?? [], agentIds, now)
@@ -60,8 +59,8 @@ export async function recordRosterObservations(tower, { present = [], absent = [
         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: 'adopt',
           text: `retired ${retired.join(', ')}`,
@@ -73,7 +72,7 @@ export async function recordRosterObservations(tower, { present = [], absent = [
 
   export async function markMissing(tower, agentIds) {
     if (!Array.isArray(agentIds) || agentIds.length === 0) return { missing: [] }
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const now = Date.now()
       const { missing } = markMissingEntries(state.roster ?? [], agentIds, now)
@@ -81,8 +80,8 @@ export async function recordRosterObservations(tower, { present = [], absent = [
         state.revision += 1
         state.updatedAt = now
         validateState(state, tower.paths.state)
-        await writeJsonAtomic(tower.paths.state, state)
-        await appendJsonl(tower.paths.activity, { at: now, type: 'adopt', text: `missing ${missing.join(', ')}` })
+        await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+        await tower.deps.store.appendJsonl(tower.paths.activity, { at: now, type: 'adopt', text: `missing ${missing.join(', ')}` })
       }
       return { missing }
     })
@@ -95,7 +94,7 @@ export async function recordRosterObservations(tower, { present = [], absent = [
     const staleMs = Number(input.staleMs) || 0
     if (staleMs <= 0 || input.authoritative !== true) return { marked: [], idled: [] }
     const activity = input.activity ?? {}
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const now = Date.now()
       const { marked, idled } = sweepRosterState(
@@ -107,8 +106,8 @@ export async function recordRosterObservations(tower, { present = [], absent = [
         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: 'watchdog',
           text: `stale ${marked.join(', ') || '-'}; idle ${idled.join(', ') || '-'}`,

package/{lib → app}/spawn-prechecks.js

@@ -2,7 +2,6 @@
 // service/provider/lease validation. Split out of tools/spawn.js; no I/O.
 import { TowerToolError } from '../domain/errors.js'
 import { ROSTER_INACTIVE_STATES } from '../domain/roster.js'
-import { inspectLeases } from './leases.js'
 
 /**
  * Pick a unique roster name before any activation.
@@ -132,9 +131,11 @@ export async function precheckWorkerOwnership({
 
 /**
  * Service/provider/preset/lease checks, run before provisioning.
- * @param {{ tower: any, ctx: any, config: any, preset: string, actor: any, exec: any }} input
+ * `inspectLeases` is injected by the composition root so the app layer never
+ * imports the lease adapter (#69).
+ * @param {{ tower: any, ctx: any, config: any, preset: string, actor: any, exec: any, inspectLeases: any }} input
  */
-export async function precheckSpawnServices({ tower, ctx, config, preset, actor, exec }) {
+export async function precheckSpawnServices({ tower, ctx, config, preset, actor, exec, inspectLeases }) {
   const subagents = ctx.get('subagents')
   if (!subagents) throw new TowerToolError('spawn-unavailable', 'subagents service is unavailable; cannot spawn')
   const providers = subagents.list()

package/app/spawn.js

@@ -8,7 +8,6 @@ import {
   rosterProjection,
 } from '../domain/collab/spawn.js'
 import { validateState } from '../domain/state.js'
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
 
 function fail(message, code = 'invalid-argument') {
   throw new TowerToolError(code, message)
@@ -16,7 +15,7 @@ function fail(message, code = 'invalid-argument') {
 
 /** Record that a spawned agent failed or went idle, so roster state is truthful. */
 export async function recordSpawnOutcome(tower, input) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     const entry = (state.roster ?? []).find((row) => row.name === input.name && row.missionId === input.missionId)
     if (!entry) return null
@@ -25,8 +24,8 @@ export async function recordSpawnOutcome(tower, input) {
     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: 'spawn',
       missionId: input.missionId,
@@ -38,7 +37,7 @@ export async function recordSpawnOutcome(tower, input) {
 
 /** Record that a live agent was interrupted by the tower. */
 export async function recordInterrupt(tower, input) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     const entry = (state.roster ?? []).find(
       (row) =>
@@ -51,8 +50,8 @@ export async function recordInterrupt(tower, input) {
     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: 'spawn',
       missionId: entry.missionId,
@@ -64,7 +63,7 @@ export async function recordInterrupt(tower, input) {
 
 /** Reserve a roster name before activation so a failed spawn is recoverable. */
 export async function reserveRoster(tower, input) {
-  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 === input.missionId)
     if (!mission) fail(`unknown mission "${input.missionId}"`)
@@ -75,8 +74,8 @@ export async function reserveRoster(tower, input) {
     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: 'spawn',
       missionId: input.missionId,
@@ -89,7 +88,7 @@ export async function reserveRoster(tower, input) {
 export async function recordSpawn(tower, input) {
   // Capture the spawn tip before taking the state lock (#51).
   const spawnTip = input.cwd ? ((await tower.tryGit(input.cwd, ['rev-parse', 'HEAD'])) ?? '').trim() || null : null
-  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 === input.missionId)
     if (!mission) fail(`unknown mission "${input.missionId}"`)
@@ -108,8 +107,8 @@ export async function recordSpawn(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: 'spawn',
       missionId: input.missionId,

package/app/teardown.js

@@ -6,7 +6,6 @@
 // therefore bumps the state revision exactly once, and the revision is
 // revalidated immediately before the irreversible git mutation so a stale
 // decision never removes a worktree that changed hands.
-import { withLock, withGitLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
 import { validateState } from '../domain/state.js'
 import { TowerToolError } from '../domain/errors.js'
 import { hasLiveAgent } from '../domain/integration/liveness.js'
@@ -21,6 +20,7 @@ import {
   teardownRemoveDecision,
   teardownRemovedDecision,
 } from '../domain/integration/teardown.js'
+import { sweepArchive } from './archive.js'
 
 /**
  * Phase 1 (#51): decide every keep/remove outcome without holding the state
@@ -77,7 +77,7 @@ async function prepareTeardown(tower, input) {
 /** Short state lock: reject a stale decision before any git mutation. */
 async function claimRemoval(tower, candidate, expectedRevision, input) {
   const activity = input.activity ?? {}
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== expectedRevision) {
       throw new TowerToolError('stale-base', `${STALE}. No worktree was removed.`)
@@ -104,7 +104,7 @@ export async function teardown(tower, input) {
     // never under the state lock. Re-read state without the lock right before
     // mutating: the git lock may have waited behind another operation, so a
     // stale candidate is refused while the worktree still exists.
-    const outcome = await withGitLock(tower.paths, async () => {
+    const outcome = await tower.deps.store.withGitLock(tower.paths, async () => {
       let fresh
       try {
         fresh = await tower.load()
@@ -139,7 +139,7 @@ export async function teardown(tower, input) {
         branchDeleteError = String(error?.message ?? error).slice(0, 240)
       }
       return { phase: 'removed', branch: worktree.branch, branchDeleteError }
-    })
+    }, tower.gitMutexOptions({ phase: 'teardown' }))
 
     if (outcome.phase === 'stale') {
       throw new TowerToolError('stale-base', `${STALE}: ${outcome.detail}. No worktree was removed.`)
@@ -154,7 +154,7 @@ export async function teardown(tower, input) {
     // the removal on the freshly loaded state instead of rejecting it (which
     // would leave state claiming a worktree that no longer exists). Only this
     // mission's fields change, so no concurrent update is lost.
-    const commit = await withLock(tower.paths, async () => {
+    const commit = await tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const mission = state.missions.find((entry) => entry.id === candidate.missionId)
       if (!mission) return { revision: state.revision }
@@ -166,8 +166,8 @@ export async function teardown(tower, input) {
       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: 'teardown',
         missionId: mission.id,
@@ -180,5 +180,25 @@ export async function teardown(tower, input) {
     setDecision(candidate.decision, teardownRemovedDecision(outcome))
   }
 
-  return { ok: true, dryRun: false, removed, decisions: prepared.decisions }
+  // Archival runs under one final short lock. It is policy-driven (age or the
+  // hot-terminal cap), so a mission torn down a moment ago stays hot until it
+  // is old enough; `archive.afterDays: 0` archives it on this call.
+  const archive = await tower.deps.store.withLock(tower.paths, async () => {
+    const state = await tower.load()
+    const swept = await sweepArchive(tower, state, { now: Date.now(), activity: input.activity ?? {} })
+    if (swept.written) {
+      validateState(state, tower.paths.state)
+      await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+    }
+    return swept
+  })
+
+  return {
+    ok: true,
+    dryRun: false,
+    removed,
+    decisions: prepared.decisions,
+    archived: archive.archived,
+    ...(archive.error ? { archiveError: archive.error } : {}),
+  }
 }