dsh-tower 2.0.3 → 2.1.0-beta.1

package/domain/missions/review.js

@@ -0,0 +1,179 @@
+// Pure review submission policy: actor resolution, verdict validation, round
+// accounting, and the resulting mission/record projections.
+//
+// app/review.js owns loading state, the worktree/tip Git reads, the lock, and
+// persistence. Everything here is deterministic and repository-free.
+// @ts-check
+import { TowerToolError } from '../errors.js'
+import { MERGE_VERDICTS, REVIEW_STATUS_RE } from '../mission.js'
+
+/** @typedef {import('../../types/index.js').Mission} Mission */
+/** @typedef {import('../../types/index.js').RosterEntry} RosterEntry */
+/** @typedef {import('../../types/index.js').Review} Review */
+
+export const MAX_REVIEW_ROUNDS = 5
+
+/**
+ * @param {string} message
+ * @param {string} [code]
+ * @returns {never}
+ */
+function fail(message, code = 'invalid-argument') {
+  throw new TowerToolError(code, message)
+}
+
+/**
+ * A mission with a worktree is the only reviewable subject; the caller checks
+ * that its status is `completed`.
+ * @param {Mission} mission
+ * @returns {void}
+ */
+export function assertReviewableMission(mission) {
+  if (!mission.worktree) fail(`mission ${mission.id} has no worktree to review`)
+}
+
+/**
+ * Resolve who is submitting the review. An unregistered caller fails closed;
+ * only an assigned reviewer or the tower (break-glass) may review.
+ * @param {{ mission: Mission, caller: RosterEntry | undefined, actorRole: string | undefined, agentId: string | undefined, breakGlassReason: unknown }} params
+ * @returns {{ reviewerName: string, reviewerRole: string }}
+ */
+export function resolveReviewActor({ mission, caller, actorRole, agentId, breakGlassReason }) {
+  if (actorRole === 'tower') {
+    if (typeof breakGlassReason !== 'string' || breakGlassReason.trim().length === 0) {
+      fail('a tower-submitted review is break-glass and requires a non-empty breakGlassReason', 'not-authorized')
+    }
+    return { reviewerName: 'tower', reviewerRole: 'tower' }
+  }
+  if (caller) {
+    if (caller.role !== 'reviewer') {
+      fail(`agent ${caller.name} is a ${caller.role}; only an assigned reviewer or the tower (break-glass) may review`)
+    }
+    if (caller.missionId !== mission.id) {
+      fail(`reviewer ${caller.name} was not assigned to mission ${mission.id}`)
+    }
+    if (mission.owner && caller.name === mission.owner) fail('the reviewer must differ from the worker', 'not-authorized')
+    return { reviewerName: caller.name, reviewerRole: 'reviewer' }
+  }
+  // Fail closed: an unknown caller is not the tower, and a missing roster row
+  // is not evidence of tower identity.
+  fail(`agent ${agentId ?? '(unknown)'} is not a registered reviewer or the tower`)
+}
+
+/**
+ * Validate the verdict payload fields that are independent of Git.
+ * @param {any} input
+ * @returns {{ status: string, merge: string, findings: string, decision: string, checks: string[] }}
+ */
+export function normalizeReviewVerdict(input) {
+  if (!REVIEW_STATUS_RE.test(String(input.status ?? ''))) {
+    fail('status must be "clean", "p1-Nitems", or "p2-Nitems"')
+  }
+  if (!MERGE_VERDICTS.includes(input.merge)) {
+    fail(`merge verdict must be one of ${MERGE_VERDICTS.join('|')}`)
+  }
+  const findings = String(input.findings ?? '').trim()
+  if (!findings) fail('findings text is required; write "none" for a clean verdict')
+  if (input.status === 'clean' && findings.toLowerCase() !== 'none') {
+    fail('a clean verdict requires findings text "none"')
+  }
+  if (input.status !== 'clean' && findings.toLowerCase() === 'none') {
+    fail('a non-clean verdict must describe its findings')
+  }
+  const decision = String(input.decision ?? '').trim()
+  if (!decision) fail('decision (the reasoning behind the verdict) is required')
+  /** @type {string[]} */
+  let checks = []
+  if (input.checks !== undefined) {
+    if (!Array.isArray(input.checks)) fail('checks must be an array of strings')
+    checks = input.checks.map((entry) => String(entry))
+  }
+  return { status: input.status, merge: input.merge, findings, decision, checks }
+}
+
+/**
+ * A reviewer may only review the tip it was spawned on.
+ * @param {RosterEntry | undefined} caller
+ * @param {string} tip
+ * @returns {void}
+ */
+export function assertReviewerSpawnTip(caller, tip) {
+  if (caller && caller.role === 'reviewer' && !String(caller.spawnTip ?? '').trim()) {
+    fail(`reviewer ${caller.name} has no recorded spawn tip; re-spawn the reviewer before reviewing`)
+  }
+  if (caller && caller.role === 'reviewer' && caller.spawnTip !== tip) {
+    fail(
+      `reviewer ${caller.name} modified the mission branch after it was spawned (${String(caller.spawnTip).slice(0, 7)} -> ${tip.slice(0, 7)}); reviewers must be read-only — spawn a fresh reviewer`,
+    )
+  }
+}
+
+/**
+ * Compute the review round and enforce the per-reviewer cap.
+ * @param {{ reviews: Review[] | undefined, branch: string, reviewerName: string, maxRoundsPerReviewer: unknown }} params
+ * @returns {{ reviewerRounds: number, round: number }}
+ */
+export function reviewRound({ reviews, branch, reviewerName, maxRoundsPerReviewer }) {
+  const prior = (reviews ?? []).filter((review) => review.branch === branch)
+  const reviewerRounds = prior.filter((review) => review.reviewer === reviewerName).length
+  const maxReviewRounds = Number(maxRoundsPerReviewer) || MAX_REVIEW_ROUNDS
+  if (reviewerRounds >= maxReviewRounds) {
+    fail(
+      `reviewer ${reviewerName} reached the ${maxReviewRounds}-round cap for ${branch}; continue with a different reviewer`,
+    )
+  }
+  const round = prior.length === 0 ? 1 : Math.max(...prior.map((review) => review.round)) + 1
+  return { reviewerRounds, round }
+}
+
+/**
+ * A non-clean verdict returns the mission to active and records the note; a
+ * clean verdict leaves the status untouched.
+ * @param {{ status: string, merge: string, round: number, reviewerName: string }} params
+ * @returns {{ returnToActive: boolean, note: string }}
+ */
+export function reviewOutcome({ status, merge, round, reviewerName }) {
+  if (status !== 'clean') {
+    return {
+      returnToActive: true,
+      note: `review round ${round} by ${reviewerName}: ${status} (${merge}) — returned to active`,
+    }
+  }
+  return { returnToActive: false, note: `review round ${round} by ${reviewerName}: clean (${merge})` }
+}
+
+/**
+ * Project the persisted review record.
+ * @param {{ seq: number, missionId: string, branch: string, tip: string, verdict: { status: string, merge: string, findings: string, checks: string[], decision: string }, reviewerName: string, reviewerRole: string, round: number, now: number, breakGlassReason?: string }} params
+ * @returns {Review}
+ */
+export function reviewRecord({
+  seq,
+  missionId,
+  branch,
+  tip,
+  verdict,
+  reviewerName,
+  reviewerRole,
+  round,
+  now,
+  breakGlassReason,
+}) {
+  return {
+    id: `R${seq}`,
+    seq,
+    missionId,
+    branch,
+    reviewedCommit: tip,
+    status: verdict.status,
+    mergeVerdict: /** @type {import('../../types/index.js').MergeVerdict} */ (verdict.merge),
+    findings: verdict.findings,
+    checks: verdict.checks,
+    decision: verdict.decision,
+    reviewer: reviewerName,
+    reviewerRole,
+    round,
+    at: now,
+    ...(reviewerRole === 'tower' ? { breakGlassReason } : {}),
+  }
+}

