@shanesaravia/hive 0.2.0 → 0.3.0

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

package/packages/server/dist/hooks/hookIngest.js

@@ -1,3 +1,4 @@
+import { ORCHESTRATOR_AGENT_NAME } from "@hive/shared";
 const SUMMARY_LIMIT = 140;
 const RAW_STRING_LIMIT = 2_000;
 const SECRET_KEY = /(token|secret|password|authorization|cookie|api[_-]?key)/i;
@@ -57,11 +58,64 @@ export function skillPromptEvents(payload, jobId) {
             }];
     });
 }
+/**
+ * Structured worker attribution. Only a provider agent id may name a person:
+ * `agent_type` is a role shared by many workers and previously landed in the
+ * same field, which could merge two workers or split one in two.
+ *
+ * For an Agent launch the payload's top-level ids belong to the *launching*
+ * agent, so they become the parent and the new worker's id comes from the tool
+ * response. That is what lets a worker's own sub-agent roll up into it instead
+ * of taking a desk of its own.
+ */
+function workerRef(payload) {
+    const top = record(payload);
+    const response = record(payload.tool_response);
+    const input = record(payload.tool_input);
+    // A launch that errored still launched: the provider returns the child id in
+    // the failure response too, and the child may already have started.
+    const launch = (payload.hook_event_name === "PostToolUse" || payload.hook_event_name === "PostToolUseFailure") && payload.tool_name === "Agent";
+    const agentId = launch
+        ? stringField(response, "agentId", "agent_id")
+        : stringField(top, "agent_id", "subagent_id");
+    const parentAgentId = launch
+        ? stringField(top, "agent_id", "subagent_id")
+        : stringField(top, "parent_agent_id", "parent_id", "parent_agent");
+    const ref = {
+        agentId,
+        agentType: stringField(top, "agent_type"),
+        label: launch
+            ? stringField(response, "description") ?? stringField(input, "description") ?? stringField(input, "subagent_type")
+            : stringField(top, "agent_name", "teammate_name", "description"),
+        // A worker's parent is only meaningful when it is another worker.
+        parentAgentId: parentAgentId && parentAgentId !== agentId && parentAgentId !== ORCHESTRATOR_AGENT_NAME ? parentAgentId : undefined,
+    };
+    return Object.values(ref).some(Boolean) ? ref : undefined;
+}
+/**
+ * A tool call that leaves work running past the end of the agent's turn.
+ *
+ * Three shapes: a backgrounded shell command; `Monitor`, which is the sanctioned
+ * way to wait (foreground sleep is blocked) and always outlives the turn; and an
+ * `Agent` launch the provider answered `isAsync`, which leaves the *launcher*
+ * waiting on a child. Missing the last two made a waiting worker look retired.
+ */
+function backgrounded(payload) {
+    const input = record(payload.tool_input);
+    if (input.run_in_background === true || input.runInBackground === true)
+        return true;
+    if (payload.tool_name === "Monitor" && (payload.hook_event_name === "PostToolUse" || payload.hook_event_name === "PreToolUse"))
+        return true;
+    if (payload.tool_name === "Agent" && payload.hook_event_name === "PostToolUse" && record(payload.tool_response).isAsync === true)
+        return true;
+    return undefined;
+}
 function evidence(payload) {
     const input = record(payload.tool_input);
     const tool = payload.tool_name ?? "";
     const command = stringField(input, "command");
     const filePath = stringField(input, "file_path", "path", "notebook_path");
+    const ref = workerRef(payload);
     let targetWorker = stringField(payload, "agent_id", "subagent_id", "agent_name", "agent_type", "teammate_name");
     // Agent launches are emitted by the manager, so the payload's top-level
     // agent_type is `hive-orchestrator`. Claude returns the durable worker id in
@@ -71,28 +125,32 @@ function evidence(payload) {
         targetWorker = stringField(record(payload.tool_response), "agentId", "agent_id") ?? targetWorker;
     }
     if (["TaskCreated", "TaskCompleted", "TeammateIdle"].includes(payload.hook_event_name))
-        return { activityKind: "agent", targetWorker };
+        return { activityKind: "agent", targetWorker, workerRef: ref };
+    // The provider's idle notification fires after every turn; it means "the
+    // session is idle", not "the assistant asked you something".
+    if (payload.hook_event_name === "Notification" && payload.notification_type === "idle_prompt")
+        return { activityKind: "agent", targetWorker, workerRef: ref };
     if (["PermissionRequest", "PermissionDenied", "Elicitation", "ElicitationResult", "Notification"].includes(payload.hook_event_name))
-        return { activityKind: "decision", targetWorker };
+        return { activityKind: "decision", targetWorker, workerRef: ref };
     if (["InstructionsLoaded", "ConfigChange"].includes(payload.hook_event_name))
-        return { activityKind: "file_read", filePath: stringField(payload, "file_path", "path"), targetWorker };
+        return { activityKind: "file_read", filePath: stringField(payload, "file_path", "path"), targetWorker, workerRef: ref };
     if (["WorktreeCreate", "WorktreeRemove"].includes(payload.hook_event_name))
-        return { activityKind: "output", artifactPath: stringField(payload, "worktree_path", "path"), targetWorker };
+        return { activityKind: "output", artifactPath: stringField(payload, "worktree_path", "path"), targetWorker, workerRef: ref };
     if (payload.hook_event_name === "SubagentStart" || payload.hook_event_name === "SubagentStop")
-        return { activityKind: "agent", targetWorker };
+        return { activityKind: "agent", targetWorker, workerRef: ref };
     if (tool === "Read" || tool === "Glob" || tool === "Grep")
-        return { activityKind: "file_read", filePath, targetWorker };
+        return { activityKind: "file_read", filePath, targetWorker, workerRef: ref };
     if (["Edit", "Write", "NotebookEdit"].includes(tool)) {
         const artifactPath = filePath && /\.(png|jpe?g|webp|gif|svg|pdf|docx?|xlsx?|pptx?|zip)$/i.test(filePath) ? filePath : undefined;
-        return { activityKind: artifactPath ? "output" : "file_write", filePath, artifactPath, targetWorker };
+        return { activityKind: artifactPath ? "output" : "file_write", filePath, artifactPath, targetWorker, workerRef: ref };
     }
     if (tool === "Bash") {
         const isTest = Boolean(command && /(^|\s)(test|pytest|vitest|jest|mocha|cargo test|go test|npm test|npm run test|typecheck|lint)(\s|$)/i.test(command));
-        return { activityKind: isTest ? "test" : "command", command: command?.slice(0, 500), targetWorker };
+        return { activityKind: isTest ? "test" : "command", command: command?.slice(0, 500), targetWorker, workerRef: ref };
     }
     if (payload.hook_event_name === "StopFailure")
-        return { activityKind: "lifecycle", targetWorker };
-    return { activityKind: payload.tool_name ? "tool" : "lifecycle", targetWorker };
+        return { activityKind: "lifecycle", targetWorker, workerRef: ref };
+    return { activityKind: payload.tool_name ? "tool" : "lifecycle", targetWorker, workerRef: ref };
 }
 function outcome(payload) {
     if (payload.hook_event_name === "PostToolUseFailure" || payload.hook_event_name === "StopFailure" || payload.hook_event_name === "PermissionDenied")
@@ -129,5 +187,6 @@ export function toHiveEvent(payload, jobId) {
         outcome: outcome(payload),
         rawPayload: sanitizeRaw(payload),
         ...evidence(payload),
+        backgrounded: backgrounded(payload),
     };
 }

