dsh-tower 2.0.4 → 2.1.0

package/adapters/default.js

@@ -0,0 +1,12 @@
+// Default composition root for Tower dependencies (#50).
+import * as store from '../lib/store.js'
+import * as vcs from '../lib/git.js'
+import * as caseSensitivity from '../lib/caseSensitivity.js'
+
+export const defaultDeps = {
+  store,
+  vcs,
+  caseSensitivity,
+  clock: { now: () => Date.now() },
+  ids: { uuid: () => crypto.randomUUID() },
+}

package/adapters/store-fs.js

@@ -0,0 +1,6 @@
+// The only lib/ module that imports node:fs (#50).
+import fs from 'node:fs'
+import fsp from 'node:fs/promises'
+
+const { createWriteStream } = fs
+export { fs, fsp, createWriteStream }

package/adapters/vcs-git.js

@@ -0,0 +1,4 @@
+// The only lib/ module that imports node:child_process (#50).
+import { execFile, spawn } from 'node:child_process'
+
+export { execFile, spawn }

package/app/archive.js

@@ -0,0 +1,190 @@
+// Terminal-mission archival use case (#73).
+//
+// The policy sweep runs inside an existing state lock, immediately before the
+// caller writes state.json: archive files are written first, then the state
+// document is compacted, so a crash between the two leaves the mission in state
+// and the archive entry is deduped by id on retry. Nothing is deleted: the full
+// mission, its linked reviews and its findings are moved to archive/<year>.json.
+import { appendJsonl } from '../lib/store.js'
+import { readArchiveIndex, readArchivedEntry, writeArchiveEntries } from '../lib/archive.js'
+import { hasLiveAgent } from '../domain/integration/liveness.js'
+import { missionSummary } from '../domain/summary.js'
+import {
+  archiveYearFor,
+  archivedEntry,
+  isClosedFinding,
+  linkedFindings,
+  linkedReviews,
+  selectForArchive,
+} from '../domain/state/archive.js'
+
+/** @typedef {import('../types/index.js').Mission} Mission */
+/** @typedef {import('../types/index.js').TowerState} TowerState */
+
+/**
+ * Read `archive/index.json` through the Tower's store. Never throws: the
+ * returned `ok:false` carries the diagnostic that status/doctor surface.
+ * @param {any} tower
+ * @returns {Promise<{ ok: boolean, file: string, missions: any[], error?: string, exists: boolean }>}
+ */
+export function archiveIndex(tower) {
+  return readArchiveIndex(tower.deps.store, tower.paths)
+}
+
+/**
+ * Load one archived mission with its linked reviews and findings.
+ * @param {any} tower
+ * @param {string} missionId
+ */
+export function archivedMission(tower, missionId) {
+  return readArchivedEntry(tower.deps.store, tower.paths, missionId)
+}
+
+/**
+ * A compact archived mission is rendered through the same summary projection as
+ * an active one, plus `archived: true`. The completion report and task bodies
+ * are intentionally absent: they live in the year file and are loaded only by
+ * `tower_status missionId`.
+ * @param {Record<string, any>} entry
+ * @returns {any}
+ */
+export function archivedSummary(entry) {
+  const mission = /** @type {any} */ ({
+    id: entry.id,
+    title: entry.title,
+    kind: entry.kind ?? 'build',
+    status: entry.status,
+    scope: Array.isArray(entry.scope) ? entry.scope : [],
+    deps: Array.isArray(entry.deps) ? entry.deps : [],
+    owner: entry.owner ?? null,
+    worktree: null,
+    blockers: [],
+    tasks: [],
+    reviewPolicy: 'required-clean',
+    mergedCommit: entry.mergedCommit ?? null,
+    mergedAt: entry.mergedAt ?? null,
+    updatedAt: entry.updatedAt ?? null,
+  })
+  return {
+    ...missionSummary(mission),
+    archived: true,
+    archivedAt: entry.archivedAt,
+    archivedYear: entry.archivedYear ?? null,
+    branch: entry.branch ?? null,
+  }
+}
+
+/**
+ * Status/board view of the archive index: a count plus a diagnostic, never a
+ * thrown error.
+ * @param {{ ok: boolean, file: string, missions: any[], error?: string, exists: boolean }} index
+ * @returns {Record<string, any>}
+ */
+export function archiveView(index) {
+  const years = index.ok
+    ? [...new Set(index.missions.map((entry) => entry.archivedYear).filter((year) => Number.isInteger(year)))].sort(
+        (left, right) => left - right,
+      )
+    : []
+  return {
+    count: index.ok ? index.missions.length : 0,
+    years,
+    file: index.file,
+    present: index.exists === true,
+    unreadable: index.ok ? false : true,
+    ...(index.ok ? {} : { message: index.error ?? 'tower archive is unreadable' }),
+  }
+}
+
+/**
+ * Move the eligible terminal missions out of `state` and into the archive.
+ * Mutates `state` in memory (missions, linked reviews and closed findings) and
+ * leaves the caller to validate/persist it under the lock it already holds.
+ *
+ * @param {any} tower
+ * @param {TowerState} state
+ * @param {{ now?: number, force?: boolean, activity?: Record<string, string | undefined> }} [options]
+ * @returns {Promise<{ archived: string[], written: boolean, files?: string[], error: string | null, year?: number }>}
+ */
+export async function sweepArchive(tower, state, options = {}) {
+  const policy = tower.config.archive ?? {}
+  if (policy.enabled === false) return { archived: [], written: false, error: null }
+  const now = options.now ?? Date.now()
+  const activity = options.activity ?? {}
+
+  // Open batches still need their members; a live agent's mission is never
+  // archived even if it is terminal (defence in depth; teardown keeps it too).
+  const protectedIds = new Set()
+  for (const batch of state.batches ?? []) {
+    const record = /** @type {Record<string, any>} */ (batch)
+    if (record.status !== 'open') continue
+    for (const missionId of Array.isArray(record.missionIds) ? record.missionIds : []) {
+      protectedIds.add(String(missionId))
+    }
+  }
+  for (const mission of state.missions) {
+    if (hasLiveAgent(state, mission.id, activity)) protectedIds.add(mission.id)
+  }
+
+  const selected = selectForArchive(state.missions, policy, {
+    now,
+    force: options.force === true,
+    protectedIds,
+  })
+  if (selected.length === 0) return { archived: [], written: false, error: null }
+
+  const archivedYear = archiveYearFor(now)
+  const entries = selected.map((mission) =>
+    archivedEntry(mission, {
+      archivedAt: now,
+      archivedYear,
+      reviews: linkedReviews(mission, state.reviews),
+      findings: linkedFindings(mission, state.findings),
+    }),
+  )
+
+  let written
+  try {
+    written = await writeArchiveEntries(tower.deps.store, tower.paths, { entries, now })
+  } catch (error) {
+    return { archived: [], written: false, error: `archive write failed: ${String(error?.message ?? error)}` }
+  }
+  if (!written.ok) return { archived: [], written: false, error: written.error ?? 'archive write failed' }
+
+  // The archive now holds the full record: compact state.json in the same lock.
+  const ids = new Set(selected.map((mission) => mission.id))
+  const branches = new Set(
+    selected
+      .map((mission) => mission.worktree?.branch)
+      .filter((branch) => typeof branch === 'string'),
+  )
+  state.missions = state.missions.filter((mission) => !ids.has(mission.id))
+  if (Array.isArray(state.reviews)) {
+    state.reviews = state.reviews.filter((review) => !ids.has(review.missionId) && !branches.has(review.branch))
+  }
+  // Open findings stay actionable in state.json; the archive keeps a snapshot.
+  if (Array.isArray(state.findings)) {
+    state.findings = state.findings.filter(
+      (finding) => !(finding.missionId != null && ids.has(finding.missionId) && isClosedFinding(finding)),
+    )
+  }
+  state.revision += 1
+  state.updatedAt = now
+
+  for (const mission of selected) {
+    await appendJsonl(tower.paths.activity, {
+      at: now,
+      type: 'archive',
+      missionId: mission.id,
+      text: `archived to archive/${archivedYear}.json`,
+    }).catch(() => {})
+  }
+
+  return {
+    archived: [...ids],
+    written: true,
+    files: written.files,
+    error: null,
+    year: archivedYear,
+  }
+}