package/domain/planning.js

@@ -0,0 +1,118 @@
+// Pure mission planning helpers.
+// @ts-check
+import { TowerToolError } from './errors.js'
+import { scopesOverlap } from './scope.js'
+import { isTerminal } from './mission.js'
+
+/** @typedef {import('../types/index.js').Mission} Mission */
+
+/**
+ * @param {string} message
+ * @returns {never}
+ */
+function fail(message) {
+  throw new TowerToolError('invalid-argument', message)
+}
+
+/**
+ * @param {Mission[]} missions
+ * @returns {number}
+ */
+function nextMissionNumber(missions) {
+  let max = 0
+  for (const mission of missions) {
+    const match = /^M(\d+)$/.exec(mission.id)
+    if (match) max = Math.max(max, Number(match[1]))
+  }
+  return max + 1
+}
+
+/**
+ * @param {Mission} mission
+ * @param {string} dep
+ * @returns {void}
+ */
+function addDependency(mission, dep) {
+  if (mission.id === dep) return
+  if (!mission.deps.includes(dep)) mission.deps.push(dep)
+}
+
+/**
+ * @param {Map<string, Mission>} missionsById
+ * @param {string} fromId
+ * @param {string} toId
+ * @returns {boolean}
+ */
+function hasDependencyPath(missionsById, fromId, toId) {
+  /** @type {Set<string>} */
+  const seen = new Set()
+  /** @type {string[]} */
+  const stack = [fromId]
+  while (stack.length > 0) {
+    const current = /** @type {string} */ (stack.pop())
+    if (current === toId) return true
+    if (seen.has(current)) continue
+    seen.add(current)
+    const mission = missionsById.get(current)
+    if (!mission) continue
+    for (const dep of mission.deps) stack.push(dep)
+  }
+  return false
+}
+
+/**
+ * @param {Mission[]} missions
+ * @returns {void}
+ */
+function assertAcyclic(missions) {
+  /** @type {Map<string, Mission>} */
+  const byId = new Map(missions.map((mission) => [mission.id, mission]))
+  /** @type {Map<string, 'visiting' | 'done'>} */
+  const state = new Map()
+  /** @type {(id: string, trail: string[]) => void} */
+  const visit = (id, trail) => {
+    const mark = state.get(id)
+    if (mark === 'done') return
+    if (mark === 'visiting') fail(`mission dependencies have a cycle: ${[...trail, id].join(' -> ')}`)
+    state.set(id, 'visiting')
+    const mission = byId.get(id)
+    if (mission) for (const dep of mission.deps) visit(dep, [...trail, id])
+    state.set(id, 'done')
+  }
+  for (const mission of missions) visit(mission.id, [])
+}
+
+/**
+ * Kimi-style heuristic: overlapping build scopes are serialized by an
+ * auto-added dependency. It is conservative, not a proof of disjointness.
+ * @param {Mission[]} newMissions
+ * @param {Mission[]} existingMissions
+ * @returns {void}
+ */
+function addAutoDeps(newMissions, existingMissions) {
+  const openExisting = existingMissions.filter((mission) => !isTerminal(mission.status))
+  const all = [...existingMissions, ...newMissions]
+  /** @type {Map<string, Mission>} */
+  const byId = new Map(all.map((mission) => [mission.id, mission]))
+
+  for (let i = 0; i < newMissions.length; i += 1) {
+    for (let j = i + 1; j < newMissions.length; j += 1) {
+      const earlier = newMissions[i]
+      const later = newMissions[j]
+      if (earlier.kind === 'survey' || later.kind === 'survey') continue
+      if (!scopesOverlap(earlier.scope, later.scope)) continue
+      if (hasDependencyPath(byId, later.id, earlier.id)) continue
+      addDependency(later, earlier.id)
+    }
+    const mission = newMissions[i]
+    if (mission.kind === 'survey') continue
+    for (const other of openExisting) {
+      if (other.kind === 'survey') continue
+      if (!scopesOverlap(mission.scope, other.scope)) continue
+      if (hasDependencyPath(byId, mission.id, other.id)) continue
+      addDependency(mission, other.id)
+    }
+  }
+}
+
+export { nextMissionNumber, addDependency, hasDependencyPath, assertAcyclic, addAutoDeps }

