@shanesaravia/hive 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 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

package/README.md

@@ -428,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.1",
+  "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,10 +1,11 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
-import { canClearDirectStudioMission } from "@hive/shared";
+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";
@@ -20,7 +21,7 @@ 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);
@@ -103,7 +104,10 @@ 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
@@ -135,9 +139,9 @@ 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");
@@ -148,6 +152,30 @@ export function registerRest(app, deps) {
         }
         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) => {
@@ -198,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);
@@ -219,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);
@@ -242,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,
@@ -256,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) {
@@ -326,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)) {
@@ -338,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 };

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));
     });
 }

package/packages/server/dist/control/launcher.js

@@ -20,11 +20,23 @@ export async function startOrchestrator(opts) {
     const args = buildLaunchArgs(opts);
     const before = new Set(listSessionFiles());
     const cwd = requireWorkingDirectory(opts.cwd);
-    const child = spawn("claude", args, { cwd, detached: true, stdio: "ignore" });
+    // stderr is piped rather than ignored: when the CLI refuses to launch it
+    // says exactly why, and throwing that away left every refusal looking like
+    // the same 30-second timeout. The pipe is drained and the child is still
+    // unref'd, so nothing keeps the server alive.
+    const child = spawn("claude", args, { cwd, detached: true, stdio: ["ignore", "ignore", "pipe"] });
+    // `claude --bg` detaches and exits at once on the happy path, so an exit is
+    // not a failure — only a non-zero one is. Reading the exit alone as failure
+    // aborts every successful launch before its session can register.
+    const refusal = { text: "", failed: false };
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => { refusal.text = (refusal.text + chunk).slice(0, 2000); });
+    child.once("exit", (code) => { refusal.failed = (code ?? 0) !== 0; });
+    child.once("error", (error) => { refusal.text ||= error.message; refusal.failed = true; });
     child.unref();
     // Worktree launches must copy/check out the repo before the session
     // registers, which can take well over 8s on large repositories.
-    const session = await waitForNewSession(before, opts.worktree ? 30000 : 8000);
+    const session = await waitForNewSession(before, opts.worktree ? 30000 : 8000, refusal);
     if (!session.jobId) {
         throw new Error("Orchestrator session started without a background job ID");
     }
@@ -45,13 +57,29 @@ export function generateWorktreeName(missionName) {
     const suffix = Math.random().toString(36).slice(2, 8);
     return slug ? `hive-${slug}-${suffix}` : `hive-${suffix}`;
 }
