@shanesaravia/hive 0.2.0 → 0.3.0

package/packages/server/dist/plans/plansStore.js

@@ -124,8 +124,11 @@ export class PlansStore {
         const now = Date.now();
         const mapTasks = (tasks) => tasks.map((task) => {
             const subtasks = task.subtasks?.length ? mapTasks(task.subtasks) : task.subtasks;
+            // A worker is addressed by whichever name the orchestrator used; the plan
+            // stores the canonical identity so every consumer can compare exactly.
+            const workerNames = [input.canonicalWorker, input.targetWorker].filter((value) => Boolean(value));
             const matched = (input.targetTask !== undefined && task.id === input.targetTask)
-                || (input.targetWorker !== undefined && (task.workerId === input.targetWorker || task.owner === input.targetWorker));
+                || workerNames.some((name) => task.workerId === name || task.owner === name);
             // A parent cannot complete ahead of its subtasks (normalize rejects it).
             const blockedBySubtasks = nextStatus === "completed" && (subtasks ?? []).some((subtask) => subtask.status !== "completed" && subtask.status !== "cancelled");
             if (!matched || blockedBySubtasks || !allowedFrom[nextStatus].includes(task.status)) {
@@ -138,8 +141,8 @@ export class PlansStore {
                 status: nextStatus,
                 updatedAt: now,
                 startedAt: task.startedAt ?? now,
-                owner: task.owner ?? input.targetWorker,
-                workerId: task.workerId ?? input.targetWorker,
+                owner: task.owner ?? input.canonicalWorker ?? input.targetWorker,
+                workerId: input.canonicalWorker ?? task.workerId ?? input.targetWorker,
                 evidence: nextStatus === "completed" && input.evidence?.trim() ? [...task.evidence, input.evidence.trim().slice(0, 300)] : task.evidence,
             };
         });
@@ -157,6 +160,46 @@ export class PlansStore {
             return undefined;
         return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: phases[0]?.tasks ?? [] } : { phases }), gates: plan.gates ?? [], approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason });
     }