package/domain/read/enrichedMissions.js

@@ -0,0 +1,58 @@
+// Pure dashboard mission enrichment: select the latest review, project the
+// review view, and merge it into the mission summary. The worktree existence
+// check and `rev-parse HEAD` that detect a moved tip stay in
+// app/enrichedMissions.js.
+// @ts-check
+import { missionSummary } from '../summary.js'
+import { latestReview, reviewsForBranch } from '../integration/review.js'
+
+/** @typedef {import('../../types/index.js').Mission} Mission */
+/** @typedef {import('../../types/index.js').Review} Review */
+/** @typedef {import('../../types/index.js').TowerState} TowerState */
+
+/**
+ * Filter the missions the caller asked for, preserving state order.
+ * @param {Mission[]} missions
+ * @param {string[] | null | undefined} onlyIds
+ * @returns {Mission[]}
+ */
+export function missionsToEnrich(missions, onlyIds) {
+  const wanted = onlyIds ? new Set(onlyIds) : null
+  return wanted ? missions.filter((mission) => wanted.has(mission.id)) : missions
+}
+
+/**
+ * @param {TowerState} state
+ * @param {Mission} mission
+ * @returns {Review | null}
+ */
+export function latestReviewForMission(state, mission) {
+  const branch = mission.worktree ? mission.worktree.branch : null
+  return latestReview(reviewsForBranch(state.reviews, branch))
+}
+
+/**
+ * @param {object} input
+ * @param {Mission} input.mission
+ * @param {Review | null} input.latest
+ * @param {boolean} input.tipMoved
+ * @returns {object}
+ */
+export function enrichedMissionView({ mission, latest, tipMoved }) {
+  return {
+    ...missionSummary(mission),
+    review: latest
+      ? {
+          id: latest.id,
+          round: latest.round,
+          status: latest.status,
+          mergeVerdict: latest.mergeVerdict,
+          reviewer: latest.reviewer,
+          reviewerRole: latest.reviewerRole,
+          reviewedCommit: latest.reviewedCommit,
+          at: latest.at,
+        }
+      : null,
+    tipMoved,
+  }
+}

