dsh-tower 2.6.0 → 2.7.0

package/domain/missions/completion.js

@@ -5,6 +5,8 @@
 // @ts-check
 import { TowerToolError } from '../errors.js'
 import { completedEvent } from '../events.js'
+import { shapeFor } from '../shapes/index.js'
+import { isWorkerRole } from '../vocabulary.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
 /** @typedef {import('../../types/index.js').RosterEntry} RosterEntry */
@@ -113,7 +115,7 @@ export function assertCompletionRequest({ mission, roster, input, maxReportBytes
   if (!worker || worker.missionId !== mission.id) {
     fail(`agent ${input.agentId} is not assigned to mission ${mission.id}`)
   }
-  if (worker.role !== 'worker') fail(`agent ${worker.name} is a ${worker.role}, not a worker`)
+  if (!isWorkerRole(worker.role)) fail(`agent ${worker.name} is a ${worker.role}, not a worker`)
   if (['retired', 'failed', 'interrupted', 'missing', 'stale'].includes(worker.state)) {
     fail(`agent ${worker.name} is ${worker.state}; a stopped worker cannot report completion`)
   }
@@ -121,6 +123,12 @@ export function assertCompletionRequest({ mission, roster, input, maxReportBytes
     fail(`agent ${worker.name} is not the current owner of mission ${mission.id} (owner: ${mission.owner})`)
   }
   if (mission.status === 'completed') fail(`mission ${mission.id} is already completed`)
+  // `blocked` is derived from open blockers, so name them instead of a generic
+  // status error: clearing them is the one recovery path (#149 W3).
+  const blockers = mission.blockers ?? []
+  if (blockers.length > 0) {
+    fail(`mission ${mission.id} has unresolved blockers: ${blockers.join('; ')}; clear the blockers to resume it`)
+  }
   if (!['active', 'planned'].includes(mission.status)) {
     fail(`mission ${mission.id} is ${mission.status}; it cannot be completed from that state`)
   }
@@ -136,11 +144,6 @@ export function assertCompletionRequest({ mission, roster, input, maxReportBytes
         .join('; ')}`,
     )
   }
-  const blockers = mission.blockers ?? []
-  if (blockers.length > 0) {
-    fail(`mission ${mission.id} has unresolved blockers: ${blockers.join('; ')}`)
-  }
-  if (!mission.worktree) fail(`mission ${mission.id} has no worktree`)
   return worker
 }
 
@@ -167,13 +170,48 @@ export function completionReport({ report, worker, checks, now, maxReportBytes }
   return { report: text, reportBytes: assertReportSize(text, maxReportBytes), by: worker.name, at: now, checks }
 }
 
+/**
+ * Normalize the optional survey result (#148 D6). Only a shape that accepts a
+ * result may carry one; the value stays small so the state document does not
+ * become an evidence dump.
+ * @param {unknown} result
+ * @returns {any}
+ */
+export function normalizeResult(result) {
+  if (result === undefined || result === null) return null
+  if (!isPlainObject(result)) fail('result must be an object')
+  const value = /** @type {Record<string, any>} */ (result)
+  /** @type {Record<string, any>} */
+  const normalized = {}
+  for (const key of ['paths', 'symbols', 'plan']) {
+    if (value[key] === undefined) continue
+    if (!Array.isArray(value[key])) fail(`result.${key} must be an array of strings`)
+    if (value[key].length > 200) fail(`result.${key} supports at most 200 entries`)
+    normalized[key] = value[key].map((entry) => {
+      if (typeof entry !== 'string' || entry.trim().length === 0) fail(`result.${key} entries must be non-empty strings`)
+      return entry.trim()
+    })
+  }
+  if (value.notes !== undefined) {
+    if (typeof value.notes !== 'string') fail('result.notes must be a string')
+    normalized.notes = value.notes.trim().slice(0, 4000)
+  }
+  return normalized
+}
+
 /**
  * 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
+ * @param {{ mission: Mission, report: any, now: number, result?: any }} params
  * @returns {{ state: Mission, events: Array<{ type: string, missionId: string }> }}
  */
-export function applyCompletion({ mission, report, now }) {
+export function applyCompletion({ mission, report, now, result }) {
+  const shape = shapeFor(mission.kind)
+  const normalized = normalizeResult(result)
+  if (normalized !== null) {
+    if (!shape.acceptsResult) fail(`mission ${mission.id} is a ${shape.kind}; a completion result is survey evidence only`)
+    mission.result = normalized
+  }
   mission.status = 'completed'
   mission.completionReport = report
   mission.updatedAt = now

package/domain/missions/findings.js

@@ -5,6 +5,7 @@
 // @ts-check
 import { TowerToolError } from '../errors.js'
 import { FINDING_SEVERITIES, FINDING_STATUSES, FINDING_TRANSITIONS, FINDING_TYPES } from '../mission.js'
+import { isReviewerRole } from '../roles.js'
 import { countFindings, findingSummary } from '../summary.js'
 
 /** @typedef {import('../../types/index.js').Finding} Finding */
@@ -158,7 +159,7 @@ export function readFindingsView(findings, input) {
  * @returns {{ noteAdded: boolean }}
  */
 export function applyFindingUpdate({ finding, input, actor, now }) {
-  if (actor.role === 'reviewer') {
+  if (isReviewerRole(actor.role)) {
     fail('reviewers may list and read findings, but only the tower or a worker may change finding status', 'not-authorized')
   }
   let noteAdded = false

package/domain/missions/lifecycle.js

@@ -6,14 +6,14 @@
 // @ts-check
 import { TowerToolError } from '../errors.js'
 import { abandonedEvent, completedEvent } from '../events.js'
-import { MISSION_STATUSES, TERMINAL_STATUSES, canTransition, pauseCauseError } from '../mission.js'
+import { pauseCauseError } from '../mission.js'
 import { normalizeScope, scopesOverlap } from '../scope.js'
+import { shapeFor } from '../shapes/index.js'
+import { isReviewerRole, isWorkerRole } from '../vocabulary.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
 /** @typedef {import('../../types/index.js').TowerState} TowerState */
 
-const TERMINAL = TERMINAL_STATUSES
-
 /**
  * @param {string} message
  * @param {string} [code]
@@ -42,8 +42,8 @@ export function normalizePauseCause(value) {
  * @returns {void}
  */
 export function assertMissionActor(mission, actor, input) {
-  const workerRequest = actor.role === 'worker'
-  if (actor.role === 'reviewer') {
+  const workerRequest = isWorkerRole(actor.role)
+  if (isReviewerRole(actor.role)) {
     fail('only the tower or a worker may update a mission; reviewers submit tower_review', 'not-authorized')
   }
   if (workerRequest && mission.owner && mission.owner !== actor.name) {
@@ -61,6 +61,48 @@ export function assertMissionActor(mission, actor, input) {
   }
 }
 
+/**
+ * Mark a mission blocked from a machine-derived failure (a merge or rebase
+ * conflict). `blocked` is derived from open blockers, so the blocker is recorded
+ * with the status in one write path; no caller assigns the status directly
+ * (#149 W3). Repeating the same failure does not duplicate the blocker.
+ * @param {Mission} mission
+ * @param {string} blocker
+ * @param {number} [now]
+ * @returns {Mission}
+ */
+export function markBlocked(mission, blocker, now = Date.now()) {
+  if (typeof blocker !== 'string' || blocker.trim().length === 0) fail('a blocker must be a non-empty string')
+  const text = blocker.trim()
+  const blockers = /** @type {string[]} */ (mission.blockers)
+  if (!blockers.includes(text)) blockers.push(text)
+  mission.status = 'blocked'
+  // A blocker wins over a pause: the human cause is superseded by the failure.
+  delete mission.pauseCause
+  mission.updatedAt = now
+  return mission
+}
+
+/**
+ * Resolve blockers that a successful machine operation has cleared (a rebase
+ * conflict that the retried rebase resolved). Blockers that do not match stay,
+ * and the mission stays blocked while any remain — recovery is always "the
+ * recorded blockers are gone", never a status assignment.
+ * @param {Mission} mission
+ * @param {(blocker: string) => boolean} matches
+ * @param {number} [now]
+ * @returns {boolean} whether any blocker was removed
+ */
+export function resolveBlockers(mission, matches, now = Date.now()) {
+  const blockers = /** @type {string[]} */ (mission.blockers ?? [])
+  const kept = blockers.filter((blocker) => !matches(blocker))
+  if (kept.length === blockers.length) return false
+  mission.blockers = kept
+  if (kept.length === 0 && mission.status === 'blocked') mission.status = 'active'
+  mission.updatedAt = now
+  return true
+}
+
 /**
  * Apply one validated `tower_mission` patch to the mission draft and return
  * the human-readable change list used by the activity log plus the domain
@@ -82,34 +124,80 @@ export function applyMissionUpdate({ mission, state, input, config }) {
   /** @type {Array<{ type: string, missionId: string }>} */
   const events = []
 
+  const shape = shapeFor(mission.kind)
+  // W3: `blocked` is derived state, `paused` is a deliberate stop. Clearing the
+  // blockers is what resumes a blocked mission, so it is applied before any
+  // status patch: `{clear_blockers:true,status:"active"}` and
+  // `{clear_blockers:true,status:"completed"}` both describe one coherent step.
+  if (input.clear_blockers === true) {
+    if ((mission.blockers ?? []).length > 0) {
+      mission.blockers = []
+      changes.push('blockers cleared')
+    }
+    if (mission.status === 'blocked') {
+      mission.status = 'active'
+      changes.push('status=active (blocked until the blockers were cleared)')
+    }
+  }
   if (input.status !== undefined) {
-    if (typeof input.status !== 'string' || !MISSION_STATUSES.includes(input.status)) {
-      fail(`unknown mission status "${input.status}"`)
+    if (typeof input.status !== 'string' || !shape.statuses.includes(input.status)) {
+      fail(`unknown mission status "${input.status}" for a ${shape.kind} mission`)
     }
     if (input.status === 'merged') {
       fail('merged is recorded only by tower_merge, not by a generic mission patch', 'invalid-transition')
     }
-    if (!canTransition(mission.status, input.status)) {
-      fail(`mission ${mission.id} cannot move from ${mission.status} to ${input.status}`, 'invalid-transition')
+    if (input.status === 'blocked') {
+      fail(
+        'blocked is derived from open blockers: record blocker:"..." instead of setting status "blocked"',
+        'invalid-transition',
+      )
     }
-    if (input.status === 'paused') {
-      mission.pauseCause = normalizePauseCause(input.pause_cause)
+    const openBlockers = mission.blockers ?? []
+    if (mission.status === 'blocked' && input.status !== 'abandoned') {
+      // A blocked mission is resumed by clearing its blockers, never by a
+      // status patch that skips the blocker record (#149 W3).
+      fail(
+        `mission ${mission.id} is blocked (${openBlockers.join('; ')}); clear_blockers resumes it — it cannot move to ${input.status} directly`,
+        'invalid-transition',
+      )
     }
-    if (mission.status === 'paused' && input.status === 'active') {
-      const requireAuthorization = config.mode.requireResumeAuthorization === true
-      if (requireAuthorization && (mission.pauseCause ?? 'user') === 'user') {
-        if (typeof input.authorization !== 'string' || input.authorization.trim().length === 0) {
-          fail('resuming a user-paused mission requires a non-empty authorization reference')
-        }
+    if (openBlockers.length > 0 && ['active', 'completed', 'paused'].includes(input.status)) {
+      fail(
+        `mission ${mission.id} has open blockers (${openBlockers.join('; ')}); clear_blockers resumes it — do not move it to ${input.status}`,
+        'invalid-transition',
+      )
+    }
+    // A status patch is a real move: the target must differ and be a legal edge.
+    // `paused` is re-entered only from a different status (a pause cause is
+    // meaningful when the pause begins, not as an in-place metadata edit).
+    // `{clear_blockers:true,status:"active"}` is one coherent resume step: the
+    // clear already moved the mission, so the redundant patch is not a second
+    // transition.
+    const redundantResume =
+      input.clear_blockers === true && input.status === 'active' && mission.status === 'active'
+    if (!redundantResume) {
+      if (!shape.canTransition(mission.status, input.status)) {
+        fail(`mission ${mission.id} cannot move from ${mission.status} to ${input.status}`, 'invalid-transition')
       }
-      if (typeof input.authorization === 'string' && input.authorization.trim()) {
-        mission.authorizationRef = input.authorization.trim()
+      if (input.status === 'paused') {
+        mission.pauseCause = normalizePauseCause(input.pause_cause)
       }
+      if (mission.status === 'paused' && input.status === 'active') {
+        const requireAuthorization = config.mode.requireResumeAuthorization === true
+        if (requireAuthorization && (mission.pauseCause ?? 'user') === 'user') {
+          if (typeof input.authorization !== 'string' || input.authorization.trim().length === 0) {
+            fail('resuming a user-paused mission requires a non-empty authorization reference')
+          }
+        }
+        if (typeof input.authorization === 'string' && input.authorization.trim()) {
+          mission.authorizationRef = input.authorization.trim()
+        }
+      }
+      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))
     }
-    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) {
@@ -144,20 +232,23 @@ export function applyMissionUpdate({ mission, state, input, config }) {
     if (typeof input.blocker !== 'string' || input.blocker.trim().length === 0) {
       fail('blocker must be a non-empty string')
     }
-    if (TERMINAL.has(mission.status)) {
+    if (shape.isTerminal(mission.status)) {
       fail(`mission ${mission.id} is ${mission.status}; a blocker cannot reopen a terminal mission`)
     }
     const blockers = /** @type {string[]} */ (mission.blockers)
     blockers.push(input.blocker.trim())
-    mission.status = 'blocked'
+    // W3: a blocker always wins over a pause; the paused cause is superseded and
+    // the mission is blocked until the blockers are cleared.
+    if (mission.status !== 'blocked') {
+      if (!shape.canTransition(mission.status, 'blocked')) {
+        fail(`mission ${mission.id} cannot move from ${mission.status} to blocked`, 'invalid-transition')
+      }
+      if (mission.status === 'paused') delete mission.pauseCause
+      mission.status = 'blocked'
+    }
     changes.push('blocker added')
   }
 
-  if (input.clear_blockers === true) {
-    mission.blockers = []
-    changes.push('blockers cleared')
-  }
-
   if (input.note !== undefined) {
     if (typeof input.note !== 'string' || input.note.trim().length === 0) {
       fail('note must be a non-empty string')
@@ -168,16 +259,21 @@ export function applyMissionUpdate({ mission, state, input, config }) {
   }
 
   if (input.scope !== undefined) {
+    if (!shape.reach.ownsPaths) {
+      fail(`mission ${mission.id} is a ${shape.kind}: it reads a commit and does not own scope`)
+    }
     if (!['active', 'completed'].includes(mission.status)) {
       fail(`scope can only be widened for active or completed missions, not ${mission.status}`)
     }
-    const scope = normalizeScope(input.scope, { allowEmpty: mission.kind === 'survey' })
-    const others = state.missions.filter(
-      (entry) => entry.id !== mission.id && !TERMINAL.has(entry.status) && entry.kind !== 'survey',
-    )
+    const scope = normalizeScope(input.scope)
+    const others = state.missions.filter((entry) => {
+      if (entry.id === mission.id) return false
+      const other = shapeFor(entry.kind)
+      return other.reach.ownsPaths && !other.isTerminal(entry.status)
+    })
     const caseInsensitive = state.caseInsensitive === true
     for (const other of others) {
-      if (mission.kind !== 'survey' && scopesOverlap(scope, other.scope, { caseInsensitive })) {
+      if (scopesOverlap(scope, other.scope, { caseInsensitive })) {
         fail(`widened scope overlaps mission ${other.id}; retire it or add an explicit ordering`)
       }
     }

package/domain/missions/plan.js

@@ -6,6 +6,7 @@
 import { TowerToolError } from '../errors.js'
 import { plannedEvents } from '../events.js'
 import { normalizeScope, validateTitle } from '../scope.js'
+import { SHAPE_KINDS, shapeFor } from '../shapes/index.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
 /** @typedef {import('../../types/index.js').TowerState} TowerState */
@@ -28,15 +29,30 @@ function isPlainObject(value) {
 
 /**
  * Validate and normalize one `tower_plan` mission entry.
+ *
+ * The shape owns the kind-specific plan fields: a build normalizes its scope, a
+ * survey records the commit it reads (`read.commit`, resolved by app/plan from
+ * `state.base`) plus the tracked-status fingerprint captured at the same moment.
  * @param {any} input
  * @param {number} index
+ * @param {{ commit?: string, dirty?: string[] }} [read]
  * @returns {any}
  */
-export function normalizeMissionInput(input, index) {
+export function normalizeMissionInput(input, index, read = {}) {
   if (!isPlainObject(input)) fail(`missions[${index}] must be an object`)
   const title = validateTitle(input.title)
-  const kind = input.kind === 'survey' ? 'survey' : 'build'
-  const scope = normalizeScope(input.scope ?? [], { allowEmpty: kind === 'survey' })
+  const kind = input.kind === undefined ? 'build' : input.kind
+  if (typeof kind !== 'string' || !SHAPE_KINDS.includes(kind)) {
+    fail(`missions[${index}].kind must be one of ${SHAPE_KINDS.join('|')}`)
+  }
+  const shape = shapeFor(kind)
+  /** @type {string[]} */
+  const scopeInput = input.scope ?? []
+  if (!Array.isArray(scopeInput)) fail(`missions[${index}].scope must be an array of globs`)
+  if (!shape.reach.ownsPaths && scopeInput.length > 0) {
+    fail(`missions[${index}] is a ${shape.kind}: it reads a commit and does not own a write scope`)
+  }
+  const scope = shape.reach.ownsPaths ? normalizeScope(scopeInput) : []
   /** @type {Array<{ text: string, status: string }>} */
   const tasks = []
   if (input.tasks !== undefined) {
@@ -80,19 +96,25 @@ export function normalizeMissionInput(input, index) {
   if (reviewPolicy === 'none' && reviewExemptionReason.length === 0) {
     fail(`missions[${index}].reviewPolicy "none" requires a non-empty reviewExemptionReason`)
   }
-  return { title, kind, scope, tasks, deps, context, references, reviewPolicy, reviewExemptionReason }
+  const fields = /** @type {any} */ (/** @type {any} */ (shape).planFields)({
+    scope,
+    readCommit: read.commit,
+    readDirty: read.dirty,
+  })
+  return { title, kind, ...fields, tasks, deps, context, references, reviewPolicy, reviewExemptionReason }
 }
 
 /**
  * Validate the plan envelope and normalize every mission entry.
  * @param {any} input
+ * @param {{ commit?: string, dirty?: string[] }} [read]
  * @returns {any[]}
  */
-export function normalizePlanMissions(input) {
+export function normalizePlanMissions(input, read = {}) {
   if (!Array.isArray(input.missions) || input.missions.length === 0) {
     fail('tower_plan needs at least one mission')
   }
-  return input.missions.map((mission, index) => normalizeMissionInput(mission, index))
+  return input.missions.map((mission, index) => normalizeMissionInput(mission, index, read))
 }
 
 /**
@@ -147,6 +169,8 @@ export function newMission(id, input, now) {
     scopeGeneration: 1,
     createdAt: now,
     updatedAt: now,
+    ...(input.readCommit === undefined ? {} : { readCommit: input.readCommit }),
+    ...(input.readDirty === undefined ? {} : { readDirty: input.readDirty }),
   }))
 }
 

package/domain/missions/review.js

@@ -7,6 +7,7 @@
 import { TowerToolError } from '../errors.js'
 import { reviewedEvent } from '../events.js'
 import { MERGE_VERDICTS, REVIEW_STATUS_RE } from '../mission.js'
+import { isReviewerRole } from '../roles.js'
 
 /** @typedef {import('../../types/index.js').Mission} Mission */
 /** @typedef {import('../../types/index.js').RosterEntry} RosterEntry */
@@ -47,7 +48,7 @@ export function resolveReviewActor({ mission, caller, actorRole, agentId, breakG
     return { reviewerName: 'tower', reviewerRole: 'tower' }
   }
   if (caller) {
-    if (caller.role !== 'reviewer') {
+    if (!isReviewerRole(caller.role)) {
       fail(`agent ${caller.name} is a ${caller.role}; only an assigned reviewer or the tower (break-glass) may review`)
     }
     if (caller.missionId !== mission.id) {
@@ -92,23 +93,6 @@ export function normalizeReviewVerdict(input) {
   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`,
-    )
-  }
-}
-
 /**
  * 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

package/domain/planning.js

@@ -2,7 +2,7 @@
 // @ts-check
 import { TowerToolError } from './errors.js'
 import { scopesOverlap } from './scope.js'
-import { isTerminal } from './mission.js'
+import { shapeFor } from './shapes/index.js'
 
 /** @typedef {import('../types/index.js').Mission} Mission */
 
@@ -93,7 +93,7 @@ function assertAcyclic(missions) {
  * @returns {void}
  */
 function addAutoDeps(newMissions, existingMissions, { caseInsensitive = false } = {}) {
-  const openExisting = existingMissions.filter((mission) => !isTerminal(mission.status))
+  const openExisting = existingMissions.filter((mission) => !shapeFor(mission.kind).isTerminal(mission.status))
   const all = [...existingMissions, ...newMissions]
   /** @type {Map<string, Mission>} */
   const byId = new Map(all.map((mission) => [mission.id, mission]))
@@ -102,15 +102,15 @@ function addAutoDeps(newMissions, existingMissions, { caseInsensitive = false }
     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 (!shapeFor(earlier.kind).reach.ownsPaths || !shapeFor(later.kind).reach.ownsPaths) continue
       if (!scopesOverlap(earlier.scope, later.scope, { caseInsensitive })) continue
       if (hasDependencyPath(byId, later.id, earlier.id)) continue
       addDependency(later, earlier.id)
     }
     const mission = newMissions[i]
-    if (mission.kind === 'survey') continue
+    if (!shapeFor(mission.kind).reach.ownsPaths) continue
     for (const other of openExisting) {
-      if (other.kind === 'survey') continue
+      if (!shapeFor(other.kind).reach.ownsPaths) continue
       if (!scopesOverlap(mission.scope, other.scope, { caseInsensitive })) continue
       if (hasDependencyPath(byId, mission.id, other.id)) continue
       addDependency(mission, other.id)

package/domain/read/missionContext.js

@@ -10,10 +10,13 @@ import { fullMission, findingSummary } from '../summary.js'
  * @param {object} input
  * @param {TowerState} input.state
  * @param {Mission} input.mission
+ * @param {Array<Record<string, any>> | Map<string, Record<string, any>>} [input.archived] archive index entries (or a by-id map) so a dependency that has already been archived keeps its evidence
  * @returns {object}
  */
-export function missionContextView({ state, mission }) {
+export function missionContextView({ state, mission, archived = [] }) {
   const byId = new Map(state.missions.map((entry) => [entry.id, entry]))
+  const archivedById =
+    archived instanceof Map ? archived : new Map(archived.map((entry) => [entry.id, entry]))
   const branch = mission.worktree ? mission.worktree.branch : null
   const reviews = branch
     ? (state.reviews ?? [])
@@ -46,8 +49,19 @@ export function missionContextView({ state, mission }) {
     })),
     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' }
+      const dep = byId.get(id) ?? archivedById.get(id)
+      if (!dep) return { id, title: null, status: 'unknown' }
+      return {
+        id,
+        title: dep.title,
+        kind: dep.kind,
+        status: dep.status,
+        readCommit: dep.readCommit ?? null,
+        // #148 D6: a survey's completion evidence travels with the dependency
+        // context so a dependent build worker sees what was found, not only that
+        // the survey finished. Formatting/clipping is the briefing's job.
+        result: dep.result ?? null,
+      }
     }),
   }
 }

package/domain/read/views.js

@@ -125,16 +125,20 @@ export function patchLimit(maxBytes) {
  * @param {string[]} input.files
  * @param {string[]} input.commits
  * @param {string} input.fullPatch
+ * @param {string|null} [input.reviewedCommit]
  * @param {number} [input.maxBytes]
  * @returns {object}
  */
-export function diffView({ mission, baseTip, branchTip, mergeBase, files, commits, fullPatch, maxBytes }) {
+export function diffView({ mission, baseTip, branchTip, mergeBase, files, commits, fullPatch, maxBytes, reviewedCommit = null }) {
   const limit = patchLimit(maxBytes)
   return {
     missionId: mission.id,
     branch: mission.worktree ? mission.worktree.branch : null,
     baseTip,
     branchTip,
+    // #149 W3: a reviewer sees (and is stamped with) one recorded commit; the
+    // field is null for every other caller reading the live branch.
+    reviewedCommit,
     mergeBase,
     files,
     commits,