@shanesaravia/hive 0.1.0

package/packages/server/dist/health/deriveAlerts.js

@@ -0,0 +1,55 @@
+const LONG_RUNNING_MS = 15 * 60 * 1000;
+const HIGH_TOKEN_TURN = 20_000;
+const MIN_TOKEN_ALERT_RUNTIME_MS = 5 * 60 * 1000;
+export function deriveAlerts(input) {
+    if (["completed", "archived"].includes(input.lifecycle))
+        return [];
+    const alerts = [];
+    if (input.stale)
+        alerts.push({ id: "stale-job", severity: "critical", title: "Stale job state", explanation: "Claude reports this job as working, but Hive cannot find its live process.", evidence: "A working/busy job record exists without a matching session record.", recovery: "Restart or resume the mission; archive the stale record if the work is no longer needed." });
+    for (const worker of input.workers.filter((item) => !item.doneAt && (item.jobState === "working" || item.jobState === "busy"))) {
+        const workerEvents = input.events.filter((event) => matchesWorker(event.targetWorker, worker));
+        const lastUpdate = Math.max(worker.startedAt, worker.jobUpdatedAt ?? 0, ...workerEvents.map((event) => event.ts));
+        if (input.now - lastUpdate >= LONG_RUNNING_MS)
+            alerts.push({ id: `quiet-worker:${worker.id}`, severity: "warning", title: `${worker.label} has gone quiet`, explanation: "This worker is still marked active but has not produced a meaningful attributed update recently.", evidence: `No targeted worker activity for ${minutes(input.now - lastUpdate)} minutes.`, recovery: "Inspect the worker, send focused guidance, or ask the orchestrator to replace it.", workerId: worker.id });
+    }
+    if (input.lifecycle === "active" && !input.turnCompleted && input.workers.length > 0 && input.workers.every((worker) => Boolean(worker.doneAt)) && (input.activity === "idle" || input.activity === "stalled"))
+        alerts.push({ id: "idle-after-workers", severity: "warning", title: "Workers finished, orchestrator idle", explanation: "Every recorded worker has reported completion, but the mission remains active without current manager activity.", evidence: `${input.workers.length} of ${input.workers.length} workers are complete.`, recovery: "Ask for an immediate status summary, review the results, or mark the mission complete." });
+    const failedCommands = new Map();
+    for (const event of input.events)
+        if (event.command && event.outcome === "failure")
+            failedCommands.set(event.command, (failedCommands.get(event.command) ?? 0) + 1);
+    for (const [command, count] of failedCommands)
+        if (count >= 3)
+            alerts.push({ id: `retry-loop:${command}`, severity: "warning", title: "Possible command retry loop", explanation: "The same command has failed repeatedly without an observed successful run.", evidence: `${count} failed runs: ${command}`, recovery: "Inspect the first failure, change the approach, or ask the orchestrator to stop retrying and report the blocker." });
+    const writers = new Map();
+    for (const event of input.events)
+        if (event.activityKind === "file_write" && event.filePath && event.targetWorker) {
+            const set = writers.get(event.filePath) ?? new Set();
+            set.add(event.targetWorker);
+            writers.set(event.filePath, set);
+        }
+    for (const [file, workerIds] of writers)
+        if (workerIds.size > 1)
+            alerts.push({ id: `overlap:${file}`, severity: "warning", title: "Workers may be editing the same file", explanation: "Multiple workers reported writes to one path, which can create conflicting implementations or merges.", evidence: `${file} · ${[...workerIds].join(", ")}`, recovery: "Have the orchestrator assign ownership or sequence the dependent work before merging." });
+    const delegations = new Map();
+    for (const event of input.events)
+        if (event.phase === "delegating") {
+            const key = event.detail.trim().toLowerCase();
+            delegations.set(key, (delegations.get(key) ?? 0) + 1);
+        }
+    for (const [detail, count] of delegations)
+        if (count > 1)
+            alerts.push({ id: `duplicate:${detail}`, severity: "info", title: "Task may have been delegated twice", explanation: "The same delegation description appears multiple times in recent mission activity.", evidence: `${count} matching delegations: ${detail}`, recovery: "Confirm whether this is intentional retry work; otherwise cancel or reassign the duplicate." });
+    const turnEvents = input.runStartedAt ? input.events.filter((event) => event.ts >= input.runStartedAt) : input.events;
+    const measurableProgress = turnEvents.some((event) => event.activityKind === "file_write" || event.activityKind === "output" || (event.activityKind === "test" && event.outcome === "success") || event.phase === "worker_reported" || event.phase === "plan_updated" || event.phase === "ready_for_review");
+    if (input.lifecycle === "active" && (input.turnTokens ?? 0) >= HIGH_TOKEN_TURN && input.runStartedAt && input.now - input.runStartedAt >= MIN_TOKEN_ALERT_RUNTIME_MS && !measurableProgress)
+        alerts.push({ id: "tokens-without-progress", severity: "warning", title: "High token use without observed progress", explanation: "The current turn has consumed substantial context without producing measurable task, file, test, worker-report, or output evidence.", evidence: `${(input.turnTokens ?? 0).toLocaleString()} tokens this turn; no progress evidence recorded in ${minutes(input.now - input.runStartedAt)} minutes.`, recovery: "Request a status summary, narrow the task, or pause and redirect the orchestrator before more context is consumed." });
+    const unresolvedQuestion = [...input.events].reverse().find((event) => event.phase === "blocked_on_user" || event.phase === "decision_resolved");
+    if (input.activity === "waiting_on_you" && unresolvedQuestion?.phase !== "blocked_on_user")
+        alerts.push({ id: "unclear-wait", severity: "warning", title: "Waiting without a clear question", explanation: "The runtime says it needs user input, but Hive has no structured pending decision to display.", evidence: "Waiting state present; no unresolved blocked_on_user event found.", recovery: "Open the mission and ask the orchestrator to state one concrete question with choices and a recommendation." });
+    return alerts;
+}
+function matchesWorker(target, worker) { if (!target)
+    return false; const value = target.toLowerCase(); return value === worker.id.toLowerCase() || value === worker.label.toLowerCase() || worker.id.toLowerCase().startsWith(value) || worker.label.toLowerCase().includes(value); }
+function minutes(ms) { return Math.max(1, Math.floor(ms / 60_000)); }

