@shanesaravia/hive 0.3.0 → 0.5.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,44 @@ 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)
+        // The job watcher can observe a newly launched turn before its request
+        // route returns. In that window syncJobs inserts the provider's enriched
+        // intent (policy, repository grants, etc.) under `<jobId>:user`. The route
+        // write is authoritative for what the person actually typed, so replace
+        // that internal prompt instead of appending a second user bubble.
+        const canonicalUserId = input.id === `${input.jobId}:user` && input.role === "user";
+        const id = canonicalUserId
+            ? this.replaceCanonicalUserMessage({ ...message, missionId: input.missionId, jobId: input.jobId || "" })
+            : this.appendSynced({ ...message, missionId: input.missionId, jobId: input.jobId || "" });
+        this.notify();
+        return { ...message, id };
+    }
+    replaceCanonicalUserMessage(message) {
+        this.db.transaction(() => {
+            // Older builds could already have appended the authoritative text under
+            // a content-suffixed id. Collapse any such race artifacts for this turn.
+            this.db.prepare("DELETE FROM mission_messages WHERE id LIKE ? AND id <> ?").run(`${message.id}:%`, message.id);
+            this.db.prepare(`
+        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,
+          role = excluded.role,
           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 });
-        this.notify();
-        return message;
+          job_id = excluded.job_id,
+          kind = excluded.kind,
+          attachments = excluded.attachments
+      `).run({ ...message, kind: message.kind ?? null, attachments: message.attachments?.length ? JSON.stringify(message.attachments) : null, noop: message.noop ? 1 : null });
+        })();
+        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 +186,7 @@ export class MessagesStore {
                         id: `${jobId}:user`,
                         missionId,
                         role: "user",
-                        text: job.intent,
+                        text: stripLoopInstructions(job.intent),
                         createdAt: timestamp(job.createdAt),
                         jobId,
                     });
@@ -160,21 +199,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 +236,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 +248,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/missions/missionsStore.js