package/app/batch.js

@@ -0,0 +1,79 @@
+// Batch use cases.
+import { TowerToolError } from '../domain/errors.js'
+import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
+import { validateState } from '../domain/state.js'
+import { validateCreate as validateBatchCreate, validateClose as validateBatchClose } from '../domain/batch.js'
+import {
+  nextBatchId,
+  createBatchRecord,
+  closeBatchRecord,
+  abandonBatchCheck,
+  applyBatchAbandon,
+  batchStatusPayload,
+} from '../domain/collab/batch.js'
+
+function fail(message, code = 'batch-invalid') {
+  throw new TowerToolError(code, message)
+}
+
+export async function createBatch(tower, input = {}, actor = 'tower') {
+    return withLock(tower.paths, async () => {
+      const state = await tower.load()
+      const normalized = validateBatchCreate(state, input)
+      if (!Array.isArray(state.batches)) state.batches = []
+      const batch = createBatchRecord(nextBatchId(state.batches), normalized, actor, Date.now())
+      state.batches.push(batch)
+      state.revision += 1
+      state.updatedAt = batch.createdAt
+      validateState(state, tower.paths.state)
+      await writeJsonAtomic(tower.paths.state, state)
+      await appendJsonl(tower.paths.activity, {
+        at: batch.createdAt,
+        type: 'batch',
+        text: `created ${batch.id}: ${batch.missionIds.join(', ')}`,
+      })
+      return batch
+    })
+  }
+
+  export async function closeBatch(tower, batchId, options = {}, actor = 'tower') {
+    return withLock(tower.paths, async () => {
+      const state = await tower.load()
+      const batch = (state.batches ?? []).find((entry) => entry.id === batchId)
+      if (!batch) fail(`unknown batch "${batchId}"`)
+      const result = validateBatchClose(state, batch, { ...options, state })
+      const blockers = Array.isArray(result.blockers) ? result.blockers : []
+      if (blockers.length > 0) return { ok: false, batch, blockers, checks: result.checks ?? [] }
+      closeBatchRecord(batch, options, actor, Date.now())
+      state.revision += 1
+      state.updatedAt = batch.closedAt
+      validateState(state, tower.paths.state)
+      await writeJsonAtomic(tower.paths.state, state)
+      await appendJsonl(tower.paths.activity, { at: batch.closedAt, type: 'batch', text: `closed ${batch.id}` })
+      return { ok: true, batch, blockers: [], checks: result.checks ?? [] }
+    })
+  }
+
+  /** @param {string} batchId @param {string} [actor] @param {string | null} [reason] */
+  export async function abandonBatch(tower, batchId, actor = 'tower', reason = null) {
+    return withLock(tower.paths, async () => {
+      const state = await tower.load()
+      const batch = (state.batches ?? []).find((entry) => entry.id === batchId)
+      if (!batch) fail(`unknown batch "${batchId}"`)
+      const { alreadyAbandoned } = abandonBatchCheck(batch, batchId)
+      if (alreadyAbandoned) return { ok: true, batch, alreadyAbandoned: true }
+      const now = Date.now()
+      applyBatchAbandon({ batch, actor, reason, now })
+      state.revision += 1
+      state.updatedAt = batch.abandonedAt
+      validateState(state, tower.paths.state)
+      await writeJsonAtomic(tower.paths.state, state)
+      await appendJsonl(tower.paths.activity, { at: batch.abandonedAt, type: 'batch', text: `abandoned ${batch.id}` })
+      return { ok: true, batch, alreadyAbandoned: false }
+    })
+  }
+
+  export async function batchStatus(tower, batchId) {
+    const state = await tower.load()
+    return batchStatusPayload(state, batchId)
+  }

