dsh-tower 2.1.0-beta.1 → 2.3.0

package/app/checkCompletion.js

@@ -5,11 +5,11 @@ import {
   assertCompletionRequest,
   assertCompletionInbox,
   completionReport,
+  applyCompletion,
 } from '../domain/missions/completion.js'
 import { fullMission } from '../domain/summary.js'
 import { validateState } from '../domain/state.js'
-import { countCommits, isClean } from '../lib/git.js'
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
+import { sweepArchive } from './archive.js'
 
 export { normalizeChecks }
 
@@ -19,16 +19,21 @@ export async function checkCompletion(tower, input) {
   if (!mission) {
     throw new TowerToolError('invalid-argument', `unknown mission "${input.missionId}"`)
   }
-  const worker = assertCompletionRequest({ mission, roster: state.roster, input })
+  const worker = assertCompletionRequest({
+    mission,
+    roster: state.roster,
+    input,
+    maxReportBytes: tower.config.gates?.maxReportBytes,
+  })
   await tower.assertWorktree(mission.worktree)
-  const commits = await countCommits(mission.worktree.path, mission.worktree.baseCommit)
+  const commits = await tower.deps.vcs.countCommits(mission.worktree.path, mission.worktree.baseCommit)
   if (commits < 1) {
     throw new TowerToolError(
       'invalid-argument',
       `mission branch has no commits since ${String(mission.worktree.baseCommit).slice(0, 12)}`,
     )
   }
-  if (!(await isClean(mission.worktree.path))) {
+  if (!(await tower.deps.vcs.isClean(mission.worktree.path))) {
     const dirty = (await tower.git(mission.worktree.path, ['status', '--porcelain']))
       .split('\n')
       .filter(Boolean)
@@ -47,7 +52,7 @@ export async function complete(tower, input) {
   // Two-phase pilot (#51): expensive git/state checks run before the lock;
   // the lock only revalidates the state revision and commits the transition.
   const prepared = await tower.checkCompletion(input)
-  return withLock(tower.paths, async () => {
+  return tower.deps.store.withLock(tower.paths, async () => {
     const state = await tower.load()
     if (state.revision !== prepared.state.revision) {
       throw new TowerToolError('stale-base', 'tower state changed while completion was being prepared; retry')
@@ -57,20 +62,27 @@ export async function complete(tower, input) {
     const { worker, commits } = prepared
     const checks = normalizeChecks(input.checks)
     const now = Date.now()
-    mission.status = 'completed'
-    mission.completionReport = completionReport({ report: input.report, worker, checks, now })
-    mission.updatedAt = now
+    const storedReport = completionReport({
+      report: input.report,
+      worker,
+      checks,
+      now,
+      maxReportBytes: tower.config.gates?.maxReportBytes,
+    })
+    const applied = applyCompletion({ mission, report: storedReport, 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: 'complete',
       missionId: mission.id,
       text: `${worker.name} reported completion (${commits} commit(s))`,
     })
+    tower.emitEvents(applied.events, { revision: state.revision, at: now })
     return { mission: fullMission(mission), commits, unread: 0 }
   })
 }

package/app/enrichedMissions.js

@@ -1,6 +1,4 @@
 // Dashboard mission enrichment use case.
-import { exists } from '../lib/store.js'
-import { revParse } from '../lib/git.js'
 import {
   enrichedMissionView,
   latestReviewForMission,
@@ -12,9 +10,9 @@ export async function enrichedMissions(tower, state, onlyIds) {
   for (const mission of missionsToEnrich(state.missions, onlyIds)) {
     const latest = latestReviewForMission(state, mission)
     let tipMoved = false
-    if (latest && mission.worktree && (await exists(mission.worktree.path))) {
+    if (latest && mission.worktree && (await tower.deps.store.exists(mission.worktree.path))) {
       try {
-        const tip = await revParse(mission.worktree.path, 'HEAD')
+        const tip = await tower.deps.vcs.revParse(mission.worktree.path, 'HEAD')
         tipMoved = tip !== latest.reviewedCommit
       } catch {
         tipMoved = false

package/app/findings.js

@@ -1,5 +1,4 @@
 // Findings use cases.
-import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
 import { validateState } from '../domain/state.js'
 import { TowerToolError } from '../domain/errors.js'
 import {
@@ -17,7 +16,7 @@ function fail(message, code = 'invalid-argument') {
 }
 
 export async function addFinding(tower, input) {
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       if (!Array.isArray(state.findings)) state.findings = []
       const fields = normalizeFindingInput(input, state.missions)
@@ -30,8 +29,8 @@ export async function addFinding(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: 'finding',
         missionId: finding.missionId,
@@ -55,7 +54,7 @@ export async function addFinding(tower, input) {
     const actor = normalizeFindingActor(input.actor)
     if (!wantsFindingUpdate(input)) return tower.readFindings(input)
 
-    return withLock(tower.paths, async () => {
+    return tower.deps.store.withLock(tower.paths, async () => {
       const state = await tower.load()
       const all = state.findings ?? []
       const finding = all.find((entry) => entry.id === input.id)
@@ -65,8 +64,8 @@ export async function addFinding(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: 'finding',
         missionId: finding.missionId,

package/app/gate.js

@@ -1,5 +1,4 @@
 // Merge/preflight gate evaluation.
-import { currentBranch } from '../lib/git.js'
 import { ROSTER_INACTIVE_STATES } from '../domain/roster.js'
 import { completionBlockers, mergeGateBlockers } from '../domain/gate.js'
 import { fullMission } from '../domain/summary.js'
@@ -20,8 +19,23 @@ import {
 
 export async function evaluateGate(tower, input) {
     const state = await tower.load()
-    const mission = state.missions.find((entry) => entry.id === input.missionId)
+    let mission = state.missions.find((entry) => entry.id === input.missionId)
+    let archivedEntry = null
+    if (!mission) {
+      // A completed mission may have been archived by policy; preflight and
+      // merge must behave the same for it as before the move (#73).
+      const archived = await tower.archivedMission(input.missionId)
+      if (archived.ok && archived.entry) {
+        archivedEntry = archived.entry
+        mission = archived.entry.mission
+      }
+    }
     if (!mission) return missingMissionGateResult(input.missionId)
+    const archiveIndex = await tower.archiveIndex()
+    const archivedMissions = new Map(
+      (archiveIndex.ok ? archiveIndex.missions : []).map((entry) => [entry.id, entry]),
+    )
+    const reviews = archivedEntry ? [...(state.reviews ?? []), ...(archivedEntry.reviews ?? [])] : state.reviews
     const activity = input.activity ?? {}
     const blockers = []
     const push = (code, detail) => blockers.push({ code, detail })
@@ -57,7 +71,7 @@ export async function evaluateGate(tower, input) {
           if (blocker) push(blocker.code, blocker.detail)
         }
         if (mission.kind !== 'survey') {
-          const blocker = outOfScopeBlocker({ mission, changedFiles })
+          const blocker = outOfScopeBlocker({ mission, changedFiles, caseInsensitive: state.caseInsensitive === true })
           if (blocker) push(blocker.code, blocker.detail)
         }
         const dirty = (await tower.git(tower.root, ['status', '--porcelain']))
@@ -71,12 +85,12 @@ export async function evaluateGate(tower, input) {
       }
     }
 
-    for (const blocker of dependencyBlockers({ deps: mission.deps ?? [], state })) {
+    for (const blocker of dependencyBlockers({ deps: mission.deps ?? [], state, archived: archivedMissions })) {
       push(blocker.code, blocker.detail)
     }
 
     const branch = worktree ? worktree.branch : null
-    const latest = latestReview(reviewsForBranch(state.reviews, branch))
+    const latest = latestReview(reviewsForBranch(reviews, branch))
     for (const blocker of mergeGateBlockers({
       mission,
       roster: state.roster ?? [],
@@ -90,19 +104,22 @@ export async function evaluateGate(tower, input) {
       rebaseWaived: latest ? tower.rebaseWaived(mission, latest) : false,
     })) push(blocker.code, blocker.detail)
 
-    const checkoutBranch = await currentBranch(tower.root)
+    const checkoutBranch = await tower.deps.vcs.currentBranch(tower.root)
     const wrongBranch = baseWrongBranchBlocker({ checkoutBranch, base: state.base })
     if (wrongBranch) push(wrongBranch.code, wrongBranch.detail)
 
-    return gateResult({
-      mission: fullMission(mission),
-      worktree,
-      branchTip,
-      baseTip,
-      changedFiles,
-      review: latest,
-      blockers,
-    })
+    return {
+      ...gateResult({
+        mission: fullMission(mission),
+        worktree,
+        branchTip,
+        baseTip,
+        changedFiles,
+        review: latest,
+        blockers,
+      }),
+      ...(archivedEntry ? { archived: true } : {}),
+    }
   }
 
   /** Read-only mission diff for reviewers: branch changes against the merge base. */

package/app/init.js

@@ -6,11 +6,11 @@
 //             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 { validateState } from '../domain/state.js'
 import { TowerToolError } from '../domain/errors.js'
 import {
   SNAPSHOT_REF_PREFIX,
+  caseProbeActivityText,
   claimCaller,
   createdInitResult,
   existingInitResult,
@@ -33,6 +33,16 @@ function fail(message, code = 'invalid-argument') {
   throw new TowerToolError(code, message)
 }
 
+/**
+ * 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>}
+ */
+function detectCaseMode(tower) {
+  return tower.deps.caseSensitivity.detect(tower.root)
+}
+
 /** Phase 1 of `Tower.init` (#51). A read-only init returns its result here. */
 async function prepareInit(tower, input) {
   const dirty = !(await tower.isClean(tower.root))
@@ -53,13 +63,17 @@ 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
     if (ownedByOther(owner, caller)) {
       fail(`tower state is owned by another agent; ${caller} is not the tower`, 'not-authorized')
     }
+    // "Detect once": a state that already carries a boolean is never re-probed,
+    // so a transient probe failure cannot silently flip the comparison mode.
+    const known = state.caseInsensitive === true || state.caseInsensitive === false
+    const caseInsensitive = known ? null : await detectCaseMode(tower)
     let reanchorBase = null
     if (input.reanchor === true) {
       const refusal = reanchorBlockedMessage(state.missions)
@@ -68,10 +82,10 @@ async function prepareInit(tower, input) {
     }
     const claim = claimCaller(owner, caller) !== null
     const reanchor = shouldReanchor({ reanchor: input.reanchor, reanchorBase, currentBase: state.base })
-    if (!claim && !reanchor) {
+    if (!claim && !reanchor && caseInsensitive === null) {
       return { early: existingInitResult({ state, statePath: tower.paths.state, dirty }) }
     }
-    return { stateRevision: state.revision, claim, reanchor, base: reanchorBase, dirty }
+    return { stateRevision: state.revision, claim, reanchor, base: reanchorBase, dirty, caseInsensitive }
   }
 
   return {
@@ -79,6 +93,7 @@ async function prepareInit(tower, input) {
     base: await resolveBase(),
     snapshot: shouldSnapshot({ snapshotDirty: input.snapshotDirty, dirty }),
     dirty,
+    caseInsensitive: await detectCaseMode(tower),
   }
 }
 
@@ -88,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) {
@@ -100,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: [] }
@@ -123,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()
@@ -154,14 +169,20 @@ async function commitInitCreate(tower, prepared, acted, input) {
       towerAgentId: input.towerAgentId ? String(input.towerAgentId) : null,
       snapshotCommit: acted.snapshotCommit,
       snapshotRef: acted.snapshotRef,
+      caseInsensitive: prepared.caseInsensitive,
       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({ base: prepared.base, snapshotCommit: acted.snapshotCommit, dirty: prepared.dirty }),
+      text: initActivityText({
+        base: prepared.base,
+        snapshotCommit: acted.snapshotCommit,
+        dirty: prepared.dirty,
+        caseInsensitive: prepared.caseInsensitive,
+      }),
     })
     return createdInitResult({
       repoRoot: tower.root,
@@ -171,13 +192,14 @@ async function commitInitCreate(tower, prepared, acted, input) {
       dirty: prepared.dirty,
       snapshotCommit: acted.snapshotCommit,
       snapshotRef: acted.snapshotRef,
+      caseInsensitive: prepared.caseInsensitive,
     })
   })
 }
 
 /** 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(
@@ -197,14 +219,29 @@ 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),
       })
     }
     let reanchored = false
+    // Record the one-time case-sensitivity probe (#90). An unknown result is
+    // not persisted, so a later init can retry it without bumping the revision
+    // on every call.
+    if (prepared.caseInsensitive !== null && state.caseInsensitive !== prepared.caseInsensitive) {
+      state.caseInsensitive = prepared.caseInsensitive
+      state.revision += 1
+      state.updatedAt = now
+      validateState(state, tower.paths.state)
+      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),
+      })
+    }
     if (prepared.reanchor && state.base !== prepared.base) {
       state.base = prepared.base
       state.baseChangedAt = now
@@ -214,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 })
   })
@@ -223,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) {