@@ -74,7 +74,7 @@ export class MissionsStore {
         return groups.length;
     }
     create(input) {
-        const id = randomUUID();
+        const id = input.id ?? randomUUID();
         const now = Date.now();
         const mission = {
             id,

package/packages/server/dist/missions/reopenOnWork.js

@@ -18,3 +18,10 @@ export function isWorkEvent(event) {
 export function reopensOnWork(status) {
     return status === "ready_for_review";
 }
+/** A completed follow-up returns work to the review state it came from. */
+export function returnsToReviewOnStop(mission, hasPendingDecision) {
+    return mission.lifecycleStatus === "active"
+        && mission.mode === "orchestrated"
+        && mission.currentState === "Working again after a follow-up"
+        && !hasPendingDecision;
+}

package/packages/server/dist/paths/pathResolver.js

@@ -67,6 +67,101 @@ export function suggestDirectories(input) {
 function stripWorktree(value) {
     return value.split(`${path.sep}.claude${path.sep}worktrees${path.sep}`)[0];
 }
+/** Directory entries at `base` matching `prefix`, formatted by the caller and capped for a completion list. */
+function listMatchingEntries(base, prefix, format) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(base, { withFileTypes: true })
+            .filter((entry) => !entry.name.startsWith(".") && entry.name.toLowerCase().startsWith(prefix))
+            .map((entry) => ({ path: format(entry.name, path.join(base, entry.name)), isDirectory: entry.isDirectory() }));
+    }
+    catch { /* an incomplete path simply has no suggestions yet */ }
+    return entries.sort((a, b) => Number(b.isDirectory) - Number(a.isDirectory) || a.path.localeCompare(b.path)).slice(0, 20);
+}
+/** "src/App.t" style — resolved under the mission's own cwd, and never escapes it. */
+function suggestRelativePathEntries(cwd, trimmed) {
+    const slash = trimmed.lastIndexOf("/");
+    const dirPart = slash === -1 ? "" : trimmed.slice(0, slash);
+    const prefix = (slash === -1 ? trimmed : trimmed.slice(slash + 1)).toLowerCase();
+    const root = path.resolve(cwd);
+    const base = path.resolve(root, dirPart);
+    if (base !== root && !base.startsWith(`${root}${path.sep}`))
+        return [];
+    return listMatchingEntries(base, prefix, (name) => (dirPart ? `${dirPart}/${name}` : name));
+}
+/** "~/Development/other-repo/" or "/abs/path" style — browses anywhere on disk, spelled back the way it was typed. */
+function suggestRootedPathEntries(trimmed) {
+    const expanded = resolveWorkingDirectory(trimmed);
+    const listChildren = trimmed.endsWith("/") || trimmed === "~";
+    const base = listChildren ? expanded : path.dirname(expanded);
+    const prefix = listChildren ? "" : path.basename(expanded).toLowerCase();
+    const home = os.homedir();
+    return listMatchingEntries(base, prefix, (_name, full) => (trimmed.startsWith("~") && (full === home || full.startsWith(`${home}${path.sep}`))
+        ? `~/${path.relative(home, full)}`
+        : full).split(path.sep).join("/"));
+}
+/**
+ * Files and directories matching `query` — the data behind live "@path"
+ * completion in a composer. A plain query ("packages/web/s") is resolved
+ * under the mission's own `cwd` and cannot escape it; a query that already
+ * names a home- or filesystem-rooted path ("~/Development/other-repo/",
+ * "/abs/path") browses from there instead, so `@` can also reach a sibling
+ * repository directly rather than only what `#` already covers by name.
+ */
+export function suggestPathEntries(cwd, query) {
+    const trimmed = query.replace(/^\.\//, "");
+    return trimmed.startsWith("~") || trimmed.startsWith("/")
+        ? suggestRootedPathEntries(trimmed)
+        : suggestRelativePathEntries(cwd, trimmed);
+}
+/** Every git repository under `roots`, unranked — a name search must see all of them, not just the recently touched ones. */
+function discoverRepositories(roots) {
+    const candidates = new Set();
+    for (const root of roots) {
+        try {
+            const topLevel = git(root, "rev-parse", "--show-toplevel");
+            if (topLevel)
+                candidates.add(topLevel);
+            for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name.startsWith("."))
+                    continue;
+                const candidate = path.join(root, entry.name);
+                if (fs.existsSync(path.join(candidate, ".git")))
+                    candidates.add(candidate);
+            }
+        }
+        catch { /* unavailable discovery root */ }
+    }
+    return [...candidates];
+}
+/** Every repository name Hive can resolve, mapped to its absolute path — siblings first, then recently used ones. */
+function repositoryRegistry(baseRepository) {
+    const registry = new Map();
+    for (const repo of knownRepositories(baseRepository))
+        registry.set(repo.name, repo.path);
+    for (const resolvedPath of discoverRepositories([defaultWorkingDirectory(), path.join(os.homedir(), "Development")])) {
+        const name = path.basename(resolvedPath).toLowerCase();
+        if (!registry.has(name))
+            registry.set(name, resolvedPath);
+    }
+    return registry;
+}
+/**
+ * Repository names starting with `query`, for live "#repo" completion. The
+ * mission's own repository is included rather than hidden — a message can
+ * legitimately name it too (e.g. describing work that spans several repos)
+ * — but flagged as `isCurrent` so the composer can mark it and a reader
+ * isn't left assuming a mention always points somewhere else.
+ */
+export function suggestRepositories(cwd, query) {
+    const lower = query.trim().toLowerCase();
+    const own = cwd ? path.basename(stripWorktree(cwd)).toLowerCase() : undefined;
+    return [...repositoryRegistry(cwd)]
+        .filter(([name]) => name.startsWith(lower))
+        .sort(([a], [b]) => a.localeCompare(b))
+        .slice(0, 10)
+        .map(([name, repoPath]) => ({ name, path: repoPath, isCurrent: name === own }));
+}
 /** Git repositories that sit beside the mission's repo (and the Hive default). */
 export function knownRepositories(baseRepository) {
     const roots = new Set();
@@ -92,13 +187,24 @@ export function knownRepositories(baseRepository) {
  * Repositories a message refers to by name ("add this to monorepo"), so a
  * mission can be granted cross-repo access without any explicit form field.
  * The mission's own repository never counts as a mention.
+ *
+ * An explicit "#name" mention (the composer's own autocomplete syntax) is
+ * resolved against the full repository registry — siblings and recently
+ * used repositories both — while the implicit bare-word heuristic stays
+ * scoped to siblings only, exactly as it always has, so existing behavior
+ * is unaffected by adding the explicit form alongside it.
  */
 export function detectRepositoryMentions(text, ownRepository) {
     const own = ownRepository ? path.basename(stripWorktree(ownRepository)).toLowerCase() : undefined;
     const lower = text.toLowerCase();
-    return knownRepositories(ownRepository)
+    const implicit = knownRepositories(ownRepository)
         .filter(({ name }) => name !== own && new RegExp(`(?<![\\w-])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`).test(lower))
         .map((repo) => repo.path);
+    const explicitNames = new Set([...text.matchAll(/#([\w.-]+)/g)].map((match) => match[1].toLowerCase()));
+    const explicit = explicitNames.size
+        ? [...repositoryRegistry(ownRepository)].filter(([name]) => name !== own && explicitNames.has(name)).map(([, repoPath]) => repoPath)
+        : [];
+    return [...new Set([...implicit, ...explicit])];
 }
 /**
  * The known repository containing filePath, excluding the mission's own repo
@@ -144,24 +250,13 @@ export function inspectWorkingDirectory(input) {
 }
 export function recentRepositories(limit = 8) {
     const roots = [defaultWorkingDirectory(), path.join(os.homedir(), "Development")];
-    const candidates = new Set();
-    for (const root of roots) {
-        try {
-            if (git(root, "rev-parse", "--show-toplevel"))
-                candidates.add(git(root, "rev-parse", "--show-toplevel"));
-            for (const entry of fs.readdirSync(root, { withFileTypes: true }))
-                if (entry.isDirectory() && !entry.name.startsWith(".")) {
-                    const candidate = path.join(root, entry.name);
-                    if (fs.existsSync(path.join(candidate, ".git")))
-                        candidates.add(candidate);
-                }
-        }
-        catch { /* unavailable discovery root */ }
-    }
-    return [...candidates].sort((a, b) => { try {
+    return discoverRepositories(roots)
+        .sort((a, b) => { try {
         return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
     }
     catch {
         return 0;
-    } }).slice(0, limit).map((resolvedPath) => ({ path: displayPath(resolvedPath), resolvedPath }));
+    } })
+        .slice(0, limit)
+        .map((resolvedPath) => ({ path: displayPath(resolvedPath), resolvedPath }));
 }

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

@@ -72,6 +72,33 @@ function normalizeGates(gates) {
         return { ...gate, id, label: gate.label.trim(), required: gate.required !== false, evidence: gate.evidence ?? [], waiver: gate.waiver ? { ...gate.waiver, reason: gate.waiver.reason.trim() } : undefined };
     });
 }
+function gateKey(gate) {
+    return `${gate.type}:${gate.label.trim().toLocaleLowerCase().replace(/\s+/g, " ")}`;
+}
+/**
+ * User-created gates are durable requirements, but the orchestrator is the
+ * actor that supplies evidence and reports when the requirement is satisfied.
+ * Reconcile an equivalent reported gate onto the protected user gate instead
+ * of retaining both IDs. The orchestrator may satisfy or fail the requirement,
+ * but only the user may waive it or weaken its definition.
+ */
+function reconcileUserGates(gates) {
+    const userGates = gates.filter((gate) => gate.source === "user");
+    if (!userGates.length)
+        return gates;
+    const reported = gates.filter((gate) => gate.source !== "user");
+    const matches = (userGate) => reported.filter((gate) => gate.id === userGate.id || gateKey(gate) === gateKey(userGate));
+    const matchedIds = new Set(userGates.flatMap((gate) => matches(gate).map((item) => item.id)));
+    const reconciled = userGates.map((gate) => {
+        const equivalents = matches(gate);
+        const satisfied = equivalents.find((item) => item.status === "satisfied");
+        const failed = equivalents.find((item) => item.status === "failed");
+        const status = gate.status === "satisfied" || gate.status === "waived" ? gate.status : satisfied ? "satisfied" : failed ? "failed" : gate.status;
+        const evidence = [...new Set([...(gate.evidence ?? []), ...equivalents.flatMap((item) => item.evidence ?? [])])];
+        return { ...gate, status, evidence };
+    });
+    return [...reported.filter((gate) => !matchedIds.has(gate.id)), ...reconciled];
+}
 /** Durable current plan plus immutable JSON snapshots for revision history. */
 export class PlansStore {
     db;
@@ -91,7 +118,7 @@ export class PlansStore {
         const incoming = input.gates === undefined ? current?.gates ?? [] : normalizeGates(input.gates);
         const protectedUserGates = preserveUserGates ? (current?.gates ?? []).filter((gate) => gate.source === "user") : [];
         const protectedIds = new Set(protectedUserGates.map((gate) => gate.id));
-        const gates = [...incoming.filter((gate) => !protectedIds.has(gate.id)), ...protectedUserGates];
+        const gates = reconcileUserGates([...incoming.filter((gate) => !protectedIds.has(gate.id)), ...protectedUserGates]);
         const plan = { missionId, revision: (current?.revision ?? 0) + 1, updatedAt: Date.now(), phases, gates, layout: input.tasks ? "flat" : "phased", approvalStatus: input.approvalStatus ?? "proposed", approvalReason: input.approvalReason?.trim() || undefined, progress: calculateProgress(phases) };
         const json = JSON.stringify(plan);
         this.db.transaction(() => {
@@ -209,7 +236,10 @@ export class PlansStore {
         this.db.prepare("INSERT OR REPLACE INTO mission_plan_revisions (mission_id, revision, updated_at, plan_json) VALUES (?, ?, ?, ?)").run(newId, revision.revision, revision.updatedAt, JSON.stringify({ ...revision, missionId: newId })); this.db.prepare("DELETE FROM mission_plans WHERE mission_id = ?").run(oldId); this.db.prepare("DELETE FROM mission_plan_revisions WHERE mission_id = ?").run(oldId); })(); }
     get(missionId) {
         const row = this.db.prepare("SELECT plan_json FROM mission_plans WHERE mission_id = ?").get(missionId);
-        return row ? JSON.parse(row.plan_json) : undefined;
+        if (!row)
+            return undefined;
+        const plan = JSON.parse(row.plan_json);
+        return { ...plan, gates: reconcileUserGates(plan.gates ?? []) };
     }
     revisions(missionId) {
         return this.db.prepare("SELECT plan_json FROM mission_plan_revisions WHERE mission_id = ? ORDER BY revision DESC").all(missionId).map((row) => JSON.parse(row.plan_json));

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 };
+}