dsh-tower 2.1.0 → 2.3.0

package/app/init.js

@@ -6,8 +6,6 @@
 //             the repo-scoped git mutex, never under the state lock.
 //   commit  — one short state lock writes/claims/reanchors, revalidating the
 //             state revision captured by prepare.
-import { withLock, withGitLock, exists, ensureDir, writeJsonAtomic, appendJsonl } from '../lib/store.js'
-import { detectCaseSensitivity } from '../lib/caseSensitivity.js'
 import { validateState } from '../domain/state.js'
 import { TowerToolError } from '../domain/errors.js'
 import {
@@ -36,16 +34,13 @@ function fail(message, code = 'invalid-argument') {
 }
 
 /**
- * Probe the checkout's own filesystem through the injected seam. The default
- * composition uses the real probe; a composition that predates #90 keeps
- * working through the fallback.
+ * Probe the checkout's own filesystem through the injected case-sensitivity
+ * port. tower_init probes once and records the answer in state (#90).
  * @param {any} tower
  * @returns {Promise<boolean | null>}
  */
-async function detectCaseMode(tower) {
-  const detect = tower.deps?.caseSensitivity?.detect
-  if (typeof detect === 'function') return detect(tower.root)
-  return detectCaseSensitivity(tower.root)
+function detectCaseMode(tower) {
+  return tower.deps.caseSensitivity.detect(tower.root)
 }
 
 /** Phase 1 of `Tower.init` (#51). A read-only init returns its result here. */
@@ -68,7 +63,7 @@ async function prepareInit(tower, input) {
     return /** @type {{ base: string }} */ (fallback).base
   }
 
-  if (await exists(tower.paths.state)) {
+  if (await tower.deps.store.exists(tower.paths.state)) {
     const state = await tower.load()
     const owner = state.towerAgentId ? String(state.towerAgentId) : null
     const caller = input.towerAgentId ? String(input.towerAgentId) : null
@@ -108,8 +103,8 @@ async function prepareInit(tower, input) {
  * revalidated first so a concurrent init cannot leave an unreferenced snapshot.
  */
 async function actInitCreate(tower, prepared) {
-  return withGitLock(tower.paths, async () => {
-    if (await exists(tower.paths.state)) return { stale: true }
+  return tower.deps.store.withGitLock(tower.paths, async () => {
+    if (await tower.deps.store.exists(tower.paths.state)) return { stale: true }
     if (!prepared.snapshot) return { snapshotCommit: null, snapshotRef: null }
     const snapshotCommit = ((await tower.tryGit(tower.root, ['stash', 'create'])) ?? '').trim() || null
     if (!snapshotCommit) {
@@ -120,12 +115,12 @@ async function actInitCreate(tower, prepared) {
     const snapshotRef = snapshotRefFor(snapshotCommit)
     await tower.git(tower.root, ['update-ref', snapshotRef, snapshotCommit])
     return { snapshotCommit, snapshotRef }
-  })
+  }, tower.gitMutexOptions({ phase: 'init' }))
 }
 
 /** Phase 2b of `Tower.init` (#51): snapshot-ref cleanup for a base reanchor. */
 async function actInitReanchor(tower, prepared) {
-  return withGitLock(tower.paths, async () => {
+  return tower.deps.store.withGitLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== prepared.stateRevision) return { staleRevision: state.revision }
     if (state.base === prepared.base) return { deleted: [] }
@@ -143,26 +138,26 @@ async function actInitReanchor(tower, prepared) {
       }
     }
     return { deleted }
-  })
+  }, tower.gitMutexOptions({ phase: 'init' }))
 }
 
 /** Restore snapshot refs when the reanchor commit is rejected after phase 2. */
 async function restoreInitRefs(tower, deleted) {
   const entries = deleted.filter((entry) => typeof entry.sha === 'string' && entry.sha.length > 0)
   if (entries.length === 0) return
-  await withGitLock(tower.paths, async () => {
+  await tower.deps.store.withGitLock(tower.paths, async () => {
     for (const entry of entries) {
       await tower.git(tower.root, ['update-ref', entry.ref, entry.sha]).catch(() => {})
     }
-  })
+  }, tower.gitMutexOptions({ phase: 'init' }))
 }
 
 /** Phase 3a of `Tower.init` (#51): write the initial state under a short lock. */
 async function commitInitCreate(tower, prepared, acted, input) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     // Revision revalidation for the create path: prepare saw "absent", so a
     // state file that appeared meanwhile must never be overwritten.
-    if (await exists(tower.paths.state)) {
+    if (await tower.deps.store.exists(tower.paths.state)) {
       throw new TowerToolError('stale-base', 'tower state appeared while init was being prepared; retry')
     }
     const now = Date.now()
@@ -178,8 +173,8 @@ async function commitInitCreate(tower, prepared, acted, input) {
       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: 'init',
       text: initActivityText({
@@ -204,7 +199,7 @@ async function commitInitCreate(tower, prepared, acted, input) {
 
 /** Phase 3b of `Tower.init` (#51): owner claim and reanchor writes under a short lock. */
 async function commitInitExisting(tower, prepared, input) {
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== prepared.stateRevision) {
       throw new TowerToolError(
@@ -224,8 +219,8 @@ async function commitInitExisting(tower, prepared, 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: 'init',
         text: ownerClaimActivityText(claimant),
@@ -240,8 +235,8 @@ async function commitInitExisting(tower, prepared, 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: 'init',
         text: caseProbeActivityText(prepared.caseInsensitive),
@@ -256,8 +251,8 @@ async function commitInitExisting(tower, prepared, 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: 'init', text: reanchorActivityText(prepared.base) })
+      await tower.deps.store.writeJsonAtomic(tower.paths.state, state)
+      await tower.deps.store.appendJsonl(tower.paths.activity, { at: now, type: 'init', text: reanchorActivityText(prepared.base) })
     }
     return existingInitWriteResult({ state, statePath: tower.paths.state, dirty: prepared.dirty, reanchored })
   })
@@ -265,7 +260,7 @@ async function commitInitExisting(tower, prepared, input) {
 
 /** #51 two-phase init: prepare/act/commit with stale-state retries. */
 export async function init(tower, input = {}) {
-  await ensureDir(tower.paths.dir)
+  await tower.deps.store.ensureDir(tower.paths.dir)
   const prepared = await prepareInit(tower, input)
   if (prepared.early) return prepared.early
   if (prepared.create) {

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) }
   })
 }
@@ -302,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
@@ -336,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 }
   })
 }
@@ -361,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 = []
 
@@ -384,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'
@@ -411,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 {
@@ -435,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)
@@ -463,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,
@@ -497,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,
@@ -528,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,
@@ -550,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,6 @@ 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') {
@@ -13,11 +12,11 @@ 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 })
@@ -25,13 +24,14 @@ export async function updateMission(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: '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,15 +5,15 @@ 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()
     // Archived ids stay in the known set: a new mission must not reuse an id
@@ -28,18 +28,21 @@ export async function plan(tower, input = {}) {
     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)),

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. */