@polpo-ai/core 0.11.1 → 0.12.1

package/dist/mission-executor.js

@@ -1,44 +1,10 @@
 import { sanitizeExpectations, parseMissionDocument } from "./schemas.js";
-import { resolveMissionStore } from "./mission-store.js";
-// ── In-memory fallback stores (no Node.js deps) ─────────────────────────
-class InMemoryCheckpointStore {
-    state = { definitions: {}, active: {}, resumed: [] };
-    async load() {
-        return this.state;
-    }
-    async save(state) {
-        this.state = state;
-    }
-    async removeGroup(state, group) {
-        delete state.definitions[group];
-        for (const key of Object.keys(state.active)) {
-            if (key.startsWith(group + ":"))
-                delete state.active[key];
-        }
-        state.resumed = state.resumed.filter(k => !k.startsWith(group + ":"));
-        return state;
-    }
-}
-class InMemoryDelayStore {
-    state = { definitions: {}, active: {}, expired: [] };
-    async load() {
-        return this.state;
-    }
-    async save(state) {
-        this.state = state;
-    }
-    async removeGroup(state, group) {
-        delete state.definitions[group];
-        for (const key of Object.keys(state.active)) {
-            if (key.startsWith(group + ":"))
-                delete state.active[key];
-        }
-        state.expired = state.expired.filter(k => !k.startsWith(group + ":"));
-        return state;
-    }
-}
+import { resolveMissionStore, resolveMissionForGroup } from "./mission-store.js";
+import { InMemoryCheckpointStore, InMemoryDelayStore } from "./in-memory-stores.js";
+import { MissionGating, parseISO8601Duration } from "./mission-gating.js";
 /**
  * Mission CRUD + execution + resume + group lifecycle.
+ * Runtime checkpoint/delay gating is delegated to MissionGating.
  */
 export class MissionExecutor {
     ctx;
@@ -47,17 +13,11 @@ export class MissionExecutor {
     cleanedGroups = new Set();
     /** Quality gates parsed from mission documents, keyed by mission group name */
     gatesByGroup = new Map();
-    /** Persistent checkpoint store — survives server restarts */
     missions;
-    cpStore;
-    /** In-memory mirror of persisted checkpoint state (synced on every mutation) */
-    cpState;
+    /** Runtime checkpoint/delay gating — owns the persisted checkpoint/delay state */
+    gating;
     /** Optional quality controller — set by orchestrator after init */
     qualityCtrl;
-    /** Persistent delay store — survives server restarts */
-    delayStore;
-    /** In-memory mirror of persisted delay state (synced on every mutation) */
-    delayState;
     /** Track the pre-execution status for scheduled/recurring missions (by group name).
      *  When a mission completes/fails, this determines whether to return to scheduled/recurring. */
     scheduledOrigin = new Map();
@@ -66,8 +26,7 @@ export class MissionExecutor {
         this.taskMgr = taskMgr;
         this.agentMgr = agentMgr;
         this.missions = resolveMissionStore(ctx);
-        this.cpStore = ctx.checkpointStore ?? new InMemoryCheckpointStore();
-        this.delayStore = ctx.delayStore ?? new InMemoryDelayStore();
+        this.gating = new MissionGating(ctx, ctx.checkpointStore ?? new InMemoryCheckpointStore(), ctx.delayStore ?? new InMemoryDelayStore());
         // Rebuild cleanedGroups from persisted task state — groups where ALL tasks
         // are already terminal don't need to be re-processed after a server restart.
         // Constructor cannot be async — expose ready promise for callers to await.
@@ -77,13 +36,12 @@ export class MissionExecutor {
     ready;
     /** Async init: load checkpoint/delay state and rebuild cleanedGroups. */
     async initStoresAndRebuild() {
-        this.cpState = await this.cpStore.load();
-        this.delayState = await this.delayStore.load();
+        await this.gating.ready;
         await this.rebuildCleanedGroups();
     }
     /** Async init: rebuild cleanedGroups from persisted task state. */
     async rebuildCleanedGroups() {
-        const allTasks = await this.ctx.registry.getAllTasks();
+        const allTasks = await this.ctx.taskStore.listTasks();
         const groups = new Set();
         for (const t of allTasks) {
             if (t.group)
@@ -104,109 +62,32 @@ export class MissionExecutor {
     getQualityGates(group) {
         return this.gatesByGroup.get(group) ?? [];
     }
+    // ─── Checkpoint/delay gating (delegated to MissionGating) ─────────────
     /** Get checkpoints for a mission group. Returns empty array if none defined. */
     getCheckpoints(group) {
-        return this.cpState?.definitions?.[group] ?? [];
+        return this.gating.getCheckpoints(group);
     }
     /**
      * Check if a task is blocked by an active (unresumed) checkpoint.
      * Returns the blocking checkpoint if found, undefined if the task can proceed.
      */
     async getBlockingCheckpoint(group, taskTitle, taskId, tasks) {
-        const checkpoints = this.cpState?.definitions?.[group];
-        if (!checkpoints)
-            return undefined;
-        for (const cp of checkpoints) {
-            // Task must be in blocksTasks
-            if (!cp.blocksTasks.includes(taskTitle) && !cp.blocksTasks.includes(taskId)) {
-                continue;
-            }
-            const cpKey = `${group}:${cp.name}`;
-            // Already resumed — don't block
-            if (this.cpState.resumed.includes(cpKey))
-                continue;
-            // Check if all afterTasks are done
-            const afterTasks = tasks.filter(t => cp.afterTasks.includes(t.title) || cp.afterTasks.includes(t.id));
-            const allDone = afterTasks.length >= cp.afterTasks.length &&
-                afterTasks.every(t => t.status === "done" || t.status === "failed");
-            if (!allDone) {
-                // afterTasks not finished yet — checkpoint not reached, don't block (deps will block naturally)
-                continue;
-            }
-            // Checkpoint reached — activate it if not already active
-            if (!this.cpState.active[cpKey]) {
-                const reachedAt = new Date().toISOString();
-                this.cpState.active[cpKey] = { checkpoint: cp, reachedAt };
-                await this.cpStore.save(this.cpState);
-                // Pause the mission — use task.missionId when available
-                const taskMissionId = tasks.find(t => t.group === group && t.missionId)?.missionId;
-                const mission = taskMissionId
-                    ? await this.missions.getMission(taskMissionId)
-                    : await this.missions.getMissionByName(group);
-                if (mission && mission.status === "active") {
-                    await this.missions.updateMission(mission.id, { status: "paused" });
-                }
-                // Register notification rules for this checkpoint's channels
-                this.ensureCheckpointNotificationRules(cpKey, cp);
-                // Emit event (picked up by notification router if rules are configured)
-                this.ctx.emitter.emit("checkpoint:reached", {
-                    missionId: mission?.id,
-                    group,
-                    checkpointName: cp.name,
-                    message: cp.message,
-                    afterTasks: cp.afterTasks,
-                    blocksTasks: cp.blocksTasks,
-                    reachedAt,
-                });
-            }
-            // Return the blocking checkpoint
-            return this.cpState.active[cpKey];
-        }
-        return undefined;
+        return this.gating.getBlockingCheckpoint(group, taskTitle, taskId, tasks);
     }
     /**
      * Resume a checkpoint, unblocking its blocksTasks.
      * Returns true if the checkpoint was active and is now resumed, false if not found.
      */
     async resumeCheckpoint(group, checkpointName) {
-        const cpKey = `${group}:${checkpointName}`;
-        const active = this.cpState.active[cpKey];
-        if (!active)
-            return false;
-        this.cpState.resumed.push(cpKey);
-        delete this.cpState.active[cpKey];
-        await this.cpStore.save(this.cpState);
-        // Un-pause the mission (back to active) — resolve via missionId from tasks
-        const groupTasks = (await this.ctx.registry.getAllTasks()).filter(t => t.group === group);
-        const mission = await this.resolveMissionForGroup(groupTasks, group);
-        if (mission && mission.status === "paused") {
-            await this.missions.updateMission(mission.id, { status: "active" });
-        }
-        this.ctx.emitter.emit("checkpoint:resumed", {
-            missionId: mission?.id,
-            group,
-            checkpointName,
-        });
-        return true;
+        return this.gating.resumeCheckpoint(group, checkpointName);
     }
     /** Get all active (unresumed) checkpoints across all mission groups. */
     getActiveCheckpoints() {
-        const result = [];
-        for (const [cpKey, data] of Object.entries(this.cpState.active)) {
-            const [group, ...nameParts] = cpKey.split(":");
-            const checkpointName = nameParts.join(":");
-            result.push({ group, checkpointName, checkpoint: data.checkpoint, reachedAt: data.reachedAt });
-        }
-        return result;
-    }
-    /** Notification rules for checkpoints removed — no-op. */
-    ensureCheckpointNotificationRules(_cpKey, _cp) {
-        // No-op: notification routing removed.
+        return this.gating.getActiveCheckpoints();
     }
-    // ─── Delay runtime ──────────────────────────────────
     /** Get delays for a mission group. Returns empty array if none defined. */
     getDelays(group) {
-        return this.delayState?.definitions?.[group] ?? [];
+        return this.gating.getDelays(group);
     }
     /**
      * Check if a task is blocked by an active (unexpired) delay.
@@ -215,91 +96,15 @@ export class MissionExecutor {
      * Returns the blocking delay if found, undefined if the task can proceed.
      */
     async getBlockingDelay(group, taskTitle, taskId, tasks) {
-        const delays = this.delayState?.definitions?.[group];
-        if (!delays)
-            return undefined;
-        for (const dl of delays) {
-            // Task must be in blocksTasks
-            if (!dl.blocksTasks.includes(taskTitle) && !dl.blocksTasks.includes(taskId)) {
-                continue;
-            }
-            const dlKey = `${group}:${dl.name}`;
-            // Already expired — don't block
-            if (this.delayState.expired.includes(dlKey))
-                continue;
-            // Check if all afterTasks are done
-            const afterTasks = tasks.filter(t => dl.afterTasks.includes(t.title) || dl.afterTasks.includes(t.id));
-            const allDone = afterTasks.length >= dl.afterTasks.length &&
-                afterTasks.every(t => t.status === "done" || t.status === "failed");
-            if (!allDone) {
-                // afterTasks not finished yet — delay not triggered, don't block (deps will block naturally)
-                continue;
-            }
-            // Delay triggered — activate timer if not already active
-            if (!this.delayState.active[dlKey]) {
-                const startedAt = new Date().toISOString();
-                const durationMs = parseISO8601Duration(dl.duration);
-                const expiresAt = new Date(Date.now() + durationMs).toISOString();
-                this.delayState.active[dlKey] = { delay: dl, startedAt, expiresAt };
-                await this.delayStore.save(this.delayState);
-                // Register notification rules for this delay's channels
-                this.ensureDelayNotificationRules(dlKey, dl);
-                // Emit event
-                const mission = await this.resolveMissionForGroupByName(group);
-                this.ctx.emitter.emit("delay:started", {
-                    missionId: mission?.id,
-                    group,
-                    delayName: dl.name,
-                    duration: dl.duration,
-                    message: dl.message,
-                    afterTasks: dl.afterTasks,
-                    blocksTasks: dl.blocksTasks,
-                    startedAt,
-                    expiresAt,
-                });
-            }
-            // Check if the timer has expired
-            const active = this.delayState.active[dlKey];
-            if (new Date(active.expiresAt).getTime() <= Date.now()) {
-                // Timer expired — mark as expired and unblock
-                this.delayState.expired.push(dlKey);
-                delete this.delayState.active[dlKey];
-                await this.delayStore.save(this.delayState);
-                const mission = await this.resolveMissionForGroupByName(group);
-                this.ctx.emitter.emit("delay:expired", {
-                    missionId: mission?.id,
-                    group,
-                    delayName: dl.name,
-                });
-                continue; // Unblocked — check next delay
-            }
-            // Still waiting — return the blocking delay
-            return active;
-        }
-        return undefined;
+        return this.gating.getBlockingDelay(group, taskTitle, taskId, tasks);
     }
     /** Get all active (unexpired) delays across all mission groups. */
     getActiveDelays() {
-        const result = [];
-        for (const [dlKey, data] of Object.entries(this.delayState.active)) {
-            const [group, ...nameParts] = dlKey.split(":");
-            const delayName = nameParts.join(":");
-            result.push({ group, delayName, delay: data.delay, startedAt: data.startedAt, expiresAt: data.expiresAt });
-        }
-        return result;
-    }
-    /** Notification rules for delays removed — no-op. */
-    ensureDelayNotificationRules(_dlKey, _dl) {
-        // No-op: notification routing removed.
+        return this.gating.getActiveDelays();
     }
-    /** Resolve a mission by group name (helper for delay/checkpoint events). */
-    async resolveMissionForGroupByName(group) {
-        const groupTasks = (await this.ctx.registry.getAllTasks()).filter(t => t.group === group);
-        return this.resolveMissionForGroup(groupTasks, group);
-    }
-    async saveMission(opts) {
+    async createMission(opts) {
         const name = opts.name ?? await this.missions.nextMissionName();
-        const mission = await this.missions.saveMission({
+        const mission = await this.missions.createMission({
             name,
             data: opts.data,
             prompt: opts.prompt,
@@ -319,8 +124,8 @@ export class MissionExecutor {
     async getMissionByName(name) {
         return this.missions.getMissionByName(name);
     }
-    async getAllMissions() {
-        return await this.missions.getAllMissions();
+    async listMissions() {
+        return await this.missions.listMissions();
     }
     async updateMission(missionId, updates) {
         return this.missions.updateMission(missionId, updates);
@@ -342,20 +147,8 @@ export class MissionExecutor {
             if (key.startsWith(missionGroup + " #"))
                 this.gatesByGroup.delete(key);
         }
-        // 4. Clean up persisted checkpoints
-        this.cpState = await this.cpStore.removeGroup(this.cpState, missionGroup);
-        for (const key of Object.keys(this.cpState.definitions)) {
-            if (key.startsWith(missionGroup + " #")) {
-                this.cpState = await this.cpStore.removeGroup(this.cpState, key);
-            }
-        }
-        // 4b. Clean up persisted delays
-        this.delayState = await this.delayStore.removeGroup(this.delayState, missionGroup);
-        for (const key of Object.keys(this.delayState.definitions)) {
-            if (key.startsWith(missionGroup + " #")) {
-                this.delayState = await this.delayStore.removeGroup(this.delayState, key);
-            }
-        }
+        // 4. Clean up persisted checkpoints and delays (incl. numbered recurring-run groups)
+        await this.gating.removeGroupAndRuns(missionGroup);
         // 5. Clean up scheduled origin cache
         this.scheduledOrigin.delete(missionGroup);
         for (const key of this.scheduledOrigin.keys()) {
@@ -376,8 +169,8 @@ export class MissionExecutor {
         return result;
     }
     async getResumableMissions() {
-        const missions = await this.getAllMissions();
-        const state = await this.ctx.registry.getState();
+        const missions = await this.listMissions();
+        const state = await this.ctx.taskStore.getState();
         return missions.filter(m => {
             // Non-resumable statuses: draft (never executed), scheduled/recurring (scheduler handles),
             // completed (done), cancelled (aborted)
@@ -413,7 +206,7 @@ export class MissionExecutor {
                 this.ctx.emitter.emit("log", { level: "warn", message: `Failed to re-register volatile agents for ${mission.name}: ${err instanceof Error ? err.message : String(err)}` });
             }
         }
-        const state = await this.ctx.registry.getState();
+        const state = await this.ctx.taskStore.getState();
         const tasks = state.tasks.filter(t => t.group === mission.name);
         const failedTasks = tasks.filter(t => t.status === "failed");
         const pendingTasks = tasks.filter(t => t.status === "pending");
@@ -511,7 +304,7 @@ export class MissionExecutor {
                     this.ctx.emitter.emit("log", { level: "warn", message: `Mission task "${t.title}": ${w}` });
                 }
             }
-            const task = await this.taskMgr.addTask({
+            const task = await this.taskMgr.createTask({
                 title: t.title,
                 description: t.description || t.title,
                 assignTo: t.assignTo || (await this.agentMgr.getAgents())[0]?.name || "default",
@@ -533,12 +326,10 @@ export class MissionExecutor {
             this.gatesByGroup.set(group, doc.qualityGates);
         }
         if (doc.checkpoints && doc.checkpoints.length > 0) {
-            this.cpState.definitions[group] = doc.checkpoints;
-            await this.cpStore.save(this.cpState);
+            await this.gating.setCheckpointDefinitions(group, doc.checkpoints);
         }
         if (doc.delays && doc.delays.length > 0) {
-            this.delayState.definitions[group] = doc.delays;
-            await this.delayStore.save(this.delayState);
+            await this.gating.setDelayDefinitions(group, doc.delays);
         }
         // Track scheduled origin so we know where to return after completion
         if (scheduledStatus) {
@@ -555,19 +346,6 @@ export class MissionExecutor {
         this.ctx.emitter.emit("mission:executed", { missionId, group, taskCount: tasks.length });
         return { tasks, group };
     }
-    /**
-     * Resolve the Mission for a group of tasks.
-     * Uses task.missionId (direct FK) when available, falls back to getMissionByName
-     * for legacy tasks that pre-date the missionId field.
-     */
-    async resolveMissionForGroup(groupTasks, group) {
-        // Prefer the direct ID reference from any task in the group
-        const mid = groupTasks.find(t => t.missionId)?.missionId;
-        if (mid)
-            return this.missions.getMission(mid);
-        // Fallback: strip run-number suffix (e.g. "Mission #3" → "Mission") for legacy compat
-        return this.missions.getMissionByName(group.replace(/ #\d+$/, ""));
-    }
     /** Check if any mission groups have all tasks terminal, and clean up their volatile agents */
     async cleanupCompletedGroups(tasks) {
         const groups = new Set();
@@ -594,7 +372,7 @@ export class MissionExecutor {
             }
             this.cleanedGroups.add(group);
             // Auto-update mission status
-            const mission = await this.resolveMissionForGroup(groupTasks, group);
+            const mission = await resolveMissionForGroup(this.missions, groupTasks, group);
             if (mission && mission.status === "active") {
                 let allDone = groupTasks.every(t => t.status === "done");
                 // Check mission quality threshold (only if all tasks passed structurally)
@@ -631,10 +409,8 @@ export class MissionExecutor {
                 // Clean up gate, checkpoint, delay, and scheduled-origin caches
                 this.gatesByGroup.delete(group);
                 this.scheduledOrigin.delete(group);
-                // Clean up persisted checkpoint entries for this group
-                this.cpState = await this.cpStore.removeGroup(this.cpState, group);
-                // Clean up persisted delay entries for this group
-                this.delayState = await this.delayStore.removeGroup(this.delayState, group);
+                // Clean up persisted checkpoint and delay entries for this group
+                await this.gating.removeGroup(group);
             }
         }
     }
@@ -665,249 +441,237 @@ export class MissionExecutor {
         this.ctx.emitter.emit("mission:saved", { missionId: mission.id, name: mission.name, status: mission.status });
         return mission;
     }
+    /**
+     * Generic read-modify-write for a named collection inside the mission `data`
+     * document. Loads the mission, hands the collection (and the full parsed
+     * document) to `mutate`, then re-validates and persists.
+     *
+     * - `createIfMissing` creates the collection when absent (add operations);
+     *   otherwise a missing collection throws `missingError`.
+     * - Optional collections left empty by the mutation are removed from the
+     *   document entirely (tasks are required and never dropped).
+     */
+    async mutateMissionCollection(missionId, key, mutate, opts = {}) {
+        const { doc } = await this.parseMissionData(missionId);
+        if (!doc[key]) {
+            if (!opts.createIfMissing)
+                throw new Error(opts.missingError ?? `No ${key} in mission`);
+            doc[key] = [];
+        }
+        mutate(doc[key], doc);
+        if (key !== "tasks" && doc[key]?.length === 0)
+            delete doc[key];
+        return this.persistMissionData(missionId, doc);
+    }
     // ─── Task operations ────────────────────────────────
     /** Add a task to a draft mission's data. */
     async addMissionTask(missionId, task) {
-        const { doc } = await this.parseMissionData(missionId);
-        // Enforce unique title
-        if (doc.tasks.some(t => t.title === task.title)) {
-            throw new Error(`Task title "${task.title}" already exists in this mission`);
-        }
-        doc.tasks.push(task);
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "tasks", tasks => {
+            // Enforce unique title
+            if (tasks.some(t => t.title === task.title)) {
+                throw new Error(`Task title "${task.title}" already exists in this mission`);
+            }
+            tasks.push(task);
+        }, { createIfMissing: true });
     }
     /** Update a specific task within the mission data (matched by title). */
     async updateMissionTask(missionId, taskTitle, updates) {
-        const { doc } = await this.parseMissionData(missionId);
-        const idx = doc.tasks.findIndex(t => t.title === taskTitle);
-        if (idx === -1)
-            throw new Error(`Task "${taskTitle}" not found in mission`);
-        // If renaming, enforce unique title
-        if (updates.title && updates.title !== taskTitle && doc.tasks.some(t => t.title === updates.title)) {
-            throw new Error(`Task title "${updates.title}" already exists in this mission`);
-        }
-        doc.tasks[idx] = { ...doc.tasks[idx], ...updates };
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "tasks", tasks => {
+            const idx = tasks.findIndex(t => t.title === taskTitle);
+            if (idx === -1)
+                throw new Error(`Task "${taskTitle}" not found in mission`);
+            // If renaming, enforce unique title
+            if (updates.title && updates.title !== taskTitle && tasks.some(t => t.title === updates.title)) {
+                throw new Error(`Task title "${updates.title}" already exists in this mission`);
+            }
+            tasks[idx] = { ...tasks[idx], ...updates };
+        }, { missingError: `Task "${taskTitle}" not found in mission` });
     }
     /** Remove a task from the mission data (by title). Also cleans up dependsOn references. */
     async removeMissionTask(missionId, taskTitle) {
-        const { doc } = await this.parseMissionData(missionId);
-        const idx = doc.tasks.findIndex(t => t.title === taskTitle);
-        if (idx === -1)
-            throw new Error(`Task "${taskTitle}" not found in mission`);
-        doc.tasks.splice(idx, 1);
-        // Clean up dependsOn references in remaining tasks
-        for (const t of doc.tasks) {
-            if (t.dependsOn) {
-                t.dependsOn = t.dependsOn.filter(d => d !== taskTitle);
+        return this.mutateMissionCollection(missionId, "tasks", (tasks, doc) => {
+            const idx = tasks.findIndex(t => t.title === taskTitle);
+            if (idx === -1)
+                throw new Error(`Task "${taskTitle}" not found in mission`);
+            tasks.splice(idx, 1);
+            // Clean up dependsOn references in remaining tasks
+            for (const t of tasks) {
+                if (t.dependsOn) {
+                    t.dependsOn = t.dependsOn.filter(d => d !== taskTitle);
+                }
             }
-        }
-        // Clean up quality gates and checkpoints that reference this task
-        if (doc.qualityGates) {
-            for (const gate of doc.qualityGates) {
-                gate.afterTasks = gate.afterTasks.filter(t => t !== taskTitle);
-                gate.blocksTasks = gate.blocksTasks.filter(t => t !== taskTitle);
+            // Clean up quality gates and checkpoints that reference this task
+            if (doc.qualityGates) {
+                for (const gate of doc.qualityGates) {
+                    gate.afterTasks = gate.afterTasks.filter(t => t !== taskTitle);
+                    gate.blocksTasks = gate.blocksTasks.filter(t => t !== taskTitle);
+                }
+                // Remove gates that became empty
+                doc.qualityGates = doc.qualityGates.filter(g => g.afterTasks.length > 0 && g.blocksTasks.length > 0);
             }
-            // Remove gates that became empty
-            doc.qualityGates = doc.qualityGates.filter(g => g.afterTasks.length > 0 && g.blocksTasks.length > 0);
-        }
-        if (doc.checkpoints) {
-            for (const cp of doc.checkpoints) {
-                cp.afterTasks = cp.afterTasks.filter(t => t !== taskTitle);
-                cp.blocksTasks = cp.blocksTasks.filter(t => t !== taskTitle);
+            if (doc.checkpoints) {
+                for (const cp of doc.checkpoints) {
+                    cp.afterTasks = cp.afterTasks.filter(t => t !== taskTitle);
+                    cp.blocksTasks = cp.blocksTasks.filter(t => t !== taskTitle);
+                }
+                doc.checkpoints = doc.checkpoints.filter(cp => cp.afterTasks.length > 0 && cp.blocksTasks.length > 0);
             }
-            doc.checkpoints = doc.checkpoints.filter(cp => cp.afterTasks.length > 0 && cp.blocksTasks.length > 0);
-        }
-        if (doc.delays) {
-            for (const dl of doc.delays) {
-                dl.afterTasks = dl.afterTasks.filter(t => t !== taskTitle);
-                dl.blocksTasks = dl.blocksTasks.filter(t => t !== taskTitle);
+            if (doc.delays) {
+                for (const dl of doc.delays) {
+                    dl.afterTasks = dl.afterTasks.filter(t => t !== taskTitle);
+                    dl.blocksTasks = dl.blocksTasks.filter(t => t !== taskTitle);
+                }
+                doc.delays = doc.delays.filter(dl => dl.afterTasks.length > 0 && dl.blocksTasks.length > 0);
             }
-            doc.delays = doc.delays.filter(dl => dl.afterTasks.length > 0 && dl.blocksTasks.length > 0);
-        }
-        // Ensure at least 1 task remains (Zod will catch this, but give a nicer error)
-        if (doc.tasks.length === 0)
-            throw new Error("Cannot remove the last task from a mission");
-        return this.persistMissionData(missionId, doc);
+            // Ensure at least 1 task remains (Zod will catch this, but give a nicer error)
+            if (tasks.length === 0)
+                throw new Error("Cannot remove the last task from a mission");
+        }, { missingError: `Task "${taskTitle}" not found in mission` });
     }
     /** Reorder tasks within the mission data. Accepts an array of task titles in the desired order. */
     async reorderMissionTasks(missionId, titles) {
-        const { doc } = await this.parseMissionData(missionId);
-        const titleSet = new Set(titles);
-        if (titleSet.size !== titles.length)
-            throw new Error("Duplicate titles in reorder list");
-        const existing = new Set(doc.tasks.map(t => t.title));
-        for (const t of titles) {
-            if (!existing.has(t))
-                throw new Error(`Task "${t}" not found in mission`);
-        }
-        if (titles.length !== doc.tasks.length)
-            throw new Error("Reorder list must include all task titles");
-        const taskMap = new Map(doc.tasks.map(t => [t.title, t]));
-        doc.tasks = titles.map(t => taskMap.get(t));
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "tasks", (tasks, doc) => {
+            const titleSet = new Set(titles);
+            if (titleSet.size !== titles.length)
+                throw new Error("Duplicate titles in reorder list");
+            const existing = new Set(tasks.map(t => t.title));
+            for (const t of titles) {
+                if (!existing.has(t))
+                    throw new Error(`Task "${t}" not found in mission`);
+            }
+            if (titles.length !== tasks.length)
+                throw new Error("Reorder list must include all task titles");
+            const taskMap = new Map(tasks.map(t => [t.title, t]));
+            doc.tasks = titles.map(t => taskMap.get(t));
+        });
     }
     // ─── Checkpoint operations ──────────────────────────
     /** Add a checkpoint to a mission's data. */
     async addMissionCheckpoint(missionId, checkpoint) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.checkpoints)
-            doc.checkpoints = [];
-        if (doc.checkpoints.some(c => c.name === checkpoint.name)) {
-            throw new Error(`Checkpoint "${checkpoint.name}" already exists in this mission`);
-        }
-        doc.checkpoints.push(checkpoint);
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "checkpoints", checkpoints => {
+            if (checkpoints.some(c => c.name === checkpoint.name)) {
+                throw new Error(`Checkpoint "${checkpoint.name}" already exists in this mission`);
+            }
+            checkpoints.push(checkpoint);
+        }, { createIfMissing: true });
     }
     /** Update a checkpoint in the mission data (matched by name). */
     async updateMissionCheckpoint(missionId, checkpointName, updates) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.checkpoints)
-            throw new Error(`Checkpoint "${checkpointName}" not found in mission`);
-        const idx = doc.checkpoints.findIndex(c => c.name === checkpointName);
-        if (idx === -1)
-            throw new Error(`Checkpoint "${checkpointName}" not found in mission`);
-        if (updates.name && updates.name !== checkpointName && doc.checkpoints.some(c => c.name === updates.name)) {
-            throw new Error(`Checkpoint "${updates.name}" already exists in this mission`);
-        }
-        doc.checkpoints[idx] = { ...doc.checkpoints[idx], ...updates };
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "checkpoints", checkpoints => {
+            const idx = checkpoints.findIndex(c => c.name === checkpointName);
+            if (idx === -1)
+                throw new Error(`Checkpoint "${checkpointName}" not found in mission`);
+            if (updates.name && updates.name !== checkpointName && checkpoints.some(c => c.name === updates.name)) {
+                throw new Error(`Checkpoint "${updates.name}" already exists in this mission`);
+            }
+            checkpoints[idx] = { ...checkpoints[idx], ...updates };
+        }, { missingError: `Checkpoint "${checkpointName}" not found in mission` });
     }
     /** Remove a checkpoint from the mission data (by name). */
     async removeMissionCheckpoint(missionId, checkpointName) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.checkpoints)
-            throw new Error(`Checkpoint "${checkpointName}" not found in mission`);
-        const idx = doc.checkpoints.findIndex(c => c.name === checkpointName);
-        if (idx === -1)
-            throw new Error(`Checkpoint "${checkpointName}" not found in mission`);
-        doc.checkpoints.splice(idx, 1);
-        if (doc.checkpoints.length === 0)
-            delete doc.checkpoints;
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "checkpoints", checkpoints => {
+            const idx = checkpoints.findIndex(c => c.name === checkpointName);
+            if (idx === -1)
+                throw new Error(`Checkpoint "${checkpointName}" not found in mission`);
+            checkpoints.splice(idx, 1);
+        }, { missingError: `Checkpoint "${checkpointName}" not found in mission` });
     }
     // ─── Delay operations ───────────────────────────────
     /** Add a delay to a mission's data. */
     async addMissionDelay(missionId, delay) {
         // Validate duration format
         parseISO8601Duration(delay.duration);
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.delays)
-            doc.delays = [];
-        if (doc.delays.some(d => d.name === delay.name)) {
-            throw new Error(`Delay "${delay.name}" already exists in this mission`);
-        }
-        doc.delays.push(delay);
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "delays", delays => {
+            if (delays.some(d => d.name === delay.name)) {
+                throw new Error(`Delay "${delay.name}" already exists in this mission`);
+            }
+            delays.push(delay);
+        }, { createIfMissing: true });
     }
     /** Update a delay in the mission data (matched by name). */
     async updateMissionDelay(missionId, delayName, updates) {
         if (updates.duration)
             parseISO8601Duration(updates.duration);
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.delays)
-            throw new Error(`Delay "${delayName}" not found in mission`);
-        const idx = doc.delays.findIndex(d => d.name === delayName);
-        if (idx === -1)
-            throw new Error(`Delay "${delayName}" not found in mission`);
-        if (updates.name && updates.name !== delayName && doc.delays.some(d => d.name === updates.name)) {
-            throw new Error(`Delay "${updates.name}" already exists in this mission`);
-        }
-        doc.delays[idx] = { ...doc.delays[idx], ...updates };
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "delays", delays => {
+            const idx = delays.findIndex(d => d.name === delayName);
+            if (idx === -1)
+                throw new Error(`Delay "${delayName}" not found in mission`);
+            if (updates.name && updates.name !== delayName && delays.some(d => d.name === updates.name)) {
+                throw new Error(`Delay "${updates.name}" already exists in this mission`);
+            }
+            delays[idx] = { ...delays[idx], ...updates };
+        }, { missingError: `Delay "${delayName}" not found in mission` });
     }
     /** Remove a delay from the mission data (by name). */
     async removeMissionDelay(missionId, delayName) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.delays)
-            throw new Error(`Delay "${delayName}" not found in mission`);
-        const idx = doc.delays.findIndex(d => d.name === delayName);
-        if (idx === -1)
-            throw new Error(`Delay "${delayName}" not found in mission`);
-        doc.delays.splice(idx, 1);
-        if (doc.delays.length === 0)
-            delete doc.delays;
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "delays", delays => {
+            const idx = delays.findIndex(d => d.name === delayName);
+            if (idx === -1)
+                throw new Error(`Delay "${delayName}" not found in mission`);
+            delays.splice(idx, 1);
+        }, { missingError: `Delay "${delayName}" not found in mission` });
     }
     // ─── Quality gate operations ────────────────────────
     /** Add a quality gate to a mission's data. */
     async addMissionQualityGate(missionId, gate) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.qualityGates)
-            doc.qualityGates = [];
-        if (doc.qualityGates.some(g => g.name === gate.name)) {
-            throw new Error(`Quality gate "${gate.name}" already exists in this mission`);
-        }
-        doc.qualityGates.push(gate);
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "qualityGates", gates => {
+            if (gates.some(g => g.name === gate.name)) {
+                throw new Error(`Quality gate "${gate.name}" already exists in this mission`);
+            }
+            gates.push(gate);
+        }, { createIfMissing: true });
     }
     /** Update a quality gate in the mission data (matched by name). */
     async updateMissionQualityGate(missionId, gateName, updates) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.qualityGates)
-            throw new Error(`Quality gate "${gateName}" not found in mission`);
-        const idx = doc.qualityGates.findIndex(g => g.name === gateName);
-        if (idx === -1)
-            throw new Error(`Quality gate "${gateName}" not found in mission`);
-        if (updates.name && updates.name !== gateName && doc.qualityGates.some(g => g.name === updates.name)) {
-            throw new Error(`Quality gate "${updates.name}" already exists in this mission`);
-        }
-        doc.qualityGates[idx] = { ...doc.qualityGates[idx], ...updates };
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "qualityGates", gates => {
+            const idx = gates.findIndex(g => g.name === gateName);
+            if (idx === -1)
+                throw new Error(`Quality gate "${gateName}" not found in mission`);
+            if (updates.name && updates.name !== gateName && gates.some(g => g.name === updates.name)) {
+                throw new Error(`Quality gate "${updates.name}" already exists in this mission`);
+            }
+            gates[idx] = { ...gates[idx], ...updates };
+        }, { missingError: `Quality gate "${gateName}" not found in mission` });
     }
     /** Remove a quality gate from the mission data (by name). */
     async removeMissionQualityGate(missionId, gateName) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.qualityGates)
-            throw new Error(`Quality gate "${gateName}" not found in mission`);
-        const idx = doc.qualityGates.findIndex(g => g.name === gateName);
-        if (idx === -1)
-            throw new Error(`Quality gate "${gateName}" not found in mission`);
-        doc.qualityGates.splice(idx, 1);
-        if (doc.qualityGates.length === 0)
-            delete doc.qualityGates;
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "qualityGates", gates => {
+            const idx = gates.findIndex(g => g.name === gateName);
+            if (idx === -1)
+                throw new Error(`Quality gate "${gateName}" not found in mission`);
+            gates.splice(idx, 1);
+        }, { missingError: `Quality gate "${gateName}" not found in mission` });
     }
     // ─── Team (volatile agents) operations ──────────────
     /** Add a team member to the mission's volatile team. */
     async addMissionTeamMember(missionId, member) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.team)
