dsh-tower 2.1.0-beta.1 → 2.3.0

package/domain/integration/init.js

@@ -116,6 +116,7 @@ export function existingInitResult({ state, statePath, dirty }) {
     reanchored: false,
     dirty,
     snapshotCommit: state.snapshotCommit ?? null,
+    caseInsensitive: state.caseInsensitive ?? null,
   }
 }
 
@@ -128,10 +129,21 @@ export function existingInitResult({ state, statePath, dirty }) {
  * @param {string | null} [input.towerAgentId]
  * @param {string | null} [input.snapshotCommit]
  * @param {string | null} [input.snapshotRef]
+ * @param {boolean | null} [input.caseInsensitive]
  * @param {number} input.now
  * @returns {TowerState}
  */
-export function initialState({ repoRoot, commonDir, base, dirty, towerAgentId = null, snapshotCommit = null, snapshotRef = null, now }) {
+export function initialState({
+  repoRoot,
+  commonDir,
+  base,
+  dirty,
+  towerAgentId = null,
+  snapshotCommit = null,
+  snapshotRef = null,
+  caseInsensitive = null,
+  now,
+}) {
   return {
     schemaVersion: SCHEMA_VERSION,
     repoRoot,
@@ -141,6 +153,7 @@ export function initialState({ repoRoot, commonDir, base, dirty, towerAgentId =
     createdAt: now,
     updatedAt: now,
     dirtyBase: dirty,
+    caseInsensitive,
     ...(towerAgentId ? { towerAgentId: String(towerAgentId) } : {}),
     ...(snapshotCommit ? { snapshotCommit, snapshotRef } : {}),
     missions: [],
@@ -156,9 +169,19 @@ export function initialState({ repoRoot, commonDir, base, dirty, towerAgentId =
  * @param {boolean} input.dirty
  * @param {string | null} input.snapshotCommit
  * @param {string | null} input.snapshotRef
+ * @param {boolean | null} [input.caseInsensitive]
  * @returns {object}
  */
-export function createdInitResult({ repoRoot, commonDir, statePath, base, dirty, snapshotCommit, snapshotRef }) {
+export function createdInitResult({
+  repoRoot,
+  commonDir,
+  statePath,
+  base,
+  dirty,
+  snapshotCommit,
+  snapshotRef,
+  caseInsensitive = null,
+}) {
   return {
     created: true,
     repoRoot,
@@ -171,6 +194,7 @@ export function createdInitResult({ repoRoot, commonDir, statePath, base, dirty,
     dirty,
     snapshotCommit,
     snapshotRef,
+    caseInsensitive,
   }
 }
 
@@ -194,6 +218,7 @@ export function existingInitWriteResult({ state, statePath, dirty, reanchored })
     reanchored,
     dirty,
     snapshotCommit: state.snapshotCommit ?? null,
+    caseInsensitive: state.caseInsensitive ?? null,
   }
 }
 
@@ -202,10 +227,21 @@ export function existingInitWriteResult({ state, statePath, dirty, reanchored })
  * @param {string} input.base
  * @param {string | null} [input.snapshotCommit]
  * @param {boolean} input.dirty
+ * @param {boolean | null} [input.caseInsensitive]
  * @returns {string}
  */
-export function initActivityText({ base, snapshotCommit = null, dirty }) {
-  return `base ${base}${snapshotCommit ? ` snapshot ${snapshotCommit.slice(0, 12)}` : ''}${dirty ? ' (dirty base)' : ''}`
+export function initActivityText({ base, snapshotCommit = null, dirty, caseInsensitive = null }) {
+  const mode = caseInsensitive === null ? '' : ` (${caseInsensitive ? 'case-insensitive' : 'case-sensitive'} filesystem)`
+  return `base ${base}${snapshotCommit ? ` snapshot ${snapshotCommit.slice(0, 12)}` : ''}${dirty ? ' (dirty base)' : ''}${mode}`
+}
+
+/**
+ * Activity line for a probe recorded on an existing state.
+ * @param {boolean} caseInsensitive
+ * @returns {string}
+ */
+export function caseProbeActivityText(caseInsensitive) {
+  return `case sensitivity detected: ${caseInsensitive ? 'case-insensitive' : 'case-sensitive'}`
 }
 
 /**

package/domain/integration/merge.js

@@ -3,6 +3,7 @@
 // writes, the state lock, and persistence stay in app/merge.js.
 // @ts-check
 import { isReviewExempt, latestReview, reviewsForBranch } from './review.js'
+import { mergedEvent } from '../events.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
 /** @typedef {import('../../types/index.js').Review} Review */
@@ -182,6 +183,40 @@ export function mergeSuccessNote(branchTip, base, newTip) {
   return `merged ${branchTip.slice(0, 7)} into ${base} as ${newTip.slice(0, 7)}`
 }
 
+/**
+ * Apply a successful two-phase merge to the mission draft and describe the
+ * domain fact, including the commit that landed. Persistence stays in
+ * app/merge.js at the commit phase.
+ * @param {{ mission: Mission, branchTip: string, base: string, newTip: string, now: number }} params
+ * @returns {{ state: Mission, events: Array<{ type: string, missionId: string, commit: string }> }}
+ */
+export function applyMergeSuccess({ mission, branchTip, base, newTip, now }) {
+  mission.status = 'merged'
+  mission.mergedAt = now
+  mission.mergedCommit = newTip
+  mission.updatedAt = now
+  mission.notes = mission.notes ?? []
+  mission.notes.push(mergeSuccessNote(branchTip, base, newTip))
+  return { state: mission, events: [mergedEvent(mission, newTip)] }
+}
+
+/**
+ * Apply an already-landed merge reconciliation to the mission draft. `note` is
+ * the evidence line the caller built from the observed commit and parents.
+ * @param {{ mission: Mission, mergedCommit: string, note: string, now: number }} params
+ * @returns {{ state: Mission, events: Array<{ type: string, missionId: string, commit: string }> }}
+ */
+export function applyLandedMerge({ mission, mergedCommit, note, now }) {
+  mission.status = 'merged'
+  mission.mergedAt = now
+  mission.mergedCommit = mergedCommit
+  mission.blockers = []
+  mission.notes = mission.notes ?? []
+  mission.notes.push(note)
+  mission.updatedAt = now
+  return { state: mission, events: [mergedEvent(mission, mergedCommit)] }
+}
+
 /**
  * @param {string} detail
  * @returns {string}

package/domain/lockBudget.js

@@ -0,0 +1,30 @@
+// Git-mutex budget policy (#93), shared by the app layer and the store
+// infrastructure (#69).
+//
+// The waiter behind the repo-scoped git mutex must outlast a merge that is
+// entitled to `mergeTimeoutMs`: a merge legally holds the mutex for its whole
+// plan.timeoutMs and then runs a few cheap evidence/cleanup git calls before
+// releasing it (#93). The budget is pure policy over the resolved Tower config,
+// so it lives in the domain rather than in an adapter; app/tower.js and
+// adapters/store.js both compute it from here.
+export const GIT_LOCK_MARGIN_MS = 60000
+
+/** The default merge timeout when a caller passes a config without `merge`. */
+export const DEFAULT_MERGE_TIMEOUT_MS = 900000
+
+/**
+ * @param {{ merge?: { timeoutMs?: number } } | null | undefined} config
+ * @param {number} [mergeTimeoutMs] the caller's resolved merge timeout
+ * @returns {number}
+ */
+export function gitLockTimeoutMs(config, mergeTimeoutMs) {
+  const explicit = Number(mergeTimeoutMs)
+  const configured = Number(config?.merge?.timeoutMs)
+  const base =
+    Number.isInteger(explicit) && explicit > 0
+      ? explicit
+      : Number.isInteger(configured) && configured > 0
+        ? configured
+        : DEFAULT_MERGE_TIMEOUT_MS
+  return base + GIT_LOCK_MARGIN_MS
+}

package/domain/mission.js

@@ -9,7 +9,7 @@
 
 /** @type {readonly MissionStatus[]} */
 export const MISSION_STATUSES = ['planned', 'active', 'completed', 'blocked', 'paused', 'merged', 'abandoned']
-export const SCHEMA_VERSION = 1
+export const SCHEMA_VERSION = 3
 /** @type {readonly MergeVerdict[]} */
 export const MERGE_VERDICTS = ['merge', 'fix-then-merge', 'hold']
 export const REVIEW_STATUS_RE = /^(clean|p1-\d+items|p2-\d+items)$/

package/domain/missions/completion.js

@@ -4,10 +4,62 @@
 // Git, and persists the transition; the rules below are repository-free.
 // @ts-check
 import { TowerToolError } from '../errors.js'
+import { completedEvent } from '../events.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
 /** @typedef {import('../../types/index.js').RosterEntry} RosterEntry */
 
+/**
+ * Hard cap for `tower_complete.report`, in UTF-8 bytes (32 KiB). The value is
+ * the default of `gates.maxReportBytes`; a repository may lower or raise it.
+ */
+export const DEFAULT_MAX_REPORT_BYTES = 32 * 1024
+
+/**
+ * UTF-8 byte length, so multi-byte text is not silently favoured by a
+ * character-count bound.
+ * @param {string} value
+ * @returns {number}
+ */
+export function utf8ByteLength(value) {
+  return Buffer.byteLength(String(value), 'utf8')
+}
+
+/**
+ * Reject a report over the cap instead of truncating it: a silent cut loses
+ * evidence and cannot be recovered by the tower. The writer is told to keep the
+ * full text beside the branch and reference it.
+ * @param {string} report
+ * @param {number} [maxBytes]
+ * @returns {number} accepted UTF-8 byte length
+ */
+export function assertReportSize(report, maxBytes = DEFAULT_MAX_REPORT_BYTES) {
+  const bytes = utf8ByteLength(report)
+  if (bytes > maxBytes) {
+    throw new TowerToolError(
+      'invalid-argument',
+      `report is ${bytes} bytes (UTF-8), over the ${maxBytes}-byte cap; reports are rejected, not truncated — write the full text to a file in the mission worktree and reference the path in the report`,
+      {
+        nextAction: 'write the full text to a file in the mission worktree and reference the path in the report',
+      },
+    )
+  }
+  return bytes
+}
+
+/**
+ * Byte size of a stored completion report. Older documents have no
+ * `reportBytes`, so the body is measured on read; the field is never required.
+ * @param {any} completionReport
+ * @returns {number | null}
+ */
+export function completionReportBytes(completionReport) {
+  if (!isPlainObject(completionReport)) return null
+  const stored = completionReport.reportBytes
+  if (Number.isInteger(stored) && stored >= 0) return stored
+  return typeof completionReport.report === 'string' ? utf8ByteLength(completionReport.report) : null
+}
+
 /**
  * @param {string} message
  * @param {string} [code]
@@ -53,10 +105,10 @@ export function normalizeChecks(checks) {
 /**
  * Resolve and validate the reporting worker and the mission's completion
  * preconditions that need no repository access.
- * @param {{ mission: Mission, roster: RosterEntry[] | undefined, input: any }} params
+ * @param {{ mission: Mission, roster: RosterEntry[] | undefined, input: any, maxReportBytes?: number }} params
  * @returns {RosterEntry}
  */
-export function assertCompletionRequest({ mission, roster, input }) {
+export function assertCompletionRequest({ mission, roster, input, maxReportBytes }) {
   const worker = (roster ?? []).find((entry) => entry.agentId === input.agentId)
   if (!worker || worker.missionId !== mission.id) {
     fail(`agent ${input.agentId} is not assigned to mission ${mission.id}`)
@@ -75,6 +127,7 @@ export function assertCompletionRequest({ mission, roster, input }) {
   if (typeof input.report !== 'string' || input.report.trim().length === 0) {
     fail('tower_complete requires a non-empty report')
   }
+  assertReportSize(input.report.trim(), maxReportBytes)
   const openTasks = (mission.tasks ?? []).filter((task) => task.status === 'open')
   if (openTasks.length > 0) {
     fail(
@@ -106,9 +159,23 @@ export function assertCompletionInbox({ mission, worker, unread }) {
 
 /**
  * Project the completion report stored on the mission.
- * @param {{ report: string, worker: RosterEntry, checks: any[], now: number }} params
+ * @param {{ report: string, worker: RosterEntry, checks: any[], now: number, maxReportBytes?: number }} params
  * @returns {any}
  */
-export function completionReport({ report, worker, checks, now }) {
-  return { report: report.trim(), by: worker.name, at: now, checks }
+export function completionReport({ report, worker, checks, now, maxReportBytes }) {
+  const text = report.trim()
+  return { report: text, reportBytes: assertReportSize(text, maxReportBytes), by: worker.name, at: now, checks }
+}
+
+/**
+ * Apply the completion transition to the mission draft and describe the domain
+ * fact. Persistence stays in app/checkCompletion.js.
+ * @param {{ mission: Mission, report: any, now: number }} params
+ * @returns {{ state: Mission, events: Array<{ type: string, missionId: string }> }}
+ */
+export function applyCompletion({ mission, report, now }) {
+  mission.status = 'completed'
+  mission.completionReport = report
+  mission.updatedAt = now
+  return { state: mission, events: [completedEvent(mission)] }
 }

package/domain/missions/lifecycle.js

@@ -5,6 +5,7 @@
 // in-memory mission draft it is given.
 // @ts-check
 import { TowerToolError } from '../errors.js'
+import { abandonedEvent, completedEvent } from '../events.js'
 import { MISSION_STATUSES, TERMINAL_STATUSES, canTransition, pauseCauseError } from '../mission.js'
 import { normalizeScope, scopesOverlap } from '../scope.js'
 
@@ -62,9 +63,10 @@ export function assertMissionActor(mission, actor, input) {
 
 /**
  * Apply one validated `tower_mission` patch to the mission draft and return
- * the human-readable change list used by the activity log.
+ * the human-readable change list used by the activity log plus the domain
+ * events the transition describes.
  * @param {{ mission: Mission, state: TowerState, input: any, config: any }} params
- * @returns {{ changes: string[] }}
+ * @returns {{ state: Mission, changes: string[], events: Array<{ type: string, missionId: string }> }}
  */
 export function applyMissionUpdate({ mission, state, input, config }) {
   const actor = input.actor ?? { name: 'tower', role: 'tower' }
@@ -77,6 +79,8 @@ export function applyMissionUpdate({ mission, state, input, config }) {
   }
   /** @type {string[]} */
   const changes = []
+  /** @type {Array<{ type: string, missionId: string }>} */
+  const events = []
 
   if (input.status !== undefined) {
     if (typeof input.status !== 'string' || !MISSION_STATUSES.includes(input.status)) {
@@ -104,6 +108,8 @@ export function applyMissionUpdate({ mission, state, input, config }) {
     }
     mission.status = input.status
     changes.push(`status=${input.status}`)
+    if (input.status === 'completed') events.push(completedEvent(mission))
+    if (input.status === 'abandoned') events.push(abandonedEvent(mission))
   }
 
   if (input.task_done !== undefined) {
@@ -169,8 +175,9 @@ export function applyMissionUpdate({ mission, state, input, config }) {
     const others = state.missions.filter(
       (entry) => entry.id !== mission.id && !TERMINAL.has(entry.status) && entry.kind !== 'survey',
     )
+    const caseInsensitive = state.caseInsensitive === true
     for (const other of others) {
-      if (mission.kind !== 'survey' && scopesOverlap(scope, other.scope)) {
+      if (mission.kind !== 'survey' && scopesOverlap(scope, other.scope, { caseInsensitive })) {
         fail(`widened scope overlaps mission ${other.id}; retire it or add an explicit ordering`)
       }
     }
@@ -181,5 +188,5 @@ export function applyMissionUpdate({ mission, state, input, config }) {
   }
 
   if (changes.length === 0) fail('tower_mission requires at least one change')
-  return { changes }
+  return { state: mission, changes, events }
 }

package/domain/missions/plan.js

@@ -4,9 +4,11 @@
 // activity entry; everything here is deterministic and repository-free.
 // @ts-check
 import { TowerToolError } from '../errors.js'
+import { plannedEvents } from '../events.js'
 import { normalizeScope, validateTitle } from '../scope.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
+/** @typedef {import('../../types/index.js').TowerState} TowerState */
 
 /**
  * @param {string} message
@@ -147,3 +149,15 @@ export function newMission(id, input, now) {
     updatedAt: now,
   }))
 }
+
+/**
+ * Append the freshly projected missions to the state document and describe the
+ * resulting domain facts. Persistence and revision accounting stay in app/plan.
+ * @param {TowerState} state
+ * @param {Mission[]} created
+ * @returns {{ state: TowerState, events: Array<{ type: string, missionId: string }> }}
+ */
+export function applyPlan(state, created) {
+  state.missions.push(...created)
+  return { state, events: plannedEvents(created) }
+}

package/domain/missions/review.js

@@ -5,6 +5,7 @@
 // persistence. Everything here is deterministic and repository-free.
 // @ts-check
 import { TowerToolError } from '../errors.js'
+import { reviewedEvent } from '../events.js'
 import { MERGE_VERDICTS, REVIEW_STATUS_RE } from '../mission.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
@@ -109,11 +110,67 @@ export function assertReviewerSpawnTip(caller, tip) {
 }
 
 /**
- * Compute the review round and enforce the per-reviewer cap.
- * @param {{ reviews: Review[] | undefined, branch: string, reviewerName: string, maxRoundsPerReviewer: unknown }} params
+ * The latest review of one branch. Higher rounds win; routes that share a round
+ * are ordered by submission sequence, so "latest" is the most recently recorded
+ * verdict (#108).
+ * @param {Review[]} reviews
+ * @returns {Review | null}
+ */
+function latestBranchReview(reviews) {
+  /** @type {Review | null} */
+  let latest = null
+  for (const review of reviews) {
+    if (!latest) {
+      latest = review
+      continue
+    }
+    const round = Number(review.round) || 0
+    const latestRound = Number(latest.round) || 0
+    if (round > latestRound) latest = review
+    else if (round === latestRound && (Number(review.seq) || 0) > (Number(latest.seq) || 0)) latest = review
+  }
+  return latest
+}
+
+/**
+ * Decide whether this submission starts a new review round or appends to the
+ * current one (#108). A completed mission always starts a new round. A mission
+ * that is `active` accepts a later route for the tip that its current round
+ * reviewed: the first non-clean verdict already returned it to `active`, and the
+ * remaining routes spawned against the same tip must still record their
+ * verdicts. A verdict for a tip that moved is rejected with an explanation.
+ * @param {{ mission: Mission, reviews: Review[] | undefined, branch: string, tip: string }} params
+ * @returns {{ appended: boolean, round: number | null }}
+ */
+export function reviewAdmission({ mission, reviews, branch, tip }) {
+  if (mission.status === 'completed') return { appended: false, round: null }
+  if (mission.status !== 'active') {
+    fail(`mission ${mission.id} is ${mission.status}; only a completed mission can be reviewed`)
+  }
+  const latest = latestBranchReview((reviews ?? []).filter((review) => review.branch === branch))
+  if (!latest) {
+    fail(`mission ${mission.id} is active and has no review round to append to; only a completed mission can be reviewed`)
+  }
+  if (latest.reviewedCommit !== tip) {
+    const cause =
+      latest.status === 'clean'
+        ? 'the reviewed tip moved'
+        : `review round ${latest.round} (${latest.status}) returned it to active and the reviewed tip moved`
+    fail(
+      `mission ${mission.id} is active: ${cause} (${String(latest.reviewedCommit).slice(0, 7)} -> ${tip.slice(0, 7)}); only review routes for the same reviewed tip can append to round ${latest.round} — return the mission to completed before starting a new round`,
+    )
+  }
+  return { appended: true, round: latest.round }
+}
+
+/**
+ * Compute the review round and enforce the per-reviewer cap. `round` joins the
+ * round `reviewAdmission` selected for an appended route; omitted, the
+ * submission opens the next round.
+ * @param {{ reviews: Review[] | undefined, branch: string, reviewerName: string, maxRoundsPerReviewer: unknown, round?: number | null }} params
  * @returns {{ reviewerRounds: number, round: number }}
  */
-export function reviewRound({ reviews, branch, reviewerName, maxRoundsPerReviewer }) {
+export function reviewRound({ reviews, branch, reviewerName, maxRoundsPerReviewer, round: sharedRound }) {
   const prior = (reviews ?? []).filter((review) => review.branch === branch)
   const reviewerRounds = prior.filter((review) => review.reviewer === reviewerName).length
   const maxReviewRounds = Number(maxRoundsPerReviewer) || MAX_REVIEW_ROUNDS
@@ -122,17 +179,28 @@ export function reviewRound({ reviews, branch, reviewerName, maxRoundsPerReviewe
       `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
+  const round = Number.isInteger(sharedRound)
+    ? /** @type {number} */ (sharedRound)
+    : 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
+ * clean verdict leaves the status untouched. An appended route records the
+ * verdict without flipping the status again (#108).
+ * @param {{ status: string, merge: string, round: number, reviewerName: string, appended?: boolean }} params
  * @returns {{ returnToActive: boolean, note: string }}
  */
-export function reviewOutcome({ status, merge, round, reviewerName }) {
+export function reviewOutcome({ status, merge, round, reviewerName, appended = false }) {
+  if (appended) {
+    return {
+      returnToActive: false,
+      note: `review round ${round} by ${reviewerName}: ${status} (${merge}) — appended to the same round; the mission stays active until it is re-completed`,
+    }
+  }
   if (status !== 'clean') {
     return {
       returnToActive: true,
@@ -142,6 +210,21 @@ export function reviewOutcome({ status, merge, round, reviewerName }) {
   return { returnToActive: false, note: `review round ${round} by ${reviewerName}: clean (${merge})` }
 }
 
+/**
+ * Apply a recorded review's mission-level effect to the draft and describe the
+ * domain fact. Persistence, the review record and the round accounting stay in
+ * app/review.js.
+ * @param {{ mission: Mission, outcome: { returnToActive: boolean, note: string }, now: number }} params
+ * @returns {{ state: Mission, events: Array<{ type: string, missionId: string }> }}
+ */
+export function applyReviewOutcome({ mission, outcome, now }) {
+  if (outcome.returnToActive) mission.status = 'active'
+  mission.notes = mission.notes ?? []
+  mission.notes.push(outcome.note)
+  mission.updatedAt = now
+  return { state: mission, events: [reviewedEvent(mission)] }
+}
+
 /**
  * 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

package/domain/planning.js

@@ -85,11 +85,14 @@ function assertAcyclic(missions) {
 /**
  * Kimi-style heuristic: overlapping build scopes are serialized by an
  * auto-added dependency. It is conservative, not a proof of disjointness.
+ * `caseInsensitive` is the checkout's detected mode (#90); on such a filesystem
+ * `src/Api/**` and `src/api/**` are the same real files and must serialise.
  * @param {Mission[]} newMissions
  * @param {Mission[]} existingMissions
+ * @param {{ caseInsensitive?: boolean }} [options]
  * @returns {void}
  */
-function addAutoDeps(newMissions, existingMissions) {
+function addAutoDeps(newMissions, existingMissions, { caseInsensitive = false } = {}) {
   const openExisting = existingMissions.filter((mission) => !isTerminal(mission.status))
   const all = [...existingMissions, ...newMissions]
   /** @type {Map<string, Mission>} */
@@ -100,7 +103,7 @@ function addAutoDeps(newMissions, existingMissions) {
       const earlier = newMissions[i]
       const later = newMissions[j]
       if (earlier.kind === 'survey' || later.kind === 'survey') continue
-      if (!scopesOverlap(earlier.scope, later.scope)) continue
+      if (!scopesOverlap(earlier.scope, later.scope, { caseInsensitive })) continue
       if (hasDependencyPath(byId, later.id, earlier.id)) continue
       addDependency(later, earlier.id)
     }
@@ -108,7 +111,7 @@ function addAutoDeps(newMissions, existingMissions) {
     if (mission.kind === 'survey') continue
     for (const other of openExisting) {
       if (other.kind === 'survey') continue
-      if (!scopesOverlap(mission.scope, other.scope)) continue
+      if (!scopesOverlap(mission.scope, other.scope, { caseInsensitive })) continue
       if (hasDependencyPath(byId, mission.id, other.id)) continue
       addDependency(mission, other.id)
     }

package/domain/read/views.js

@@ -38,9 +38,22 @@ export function missionDetailView({ state, mission, activity }) {
  * @param {number} input.unreadTower
  * @param {object} input.config
  * @param {object[]} input.missions enriched mission views
+ * @param {number | null} [input.archivedMissions] archived mission count, or null when unreadable
+ * @param {object} [input.archive] archive index view/diagnostic
+ * @param {{ held: boolean, pid?: number | null, phase?: string | null, heldMs?: number | null }} [input.gitLock]
  * @returns {object}
  */
-export function statusView({ state, statePath, activity, unreadTower, config = {}, missions }) {
+export function statusView({
+  state,
+  statePath,
+  activity,
+  unreadTower,
+  config = {},
+  missions,
+  archivedMissions = 0,
+  archive = null,
+  gitLock = { held: false },
+}) {
   /** @type {Record<string, number>} */
   const counts = {}
   for (const status of MISSION_STATUSES) counts[status] = 0
@@ -88,6 +101,9 @@ export function statusView({ state, statePath, activity, unreadTower, config = {
       at: finding.at,
     })),
     missions,
+    archivedMissions,
+    gitLock,
+    ...(archive ? { archive } : {}),
     activity,
   }
 }

package/domain/report.js

@@ -7,9 +7,10 @@ import { taskCounts } from './summary.js'
 
 /**
  * @param {TowerState} state
+ * @param {{ count?: number, unreadable?: boolean, message?: string } | null} [archive]
  * @returns {string}
  */
-export function boardMarkdown(state) {
+export function boardMarkdown(state, archive = null) {
   const lines = []
   lines.push(`# Tower missions — ${state.repoRoot}`)
   lines.push('')
@@ -23,6 +24,13 @@ export function boardMarkdown(state) {
     `Missions: ${state.missions.length} · ` +
       MISSION_STATUSES.map((status) => `${status} ${counts[status]}`).join(' · '),
   )
+  if (archive) {
+    lines.push(
+      archive.unreadable === true
+        ? `Archived: unreadable (${archive.message ?? 'archive index could not be read'})`
+        : `Archived: ${archive.count ?? 0} terminal mission(s) in archive/ (not listed; use tower_status includeArchived)`,
+    )
+  }
   const openFindings = (state.findings ?? []).filter((finding) => !['fixed', 'wontfix'].includes(finding.status ?? 'open'))
   lines.push(`Findings: ${openFindings.length} open of ${(state.findings ?? []).length}`)
   lines.push('')