+    /**
+     * Records that a worker is running a task: stamps the canonical identity and
+     * advances a queued/blocked task to working. Forward-only and idempotent, so
+     * a repeated snapshot cannot churn revisions, and never marks work complete —
+     * a running worker proves work started, not that it succeeded.
+     */
+    attachWorker(missionId, input) {
+        const plan = this.get(missionId);
+        if (!plan)
+            return undefined;
+        let changed = false;
+        const now = Date.now();
+        const mapTasks = (tasks) => tasks.map((task) => {
+            const subtasks = task.subtasks?.length ? mapTasks(task.subtasks) : task.subtasks;
+            if (task.id !== input.taskId)
+                return subtasks === task.subtasks ? task : { ...task, subtasks };
+            const advancing = task.status === "queued" || task.status === "blocked";
+            if (task.workerId === input.canonicalWorker && !advancing)
+                return subtasks === task.subtasks ? task : { ...task, subtasks };
+            changed = true;
+            return {
+                ...task,
+                subtasks,
+                status: advancing ? "working" : task.status,
+                owner: task.owner ?? input.label ?? input.canonicalWorker,
+                workerId: input.canonicalWorker,
+                startedAt: task.startedAt ?? now,
+                updatedAt: now,
+            };
+        });
+        const phases = plan.phases.map((phase) => {
+            const tasks = mapTasks(phase.tasks);
+            const statuses = allPlanTasks(tasks).map((task) => task.status);
+            const status = (phase.status === "queued" || phase.status === "completed") && statuses.some((s) => s === "working" || s === "reviewing") ? "working" : phase.status;
+            return { ...phase, status, tasks };
+        });
+        if (!changed)
+            return undefined;
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: phases[0]?.tasks ?? [] } : { phases }), gates: plan.gates ?? [], approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason });
+    }
     removeMission(missionId) { this.db.transaction(() => { this.db.prepare("DELETE FROM mission_plans WHERE mission_id = ?").run(missionId); this.db.prepare("DELETE FROM mission_plan_revisions WHERE mission_id = ?").run(missionId); })(); for (const listener of this.listeners)
         listener(); }
     migrateMission(oldId, newId) { this.db.transaction(() => { const current = this.get(oldId); if (current) {

package/packages/server/dist/roster/missionReplay.js

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MissionsStore } from "../missions/missionsStore.js";
+import { buildFleetSnapshot } from "./rosterBuilder.js";
+import { WorkerIdentityStore } from "./workerIdentity.js";
+const fixturesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures");
+export function loadMissionFixture(name) {
+    return JSON.parse(fs.readFileSync(path.join(fixturesDir, `${name}.events.json`), "utf8"));
+}
+/**
+ * The manager's job is `done` between a Stop and the next prompt — the turn
+ * boundary that repeatedly got mistaken for the end of the mission.
+ */
+function jobStateAt(events) {
+    let state = "working";
+    for (const event of events) {
+        if (event.hookEventName === "Stop")
+            state = "done";
+        if (event.hookEventName === "UserPromptSubmit")
+            state = "working";
+    }
+    return state;
+}
+export function replayMission(fixture, options = {}) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `hive-replay-${fixture.name}-`));
+    options.cleanup?.(() => fs.rmSync(dir, { recursive: true, force: true }));
+    const missions = new MissionsStore(path.join(dir, "missions.json"), path.join(dir, "threads.json"));
+    missions.init();
+    const primaryJob = fixture.jobs[0];
+    const mission = missions.create({
+        name: fixture.name, objective: fixture.objective, jobId: primaryJob?.jobId ?? fixture.missionId,
+        sessionId: fixture.sessionId, mode: fixture.mode,
+    });
+    for (const { jobId } of fixture.jobs.slice(1))
+        missions.linkJob(mission.id, jobId);
+    const identity = new WorkerIdentityStore(path.join(dir, "hive.db"));
+    // A read-only stand-in for the plans store: the recorded revisions already
+    // contain the worker bindings production wrote, so replaying must not write
+    // new ones over them.
+    const revisions = [...(fixture.planRevisions ?? [])].sort((a, b) => a.updatedAt - b.updatedAt);
+    const plansAt = (at) => ({
+        get: () => [...revisions].reverse().find((entry) => entry.updatedAt <= at)?.plan,
+        attachWorker: () => undefined,
+    });
+    const start = fixture.events[0]?.ts ?? 0;
+    const steps = [];
+    for (let index = 1; index <= fixture.events.length; index += 1) {
+        const seen = fixture.events.slice(0, index);
+        const event = seen[seen.length - 1];
+        const now = event.ts + 1;
+        // The REST ingest moves the mission to review on this event; a replay that
+        // left it active never showed the office the moment the manager leaves
+        // for the hall while workers are still on their way out (mission test41).
+        if (event.source === "custom" && event.phase === "ready_for_review")
+            missions.setLifecycleStatus(mission.id, "ready_for_review");
+        const state = jobStateAt(seen);
+        const jobs = new Map(fixture.jobs.map(({ jobId, job }) => [jobId, {
+                ...job,
+                state,
+                // The provider's fan file is written as workers finish; before the turn
+                // ends the roster only has hook evidence to go on. A recorded fixture
+                // holds the file's *final* contents, so entries — and their doneAt — are
+                // masked until the moment they were really written. Without that the
+                // replay hands the roster a worker's completion long before it happened.
+                fan: state === "done"
+                    ? job.fan.filter((entry) => entry.startedAt <= now).map((entry) => ({ ...entry, doneAt: entry.doneAt !== undefined && entry.doneAt <= now ? entry.doneAt : undefined }))
+                    : [],
+            }]));
+        const events = {
+            recentFor: (id, limit = 50) => seen.filter((item) => item.sessionId === id || item.jobId === id).slice(-limit),
+            sessionIds: () => [...new Set(seen.map((item) => item.sessionId))],
+        };
+        steps.push({ elapsedMs: event.ts - start, event, snapshot: buildFleetSnapshot(new Map(), jobs, events, missions, undefined, plansAt(now), now, identity) });
+    }
+    return steps;
+}
+/** The mission node under replay, for the one mission a fixture contains. */
+export function replayedMission(step) {
+    return step.snapshot.orchestrators[0];
+}