package/packages/server/dist/index.js

@@ -2,7 +2,7 @@ import Fastify from "fastify";
 import cors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
 import websocket from "@fastify/websocket";
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { config } from "./config.js";
@@ -12,6 +12,7 @@ import { EventsStore } from "./events/eventsStore.js";
 import { MissionsStore } from "./missions/missionsStore.js";
 import { MessagesStore } from "./messages/messagesStore.js";
 import { PlansStore } from "./plans/plansStore.js";
+import { WorkerIdentityStore } from "./roster/workerIdentity.js";
 import { registerRest } from "./api/rest.js";
 import { registerWs } from "./api/ws.js";
 import { drainHookSpool } from "./hooks/hookSpool.js";
@@ -41,6 +42,7 @@ async function main() {
     const missions = new MissionsStore();
     const messages = new MessagesStore();
     const plans = new PlansStore();
+    const workerIdentity = new WorkerIdentityStore();
     const policies = new PoliciesStore();
     const codex = new CodexRuntime();
     events.init();
@@ -58,12 +60,17 @@ async function main() {
     messages.syncJobs(jobsWatcher.getAll(), missions);
     jobsWatcher.onJobsChange((jobs) => messages.syncJobs(jobs, missions));
     missions.onChange(() => messages.syncJobs(jobsWatcher.getAll(), missions));
-    registerRest(app, { sessionsWatcher, jobsWatcher, events, missions, messages, plans, policies, codex });
-    registerWs(app, { sessionsWatcher, jobsWatcher, events, missions, messages, plans });
-    app.get("/health", async () => ({ ok: true }));
     const webRoot = process.env.HIVE_WEB_DIST
         ? path.resolve(process.env.HIVE_WEB_DIST)
         : fileURLToPath(new URL("../../web/dist/", import.meta.url));
+    // Identifies the web bundle this server serves. A tab that loaded an older
+    // bundle reconnects after a restart and keeps running old code against new
+    // data — a fixed bug reported again from a stale tab. The client reloads
+    // when this changes.
+    const webBuild = webBuildId(webRoot);
+    registerRest(app, { sessionsWatcher, jobsWatcher, events, missions, messages, plans, policies, codex, workerIdentity });
+    registerWs(app, { sessionsWatcher, jobsWatcher, events, missions, messages, plans, workerIdentity, webBuild });
+    app.get("/health", async () => ({ ok: true, webBuild }));
     const isCompiledRuntime = fileURLToPath(import.meta.url).includes(`${path.sep}dist${path.sep}`);
     if (existsSync(path.join(webRoot, "index.html"))) {
         await app.register(fastifyStatic, { root: webRoot });
@@ -82,6 +89,15 @@ async function main() {
     if (replayedHooks)
         app.log.info(`replayed ${replayedHooks} hook event(s) captured while Hive was offline`);
 }
+function webBuildId(webRoot) {
+    try {
+        const entry = readdirSync(path.join(webRoot, "assets")).find((file) => /^index-.*\.js$/.test(file));
+        if (entry)
+            return entry;
+    }
+    catch { /* no built bundle: dev server, or tests */ }
+    return `dev-${process.pid}-${Date.now()}`;
+}
 main().catch((err) => {
     console.error(err);
     process.exit(1);

package/packages/server/dist/messages/messagesStore.js

@@ -27,6 +27,7 @@ function toMessage(row) {
         text: row.text,
         createdAt: row.created_at,
         jobId: row.job_id ?? "",
+        ...(row.kind === "update" ? { kind: "update" } : {}),
     };
 }
 /** Indexed, paginated transcript storage. History is never prompt context by default. */
@@ -44,13 +45,18 @@ export class MessagesStore {
         role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
         text TEXT NOT NULL,
         created_at INTEGER NOT NULL,
-        job_id TEXT
+        job_id TEXT,
+        kind TEXT
       );
       CREATE INDEX IF NOT EXISTS idx_mission_messages_page
         ON mission_messages (mission_id, created_at DESC, id DESC);
       CREATE INDEX IF NOT EXISTS idx_mission_messages_job
         ON mission_messages (job_id);
     `);
+        try {
+            this.db.exec("ALTER TABLE mission_messages ADD COLUMN kind TEXT");
+        }
+        catch { /* already present */ }
     }
     close() {
         this.db.close();
@@ -65,18 +71,19 @@ export class MessagesStore {
             text: input.text,
             createdAt: input.createdAt,
             jobId: input.jobId,
+            ...(input.kind ? { kind: input.kind } : {}),
         };
         this.db
             .prepare(`
-        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId)
+        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind)
+        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind)
         ON CONFLICT(id) DO UPDATE SET
           mission_id = excluded.mission_id,
           text = excluded.text,
           created_at = excluded.created_at,
           job_id = excluded.job_id
       `)
-            .run({ ...message, missionId: input.missionId, jobId: input.jobId || null });
+            .run({ ...message, kind: message.kind ?? null, missionId: input.missionId, jobId: input.jobId || null });
         this.notify();
         return message;
     }
@@ -84,7 +91,7 @@ export class MessagesStore {
         const limit = Math.min(Math.max(options.limit ?? DEFAULT_PAGE_SIZE, 1), MAX_PAGE_SIZE);
         const rows = this.db
             .prepare(`
-        SELECT id, mission_id, role, text, created_at, job_id
+        SELECT id, mission_id, role, text, created_at, job_id, kind
         FROM mission_messages
         WHERE mission_id = @missionId
           AND (@before IS NULL OR created_at < @before)
@@ -123,7 +130,7 @@ export class MessagesStore {
         const terms = [...new Set(query.toLowerCase().match(/[a-z0-9_-]{4,}/g) ?? [])].slice(0, 20);
         if (!terms.length)
             return [];
-        const rows = this.db.prepare("SELECT id, mission_id, role, text, created_at, job_id FROM mission_messages WHERE mission_id = ? ORDER BY created_at DESC LIMIT 250").all(missionId);
+        const rows = this.db.prepare("SELECT id, mission_id, role, text, created_at, job_id, kind FROM mission_messages WHERE mission_id = ? ORDER BY created_at DESC LIMIT 250").all(missionId);
         let remaining = chars(CONTEXT_BUDGETS.retrievedTokens);
         return rows.filter((row) => !excludedIds.has(row.id)).map(toMessage).map((message) => ({ message, score: terms.filter((term) => message.text.toLowerCase().includes(term)).length })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || b.message.createdAt - a.message.createdAt).slice(0, 6).flatMap(({ message }) => { if (remaining <= 0)
             return []; const text = message.text.slice(0, remaining); remaining -= text.length; return [{ ...message, text }]; }).sort((a, b) => a.createdAt - b.createdAt);
@@ -160,6 +167,12 @@ export class MessagesStore {
                     // Mid-turn permission prompts: the job stays "working" but tempo
                     // flips to blocked with the ask in needs (e.g. "approve Bash: …").
                     ?? (job.tempo === "blocked" && job.needs ? `🔐 ${job.needs}` : undefined);
+                // What the model said on the way — narration between tool calls — as
+                // compact updates, so the conversation shows the work as it goes
+                // rather than a single reply at the end.
+                const updates = (job.progressTexts ?? []).filter((text) => text !== result);
+                const turnStartedAt = timestamp(job.createdAt);
+                updates.forEach((text, index) => this.upsertSynced({ id: `${jobId}:update:${index}`, missionId, role: "assistant", text, createdAt: turnStartedAt + 1 + index, jobId, kind: "update" }));
                 if (result) {
                     this.upsertSynced({
                         id: `${jobId}:assistant`,
@@ -182,27 +195,27 @@ export class MessagesStore {
     insertSynced(message) {
         this.db
             .prepare(`
-        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId)
+        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind)
+        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind)
         ON CONFLICT(id) DO UPDATE SET
           mission_id = excluded.mission_id,
           created_at = excluded.created_at,
           job_id = excluded.job_id
       `)
-            .run(message);
+            .run({ ...message, kind: message.kind ?? null });
     }
     upsertSynced(message) {
         this.db
             .prepare(`
-        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId)
+        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind)
+        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind)
         ON CONFLICT(id) DO UPDATE SET
           mission_id = excluded.mission_id,
           text = excluded.text,
           created_at = excluded.created_at,
           job_id = excluded.job_id
       `)
-            .run(message);
+            .run({ ...message, kind: message.kind ?? null });
     }
     notify() {
         for (const listener of this.listeners)

package/packages/server/dist/missions/missionsStore.js

@@ -11,6 +11,8 @@ const emptyData = () => ({
     deletedJobIds: [],
 });
 /** Durable Hive mission identity and metadata, independent of Claude jobs. */
+/** The standing this store writes when a mission reaches review, and only that. */
+const AWAITING_ACCEPTANCE = /^awaiting (user )?acceptance\.?$/i;
 export class MissionsStore {
     filePath;
     legacyThreadsPath;
@@ -190,9 +192,26 @@ export class MissionsStore {
         mission.updatedAt = Date.now();
         this.changed();
     }
+    /**
+     * Repoints a mission at a different working directory. Used when a mission's
+     * worktree has been reclaimed and work must continue in the base repository.
+     */
+    setRepository(missionId, repository) {
+        const mission = this.ensureLegacyMission(missionId);
+        mission.repository = repository;
+        mission.updatedAt = Date.now();
+        this.changed();
+    }
     setLifecycleStatus(missionId, status) {
         const mission = this.ensureLegacyMission(missionId);
         mission.lifecycleStatus = status;
+        // Reaching review writes "Awaiting user acceptance" as the mission's
+        // standing. Leaving review left it there, so a reopened mission kept
+        // telling the board it was waiting for an acceptance nobody could give —
+        // and the card, having no chip to explain it, just looked stuck.
+        if (status !== "ready_for_review" && AWAITING_ACCEPTANCE.test(mission.currentState?.trim() ?? "")) {
+            mission.currentState = undefined;
+        }
         mission.updatedAt = Date.now();
         this.changed();
     }

package/packages/server/dist/missions/reopenOnWork.js

@@ -0,0 +1,20 @@
+export function isWorkEvent(event) {
+    // Something was written to the repository.
+    if (event.activityKind === "file_write")
+        return true;
+    // An artifact written through the same tools — an image, a PDF, a document.
+    if (event.activityKind === "output" && event.filePath)
+        return true;
+    // A worker started. Note the hook names rather than activityKind "agent",
+    // which also covers a teammate going idle — the opposite of work.
+    if (event.hookEventName === "SubagentStart" || event.hookEventName === "TaskCreated")
+        return true;
+    // The orchestrator saying it is handing work out.
+    if (event.source === "custom" && event.phase === "delegating")
+        return true;
+    return false;
+}
+/** The lifecycle states an observed piece of work should pull back to active. */
+export function reopensOnWork(status) {
+    return status === "ready_for_review";
+}

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

@@ -0,0 +1,114 @@
+import { matchesWorker } from "@hive/shared";
+import { allPlanTasks } from "./plansStore.js";
+const key = (value) => value?.trim().toLowerCase() || undefined;
+/**
+ * Reconciles the board against the workers that are actually running.
+ *
+ * Orchestrators reliably launch workers but often forget to republish the plan,
+ * and a worker launched without a `delegating` event carries no task id at all.
+ * Either way the board sits at "queued" while work is visibly in flight. Rather
+ * than warn about that, derive the link from evidence Hive already has: the
+ * task ids bound to the worker's identity, or an exact match between the Agent
+ * description and a task's title or deliverable.
+ *
+ * Deliberately one-directional. A running worker is proof work started, so
+ * queued/blocked tasks may advance to working. A worker *stopping* is not proof
+ * the task succeeded, so completion still requires the orchestrator's report or
+ * a gate — this never marks anything done.
+ */
+export function reconcilePlanWorkers(plan, workers) {
+    if (!plan)
+        return [];
+    const tasks = plan.phases.flatMap((phase) => allPlanTasks(phase.tasks));
+    if (!tasks.length)
+        return [];
+    const open = (task) => task.status !== "completed" && task.status !== "cancelled";
+    const bindings = [];
+    // A task already claimed by another worker is never re-pointed here.
+    const claimedTasks = new Set(tasks.filter((task) => task.workerId || task.owner).map((task) => task.id));
+    for (const worker of workers) {
+        const explicit = (worker.taskIds ?? []).filter((id) => tasks.some((task) => task.id === id && open(task)));
+        if (explicit.length) {
+            for (const taskId of explicit)
+                bindings.push({ taskId, canonicalWorker: worker.id, label: worker.label, inferred: false });
+            continue;
+        }
+        // No `--task` was ever emitted for this worker. Fall back to an exact,
+        // unambiguous text match: orchestrators normally pass the task's title or
+        // its deliverable as the Agent description.
+        const name = key(worker.label);
+        if (!name)
+            continue;
+        const candidates = tasks.filter((task) => open(task) && !claimedTasks.has(task.id)
+            && (key(task.title) === name || key(task.assignment) === name || key(task.description) === name));
+        if (candidates.length !== 1)
+            continue;
+        claimedTasks.add(candidates[0].id);
+        bindings.push({ taskId: candidates[0].id, canonicalWorker: worker.id, label: worker.label, inferred: true });
+    }
+    // Skip anything the board already reflects.
+    return bindings.filter(({ taskId, canonicalWorker }) => {
+        const task = tasks.find((item) => item.id === taskId);
+        if (!task)
+            return false;
+        const worker = workers.find((item) => item.id === canonicalWorker);
+        const named = matchesWorker(task.workerId, worker) || matchesWorker(task.owner, worker);
+        const started = task.status === "working" || task.status === "reviewing";
+        return !named || !started;
+    });
+}
+/**
+ * Fill each task's changed files from the writes Hive already observed.
+ *
+ * `changedFiles` appears in the orchestrator's plan schema but nothing in its
+ * instructions ever asks it to be populated, so in practice it stays empty and
+ * the acceptance view has no idea what a mission touched. Hive does not need
+ * to be told: every file-write hook carries the path and the worker that made
+ * it, and workers are already bound to tasks. Deriving beats reporting here —
+ * it cannot drift from what actually happened, and it needs no cooperation
+ * from the model.
+ *
+ * Anything the orchestrator *did* report is kept and merged, never replaced:
+ * it may know about writes made before Hive was watching.
+ */
+export function deriveChangedFiles(plan, workers, events) {
+    if (!plan)
+        return plan;
+    const writes = events.filter((event) => event.activityKind === "file_write" && event.filePath);
+    if (!writes.length)
+        return plan;
+    const tasks = plan.phases.flatMap((phase) => allPlanTasks(phase.tasks));
+    const byTask = new Map();
+    const add = (taskId, filePath) => {
+        const set = byTask.get(taskId) ?? new Set();
+        set.add(filePath);
+        byTask.set(taskId, set);
+    };
+    for (const event of writes) {
+        // An explicit `--task` is the orchestrator's own attribution; trust it.
+        if (event.targetTask && tasks.some((task) => task.id === event.targetTask)) {
+            add(event.targetTask, event.filePath);
+            continue;
+        }
+        // Otherwise go through the worker, using the one identity comparison the
+        // rest of Hive uses, so an alias or a delegation label resolves the same.
+        const worker = workers.find((item) => matchesWorker(event.targetWorker, item));
+        if (!worker)
+            continue;
+        const owned = tasks.filter((task) => (worker.taskIds ?? []).includes(task.id) || matchesWorker(task.workerId, worker) || matchesWorker(task.owner, worker));
+        // A worker covering several tasks gives no evidence about which one a
+        // write belongs to, so attribute only when the answer is unambiguous.
+        if (owned.length === 1)
+            add(owned[0].id, event.filePath);
+    }
+    if (!byTask.size)
+        return plan;
+    const merge = (task) => {
+        const derived = byTask.get(task.id);
+        const subtasks = task.subtasks?.length ? task.subtasks.map(merge) : task.subtasks;
+        if (!derived)
+            return subtasks === task.subtasks ? task : { ...task, subtasks };
+        return { ...task, changedFiles: [...new Set([...(task.changedFiles ?? []), ...derived])].sort(), subtasks };
+    };
+    return { ...plan, phases: plan.phases.map((phase) => ({ ...phase, tasks: phase.tasks.map(merge) })) };
+}