@shanesaravia/hive 0.2.1 → 0.4.0

package/packages/server/dist/loops/loopScheduler.js

@@ -0,0 +1,58 @@
+import { withLoopInstructions } from "./loopNoop.js";
+export const LOOP_TICK_MS = 15_000;
+/**
+ * Fires due loops.
+ *
+ * A loop never overlaps itself: the run is marked before the send, so a slow
+ * turn delays the next firing rather than stacking a second one behind it.
+ * A mission that has gone away stops its loops instead of failing forever.
+ */
+export class LoopScheduler {
+    deps;
+    timer;
+    running = new Set();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    start(intervalMs = LOOP_TICK_MS) {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => { void this.tick(); }, intervalMs);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    async tick(now = Date.now()) {
+        for (const loop of this.deps.loops.due(now)) {
+            if (this.running.has(loop.id))
+                continue;
+            if (!this.deps.isRunnable(loop.missionId)) {
+                this.deps.loops.stop(loop.id, "the mission is no longer running");
+                continue;
+            }
+            // Deferred, not skipped: nextRunAt stays in the past, so the loop fires
+            // on the first tick after the mission goes quiet rather than losing its
+            // turn or interrupting one.
+            if (this.deps.isBusy(loop.missionId))
+                continue;
+            this.running.add(loop.id);
+            // Marked before the send: a turn that outlasts the interval must push the
+            // next firing out, never queue another on top of it.
+            this.deps.loops.markRun(loop.id, now);
+            try {
+                // The stored prompt stays exactly what was asked for; the folding
+                // instruction is added only on the way out.
+                await this.deps.send(loop.missionId, withLoopInstructions(loop.prompt));
+            }
+            catch (error) {
+                this.deps.onError?.(loop, error);
+            }
+            finally {
+                this.running.delete(loop.id);
+            }
+        }
+    }
+}

package/packages/server/dist/loops/loopStore.js