package/app/board.js

@@ -0,0 +1,27 @@
+// Mission board (MISSIONS.md) writing use cases.
+import path from 'node:path'
+import { fsp } from '../adapters/store-fs.js'
+import { renameWithRetry } from '../lib/store.js'
+import { archiveView } from './archive.js'
+
+export function boardFile(tower) {
+  return tower.config.docs?.boardLocation === 'repo'
+    ? path.join(tower.root, 'MISSIONS.md')
+    : path.join(tower.paths.dir, 'MISSIONS.md')
+}
+
+export async function writeBoard(tower) {
+  if (tower.config.docs?.board === false) return null
+  try {
+    const state = await tower.load()
+    const index = await tower.archiveIndex()
+    const file = boardFile(tower)
+    await tower.ensureExcluded(file)
+    const tmp = `${file}.tmp-${process.pid}-${Date.now()}`
+    await fsp.writeFile(tmp, tower.boardMarkdown(state, archiveView(index)), 'utf8')
+    await renameWithRetry(tmp, file)
+    return file
+  } catch {
+    return null
+  }
+}

package/app/checkCompletion.js

@@ -0,0 +1,89 @@
+// Worker completion preparation and commit use cases.
+import { TowerToolError } from '../domain/errors.js'
+import {
+  normalizeChecks,
+  assertCompletionRequest,
+  assertCompletionInbox,
+  completionReport,
+} 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 }
+
+export async function checkCompletion(tower, input) {
+  const state = await tower.load()
+  const mission = state.missions.find((entry) => entry.id === input.missionId)
+  if (!mission) {
+    throw new TowerToolError('invalid-argument', `unknown mission "${input.missionId}"`)
+  }
+  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)
+  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))) {
+    const dirty = (await tower.git(mission.worktree.path, ['status', '--porcelain']))
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => line.slice(3).trim())
+    throw new TowerToolError(
+      'worktree-dirty',
+      `mission ${mission.id} worktree has uncommitted changes (${dirty.slice(0, 8).join(', ')}${dirty.length > 8 ? ', …' : ''}); commit, remove, or record them before tower_complete`,
+    )
+  }
+  const unread = tower.unreadFor(state, worker.name)
+  assertCompletionInbox({ mission, worker, unread })
+  return { state, mission, worker, commits }
+}
+
+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 () => {
+    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')
+    }
+    const mission = state.missions.find((entry) => entry.id === input.missionId)
+    if (!mission) throw new TowerToolError('mission-not-found', `unknown mission "${input.missionId}"`)
+    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,
+      maxReportBytes: tower.config.gates?.maxReportBytes,
+    })
+    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, {
+      at: now,
+      type: 'complete',
+      missionId: mission.id,
+      text: `${worker.name} reported completion (${commits} commit(s))`,
+    })
+    return { mission: fullMission(mission), commits, unread: 0 }
+  })
+}

