pulseed 0.6.5 → 0.6.6

package/dist/runtime/store/goal-task-state-store.js

@@ -0,0 +1,992 @@
+import { randomUUID } from "node:crypto";
+import { openControlDatabase, } from "./control-db/index.js";
+import { GoalSchema, GoalTreeSchema } from "../../base/types/goal.js";
+import { ObservationLogEntrySchema, ObservationLogSchema } from "../../base/types/state.js";
+import { GapHistoryEntrySchema } from "../../base/types/gap.js";
+import { TaskSchema } from "../../base/types/task.js";
+import { CheckpointSchema, LoopCheckpointSchema } from "../../base/types/checkpoint.js";
+import { PipelineStateSchema } from "../../base/types/pipeline.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+const GOAL_STATE_WRITE_LOCK_TIMEOUT_MS = 5_000;
+const GOAL_STATE_WRITE_LOCK_LEASE_MS = 30_000;
+const GOAL_STATE_WRITE_LOCK_RETRY_MS = 25;
+function parseJson(value) {
+    return JSON.parse(value);
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function normalizeRawGoal(goalId, data) {
+    const object = asObject(data);
+    if (!object) {
+        throw new Error("Goal raw state must be an object.");
+    }
+    const timestamp = typeof object["updated_at"] === "string"
+        ? object["updated_at"]
+        : typeof object["created_at"] === "string"
+            ? object["created_at"]
+            : nowIso();
+    const dimensions = Array.isArray(object["dimensions"])
+        ? object["dimensions"].map((dimension, index) => {
+            const dimensionObject = asObject(dimension) ?? {};
+            const name = typeof dimensionObject["name"] === "string" && dimensionObject["name"].length > 0
+                ? dimensionObject["name"]
+                : `dimension-${index + 1}`;
+            const observationMethod = asObject(dimensionObject["observation_method"]);
+            return {
+                ...dimensionObject,
+                name,
+                label: typeof dimensionObject["label"] === "string" ? dimensionObject["label"] : name,
+                current_value: Object.hasOwn(dimensionObject, "current_value") ? dimensionObject["current_value"] : null,
+                threshold: asObject(dimensionObject["threshold"]) ?? { type: "present" },
+                confidence: typeof dimensionObject["confidence"] === "number" ? dimensionObject["confidence"] : 0.5,
+                observation_method: observationMethod ?? {
+                    type: "manual",
+                    source: "legacy-raw-goal-write",
+                    schedule: null,
+                    endpoint: null,
+                    confidence_tier: "self_report",
+                },
+                last_updated: typeof dimensionObject["last_updated"] === "string" ? dimensionObject["last_updated"] : null,
+                history: Array.isArray(dimensionObject["history"]) ? dimensionObject["history"] : [],
+            };
+        })
+        : [];
+    return GoalSchema.parse({
+        ...object,
+        id: typeof object["id"] === "string" && object["id"].length > 0 ? object["id"] : goalId,
+        title: typeof object["title"] === "string" && object["title"].length > 0 ? object["title"] : goalId,
+        dimensions,
+        created_at: typeof object["created_at"] === "string" ? object["created_at"] : timestamp,
+        updated_at: timestamp,
+    });
+}
+function stripJsonExtension(name) {
+    return name.endsWith(".json") ? name.slice(0, -".json".length) : null;
+}
+function normalizeRelativePath(relativePath) {
+    return relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function parseRawPath(relativePath) {
+    const parts = normalizeRelativePath(relativePath).split("/").filter(Boolean);
+    if (parts.length === 0)
+        return null;
+    if (parts[0] === "goals" && parts.length === 3) {
+        const goalId = parts[1];
+        if (parts[2] === "goal.json")
+            return { kind: "goal", goalId };
+        if (parts[2] === "observations.json")
+            return { kind: "observation_log", goalId };
+        if (parts[2] === "gap-history.json")
+            return { kind: "gap_history", goalId };
+        if (parts[2] === "checkpoint.json")
+            return { kind: "loop_checkpoint", goalId };
+    }
+    if (parts[0] === "goal-trees" && parts.length === 2) {
+        const rootId = stripJsonExtension(parts[1]);
+        return rootId ? { kind: "goal_tree", rootId } : null;
+    }
+    if (parts[0] === "tasks" && parts.length >= 3) {
+        const goalId = parts[1];
+        if (parts.length === 3 && parts[2] === "task-history.json") {
+            return { kind: "task_history", goalId };
+        }
+        if (parts.length === 3 && parts[2] === "last-failure-context.json") {
+            return { kind: "task_failure_context", goalId };
+        }
+        if (parts.length === 4 && parts[2] === "ledger") {
+            const taskId = stripJsonExtension(parts[3]);
+            return taskId ? { kind: "task_outcome_ledger", goalId, taskId } : null;
+        }
+        if (parts.length === 3) {
+            const taskId = stripJsonExtension(parts[2]);
+            return taskId ? { kind: "task", goalId, taskId } : null;
+        }
+    }
+    if (parts[0] === "verification" && parts.length === 3 && parts[2] === "verification-result.json") {
+        return { kind: "task_verification_result", taskId: parts[1] };
+    }
+    if (parts[0] === "checkpoints" && parts.length === 3) {
+        const goalId = parts[1];
+        if (parts[2] === "index.json")
+            return { kind: "checkpoint_index", goalId };
+        const checkpointId = stripJsonExtension(parts[2]);
+        return checkpointId ? { kind: "checkpoint", goalId, checkpointId } : null;
+    }
+    if (parts[0] === "pipelines" && parts.length === 2) {
+        const taskId = stripJsonExtension(parts[1]);
+        return taskId ? { kind: "pipeline", taskId } : null;
+    }
+    return null;
+}
+export class GoalTaskStateStore {
+    baseDir;
+    options;
+    dbPromise = null;
+    constructor(baseDir, options = {}) {
+        this.baseDir = baseDir;
+        this.options = options;
+    }
+    async ensureReady() {
+        await this.database();
+    }
+    async withGoalStateWriteLock(goalId, work) {
+        const release = await this.acquireGoalStateWriteLock(goalId);
+        try {
+            return await work();
+        }
+        finally {
+            release();
+        }
+    }
+    async saveGoal(goal) {
+        const parsed = GoalSchema.parse(goal);
+        const db = await this.database();
+        db.transaction((sqlite) => upsertGoal(sqlite, parsed, 0));
+        return parsed;
+    }
+    async saveArchivedGoal(goal) {
+        const parsed = GoalSchema.parse({ ...goal, status: "archived" });
+        const db = await this.database();
+        db.transaction((sqlite) => upsertGoal(sqlite, parsed, 1));
+        return parsed;
+    }
+    async loadGoal(goalId, options = {}) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT goal_json
+        FROM goal_records
+        WHERE goal_id = ?
+          AND (? = 1 OR archived = 0)
+      `).get(goalId, options.includeArchived === false ? 0 : 1);
+            return row ? GoalSchema.parse(parseJson(row.goal_json)) : null;
+        });
+    }
+    async goalExists(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT 1 AS exists_flag
+        FROM goal_records
+        WHERE goal_id = ? AND archived = 0
+      `).get(goalId);
+            return row !== undefined;
+        });
+    }
+    async listGoalIds(options = {}) {
+        const archived = options.archived === true ? 1 : 0;
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT goal_id
+        FROM goal_records
+        WHERE archived = ?
+        ORDER BY updated_at ASC, goal_id ASC
+      `).all(archived);
+            return rows.map((row) => row.goal_id);
+        });
+    }
+    async markGoalArchived(goalId) {
+        const db = await this.database();
+        return db.transaction((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT goal_json
+        FROM goal_records
+        WHERE goal_id = ? AND archived = 0
+      `).get(goalId);
+            if (!row) {
+                return false;
+            }
+            const timestamp = nowIso();
+            const goal = GoalSchema.parse(parseJson(row.goal_json));
+            const archivedGoal = GoalSchema.parse({ ...goal, status: "archived", updated_at: timestamp });
+            const result = sqlite.prepare(`
+        UPDATE goal_records
+        SET archived = 1,
+            status = 'archived',
+            updated_at = ?,
+            goal_json = json(?)
+        WHERE goal_id = ? AND archived = 0
+      `).run(timestamp, JSON.stringify(archivedGoal), goalId);
+            return result.changes > 0;
+        });
+    }
+    async deleteGoal(goalId) {
+        const db = await this.database();
+        return db.transaction((sqlite) => {
+            const result = sqlite.prepare("DELETE FROM goal_records WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM goal_observation_logs WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM goal_gap_histories WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM goal_loop_checkpoints WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM goal_stall_records WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM task_records WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM task_history_records WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM task_outcome_events WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM task_outcome_summaries WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM task_failure_contexts WHERE goal_id = ?").run(goalId);
+            sqlite.prepare("DELETE FROM task_checkpoints WHERE goal_id = ?").run(goalId);
+            return result.changes > 0;
+        });
+    }
+    async saveGoalTree(tree) {
+        const parsed = GoalTreeSchema.parse(tree);
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            sqlite.prepare(`
+        INSERT INTO goal_tree_records (root_id, updated_at, tree_json)
+        VALUES (?, ?, json(?))
+        ON CONFLICT(root_id) DO UPDATE SET
+          updated_at = excluded.updated_at,
+          tree_json = excluded.tree_json
+      `).run(parsed.root_id, nowIso(), JSON.stringify(parsed));
+        });
+        return parsed;
+    }
+    async loadGoalTree(rootId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT tree_json
+        FROM goal_tree_records
+        WHERE root_id = ?
+      `).get(rootId);
+            return row ? GoalTreeSchema.parse(parseJson(row.tree_json)) : null;
+        });
+    }
+    async deleteGoalTree(rootId) {
+        const db = await this.database();
+        return db.transaction((sqlite) => sqlite.prepare("DELETE FROM goal_tree_records WHERE root_id = ?").run(rootId).changes > 0);
+    }
+    async saveObservationLog(log) {
+        const parsed = ObservationLogSchema.parse(log);
+        const db = await this.database();
+        db.transaction((sqlite) => upsertObservationLog(sqlite, parsed));
+        return parsed;
+    }
+    async loadObservationLog(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT log_json
+        FROM goal_observation_logs
+        WHERE goal_id = ?
+      `).get(goalId);
+            return row ? ObservationLogSchema.parse(parseJson(row.log_json)) : null;
+        });
+    }
+    async appendObservation(goalId, entry, maxEntries) {
+        const parsed = ObservationLogEntrySchema.parse(entry);
+        const db = await this.database();
+        return db.transaction((sqlite) => {
+            const current = readObservationLog(sqlite, goalId) ?? { goal_id: goalId, entries: [] };
+            const next = ObservationLogSchema.parse({
+                ...current,
+                entries: [...current.entries, parsed].slice(-maxEntries),
+            });
+            upsertObservationLog(sqlite, next);
+            return next;
+        });
+    }
+    async saveGapHistory(goalId, history) {
+        const parsed = history.map((entry) => GapHistoryEntrySchema.parse(entry));
+        const db = await this.database();
+        db.transaction((sqlite) => upsertGapHistory(sqlite, goalId, parsed));
+        return parsed;
+    }
+    async loadGapHistory(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => readGapHistory(sqlite, goalId));
+    }
+    async appendGapHistoryEntry(goalId, entry, maxEntries) {
+        const parsed = GapHistoryEntrySchema.parse(entry);
+        const db = await this.database();
+        return db.transaction((sqlite) => {
+            const next = [...readGapHistory(sqlite, goalId), parsed].slice(-maxEntries);
+            upsertGapHistory(sqlite, goalId, next);
+            return next;
+        });
+    }
+    async saveTask(task) {
+        const parsed = TaskSchema.parse(task);
+        const db = await this.database();
+        db.transaction((sqlite) => upsertTask(sqlite, parsed));
+        return parsed;
+    }
+    async loadTask(goalId, taskId) {
+        const db = await this.database();
+        return db.read((sqlite) => readTask(sqlite, goalId, taskId));
+    }
+    async listTasks(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT task_json
+        FROM task_records
+        WHERE goal_id = ?
+        ORDER BY created_at DESC, task_id ASC
+      `).all(goalId);
+            return rows.map((row) => TaskSchema.parse(parseJson(row.task_json)));
+        });
+    }
+    async listTasksByStatus(status) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT task_json
+        FROM task_records
+        WHERE status = ?
+        ORDER BY updated_at ASC, goal_id ASC, task_id ASC
+      `).all(status);
+            return rows.map((row) => TaskSchema.parse(parseJson(row.task_json)));
+        });
+    }
+    async deleteTask(goalId, taskId) {
+        const db = await this.database();
+        return db.transaction((sqlite) => {
+            const result = sqlite.prepare("DELETE FROM task_records WHERE goal_id = ? AND task_id = ?").run(goalId, taskId);
+            sqlite.prepare("DELETE FROM task_outcome_events WHERE goal_id = ? AND task_id = ?").run(goalId, taskId);
+            sqlite.prepare("DELETE FROM task_outcome_summaries WHERE goal_id = ? AND task_id = ?").run(goalId, taskId);
+            sqlite.prepare("DELETE FROM task_checkpoints WHERE goal_id = ? AND task_id = ?").run(goalId, taskId);
+            return result.changes > 0;
+        });
+    }
+    async saveTaskHistory(goalId, history) {
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            sqlite.prepare("DELETE FROM task_history_records WHERE goal_id = ?").run(goalId);
+            const insert = sqlite.prepare(`
+        INSERT INTO task_history_records (goal_id, task_id, sort_order, updated_at, record_json)
+        VALUES (@goal_id, @task_id, @sort_order, @updated_at, json(@record_json))
+      `);
+            history.forEach((record, index) => {
+                const object = asObject(record);
+                insert.run({
+                    goal_id: goalId,
+                    task_id: typeof object?.["task_id"] === "string"
+                        ? object["task_id"]
+                        : typeof object?.["id"] === "string"
+                            ? object["id"]
+                            : null,
+                    sort_order: index,
+                    updated_at: nowIso(),
+                    record_json: JSON.stringify(record),
+                });
+            });
+        });
+        return history;
+    }
+    async loadTaskHistory(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT record_json
+        FROM task_history_records
+        WHERE goal_id = ?
+        ORDER BY sort_order ASC, history_id ASC
+      `).all(goalId);
+            return rows.map((row) => parseJson(row.record_json));
+        });
+    }
+    async saveTaskOutcomeLedger(record) {
+        const events = Array.isArray(record.events) ? record.events : [];
+        const summary = asObject(record.summary) ?? {};
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            sqlite.prepare("DELETE FROM task_outcome_events WHERE goal_id = ? AND task_id = ?").run(record.goal_id, record.task_id);
+            const insertEvent = sqlite.prepare(`
+        INSERT INTO task_outcome_events (goal_id, task_id, event_index, event_type, occurred_at, event_json)
+        VALUES (@goal_id, @task_id, @event_index, @event_type, @occurred_at, json(@event_json))
+      `);
+            events.forEach((event, index) => {
+                const eventObject = asObject(event) ?? {};
+                insertEvent.run({
+                    goal_id: record.goal_id,
+                    task_id: record.task_id,
+                    event_index: index,
+                    event_type: typeof eventObject["type"] === "string" ? eventObject["type"] : "unknown",
+                    occurred_at: typeof eventObject["ts"] === "string" ? eventObject["ts"] : nowIso(),
+                    event_json: JSON.stringify(event),
+                });
+            });
+            sqlite.prepare(`
+        INSERT INTO task_outcome_summaries (
+          goal_id, task_id, latest_event_type, latest_event_at,
+          task_status, tokens_used, updated_at, summary_json
+        )
+        VALUES (
+          @goal_id, @task_id, @latest_event_type, @latest_event_at,
+          @task_status, @tokens_used, @updated_at, json(@summary_json)
+        )
+        ON CONFLICT(goal_id, task_id) DO UPDATE SET
+          latest_event_type = excluded.latest_event_type,
+          latest_event_at = excluded.latest_event_at,
+          task_status = excluded.task_status,
+          tokens_used = excluded.tokens_used,
+          updated_at = excluded.updated_at,
+          summary_json = excluded.summary_json
+      `).run({
+                goal_id: record.goal_id,
+                task_id: record.task_id,
+                latest_event_type: typeof summary["latest_event_type"] === "string" ? summary["latest_event_type"] : null,
+                latest_event_at: typeof summary["latest_event_at"] === "string" ? summary["latest_event_at"] : null,
+                task_status: typeof summary["task_status"] === "string" ? summary["task_status"] : "unknown",
+                tokens_used: typeof summary["tokens_used"] === "number" ? Math.max(0, Math.trunc(summary["tokens_used"])) : 0,
+                updated_at: nowIso(),
+                summary_json: JSON.stringify(summary),
+            });
+        });
+        return { ...record, events, summary };
+    }
+    async loadTaskOutcomeLedger(goalId, taskId) {
+        const db = await this.database();
+        return db.read((sqlite) => readTaskOutcomeLedger(sqlite, goalId, taskId));
+    }
+    async deleteTaskOutcomeLedger(goalId, taskId) {
+        const db = await this.database();
+        return db.transaction((sqlite) => {
+            sqlite.prepare("DELETE FROM task_outcome_events WHERE goal_id = ? AND task_id = ?").run(goalId, taskId);
+            return sqlite.prepare("DELETE FROM task_outcome_summaries WHERE goal_id = ? AND task_id = ?").run(goalId, taskId).changes > 0;
+        });
+    }
+    async listTaskOutcomeLedgers() {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT goal_id, task_id
+        FROM task_outcome_summaries
+        ORDER BY goal_id ASC, task_id ASC
+      `).all();
+            return rows
+                .map((row) => readTaskOutcomeLedger(sqlite, row.goal_id, row.task_id))
+                .filter((record) => record !== null);
+        });
+    }
+    async saveTaskFailureContext(goalId, context) {
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            if (context === null) {
+                sqlite.prepare("DELETE FROM task_failure_contexts WHERE goal_id = ?").run(goalId);
+                return;
+            }
+            sqlite.prepare(`
+        INSERT INTO task_failure_contexts (goal_id, updated_at, context_json)
+        VALUES (?, ?, json(?))
+        ON CONFLICT(goal_id) DO UPDATE SET
+          updated_at = excluded.updated_at,
+          context_json = excluded.context_json
+      `).run(goalId, nowIso(), JSON.stringify(context));
+        });
+    }
+    async loadTaskFailureContext(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT context_json
+        FROM task_failure_contexts
+        WHERE goal_id = ?
+      `).get(goalId);
+            return row ? parseJson(row.context_json) : null;
+        });
+    }
+    async saveTaskVerificationResult(taskId, result) {
+        if (result === null) {
+            const db = await this.database();
+            db.transaction((sqlite) => sqlite.prepare("DELETE FROM task_verification_results WHERE task_id = ?").run(taskId));
+            return;
+        }
+        const object = asObject(result);
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            sqlite.prepare(`
+        INSERT INTO task_verification_results (
+          task_id, goal_id, verdict, result_timestamp, updated_at, result_json
+        )
+        VALUES (
+          @task_id, @goal_id, @verdict, @result_timestamp, @updated_at, json(@result_json)
+        )
+        ON CONFLICT(task_id) DO UPDATE SET
+          goal_id = excluded.goal_id,
+          verdict = excluded.verdict,
+          result_timestamp = excluded.result_timestamp,
+          updated_at = excluded.updated_at,
+          result_json = excluded.result_json
+      `).run({
+                task_id: typeof object?.["task_id"] === "string" ? object["task_id"] : taskId,
+                goal_id: typeof object?.["goal_id"] === "string" ? object["goal_id"] : null,
+                verdict: typeof object?.["verdict"] === "string" ? object["verdict"] : null,
+                result_timestamp: typeof object?.["timestamp"] === "string" ? object["timestamp"] : null,
+                updated_at: nowIso(),
+                result_json: JSON.stringify(result),
+            });
+        });
+    }
+    async loadTaskVerificationResult(taskId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT result_json
+        FROM task_verification_results
+        WHERE task_id = ?
+      `).get(taskId);
+            return row ? parseJson(row.result_json) : null;
+        });
+    }
+    async saveCheckpoint(checkpoint) {
+        const parsed = CheckpointSchema.parse(checkpoint);
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            sqlite.prepare(`
+        INSERT INTO task_checkpoints (
+          checkpoint_id, goal_id, task_id, agent_id, created_at, checkpoint_json
+        )
+        VALUES (?, ?, ?, ?, ?, json(?))
+        ON CONFLICT(checkpoint_id) DO UPDATE SET
+          goal_id = excluded.goal_id,
+          task_id = excluded.task_id,
+          agent_id = excluded.agent_id,
+          created_at = excluded.created_at,
+          checkpoint_json = excluded.checkpoint_json
+      `).run(parsed.checkpoint_id, parsed.goal_id, parsed.task_id, parsed.agent_id, parsed.created_at, JSON.stringify(parsed));
+        });
+        return parsed;
+    }
+    async loadCheckpoint(checkpointId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT checkpoint_json
+        FROM task_checkpoints
+        WHERE checkpoint_id = ?
+      `).get(checkpointId);
+            return row ? CheckpointSchema.parse(parseJson(row.checkpoint_json)) : null;
+        });
+    }
+    async listCheckpointEntries(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT checkpoint_id, task_id, agent_id, created_at
+        FROM task_checkpoints
+        WHERE goal_id = ?
+        ORDER BY created_at ASC, checkpoint_id ASC
+      `).all(goalId);
+            return rows;
+        });
+    }
+    async loadLatestCheckpoint(goalId, taskId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = taskId
+                ? sqlite.prepare(`
+            SELECT checkpoint_json
+            FROM task_checkpoints
+            WHERE goal_id = ? AND task_id = ?
+            ORDER BY created_at DESC, checkpoint_id DESC
+            LIMIT 1
+          `).get(goalId, taskId)
+                : sqlite.prepare(`
+            SELECT checkpoint_json
+            FROM task_checkpoints
+            WHERE goal_id = ?
+            ORDER BY created_at DESC, checkpoint_id DESC
+            LIMIT 1
+          `).get(goalId);
+            const typed = row;
+            return typed ? CheckpointSchema.parse(parseJson(typed.checkpoint_json)) : null;
+        });
+    }
+    async deleteCheckpoint(goalId, checkpointId) {
+        const db = await this.database();
+        return db.transaction((sqlite) => sqlite.prepare("DELETE FROM task_checkpoints WHERE goal_id = ? AND checkpoint_id = ?").run(goalId, checkpointId).changes > 0);
+    }
+    async garbageCollectCheckpoints(goalId, cutoffMs) {
+        const db = await this.database();
+        return db.transaction((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT checkpoint_id, created_at
+        FROM task_checkpoints
+        WHERE goal_id = ?
+      `).all(goalId);
+            const toDelete = rows.filter((row) => {
+                const createdMs = Date.parse(row.created_at);
+                return Number.isFinite(createdMs) && createdMs < cutoffMs;
+            });
+            const deleteStmt = sqlite.prepare("DELETE FROM task_checkpoints WHERE goal_id = ? AND checkpoint_id = ?");
+            for (const row of toDelete) {
+                deleteStmt.run(goalId, row.checkpoint_id);
+            }
+            return toDelete.length;
+        });
+    }
+    async saveLoopCheckpoint(goalId, checkpoint, adapterType) {
+        const parsed = LoopCheckpointSchema.parse(checkpoint);
+        await this.saveLoopCheckpointRaw(goalId, parsed, adapterType);
+        return parsed;
+    }
+    async saveLoopCheckpointRaw(goalId, checkpoint, adapterType) {
+        const object = asObject(checkpoint);
+        const cycleNumber = typeof object?.["cycle_number"] === "number" && object["cycle_number"] >= 0
+            ? Math.trunc(object["cycle_number"])
+            : 0;
+        const timestamp = typeof object?.["timestamp"] === "string" ? object["timestamp"] : nowIso();
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            sqlite.prepare(`
+        INSERT INTO goal_loop_checkpoints (
+          goal_id, adapter_type, cycle_number, updated_at, checkpoint_json
+        )
+        VALUES (?, ?, ?, ?, json(?))
+        ON CONFLICT(goal_id) DO UPDATE SET
+          adapter_type = excluded.adapter_type,
+          cycle_number = excluded.cycle_number,
+          updated_at = excluded.updated_at,
+          checkpoint_json = excluded.checkpoint_json
+      `).run(goalId, adapterType ?? null, cycleNumber, timestamp, JSON.stringify(checkpoint));
+        });
+    }
+    async loadLoopCheckpoint(goalId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT checkpoint_json
+        FROM goal_loop_checkpoints
+        WHERE goal_id = ?
+      `).get(goalId);
+            return row ? LoopCheckpointSchema.parse(parseJson(row.checkpoint_json)) : null;
+        });
+    }
+    async savePipeline(taskId, state) {
+        const parsed = PipelineStateSchema.parse(state);
+        const db = await this.database();
+        db.transaction((sqlite) => {
+            sqlite.prepare(`
+        INSERT INTO pipeline_state_records (
+          task_id, pipeline_id, status, current_stage_index, started_at, updated_at, pipeline_json
+        )
+        VALUES (?, ?, ?, ?, ?, ?, json(?))
+        ON CONFLICT(task_id) DO UPDATE SET
+          pipeline_id = excluded.pipeline_id,
+          status = excluded.status,
+          current_stage_index = excluded.current_stage_index,
+          started_at = excluded.started_at,
+          updated_at = excluded.updated_at,
+          pipeline_json = excluded.pipeline_json
+      `).run(taskId, parsed.pipeline_id, parsed.status, parsed.current_stage_index, parsed.started_at, parsed.updated_at, JSON.stringify(parsed));
+        });
+        return parsed;
+    }
+    async loadPipeline(taskId) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const row = sqlite.prepare(`
+        SELECT pipeline_json
+        FROM pipeline_state_records
+        WHERE task_id = ?
+      `).get(taskId);
+            return row ? PipelineStateSchema.parse(parseJson(row.pipeline_json)) : null;
+        });
+    }
+    async listPipelinesByStatus(status) {
+        const db = await this.database();
+        return db.read((sqlite) => {
+            const rows = sqlite.prepare(`
+        SELECT pipeline_json
+        FROM pipeline_state_records
+        WHERE status = ?
+        ORDER BY updated_at ASC, task_id ASC
+      `).all(status);
+            return rows.map((row) => PipelineStateSchema.parse(parseJson(row.pipeline_json)));
+        });
+    }
+    async readRawPath(relativePath) {
+        const match = parseRawPath(relativePath);
+        if (!match)
+            return { handled: false, value: null };
+        switch (match.kind) {
+            case "goal":
+                return { handled: true, value: await this.loadGoal(match.goalId, { includeArchived: true }) };
+            case "goal_tree":
+                return { handled: true, value: await this.loadGoalTree(match.rootId) };
+            case "observation_log":
+                return { handled: true, value: await this.loadObservationLog(match.goalId) };
+            case "gap_history":
+                return { handled: true, value: await this.loadGapHistory(match.goalId) };
+            case "loop_checkpoint":
+                return { handled: true, value: await this.loadLoopCheckpoint(match.goalId) };
+            case "task":
+                return { handled: true, value: await this.loadTask(match.goalId, match.taskId) };
+            case "task_history":
+                return { handled: true, value: await this.loadTaskHistory(match.goalId) };
+            case "task_outcome_ledger":
+                return { handled: true, value: await this.loadTaskOutcomeLedger(match.goalId, match.taskId) };
+            case "task_failure_context":
+                return { handled: true, value: await this.loadTaskFailureContext(match.goalId) };
+            case "task_verification_result":
+                return { handled: true, value: await this.loadTaskVerificationResult(match.taskId) };
+            case "checkpoint_index":
+                return {
+                    handled: true,
+                    value: { goal_id: match.goalId, checkpoints: await this.listCheckpointEntries(match.goalId) },
+                };
+            case "checkpoint":
+                return { handled: true, value: await this.loadCheckpoint(match.checkpointId) };
+            case "pipeline":
+                return { handled: true, value: await this.loadPipeline(match.taskId) };
+        }
+    }
+    async writeRawPath(relativePath, data) {
+        const match = parseRawPath(relativePath);
+        if (!match)
+            return false;
+        switch (match.kind) {
+            case "goal":
+                if (data === null) {
+                    await this.deleteGoal(match.goalId);
+                }
+                else {
+                    await this.saveGoal(normalizeRawGoal(match.goalId, data));
+                }
+                return true;
+            case "goal_tree":
+                if (data === null) {
+                    await this.deleteGoalTree(match.rootId);
+                }
+                else {
+                    await this.saveGoalTree(GoalTreeSchema.parse(data));
+                }
+                return true;
+            case "observation_log":
+                if (data === null) {
+                    await this.saveObservationLog({ goal_id: match.goalId, entries: [] });
+                }
+                else {
+                    await this.saveObservationLog(ObservationLogSchema.parse(data));
+                }
+                return true;
+            case "gap_history":
+                await this.saveGapHistory(match.goalId, Array.isArray(data) ? data : []);
+                return true;
+            case "loop_checkpoint":
+                if (data !== null) {
+                    await this.saveLoopCheckpointRaw(match.goalId, data);
+                }
+                return true;
+            case "task":
+                if (data === null) {
+                    await this.deleteTask(match.goalId, match.taskId);
+                }
+                else {
+                    await this.saveTask(TaskSchema.parse(data));
+                }
+                return true;
+            case "task_history":
+                await this.saveTaskHistory(match.goalId, Array.isArray(data) ? data : []);
+                return true;
+            case "task_outcome_ledger": {
+                if (data === null) {
+                    await this.deleteTaskOutcomeLedger(match.goalId, match.taskId);
+                }
+                else {
+                    const record = asObject(data);
+                    if (!record)
+                        throw new Error("Task outcome ledger must be an object.");
+                    await this.saveTaskOutcomeLedger({
+                        task_id: typeof record["task_id"] === "string" ? record["task_id"] : match.taskId,
+                        goal_id: typeof record["goal_id"] === "string" ? record["goal_id"] : match.goalId,
+                        events: Array.isArray(record["events"]) ? record["events"] : [],
+                        summary: asObject(record["summary"]) ?? {},
+                    });
+                }
+                return true;
+            }
+            case "task_failure_context":
+                await this.saveTaskFailureContext(match.goalId, data);
+                return true;
+            case "task_verification_result":
+                await this.saveTaskVerificationResult(match.taskId, data);
+                return true;
+            case "checkpoint_index":
+                return true;
+            case "checkpoint":
+                if (data === null) {
+                    await this.deleteCheckpoint(match.goalId, match.checkpointId);
+                }
+                else {
+                    await this.saveCheckpoint(CheckpointSchema.parse(data));
+                }
+                return true;
+            case "pipeline":
+                if (data !== null) {
+                    await this.savePipeline(match.taskId, PipelineStateSchema.parse(data));
+                }
+                return true;
+        }
+    }
+    async database() {
+        if (this.options.controlDb) {
+            return this.options.controlDb;
+        }
+        this.dbPromise ??= openControlDatabase({
+            baseDir: this.options.controlBaseDir ?? this.baseDir,
+            dbPath: this.options.controlDbPath,
+        });
+        return this.dbPromise;
+    }
+    async acquireGoalStateWriteLock(goalId) {
+        const db = await this.database();
+        const ownerToken = randomUUID();
+        const startedAt = Date.now();
+        while (true) {
+            const acquired = db.transaction((sqlite) => {
+                const now = Date.now();
+                sqlite.prepare(`
+          DELETE FROM goal_state_write_locks
+          WHERE goal_id = ? AND lease_until <= ?
+        `).run(goalId, now);
+                const result = sqlite.prepare(`
+          INSERT OR IGNORE INTO goal_state_write_locks (
+            goal_id,
+            owner_token,
+            owner_pid,
+            acquired_at,
+            lease_until
+          )
+          VALUES (?, ?, ?, ?, ?)
+        `).run(goalId, ownerToken, process.pid, now, now + GOAL_STATE_WRITE_LOCK_LEASE_MS);
+                return result.changes === 1;
+            });
+            if (acquired) {
+                return () => {
+                    db.transaction((sqlite) => {
+                        sqlite.prepare(`
+              DELETE FROM goal_state_write_locks
+              WHERE goal_id = ? AND owner_token = ?
+            `).run(goalId, ownerToken);
+                    });
+                };
+            }
+            if (Date.now() - startedAt >= GOAL_STATE_WRITE_LOCK_TIMEOUT_MS) {
+                throw new Error(`Timed out waiting for goal state write lock in control DB for "${goalId}"`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, GOAL_STATE_WRITE_LOCK_RETRY_MS));
+        }
+    }
+}
+function upsertGoal(sqlite, goal, archived) {
+    sqlite.prepare(`
+    INSERT INTO goal_records (goal_id, parent_goal_id, status, updated_at, archived, goal_json)
+    VALUES (?, ?, ?, ?, ?, json(?))
+    ON CONFLICT(goal_id) DO UPDATE SET
+      parent_goal_id = excluded.parent_goal_id,
+      status = excluded.status,
+      updated_at = excluded.updated_at,
+      archived = excluded.archived,
+      goal_json = excluded.goal_json
+  `).run(goal.id, goal.parent_id ?? null, goal.status, goal.updated_at, archived, JSON.stringify(goal));
+}
+function readObservationLog(sqlite, goalId) {
+    const row = sqlite.prepare(`
+    SELECT log_json
+    FROM goal_observation_logs
+    WHERE goal_id = ?
+  `).get(goalId);
+    return row ? ObservationLogSchema.parse(parseJson(row.log_json)) : null;
+}
+function upsertObservationLog(sqlite, log) {
+    sqlite.prepare(`
+    INSERT INTO goal_observation_logs (goal_id, updated_at, log_json)
+    VALUES (?, ?, json(?))
+    ON CONFLICT(goal_id) DO UPDATE SET
+      updated_at = excluded.updated_at,
+      log_json = excluded.log_json
+  `).run(log.goal_id, nowIso(), JSON.stringify(log));
+}
+function readGapHistory(sqlite, goalId) {
+    const row = sqlite.prepare(`
+    SELECT history_json
+    FROM goal_gap_histories
+    WHERE goal_id = ?
+  `).get(goalId);
+    if (!row)
+        return [];
+    const parsed = parseJson(row.history_json);
+    return Array.isArray(parsed)
+        ? parsed.map((entry) => GapHistoryEntrySchema.parse(entry))
+        : [];
+}
+function upsertGapHistory(sqlite, goalId, history) {
+    sqlite.prepare(`
+    INSERT INTO goal_gap_histories (goal_id, updated_at, history_json)
+    VALUES (?, ?, json(?))
+    ON CONFLICT(goal_id) DO UPDATE SET
+      updated_at = excluded.updated_at,
+      history_json = excluded.history_json
+  `).run(goalId, nowIso(), JSON.stringify(history));
+}
+function upsertTask(sqlite, task) {
+    sqlite.prepare(`
+    INSERT INTO task_records (
+      goal_id, task_id, status, primary_dimension, strategy_id,
+      created_at, started_at, completed_at, updated_at, task_json
+    )
+    VALUES (
+      @goal_id, @task_id, @status, @primary_dimension, @strategy_id,
+      @created_at, @started_at, @completed_at, @updated_at, json(@task_json)
+    )
+    ON CONFLICT(goal_id, task_id) DO UPDATE SET
+      status = excluded.status,
+      primary_dimension = excluded.primary_dimension,
+      strategy_id = excluded.strategy_id,
+      created_at = excluded.created_at,
+      started_at = excluded.started_at,
+      completed_at = excluded.completed_at,
+      updated_at = excluded.updated_at,
+      task_json = excluded.task_json
+  `).run({
+        goal_id: task.goal_id,
+        task_id: task.id,
+        status: task.status,
+        primary_dimension: task.primary_dimension,
+        strategy_id: task.strategy_id ?? null,
+        created_at: task.created_at,
+        started_at: task.started_at ?? null,
+        completed_at: task.completed_at ?? null,
+        updated_at: task.completed_at ?? task.started_at ?? task.created_at,
+        task_json: JSON.stringify(task),
+    });
+}
+function readTask(sqlite, goalId, taskId) {
+    const row = sqlite.prepare(`
+    SELECT task_json
+    FROM task_records
+    WHERE goal_id = ? AND task_id = ?
+  `).get(goalId, taskId);
+    return row ? TaskSchema.parse(parseJson(row.task_json)) : null;
+}
+function readTaskOutcomeLedger(sqlite, goalId, taskId) {
+    const summaryRow = sqlite.prepare(`
+    SELECT summary_json
+    FROM task_outcome_summaries
+    WHERE goal_id = ? AND task_id = ?
+  `).get(goalId, taskId);
+    if (!summaryRow)
+        return null;
+    const eventRows = sqlite.prepare(`
+    SELECT event_json
+    FROM task_outcome_events
+    WHERE goal_id = ? AND task_id = ?
+    ORDER BY event_index ASC
+  `).all(goalId, taskId);
+    return {
+        goal_id: goalId,
+        task_id: taskId,
+        events: eventRows.map((row) => parseJson(row.event_json)),
+        summary: parseJson(summaryRow.summary_json),
+    };
+}
+//# sourceMappingURL=goal-task-state-store.js.map