-            doc.team = [];
-        if (doc.team.some((m) => m.name === member.name)) {
-            throw new Error(`Team member "${member.name}" already exists in this mission`);
-        }
-        doc.team.push(member);
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "team", team => {
+            if (team.some((m) => m.name === member.name)) {
+                throw new Error(`Team member "${member.name}" already exists in this mission`);
+            }
+            team.push(member);
+        }, { createIfMissing: true });
     }
     /** Update a team member in the mission data (matched by name). */
     async updateMissionTeamMember(missionId, memberName, updates) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.team)
-            throw new Error(`Team member "${memberName}" not found in mission`);
-        const team = doc.team;
-        const idx = team.findIndex((m) => m.name === memberName);
-        if (idx === -1)
-            throw new Error(`Team member "${memberName}" not found in mission`);
-        if (updates.name && updates.name !== memberName && team.some((m) => m.name === updates.name)) {
-            throw new Error(`Team member "${updates.name}" already exists in this mission`);
-        }
-        team[idx] = { ...team[idx], ...updates };
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "team", team => {
+            const idx = team.findIndex((m) => m.name === memberName);
+            if (idx === -1)
+                throw new Error(`Team member "${memberName}" not found in mission`);
+            if (updates.name && updates.name !== memberName && team.some((m) => m.name === updates.name)) {
+                throw new Error(`Team member "${updates.name}" already exists in this mission`);
+            }
+            team[idx] = { ...team[idx], ...updates };
+        }, { missingError: `Team member "${memberName}" not found in mission` });
     }
     /** Remove a team member from the mission data (by name). */
     async removeMissionTeamMember(missionId, memberName) {
-        const { doc } = await this.parseMissionData(missionId);
-        if (!doc.team)
-            throw new Error(`Team member "${memberName}" not found in mission`);
-        const team = doc.team;
-        const idx = team.findIndex((m) => m.name === memberName);
-        if (idx === -1)
-            throw new Error(`Team member "${memberName}" not found in mission`);
-        team.splice(idx, 1);
-        if (team.length === 0)
-            delete doc.team;
-        return this.persistMissionData(missionId, doc);
+        return this.mutateMissionCollection(missionId, "team", team => {
+            const idx = team.findIndex((m) => m.name === memberName);
+            if (idx === -1)
+                throw new Error(`Team member "${memberName}" not found in mission`);
+            team.splice(idx, 1);
+        }, { missingError: `Team member "${memberName}" not found in mission` });
     }
     // ─── Notifications operations ───────────────────────
     /** Update the mission-level notification rules. */