package/app/enrichedMissions.js

@@ -0,0 +1,26 @@
+// Dashboard mission enrichment use case.
+import { exists } from '../lib/store.js'
+import { revParse } from '../lib/git.js'
+import {
+  enrichedMissionView,
+  latestReviewForMission,
+  missionsToEnrich,
+} from '../domain/read/enrichedMissions.js'
+
+export async function enrichedMissions(tower, state, onlyIds) {
+  const out = []
+  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))) {
+      try {
+        const tip = await revParse(mission.worktree.path, 'HEAD')
+        tipMoved = tip !== latest.reviewedCommit
+      } catch {
+        tipMoved = false
+      }
+    }
+    out.push(enrichedMissionView({ mission, latest, tipMoved }))
+  }
+  return out
+}

package/app/findings.js

@@ -0,0 +1,78 @@
+// Findings use cases.
+import { withLock, writeJsonAtomic, appendJsonl } from '../lib/store.js'
+import { validateState } from '../domain/state.js'
+import { TowerToolError } from '../domain/errors.js'
+import {
+  normalizeFindingInput,
+  newFinding,
+  normalizeFindingActor,
+  wantsFindingUpdate,
+  readFindingsView,
+  applyFindingUpdate,
+  findingUpdateView,
+} from '../domain/missions/findings.js'
+
+function fail(message, code = 'invalid-argument') {
+  throw new TowerToolError(code, message)
+}
+
+export async function addFinding(tower, input) {
+    return withLock(tower.paths, async () => {
+      const state = await tower.load()
+      if (!Array.isArray(state.findings)) state.findings = []
+      const fields = normalizeFindingInput(input, state.missions)
+      const now = Date.now()
+      const seq = (state.findingSeq ?? 0) + 1
+      state.findingSeq = seq
+      const finding = newFinding(fields, { seq, now, reportedBy: input.reportedBy })
+      state.findings.push(finding)
+      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: 'finding',
+        missionId: finding.missionId,
+        text: `${finding.id} ${finding.type}: ${finding.title}`,
+      })
+      return finding
+    })
+  }
+
+  /** List or read findings. Read-only paths never take the writer lock. */
+  export async function readFindings(tower, input = {}) {
+    const state = await tower.load()
+    return readFindingsView(state.findings ?? [], input)
+  }
+
+  /**
+   * List, read, or transition findings. Listing and reading are lock-free;
+   * only a transition takes the writer lock. Reviewers may only read.
+   */
+  export async function findings(tower, input = {}) {
+    const actor = normalizeFindingActor(input.actor)
+    if (!wantsFindingUpdate(input)) return tower.readFindings(input)
+
+    return withLock(tower.paths, async () => {
+      const state = await tower.load()
+      const all = state.findings ?? []
+      const finding = all.find((entry) => entry.id === input.id)
+      if (!finding) fail(`unknown finding "${input.id}"`, 'finding-not-found')
+      const now = Date.now()
+      const { noteAdded } = applyFindingUpdate({ finding, input, actor, now })
+      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: 'finding',
+        missionId: finding.missionId,
+        text: `${finding.id} ${finding.status}${noteAdded ? ' +note' : ''} (${actor.name})`,
+      })
+      // Counts must reflect the transition just recorded.
+      return findingUpdateView(finding, all)
+    })
+  }

