@shanesaravia/hive 0.1.0

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

@@ -0,0 +1,283 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { config } from "../config.js";
+const emptyData = () => ({
+    version: 1,
+    missions: {},
+    jobMissions: {},
+    latestSessions: {},
+    sessionNames: {},
+    deletedJobIds: [],
+});
+/** Durable Hive mission identity and metadata, independent of Claude jobs. */
+export class MissionsStore {
+    filePath;
+    legacyThreadsPath;
+    data = emptyData();
+    listeners = new Set();
+    idMigrations = new Map();
+    constructor(filePath = config.missionsPath, legacyThreadsPath = config.threadsPath) {
+        this.filePath = filePath;
+        this.legacyThreadsPath = legacyThreadsPath;
+    }
+    init() {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+            this.data = {
+                version: 1,
+                missions: parsed.missions ?? {},
+                jobMissions: parsed.jobMissions ?? {},
+                latestSessions: parsed.latestSessions ?? {},
+                sessionNames: parsed.sessionNames ?? {},
+                deletedJobIds: parsed.deletedJobIds ?? [],
+            };
+            this.migrateLegacyIds();
+            if (this.idMigrations.size)
+                this.persist();
+            return;
+        }
+        catch {
+            this.migrateLegacyThreads();
+            this.migrateLegacyIds();
+            this.persist();
+        }
+    }
+    migrations() { return this.idMigrations; }
+    adoptLegacyOrchestrators(jobs) {
+        const pending = [...jobs].filter(([jobId, job]) => job.template === "hive-orchestrator" && !this.get(this.missionFor(jobId)));
+        const groups = [];
+        for (const entry of pending) {
+            const ids = new Set([entry[1].sessionId, entry[1].resumeSessionId].filter(Boolean));
+            const matches = groups.filter((group) => group.some(([, job]) => ids.has(job.sessionId) || ids.has(job.resumeSessionId)));
+            if (!matches.length)
+                groups.push([entry]);
+            else {
+                matches[0].push(entry);
+                for (const extra of matches.slice(1)) {
+                    matches[0].push(...extra);
+                    groups.splice(groups.indexOf(extra), 1);
+                }
+            }
+        }
+        for (const group of groups) {
+            group.sort((a, b) => Date.parse(a[1].createdAt ?? "") - Date.parse(b[1].createdAt ?? ""));
+            const [firstId, first] = group[0];
+            const latest = group.at(-1);
+            const mission = this.create({ name: latest[1].name ?? first.name, objective: first.intent ?? first.detail ?? "Recovered orchestrated mission", repository: first.originCwd ?? first.cwd, jobId: firstId, sessionId: latest[1].sessionId ?? latest[1].resumeSessionId, mode: "orchestrated" });
+            for (const [jobId, job] of group.slice(1))
+                this.linkJob(mission.id, jobId, job.sessionId ?? job.resumeSessionId);
+        }
+        return groups.length;
+    }
+    create(input) {
+        const id = randomUUID();
+        const now = Date.now();
+        const mission = {
+            id,
+            name: input.name?.trim() || undefined,
+            objective: input.objective.trim(),
+            acceptanceCriteria: input.acceptanceCriteria ?? [],
+            repository: input.repository,
+            compactSummary: input.compactSummary,
+            currentState: input.currentState,
+            lifecycleStatus: "active",
+            mode: input.mode ?? "orchestrated",
+            budgets: input.budgets,
+            template: input.template,
+            policy: input.policy,
+            provider: input.provider ?? "claude",
+            model: input.model?.trim() || undefined,
+            additionalRepositories: input.additionalRepositories?.length ? [...new Set(input.additionalRepositories)] : undefined,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.data.missions[id] = mission;
+        this.data.jobMissions[input.jobId] = id;
+        if (input.sessionId)
+            this.data.latestSessions[id] = input.sessionId;
+        this.changed();
+        return mission;
+    }
+    missionFor(jobId) {
+        return this.data.jobMissions[jobId] ?? jobId;
+    }
+    /** Records extra repositories the mission touches; grants ride every later turn. */
+    addRepositories(missionId, repositories) {
+        const mission = this.data.missions[missionId];
+        if (!mission || !repositories.length)
+            return;
+        const merged = [...new Set([...(mission.additionalRepositories ?? []), ...repositories])];
+        if (merged.length === (mission.additionalRepositories?.length ?? 0))
+            return;
+        mission.additionalRepositories = merged;
+        mission.updatedAt = Date.now();
+        this.changed();
+    }
+    isDeletedJob(jobId) { return this.data.deletedJobIds.includes(jobId); }
+    remove(missionId) {
+        if (!this.data.missions[missionId])
+            return false;
+        for (const [jobId, linkedMission] of Object.entries(this.data.jobMissions))
+            if (linkedMission === missionId) {
+                if (!this.data.deletedJobIds.includes(jobId))
+                    this.data.deletedJobIds.push(jobId);
+                delete this.data.jobMissions[jobId];
+            }
+        delete this.data.latestSessions[missionId];
+        delete this.data.missions[missionId];
+        this.changed();
+        return true;
+    }
+    get(missionId) {
+        return this.data.missions[missionId];
+    }
+    summaryFor(missionId, fallbackObjective = "") {
+        const mission = this.get(missionId);
+        return {
+            id: missionId,
+            objective: mission?.objective || fallbackObjective,
+            acceptanceCriteria: mission?.acceptanceCriteria ?? [],
+            repository: mission?.repository,
+            compactSummary: mission?.compactSummary,
+            currentState: mission?.currentState,
+            lifecycleStatus: mission?.lifecycleStatus ?? "active",
+            mode: mission?.mode ?? "orchestrated",
+            budgets: mission?.budgets,
+            template: mission?.template,
+            ...(mission?.policy ? { policy: mission.policy } : {}),
+            provider: mission?.provider ?? "claude",
+            ...(mission?.model ? { model: mission.model } : {}),
+            ...(mission?.additionalRepositories?.length ? { additionalRepositories: mission.additionalRepositories } : {}),
+        };
+    }
+    nameFor(missionId) {
+        if (missionId.startsWith("session:")) {
+            return this.data.sessionNames[missionId.slice("session:".length)];
+        }
+        return this.get(missionId)?.name;
+    }
+    rename(missionId, name) {
+        const trimmed = name.trim();
+        if (missionId.startsWith("session:")) {
+            const sessionId = missionId.slice("session:".length);
+            if (trimmed)
+                this.data.sessionNames[sessionId] = trimmed;
+            else
+                delete this.data.sessionNames[sessionId];
+        }
+        else {
+            const mission = this.ensureLegacyMission(missionId);
+            mission.name = trimmed || undefined;
+            mission.updatedAt = Date.now();
+        }
+        this.changed();
+    }
+    latestSessionFor(missionId) {
+        return this.data.latestSessions[missionId];
+    }
+    updateContext(missionId, context) {
+        const mission = this.ensureLegacyMission(missionId);
+        if (context.compactSummary !== undefined) {
+            mission.compactSummary = context.compactSummary.trim() || undefined;
+        }
+        if (context.currentState !== undefined) {
+            mission.currentState = context.currentState.trim() || undefined;
+        }
+        mission.updatedAt = Date.now();
+        this.changed();
+    }
+    setLifecycleStatus(missionId, status) {
+        const mission = this.ensureLegacyMission(missionId);
+        mission.lifecycleStatus = status;
+        mission.updatedAt = Date.now();
+        this.changed();
+    }
+    setPolicy(missionId, policy) {
+        const mission = this.ensureLegacyMission(missionId);
+        mission.policy = policy;
+        mission.updatedAt = Date.now();
+        this.changed();
+    }
+    linkJob(missionId, jobId, sessionId) {
+        this.ensureLegacyMission(missionId);
+        this.data.jobMissions[jobId] = missionId;
+        if (sessionId)
+            this.data.latestSessions[missionId] = sessionId;
+        const mission = this.data.missions[missionId];
+        if (mission)
+            mission.updatedAt = Date.now();
+        this.changed();
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+    }
+    migrateLegacyThreads() {
+        let legacy = {};
+        try {
+            legacy = JSON.parse(fs.readFileSync(this.legacyThreadsPath, "utf8"));
+        }
+        catch {
+            return;
+        }
+        this.data.jobMissions = { ...(legacy.jobThreads ?? {}) };
+        this.data.latestSessions = { ...(legacy.latestSessions ?? {}) };
+        for (const [id, name] of Object.entries(legacy.names ?? {})) {
+            if (id.startsWith("session:")) {
+                this.data.sessionNames[id.slice("session:".length)] = name;
+            }
+            else {
+                const mission = this.ensureLegacyMission(id);
+                mission.name = name;
+            }
+        }
+        for (const missionId of new Set(Object.values(this.data.jobMissions))) {
+            this.ensureLegacyMission(missionId);
+        }
+    }
+    migrateLegacyIds() {
+        const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        for (const [oldId, mission] of Object.entries({ ...this.data.missions })) {
+            if (uuid.test(oldId))
+                continue;
+            const nextId = randomUUID();
+            this.idMigrations.set(oldId, nextId);
+            this.data.missions[nextId] = { ...mission, id: nextId };
+            delete this.data.missions[oldId];
+            for (const [jobId, missionId] of Object.entries(this.data.jobMissions))
+                if (missionId === oldId)
+                    this.data.jobMissions[jobId] = nextId;
+            this.data.jobMissions[oldId] ??= nextId;
+            if (this.data.latestSessions[oldId]) {
+                this.data.latestSessions[nextId] = this.data.latestSessions[oldId];
+                delete this.data.latestSessions[oldId];
+            }
+        }
+    }
+    ensureLegacyMission(id) {
+        const existing = this.data.missions[id];
+        if (existing)
+            return existing;
+        const mission = {
+            id,
+            objective: "",
+            acceptanceCriteria: [],
+            lifecycleStatus: "active",
+            mode: "orchestrated",
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        this.data.missions[id] = mission;
+        this.data.jobMissions[id] ??= id;
+        return mission;
+    }
+    changed() {
+        this.persist();
+        for (const listener of this.listeners)
+            listener();
+    }
+    persist() {
+        fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
+    }
+}

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

@@ -0,0 +1,167 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+export function defaultWorkingDirectory() {
+    const candidate = process.env.INIT_CWD || process.cwd();
+    try {
+        if (fs.statSync(candidate).isDirectory())
+            return path.resolve(candidate);
+    }
+    catch { /* fall through */ }
+    return process.cwd();
+}
+export function resolveWorkingDirectory(input) {
+    const value = input?.trim();
+    if (!value)
+        return defaultWorkingDirectory();
+    if (value === "~")
+        return os.homedir();
+    if (value.startsWith("~/"))
+        return path.resolve(os.homedir(), value.slice(2));
+    return path.resolve(defaultWorkingDirectory(), value);
+}
+export function requireWorkingDirectory(input) {
+    const resolved = resolveWorkingDirectory(input);
+    try {
+        if (fs.statSync(resolved).isDirectory())
+            return resolved;
+    }
+    catch { /* use friendly error below */ }
+    throw new Error(`Directory does not exist: ${resolved}`);
+}
+function displayPath(value) {
+    const home = os.homedir();
+    return value === home ? "~" : value.startsWith(`${home}${path.sep}`) ? `~/${path.relative(home, value)}` : value;
+}
+export function suggestDirectories(input) {
+    const raw = input?.trim() ?? "";
+    if (!raw) {
+        const candidates = [defaultWorkingDirectory(), os.homedir(), path.join(os.homedir(), "Development")];
+        return candidates.filter((candidate, index) => candidates.indexOf(candidate) === index && fs.existsSync(candidate)).map((resolvedPath) => ({ path: displayPath(resolvedPath), resolvedPath }));
+    }
+    const expanded = resolveWorkingDirectory(raw);
+    let parent = path.dirname(expanded);
+    let prefix = path.basename(expanded).toLowerCase();
+    if (raw.endsWith("/") || raw === "~") {
+        parent = expanded;
+        prefix = "";
+    }
+    const suggestions = [];
+    if (fs.existsSync(expanded))
+        suggestions.push({ path: displayPath(expanded), resolvedPath: expanded });
+    try {
+        for (const entry of fs.readdirSync(parent, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name.startsWith(".") || !entry.name.toLowerCase().startsWith(prefix))
+                continue;
+            const resolvedPath = path.join(parent, entry.name);
+            if (!suggestions.some((item) => item.resolvedPath === resolvedPath))
+                suggestions.push({ path: displayPath(resolvedPath), resolvedPath });
+            if (suggestions.length >= 10)
+                break;
+        }
+    }
+    catch { /* an incomplete path simply has no suggestions */ }
+    return suggestions;
+}
+function stripWorktree(value) {
+    return value.split(`${path.sep}.claude${path.sep}worktrees${path.sep}`)[0];
+}
+/** Git repositories that sit beside the mission's repo (and the Hive default). */
+export function knownRepositories(baseRepository) {
+    const roots = new Set();
+    if (baseRepository)
+        roots.add(path.dirname(stripWorktree(baseRepository)));
+    roots.add(path.dirname(defaultWorkingDirectory()));
+    const found = new Map();
+    for (const root of roots) {
+        try {
+            for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name.startsWith("."))
+                    continue;
+                const full = path.join(root, entry.name);
+                if (fs.existsSync(path.join(full, ".git")))
+                    found.set(entry.name.toLowerCase(), full);
+            }
+        }
+        catch { /* a root may have been removed */ }
+    }
+    return [...found.entries()].map(([name, resolvedPath]) => ({ name, path: resolvedPath }));
+}
+/**
+ * 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.
+ */
+export function detectRepositoryMentions(text, ownRepository) {
+    const own = ownRepository ? path.basename(stripWorktree(ownRepository)).toLowerCase() : undefined;
+    const lower = text.toLowerCase();
+    return knownRepositories(ownRepository)
+        .filter(({ name }) => name !== own && new RegExp(`(?<![\\w-])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`).test(lower))
+        .map((repo) => repo.path);
+}
+/**
+ * The known repository containing filePath, excluding the mission's own repo
+ * (worktree paths count as their base repo). Used to record which other
+ * repositories a mission has actually touched.
+ */
+export function foreignRepositoryForPath(filePath, ownRepository) {
+    const own = ownRepository ? stripWorktree(ownRepository) : undefined;
+    if (own && (filePath === own || filePath.startsWith(`${own}${path.sep}`)))
+        return undefined;
+    return knownRepositories(ownRepository).find(({ path: repo }) => filePath === repo || filePath.startsWith(`${repo}${path.sep}`))?.path;
+}
+function git(directory, ...args) {
+    try {
+        return execFileSync("git", ["-C", directory, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 1_000 }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function inspectWorkingDirectory(input) {
+    const resolvedPath = resolveWorkingDirectory(input);
+    let exists = false;
+    try {
+        exists = fs.statSync(resolvedPath).isDirectory();
+    }
+    catch { /* invalid path */ }
+    const repositoryRoot = exists ? git(resolvedPath, "rev-parse", "--show-toplevel") : undefined;
+    const gitDir = repositoryRoot ? git(resolvedPath, "rev-parse", "--git-dir") : undefined;
+    const commonDir = repositoryRoot ? git(resolvedPath, "rev-parse", "--git-common-dir") : undefined;
+    const configurationRoot = repositoryRoot ?? resolvedPath;
+    return {
+        input: input?.trim() || displayPath(defaultWorkingDirectory()), resolvedPath, exists, repositoryRoot,
+        branch: repositoryRoot ? git(resolvedPath, "branch", "--show-current") ?? "detached HEAD" : undefined,
+        isWorktree: Boolean(repositoryRoot && gitDir && commonDir && path.resolve(resolvedPath, gitDir) !== path.resolve(resolvedPath, commonDir)),
+        configuration: [
+            { label: "CLAUDE.md", available: exists && fs.existsSync(path.join(configurationRoot, "CLAUDE.md")) },
+            { label: ".mcp.json", available: exists && fs.existsSync(path.join(configurationRoot, ".mcp.json")) },
+            { label: "Project settings", available: exists && fs.existsSync(path.join(configurationRoot, ".claude", "settings.json")) },
+            { label: "Project skills", available: exists && fs.existsSync(path.join(configurationRoot, ".claude", "skills")) },
+        ],
+    };
+}
+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 fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+    }
+    catch {
+        return 0;
+    } }).slice(0, limit).map((resolvedPath) => ({ path: displayPath(resolvedPath), resolvedPath }));
+}

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

