@shanesaravia/hive 0.3.0 → 0.4.0

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

@@ -1,6 +1,7 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import Database from "better-sqlite3";
 import { config } from "../config.js";
+import { stripLoopInstructions, stripNoopMarker } from "../loops/loopNoop.js";
 const DEFAULT_PAGE_SIZE = 30;
 const MAX_PAGE_SIZE = 100;
 export const MODEL_CONTEXT_MESSAGE_LIMIT = 12;
@@ -16,6 +17,14 @@ function outputText(job) {
     }
     return undefined;
 }
+/**
+ * Stable suffix derived from the text itself, so re-running a sync over the
+ * same content is a no-op while genuinely different content lands under its own
+ * id instead of overwriting what is already on screen.
+ */
+export function contentKey(text) {
+    return createHash("sha1").update(text).digest("hex").slice(0, 12);
+}
 function timestamp(value) {
     const parsed = value ? Date.parse(value) : NaN;
     return Number.isNaN(parsed) ? Date.now() : parsed;
@@ -28,6 +37,8 @@ function toMessage(row) {
         createdAt: row.created_at,
         jobId: row.job_id ?? "",
         ...(row.kind === "update" ? { kind: "update" } : {}),
+        ...(row.attachments ? { attachments: JSON.parse(row.attachments) } : {}),
+        ...(row.noop ? { noop: true } : {}),
     };
 }
 /** Indexed, paginated transcript storage. History is never prompt context by default. */
@@ -46,7 +57,9 @@ export class MessagesStore {
         text TEXT NOT NULL,
         created_at INTEGER NOT NULL,
         job_id TEXT,
-        kind TEXT
+        kind TEXT,
+        attachments TEXT,
+        noop INTEGER
       );
       CREATE INDEX IF NOT EXISTS idx_mission_messages_page
         ON mission_messages (mission_id, created_at DESC, id DESC);
@@ -57,6 +70,14 @@ export class MessagesStore {
             this.db.exec("ALTER TABLE mission_messages ADD COLUMN kind TEXT");
         }
         catch { /* already present */ }
+        try {
+            this.db.exec("ALTER TABLE mission_messages ADD COLUMN attachments TEXT");
+        }
+        catch { /* already present */ }
+        try {
+            this.db.exec("ALTER TABLE mission_messages ADD COLUMN noop INTEGER");
+        }
+        catch { /* already present */ }
     }
     close() {
         this.db.close();
@@ -72,26 +93,20 @@ export class MessagesStore {
             createdAt: input.createdAt,
             jobId: input.jobId,
             ...(input.kind ? { kind: input.kind } : {}),
+            ...(input.attachments?.length ? { attachments: input.attachments } : {}),
         };
-        this.db
-            .prepare(`
-        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, kind: message.kind ?? null, missionId: input.missionId, jobId: input.jobId || null });
+        // Callers key on the job (`<jobId>:user`), so a retried turn can collide
+        // with a message already on screen. Append rather than rewrite it, and
+        // report the id the text actually landed under.
+        const id = this.appendSynced({ ...message, missionId: input.missionId, jobId: input.jobId || "" });
         this.notify();
-        return message;
+        return { ...message, id };
     }
     page(missionId, options = {}) {
         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, kind
+        SELECT id, mission_id, role, text, created_at, job_id, kind, attachments, noop
         FROM mission_messages
         WHERE mission_id = @missionId
           AND (@before IS NULL OR created_at < @before)
@@ -147,7 +162,7 @@ export class MessagesStore {
                         id: `${jobId}:user`,
                         missionId,
                         role: "user",
-                        text: job.intent,
+                        text: stripLoopInstructions(job.intent),
                         createdAt: timestamp(job.createdAt),
                         jobId,
                     });
@@ -160,21 +175,35 @@ export class MessagesStore {
                 // Blocked turns (e.g. awaiting acceptance) also carry a compressed
                 // output.result — the transcript text wins there too when it says more.
                 const fullReply = (job.state === "done" || job.state === "blocked") && job.lastText && job.lastText.length > (output?.length ?? 0) ? job.lastText : undefined;
-                const result = fullReply
+                const rawResult = fullReply
                     ?? output
                     ?? (job.state === "failed" ? `⚠️ This turn failed: ${job.detail ?? "the session exited before producing a reply"}` : undefined)
-                    ?? (job.state === "blocked" ? job.lastText ?? job.needs ?? job.detail : undefined)
-                    // 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);
+                    ?? (job.state === "blocked" ? job.lastText ?? job.needs ?? job.detail : undefined);
+                // A looping agent ends a pass that found nothing with a marker line.
+                // It is bookkeeping, so it is split off here and never reaches the
+                // transcript — only the flag it sets, which folds the run away.
+                const quiet = rawResult ? stripNoopMarker(rawResult) : undefined;
+                const result = quiet?.text || rawResult;
+                // Mid-turn permission prompts: the job stays "working" but tempo flips
+                // to blocked with the ask in needs (e.g. "approve Bash: …"). This is a
+                // passing event, not the turn's reply — it gets its own appended line
+                // rather than sitting in `:assistant`, where the real reply would later
+                // overwrite it and the prompt would appear to vanish.
+                const prompt = 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" }));
+                // Keyed by content, not by position: the filter above can drop an entry
+                // on a later sync, and index-keyed ids would then shift every following
+                // bubble onto different text.
+                updates.forEach((text, index) => this.appendSynced({ id: `${jobId}:update:${contentKey(text)}`, missionId, role: "assistant", text, createdAt: turnStartedAt + 1 + index, jobId, kind: "update" }));
+                if (prompt) {
+                    this.appendSynced({ id: `${jobId}:prompt:${contentKey(prompt)}`, missionId, role: "assistant", text: prompt, createdAt: timestamp(job.updatedAt ?? job.createdAt), jobId, kind: "update" });
+                }
                 if (result) {
-                    this.upsertSynced({
+                    this.appendSynced({
                         id: `${jobId}:assistant`,
                         missionId,
                         role: "assistant",
@@ -183,6 +212,10 @@ export class MessagesStore {
                         jobId,
                     });
                 }
+                // After the reply is written, so the run folds as a whole rather than
+                // leaving the newest message behind.
+                if (quiet?.noop)
+                    this.markQuietRun(jobId);
             }
         });
         sync();
@@ -191,31 +224,62 @@ export class MessagesStore {
     onChange(listener) {
         this.listeners.add(listener);
     }
-    /** Upsert that follows mission relinking but never overwrites existing text. */
+    /**
+     * Insert that follows mission relinking but never rewrites text — and never
+     * rewrites `created_at` either, which is the sort key: moving it would slide
+     * an already-read bubble to a different place in the transcript.
+     */
     insertSynced(message) {
         this.db
             .prepare(`
-        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind)
+        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind, attachments, noop)
+        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind, @attachments, @noop)
         ON CONFLICT(id) DO UPDATE SET
           mission_id = excluded.mission_id,