@@ -922,7 +686,7 @@ export class MissionExecutor {
         return this.persistMissionData(missionId, doc);
     }
     async buildMissionReport(missionId, group, groupTasks, allPassed) {
-        const state = await this.ctx.registry.getState();
+        const state = await this.ctx.taskStore.getState();
         const processes = state?.processes ?? [];
         const allFilesCreated = new Set();
         const allFilesEdited = new Set();
@@ -974,23 +738,4 @@ export class MissionExecutor {
         };
     }
 }
-// ── ISO 8601 Duration Parser ──────────────────────────────────────────
-// Supports: P[nY][nM][nW][nD][T[nH][nM][nS]]
-// Examples: PT2H (2 hours), PT30M (30 min), P1D (1 day), P1DT6H (1 day 6 hours)
-const ISO_DURATION_RE = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
-function parseISO8601Duration(duration) {
-    const m = ISO_DURATION_RE.exec(duration);
-    if (!m)
-        throw new Error(`Invalid ISO 8601 duration: "${duration}"`);
-    const years = parseInt(m[1] || "0", 10);
-    const months = parseInt(m[2] || "0", 10);
-    const weeks = parseInt(m[3] || "0", 10);
-    const days = parseInt(m[4] || "0", 10);
-    const hours = parseInt(m[5] || "0", 10);
-    const minutes = parseInt(m[6] || "0", 10);
-    const seconds = parseFloat(m[7] || "0");
-    // Approximate: 1 year ≈ 365.25 days, 1 month ≈ 30.44 days
-    const totalDays = years * 365.25 + months * 30.44 + weeks * 7 + days;
-    return ((totalDays * 24 + hours) * 60 + minutes) * 60000 + seconds * 1000;
-}
 //# sourceMappingURL=mission-executor.js.map