+/**
+ * The permission mode a background session runs in.
+ *
+ * Nothing is watching a background job's TTY, so any mode that stops to ask a
+ * question is a mode that can park a mission indefinitely. That is why this
+ * was "bypassPermissions" — but the CLI now requires a one-time interactive
+ * disclaimer before --bg will accept it, which is not something a server can
+ * agree to on the user's behalf, so every launch failed outright.
+ *
+ * "auto" takes it. It is also the mode that should have been asked for: it
+ * still declines what it judges genuinely dangerous rather than waiving every
+ * check, and Hive already surfaces a parked mission as a decision the user can
+ * answer from the board. A prompt nobody sees is the thing to avoid; a prompt
+ * Hive can put in front of someone is the product working.
+ *
+ * The policy remains the real boundary either way, and it is a stronger one
+ * than a prompt: `--disallowedTools` denies rm, git reset --hard, git clean,
+ * releases and publishes outright, and a denied tool cannot be used at any
+ * permission level.
+ */
+export const PERMISSION_MODE = "auto";
 export function buildLaunchArgs(opts) {
-    const args = [
-        "--bg",
-        // Background sessions have no TTY to answer permission prompts — "auto"
-        // (the mode Claude Code's own background jobs use) lets it proceed
-        // without stalling. disallowedTools remains the actual safety boundary.
-    ];
+    const args = ["--bg"];
     // Variadic --add-dir must come before the trailing task positional, with a
     // flag after it, or it would swallow the task as another directory.
     if (opts.addDirs?.length)
@@ -64,7 +92,7 @@ export function buildLaunchArgs(opts) {
         args.push("--disallowedTools", [...new Set(denied)].join(","));
     if (opts.policy?.allowedTools.length)
         args.push("--allowedTools", opts.policy.allowedTools.join(","));
-    args.push("--permission-mode", "auto");
+    args.push("--permission-mode", PERMISSION_MODE);
     if (opts.worktree) {
         // Always pass an explicit name: the CLI's --worktree greedily consumes the
         // next non-flag argument, so a bare --worktree would swallow the task
@@ -93,7 +121,9 @@ function listSessionFiles() {
  * new session is up is its sessions/<pid>.json file appearing. Poll the
  * filesystem briefly (startup confirmation only, not steady-state polling).
  */
-async function waitForNewSession(before, timeoutMs) {
+async function waitForNewSession(before, timeoutMs, 
+/** What the CLI said on its way out, if it refused to start at all. */
+refusal) {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
         const now = listSessionFiles();
@@ -108,7 +138,16 @@ async function waitForNewSession(before, timeoutMs) {
                 // The daemon may still be writing the newly discovered file.
             }
         }
+        // A CLI that has already failed is never going to register a session, so
+        // report what it said instead of waiting out the rest of the timeout.
+        if (refusal?.failed)
+            throw new Error(launchFailure(refusal.text));
         await new Promise((r) => setTimeout(r, 250));
     }
-    throw new Error("Timed out waiting for orchestrator session to start");
+    throw new Error(refusal?.text ? launchFailure(refusal.text) : "Timed out waiting for orchestrator session to start");
+}
+/** The CLI's own words, trimmed to the part worth putting on a banner. */
+export function launchFailure(stderr) {
+    const said = stderr.split("\n").map((line) => line.trim()).filter(Boolean).join(" ").trim();
+    return said ? `Claude CLI refused to start the mission: ${said}` : "Claude CLI exited before the mission started";
 }

package/packages/server/dist/control/messaging.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { config } from "../config.js";
 import { disallowedTools } from "../policies/policiesStore.js";
+import { PERMISSION_MODE } from "./launcher.js";
 const execFileAsync = promisify(execFile);
 /**
  * Sends a follow-up message into a running session. The per-session Unix
@@ -22,10 +23,10 @@ export function buildResumeArgs(sessionId, text, policy, addDirs) {
     // The prompt positional must precede --resume/--bg: trailing positionals are
     // silently dropped on resumed background turns (the session starts idle,
     // "send a prompt to start", and never replies).
-    // Resumes inherit the session's permission mode today, but pin auto
+    // Resumes inherit the session's permission mode today, but pin it
     // explicitly so a CLI change can never drop follow-up turns into a
     // prompting mode no background session can answer.
-    const args = [text, "--resume", sessionId, "--bg", "--permission-mode", "auto"];
+    const args = [text, "--resume", sessionId, "--bg", "--permission-mode", PERMISSION_MODE];
     const denied = policy ? disallowedTools(policy) : [];
     if (denied.length)
         args.push("--disallowedTools", denied.join(","));

package/packages/server/dist/health/deriveAlerts.js

@@ -1,3 +1,4 @@
+import { matchesWorker } from "@hive/shared";
 const LONG_RUNNING_MS = 15 * 60 * 1000;
 const HIGH_TOKEN_TURN = 20_000;
 const MIN_TOKEN_ALERT_RUNTIME_MS = 5 * 60 * 1000;
@@ -50,6 +51,4 @@ export function deriveAlerts(input) {
         alerts.push({ id: "unclear-wait", severity: "warning", title: "Waiting without a clear question", explanation: "The runtime says it needs user input, but Hive has no structured pending decision to display.", evidence: "Waiting state present; no unresolved blocked_on_user event found.", recovery: "Open the mission and ask the orchestrator to state one concrete question with choices and a recommendation." });
     return alerts;
 }
-function matchesWorker(target, worker) { if (!target)
-    return false; const value = target.toLowerCase(); return value === worker.id.toLowerCase() || value === worker.label.toLowerCase() || worker.id.toLowerCase().startsWith(value) || worker.label.toLowerCase().includes(value); }
 function minutes(ms) { return Math.max(1, Math.floor(ms / 60_000)); }