-          created_at = excluded.created_at,
           job_id = excluded.job_id
       `)
-            .run({ ...message, kind: message.kind ?? null });
+            .run({ ...message, kind: message.kind ?? null, attachments: message.attachments?.length ? JSON.stringify(message.attachments) : null, noop: message.noop ? 1 : null });
+        return message.id;
     }
-    upsertSynced(message) {
+    /**
+     * The append-only write, and the reason a bubble the reader has already seen
+     * cannot be swapped for a different one.
+     *
+     * Syncs run repeatedly over the same live job, and its text moves as the turn
+     * progresses — a compressed `output.result` arrives before the transcript's
+     * fuller `lastText`. Only one kind of in-place edit stays truthful: pure
+     * growth, where what is on screen is a prefix of what is arriving, so the
+     * message extends rather than changes. Text that genuinely differs is a
+     * different thing to say and lands as its own appended message.
+     */
+    appendSynced(message) {
+        const existing = this.db
+            .prepare("SELECT text FROM mission_messages WHERE id = ?")
+            .get(message.id);
+        if (existing && existing.text !== message.text && !message.text.startsWith(existing.text)) {
+            return this.insertSynced({ ...message, id: `${message.id}:${contentKey(message.text)}` });
+        }
         this.db
             .prepare(`
-        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind)
+        INSERT INTO mission_messages (id, mission_id, role, text, created_at, job_id, kind, attachments, noop)
+        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId, @kind, @attachments, @noop)
         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, kind: message.kind ?? null });