package/domain/read/missionContext.js

@@ -0,0 +1,53 @@
+// Pure mission-context projection: reviews, findings, and dependency statuses
+// for one mission. Loading state and activity stays in app/missionContext.js.
+// @ts-check
+import { fullMission, findingSummary } from '../summary.js'
+
+/** @typedef {import('../../types/index.js').Mission} Mission */
+/** @typedef {import('../../types/index.js').TowerState} TowerState */
+
+/**
+ * @param {object} input
+ * @param {TowerState} input.state
+ * @param {Mission} input.mission
+ * @returns {object}
+ */
+export function missionContextView({ state, mission }) {
+  const byId = new Map(state.missions.map((entry) => [entry.id, entry]))
+  const branch = mission.worktree ? mission.worktree.branch : null
+  const reviews = branch
+    ? (state.reviews ?? [])
+        .filter((review) => review.branch === branch)
+        .slice()
+        .sort((left, right) => right.round - left.round)
+        .slice(0, 3)
+    : []
+  const findings = (state.findings ?? [])
+    .filter((finding) => finding.missionId === mission.id)
+    .slice()
+    .sort((left, right) => (right.seq ?? 0) - (left.seq ?? 0))
+    .slice(0, 10)
+  return {
+    base: state.base,
+    mission: fullMission(mission),
+    snapshotCommit: state.snapshotCommit ?? null,
+    completionReport: mission.completionReport ?? null,
+    reviews: reviews.map((review) => ({
+      id: review.id,
+      round: review.round,
+      status: review.status,
+      mergeVerdict: review.mergeVerdict,
+      reviewer: review.reviewer,
+      findings: review.findings,
+      checks: review.checks ?? [],
+      decision: review.decision,
+      reviewedCommit: review.reviewedCommit,
+      at: review.at,
+    })),
+    findings: findings.map((finding) => findingSummary(finding)),
+    deps: (mission.deps ?? []).map((id) => {
+      const dep = byId.get(id)
+      return dep ? { id, title: dep.title, status: dep.status } : { id, title: null, status: 'unknown' }
+    }),
+  }
+}

package/domain/read/views.js

