@shanesaravia/hive 0.2.1 → 0.3.0

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;
@@ -203,6 +205,13 @@ export class MissionsStore {
     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) })) };
+}

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

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

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

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