+            .run({ ...message, kind: message.kind ?? null, attachments: message.attachments?.length ? JSON.stringify(message.attachments) : null, noop: message.noop ? 1 : null });
+        return message.id;
+    }
+    /**
+     * Flags every message of a turn as a quiet loop pass.
+     *
+     * Display metadata only — no text is rewritten and nothing moves, so the
+     * append-only guarantee holds. The prompt is flagged alongside the reply so
+     * a run folds as one unit rather than leaving its question stranded.
+     */
+    markQuietRun(jobId) {
+        this.db.prepare("UPDATE mission_messages SET noop = 1 WHERE job_id = ? AND noop IS NULL").run(jobId);
     }
     notify() {
         for (const listener of this.listeners)

package/packages/server/dist/reviews/reviewDiff.js

@@ -0,0 +1,47 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+const MAX_PATCH = 200_000;
+function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", timeout: 5_000, maxBuffer: 2_000_000, stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function gitDiff(cwd, args) {
+    try {
+        return git(cwd, ["diff", ...args]);
+    }
+    catch (error) {
+        const stdout = error.stdout;
+        if (stdout !== undefined)
+            return String(stdout).trim();
+        throw error;
+    }
+}
+/** Read-only source-control evidence for a mission-controlled repository. */
+export function reviewDiff(cwd) {
+    if (!cwd || !fs.existsSync(cwd))
+        return { available: false, stat: "", patch: "", files: [], truncated: false, error: "Repository is unavailable." };
+    try {
+        if (git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== "true")
+            throw new Error("Not a Git worktree");
+        let base;
+        for (const candidate of ["origin/main", "main", "origin/master", "master"]) {
+            try {
+                base = git(cwd, ["merge-base", "HEAD", candidate]);
+                if (base)
+                    break;
+            }
+            catch { /* try next baseline */ }
+        }
+        const range = base ? [`${base}..HEAD`] : [];
+        const committed = gitDiff(cwd, range);
+        const working = gitDiff(cwd, ["HEAD"]);
+        const untracked = git(cwd, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean);
+        const untrackedPatches = untracked.map((file) => gitDiff(cwd, ["--no-index", "--", "/dev/null", file]));
+        const patch = [committed, working, ...untrackedPatches].filter(Boolean).join("\n");
+        const stat = [git(cwd, ["diff", "--stat", ...range]), git(cwd, ["diff", "--stat", "HEAD"]), untracked.length ? `${untracked.length} untracked file${untracked.length === 1 ? "" : "s"}` : ""].filter(Boolean).join("\n");
+        const files = [...new Set([...git(cwd, ["diff", "--name-only", ...range]).split("\n"), ...git(cwd, ["diff", "--name-only", "HEAD"]).split("\n"), ...untracked].filter(Boolean))];
+        return { available: true, base, stat, patch: patch.slice(0, MAX_PATCH), files, truncated: patch.length > MAX_PATCH };
+    }
+    catch (error) {
+        return { available: false, stat: "", patch: "", files: [], truncated: false, error: error.message };
+    }
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Phrases that mark a reply as genuinely handing a choice back to the reader.
+ *
+ * Deliberately narrow. A turn ending "let me know if you need anything else"
+ * is politeness, not a decision, and surfacing those as "Needs you" would
+ * teach the reader to ignore the one signal that should never be ignored.
+ */
+const ASK_PATTERNS = [
+    /\bfor you to decide\b/i,
+    /\byour (call|decision|choice)\b/i,
+    /\bup to you\b/i,
+    /\bsay the word\b/i,
+    /\bwhich (one )?(would|do) you (prefer|want)\b/i,
+    /\b(do|would) you want me to\b/i,
+    /\bwould you like me to\b/i,
+    /\bshall I\b/i,
+    /\bshould I\b[^?]*\?/i,
+    /\bplease (confirm|advise|choose)\b/i,
+    /\blet me know (which|whether|if you want|if you'd)\b/i,
+    /\bneeds? your (input|decision|sign-?off|approval|steer)\b/i,
+    /\bwaiting (on|for) your (call|decision|answer|input)\b/i,
+];
+/** Sign-offs that look like asks but close a turn rather than pausing it. */
+const CLOSING_PATTERNS = [
+    /^\s*(anything else|any(thing)? more)\b/i,
+    /\blet me know if you (need|have|spot|want) (anything|any|something)\b/i,
+];
+const MAX_QUESTION_CHARS = 800;
+/** Strips leading markdown emphasis and list markers so the ask reads as prose. */
+function tidy(line) {
+    return line.replace(/^\s*[-*]\s+/, "").replace(/\*\*/g, "").trim();
+}
+/**
+ * Finds a decision the agent handed back in the prose of its reply.
+ *
+ * Hive's decision inbox is fed by structured signals — emitted decisions,
+ * parked permissions, provider prompts — none of which fire when an agent
+ * simply finishes its turn by asking a question. Those asks were reaching the
+ * transcript with no affordance at all: no "Needs you", nothing in the inbox,
+ * nothing to answer, and a mission that looked finished while it waited.
+ *
+ * Returns the ask from the first marker line onward, so an enumerated list of
+ * choices arrives with the question that introduced it.
+ */
+export function detectReplyAsk(reply) {
+    if (!reply?.trim())
+        return undefined;
+    const lines = reply.split("\n");
+    const at = lines.findIndex((line) => {
+        if (CLOSING_PATTERNS.some((pattern) => pattern.test(line)))
+            return false;
+        return ASK_PATTERNS.some((pattern) => pattern.test(line));
+    });
+    if (at === -1)
+        return undefined;
+    // From the marker to the end: an ask is routinely a header followed by the
+    // options it introduces, and the header alone would be unanswerable.
+    const question = lines.slice(at).map(tidy).filter(Boolean).join("\n").trim();
+    if (!question)
+        return undefined;
+    return { question: question.length > MAX_QUESTION_CHARS ? `${question.slice(0, MAX_QUESTION_CHARS).trimEnd()}…` : question };
+}

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

@@ -288,9 +288,12 @@ 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.
  */
-export const WORKER_IDENTITY_RESOLVER_VERSION = "4";
+export const WORKER_IDENTITY_RESOLVER_VERSION = "5";
 /** Persists resolved identities so they survive the bounded event ring. */
 export class WorkerIdentityStore {
     db;
@@ -400,6 +403,7 @@ 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);
     // 1. Hook lifecycle evidence, keyed by the provider's own agent id.
@@ -468,16 +472,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,
@@ -615,7 +630,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)
@@ -774,8 +798,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

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"),
     ];