@shanesaravia/hive 0.2.1 → 0.4.0

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

@@ -1,7 +1,11 @@
 import { deriveStatus, } from "@hive/shared";
 import { allPlanTasks } from "../plans/plansStore.js";
+import { deriveChangedFiles, reconcilePlanWorkers } from "../plans/planReconcile.js";
 import { config } from "../config.js";
 import { deriveAlerts } from "../health/deriveAlerts.js";
+import { jobIsLive } from "../control/missionQuiesce.js";
+import { resolveMissionWorkers } from "./workerIdentity.js";
+import { detectReplyAsk } from "./replyAsk.js";
 const ORCHESTRATOR_AGENT_NAME = "hive-orchestrator";
 function dateMs(value) {
     const parsed = value ? Date.parse(value) : NaN;
@@ -18,7 +22,7 @@ function resultText(job) {
     return undefined;
 }
 /** Joins Claude's short-lived jobs into durable, Hive-managed missions. */
-export function buildFleetSnapshot(sessions, jobs, events, missions, messageStore, planStore, now = Date.now()) {
+export function buildFleetSnapshot(sessions, jobs, events, missions, messageStore, planStore, now = Date.now(), workerIdentity) {
     const workerCorrelationGraceMs = 8_000;
     const orchestrators = [];
     const other = [];
@@ -95,7 +99,20 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
                     choices: latestJob.promptChoices ?? [], impact: "The provider is waiting for this answer before the skill can continue.", createdAt: node.updatedAt, ...missionContext,
                 }]
             : [];
-        return [...fromEvents, ...parked, ...providerPrompt];
+        // A turn that ended by asking the reader something. No structured signal
+        // fires for this — the agent simply wrote the question — so without it the
+        // mission sits looking finished while it waits for an answer.
+        const replyAsk = node.turnCompleted && latestJob && !resolved.has(`ask:${node.jobId}`)
+            ? detectReplyAsk(latestJob.lastText ?? resultText(latestJob))
+            : undefined;
+        const fromReply = replyAsk && !fromEvents.length && !parked.length && !providerPrompt.length
+            ? [{
+                    id: `ask:${node.jobId}`, missionId: node.missionId, missionName: node.name,
+                    kind: "question", question: replyAsk.question,
+                    choices: [], impact: "The mission has finished its turn and is waiting on your answer.", createdAt: node.updatedAt, ...missionContext,
+                }]
+            : [];
+        return [...fromEvents, ...parked, ...providerPrompt, ...fromReply];
     };
     for (const [missionId, group] of groups) {
         group.sort((a, b) => dateMs(a.job.createdAt) - dateMs(b.job.createdAt));
@@ -124,7 +141,7 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
                 .map((event) => [`${event.sessionId}:${event.jobId ?? ""}:${event.ts}:${event.phase}:${event.decisionId ?? ""}:${event.targetWorker ?? ""}:${event.detail}`, event])).values()]
             .sort((a, b) => a.ts - b.ts);
         let recentEvents = allEvents.slice(-100);