@@ -0,0 +1,128 @@
+// Pure read-model projections for the status/detail/diff use cases. Loading
+// state, reading the activity tail, and running Git stay in app/read.js.
+// @ts-check
+import { FINDING_STATUSES, MISSION_STATUSES } from '../mission.js'
+import { fullMission, findingSummary, taskCounts } from '../summary.js'
+
+/** @typedef {import('../../types/index.js').Mission} Mission */
+/** @typedef {import('../../types/index.js').TowerState} TowerState */
+
+/**
+ * @param {object} input
+ * @param {TowerState} input.state
+ * @param {Mission} input.mission
+ * @param {Array<Record<string, unknown>>} input.activity
+ * @returns {object}
+ */
+export function missionDetailView({ state, mission, activity }) {
+  const branch = mission.worktree ? mission.worktree.branch : null
+  const reviews = (state.reviews ?? [])
+    .filter((review) => review.missionId === mission.id || (branch && review.branch === branch))
+    .slice()
+    .sort((left, right) => right.round - left.round)
+  const findings = (state.findings ?? []).filter((finding) => finding.missionId === mission.id)
+  const missionActivity = activity.filter((entry) => entry.missionId === mission.id)
+  return {
+    mission: fullMission(mission),
+    reviews: reviews.slice(0, 10),
+    findings: findings.slice(-10).map((finding) => findingSummary(finding)),
+    activity: missionActivity.slice(-20),
+  }
+}
+
+/**
+ * @param {object} input
+ * @param {TowerState} input.state
+ * @param {string} input.statePath
+ * @param {Array<Record<string, unknown>>} input.activity
+ * @param {number} input.unreadTower
+ * @param {object} input.config
+ * @param {object[]} input.missions enriched mission views
+ * @returns {object}
+ */
+export function statusView({ state, statePath, activity, unreadTower, config = {}, missions }) {
+  /** @type {Record<string, number>} */
+  const counts = {}
+  for (const status of MISSION_STATUSES) counts[status] = 0
+  for (const mission of state.missions) counts[mission.status] = (counts[mission.status] ?? 0) + 1
+  const openTasks = state.missions.reduce((sum, mission) => sum + taskCounts(mission.tasks ?? []).open, 0)
+  /** @type {Record<string, number>} */
+  const findingsByStatus = {}
+  for (const findingStatus of FINDING_STATUSES) findingsByStatus[findingStatus] = 0
+  for (const finding of state.findings ?? []) {
+    const findingStatus = finding.status ?? 'open'
+    findingsByStatus[findingStatus] = (findingsByStatus[findingStatus] ?? 0) + 1
+  }
+  return {
+    repoRoot: state.repoRoot,
+    commonDir: state.commonDir,
+    statePath,
+    base: state.base,
+    revision: state.revision,
+    towerAgentId: state.towerAgentId ?? null,
+    ownerMissing: !state.towerAgentId,
+    counts,
+    openTasks,
+    roster: (state.roster ?? []).length,
+    messages: (state.messages ?? []).length,
+    unreadTower,
+    findings: (state.findings ?? []).length,
+    findingsByStatus,
+    reviews: (state.reviews ?? []).length,
+    config: {
+      path: config.configPath ?? null,
+      repoConfigPresent: config.repoConfigPresent === true,
+      spawn: {
+        workerPreset: config.spawn?.workerPreset ?? null,
+        reviewerPreset: config.spawn?.reviewerPreset ?? null,
+      },
+    },
+    recentFindings: (state.findings ?? []).slice(-5).map((finding) => ({
+      id: finding.id,
+      type: finding.type,
+      severity: finding.severity,
+      status: finding.status ?? 'open',
+      title: finding.title,
+      missionId: finding.missionId,
+      reportedBy: finding.reportedBy,
+      at: finding.at,
+    })),
+    missions,
+    activity,
+  }
+}
+
+/**
+ * @param {unknown} maxBytes
+ * @returns {number}
+ */
+export function patchLimit(maxBytes) {
+  return Number.isInteger(maxBytes) && /** @type {number} */ (maxBytes) > 0 ? /** @type {number} */ (maxBytes) : 64 * 1024
+}
+
+/**
+ * @param {object} input
+ * @param {Mission} input.mission
+ * @param {string} input.baseTip
+ * @param {string} input.branchTip
+ * @param {string} input.mergeBase
+ * @param {string[]} input.files
+ * @param {string[]} input.commits
+ * @param {string} input.fullPatch
+ * @param {number} [input.maxBytes]
+ * @returns {object}
+ */
+export function diffView({ mission, baseTip, branchTip, mergeBase, files, commits, fullPatch, maxBytes }) {
+  const limit = patchLimit(maxBytes)
+  return {
+    missionId: mission.id,
+    branch: mission.worktree ? mission.worktree.branch : null,
+    baseTip,
+    branchTip,
+    mergeBase,
+    files,
+    commits,
+    truncated: fullPatch.length > limit,
+    patch: fullPatch.slice(0, limit),
+  }
+}

package/domain/report.js