package/packages/server/dist/hooks/hookIngest.js

@@ -0,0 +1,90 @@
+const SUMMARY_LIMIT = 140;
+const RAW_STRING_LIMIT = 2_000;
+const SECRET_KEY = /(token|secret|password|authorization|cookie|api[_-]?key)/i;
+function sanitizeRaw(value, depth = 0) {
+    if (depth > 5)
+        return "[depth limit]";
+    if (typeof value === "string")
+        return value.length > RAW_STRING_LIMIT ? `${value.slice(0, RAW_STRING_LIMIT)}…` : value;
+    if (Array.isArray(value))
+        return value.slice(0, 50).map((item) => sanitizeRaw(item, depth + 1));
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).slice(0, 100).map(([key, item]) => [key, SECRET_KEY.test(key) ? "[redacted]" : sanitizeRaw(item, depth + 1)]));
+    return value;
+}
+function record(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function stringField(input, ...keys) {
+    for (const key of keys)
+        if (typeof input[key] === "string")
+            return input[key];
+    return undefined;
+}
+function evidence(payload) {
+    const input = record(payload.tool_input);
+    const tool = payload.tool_name ?? "";
+    const command = stringField(input, "command");
+    const filePath = stringField(input, "file_path", "path", "notebook_path");
+    const targetWorker = stringField(payload, "agent_id", "subagent_id", "agent_name", "agent_type", "teammate_name");
+    if (["TaskCreated", "TaskCompleted", "TeammateIdle"].includes(payload.hook_event_name))
+        return { activityKind: "agent", targetWorker };
+    if (["PermissionRequest", "PermissionDenied", "Elicitation", "ElicitationResult", "Notification"].includes(payload.hook_event_name))
+        return { activityKind: "decision", targetWorker };
+    if (["InstructionsLoaded", "ConfigChange"].includes(payload.hook_event_name))
+        return { activityKind: "file_read", filePath: stringField(payload, "file_path", "path"), targetWorker };
+    if (["WorktreeCreate", "WorktreeRemove"].includes(payload.hook_event_name))
+        return { activityKind: "output", artifactPath: stringField(payload, "worktree_path", "path"), targetWorker };
+    if (payload.hook_event_name === "SubagentStart" || payload.hook_event_name === "SubagentStop")
+        return { activityKind: "agent", targetWorker };
+    if (tool === "Read" || tool === "Glob" || tool === "Grep")
+        return { activityKind: "file_read", filePath, targetWorker };
+    if (["Edit", "Write", "NotebookEdit"].includes(tool)) {
+        const artifactPath = filePath && /\.(png|jpe?g|webp|gif|svg|pdf|docx?|xlsx?|pptx?|zip)$/i.test(filePath) ? filePath : undefined;
+        return { activityKind: artifactPath ? "output" : "file_write", filePath, artifactPath, targetWorker };
+    }
+    if (tool === "Bash") {
+        const isTest = Boolean(command && /(^|\s)(test|pytest|vitest|jest|mocha|cargo test|go test|npm test|npm run test|typecheck|lint)(\s|$)/i.test(command));
+        return { activityKind: isTest ? "test" : "command", command: command?.slice(0, 500), targetWorker };
+    }
+    if (payload.hook_event_name === "StopFailure")
+        return { activityKind: "lifecycle", targetWorker };
+    return { activityKind: payload.tool_name ? "tool" : "lifecycle", targetWorker };
+}
+function outcome(payload) {
+    if (payload.hook_event_name === "PostToolUseFailure" || payload.hook_event_name === "StopFailure" || payload.hook_event_name === "PermissionDenied")
+        return "failure";
+    if (payload.hook_event_name !== "PostToolUse")
+        return undefined;
+    const response = record(payload.tool_response);
+    const exitCode = response.exit_code ?? response.exitCode;
+    if (response.is_error === true || response.success === false || typeof response.error === "string" || (typeof exitCode === "number" && exitCode !== 0))
+        return "failure";
+    return "success";
+}
+function summarize(payload) {
+    if (payload.tool_name) {
+        const input = typeof payload.tool_input === "object"
+            ? JSON.stringify(payload.tool_input)
+            : String(payload.tool_input ?? "");
+        return `${payload.tool_name} ${input}`.slice(0, SUMMARY_LIMIT);
+    }
+    const fields = record(payload);
+    const subject = stringField(fields, "task_subject", "message", "reason", "error", "prompt", "teammate_name", "file_path", "worktree_path", "cwd");
+    return subject ? `${payload.hook_event_name}: ${subject}`.slice(0, SUMMARY_LIMIT) : payload.hook_event_name;
+}
+export function toHiveEvent(payload, jobId) {
+    return {
+        ts: typeof payload._hive_spooled_at === "number" ? payload._hive_spooled_at : Date.now(),
+        sessionId: payload.session_id,
+        jobId,
+        source: "hook",
+        hookEventName: payload.hook_event_name,
+        toolName: payload.tool_name,
+        targetTask: stringField(record(payload), "task_id"),
+        detail: summarize(payload),
+        outcome: outcome(payload),
+        rawPayload: sanitizeRaw(payload),
+        ...evidence(payload),
+    };
+}

package/packages/server/dist/hooks/hookSpool.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import { config } from "../config.js";
+import { toHiveEvent } from "./hookIngest.js";
+export function drainHookSpool(events, spoolPath = config.hookSpoolPath) {
+    const processing = `${spoolPath}.processing`;
+    let count = 0;
+    for (const file of [processing, spoolPath]) {
+        if (!fs.existsSync(file))
+            continue;
+        let source = file;
+        if (file === spoolPath) {
+            try {
+                fs.renameSync(spoolPath, processing);
+                source = processing;
+            }
+            catch {
+                continue;
+            }
+        }
+        const lines = fs.readFileSync(source, "utf8").split("\n").filter(Boolean);
+        for (const line of lines)
+            try {
+                const payload = JSON.parse(line);
+                if (payload.session_id && payload.hook_event_name) {
+                    events.add(toHiveEvent(payload, undefined));
+                    count += 1;
+                }
+            }
+            catch { /* skip corrupt partial writes */ }
+        fs.rmSync(source, { force: true });
+    }
+    return count;
+}

package/packages/server/dist/hooks/setupHooks.js

@@ -0,0 +1,102 @@
+import fs from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+const HOOK_EVENTS = [
+    "Setup",
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "PermissionRequest",
+    "PermissionDenied",
+    "Stop",
+    "StopFailure",
+    "Notification",
+    "SubagentStart",
+    "SubagentStop",
+    "TaskCreated",
+    "TaskCompleted",
+    "TeammateIdle",
+    "PreCompact",
+    "PostCompact",
+    "SessionStart",
+    "SessionEnd",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "InstructionsLoaded",
+    "ConfigChange",
+    "CwdChanged",
+    // WorktreeCreate/WorktreeRemove are deliberately absent: they are delegation
+    // hooks, not notifications — registering one makes the CLI expect the hook
+    // itself to create/remove the worktree (and print its path), so a passive
+    // relay breaks every `claude --worktree` launch.
+    "Elicitation",
+    "ElicitationResult",
+];
+const MARKER = "hive-hook-relay";
+function hiveHookCommand(eventName) {
+    return `node '${config.hookRelayPath.replaceAll("'", "'\\''")}' '${eventName}' # ${MARKER}`;
+}
+const relaySource = `const fs=require("node:fs"),path=require("node:path");let body="";process.stdin.setEncoding("utf8");process.stdin.on("data",c=>body+=c);process.stdin.on("end",async()=>{let payload;try{payload=JSON.parse(body)}catch{return}const event=process.argv[2]||payload.hook_event_name||"unknown";try{const controller=new AbortController();const timer=setTimeout(()=>controller.abort(),900);const response=await fetch("http://127.0.0.1:"+(process.env.HIVE_PORT||"${config.port}")+"/hooks/"+encodeURIComponent(event),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(payload),signal:controller.signal});clearTimeout(timer);if(!response.ok)throw new Error("HTTP "+response.status)}catch{try{fs.mkdirSync(path.dirname(${JSON.stringify(config.hookSpoolPath)}),{recursive:true});payload._hive_spooled_at=Date.now();fs.appendFileSync(${JSON.stringify(config.hookSpoolPath)},JSON.stringify(payload)+"\\n")}catch{}}});`;
+/**
+ * Additively merges Hive's relay hook into ~/.claude/settings.json.
+ * Never removes or replaces existing hook entries (e.g. the sound-notification
+ * hooks). Backs up the original file before writing. Idempotent — re-running
+ * `hive setup` will not duplicate entries already tagged with MARKER.
+ */
+export function planHookSetup() {
+    const raw = fs.existsSync(config.settingsPath)
+        ? fs.readFileSync(config.settingsPath, "utf-8")
+        : "{}";
+    const settings = JSON.parse(raw);
+    settings.hooks ??= {};
+    let changed = false;
+    // Prune relay entries left behind on events Hive no longer hooks
+    // (e.g. WorktreeCreate/WorktreeRemove, where a relay breaks the CLI).
+    for (const eventName of Object.keys(settings.hooks)) {
+        if (HOOK_EVENTS.includes(eventName))
+            continue;
+        const entries = settings.hooks[eventName];
+        const kept = entries.filter((entry) => !entry.hooks.some((hook) => hook.command.includes(MARKER)));
+        if (kept.length === entries.length)
+            continue;
+        if (kept.length)
+            settings.hooks[eventName] = kept;
+        else
+            delete settings.hooks[eventName];
+        changed = true;
+    }
+    for (const eventName of HOOK_EVENTS) {
+        const entries = settings.hooks[eventName] ?? [];
+        const desired = hiveHookCommand(eventName);
+        const existing = entries.flatMap((entry) => entry.hooks).find((hook) => hook.command.includes(MARKER));
+        if (existing) {
+            if (existing.command !== desired) {
+                existing.command = desired;
+                changed = true;
+            }
+            continue;
+        }
+        entries.push({
+            hooks: [{ type: "command", command: hiveHookCommand(eventName) }],
+        });
+        settings.hooks[eventName] = entries;
+        changed = true;
+    }
+    return {
+        settings,
+        changed: changed || !fs.existsSync(config.hookRelayPath) || fs.readFileSync(config.hookRelayPath, "utf8") !== relaySource,
+        backupNeeded: fs.existsSync(config.settingsPath),
+    };
+}
+export function applyHookSetup() {
+    const { settings, changed, backupNeeded } = planHookSetup();
+    fs.mkdirSync(path.dirname(config.hookRelayPath), { recursive: true });
+    fs.writeFileSync(config.hookRelayPath, relaySource, { mode: 0o755 });
+    if (!changed)
+        return;
+    if (backupNeeded) {
+        fs.copyFileSync(config.settingsPath, `${config.settingsPath}.hive-backup`);
+    }
+    fs.writeFileSync(config.settingsPath, JSON.stringify(settings, null, 2) + "\n");
+}

package/packages/server/dist/index.js

@@ -0,0 +1,88 @@
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import websocket from "@fastify/websocket";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { config } from "./config.js";
+import { SessionsWatcher } from "./watch/sessionsWatcher.js";
+import { JobsWatcher } from "./watch/jobsWatcher.js";
+import { EventsStore } from "./events/eventsStore.js";
+import { MissionsStore } from "./missions/missionsStore.js";
+import { MessagesStore } from "./messages/messagesStore.js";
+import { PlansStore } from "./plans/plansStore.js";
+import { registerRest } from "./api/rest.js";
+import { registerWs } from "./api/ws.js";
+import { drainHookSpool } from "./hooks/hookSpool.js";
+import { PoliciesStore } from "./policies/policiesStore.js";
+import { CodexRuntime } from "./control/codexRuntime.js";
+import { allowedBrowserOrigins, browserOriginAllowed } from "./security/originPolicy.js";
+async function main() {
+    const app = Fastify({ logger: true });
+    const browserOrigins = allowedBrowserOrigins({
+        serverPort: config.port,
+        dashboardUrl: config.dashboardUrl,
+        additionalOrigins: process.env.HIVE_ALLOWED_ORIGINS,
+    });
+    await app.register(cors, {
+        origin: (origin, callback) => callback(null, browserOriginAllowed(origin, browserOrigins)),
+    });
+    await app.register(websocket);
+    app.addHook("onRequest", async (request, reply) => {
+        if (!browserOriginAllowed(request.headers.origin, browserOrigins)) {
+            return reply.code(403).send({ error: "Browser origin is not allowed" });
+        }
+    });
+    mkdirSync(config.hiveDataDir, { recursive: true });
+    const sessionsWatcher = new SessionsWatcher();
+    const jobsWatcher = new JobsWatcher();
+    const events = new EventsStore();
+    const missions = new MissionsStore();
+    const messages = new MessagesStore();
+    const plans = new PlansStore();
+    const policies = new PoliciesStore();
+    const codex = new CodexRuntime();
+    events.init();
+    policies.init();
+    codex.init();
+    const replayedHooks = drainHookSpool(events);
+    missions.init();
+    for (const [oldId, newId] of missions.migrations()) {
+        messages.migrateMission(oldId, newId);
+        plans.migrateMission(oldId, newId);
+    }
+    sessionsWatcher.start();
+    jobsWatcher.start();
+    missions.adoptLegacyOrchestrators(jobsWatcher.getAll());
+    messages.syncJobs(jobsWatcher.getAll(), missions);
+    jobsWatcher.onJobsChange((jobs) => messages.syncJobs(jobs, missions));
+    missions.onChange(() => messages.syncJobs(jobsWatcher.getAll(), missions));
+    registerRest(app, { sessionsWatcher, jobsWatcher, events, missions, messages, plans, policies, codex });
+    registerWs(app, { sessionsWatcher, jobsWatcher, events, missions, messages, plans });
+    app.get("/health", async () => ({ ok: true }));
+    const webRoot = process.env.HIVE_WEB_DIST
+        ? path.resolve(process.env.HIVE_WEB_DIST)
+        : fileURLToPath(new URL("../../web/dist/", import.meta.url));
+    const isCompiledRuntime = fileURLToPath(import.meta.url).includes(`${path.sep}dist${path.sep}`);
+    if (existsSync(path.join(webRoot, "index.html"))) {
+        await app.register(fastifyStatic, { root: webRoot });
+        app.setNotFoundHandler((request, reply) => {
+            if (request.method === "GET" && request.headers.accept?.includes("text/html")) {
+                return reply.sendFile("index.html");
+            }
+            return reply.code(404).send({ error: "Not found" });
+        });
+    }
+    else if (process.env.NODE_ENV === "production" || isCompiledRuntime) {
+        throw new Error(`Hive web build not found at ${webRoot}. Run the web build before starting production.`);
+    }
+    await app.listen({ port: config.port, host: "127.0.0.1" });
+    app.log.info(`hive server listening on http://127.0.0.1:${config.port}`);
+    if (replayedHooks)
+        app.log.info(`replayed ${replayedHooks} hook event(s) captured while Hive was offline`);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

@@ -0,0 +1,211 @@
+import { randomUUID } from "node:crypto";
+import Database from "better-sqlite3";
+import { config } from "../config.js";
+const DEFAULT_PAGE_SIZE = 30;
+const MAX_PAGE_SIZE = 100;
+export const MODEL_CONTEXT_MESSAGE_LIMIT = 12;
+export const CONTEXT_BUDGETS = { summaryTokens: 800, recentTokens: 2_000, retrievedTokens: 1_000 };
+const chars = (tokens) => tokens * 4;
+function outputText(job) {
+    if (typeof job.output === "string")
+        return job.output;
+    if (job.output && typeof job.output === "object" && "result" in job.output) {
+        const result = job.output.result;
+        if (typeof result === "string")
+            return result;
+    }
+    return undefined;
+}
+function timestamp(value) {
+    const parsed = value ? Date.parse(value) : NaN;
+    return Number.isNaN(parsed) ? Date.now() : parsed;
+}
+function toMessage(row) {
+    return {
+        id: row.id,
+        role: row.role,
+        text: row.text,
+        createdAt: row.created_at,
+        jobId: row.job_id ?? "",
+    };
+}
+/** Indexed, paginated transcript storage. History is never prompt context by default. */
+export class MessagesStore {
+    db;
+    listeners = new Set();
+    constructor(filePath = config.databasePath) {
+        this.db = new Database(filePath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS mission_messages (
+        id TEXT PRIMARY KEY,
+        mission_id TEXT NOT NULL,
+        role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+        text TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        job_id TEXT
+      );
+      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);
+    `);
+    }
+    close() {
+        this.db.close();
+    }
+    removeMission(missionId) { this.db.prepare("DELETE FROM mission_messages WHERE mission_id = ?").run(missionId); for (const listener of this.listeners)
+        listener(); }
+    migrateMission(oldId, newId) { this.db.prepare("UPDATE mission_messages SET mission_id = ? WHERE mission_id = ?").run(newId, oldId); }
+    add(input) {
+        const message = {
+            id: input.id ?? randomUUID(),
+            role: input.role,
+            text: input.text,
+            createdAt: input.createdAt,
+            jobId: input.jobId,
+        };
+        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 });
+        this.notify();
+        return message;
+    }
+    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
+        FROM mission_messages
+        WHERE mission_id = @missionId
+          AND (@before IS NULL OR created_at < @before)
+        ORDER BY created_at DESC, id DESC
+        LIMIT @fetchLimit
+      `)
+            .all({
+            missionId,
+            before: options.before ?? null,
+            fetchLimit: limit + 1,
+        });
+        const hasMore = rows.length > limit;
+        const pageRows = rows.slice(0, limit).reverse();
+        return {
+            messages: pageRows.map(toMessage),
+            hasMore,
+            nextBefore: hasMore ? pageRows[0]?.created_at : undefined,
+        };
+    }
+    recent(missionId, limit = DEFAULT_PAGE_SIZE) {
+        return this.page(missionId, { limit }).messages;
+    }
+    count(missionId) {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS count FROM mission_messages WHERE mission_id = ?")
+            .get(missionId);
+        return row.count;
+    }
+    /** Fixed-size window for a future manager handoff; never returns full history. */
+    modelContext(missionId) {
+        let remaining = chars(CONTEXT_BUDGETS.recentTokens);
+        return this.recent(missionId, MODEL_CONTEXT_MESSAGE_LIMIT).reverse().flatMap((message) => { if (remaining <= 0)
+            return []; const text = message.text.slice(0, remaining); remaining -= text.length; return [{ ...message, text }]; }).reverse();
+    }
+    relevantContext(missionId, query, excludedIds = new Set()) {
+        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);
+        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);
+    }
+    syncJobs(jobs, missions) {
+        const sync = this.db.transaction(() => {
+            for (const [jobId, job] of jobs) {
+                const missionId = missions.missionFor(jobId);
+                if (job.intent) {
+                    // Insert-only: the route already stored the user's own words; the
+                    // job's intent includes appended policy/template prompts that
+                    // should never surface in their chat bubble.
+                    this.insertSynced({
+                        id: `${jobId}:user`,
+                        missionId,
+                        role: "user",
+                        text: job.intent,
+                        createdAt: timestamp(job.createdAt),
+                        jobId,
+                    });
+                }
+                // The daemon compresses replies: done turns get a one-line summary in
+                // output.result, blocked turns park a terse question in needs/detail,
+                // and failed turns produce nothing. lastText carries the model's real
+                // final message from the transcript — prefer it when it says more.
+                const output = outputText(job);
+                // 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
+                    ?? 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);
+                if (result) {
+                    this.upsertSynced({
+                        id: `${jobId}:assistant`,
+                        missionId,
+                        role: "assistant",
+                        text: result,
+                        createdAt: timestamp(job.updatedAt ?? job.createdAt),
+                        jobId,
+                    });
+                }
+            }
+        });
+        sync();
+        this.notify();
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+    }
+    /** Upsert that follows mission relinking but never overwrites existing text. */
+    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)
+        ON CONFLICT(id) DO UPDATE SET
+          mission_id = excluded.mission_id,
+          created_at = excluded.created_at,
+          job_id = excluded.job_id
+      `)
+            .run(message);
+    }
+    upsertSynced(message) {
+        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);
+    }
+    notify() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}