package/packages/server/dist/roster/rosterBuilder.js

@@ -1,7 +1,9 @@
 import { deriveStatus, } from "@hive/shared";
 import { allPlanTasks } from "../plans/plansStore.js";
+import { deriveChangedFiles, reconcilePlanWorkers } from "../plans/planReconcile.js";
 import { config } from "../config.js";
 import { deriveAlerts } from "../health/deriveAlerts.js";
+import { resolveMissionWorkers } from "./workerIdentity.js";
 const ORCHESTRATOR_AGENT_NAME = "hive-orchestrator";
 function dateMs(value) {
     const parsed = value ? Date.parse(value) : NaN;
@@ -18,7 +20,7 @@ function resultText(job) {
     return undefined;
 }
 /** Joins Claude's short-lived jobs into durable, Hive-managed missions. */
-export function buildFleetSnapshot(sessions, jobs, events, missions, messageStore, planStore, now = Date.now()) {
+export function buildFleetSnapshot(sessions, jobs, events, missions, messageStore, planStore, now = Date.now(), workerIdentity) {
     const workerCorrelationGraceMs = 8_000;
     const orchestrators = [];
     const other = [];
@@ -52,6 +54,51 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
         group.push({ jobId, job });
         groups.set(missionId, group);
     }
+    // Per-mission pending decisions. Used both for the global inbox and, inside the
+    // mission loop, to keep a mission reading as waiting_on_you for as long as a
+    // decision is unanswered — even after the provider session record has gone
+    // quiet — so the office lighting, desk, status pill, and "?" badge agree.
+    const pendingDecisionsFor = (node) => {
+        if (node.lifecycleStatus === "completed" || node.lifecycleStatus === "archived")
+            return [];
+        const resolved = new Set(node.recentEvents.filter((event) => event.phase === "decision_resolved" && event.decisionId).map((event) => event.decisionId));
+        const missionContext = { missionObjective: node.mission.objective || undefined, repository: node.mission.repository };
+        // Only the current, mid-turn blocker belongs in the decision inbox. An
+        // unresolved event from an older/completed turn is history: the mission
+        // may remain open for optional follow-up, but it is not waiting on the
+        // user. Requiring the blocker to be the latest observed event also clears
+        // it as soon as provider activity resumes.
+        const latestEvent = node.recentEvents.at(-1);
+        const fromEvents = !node.turnCompleted && latestEvent?.phase === "blocked_on_user"
+            && latestEvent.decisionId && !resolved.has(latestEvent.decisionId)
+            && (!latestEvent.jobId || latestEvent.jobId === node.jobId)
+            ? [{
+                    id: latestEvent.decisionId, missionId: node.missionId, missionName: node.name,
+                    kind: latestEvent.decisionKind ?? "question", question: latestEvent.detail, context: latestEvent.context,
+                    choices: latestEvent.choices ?? [], recommendation: latestEvent.recommendation, impact: latestEvent.impact, createdAt: latestEvent.ts, ...missionContext,
+                }]
+            : [];
+        // A permission prompt parks the session mid-turn (tempo blocked, the ask
+        // in needs) with no TTY to answer it — surface it as an answerable
+        // decision. It self-clears once the job is no longer parked.
+        const latestJob = jobs.get(node.jobId);
+        const parked = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && /^approve\s/i.test(latestJob.needs) && !resolved.has(`perm:${node.jobId}`)
+            ? [{
+                    id: `perm:${node.jobId}`, missionId: node.missionId, missionName: node.name,
+                    kind: "permission", question: latestJob.needs, context: latestJob.detail,
+                    choices: ["Approve & continue", "Deny"], impact: "The session is parked at this prompt until you answer.", createdAt: node.updatedAt, ...missionContext,
+                }]
+            : [];
+        const hasStructuredPrompt = node.recentEvents.some((event) => event.jobId === node.jobId && event.phase === "blocked_on_user" && event.decisionId?.startsWith("skill-prompt:"));
+        const providerPrompt = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && (latestJob.promptChoices?.length ?? 0) > 0 && !/^approve\s/i.test(latestJob.needs) && !/rate limit|spend limit/i.test(latestJob.needs) && !hasStructuredPrompt && !resolved.has(`prompt:${node.jobId}`)
+            ? [{
+                    id: `prompt:${node.jobId}`, missionId: node.missionId, missionName: node.name,
+                    kind: "question", question: latestJob.needs, context: latestJob.detail,
+                    choices: latestJob.promptChoices ?? [], impact: "The provider is waiting for this answer before the skill can continue.", createdAt: node.updatedAt, ...missionContext,
+                }]
+            : [];
+        return [...fromEvents, ...parked, ...providerPrompt];
+    };
     for (const [missionId, group] of groups) {
         group.sort((a, b) => dateMs(a.job.createdAt) - dateMs(b.job.createdAt));
         const latest = group[group.length - 1];
@@ -79,7 +126,7 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
                 .map((event) => [`${event.sessionId}:${event.jobId ?? ""}:${event.ts}:${event.phase}:${event.decisionId ?? ""}:${event.targetWorker ?? ""}:${event.detail}`, event])).values()]
             .sort((a, b) => a.ts - b.ts);
         let recentEvents = allEvents.slice(-100);
-        let workers = group.flatMap(({ jobId, job }) => (job.fan ?? []).filter((worker) => worker.kind === "agent" || worker.kind === "subagent").map((worker) => ({
+        const fanWorkers = group.flatMap(({ jobId, job }) => (job.fan ?? []).filter((worker) => worker.kind === "agent" || worker.kind === "subagent").map((worker) => ({
             ...worker,
             jobId,
             jobState: job.state,
@@ -89,150 +136,41 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
             const linkedSession = sessionsByJob.get(jobId);
             return [...(job.sessionId ? [[job.sessionId, jobId]] : []), ...(linkedSession ? [[linkedSession.sessionId, jobId]] : [])];
         }));
-        const jobStateById = new Map(group.map(({ jobId, job }) => [jobId, job.state]));
-        const parentTurnFinished = (jobId) => ["done", "completed", "failed", "error", "cancelled", "canceled", "stopped"].includes((jobStateById.get(jobId) ?? "").toLowerCase());
         const eventJobId = (event) => event.jobId ?? jobIdBySession.get(event.sessionId);
-        // A job's fan array is only a current view and can drop an earlier worker
-        // as soon as a later worker starts. Rebuild the durable native roster from
-        // hook history, keyed by Claude's real agent id, and merge fan metadata.
-        const nativeEvidence = new Map();
-        for (const event of allEvents) {
-            const resolvedJobId = eventJobId(event);
-            const raw = event.rawPayload && typeof event.rawPayload === "object" ? event.rawPayload : {};
-            const response = raw.tool_response && typeof raw.tool_response === "object" ? raw.tool_response : {};
-            const input = raw.tool_input && typeof raw.tool_input === "object" ? raw.tool_input : {};
-            const launchId = typeof response.agentId === "string" ? response.agentId : typeof response.agent_id === "string" ? response.agent_id : undefined;
-            const nativeId = launchId ?? event.targetWorker;
-            if (!resolvedJobId || !nativeId || nativeId === "hive-orchestrator")
-                continue;
-            const isStart = event.hookEventName === "SubagentStart" || (event.hookEventName === "PostToolUse" && event.toolName === "Agent" && Boolean(launchId));
-            const isStop = event.hookEventName === "SubagentStop";
-            if (!isStart && !isStop)
-                continue;
-            const label = typeof response.description === "string" ? response.description : typeof input.description === "string" ? input.description : nativeId;
-            const key = `${resolvedJobId}:${nativeId}`;
-            const prior = nativeEvidence.get(key);
-            // A stop without any observed launch is often a nested/background task
-            // notification. It is evidence, but not enough to invent a person.
-            if (isStop && !prior)
-                continue;
-            nativeEvidence.set(key, {
-                id: nativeId,
-                jobId: resolvedJobId,
-                label: prior?.label !== prior?.id ? prior.label : label,
-                startedAt: Math.min(prior?.startedAt ?? event.ts, event.ts),
-                doneAt: isStop ? event.ts : isStart ? undefined : prior?.doneAt,
-                updatedAt: event.ts,
-                running: isStart,
-            });
-        }
-        const workerByNativeKey = new Map(workers.map((worker) => [`${worker.jobId}:${worker.id}`, worker]));
-        for (const native of nativeEvidence.values()) {
-            const key = `${native.jobId}:${native.id}`;
-            const fanWorker = workerByNativeKey.get(key);
-            const turnFinished = parentTurnFinished(native.jobId);
-            // SubagentStop is the worker's own terminal lifecycle boundary. The
-            // manager may remain idle/open for follow-up, but that must not keep a
-            // finished worker seated indefinitely. A later SubagentStart for the
-            // same native id clears native.doneAt above and resumes that person.
-            const workerFinished = Boolean(native.doneAt) || turnFinished;
-            const merged = fanWorker ? {
-                ...fanWorker,
-                label: fanWorker.label || native.label,
-                startedAt: Math.min(fanWorker.startedAt, native.startedAt),
-                doneAt: native.doneAt ?? (turnFinished ? fanWorker.doneAt : undefined),
-                updatedAt: Math.max(fanWorker.updatedAt ?? 0, native.updatedAt),
-                jobState: workerFinished ? "done" : native.running ? "working" : "idle",
-            } : {
-                id: native.id,
-                kind: "agent",
-                label: native.label,
-                startedAt: native.startedAt,
-                doneAt: native.doneAt,
-                updatedAt: native.updatedAt,
-                jobId: native.jobId,
-                jobState: workerFinished ? "done" : native.running ? "working" : "idle",
-            };
-            workerByNativeKey.set(key, merged);
+        const missionSummary = missions?.summaryFor(missionId, oldest.job.intent ?? "");
+        // One canonical person per delegated job. The resolver owns every identity
+        // decision — native ids, delegation labels, plan tasks, nested agents —
+        // and persists them so a later poll cannot re-decide them differently.
+        const resolved = resolveMissionWorkers({
+            missionId,
+            fanWorkers,
+            events: allEvents,
+            eventJobId,
+            planTasks: planStore?.get(missionId)?.phases.flatMap((phase) => allPlanTasks(phase.tasks)),
+            missionActive: (missionSummary?.lifecycleStatus ?? "active") === "active",
+            seeded: workerIdentity?.list(missionId),
+            seededNested: workerIdentity?.listNested(missionId),
+            now,
+            correlationGraceMs: workerCorrelationGraceMs,
+        });
+        let workers = resolved.workers;
+        if (workerIdentity && resolved.dirty) {
+            workerIdentity.save(missionId, resolved.records);
+            workerIdentity.saveNested(missionId, resolved.nested);
         }
-        workers = [...workerByNativeKey.values()];
-        // A resumed/follow-up job may address the same provider-native agent id.
-        // The mission roster is person-oriented, so expose that id once using its
-        // latest lifecycle state instead of creating duplicate React/desk actors
-        // for each short-lived parent job.
-        const workersByIdentity = new Map();
-        for (const worker of workers.sort((a, b) => a.startedAt - b.startedAt || a.id.localeCompare(b.id))) {
-            const prior = workersByIdentity.get(worker.id);
-            if (!prior) {
-                workersByIdentity.set(worker.id, worker);
-                continue;
+        // Keep the board honest without waiting for the orchestrator to republish
+        // it: a worker that is provably running advances its task to working.
+        if (planStore) {
+            // `doneAt` is the only lifecycle signal; `jobState` is decoration.
+            const present = workers.filter((worker) => !worker.doneAt);
+            for (const binding of reconcilePlanWorkers(planStore.get(missionId), present)) {
+                planStore.attachWorker(missionId, binding);
+                if (binding.inferred)
+                    workerIdentity?.addTaskBinding(missionId, binding.canonicalWorker, binding.taskId);
             }
-            const priorFreshness = prior.updatedAt ?? prior.doneAt ?? prior.startedAt;
-            const workerFreshness = worker.updatedAt ?? worker.doneAt ?? worker.startedAt;
-            const latest = workerFreshness >= priorFreshness ? worker : prior;
-            workersByIdentity.set(worker.id, {
-                ...latest,
-                label: latest.label || prior.label,
-                startedAt: Math.min(prior.startedAt, worker.startedAt),
-            });
         }
-        workers = [...workersByIdentity.values()];
-        // Friendly/custom worker names are presentation aliases only. Native
-        // Claude ids remain canonical so close or repeated delegations can never
-        // swap React identities or manufacture an extra avatar.
-        const workerAliases = new Map();
-        const claimedNativeWorkers = new Set();
-        for (const event of allEvents.filter((candidate) => candidate.source === "custom" && candidate.phase === "delegating" && candidate.targetWorker)) {
-            const resolvedJobId = eventJobId(event);
-            if (!resolvedJobId)
-                continue;
-            const aliasKey = `${resolvedJobId}:${event.targetWorker}`;
-            const candidate = workers
-                .filter((worker) => worker.jobId === resolvedJobId && !claimedNativeWorkers.has(worker.id) && Math.abs(worker.startedAt - event.ts) <= 30_000)
-                .sort((a, b) => Math.abs(a.startedAt - event.ts) - Math.abs(b.startedAt - event.ts))[0];
-            workerAliases.set(aliasKey, candidate?.id ?? aliasKey);
-            if (!candidate)
-                continue;
-            claimedNativeWorkers.add(candidate.id);
-        }
-        if (workerAliases.size)
-            recentEvents = recentEvents.map((event) => {
-                if (!event.targetWorker)
-                    return event;
-                const resolvedJobId = eventJobId(event);
-                if (!resolvedJobId)
-                    return event;
-                const key = `${resolvedJobId}:${event.targetWorker}`;
-                const targetWorker = workerAliases.get(key);
-                return targetWorker ? { ...event, targetWorker } : event;
-            });
-        // Claude's fan file can arrive just before its delegation hook. Publishing
-        // that unmatched native id for a single poll makes the office animate a
-        // second person. Hold it briefly for correlation; canonical/event-backed
-        // workers remain immediate, and hookless workers appear after the grace.
-        const correlatedWorkerIds = new Set(recentEvents.filter((event) => event.source === "custom" && event.phase === "delegating").map((event) => event.targetWorker).filter((id) => Boolean(id)));
-        workers = workers.filter((worker) => nativeEvidence.has(`${worker.jobId}:${worker.id}`) || correlatedWorkerIds.has(worker.id) || now - worker.startedAt >= workerCorrelationGraceMs);
+        recentEvents = recentEvents.map(resolved.rewrite);
         const derived = deriveStatus(session, latest.job, recentEvents, now);
-        const workerIds = new Set(workers.map((worker) => worker.id));
-        for (const event of recentEvents) {
-            if (!event.targetWorker || workerIds.has(event.targetWorker))
-                continue;
-            const related = recentEvents.filter((candidate) => candidate.targetWorker === event.targetWorker);
-            const start = related.find((candidate) => candidate.phase === "delegating" || candidate.phase?.toLowerCase().includes("subagentstart") || candidate.hookEventName?.toLowerCase() === "subagentstart");
-            if (!start)
-                continue;
-            // A friendly delegation target is an alias, not a person. Hold every
-            // unmatched identity through the correlation window; a native Agent id
-            // normally arrives within milliseconds and becomes the sole actor.
-            if (now - start.ts < workerCorrelationGraceMs)
-                continue;
-            const done = [...related].reverse().find((candidate) => candidate.phase === "worker_reported" || candidate.phase?.toLowerCase().includes("subagentstop") || candidate.hookEventName?.toLowerCase() === "subagentstop");
-            const resolvedJobId = eventJobId(event);
-            if (!resolvedJobId)
-                continue;
-            workers.push({ id: event.targetWorker, label: event.targetWorker, kind: "subagent", startedAt: start.ts, doneAt: done?.ts, updatedAt: related.at(-1)?.ts, jobId: resolvedJobId, jobState: done ? "done" : latest.job.state });
-            workerIds.add(event.targetWorker);
-        }
         const derivedMessages = group.flatMap(({ jobId, job }) => {
             const createdAt = dateMs(job.createdAt);
             const updatedAt = dateMs(job.updatedAt) || createdAt;
@@ -274,7 +212,9 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
             lifecycleStatus: "active",
             mode: "orchestrated",
         };
-        const missionPlan = planStore?.get(missionId);
+        // Derived at read time rather than written back: the events are the source
+        // of truth, so this always reflects the latest ones without extra writes.
+        const missionPlan = deriveChangedFiles(planStore?.get(missionId), workers, recentEvents);
         const inactiveForMs = Math.max(0, now - updatedAt);
         let activityStatus = derived.status;
         if (mission.lifecycleStatus === "completed" || mission.lifecycleStatus === "archived") {
@@ -298,8 +238,15 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
                 activityStatus = "stalled";
             }
         }
+        const name = missions?.nameFor(missionId) ?? oldest.job.name ?? latest.job.name ?? missionId;
+        const turnCompleted = latest.job.state === "done";
+        const pendingDecisions = pendingDecisionsFor({ missionId, name, jobId: latest.jobId, mission, lifecycleStatus: mission.lifecycleStatus, turnCompleted, recentEvents, updatedAt });
+        // An unanswered decision is, by definition, waiting on the user. Do not let the
+        // runtime's quiet session decay it to idle/stalled while the question stands.
+        if (mission.lifecycleStatus === "active" && pendingDecisions.length && (activityStatus === "idle" || activityStatus === "stalled"))
+            activityStatus = "waiting_on_you";
         const runStartedAt = dateMs(latest.job.createdAt) || createdAt;
-        const alerts = deriveAlerts({ lifecycle: mission.lifecycleStatus, activity: activityStatus, stale: derived.stale, turnCompleted: latest.job.state === "done", workers, events: recentEvents, now, turnTokens: latest.job.tokens ?? 0, runStartedAt });
+        const alerts = deriveAlerts({ lifecycle: mission.lifecycleStatus, activity: activityStatus, stale: derived.stale, turnCompleted, workers, events: recentEvents, now, turnTokens: latest.job.tokens ?? 0, runStartedAt });
         orchestrators.push({
             missionId,
             threadId: missionId,
@@ -312,14 +259,11 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
                 latest.job.resumeSessionId ??
                 latest.jobId,
             pid: session?.pid ?? -1,
-            name: missions?.nameFor(missionId) ??
-                oldest.job.name ??
-                latest.job.name ??
-                missionId,
+            name,
             status: activityStatus,
             lifecycleStatus: mission.lifecycleStatus,
             activityStatus,
-            turnCompleted: latest.job.state === "done",
+            turnCompleted,
             inactiveForMs,
             waitingFor: mission.lifecycleStatus === "completed" || mission.lifecycleStatus === "archived" ? undefined : session?.waitingFor ?? latest.job.needs,
             worktreePath: latest.job.worktreePath ?? oldest.job.worktreePath,
@@ -362,46 +306,6 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
         });
     }
     orchestrators.sort((a, b) => b.updatedAt - a.updatedAt);
-    const decisions = orchestrators.flatMap((node) => {
-        if (node.lifecycleStatus === "completed" || node.lifecycleStatus === "archived")
-            return [];
-        const resolved = new Set(node.recentEvents.filter((event) => event.phase === "decision_resolved" && event.decisionId).map((event) => event.decisionId));
-        const missionContext = { missionObjective: node.mission.objective || undefined, repository: node.mission.repository };
-        // Only the current, mid-turn blocker belongs in the decision inbox. An
-        // unresolved event from an older/completed turn is history: the mission
-        // may remain open for optional follow-up, but it is not waiting on the
-        // user. Requiring the blocker to be the latest observed event also clears
-        // it as soon as provider activity resumes.
-        const latestEvent = node.recentEvents.at(-1);
-        const fromEvents = !node.turnCompleted && latestEvent?.phase === "blocked_on_user"
-            && latestEvent.decisionId && !resolved.has(latestEvent.decisionId)
-            && (!latestEvent.jobId || latestEvent.jobId === node.jobId)
-            ? [{
-                    id: latestEvent.decisionId, missionId: node.missionId, missionName: node.name,
-                    kind: latestEvent.decisionKind ?? "question", question: latestEvent.detail, context: latestEvent.context,
-                    choices: latestEvent.choices ?? [], recommendation: latestEvent.recommendation, impact: latestEvent.impact, createdAt: latestEvent.ts, ...missionContext,
-                }]
-            : [];
-        // A permission prompt parks the session mid-turn (tempo blocked, the ask
-        // in needs) with no TTY to answer it — surface it as an answerable
-        // decision. It self-clears once the job is no longer parked.
-        const latestJob = jobs.get(node.jobId);
-        const parked = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && /^approve\s/i.test(latestJob.needs) && !resolved.has(`perm:${node.jobId}`)
-            ? [{
-                    id: `perm:${node.jobId}`, missionId: node.missionId, missionName: node.name,
-                    kind: "permission", question: latestJob.needs, context: latestJob.detail,
-                    choices: ["Approve & continue", "Deny"], impact: "The session is parked at this prompt until you answer.", createdAt: node.updatedAt, ...missionContext,
-                }]
-            : [];
-        const hasStructuredPrompt = node.recentEvents.some((event) => event.jobId === node.jobId && event.phase === "blocked_on_user" && event.decisionId?.startsWith("skill-prompt:"));
-        const providerPrompt = !node.turnCompleted && latestJob?.tempo === "blocked" && latestJob.needs && (latestJob.promptChoices?.length ?? 0) > 0 && !/^approve\s/i.test(latestJob.needs) && !/rate limit|spend limit/i.test(latestJob.needs) && !hasStructuredPrompt && !resolved.has(`prompt:${node.jobId}`)
-            ? [{
-                    id: `prompt:${node.jobId}`, missionId: node.missionId, missionName: node.name,
-                    kind: "question", question: latestJob.needs, context: latestJob.detail,
-                    choices: latestJob.promptChoices ?? [], impact: "The provider is waiting for this answer before the skill can continue.", createdAt: node.updatedAt, ...missionContext,
-                }]
-            : [];
-        return [...fromEvents, ...parked, ...providerPrompt];
-    }).sort((a, b) => b.createdAt - a.createdAt);
+    const decisions = orchestrators.flatMap((node) => pendingDecisionsFor(node)).sort((a, b) => b.createdAt - a.createdAt);
     return { orchestrators, decisions, other, generatedAt: Date.now() };
 }