@shanesaravia/hive 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 All notable changes to Hive will be documented in this file.
 
+## 0.3.0 — 2026-08-29
+
+Turns a mission's full page into a dashboard, carries the keyboard into it, and settles a run of places where two parts of the board disagreed about one fact.
+
+### Added
+
+- A mission's full page is a dashboard rather than five tabs: the objective and its acceptance criteria, the conversation, and what is happening now sit in three columns that cannot hide each other, with the plan full width beneath them and diagnostics folded away at the foot.
+- Progress measures that say how far along a mission is — phase and gate progress and the files that actually changed — replacing elapsed time, a worker count and the same worker count again.
+- Keyboard control of a mission's own page: `a` and `d` do what the mission is asking, `r` reaches the composer, `p` pauses, `g c` / `g w` / `g p` / `g d` / `g g` jump around the page, `h` and `l` walk the missions still yours to do, and `⇧H` / `⇧L` walk only the ones asking for you.
+- Bulk **Complete** and **Delete**, with `⇧C`, `⇧P`, `⇧A` and `⇧⌫` on the selection bar and `⏎` to commit a confirmation. Archive and Delete arm a confirmation rather than firing, so nothing irreversible happens on a keystroke.
+- Click-to-copy on a mission's repository path, branch and id, and a note on returning to a mission of what arrived while you were away.
+- A **Settings** menu for sound, notifications, workspace policy and templates.
+
+### Changed
+
+- One page width for the board, the office and both mission presentations, which had grown three between them.
+- The Needs you rail leads the board and reads as the most important thing on it; running work now sits above work awaiting acceptance, which the rail directly above it already lists.
+- Bulk Accept and Complete became one **Complete**, over running work and work awaiting acceptance alike, and every bulk control appears only when it applies to the selection.
+- Filters survive a reload, as the sort beside them already did, and the board's shortcuts keep working in the office.
+- **Request changes** asks what should change instead of quietly reopening the mission, and a mission awaiting acceptance reopens when it starts working again rather than because you spoke to it.
+
+### Fixed
+
+- Background sessions launch in `auto`. `bypassPermissions` now requires a one-time interactive disclaimer that a server cannot give on the user's behalf, so every mission launch was failing; a launch that is refused now reports the CLI's own words in about a second instead of a thirty-second timeout.
+- One owner for Escape. Ten independent listeners each guessed whether the key was theirs, so two open slide-overs closed together on one press.
+- Clicking a worker opens that worker beside the board, instead of promoting the whole board to a full page and dropping the worker on the way.
+- The office counts the missions the board says need you. Its floor badges and its avatars each used a different rule, and neither counted a pending decision or an unapproved plan.
+- A card no longer asks you to approve a plan whose work has already run, and a reopened mission stops reporting that it awaits an acceptance.
+- The activity line's tense follows the evidence — `Ran` for a finished command, `Running` only while one is open — and it names a worker's own events rather than labelling them "Worker activity".
+- A stale mission is called stale in the rail, as it already was in its pill and in the filter.
+- Cards keep one shape whatever state they are in, rows end level, and a card's standing summary clamps to the two lines it was always meant to.
+
+## 0.2.1 — 2026-08-25
+
+### Added
+
+- Plan tab shows a "Phases" / "Tasks" section header, clarifying that task numbers are global across phases.
+- Pending decisions appear in the top notice slot as a compact strip and slide-over, visible from every tab and both presentations, replacing the Conversation-tab-only placement.
+- Office desks are click targets that behave exactly like their avatar, across manager, worker, and direct seats in both the fleet floor and the mission room.
+- Shared `DetailDrawer` shell so worker inspection and pending decisions match in width, background, header rhythm, and dismissal.
+
+### Changed
+
+- Mission room collapses its goal to one line, compacts summary tiles, drops duplicate side-panel titles, and lets the room and chat grow with the viewport, adding roughly 100px of chat at 900px tall and 320px on tall displays.
+- Widened the mission room viewBox so the whole floor stays inside the canvas, with height capped to avoid empty canvas beneath it.
+
+### Fixed
+
+- Reclaim a mission's worktree and branch when it is deleted, archived, or completed, instead of leaving every worktree-isolated mission behind on disk forever. Completion keeps a worktree that holds uncommitted changes, since a follow-up message reopens a completed mission and **Clear completed desks** completes many at once.
+- Resume a reopened mission in its base repository when its worktree has already been reclaimed, rather than resuming into a path that no longer exists.
+- An unanswered decision keeps a mission in `waiting_on_you` instead of decaying to idle or stalled once the session record goes quiet, so office lighting, desks, status pill, and the attention badge stay in agreement.
+- Suppressed the duplicate "Waiting for your reply" banner when a structured decision already covers it.
+
 ## 0.2.0 — 2026-08-25
 
 Adds the visual office, a second presentation of the same fleet state alongside the existing cards.