-        let workers = group.flatMap(({ jobId, job }) => (job.fan ?? []).filter((worker) => worker.kind === "agent" || worker.kind === "subagent").map((worker) => ({
+        const fanWorkers = group.flatMap(({ jobId, job }) => (job.fan ?? []).filter((worker) => worker.kind === "agent" || worker.kind === "subagent").map((worker) => ({
             ...worker,
             jobId,
             jobState: job.state,
@@ -134,150 +151,48 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
             const linkedSession = sessionsByJob.get(jobId);
             return [...(job.sessionId ? [[job.sessionId, jobId]] : []), ...(linkedSession ? [[linkedSession.sessionId, jobId]] : [])];
         }));
-        const jobStateById = new Map(group.map(({ jobId, job }) => [jobId, job.state]));
-        const parentTurnFinished = (jobId) => ["done", "completed", "failed", "error", "cancelled", "canceled", "stopped"].includes((jobStateById.get(jobId) ?? "").toLowerCase());
         const eventJobId = (event) => event.jobId ?? jobIdBySession.get(event.sessionId);
-        // A job's fan array is only a current view and can drop an earlier worker
-        // as soon as a later worker starts. Rebuild the durable native roster from
-        // hook history, keyed by Claude's real agent id, and merge fan metadata.
-        const nativeEvidence = new Map();
-        for (const event of allEvents) {
-            const resolvedJobId = eventJobId(event);
-            const raw = event.rawPayload && typeof event.rawPayload === "object" ? event.rawPayload : {};
-            const response = raw.tool_response && typeof raw.tool_response === "object" ? raw.tool_response : {};
-            const input = raw.tool_input && typeof raw.tool_input === "object" ? raw.tool_input : {};
-            const launchId = typeof response.agentId === "string" ? response.agentId : typeof response.agent_id === "string" ? response.agent_id : undefined;
-            const nativeId = launchId ?? event.targetWorker;
-            if (!resolvedJobId || !nativeId || nativeId === "hive-orchestrator")
-                continue;
-            const isStart = event.hookEventName === "SubagentStart" || (event.hookEventName === "PostToolUse" && event.toolName === "Agent" && Boolean(launchId));
-            const isStop = event.hookEventName === "SubagentStop";
-            if (!isStart && !isStop)
-                continue;
-            const label = typeof response.description === "string" ? response.description : typeof input.description === "string" ? input.description : nativeId;
-            const key = `${resolvedJobId}:${nativeId}`;
-            const prior = nativeEvidence.get(key);
-            // A stop without any observed launch is often a nested/background task
-            // notification. It is evidence, but not enough to invent a person.
-            if (isStop && !prior)
-                continue;
-            nativeEvidence.set(key, {
-                id: nativeId,
-                jobId: resolvedJobId,
-                label: prior?.label !== prior?.id ? prior.label : label,
-                startedAt: Math.min(prior?.startedAt ?? event.ts, event.ts),
-                doneAt: isStop ? event.ts : isStart ? undefined : prior?.doneAt,
-                updatedAt: event.ts,
-                running: isStart,
-            });
-        }
-        const workerByNativeKey = new Map(workers.map((worker) => [`${worker.jobId}:${worker.id}`, worker]));
-        for (const native of nativeEvidence.values()) {
-            const key = `${native.jobId}:${native.id}`;
-            const fanWorker = workerByNativeKey.get(key);
-            const turnFinished = parentTurnFinished(native.jobId);
-            // SubagentStop is the worker's own terminal lifecycle boundary. The
-            // manager may remain idle/open for follow-up, but that must not keep a
-            // finished worker seated indefinitely. A later SubagentStart for the
-            // same native id clears native.doneAt above and resumes that person.
-            const workerFinished = Boolean(native.doneAt) || turnFinished;
-            const merged = fanWorker ? {
-                ...fanWorker,
-                label: fanWorker.label || native.label,
-                startedAt: Math.min(fanWorker.startedAt, native.startedAt),
-                doneAt: native.doneAt ?? (turnFinished ? fanWorker.doneAt : undefined),
-                updatedAt: Math.max(fanWorker.updatedAt ?? 0, native.updatedAt),
-                jobState: workerFinished ? "done" : native.running ? "working" : "idle",
-            } : {
-                id: native.id,
-                kind: "agent",
-                label: native.label,
-                startedAt: native.startedAt,
-                doneAt: native.doneAt,
-                updatedAt: native.updatedAt,
-                jobId: native.jobId,
-                jobState: workerFinished ? "done" : native.running ? "working" : "idle",
-            };
-            workerByNativeKey.set(key, merged);
+        const missionSummary = missions?.summaryFor(missionId, oldest.job.intent ?? "");
+        const turnCompleted = latest.job.state === "done";
+        // Every manager on this mission the provider can still act through. A
+        // mission is meant to have one; more than one means a resume forked
+        // instead of continuing, and the extras are still working the same
+        // worktree. Both the roster and the alerts need to know.
+        const liveJobIds = group.filter(({ jobId, job }) => jobIsLive(jobId, job, sessions.values())).map(({ jobId }) => jobId);
+        // One canonical person per delegated job. The resolver owns every identity
+        // decision — native ids, delegation labels, plan tasks, nested agents —
+        // and persists them so a later poll cannot re-decide them differently.
+        const resolved = resolveMissionWorkers({
+            missionId,
+            fanWorkers,
+            events: allEvents,
+            eventJobId,
+            planTasks: planStore?.get(missionId)?.phases.flatMap((phase) => allPlanTasks(phase.tasks)),
+            missionActive: (missionSummary?.lifecycleStatus ?? "active") === "active",
+            seeded: workerIdentity?.list(missionId),
+            seededNested: workerIdentity?.listNested(missionId),
+            now,
+            correlationGraceMs: workerCorrelationGraceMs,
+            liveJobIds,
+        });
+        let workers = resolved.workers;
+        if (workerIdentity && resolved.dirty) {
+            workerIdentity.save(missionId, resolved.records);
+            workerIdentity.saveNested(missionId, resolved.nested);
         }
-        workers = [...workerByNativeKey.values()];
-        // A resumed/follow-up job may address the same provider-native agent id.
-        // The mission roster is person-oriented, so expose that id once using its
-        // latest lifecycle state instead of creating duplicate React/desk actors
-        // for each short-lived parent job.
-        const workersByIdentity = new Map();
-        for (const worker of workers.sort((a, b) => a.startedAt - b.startedAt || a.id.localeCompare(b.id))) {
-            const prior = workersByIdentity.get(worker.id);
-            if (!prior) {
-                workersByIdentity.set(worker.id, worker);
-                continue;
+        // Keep the board honest without waiting for the orchestrator to republish
+        // it: a worker that is provably running advances its task to working.
+        if (planStore) {
+            // `doneAt` is the only lifecycle signal; `jobState` is decoration.
+            const present = workers.filter((worker) => !worker.doneAt);
+            for (const binding of reconcilePlanWorkers(planStore.get(missionId), present)) {
+                planStore.attachWorker(missionId, binding);
+                if (binding.inferred)
+                    workerIdentity?.addTaskBinding(missionId, binding.canonicalWorker, binding.taskId);
             }
-            const priorFreshness = prior.updatedAt ?? prior.doneAt ?? prior.startedAt;
-            const workerFreshness = worker.updatedAt ?? worker.doneAt ?? worker.startedAt;
-            const latest = workerFreshness >= priorFreshness ? worker : prior;
-            workersByIdentity.set(worker.id, {
-                ...latest,
-                label: latest.label || prior.label,
-                startedAt: Math.min(prior.startedAt, worker.startedAt),
-            });
-        }
-        workers = [...workersByIdentity.values()];
-        // Friendly/custom worker names are presentation aliases only. Native
-        // Claude ids remain canonical so close or repeated delegations can never
-        // swap React identities or manufacture an extra avatar.
-        const workerAliases = new Map();
-        const claimedNativeWorkers = new Set();
-        for (const event of allEvents.filter((candidate) => candidate.source === "custom" && candidate.phase === "delegating" && candidate.targetWorker)) {
-            const resolvedJobId = eventJobId(event);
-            if (!resolvedJobId)
-                continue;
-            const aliasKey = `${resolvedJobId}:${event.targetWorker}`;
-            const candidate = workers
-                .filter((worker) => worker.jobId === resolvedJobId && !claimedNativeWorkers.has(worker.id) && Math.abs(worker.startedAt - event.ts) <= 30_000)
-                .sort((a, b) => Math.abs(a.startedAt - event.ts) - Math.abs(b.startedAt - event.ts))[0];
-            workerAliases.set(aliasKey, candidate?.id ?? aliasKey);
-            if (!candidate)
-                continue;
-            claimedNativeWorkers.add(candidate.id);
         }
-        if (workerAliases.size)
-            recentEvents = recentEvents.map((event) => {
-                if (!event.targetWorker)
-                    return event;
-                const resolvedJobId = eventJobId(event);
-                if (!resolvedJobId)
-                    return event;
-                const key = `${resolvedJobId}:${event.targetWorker}`;
-                const targetWorker = workerAliases.get(key);
-                return targetWorker ? { ...event, targetWorker } : event;
-            });
-        // Claude's fan file can arrive just before its delegation hook. Publishing
-        // that unmatched native id for a single poll makes the office animate a
-        // second person. Hold it briefly for correlation; canonical/event-backed
-        // workers remain immediate, and hookless workers appear after the grace.
-        const correlatedWorkerIds = new Set(recentEvents.filter((event) => event.source === "custom" && event.phase === "delegating").map((event) => event.targetWorker).filter((id) => Boolean(id)));
-        workers = workers.filter((worker) => nativeEvidence.has(`${worker.jobId}:${worker.id}`) || correlatedWorkerIds.has(worker.id) || now - worker.startedAt >= workerCorrelationGraceMs);
+        recentEvents = recentEvents.map(resolved.rewrite);
         const derived = deriveStatus(session, latest.job, recentEvents, now);
-        const workerIds = new Set(workers.map((worker) => worker.id));
-        for (const event of recentEvents) {
-            if (!event.targetWorker || workerIds.has(event.targetWorker))
-                continue;
-            const related = recentEvents.filter((candidate) => candidate.targetWorker === event.targetWorker);
-            const start = related.find((candidate) => candidate.phase === "delegating" || candidate.phase?.toLowerCase().includes("subagentstart") || candidate.hookEventName?.toLowerCase() === "subagentstart");
-            if (!start)
-                continue;
-            // A friendly delegation target is an alias, not a person. Hold every
-            // unmatched identity through the correlation window; a native Agent id
-            // normally arrives within milliseconds and becomes the sole actor.
-            if (now - start.ts < workerCorrelationGraceMs)
-                continue;
-            const done = [...related].reverse().find((candidate) => candidate.phase === "worker_reported" || candidate.phase?.toLowerCase().includes("subagentstop") || candidate.hookEventName?.toLowerCase() === "subagentstop");
-            const resolvedJobId = eventJobId(event);
-            if (!resolvedJobId)
-                continue;
-            workers.push({ id: event.targetWorker, label: event.targetWorker, kind: "subagent", startedAt: start.ts, doneAt: done?.ts, updatedAt: related.at(-1)?.ts, jobId: resolvedJobId, jobState: done ? "done" : latest.job.state });
-            workerIds.add(event.targetWorker);
-        }
         const derivedMessages = group.flatMap(({ jobId, job }) => {
             const createdAt = dateMs(job.createdAt);
             const updatedAt = dateMs(job.updatedAt) || createdAt;
@@ -319,7 +234,9 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
             lifecycleStatus: "active",
             mode: "orchestrated",
         };
-        const missionPlan = planStore?.get(missionId);
+        // Derived at read time rather than written back: the events are the source
+        // of truth, so this always reflects the latest ones without extra writes.
+        const missionPlan = deriveChangedFiles(planStore?.get(missionId), workers, recentEvents);
         const inactiveForMs = Math.max(0, now - updatedAt);
         let activityStatus = derived.status;
         if (mission.lifecycleStatus === "completed" || mission.lifecycleStatus === "archived") {
@@ -338,20 +255,34 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
             // In that case the runtime is idle, not mission-complete.
             if (activityStatus === "done")
                 activityStatus = "idle";
-            const workExpected = session?.status === "busy" || latest.job.state === "working" || latest.job.state === "busy" || workers.some((worker) => !worker.doneAt && (worker.jobState === "working" || worker.jobState === "busy")) || Boolean(missionPlan?.phases.some((phase) => phase.status === "working" || phase.status === "reviewing" || allPlanTasks(phase.tasks).some((task) => task.status === "working" || task.status === "reviewing")));
-            if (activityStatus === "idle" && workExpected && inactiveForMs >= config.stalledAfterMs) {
+            // Provably running right now, as opposed to a plan that merely claims
+            // work is open. Workers outlive the manager's own session going quiet
+            // between turns, so a mission with live workers is working — reading
+            // "Idle" while four of them report progress is simply wrong.
+            const liveWork = session?.status === "busy"
+                || latest.job.state === "working" || latest.job.state === "busy"
+                || workers.some((worker) => !worker.doneAt && (worker.jobState === "working" || worker.jobState === "busy"));
+            const workExpected = liveWork || Boolean(missionPlan?.phases.some((phase) => phase.status === "working" || phase.status === "reviewing" || allPlanTasks(phase.tasks).some((task) => task.status === "working" || task.status === "reviewing")));
+            if ((activityStatus === "idle" || activityStatus === "working") && workExpected && inactiveForMs >= config.stalledAfterMs) {
+                // Covers "working" too: a job record left behind by a dead process
+                // still claims to be working, and only the elapsed time known here can
+                // tell that apart from work actually in progress.
                 activityStatus = "stalled";
             }
+            else if (activityStatus === "idle" && liveWork) {
+                // A stale plan can claim work forever, so only provably live work
+                // promotes an idle mission; a plan's claim alone must not.
+                activityStatus = "working";
+            }
         }
         const name = missions?.nameFor(missionId) ?? oldest.job.name ?? latest.job.name ?? missionId;
-        const turnCompleted = latest.job.state === "done";
         const pendingDecisions = pendingDecisionsFor({ missionId, name, jobId: latest.jobId, mission, lifecycleStatus: mission.lifecycleStatus, turnCompleted, recentEvents, updatedAt });
         // An unanswered decision is, by definition, waiting on the user. Do not let the
         // runtime's quiet session decay it to idle/stalled while the question stands.
         if (mission.lifecycleStatus === "active" && pendingDecisions.length && (activityStatus === "idle" || activityStatus === "stalled"))
             activityStatus = "waiting_on_you";
         const runStartedAt = dateMs(latest.job.createdAt) || createdAt;
-        const alerts = deriveAlerts({ lifecycle: mission.lifecycleStatus, activity: activityStatus, stale: derived.stale, turnCompleted, workers, events: recentEvents, now, turnTokens: latest.job.tokens ?? 0, runStartedAt });
+        const alerts = deriveAlerts({ lifecycle: mission.lifecycleStatus, activity: activityStatus, stale: derived.stale, turnCompleted, workers, events: recentEvents, now, turnTokens: latest.job.tokens ?? 0, runStartedAt, liveJobIds });
         orchestrators.push({
             missionId,
             threadId: missionId,