@@ -0,0 +1,59 @@
+// Pure human-readable mission board.
+// @ts-check
+import { MISSION_STATUSES } from './mission.js'
+import { taskCounts } from './summary.js'
+
+/** @typedef {import('../types/index.js').TowerState} TowerState */
+
+/**
+ * @param {TowerState} state
+ * @returns {string}
+ */
+export function boardMarkdown(state) {
+  const lines = []
+  lines.push(`# Tower missions — ${state.repoRoot}`)
+  lines.push('')
+  lines.push(`Base: \`${state.base}\` · revision ${state.revision} · updated ${new Date(state.updatedAt ?? Date.now()).toISOString()}`)
+  /** @type {Record<string, number>} */
+  const counts = {}
+  for (const status of MISSION_STATUSES) counts[status] = 0
+  for (const mission of state.missions) counts[mission.status] += 1
+  lines.push('')
+  lines.push(
+    `Missions: ${state.missions.length} · ` +
+      MISSION_STATUSES.map((status) => `${status} ${counts[status]}`).join(' · '),
+  )
+  const openFindings = (state.findings ?? []).filter((finding) => !['fixed', 'wontfix'].includes(finding.status ?? 'open'))
+  lines.push(`Findings: ${openFindings.length} open of ${(state.findings ?? []).length}`)
+  lines.push('')
+  lines.push('| Mission | Status | Kind | Title | Owner | Tasks (done/open/dropped) | Latest review | Merged |')
+  lines.push('|---|---|---|---|---|---|---|---|')
+  for (const mission of state.missions) {
+    const tasks = taskCounts(mission.tasks ?? [])
+    const branch = mission.worktree ? mission.worktree.branch : null
+    const reviews = branch ? (state.reviews ?? []).filter((review) => review.branch === branch) : []
+    const latest = reviews.length > 0 ? reviews.reduce((a, b) => (a.round >= b.round ? a : b)) : null
+    const reviewText = latest ? `R${latest.round} ${latest.status}/${latest.mergeVerdict}` : '—'
+    lines.push(
+      `| ${mission.id} | ${mission.status} | ${mission.kind} | ${String(mission.title).replaceAll('|', '\\|')} | ${
+        mission.owner ?? '—'
+      } | ${tasks.done}/${tasks.open}/${tasks.dropped} | ${reviewText} | ${
+        mission.mergedCommit ? mission.mergedCommit.slice(0, 8) : '—'
+      } |`,
+    )
+  }
+  if ((state.roster ?? []).length > 0) {
+    lines.push('')
+    lines.push('## Roster')
+    lines.push('')
+    lines.push('| Name | Role | Mission | State | Agent |')
+    lines.push('|---|---|---|---|---|')
+    for (const entry of state.roster ?? []) {
+      lines.push(
+        `| ${entry.name} | ${entry.role} | ${entry.missionId} | ${entry.state} | \`${entry.agentId}\` |`,
+      )
+    }
+  }
+  lines.push('')
+  return lines.join('\n')
+}

package/domain/roster.js

@@ -0,0 +1,40 @@
+// Pure roster predicates.
+// @ts-check
+
+/** @typedef {import('../types/index.js').RosterEntry} RosterEntry */
+/** @typedef {import('../types/index.js').TowerState} TowerState */
+
+/** @type {readonly string[]} */
+export const ROSTER_INACTIVE_STATES = ['retired', 'failed', 'interrupted', 'missing', 'stale', 'inactive']
+/** @type {ReadonlySet<string>} */
+export const ROSTER_INACTIVE = new Set(ROSTER_INACTIVE_STATES)
+
+/**
+ * @param {TowerState} state
+ * @param {string} missionId
+ * @returns {RosterEntry | undefined}
+ */
+export function liveWorkerEntry(state, missionId) {
+  return (state.roster ?? []).find(
+    (entry) => entry.missionId === missionId && entry.role === 'worker' && !ROSTER_INACTIVE.has(entry.state),
+  )
+}
+
+/**
+ * @param {TowerState} state
+ * @param {string} missionId
+ * @returns {RosterEntry[]}
+ */
+export function workerEntries(state, missionId) {
+  return (state.roster ?? []).filter((entry) => entry.missionId === missionId && entry.role === 'worker')
+}
+
+/**
+ * @param {TowerState} state
+ * @returns {number}
+ */
+export function countLiveWorkers(state) {
+  return (state.roster ?? []).filter(
+    (entry) => entry.role === 'worker' && !ROSTER_INACTIVE.has(entry.state) && entry.state !== 'reserved',
+  ).length
+}