package/README.md

@@ -311,6 +311,20 @@ Hive deliberately separates the durable mission lifecycle from current runtime a
 
 A Claude job ending does **not** automatically mean its mission succeeded. Orchestrators move missions to **Awaiting acceptance**; the user accepts completion or requests changes. Manual lifecycle controls are available in the mission header.
 
+### Worktree reclamation
+
+Missions launched with worktree isolation get a checked-out worktree under `.claude/worktrees/` and a matching `worktree-` branch. Hive reclaims both when a mission reaches a terminal state, so repositories do not accumulate abandoned checkouts.
+
+| Mission reaches | Worktree |
+| --- | --- |
+| Deleted | Removed |
+| Archived | Removed |
+| Completed | Removed when clean; **kept** when it holds uncommitted changes |
+
+Completion is treated more cautiously than deletion or archiving because it is reversible — sending a follow-up message to a completed mission reopens it — and because **Clear completed desks** completes many Direct missions at once. Uncommitted work in a worktree therefore survives completion, and a worktree left behind for that reason is recorded in the mission's Activity tab.
+
+Reclamation only ever touches worktrees in Hive's managed layout; a repository or a hand-made directory is never removed, whatever a stale job record claims. If a reopened mission's worktree has already been reclaimed, Hive resumes it in the repository the worktree was cut from and records the change.
+
 ## MCP servers, skills, and project configuration
 
 Hive launches the normal local provider CLI rather than a separate container or account.
@@ -414,6 +428,8 @@ Project planning is split by scope:
 - [`docs/IMPROVEMENTS.md`](docs/IMPROVEMENTS.md) — core product roadmap and completion checklist
 - [`docs/VISUAL_OFFICE_PLAN.md`](docs/VISUAL_OFFICE_PLAN.md) — completed visual-office foundation
 - [`docs/VISUAL_OFFICE_FEEL_ALIVE_PLAN.md`](docs/VISUAL_OFFICE_FEEL_ALIVE_PLAN.md) — current and upcoming atmosphere, interaction, and polish phases
+- [`docs/AGENT_SYNC_AND_OFFICE_STATE_PLAN.md`](docs/AGENT_SYNC_AND_OFFICE_STATE_PLAN.md) — audit and phased plan for 1:1 terminal-agent sync, canonical worker identity, and checkpointed office animation state
+- [`docs/OFFICE_STABILITY_AUDIT.md`](docs/OFFICE_STABILITY_AUDIT.md) — replay-driven audit of the backend → office pipeline, with the tiered plan for a dependable roster and animation scene
 
 ## Troubleshooting
 

package/node_modules/@hive/shared/dist/directStudio.d.ts

@@ -4,4 +4,10 @@ import type { OrchestratorNode } from "./types.js";
  * Bulk cleanup must never accept gates or dismiss a mission that still needs
  * work or user attention.
  */
+/**
+ * A direct agent has finished when its turn is over and nothing is pending:
+ * its desk goes green with the check, and it stays seated until the user
+ * marks it complete — leaving at once would take its reply with it.
+ */
+export declare function isDirectMissionFinished(node: OrchestratorNode): boolean;
 export declare function canClearDirectStudioMission(node: OrchestratorNode): boolean;

package/node_modules/@hive/shared/dist/directStudio.js

@@ -4,6 +4,18 @@ const CLEARABLE_ACTIVITY = new Set(["idle", "done", "offline"]);
  * Bulk cleanup must never accept gates or dismiss a mission that still needs
  * work or user attention.
  */