package/app/gate.js

@@ -0,0 +1,126 @@
+// 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'
+import { latestReview, reviewsForBranch } from '../domain/integration/review.js'
+import {
+  baseDirtyBlocker,
+  baseWrongBranchBlocker,
+  dependencyBlockers,
+  gateResult,
+  mergeIntentPendingBlocker,
+  missingMissionGateResult,
+  noWorktreeBlocker,
+  outOfScopeBlocker,
+  overwrittenPaths,
+  staleBaseBlocker,
+  surveyChangedFilesBlocker,
+} from '../domain/integration/gate.js'
+
+export async function evaluateGate(tower, input) {
+    const state = await tower.load()
+    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 })
+
+    for (const blocker of completionBlockers(mission, tower.config)) push(blocker.code, blocker.detail)
+    if (state.mergeIntent && state.mergeIntent.missionId === mission.id) {
+      const blocker = mergeIntentPendingBlocker(state.mergeIntent)
+      push(blocker.code, blocker.detail)
+    }
+
+    const worktree = mission.worktree ?? null
+    let branchTip = null
+    let baseTip = null
+    let changedFiles = []
+    if (!worktree) {
+      const blocker = noWorktreeBlocker(mission.id)
+      push(blocker.code, blocker.detail)
+    } else {
+      try {
+        await tower.assertWorktree(worktree)
+        branchTip = await tower.revParse(worktree.path, 'HEAD')
+        baseTip = await tower.revParse(tower.root, state.base)
+        const mergeBase = (await tower.git(worktree.path, ['merge-base', baseTip, branchTip])).trim()
+        changedFiles = (await tower.git(worktree.path, ['diff', '--name-only', `${mergeBase}..${branchTip}`]))
+          .split('\n')
+          .filter(Boolean)
+        if (!(await tower.isAncestor(tower.root, baseTip, branchTip))) {
+          const blocker = staleBaseBlocker({ branch: worktree.branch, base: state.base, baseTip })
+          push(blocker.code, blocker.detail)
+        }
+        if (mission.kind === 'survey') {
+          const blocker = surveyChangedFilesBlocker({ missionId: mission.id, changedFiles })
+          if (blocker) push(blocker.code, blocker.detail)
+        }
+        if (mission.kind !== 'survey') {
+          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']))
+          .split('\n')
+          .filter(Boolean)
+          .map((line) => line.slice(3).trim())
+        const blocker = baseDirtyBlocker(overwrittenPaths(changedFiles, dirty))
+        if (blocker) push(blocker.code, blocker.detail)
+      } catch (error) {
+        push('branch-missing', String(error?.message ?? error))
+      }
+    }
+
+    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(reviews, branch))
+    for (const blocker of mergeGateBlockers({
+      mission,
+      roster: state.roster ?? [],
+      branch,
+      branchTip,
+      review: latest,
+      config: tower.config,
+      activity,
+      parentStatus: input.parentStatus,
+      inactiveStates: ROSTER_INACTIVE_STATES,
+      rebaseWaived: latest ? tower.rebaseWaived(mission, latest) : false,
+    })) push(blocker.code, blocker.detail)
+
+    const checkoutBranch = await 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,
+      }),
+      ...(archivedEntry ? { archived: true } : {}),
+    }
+  }
+
+  /** Read-only mission diff for reviewers: branch changes against the merge base. */