@shanesaravia/hive 0.3.0 → 0.5.0

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

@@ -3,7 +3,9 @@ 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;
@@ -97,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));
@@ -138,6 +153,12 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
         }));
         const eventJobId = (event) => event.jobId ?? jobIdBySession.get(event.sessionId);
         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.
@@ -152,6 +173,7 @@ export function buildFleetSnapshot(sessions, jobs, events, missions, messageStor
             seededNested: workerIdentity?.listNested(missionId),
             now,
             correlationGraceMs: workerCorrelationGraceMs,
+            liveJobIds,
         });
         let workers = resolved.workers;
         if (workerIdentity && resolved.dirty) {
@@ -233,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,

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

@@ -131,13 +131,62 @@ const LAUNCH_NAME_GRACE_MS = 3_000;
  */
 export class WorkerIdentityTable {
     missionId;
+    liveJobIds;
     byCanonical = new Map();
     dirty = false;
-    constructor(missionId, seeded = []) {
+    constructor(missionId, seeded = [], liveJobIds = new Set()) {
         this.missionId = missionId;
+        this.liveJobIds = liveJobIds;
         for (const record of seeded)
             this.byCanonical.set(record.canonicalId, { ...record, nativeIds: [...record.nativeIds], labels: [...record.labels], planTaskIds: [...record.planTaskIds], sessionIds: [...record.sessionIds] });
     }
+    /**
+     * Whether this record belongs to a manager other than the one asking, and
+     * so must not be found by name.
+     *
+     * Only a name can be ambiguous. A provider-native agent id is unique by
+     * construction and means the same worker wherever it turns up. A plan task
+     * id and a delegation label are words an orchestrator chose, and two
+     * managers live on one mission choose the same words for different people:
+     * on mission f7ae71c7 two of them delegated plan task `t12` to a worker they
+     * both called `mr-babysitter`, three minutes apart. Matched across the two,
+     * one manager's report retired the other manager's worker.
+     *
+     * Two conditions keep this from splitting workers that ought to merge. The
+     * other job must still be able to act — a job that is over is not competing
+     * for anything, so a task picked up on a later turn still finds the worker
+     * whose task it is. And the worker must still be running: one that has
+     * finished is nobody's to guard, and adopting its task is exactly the retry
+     * this table exists to recognise.
+     */
+    ownedElsewhere(record, jobId) {
+        if (!jobId || !record.lastJobId || record.lastJobId === jobId)
+            return false;
+        return this.liveJobIds.has(record.lastJobId) && !record.doneAt;
+    }
+    /**
+     * A canonical id no other record has taken.
+     *
+     * A native id is unique already. A label is not, and two live managers can
+     * hand the same one to two different workers — where the table used to merge
+     * them it now keeps them apart, and keying both on the label would silently
+     * drop the first from the floor. The label stays the worker's display name
+     * either way; only the key it is filed under gains the owning job.
+     */
+    freeCanonicalId(label, jobId) {
+        if (!this.byCanonical.has(label))
+            return label;
+        const scoped = `${label}#${(jobId ?? "").slice(0, 8)}`;
+        if (jobId && !this.byCanonical.has(scoped))
+            return scoped;
+        for (let suffix = 2; suffix <= this.byCanonical.size + 2; suffix += 1) {
+            const candidate = `${jobId ? scoped : label}#${suffix}`;
+            if (!this.byCanonical.has(candidate))
+                return candidate;
+        }
+        // Unreachable: more candidates are tried above than there are records.
+        return `${label}#${this.byCanonical.size + 3}`;
+    }
     /** Flags a change made by a later pass, so the record set is persisted. */
     markDirty() { this.dirty = true; }
     /**
@@ -165,15 +214,17 @@ export class WorkerIdentityTable {
             if (match)
                 return match;
         }
+        // Names, unlike native ids, can belong to a live sibling manager.
+        const mine = (record) => !this.ownedElsewhere(record, ref.jobId);
         const task = norm(ref.taskId);
         if (task) {
-            const match = this.records().find((record) => record.planTaskIds.some((id) => id.toLowerCase() === task));
+            const match = this.records().find((record) => mine(record) && record.planTaskIds.some((id) => id.toLowerCase() === task));
             if (match)
                 return match;
         }
         const label = norm(ref.label);
         if (label) {
-            const match = this.records().find((record) => record.labels.some((item) => item.toLowerCase() === label));
+            const match = this.records().find((record) => mine(record) && record.labels.some((item) => item.toLowerCase() === label));
             if (match)
                 return match;
         }
@@ -185,13 +236,16 @@ export class WorkerIdentityTable {
     }
     /** Merge this evidence into an existing person, or create one. */
     bind(ref, into, options = {}) {
-        const existing = into ?? (options.allowLabelMerge === false ? this.find({ nativeId: ref.nativeId, taskId: ref.taskId }) : this.find(ref));
+        const existing = into ?? (options.allowLabelMerge === false ? this.find({ nativeId: ref.nativeId, taskId: ref.taskId, jobId: ref.jobId }) : this.find(ref));
         if (!existing) {
             // A native id is the stable, provider-owned name and is preferred as the
             // canonical id. A label-only worker (Codex, or a delegation whose launch
             // hook never arrived) is keyed by its label, scoped to this mission
-            // rather than to a single parent job so a resumed turn reuses it.
-            const canonicalId = ref.nativeId?.trim() || ref.label?.trim();
+            // rather than to a single parent job so a resumed turn reuses it — and
+            // disambiguated by job only where a live sibling already holds the name.
+            const native = ref.nativeId?.trim();
+            const label = ref.label?.trim();
+            const canonicalId = native || (label ? this.freeCanonicalId(label, ref.jobId) : undefined);
             if (!canonicalId)
                 throw new Error("worker identity requires a native id or a label");
             const record = { canonicalId, missionId: this.missionId, nativeIds: [], labels: [], planTaskIds: [], sessionIds: [], startedAt: ref.at, lastJobId: ref.jobId };
@@ -273,14 +327,26 @@ export class WorkerIdentityTable {
             this.dirty = true;
         return existing;
     }
-    /** Canonical id for any alias, or undefined when nothing has claimed it. */
-    canonicalFor(value) {
+    /**
+     * Canonical id for any alias, or undefined when nothing has claimed it.
+     *
+     * `jobId` is the manager speaking. Where two of them are live and have used
+     * the same word for two different workers, the speaker's own worker is the
+     * one it means — without that, a manager reporting its worker finished
+     * retired whichever record happened to be found first, and the wrong avatar
+     * left the floor.
+     */
+    canonicalFor(value, jobId) {
         if (!value)
             return undefined;
         const wanted = norm(value);
         if (!wanted)
             return undefined;
-        return this.records().find((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds].some((item) => item.toLowerCase() === wanted))?.canonicalId;
+        const matches = this.records().filter((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds].some((item) => item.toLowerCase() === wanted));
+        if (!matches.length)
+            return undefined;
+        const own = jobId ? matches.find((record) => record.lastJobId === jobId) : undefined;
+        return (own ?? matches.find((record) => !this.ownedElsewhere(record, jobId)) ?? matches[0]).canonicalId;
     }
 }
 /**
@@ -288,9 +354,13 @@ export class WorkerIdentityTable {
  * produced a different binding. Version 2 fixed an earlier delegation
  * adopting a later, unrelated launch that was still inside the pairing window,
  * which merged two workers into one actor and left the second delegation's
- * label stranded as a third.
+ * label stranded as a third. Version 5 stopped a launch under a still-live
+ * sibling job being read as a replacement, which merged the workers of
+ * concurrent managers into one person — and clears the records those bindings
+ * already wrote. Version 6 stopped a plan task or delegation label finding a
+ * live sibling manager's worker at all.
  */
-export const WORKER_IDENTITY_RESOLVER_VERSION = "4";
+export const WORKER_IDENTITY_RESOLVER_VERSION = "6";
 /** Persists resolved identities so they survive the bounded event ring. */
 export class WorkerIdentityStore {
     db;
@@ -358,12 +428,13 @@ export class WorkerIdentityStore {
             .run(JSON.stringify(record), Date.now(), missionId, canonicalId);
     }
     /** Canonical worker id for any alias, label, or plan task id. */
-    canonicalFor(missionId, value) {
+    canonicalFor(missionId, value, jobId) {
         const wanted = value?.trim().toLowerCase();
         if (!wanted)
             return undefined;
-        return this.list(missionId).find((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds]
-            .some((item) => item.trim().toLowerCase() === wanted))?.canonicalId;
+        const matches = this.list(missionId).filter((record) => [record.canonicalId, ...record.nativeIds, ...record.labels, ...record.planTaskIds]
+            .some((item) => item.trim().toLowerCase() === wanted));
+        return (jobId ? matches.find((record) => record.lastJobId === jobId) : undefined)?.canonicalId ?? matches[0]?.canonicalId;
     }
     removeMission(missionId) {
         this.db.prepare("DELETE FROM mission_workers WHERE mission_id = ?").run(missionId);
@@ -400,8 +471,9 @@ export function resolveMissionWorkers(input) {
     const events = expandMultiTargetEvents(input.events);
     const correlationGraceMs = input.correlationGraceMs ?? 8_000;
     const pairWindowMs = input.pairWindowMs ?? 30_000;
+    const liveJobIds = new Set(input.liveJobIds ?? []);
     const planTasksInput = input.planTasks ?? [];
-    const table = new WorkerIdentityTable(missionId, input.seeded);
+    const table = new WorkerIdentityTable(missionId, input.seeded, liveJobIds);
     // 1. Hook lifecycle evidence, keyed by the provider's own agent id.
     const nativeEvidence = new Map();
     // An agent launched by a worker is that worker's activity, not a new person
@@ -468,16 +540,27 @@ export function resolveMissionWorkers(input) {
             continue;
         const prior = nativeEvidence.get(nativeId);
         // A stop with no observed launch is usually a nested or background task
-        // notification: evidence, but not enough to invent a person.
-        if (isStop && !prior)
+        // notification: evidence, but not enough to invent a person — unless a
+        // persisted record already claims this id. Then the person exists and the
+        // launch has merely scrolled out of the event ring, which on a busy
+        // mission takes only a couple of minutes: 216 events separated one
+        // observed worker's start from its stop, and the ring holds 200. Dropping
+        // the stop there left `lastStoppedAt` unset for good, and a worker that
+        // had finished a quarter of an hour earlier read "Working" indefinitely.
+        const seededRecord = isStop && !prior ? table.find({ nativeId }) : undefined;
+        if (isStop && !prior && !seededRecord)
             continue;
         const label = labelOf(event) ?? prior?.label ?? nativeId;
         nativeEvidence.set(nativeId, {
             nativeId,
             jobId,
             label: prior && prior.label !== prior.nativeId ? prior.label : label,
-            startedAt: Math.min(prior?.startedAt ?? event.ts, event.ts),
-            restartedAt: isStart ? event.ts : prior?.restartedAt ?? event.ts,
+            startedAt: Math.min(prior?.startedAt ?? seededRecord?.startedAt ?? event.ts, event.ts),
+            // A stop must never be read as a start. Where the launch is out of view,
+            // the record's own last start is the honest answer; inventing one at the
+            // stop's timestamp would make the worker look as though it began at the
+            // moment it ended.
+            restartedAt: isStart ? event.ts : prior?.restartedAt ?? seededRecord?.lastStartedAt ?? event.ts,
             doneAt: isStop ? event.ts : isStart ? undefined : prior?.doneAt,
             updatedAt: event.ts,
             running: isStart,
@@ -530,7 +613,7 @@ export function resolveMissionWorkers(input) {
     // worker there is nothing a name could change, so it binds immediately as it
     // always has; it is two delegations reaching for the same anonymous launch
     // that need the description to arrive first.
-    const contenders = delegations.filter((event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event) })?.nativeIds.length).length;
+    const contenders = delegations.filter((event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event), jobId: eventJobId(event) })?.nativeIds.length).length;
     // Decide nothing while a name may still be arriving. Deferring the whole
     // pass rather than the individual launch matters: pairing sees every launch
     // at once either way, so waiting cannot change which delegation wins a
@@ -538,7 +621,7 @@ export function resolveMissionWorkers(input) {
     const waitingForNames = contenders > 1
         && launchOrder.some((launch) => !launchIsNamed(launch.nativeId) && now - launch.startedAt < LAUNCH_NAME_GRACE_MS);
     const namedLaunches = waitingForNames ? [] : launchOrder;
-    const needsLaunch = (event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event) })?.nativeIds.length;
+    const needsLaunch = (event) => !table.find({ label: event.targetWorker?.trim() || undefined, taskId: identityTask(event), jobId: eventJobId(event) })?.nativeIds.length;
     const pairing = pairDelegationsByName({
         delegations: delegations.filter(needsLaunch),
         launches: namedLaunches.filter((launch) => !claimed.has(launch.nativeId)),
@@ -568,7 +651,7 @@ export function resolveMissionWorkers(input) {
                 return false;
             if (pairing.has(other))
                 return false;
-            const otherNamed = table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other) });
+            const otherNamed = table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other), jobId });
             if (otherNamed?.nativeIds.length)
                 return false;
             return Math.abs(startedAt - other.ts) < Math.abs(startedAt - event.ts);
@@ -586,7 +669,7 @@ export function resolveMissionWorkers(input) {
         // An already-known label or plan task wins over the launch: a retried or
         // replaced task keeps its person, and the fresh provider id joins it as
         // another alias instead of taking a second desk.
-        const named = table.find({ label, taskId: identityTask(event) });
+        const named = table.find({ label, taskId: identityTask(event), jobId });
         const known = named ?? (pairable ? table.find({ nativeId: pairable.nativeId }) : undefined);
         // A delegation that already has its worker must not swallow a later,
         // unrelated launch just because it is still inside the pairing window —
@@ -615,7 +698,16 @@ export function resolveMissionWorkers(input) {
         const previousStopped = previousStoppedAt !== Infinity && event.ts >= previousStoppedAt;
         // A retry on a later turn arrives under a new job while the old attempt's
         // job has simply ended; that is a replacement too, stop or no stop.
-        const laterJob = Boolean(pairable && named?.lastJobId && pairable.jobId !== named.lastJobId);
+        //
+        // "Under a new job" only means the old attempt ended if the old job did.
+        // Two managers live on one mission at the same time — a resume that forked
+        // rather than continued — delegate the same plan task within seconds of
+        // each other under two different job ids, and reading the second as a
+        // retry of the first merged four separate agents across four sessions into
+        // one person: a board refresher's work was credited to the reviewer, and
+        // the mission reported a worker had done something that worker never did.
+        // A job still able to act has not ended, and its worker is a sibling.
+        const laterJob = Boolean(pairable && named?.lastJobId && pairable.jobId !== named.lastJobId && !liveJobIds.has(named.lastJobId));
         const replacing = alreadyLaunched && !sameLaunch && !reported && taskStillOpen && (previousStopped || laterJob);
         const adopt = pairable && (!alreadyLaunched || sameLaunch || replacing) ? pairable : undefined;
         if (adopt)
@@ -643,7 +735,7 @@ export function resolveMissionWorkers(input) {
         // still running. Merging by description exists for a retry — a fresh id for
         // work whose previous attempt has stopped or been reported — and
         // orchestrators reuse descriptions for parallel workers.
-        const sameName = label ? table.find({ label }) : undefined;
+        const sameName = label ? table.find({ label, jobId: native.jobId }) : undefined;
         const sameNameLive = Boolean(sameName?.nativeIds.length) && sameName.nativeIds.some((id) => { const evidence = nativeEvidence.get(id); return evidence ? !evidence.doneAt : false; })
             && ![sameName.canonicalId, ...sameName.nativeIds, ...sameName.labels, ...sameName.planTaskIds].some((value) => reportedRefs.has(norm(value) ?? ""));
         const ref = { nativeId: native.nativeId, label, jobId: native.jobId, sessionId: native.sessionId, at: native.startedAt };
@@ -667,7 +759,7 @@ export function resolveMissionWorkers(input) {
         // it, and nobody when the manager did.
         const canonical = event.toolName === "Agent"
             ? (event.workerRef?.parentAgentId ? table.canonicalFor(event.workerRef.parentAgentId) : undefined)
-            : table.canonicalFor(event.workerRef?.agentId) ?? table.canonicalFor(event.targetWorker);
+            : table.canonicalFor(event.workerRef?.agentId) ?? table.canonicalFor(event.targetWorker, eventJobId(event));
         if (canonical)
             backgroundedAt.set(canonical, Math.max(backgroundedAt.get(canonical) ?? 0, event.ts));
     }
@@ -679,7 +771,7 @@ export function resolveMissionWorkers(input) {
     for (const event of events) {
         if (event.source !== "custom")
             continue;
-        let canonical = table.canonicalFor(event.targetWorker) ?? table.canonicalFor(event.targetTask);
+        let canonical = table.canonicalFor(event.targetWorker, eventJobId(event)) ?? table.canonicalFor(event.targetTask, eventJobId(event));
         if (!canonical)
             continue;
         // A delegation whose launch was never paired sits as an unpublished label
@@ -774,8 +866,21 @@ export function resolveMissionWorkers(input) {
         const closedTasks = taskIds.length && planTasks.length ? planTasks.filter((task) => taskIds.includes(task.id) && (task.status === "completed" || task.status === "cancelled")) : [];
         const taskClosed = closedTasks.length && !openTask ? Math.max(...closedTasks.map((task) => task.updatedAt ?? 0)) || stoppedAt || now : undefined;
         // The stop-settle applies only where nothing else can ever speak for the
-        // worker: a mission with no plan.
-        const settledStop = stoppedAt !== undefined && !planTasks.length && !awaitingBackgroundWork && now - stoppedAt >= WORKER_STOP_SETTLE_MS ? stoppedAt : undefined;
+        // worker. That is a question about *this* worker, not about the mission:
+        // the reason a plan suppresses the settle is that the orchestrator is
+        // speaking for its workers through it, and it speaks for a worker only via
+        // a task that worker owns. A worker with no task of its own, in a mission
+        // that has a plan, had nothing that could ever retire it — no task to
+        // close, no settle allowed — so a `SubagentStop` left it reading as merely
+        // paused for the rest of the mission. One observed worker sat that way for
+        // 27 minutes beside a manager that had been idle for 26 of them.
+        // Either direction of the binding counts: a task id the record has claimed,
+        // or a task that names this worker itself. Reading only the first missed
+        // every worker the plan had been reconciled onto rather than delegated to.
+        const ownNames = new Set([record.canonicalId, ...record.nativeIds, ...record.labels].map((name) => name.toLowerCase()));
+        const spokenForByPlan = planTasks.some((task) => (taskIds.length > 0 && taskIds.includes(task.id))
+            || (task.workerId ? ownNames.has(task.workerId.toLowerCase()) : false));
+        const settledStop = stoppedAt !== undefined && !spokenForByPlan && !awaitingBackgroundWork && now - stoppedAt >= WORKER_STOP_SETTLE_MS ? stoppedAt : undefined;
         // The orchestrator's report closes a worker for good. The provider may
         // still start that agent again — a manager checking on a delayed reply
         // does exactly this, twice in one observed run — but those are follow-ups
@@ -824,7 +929,7 @@ export function resolveMissionWorkers(input) {
         // native id is the one that survives.
         const delegationWaiting = !record.published && !record.delegated && record.nativeIds.length > 0
             && delegations.some((other) => eventJobId(other) === jobId && needsLaunch(other)
-                && table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other) })?.published)
+                && table.find({ label: other.targetWorker?.trim() || undefined, taskId: identityTask(other), jobId: eventJobId(other) })?.published)
             && now - startedAt < correlationGraceMs;
         if (mayYetPair || delegationWaiting || (!corroborated && now - startedAt < correlationGraceMs))
             continue;

package/packages/server/dist/skills/skillDiscovery.js

@@ -50,17 +50,41 @@ function collectPluginSkills(root) {
     }
     return output;
 }
+/**
+ * A mission's recorded repository can be a directory that no longer exists —
+ * reaching a terminal state reclaims its worktree. The project half of
+ * discovery is unavailable then, but the user's own skills are not, so this
+ * degrades to them rather than failing outright. Failing threw out ten usable
+ * skills over a missing project directory, and, because `sendToMission`
+ * discovers skills before it falls back to a live repository, made messaging
+ * such a mission impossible.
+ */
+function projectSkills(cwd, provider) {
+    let project;
+    try {
+        project = requireWorkingDirectory(cwd);
+    }
+    catch {
+        return [];
+    }
+    return provider === "codex"
+        ? collect(path.join(project, ".codex", "skills"), "project")
+        : [
+            ...collect(path.join(project, ".claude", "skills"), "project"),
+            ...collect(path.join(project, ".claude", "commands"), "project"),
+        ];
+}
 export function discoverSkills(cwd, provider = "claude") {
-    const project = requireWorkingDirectory(cwd);
     const claudeConfig = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
     const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+    // Project entries lead, so the dedup below keeps them over a user skill of
+    // the same name.
     const all = provider === "codex" ? [
-        ...collect(path.join(project, ".codex", "skills"), "project"),
+        ...projectSkills(cwd, provider),
         ...collect(path.join(codexHome, "skills"), "user"),
         ...collectPluginSkills(path.join(codexHome, "plugins", "cache")),
     ] : [
-        ...collect(path.join(project, ".claude", "skills"), "project"),
-        ...collect(path.join(project, ".claude", "commands"), "project"),
+        ...projectSkills(cwd, provider),
         ...collect(path.join(claudeConfig, "skills"), "user"),
         ...collect(path.join(claudeConfig, "commands"), "user"),
     ];

package/packages/server/dist/terminals/claudeStreamClient.js

@@ -0,0 +1,90 @@
+import { spawn } from "node:child_process";
+import { Duplex } from "node:stream";
+export function claudeStreamArguments(options) {
+    const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"];
+    if (options.resumeSessionId)
+        args.push("--resume", options.resumeSessionId);
+    if (options.model)
+        args.push("--model", options.model);
+    return args;
+}
+/** Reproducible lifecycle spike; production Claude --bg remains follow-up only. */
+export class ClaudeStreamClient {
+    stream;
+    interruptProcess;
+    terminateProcess;
+    buffer = "";
+    closed = false;
+    listeners = new Set();
+    constructor(stream, interruptProcess = () => undefined, terminateProcess = () => undefined) {
+        this.stream = stream;
+        this.interruptProcess = interruptProcess;
+        this.terminateProcess = terminateProcess;
+        stream.setEncoding("utf8");
+        stream.on("data", (chunk) => this.consume(chunk));
+        stream.on("close", () => this.finish());
+        stream.on("error", (error) => this.emit({ type: "hive/error", message: error.message }));
+    }
+    static spawn(options, command = "claude") {
+        const child = spawn(command, claudeStreamArguments(options), { cwd: options.cwd, stdio: ["pipe", "pipe", "pipe"] });
+        child.stderr.resume();
+        return new ClaudeStreamClient(new ChildDuplex(child), () => { child.kill("SIGINT"); }, () => { child.kill("SIGTERM"); });
+    }
+    send(text, sessionId) {
+        if (this.closed)
+            throw new Error("Claude stream client is closed");
+        const message = { type: "user", message: { role: "user", content: text } };
+        if (sessionId)
+            message.session_id = sessionId;
+        this.stream.write(`${JSON.stringify(message)}\n`);
+    }
+    onEvent(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+    interrupt() { if (!this.closed)
+        this.interruptProcess(); }
+    endInput() { if (!this.closed)
+        this.stream.end(); }
+    close() { if (!this.closed) {
+        this.closed = true;
+        this.stream.end();
+        this.terminateProcess();
+    } }
+    consume(chunk) {
+        this.buffer += chunk;
+        let newline;
+        while ((newline = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event && typeof event.type === "string")
+                    this.emit(event);
+            }
+            catch {
+                this.emit({ type: "hive/invalid-json", line });
+            }
+        }
+    }
+    finish() { if (!this.closed) {
+        this.closed = true;
+        this.emit({ type: "hive/connection/closed" });
+    } }
+    emit(event) { for (const listener of this.listeners)
+        listener(event); }
+}
+class ChildDuplex extends Duplex {
+    child;
+    constructor(child) {
+        super();
+        this.child = child;
+        child.stdout.on("data", (chunk) => this.push(chunk));
+        child.stdout.on("end", () => this.push(null));
+        child.stdout.on("error", (error) => this.destroy(error));
+        child.stdin.on("error", (error) => this.destroy(error));
+        child.once("exit", () => this.push(null));
+    }
+    _read() { }
+    _write(chunk, encoding, callback) { this.child.stdin.write(chunk, encoding, callback); }
+    _final(callback) { this.child.stdin.end(callback); }
+}