@@ -0,0 +1,118 @@
+import { randomUUID } from "node:crypto";
+import Database from "better-sqlite3";
+import { config } from "../config.js";
+function toLoop(row) {
+    return {
+        id: row.id,
+        missionId: row.mission_id,
+        prompt: row.prompt,
+        intervalMs: row.interval_ms,
+        status: row.status,
+        createdAt: row.created_at,
+        ...(row.last_run_at ? { lastRunAt: row.last_run_at } : {}),
+        nextRunAt: row.next_run_at,
+        runCount: row.run_count,
+        ...(row.stopped_reason ? { stoppedReason: row.stopped_reason } : {}),
+    };
+}
+/**
+ * Recurring prompts Hive re-sends to a mission.
+ *
+ * Persisted rather than held in memory: a loop that quietly dies when the
+ * server restarts is a loop the reader still believes is running, which is the
+ * failure this whole feature exists to prevent.
+ */
+export class LoopStore {
+    db;
+    listeners = new Set();
+    constructor(filePath = config.databasePath) {
+        this.db = new Database(filePath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mission_loops (
+        id TEXT PRIMARY KEY,
+        mission_id TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        interval_ms INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        last_run_at INTEGER,
+        next_run_at INTEGER NOT NULL,
+        run_count INTEGER NOT NULL DEFAULT 0,
+        stopped_reason TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_mission_loops_mission ON mission_loops (mission_id, status);
+      CREATE INDEX IF NOT EXISTS idx_mission_loops_due ON mission_loops (status, next_run_at);
+    `);
+    }
+    close() { this.db.close(); }
+    onChange(listener) { this.listeners.add(listener); }
+    notify() { for (const listener of this.listeners)
+        listener(); }
+    create(input) {
+        const now = input.now ?? Date.now();
+        const loop = {
+            id: randomUUID().slice(0, 8),
+            mission_id: input.missionId,
+            prompt: input.prompt,
+            interval_ms: input.intervalMs,
+            status: "active",
+            created_at: now,
+            last_run_at: null,
+            // The first run is one interval away, not immediate: the message that
+            // created the loop is itself the first pass.
+            next_run_at: now + input.intervalMs,
+            run_count: 0,
+            stopped_reason: null,
+        };
+        this.db.prepare(`
+      INSERT INTO mission_loops (id, mission_id, prompt, interval_ms, status, created_at, last_run_at, next_run_at, run_count, stopped_reason)
+      VALUES (@id, @mission_id, @prompt, @interval_ms, @status, @created_at, @last_run_at, @next_run_at, @run_count, @stopped_reason)
+    `).run(loop);
+        this.notify();
+        return toLoop(loop);
+    }
+    get(id) {
+        const row = this.db.prepare("SELECT * FROM mission_loops WHERE id = ?").get(id);
+        return row ? toLoop(row) : undefined;
+    }
+    /** Active loops, soonest first. Stopped ones are history, not state. */
+    active(missionId) {
+        const rows = missionId
+            ? this.db.prepare("SELECT * FROM mission_loops WHERE status = 'active' AND mission_id = ? ORDER BY next_run_at").all(missionId)
+            : this.db.prepare("SELECT * FROM mission_loops WHERE status = 'active' ORDER BY next_run_at").all();
+        return rows.map(toLoop);
+    }
+    due(now = Date.now()) {
+        return this.db.prepare("SELECT * FROM mission_loops WHERE status = 'active' AND next_run_at <= ? ORDER BY next_run_at").all(now).map(toLoop);
+    }
+    /** Records a firing and schedules the next one from now, not from the due time. */
+    markRun(id, now = Date.now()) {
+        this.db.prepare(`
+      UPDATE mission_loops
+      SET last_run_at = @now, next_run_at = @now + interval_ms, run_count = run_count + 1
+      WHERE id = @id AND status = 'active'
+    `).run({ id, now });
+        this.notify();
+    }
+    stop(id, reason) {
+        const result = this.db
+            .prepare("UPDATE mission_loops SET status = 'stopped', stopped_reason = ? WHERE id = ? AND status = 'active'")
+            .run(reason ?? null, id);
+        if (result.changes)
+            this.notify();
+        return result.changes > 0;
+    }
+    stopMission(missionId, reason) {
+        const result = this.db
+            .prepare("UPDATE mission_loops SET status = 'stopped', stopped_reason = ? WHERE mission_id = ? AND status = 'active'")
+            .run(reason ?? null, missionId);
+        if (result.changes)
+            this.notify();
+        return result.changes;
+    }
+    removeMission(missionId) {
+        this.db.prepare("DELETE FROM mission_loops WHERE mission_id = ?").run(missionId);
+        this.notify();
+    }
+}

package/packages/server/dist/loops/monitors.js

@@ -0,0 +1,38 @@
+/**
+ * Background watchers a mission's agent has open, each by name.
+ *
+ * They come from the job's fan rather than the `inFlight.kinds` tally, which
+ * only ever yields a count — and a count cannot tell you whether the watcher
+ * you are looking for is the one still running.
+ *
+ * Hive does not start these and the CLI has no per-watcher stop (`claude stop`
+ * takes a session), so the turn that owns them is what can actually be ended.
+ * Naming them is what makes that choice an informed one.
+ */
+export function activeMonitors(jobs, missionFor, missionName) {
+    const monitors = [];
+    for (const [jobId, job] of jobs) {
+        // A finished turn's watchers are finished with it. Real job records keep
+        // fan entries with no doneAt long after the turn ended, so trusting the
+        // entry alone would report watchers that stopped days ago.
+        if (job.state === "done" || job.state === "failed")
+            continue;
+        const missionId = missionFor(jobId);
+        if (!missionId)
+            continue;
+        for (const entry of job.fan ?? []) {
+            if (entry.kind !== "monitor" || entry.doneAt)
+                continue;
+            monitors.push({
+                missionId,
+                missionName: missionName(missionId),
+                jobId,
+                id: entry.id,
+                label: entry.label?.trim() || "unnamed watcher",
+                startedAt: entry.startedAt || Date.parse(job.createdAt ?? "") || 0,
+                ...(job.detail ? { detail: job.detail } : {}),
+            });
+        }
+    }
+    return monitors.sort((a, b) => a.startedAt - b.startedAt);
+}

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

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+/** What a pasted screenshot can actually be, and the extension it lands under. */
+const EXTENSIONS = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+};
+export const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+export function isSupportedMediaType(mediaType) {
+    return mediaType in EXTENSIONS;
+}
+/**
+ * Images pasted into a mission conversation, written to disk so the agent can
+ * open them.
+ *
+ * The model does not receive bytes — Hive hands the session an absolute path
+ * and the agent reads it with its own Read tool, which is the one route that
+ * works identically for every provider and needs no protocol of its own.
+ */
+export class AttachmentStore {
+    root;
+    constructor(root = path.join(config.hiveDataDir, "attachments")) {
+        this.root = root;
+    }
+    /** Ids are opaque and generated here, so a caller can never address a path. */
+    fileFor(missionId, id) {
+        const dir = path.join(this.root, encodeURIComponent(missionId));
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            return undefined;
+        }
+        const match = entries.find((entry) => path.basename(entry, path.extname(entry)) === id);
+        return match ? path.join(dir, match) : undefined;
+    }
+    save(missionId, input) {
+        const extension = EXTENSIONS[input.mediaType];
+        if (!extension)
+            throw new Error(`unsupported attachment type: ${input.mediaType}`);
+        if (input.data.byteLength > MAX_ATTACHMENT_BYTES)
+            throw new Error("attachment is larger than 10MB");
+        const id = randomUUID();
+        const dir = path.join(this.root, encodeURIComponent(missionId));
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, `${id}.${extension}`);
+        fs.writeFileSync(file, input.data);
+        return {
+            id,
+            name: input.name?.trim() || `pasted-image.${extension}`,
+            mediaType: input.mediaType,
+            bytes: input.data.byteLength,
+            path: file,
+            url: `/api/mission/${encodeURIComponent(missionId)}/attachment/${id}`,
+        };
+    }
+    read(missionId, id) {
+        const file = this.fileFor(missionId, id);
+        if (!file)
+            return undefined;
+        const extension = path.extname(file).slice(1);
+        const mediaType = Object.entries(EXTENSIONS).find(([, value]) => value === extension)?.[0];
+        return mediaType ? { file, mediaType } : undefined;
+    }
+    /** The stored descriptor, rebuilt from disk so a caller cannot assert one. */
+    describe(missionId, id, name) {
+        const found = this.read(missionId, id);
+        if (!found)
+            return undefined;
+        let bytes = 0;
+        try {
+            bytes = fs.statSync(found.file).size;
+        }
+        catch { /* reported as zero */ }
+        return {
+            id,
+            name: name?.trim() || path.basename(found.file),
+            mediaType: found.mediaType,
+            bytes,
+            path: found.file,
+            url: `/api/mission/${encodeURIComponent(missionId)}/attachment/${id}`,
+        };
+    }
+    removeMission(missionId) {
+        fs.rmSync(path.join(this.root, encodeURIComponent(missionId)), { recursive: true, force: true });
+    }
+}

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;
@@ -27,6 +36,9 @@ function toMessage(row) {
         text: row.text,
         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. */
@@ -44,13 +56,28 @@ 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,
+        attachments TEXT,
+        noop INTEGER
       );
       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 */ }
+        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();
@@ -65,26 +92,21 @@ export class MessagesStore {
             text: input.text,
             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)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId)
-        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 });
+        // 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
+        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)
@@ -123,7 +145,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);
@@ -140,7 +162,7 @@ export class MessagesStore {
                         id: `${jobId}:user`,
                         missionId,
                         role: "user",
-                        text: job.intent,
+                        text: stripLoopInstructions(job.intent),
                         createdAt: timestamp(job.createdAt),
                         jobId,
                     });
@@ -153,15 +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);
+                // 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",
@@ -170,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();
@@ -178,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)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId)
+        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);
+            .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)
-        VALUES (@id, @missionId, @role, @text, @createdAt, @jobId)
+        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);
+            .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/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";
+}