+/**
+ * A direct agent has finished when its turn is over and nothing is pending:
+ * its desk goes green with the check, and it stays seated until the user
+ * marks it complete — leaving at once would take its reply with it.
+ */
+export function isDirectMissionFinished(node) {
+    if (node.mission.mode !== "direct" || node.lifecycleStatus !== "active" || !node.turnCompleted)
+        return false;
+    if (!["idle", "done"].includes(node.activityStatus) || node.inFlight.tasks > 0 || node.inFlight.queued > 0)
+        return false;
+    return node.alerts.every((alert) => alert.severity !== "critical");
+}
 export function canClearDirectStudioMission(node) {
     if (node.mission.mode !== "direct" || node.lifecycleStatus !== "active")
         return false;

package/node_modules/@hive/shared/dist/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./types.js";
 export * from "./status.js";
+export * from "./workers.js";
 export * from "./directStudio.js";
+export * from "./reviewHall.js";

package/node_modules/@hive/shared/dist/index.js

@@ -1,3 +1,5 @@
 export * from "./types.js";
 export * from "./status.js";
+export * from "./workers.js";
 export * from "./directStudio.js";
+export * from "./reviewHall.js";

package/node_modules/@hive/shared/dist/reviewHall.d.ts

@@ -0,0 +1,15 @@
+import type { OrchestratorNode } from "./types.js";
+/**
+ * Whether a mission awaiting acceptance can be accepted without a human
+ * reading it first.
+ *
+ * Acceptance is the human sign-off that `ready_for_review` exists to require,
+ * so a bulk action must only ever cover missions where there is demonstrably
+ * nothing to judge: every required gate is satisfied or explicitly waived,
+ * nothing is asking a question, no alert is open, and no work is still moving.
+ * Anything else keeps its seat and has to be accepted individually — a bulk
+ * button must never turn the review step into a rubber stamp.
+ */
+export declare function canAcceptReviewMission(node: OrchestratorNode, hasPendingDecision?: boolean): boolean;
+/** Why a seated mission was left for the user to accept themselves. */
+export declare function reviewAcceptanceBlocker(node: OrchestratorNode, hasPendingDecision?: boolean): string | undefined;

package/node_modules/@hive/shared/dist/reviewHall.js

@@ -0,0 +1,49 @@
+/**
+ * Whether a mission awaiting acceptance can be accepted without a human
+ * reading it first.
+ *
+ * Acceptance is the human sign-off that `ready_for_review` exists to require,
+ * so a bulk action must only ever cover missions where there is demonstrably
+ * nothing to judge: every required gate is satisfied or explicitly waived,
+ * nothing is asking a question, no alert is open, and no work is still moving.
+ * Anything else keeps its seat and has to be accepted individually — a bulk
+ * button must never turn the review step into a rubber stamp.
+ */
+export function canAcceptReviewMission(node, hasPendingDecision = false) {
+    if (node.lifecycleStatus !== "ready_for_review")
+        return false;
+    if (hasPendingDecision)
+        return false;
+    if (node.activityStatus === "waiting_on_you" || node.activityStatus === "error" || node.activityStatus === "stalled")
+        return false;
+    if (node.inFlight.tasks > 0 || node.inFlight.queued > 0)
+        return false;
+    if (node.workers.some((worker) => !worker.doneAt && (worker.jobState === "working" || worker.jobState === "busy")))
+        return false;
+    if (node.alerts.length > 0)
+        return false;
+    return !(node.plan?.gates ?? []).some((gate) => gate.required && gate.status !== "satisfied" && gate.status !== "waived");
+}
+/** Why a seated mission was left for the user to accept themselves. */
+export function reviewAcceptanceBlocker(node, hasPendingDecision = false) {
+    if (node.lifecycleStatus !== "ready_for_review")
+        return "not awaiting acceptance";
+    if (hasPendingDecision)
+        return "waiting on your answer";
+    if (node.activityStatus === "waiting_on_you")
+        return "waiting on you";
+    if (node.activityStatus === "error")
+        return "runtime error";
+    if (node.activityStatus === "stalled")
+        return "work stalled";
+    if (node.inFlight.tasks > 0 || node.inFlight.queued > 0)
+        return "work still in flight";
+    if (node.workers.some((worker) => !worker.doneAt && (worker.jobState === "working" || worker.jobState === "busy")))
+        return "a worker is still running";
+    if (node.alerts.length > 0)
+        return node.alerts.length === 1 ? "1 open alert" : `${node.alerts.length} open alerts`;
+    const unmet = (node.plan?.gates ?? []).filter((gate) => gate.required && gate.status !== "satisfied" && gate.status !== "waived");
+    if (unmet.length)
+        return unmet.length === 1 ? `unmet gate: ${unmet[0].label}` : `${unmet.length} unmet gates`;
+    return undefined;
+}

package/node_modules/@hive/shared/dist/types.d.ts

@@ -57,6 +57,8 @@ export interface ClaudeJob {
      * needs/detail — the full conversational reply lives in the timeline.
      */
     lastText?: string;
+    /** Hive-augmented: what the model said between tool calls this turn, oldest first. */
+    progressTexts?: string[];
     children: JobChild[];
     intent?: string;
     name?: string;
@@ -80,6 +82,8 @@ export interface MissionMessage {
     text: string;
     createdAt: number;
     jobId: string;
+    /** `update`: something the agent said on the way to its reply, shown compactly. */
+    kind?: "reply" | "update";
 }
 /** @deprecated Use MissionMessage. */
 export type ThreadMessage = MissionMessage;
@@ -87,6 +91,22 @@ export interface WorkerActivity extends JobFanEntry {
     jobId: string;
     jobState: string;
     jobUpdatedAt?: number;
+    /** Other provider ids and delegation labels that refer to this same worker. */
+    aliases?: string[];
+    /** Plan task ids delegated to this worker. */
+    taskIds?: string[];
+}
+/**
+ * Structured worker attribution for a hook firing. Replaces overloading one
+ * string with an agent id, an agent *type*, and a human label: only `agentId`
+ * may create a worker identity, and `parentAgentId` marks a nested agent whose
+ * activity belongs to its parent.
+ */
+export interface WorkerRef {
+    agentId?: string;
+    agentType?: string;
+    label?: string;
+    parentAgentId?: string;
 }
 export interface MissionSummary {
     id: string;
@@ -295,10 +315,19 @@ export interface HiveEvent {
     command?: string;
     artifactPath?: string;
     outcome?: "success" | "failure";
+    /**
+     * The tool call left work running in the background. The provider ends the
+     * agent's turn and wakes it when that work finishes, so a worker with an
+     * outstanding backgrounded command has not finished — it is waiting.
+     */
+    backgrounded?: boolean;
     /** For source: 'custom' — one of the orchestrator lifecycle phases. */
     phase?: "delegating" | "worker_started" | "worker_reported" | "reviewing" | "blocked_on_user" | "ready_for_review" | "plan_updated" | "decision_resolved" | "resuming" | "custom";
     detail: string;
+    /** Best-effort display name for the attributed worker. */
     targetWorker?: string;
+    /** Structured attribution; `workerRef.agentId` is the only identity source. */
+    workerRef?: WorkerRef;
     targetTask?: string;
     decisionId?: string;
     decisionKind?: DecisionKind;

package/node_modules/@hive/shared/dist/workers.d.ts

@@ -0,0 +1,14 @@
+import type { WorkerActivity } from "./types.js";
+/** The manager's own agent name. Never a worker on the floor. */
+export declare const ORCHESTRATOR_AGENT_NAME = "hive-orchestrator";
+/** Every string that refers to one canonical worker. */
+export declare function workerRefs(worker: Pick<WorkerActivity, "id" | "label" | "aliases" | "taskIds">): string[];
+/**
+ * The single worker-identity comparison for the whole app.
+ *
+ * The server resolves every provider name, delegation label, and plan task id
+ * for a worker into one canonical identity and publishes the rest as aliases,
+ * so consumers can compare exactly. Prefix and substring matching used to
+ * stand in for this and could silently merge two workers or split one.
+ */
+export declare function matchesWorker(target: string | undefined, worker: Pick<WorkerActivity, "id" | "label" | "aliases" | "taskIds">): boolean;

package/node_modules/@hive/shared/dist/workers.js

@@ -0,0 +1,22 @@
+/** The manager's own agent name. Never a worker on the floor. */
+export const ORCHESTRATOR_AGENT_NAME = "hive-orchestrator";
+/** Every string that refers to one canonical worker. */
+export function workerRefs(worker) {
+    return [worker.id, worker.label, ...(worker.aliases ?? []), ...(worker.taskIds ?? [])]
+        .map((value) => value?.trim())
+        .filter((value) => Boolean(value));
+}
+/**
+ * The single worker-identity comparison for the whole app.
+ *
+ * The server resolves every provider name, delegation label, and plan task id
+ * for a worker into one canonical identity and publishes the rest as aliases,
+ * so consumers can compare exactly. Prefix and substring matching used to
+ * stand in for this and could silently merge two workers or split one.
+ */
+export function matchesWorker(target, worker) {
+    const wanted = target?.trim().toLowerCase();
+    if (!wanted)
+        return false;
+    return workerRefs(worker).some((ref) => ref.toLowerCase() === wanted);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shanesaravia/hive",
   "private": false,
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Provider-neutral local mission control for Claude Code, Codex, and agent fleets.",
   "license": "MIT",

package/packages/server/dist/api/rest.js

@@ -1,9 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { canClearDirectStudioMission } from "@hive/shared";
+import fs from "node:fs";
+import { canAcceptReviewMission, canClearDirectStudioMission, reviewAcceptanceBlocker } from "@hive/shared";
 import { CONTEXT_BUDGETS } from "../messages/messagesStore.js";
 import { allPlanTasks } from "../plans/plansStore.js";
 import { buildFleetSnapshot } from "../roster/rosterBuilder.js";
 import { skillPromptEvents, toHiveEvent } from "../hooks/hookIngest.js";
+import { isWorkEvent, reopensOnWork } from "../missions/reopenOnWork.js";
 import { startOrchestrator } from "../control/launcher.js";
 import { matchNativeCommand, runNativeCommand } from "../control/nativeCommands.js";
 import { sendMessage } from "../control/messaging.js";
@@ -17,8 +19,9 @@ import { createTemplate, deleteTemplate, discoverTemplates, discoverTemplatesDet
 import { publishGitHubReport } from "../reports/githubPublisher.js";
 import { enforceWorkingDirectory, normalize } from "../policies/policiesStore.js";
 import { detectProviderModels } from "../control/providerModels.js";
+import { reclaimEventDetail, reclaimWorktree } from "../worktrees/worktreeReclaim.js";
 export function registerRest(app, deps) {
-    const { sessionsWatcher, jobsWatcher, events, missions, messages, plans, policies, codex } = deps;
+    const { sessionsWatcher, jobsWatcher, events, missions, messages, plans, policies, codex, workerIdentity } = deps;
     const missionSendTails = new Map();
     function latestMissionTarget(missionId) {
         const candidates = [...jobsWatcher.getAll()].filter(([jobId]) => missions.missionFor(jobId) === missionId);
@@ -27,6 +30,47 @@ export function registerRest(app, deps) {
         const sessionId = missions.latestSessionFor(missionId) ?? latest?.[1].sessionId ?? latest?.[1].resumeSessionId;
         return latest && sessionId ? { jobId: latest[0], sessionId } : undefined;
     }
+    /**
+     * Worktree identity lives on the provider job records, not the durable
+     * mission, so it must be read while those jobs are still linked — callers
+     * that also delete the mission have to resolve this first.
+     */
+    function missionWorktree(missionId) {
+        const jobs = [...jobsWatcher.getAll()].filter(([jobId]) => missions.missionFor(jobId) === missionId);
+        const carrier = jobs.find(([, job]) => job.worktreePath)?.[1];
+        return { path: carrier?.worktreePath, branch: carrier?.worktreeBranch };
+    }
+    /**
+     * The working directory to resume a mission in. Normally the recorded
+     * repository; when that was a worktree Hive has since reclaimed, the base
+     * repository the worktree was cut from.
+     */
+    function resumeRepository(missionId, repository) {
+        if (!repository || fs.existsSync(repository))
+            return repository;
+        const jobs = [...jobsWatcher.getAll()].filter(([jobId]) => missions.missionFor(jobId) === missionId);
+        const origin = jobs.map(([, job]) => job.originCwd).find((cwd) => cwd && fs.existsSync(cwd));
+        return origin ?? repository;
+    }
+    /**
+     * Reclaims the mission's worktree and records the outcome on the timeline.
+     * Never throws: losing a worktree cleanup must not fail the lifecycle
+     * change the user actually asked for.
+     */
+    function reclaimMissionWorktree(missionId, trigger, target, worktree = missionWorktree(missionId)) {
+        if (!worktree.path)
+            return;
+        let detail;
+        try {
+            detail = reclaimEventDetail(reclaimWorktree(worktree, trigger), trigger);
+        }
+        catch (error) {
+            detail = `Worktree reclaim failed: ${error.message}`;
+        }
+        if (detail && target) {
+            events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail });
+        }
+    }
     async function withMissionQueue(missionId, run) {
         const previous = missionSendTails.get(missionId) ?? Promise.resolve();
         const operation = previous.catch(() => undefined).then(run);
@@ -60,13 +104,25 @@ export function registerRest(app, deps) {
             // provider to resume. Fast subagents can start and finish while the CLI
             // launch call is still pending; reopening afterward leaves their FIFO
             // stories assigned to a room with no worker desks.
-            const reopening = ["ready_for_review", "completed", "archived", "failed", "paused"].includes(summary.lifecycleStatus);
+            // "ready_for_review" is deliberately absent: a question asked of finished
+            // work is not a reason to un-finish it. That mission reopens only if the
+            // turn actually does something — see reopenOnWork.
+            const reopening = ["completed", "archived", "failed", "paused"].includes(summary.lifecycleStatus);
             if (reopening)
                 missions.setLifecycleStatus(missionId, "active");
+            // A follow-up implicitly reopens a closed mission, but reaching a
+            // terminal state reclaims its worktree — so the recorded repository can
+            // be a directory that no longer exists. Fall back to the repository the
+            // worktree was cut from rather than resuming into a dead path.
+            const repository = resumeRepository(missionId, summary.repository);
+            if (repository && repository !== summary.repository) {
+                missions.setRepository(missionId, repository);
+                events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Mission worktree was reclaimed; resuming in ${repository}` });
+            }
             let result;
             try {
                 result = provider === "codex"
-                    ? await codex.start({ task: prompt, cwd: summary.repository, model: summary.model, mode: summary.mode, policy, resumeSessionId: target.sessionId })
+                    ? await codex.start({ task: prompt, cwd: repository, model: summary.model, mode: summary.mode, policy, resumeSessionId: target.sessionId })
                     : await sendMessage(target.sessionId, prompt, policy, additionalRepos);
             }
             catch (error) {
@@ -83,16 +139,43 @@ export function registerRest(app, deps) {
             return result;
         });
     }
-    app.get("/api/fleet", async () => buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans));
+    app.get("/api/fleet", async () => buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans, Date.now(), workerIdentity));
     app.post("/api/direct-studio/clear-completed", async () => {
-        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans);
+        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans, Date.now(), workerIdentity);
         const eligible = snapshot.orchestrators.filter(canClearDirectStudioMission);
         for (const node of eligible) {
             missions.setLifecycleStatus(node.missionId, "completed");
             events.add({ ts: Date.now(), sessionId: node.sessionId, jobId: node.jobId, source: "custom", phase: "custom", activityKind: "lifecycle", detail: "Direct mission completed through Clear completed desks" });
+            // Bulk completion reclaims on the same clean-only terms as a single
+            // completion: uncommitted work in any desk's worktree survives.
+            reclaimMissionWorktree(node.missionId, "completed", { jobId: node.jobId, sessionId: node.sessionId });
         }
         return { ok: true, cleared: eligible.map((node) => node.missionId), remaining: snapshot.orchestrators.filter((node) => node.mission.mode === "direct" && node.lifecycleStatus === "active").length - eligible.length };
     });
+    app.post("/api/review-hall/accept-clear", async () => {
+        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans, Date.now(), workerIdentity);
+        const pending = new Set((snapshot.decisions ?? []).map((decision) => decision.missionId));
+        const seated = snapshot.orchestrators.filter((node) => node.lifecycleStatus === "ready_for_review");
+        const eligible = seated.filter((node) => canAcceptReviewMission(node, pending.has(node.missionId)));
+        for (const node of eligible) {
+            missions.setLifecycleStatus(node.missionId, "completed");
+            events.add({ ts: Date.now(), sessionId: node.sessionId, jobId: node.jobId, source: "custom", phase: "custom", activityKind: "lifecycle", detail: "Accepted through Accept all clear in the review hall" });
+            // Acceptance reclaims on clean-only terms, so a worktree holding
+            // uncommitted work is preserved rather than discarded in bulk.
+            reclaimMissionWorktree(node.missionId, "completed", { jobId: node.jobId, sessionId: node.sessionId });
+        }
+        const accepted = new Set(eligible.map((node) => node.missionId));
+        return {
+            ok: true,
+            accepted: eligible.map((node) => node.missionId),
+            // Everything left seated, with the reason it still needs a human.
+            skipped: seated.filter((node) => !accepted.has(node.missionId)).map((node) => ({
+                missionId: node.missionId,
+                name: node.name,
+                reason: reviewAcceptanceBlocker(node, pending.has(node.missionId)) ?? "needs review",
+            })),
+        };
+    });
     app.get("/api/policies", async () => ({ policy: policies.get() }));
     app.get("/api/providers/models", async () => ({ providers: detectProviderModels() }));
     app.put("/api/policies", async (req, reply) => {
@@ -143,7 +226,7 @@ export function registerRest(app, deps) {
         return { error: err.message };
     } });
     app.get("/api/mission/:missionId/report", async (req, reply) => {
-        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans);
+        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans, Date.now(), workerIdentity);
         const node = snapshot.orchestrators.find((item) => item.missionId === req.params.missionId);
         if (!node) {
             reply.code(404);
@@ -164,7 +247,7 @@ export function registerRest(app, deps) {
             reply.code(400);
             return { error: "choose a GitHub issue or pull request" };
         }
-        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans);
+        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans, Date.now(), workerIdentity);
         const node = snapshot.orchestrators.find((item) => item.missionId === req.params.missionId);
         if (!node?.mission.repository) {
             reply.code(404);
@@ -187,6 +270,24 @@ export function registerRest(app, deps) {
     app.get("/api/session/:sessionId/timeline", async (req) => {
         return { events: events.recentFor(req.params.sessionId, 200) };
     });
+    /**
+     * Finished work that starts working again is no longer finished.
+     *
+     * The mission stays awaiting acceptance while it answers a question; the
+     * moment it writes something or starts a worker, it is active again and the
+     * board should say so without the user having to notice.
+     */
+    function reopenIfWorking(event, jobId) {
+        if (!isWorkEvent(event))
+            return;
+        const missionId = missions.missionFor(jobId);
+        const mission = missions.get(missionId);
+        if (!mission || !reopensOnWork(mission.lifecycleStatus))
+            return;
+        missions.setLifecycleStatus(missionId, "active");
+        missions.updateContext(missionId, { currentState: "Working again after a follow-up" });
+        events.add({ ts: Date.now(), sessionId: event.sessionId, jobId, source: "custom", phase: "custom", activityKind: "lifecycle", detail: "Mission reopened from ready_for_review: it started working again" });
+    }
     app.post("/hooks/:eventName", async (req, reply) => {
         const payload = {
             ...req.body,
@@ -201,6 +302,8 @@ export function registerRest(app, deps) {
         events.add(event);
         for (const promptEvent of skillPromptEvents(payload, jobId))
             events.add(promptEvent);
+        if (jobId)
+            reopenIfWorking(event, jobId);
         // A write landing in another known repo marks that repo as touched by
         // the mission, so its footprint chips reflect reality, not just intent.
         if (event.activityKind === "file_write" && event.filePath && jobId) {
@@ -271,6 +374,8 @@ export function registerRest(app, deps) {
             impact: phase === "blocked_on_user" ? decision?.impact : undefined,
             context: phase === "blocked_on_user" ? decision?.context : undefined,
         });
+        if (effectiveJobId && phase !== "ready_for_review")
+            reopenIfWorking({ sessionId, source: "custom", phase }, effectiveJobId);
         if (phase === "ready_for_review" && effectiveJobId) {
             const missionId = missions.missionFor(effectiveJobId);
             if (missions.get(missionId)) {
@@ -283,10 +388,15 @@ export function registerRest(app, deps) {
             if (missions.get(missionId)) {
                 // Best-effort: keeps plan task statuses truthful when the
                 // orchestrator emits activity without republishing the plan.
-                try {
-                    plans.applyTaskEvent(missionId, { phase, targetTask, targetWorker, evidence: phase === "worker_reported" ? detail : undefined });
+                // One emit may name several workers (`--target a,b,c`); the task moves for each.
+                const targets = targetWorker && /[,;]/.test(targetWorker) ? [...new Set(targetWorker.split(/[,;]/).map((value) => value.trim()).filter(Boolean))] : [targetWorker];
+                for (const target of targets) {
+                    const canonicalWorker = workerIdentity.canonicalFor(missionId, target);
+                    try {
+                        plans.applyTaskEvent(missionId, { phase, targetTask, targetWorker: target, canonicalWorker, evidence: phase === "worker_reported" ? detail : undefined });
+                    }
+                    catch { /* a later plan_updated remains the source of truth */ }
                 }
-                catch { /* a later plan_updated remains the source of truth */ }
             }
         }
         return { ok: true };
@@ -816,6 +926,11 @@ Revise the structured plan to remove that requirement and stop work that was nee
         const target = latestMissionTarget(req.params.missionId);
         if (target)
             events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Mission status changed from ${previous} to ${req.body.status}` });
+        // Reclaim only on entry into a terminal state, so re-archiving an already
+        // archived mission does not re-run git against a path that is long gone.
+        if (previous !== req.body.status && (req.body.status === "archived" || req.body.status === "completed")) {
+            reclaimMissionWorktree(req.params.missionId, req.body.status, target);
+        }
         return { ok: true };
     });
     app.post("/api/mission/:missionId/action", async (req, reply) => {
@@ -900,6 +1015,9 @@ Revise the structured plan to remove that requirement and stop work that was nee
     });
     app.delete("/api/mission/:missionId", async (req, reply) => {
         const target = latestMissionTarget(req.params.missionId);
+        // Resolved before removal: missions.remove() unlinks the jobs that carry
+        // the worktree path, and afterwards it can no longer be found.
+        const worktree = missionWorktree(req.params.missionId);
         if (target)
             events.add({ ts: Date.now(), ...target, source: "custom", phase: "custom", activityKind: "lifecycle", detail: `Mission permanently deleted: ${req.params.missionId}` });
         if (!missions.remove(req.params.missionId)) {
@@ -908,6 +1026,7 @@ Revise the structured plan to remove that requirement and stop work that was nee
         }
         messages.removeMission(req.params.missionId);
         plans.removeMission(req.params.missionId);
+        reclaimMissionWorktree(req.params.missionId, "deleted", target, worktree);
         return { ok: true };
     });
     app.post("/api/session/:pid/stop", async (req, reply) => {

package/packages/server/dist/api/ws.js

@@ -4,14 +4,32 @@ import { buildFleetSnapshot } from "../roster/rosterBuilder.js";
  * REST for live state — this is the only steady-state channel.
  */
 export function registerWs(app, deps) {
-    const { sessionsWatcher, jobsWatcher, events, missions, messages, plans } = deps;
+    const { sessionsWatcher, jobsWatcher, events, missions, messages, plans, workerIdentity, webBuild } = deps;
     const clients = new Set();
+    // Every roster the client ever sees is built the same way. The first one
+    // used to be built without the identity store, so a reload resolved workers
+    // from the bare event window and the next broadcast disagreed with it.
+    const currentRoster = () => buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans, Date.now(), workerIdentity);
+    let lastRosterJson = "";
     function broadcastRoster() {
-        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans);
-        const msg = JSON.stringify({ type: "roster", snapshot });
+        lastRosterJson = JSON.stringify({ type: "roster", snapshot: currentRoster() });
         for (const client of clients)
-            client.send(msg);
+            client.send(lastRosterJson);
     }
+    // Time-based rules — correlation graces, the stop-settle, stalled work — used
+    // to take effect only when some unrelated event happened to arrive. A short
+    // ticker re-derives the roster and pushes it only when something changed.
+    const ticker = setInterval(() => {
+        if (!clients.size)
+            return;
+        const next = JSON.stringify({ type: "roster", snapshot: currentRoster() });
+        if (next === lastRosterJson)
+            return;
+        lastRosterJson = next;
+        for (const client of clients)
+            client.send(next);
+    }, 1_500);
+    app.addHook("onClose", async () => { clearInterval(ticker); });
     function broadcastEvent(event) {
         const msg = JSON.stringify({ type: "event", event });
         for (const client of clients)
@@ -28,10 +46,9 @@ export function registerWs(app, deps) {
     });
     app.get("/ws", { websocket: true }, (socket) => {
         clients.add(socket);
-        socket.send(JSON.stringify({
-            type: "roster",
-            snapshot: buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans),
-        }));
+        if (webBuild)
+            socket.send(JSON.stringify({ type: "hello", build: webBuild }));
+        socket.send(JSON.stringify({ type: "roster", snapshot: currentRoster() }));
         socket.on("close", () => clients.delete(socket));
     });
 }