@@ -0,0 +1,212 @@
+import Database from "better-sqlite3";
+import { config } from "../config.js";
+const STATUSES = new Set(["queued", "working", "blocked", "reviewing", "completed", "failed", "cancelled"]);
+const GATE_STATUSES = new Set(["pending", "satisfied", "failed", "waived"]);
+const GATE_TYPES = new Set(["test", "typecheck", "lint", "ci", "review", "pr", "screenshot", "documentation", "user_approval", "custom"]);
+function calculateProgress(phases) {
+    const tasks = phases.flatMap((phase) => leafTasks(phase.tasks)).filter((task) => task.status !== "cancelled");
+    const finished = tasks.filter((task) => task.status === "completed");
+    const totalWeight = tasks.reduce((sum, task) => sum + task.weight, 0);
+    const completedWeight = finished.reduce((sum, task) => sum + task.weight, 0);
+    return { completedWeight, totalWeight, percent: totalWeight ? Math.round(completedWeight / totalWeight * 100) : undefined, completedTasks: finished.length, totalTasks: tasks.length };
+}
+function leafTasks(tasks) { return tasks.flatMap((task) => task.subtasks?.length ? leafTasks(task.subtasks) : [task]); }
+export function allPlanTasks(tasks) { return tasks.flatMap((task) => [task, ...allPlanTasks(task.subtasks ?? [])]); }
+function normalize(input) {
+    if (input.tasks && input.phases?.length)
+        throw new Error("plan must use either flat tasks or phases, not both");
+    const source = input.tasks ? [{ id: "flat", title: "Tasks", status: flatStatus(input.tasks), acceptanceCriteria: [], dependsOn: [], tasks: input.tasks }] : input.phases;
+    if (!Array.isArray(source))
+        throw new Error("plan phases or flat tasks must be an array");
+    const ids = new Set();
+    return source.map((phase, phaseIndex) => {
+        const id = String(phase.id || `phase-${phaseIndex + 1}`).trim();
+        if (!id || ids.has(id))
+            throw new Error(`duplicate or empty plan item id: ${id}`);
+        ids.add(id);
+        if (!phase.title?.trim())
+            throw new Error(`phase ${id} requires a title`);
+        if (!STATUSES.has(phase.status))
+            throw new Error(`invalid phase status: ${phase.status}`);
+        const normalizeTasks = (sourceTasks, parentId) => sourceTasks.map((task, taskIndex) => {
+            const taskId = String(task.id || `${parentId}-task-${taskIndex + 1}`).trim();
+            if (!taskId || ids.has(taskId))
+                throw new Error(`duplicate or empty plan item id: ${taskId}`);
+            ids.add(taskId);
+            if (!task.title?.trim())
+                throw new Error(`task ${taskId} requires a title`);
+            if (!STATUSES.has(task.status))
+                throw new Error(`invalid task status: ${task.status}`);
+            const subtasks = normalizeTasks(task.subtasks ?? [], taskId);
+            if (task.status === "completed" && subtasks.some((subtask) => subtask.status !== "completed" && subtask.status !== "cancelled"))
+                throw new Error(`task ${taskId} cannot be completed while required subtasks remain`);
+            return { ...task, id: taskId, title: task.title.trim(), weight: Number.isFinite(task.weight) && task.weight > 0 ? task.weight : 1, dependsOn: task.dependsOn ?? [], evidence: task.evidence ?? [], subtasks };
+        });
+        const tasks = normalizeTasks(phase.tasks ?? [], id);
+        if (phase.status === "completed" && tasks.some((task) => task.status !== "completed" && task.status !== "cancelled")) {
+            throw new Error(`phase ${id} cannot be completed while required tasks remain`);
+        }
+        return { ...phase, id, title: phase.title.trim(), acceptanceCriteria: phase.acceptanceCriteria ?? [], dependsOn: phase.dependsOn ?? [], tasks };
+    });
+}
+function flatStatus(tasks) { if (tasks.length && tasks.every((task) => task.status === "completed" || task.status === "cancelled"))
+    return "completed"; if (tasks.some((task) => task.status === "blocked"))
+    return "blocked"; if (tasks.some((task) => task.status === "reviewing"))
+    return "reviewing"; if (tasks.some((task) => task.status === "working"))
+    return "working"; return "queued"; }
+function normalizeGates(gates) {
+    const ids = new Set();
+    return (gates ?? []).map((gate, index) => {
+        const id = String(gate.id || `gate-${index + 1}`).trim();
+        if (!id || ids.has(id))
+            throw new Error(`duplicate or empty completion gate id: ${id}`);
+        ids.add(id);
+        if (!gate.label?.trim())
+            throw new Error(`completion gate ${id} requires a label`);
+        if (!GATE_TYPES.has(gate.type))
+            throw new Error(`invalid completion gate type: ${gate.type}`);
+        if (!GATE_STATUSES.has(gate.status))
+            throw new Error(`invalid completion gate status: ${gate.status}`);
+        if (gate.status === "waived" && !gate.waiver?.reason?.trim())
+            throw new Error(`waived completion gate ${id} requires a reason`);
+        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 };
+    });
+}
+/** Durable current plan plus immutable JSON snapshots for revision history. */
+export class PlansStore {
+    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_plans (mission_id TEXT PRIMARY KEY, revision INTEGER NOT NULL, updated_at INTEGER NOT NULL, plan_json TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS mission_plan_revisions (mission_id TEXT NOT NULL, revision INTEGER NOT NULL, updated_at INTEGER NOT NULL, plan_json TEXT NOT NULL, PRIMARY KEY (mission_id, revision));
+      CREATE INDEX IF NOT EXISTS idx_plan_revisions ON mission_plan_revisions (mission_id, revision DESC);
+    `);
+    }
+    replace(missionId, input) {
+        const phases = normalize(input);
+        const current = this.get(missionId);
+        const gates = input.gates === undefined ? current?.gates ?? [] : normalizeGates(input.gates);
+        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(() => {
+            this.db.prepare("INSERT INTO mission_plans (mission_id, revision, updated_at, plan_json) VALUES (?, ?, ?, ?) ON CONFLICT(mission_id) DO UPDATE SET revision=excluded.revision, updated_at=excluded.updated_at, plan_json=excluded.plan_json").run(missionId, plan.revision, plan.updatedAt, json);
+            this.db.prepare("INSERT INTO mission_plan_revisions (mission_id, revision, updated_at, plan_json) VALUES (?, ?, ?, ?)").run(missionId, plan.revision, plan.updatedAt, json);
+        })();
+        for (const listener of this.listeners)
+            listener();
+        return plan;
+    }
+    /**
+     * Best-effort reconciliation from orchestrator activity events. The plan is
+     * authored by the orchestrator via plan_updated, but orchestrators reliably
+     * emit delegating/worker_reported while often forgetting to republish the
+     * plan — without this, tasks sit at "queued"/"working" forever while the
+     * workers finish. Matches by task id or worker name; transitions are
+     * forward-only, and any later plan_updated fully overrides the result.
+     */
+    applyTaskEvent(missionId, input) {
+        const plan = this.get(missionId);
+        if (!plan || (!input.targetTask && !input.targetWorker))
+            return undefined;
+        const nextStatus = input.phase === "delegating" ? "working" : input.phase === "reviewing" ? "reviewing" : "completed";
+        const allowedFrom = {
+            working: ["queued", "blocked"],
+            reviewing: ["queued", "working"],
+            completed: ["queued", "working", "reviewing"],
+        };
+        let changed = false;
+        const now = Date.now();
+        const mapTasks = (tasks) => tasks.map((task) => {
+            const subtasks = task.subtasks?.length ? mapTasks(task.subtasks) : task.subtasks;
+            const matched = (input.targetTask !== undefined && task.id === input.targetTask)
+                || (input.targetWorker !== undefined && (task.workerId === input.targetWorker || task.owner === input.targetWorker));
+            // A parent cannot complete ahead of its subtasks (normalize rejects it).
+            const blockedBySubtasks = nextStatus === "completed" && (subtasks ?? []).some((subtask) => subtask.status !== "completed" && subtask.status !== "cancelled");
+            if (!matched || blockedBySubtasks || !allowedFrom[nextStatus].includes(task.status)) {
+                return subtasks === task.subtasks ? task : { ...task, subtasks };
+            }
+            changed = true;
+            return {
+                ...task,
+                subtasks,
+                status: nextStatus,
+                updatedAt: now,
+                startedAt: task.startedAt ?? now,
+                owner: task.owner ?? input.targetWorker,
+                workerId: task.workerId ?? input.targetWorker,
+                evidence: nextStatus === "completed" && input.evidence?.trim() ? [...task.evidence, input.evidence.trim().slice(0, 300)] : task.evidence,
+            };
+        });
+        const phases = plan.phases.map((phase) => {
+            const tasks = mapTasks(phase.tasks);
+            const statuses = allPlanTasks(tasks).map((task) => task.status);
+            let status = phase.status;
+            if (statuses.length && statuses.every((s) => s === "completed" || s === "cancelled"))
+                status = "completed";
+            else if ((phase.status === "queued" || phase.status === "completed") && statuses.some((s) => s === "working" || s === "reviewing"))
+                status = "working";
+            return { ...phase, status, tasks };
+        });
+        if (!changed)
+            return undefined;
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: phases[0]?.tasks ?? [] } : { phases }), gates: plan.gates ?? [], approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason });
+    }
+    removeMission(missionId) { this.db.transaction(() => { this.db.prepare("DELETE FROM mission_plans WHERE mission_id = ?").run(missionId); this.db.prepare("DELETE FROM mission_plan_revisions WHERE mission_id = ?").run(missionId); })(); for (const listener of this.listeners)
+        listener(); }
+    migrateMission(oldId, newId) { this.db.transaction(() => { const current = this.get(oldId); if (current) {
+        const migrated = JSON.stringify({ ...current, missionId: newId });
+        this.db.prepare("INSERT OR REPLACE INTO mission_plans (mission_id, revision, updated_at, plan_json) VALUES (?, ?, ?, ?)").run(newId, current.revision, current.updatedAt, migrated);
+    } for (const revision of this.revisions(oldId))
+        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;
+    }
+    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));
+    }
+    waiveGate(missionId, gateId, reason) {
+        const plan = this.get(missionId);
+        if (!plan)
+            throw new Error("mission plan not found");
+        const gate = plan.gates?.find((item) => item.id === gateId);
+        if (!gate)
+            throw new Error("completion gate not found");
+        if (!reason.trim())
+            throw new Error("waiver reason is required");
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan.phases }), gates: (plan.gates ?? []).map((item) => item.id === gateId ? { ...item, status: "waived", waiver: { reason: reason.trim(), waivedAt: Date.now() } } : item), approvalStatus: plan.approvalStatus ?? "proposed", approvalReason: plan.approvalReason });
+    }
+    unresolvedRequiredGates(missionId) {
+        return (this.get(missionId)?.gates ?? []).filter((gate) => gate.required && gate.status !== "satisfied" && gate.status !== "waived");
+    }
+    satisfyUserApprovalGates(missionId) {
+        const plan = this.get(missionId);
+        if (!plan)
+            return undefined;
+        const pending = (plan.gates ?? []).some((gate) => gate.type === "user_approval" && gate.status !== "satisfied" && gate.status !== "waived");
+        if (!pending)
+            return plan;
+        return this.replace(missionId, {
+            ...(plan.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan.phases }),
+            gates: (plan.gates ?? []).map((gate) => gate.type === "user_approval" && gate.status !== "satisfied" && gate.status !== "waived" ? { ...gate, status: "satisfied", evidence: [...gate.evidence, "Mission accepted by user"] } : gate),
+            approvalStatus: plan.approvalStatus ?? "proposed",
+            approvalReason: plan.approvalReason,
+        });
+    }
+    setApproval(missionId, status, reason) {
+        const plan = this.get(missionId);
+        if (!plan)
+            throw new Error("mission plan not found");
+        const executionStarted = plan.phases.some((phase) => phase.status !== "queued" || allPlanTasks(phase.tasks).some((task) => task.status !== "queued"));
+        if (executionStarted)
+            throw new Error("plan approval is only available before execution begins");
+        if (status === "rejected" && !reason?.trim())
+            throw new Error("rejection reason is required");
+        return this.replace(missionId, { ...(plan.layout === "flat" ? { tasks: plan.phases[0]?.tasks ?? [] } : { phases: plan.phases }), gates: plan.gates ?? [], approvalStatus: status, approvalReason: reason });
+    }
+    onChange(listener) { this.listeners.add(listener); }
+    close() { this.db.close(); }
+}