pulseed 0.6.5 → 0.6.6

package/dist/base/state/state-manager.js

@@ -6,76 +6,192 @@ import { GoalSchema, GoalTreeSchema } from "../types/goal.js";
 import { ObservationLogSchema, ObservationLogEntrySchema } from "../types/state.js";
 import { GapHistoryEntrySchema } from "../types/gap.js";
 import { TaskSchema } from "../types/task.js";
-import { LoopCheckpointSchema } from "../types/checkpoint.js";
+import { PipelineStateSchema } from "../types/pipeline.js";
+import { CheckpointSchema, LoopCheckpointSchema } from "../types/checkpoint.js";
+import { PortfolioSchema, parseStrategy } from "../types/strategy.js";
+import { CapabilityRegistrySchema } from "../types/capability.js";
 import { initDirs, atomicWrite, atomicRead } from "./state-persistence.js";
-import { GoalWriteCoordinator } from "./state-manager-goal-write.js";
-import { recoverStateManagerWAL } from "./state-manager-wal.js";
-import { archiveCompleteMarkerPath, archiveGoalDir, archiveGoalState, goalStorageLocation, listArchivedGoals as listArchivedGoalsFromState, listRecoverableArchivedGoalIds as listRecoverableArchivedGoalIdsFromState, readTasksFromDir, resolveGoalLocation, taskStorageDirs, visitChildGoals, } from "./state-manager-goal-state.js";
+import { listRecoverableArchivedGoalIds as listRecoverableArchivedGoalIdsFromState, } from "./legacy-archived-goal-recovery.js";
 export { initDirs, atomicWrite, atomicRead };
 const MAX_HISTORY_ENTRIES = 500;
+function normalizeRawStatePath(relativePath) {
+    return relativePath.replace(/\\/g, "/").replace(/^\/+/, "").split("/").filter(Boolean);
+}
+function assertSafeRawStateLogicalPath(relativePath) {
+    const unsafeSegment = normalizeRawStatePath(relativePath).some((part) => part === "." || part === "..");
+    if (unsafeSegment) {
+        throw new StateError(`Unsafe StateManager raw fallback path is not allowed: ${relativePath}`);
+    }
+}
+function isGoalTaskDurableStatePath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    if (parts.length === 0)
+        return false;
+    if (parts[0] === "goals" && parts.length >= 3)
+        return true;
+    if (parts[0] === "tasks" && parts.length >= 3)
+        return true;
+    if (parts[0] === "goal-trees" && parts.length === 2)
+        return true;
+    if (parts[0] === "verification" && parts.length === 3)
+        return true;
+    if (parts[0] === "checkpoints" && parts.length >= 3)
+        return true;
+    if (parts[0] === "pipelines" && parts.length === 2)
+        return true;
+    return false;
+}
+function parseStallStateRawPath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    if (parts[0] !== "stalls" || parts.length !== 2)
+        return null;
+    const fileName = parts[1];
+    return fileName.endsWith(".json") ? fileName.slice(0, -".json".length) : null;
+}
+function isLearningRuntimeRawPath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    if (parts[0] !== "learning" || parts.length !== 2)
+        return false;
+    const fileName = parts[1];
+    return fileName.endsWith("_logs.json")
+        || fileName.endsWith("_patterns.json")
+        || fileName.endsWith("_feedback.json")
+        || fileName.endsWith("_structural_feedback.json");
+}
+function isKnowledgeTransferRawPath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    return (parts.length === 2 && parts[0] === "knowledge-transfer" && parts[1] === "snapshot.json")
+        || (parts.length === 2 && parts[0] === "meta-patterns" && parts[1] === "last_aggregated_at.json");
+}
+function isCapabilityDependenciesRawPath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    return parts.length === 1 && parts[0] === "capability_dependencies.json";
+}
+function isTransferTrustRawPath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    return (parts.length === 2 && parts[0] === "transfer-trust" && parts[1] === "_index.json")
+        || (parts.length === 2 && parts[0] === "transfer-trust" && parts[1].endsWith(".json"))
+        || (parts.length === 2 && parts[0] === "transfer-trust-history" && parts[1].endsWith(".json"));
+}
+function isStrategyDreamDurableStatePath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    return parts[0] === "strategies" && parts.length >= 3;
+}
+function isProcessSessionDurableStatePath(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    return parts[0] === "runtime" && parts[1] === "process-sessions" && parts.length === 3 && parts[2].endsWith(".json");
+}
+const RAW_FALLBACK_CONFIG_FILES = new Set([
+    "provider.json",
+    "daemon.json",
+    "daemon-config.json",
+    "notification.json",
+    "character-config.json",
+    "mcp-servers.json",
+    "mcpServers.json",
+    "relationship-profile.json",
+]);
+function isExplicitRawFallbackBoundary(relativePath) {
+    const parts = normalizeRawStatePath(relativePath);
+    if (parts.length === 1 && RAW_FALLBACK_CONFIG_FILES.has(parts[0])) {
+        return true;
+    }
+    if (parts.length === 4
+        && parts[0] === "gateway"
+        && parts[1] === "channels"
+        && parts[3] === "config.json") {
+        return true;
+    }
+    if (parts.length === 3 && parts[0] === "reports" && parts[2].endsWith(".json")) {
+        return true;
+    }
+    return false;
+}
+function assertExplicitRawFallbackBoundary(relativePath) {
+    if (!isExplicitRawFallbackBoundary(relativePath)) {
+        throw new StateError(`Unclassified StateManager raw fallback path is not allowed: ${relativePath}`);
+    }
+}
 /**
  * StateManager handles persistence of goals, state vectors, observation logs,
- * and gap history under a base directory (default: ~/.pulseed/).
+ * and gap history under a typed database owned by the configured base directory
+ * (default: ~/.pulseed/).
  *
- * File layout:
- *   <base>/goals/<goal_id>/goal.json
- *   <base>/goals/<goal_id>/observations.json
- *   <base>/goals/<goal_id>/gap-history.json
- *   <base>/goal-trees/<root_id>.json
+ * Durable logical paths are routed through typed stores. The remaining raw
+ * fallback is restricted to explicit config/user-authored content and
+ * debug/export artifact boundaries.
+ *
+ * Durable state layout:
+ *   <base>/runtime/control.db
  *   <base>/events/              (event queue directory)
  *   <base>/events/archive/      (processed events)
  *   <base>/reports/             (report output directory)
- *
- * All writes are atomic: write to .tmp file, then rename.
  */
 export class StateManager {
     baseDir;
     logger;
-    walEnabled;
-    goalWriteCoordinator;
+    goalTaskStateStorePromise = null;
+    strategyDreamStateStorePromise = null;
+    processSessionStateStorePromise = null;
+    capabilityRegistryStateStorePromise = null;
+    stallStateStorePromise = null;
+    learningRuntimeStateStorePromise = null;
+    knowledgeTransferStateStorePromise = null;
+    transferTrustStateStorePromise = null;
+    goalStateWriteQueues = new Map();
+    writeFences = new Map();
     constructor(baseDir, logger, options) {
         this.baseDir = baseDir ?? getPulseedDirPath();
         this.logger = logger;
-        this.walEnabled = options?.walEnabled ?? true;
-        this.goalWriteCoordinator = new GoalWriteCoordinator({
-            baseDir: this.baseDir,
-            walEnabled: this.walEnabled,
-            loadGoal: (goalId) => this.loadGoal(goalId),
-        });
+        void options;
     }
     /** Create required subdirectories. Must be called after construction before first use. */
     async init() {
         await initDirs(this.baseDir);
-        if (this.walEnabled) {
-            await this.recoverWAL();
-        }
-    }
-    /**
-     * Scan all goals for uncommitted WAL entries and replay them.
-     * Depends on initDirs() having been called first (to ensure goals/ exists).
-     */
-    async recoverWAL() {
-        await recoverStateManagerWAL({
-            baseDir: this.baseDir,
-            logger: this.logger,
-            listGoalIds: () => this.listGoalIds(),
-        });
+        await (await this.goalTaskStateStore()).ensureReady();
+        await (await this.strategyDreamStateStore()).ensureReady();
+        await (await this.capabilityRegistryStateStore()).ensureReady();
+        await (await this.processSessionStateStore()).ensureReady();
+        await (await this.stallStateStore()).ensureReady();
+        await (await this.learningRuntimeStateStore()).ensureReady();
+        await (await this.knowledgeTransferStateStore()).ensureReady();
+        await (await this.transferTrustStateStore()).ensureReady();
     }
     /** Returns the base directory path */
     getBaseDir() {
         return this.baseDir;
     }
     setWriteFence(goalId, fence) {
-        this.goalWriteCoordinator.setWriteFence(goalId, fence);
+        this.writeFences.set(goalId, fence);
     }
     clearWriteFence(goalId) {
-        this.goalWriteCoordinator.clearWriteFence(goalId);
+        this.writeFences.delete(goalId);
     }
     async assertWriteFence(goalId, op, data) {
-        await this.goalWriteCoordinator.assertWriteFence(goalId, op, data);
-    }
-    async goalDir(goalId) {
-        return this.goalWriteCoordinator.goalDir(goalId);
+        const fence = this.writeFences.get(goalId);
+        if (!fence)
+            return;
+        await fence({ goalId, op, data });
+    }
+    async runGoalStateMutation(goalId, op, data, fn) {
+        const previous = this.goalStateWriteQueues.get(goalId) ?? Promise.resolve();
+        const run = previous.catch(() => undefined).then(async () => {
+            const store = await this.goalTaskStateStore();
+            return store.withGoalStateWriteLock(goalId, async () => {
+                await this.assertWriteFence(goalId, op, data);
+                return fn();
+            });
+        });
+        const marker = run.then(() => undefined, () => undefined);
+        this.goalStateWriteQueues.set(goalId, marker);
+        try {
+            return await run;
+        }
+        finally {
+            if (this.goalStateWriteQueues.get(goalId) === marker) {
+                this.goalStateWriteQueues.delete(goalId);
+            }
+        }
     }
     // ─── Atomic Write / Read (delegated to state-persistence) ───
     async atomicWrite(filePath, data) {
@@ -84,10 +200,6 @@ export class StateManager {
     async atomicRead(filePath) {
         return atomicRead(filePath, this.logger);
     }
-    /** Wrap a goal write with lock + WAL + snapshot cycle. */
-    async protectedWrite(goalId, op, data, writeFn) {
-        await this.goalWriteCoordinator.protectedWrite(goalId, op, data, writeFn);
-    }
     isEnoent(error) {
         return error.code === "ENOENT";
     }
@@ -102,36 +214,22 @@ export class StateManager {
             return false;
         }
     }
-    goalStorageLocation(goalId, kind) {
-        return goalStorageLocation(this.baseDir, goalId, kind);
-    }
-    archiveGoalDir(goalId) {
-        return archiveGoalDir(this.baseDir, goalId);
-    }
-    archiveCompleteMarkerPath(archiveBase) {
-        return archiveCompleteMarkerPath(archiveBase);
-    }
-    taskStorageDirs(goalId) {
-        return taskStorageDirs(this.baseDir, goalId);
-    }
-    async readTasksFromDir(tasksDir) {
-        return readTasksFromDir(tasksDir, {
-            atomicRead: (filePath) => this.atomicRead(filePath),
-            isEnoent: (error) => this.isEnoent(error),
-        });
-    }
     async cleanupActiveGoalState(goalId) {
         await fsp.rm(path.join(this.baseDir, "goals", goalId), { recursive: true, force: true });
         await fsp.rm(path.join(this.baseDir, "tasks", goalId), { recursive: true, force: true });
         await fsp.rm(path.join(this.baseDir, "strategies", goalId), { recursive: true, force: true });
+        await (await this.strategyDreamStateStore()).deleteGoalStrategyState(goalId);
+        await (await this.stallStateStore()).deleteStallState(goalId);
         await fsp.rm(path.join(this.baseDir, "stalls", `${goalId}.json`), { force: true });
+        await this.cleanupLearningRuntimeState(goalId);
         await fsp.rm(path.join(this.baseDir, "reports", goalId), { recursive: true, force: true });
     }
-    async commitArchiveGoal(stagingBase, archiveBase) {
-        await fsp.rename(stagingBase, archiveBase);
-    }
-    async resolveGoalLocation(goalId, includeArchive) {
-        return resolveGoalLocation(this.baseDir, goalId, includeArchive, (filePath) => this.pathExists(filePath));
+    async cleanupLearningRuntimeState(goalId) {
+        await (await this.learningRuntimeStateStore()).deleteGoalLearningState(goalId);
+        await fsp.rm(path.join(this.baseDir, "learning", `${goalId}_logs.json`), { force: true });
+        await fsp.rm(path.join(this.baseDir, "learning", `${goalId}_patterns.json`), { force: true });
+        await fsp.rm(path.join(this.baseDir, "learning", `${goalId}_feedback.json`), { force: true });
+        await fsp.rm(path.join(this.baseDir, "learning", `${goalId}_structural_feedback.json`), { force: true });
     }
     markGoalVisited(goalId, visited) {
         if (visited.has(goalId))
@@ -139,13 +237,6 @@ export class StateManager {
         visited.add(goalId);
         return true;
     }
-    async visitChildGoals(goalId, location, visited, visit) {
-        await visitChildGoals(goalId, location, visited, {
-            atomicRead: (filePath) => this.atomicRead(filePath),
-            loadGoal: (childGoalId) => this.loadGoal(childGoalId),
-            logger: this.logger,
-        }, visit);
-    }
     capHistoryEntries(entries) {
         return entries.slice(-MAX_HISTORY_ENTRIES);
     }
@@ -154,239 +245,283 @@ export class StateManager {
             throw new StateError(`appendObservation: entry.goal_id ("${entry.goal_id}") does not match goalId ("${goalId}")`);
         }
     }
-    async writeObservationLog(goalId, op, log, resolveDirBeforeWrite) {
-        const resolvedDir = resolveDirBeforeWrite ? await this.goalDir(goalId) : null;
-        await this.protectedWrite(goalId, op, log, async () => {
-            const dir = resolvedDir ?? await this.goalDir(goalId);
-            await this.atomicWrite(path.join(dir, "observations.json"), log);
-        });
-    }
-    async writeGapHistory(goalId, op, entries, resolveDirBeforeWrite) {
-        const resolvedDir = resolveDirBeforeWrite ? await this.goalDir(goalId) : null;
-        await this.protectedWrite(goalId, op, { goalId, entries }, async () => {
-            const dir = resolvedDir ?? await this.goalDir(goalId);
-            await this.atomicWrite(path.join(dir, "gap-history.json"), entries);
-        });
+    async goalTaskStateStore() {
+        this.goalTaskStateStorePromise ??= import("../../runtime/store/goal-task-state-store.js")
+            .then(({ GoalTaskStateStore }) => new GoalTaskStateStore(this.baseDir));
+        return this.goalTaskStateStorePromise;
+    }
+    async strategyDreamStateStore() {
+        this.strategyDreamStateStorePromise ??= import("../../runtime/store/strategy-dream-state-store.js")
+            .then(({ StrategyDreamStateStore }) => new StrategyDreamStateStore(this.baseDir));
+        return this.strategyDreamStateStorePromise;
+    }
+    async processSessionStateStore() {
+        this.processSessionStateStorePromise ??= import("../../runtime/store/process-session-state-store.js")
+            .then(({ ProcessSessionStateStore }) => new ProcessSessionStateStore(this.baseDir));
+        return this.processSessionStateStorePromise;
+    }
+    async capabilityRegistryStateStore() {
+        this.capabilityRegistryStateStorePromise ??= import("../../runtime/store/capability-registry-state-store.js")
+            .then(({ CapabilityRegistryStateStore }) => new CapabilityRegistryStateStore(this.baseDir));
+        return this.capabilityRegistryStateStorePromise;
+    }
+    async stallStateStore() {
+        this.stallStateStorePromise ??= import("../../runtime/store/stall-state-store.js")
+            .then(({ StallStateStore }) => new StallStateStore(this.baseDir));
+        return this.stallStateStorePromise;
+    }
+    async learningRuntimeStateStore() {
+        this.learningRuntimeStateStorePromise ??= import("../../runtime/store/learning-runtime-state-store.js")
+            .then(({ LearningRuntimeStateStore }) => new LearningRuntimeStateStore(this.baseDir));
+        return this.learningRuntimeStateStorePromise;
+    }
+    async knowledgeTransferStateStore() {
+        this.knowledgeTransferStateStorePromise ??= import("../../runtime/store/knowledge-transfer-state-store.js")
+            .then(({ KnowledgeTransferStateStore }) => new KnowledgeTransferStateStore(this.baseDir));
+        return this.knowledgeTransferStateStorePromise;
+    }
+    async transferTrustStateStore() {
+        this.transferTrustStateStorePromise ??= import("../../runtime/store/transfer-trust-state-store.js")
+            .then(({ TransferTrustStateStore }) => new TransferTrustStateStore(this.baseDir));
+        return this.transferTrustStateStorePromise;
     }
     // ─── Goal CRUD ───
     async saveGoal(goal) {
         const parsed = GoalSchema.parse(goal);
-        const dir = await this.goalDir(parsed.id);
-        await this.protectedWrite(parsed.id, "save_goal", parsed, async () => {
-            await this.atomicWrite(path.join(dir, "goal.json"), parsed);
+        await this.runGoalStateMutation(parsed.id, "save_goal", parsed, async () => {
+            await (await this.goalTaskStateStore()).saveGoal(parsed);
         });
     }
     async loadGoal(goalId) {
-        const archiveBase = this.archiveGoalDir(goalId);
-        const archiveCompleteMarkerExists = await this.pathExists(this.archiveCompleteMarkerPath(archiveBase));
-        const archiveGoalPath = this.goalStorageLocation(goalId, "archive").goalJsonPath;
-        const archiveGoalExists = await this.pathExists(archiveGoalPath);
-        // Committed archive wins over stale active state after crash cleanup.
-        if (archiveCompleteMarkerExists && archiveGoalExists) {
-            const archiveRaw = await this.atomicRead(archiveGoalPath);
-            if (archiveRaw !== null)
-                return GoalSchema.parse(archiveRaw);
-        }
-        // Primary path: active goals
-        const filePath = path.join(this.baseDir, "goals", goalId, "goal.json");
-        const raw = await this.atomicRead(filePath);
-        if (raw !== null)
-            return GoalSchema.parse(raw);
-        // Fallback: archived goals (archiveGoal() copies goal dir to archive/<goalId>/goal/)
-        if (!archiveGoalExists)
-            return null;
-        const archiveRaw = await this.atomicRead(archiveGoalPath);
-        if (archiveRaw === null)
-            return null;
-        return GoalSchema.parse(archiveRaw);
+        return (await this.goalTaskStateStore()).loadGoal(goalId, { includeArchived: true });
     }
     async deleteGoal(goalId, _visited = new Set()) {
         if (!this.markGoalVisited(goalId, _visited))
             return false;
-        const location = await this.resolveGoalLocation(goalId, true);
-        if (location === null)
-            return false;
-        // Recursively delete children first (depth-first)
-        await this.visitChildGoals(goalId, location, _visited, (childId, visited) => this.deleteGoal(childId, visited));
-        await fsp.rm(location.dir, { recursive: true, force: true });
-        return true;
+        return this.runGoalStateMutation(goalId, "delete_goal", { goalId }, async () => {
+            const goal = await this.loadGoal(goalId);
+            if (goal === null) {
+                return false;
+            }
+            // Recursively delete children first (depth-first)
+            for (const childId of goal.children_ids) {
+                await this.deleteGoal(childId, _visited);
+            }
+            await (await this.goalTaskStateStore()).deleteGoal(goalId);
+            await this.cleanupActiveGoalState(goalId);
+            return true;
+        });
     }
-    /**
-     * Archive a completed goal by moving its state files to
-     * <base>/archive/<goalId>/.
-     *
-     * Moves:
-     *   goals/<goalId>/         → archive/<goalId>/goal/
-     *   tasks/<goalId>/         → archive/<goalId>/tasks/    (if exists)
-     *   strategies/<goalId>/    → archive/<goalId>/strategies/ (if exists)
-     *   stalls/<goalId>.json    → archive/<goalId>/stalls.json (if exists)
-     *   reports/<goalId>/       → archive/<goalId>/reports/  (if exists)
-     *
-     * Returns true if the goal was archived, false if the goal was not found.
-     */
+    /** Archive a DB-owned goal without falling back to legacy goal JSON. */
     async archiveGoal(goalId, _visited = new Set()) {
         if (!this.markGoalVisited(goalId, _visited))
             return false;
-        return archiveGoalState(goalId, _visited, {
-            baseDir: this.baseDir,
-            logger: this.logger,
-            pathExists: (filePath) => this.pathExists(filePath),
-            atomicRead: (filePath) => this.atomicRead(filePath),
-            atomicWrite: (filePath, data) => this.atomicWrite(filePath, data),
-            loadGoal: (loadGoalId) => this.loadGoal(loadGoalId),
-            cleanupActiveGoalState: (cleanupGoalId) => this.cleanupActiveGoalState(cleanupGoalId),
-            goalWriteProtectedOperation: (writeGoalId, op, data, fn) => this.goalWriteCoordinator.protectedOperation(writeGoalId, op, data, fn),
-            commitArchiveGoal: (stagingBase, archiveBase) => this.commitArchiveGoal(stagingBase, archiveBase),
-        });
+        const store = await this.goalTaskStateStore();
+        const goal = await store.loadGoal(goalId, { includeArchived: false });
+        if (goal !== null) {
+            for (const childId of goal.children_ids) {
+                await this.archiveGoal(childId, _visited);
+            }
+            return this.runGoalStateMutation(goalId, "archive_goal", { goalId }, async () => {
+                const archived = await store.markGoalArchived(goalId);
+                await fsp.rm(path.join(this.baseDir, "goals", goalId), { recursive: true, force: true });
+                await fsp.rm(path.join(this.baseDir, "tasks", goalId), { recursive: true, force: true });
+                await (await this.strategyDreamStateStore()).deleteGoalStrategyState(goalId);
+                await (await this.stallStateStore()).deleteStallState(goalId);
+                await fsp.rm(path.join(this.baseDir, "stalls", `${goalId}.json`), { force: true });
+                return archived || (await store.loadGoal(goalId, { includeArchived: true })) !== null;
+            });
+        }
+        return false;
     }
     /**
-     * Returns the goal IDs of all archived goals under <base>/archive/.
+     * Returns DB-owned archived goal IDs. Legacy archive directories are exposed
+     * only through listRecoverableArchivedGoalIds() for explicit migration/recovery.
      */
     async listArchivedGoals() {
-        return listArchivedGoalsFromState(this.baseDir, (filePath) => this.pathExists(filePath));
+        return (await this.goalTaskStateStore()).listGoalIds({ archived: true });
     }
     async listGoalIds() {
-        const goalsDir = path.join(this.baseDir, "goals");
-        try {
-            const entries = await fsp.readdir(goalsDir, { withFileTypes: true });
-            return entries.filter((d) => d.isDirectory()).map((d) => d.name);
-        }
-        catch (e) {
-            if (e.code !== "ENOENT")
-                throw e;
-            return [];
-        }
+        return (await this.goalTaskStateStore()).listGoalIds({ archived: false });
     }
     async listRecoverableArchivedGoalIds() {
         return listRecoverableArchivedGoalIdsFromState(this.baseDir, (filePath) => this.pathExists(filePath));
     }
     async listTasks(goalId, options = {}) {
-        const { activeDir, archiveDir } = this.taskStorageDirs(goalId);
-        if (activeDir === null || archiveDir === null) {
-            return [];
-        }
-        const activeTasks = await this.readTasksFromDir(activeDir);
-        if (activeTasks.length > 0 || options.includeArchive === false) {
-            return activeTasks;
-        }
-        return this.readTasksFromDir(archiveDir);
+        void options;
+        return (await this.goalTaskStateStore()).listTasks(goalId);
+    }
+    async listTasksByStatus(status) {
+        return (await this.goalTaskStateStore()).listTasksByStatus(status);
     }
     async loadTask(goalId, taskId, options = {}) {
-        const relativeCandidates = [`tasks/${goalId}/${taskId}.json`];
-        if (options.includeArchive !== false) {
-            relativeCandidates.push(`archive/${goalId}/tasks/${taskId}.json`);
-        }
-        for (const relativePath of relativeCandidates) {
-            const raw = await this.readRaw(relativePath);
-            if (raw === null)
-                continue;
-            const parsed = TaskSchema.safeParse(raw);
-            if (parsed.success) {
-                return parsed.data;
-            }
-        }
-        return null;
+        void options;
+        return (await this.goalTaskStateStore()).loadTask(goalId, taskId);
+    }
+    async saveTask(task) {
+        const parsed = TaskSchema.parse(task);
+        await (await this.goalTaskStateStore()).saveTask(parsed);
+    }
+    async loadTaskHistory(goalId) {
+        return (await this.goalTaskStateStore()).loadTaskHistory(goalId);
+    }
+    async saveTaskHistory(goalId, history) {
+        await (await this.goalTaskStateStore()).saveTaskHistory(goalId, history);
+    }
+    async loadTaskFailureContext(goalId) {
+        return (await this.goalTaskStateStore()).loadTaskFailureContext(goalId);
+    }
+    async saveTaskFailureContext(goalId, context) {
+        await (await this.goalTaskStateStore()).saveTaskFailureContext(goalId, context);
+    }
+    async loadTaskVerificationResult(taskId) {
+        return (await this.goalTaskStateStore()).loadTaskVerificationResult(taskId);
+    }
+    async saveTaskVerificationResult(taskId, result) {
+        await (await this.goalTaskStateStore()).saveTaskVerificationResult(taskId, result);
+    }
+    async loadTaskOutcomeLedger(goalId, taskId) {
+        return (await this.goalTaskStateStore()).loadTaskOutcomeLedger(goalId, taskId);
+    }
+    async saveTaskOutcomeLedger(record) {
+        await (await this.goalTaskStateStore()).saveTaskOutcomeLedger(record);
+    }
+    async listPipelinesByStatus(status) {
+        return (await this.goalTaskStateStore()).listPipelinesByStatus(status);
+    }
+    async savePipeline(taskId, state) {
+        await (await this.goalTaskStateStore()).savePipeline(taskId, PipelineStateSchema.parse(state));
+    }
+    async loadPipeline(taskId) {
+        return (await this.goalTaskStateStore()).loadPipeline(taskId);
     }
     // ─── Goal Tree ───
     async saveGoalTree(tree) {
         const parsed = GoalTreeSchema.parse(tree);
-        const filePath = path.join(this.baseDir, "goal-trees", `${parsed.root_id}.json`);
-        await this.atomicWrite(filePath, parsed);
+        await (await this.goalTaskStateStore()).saveGoalTree(parsed);
     }
     async loadGoalTree(rootId) {
-        const filePath = path.join(this.baseDir, "goal-trees", `${rootId}.json`);
-        const raw = await this.atomicRead(filePath);
-        if (raw === null)
-            return null;
-        return GoalTreeSchema.parse(raw);
+        return (await this.goalTaskStateStore()).loadGoalTree(rootId);
     }
     async deleteGoalTree(rootId) {
-        const filePath = path.join(this.baseDir, "goal-trees", `${rootId}.json`);
-        try {
-            await fsp.unlink(filePath);
-            return true;
-        }
-        catch (e) {
-            if (e.code !== "ENOENT")
-                throw e;
-            return false;
-        }
+        return (await this.goalTaskStateStore()).deleteGoalTree(rootId);
     }
     // ─── Observation Log ───
     async saveObservationLog(log) {
         const parsed = ObservationLogSchema.parse(log);
-        await this.writeObservationLog(parsed.goal_id, "save_observation", parsed, true);
+        await this.runGoalStateMutation(parsed.goal_id, "save_observation", parsed, async () => {
+            await (await this.goalTaskStateStore()).saveObservationLog(parsed);
+        });
     }
     async loadObservationLog(goalId) {
-        const filePath = path.join(this.baseDir, "goals", goalId, "observations.json");
-        const raw = await this.atomicRead(filePath);
-        if (raw === null)
-            return null;
-        return ObservationLogSchema.parse(raw);
+        return (await this.goalTaskStateStore()).loadObservationLog(goalId);
     }
     async appendObservation(goalId, entry) {
         const parsed = ObservationLogEntrySchema.parse(entry);
         this.assertObservationGoalId(goalId, parsed);
-        await this.goalWriteCoordinator.protectedReadModifyWrite(goalId, "append_observation", async () => {
-            const log = (await this.loadObservationLog(goalId)) ?? { goal_id: goalId, entries: [] };
-            return {
-                ...log,
-                entries: this.capHistoryEntries([...log.entries, parsed]),
-            };
-        }, async (log) => {
-            const dir = await this.goalDir(goalId);
-            await this.atomicWrite(path.join(dir, "observations.json"), log);
+        await this.runGoalStateMutation(goalId, "append_observation", parsed, async () => {
+            await (await this.goalTaskStateStore()).appendObservation(goalId, parsed, MAX_HISTORY_ENTRIES);
         });
     }
     // ─── Gap History ───
     async saveGapHistory(goalId, history) {
         const parsed = history.map((e) => GapHistoryEntrySchema.parse(e));
-        await this.writeGapHistory(goalId, "save_gap_history", parsed, true);
+        await this.runGoalStateMutation(goalId, "save_gap_history", { goalId, entries: parsed }, async () => {
+            await (await this.goalTaskStateStore()).saveGapHistory(goalId, parsed);
+        });
     }
     async loadGapHistory(goalId) {
-        const filePath = path.join(this.baseDir, "goals", goalId, "gap-history.json");
-        const raw = await this.atomicRead(filePath);
-        if (raw === null)
-            return [];
-        return raw.map((e) => GapHistoryEntrySchema.parse(e));
+        return (await this.goalTaskStateStore()).loadGapHistory(goalId);
     }
     async appendGapHistoryEntry(goalId, entry) {
         const parsed = GapHistoryEntrySchema.parse(entry);
-        await this.goalWriteCoordinator.protectedReadModifyWrite(goalId, "append_gap_entry", async () => {
-            const history = await this.loadGapHistory(goalId);
-            return {
-                goalId,
-                entries: this.capHistoryEntries([...history, parsed]),
-            };
-        }, async (payload) => {
-            const dir = await this.goalDir(goalId);
-            await this.atomicWrite(path.join(dir, "gap-history.json"), payload.entries);
+        await this.runGoalStateMutation(goalId, "append_gap_entry", parsed, async () => {
+            await (await this.goalTaskStateStore()).appendGapHistoryEntry(goalId, parsed, MAX_HISTORY_ENTRIES);
         });
     }
+    async loadCurrentGapForDimension(goalId, dimensionName) {
+        const history = await this.loadGapHistory(goalId);
+        for (let index = history.length - 1; index >= 0; index--) {
+            const match = history[index]?.gap_vector.find((gap) => gap.dimension_name === dimensionName);
+            if (match && typeof match.normalized_weighted_gap === "number") {
+                return match.normalized_weighted_gap;
+            }
+        }
+        return null;
+    }
+    async saveLoopCheckpoint(goalId, checkpoint, adapterType) {
+        const parsed = LoopCheckpointSchema.parse(checkpoint);
+        await (await this.goalTaskStateStore()).saveLoopCheckpoint(goalId, parsed, adapterType);
+    }
+    async loadLoopCheckpoint(goalId) {
+        return (await this.goalTaskStateStore()).loadLoopCheckpoint(goalId);
+    }
+    async saveCheckpoint(checkpoint) {
+        return (await this.goalTaskStateStore()).saveCheckpoint(CheckpointSchema.parse(checkpoint));
+    }
+    async loadCheckpoint(checkpointId) {
+        return (await this.goalTaskStateStore()).loadCheckpoint(checkpointId);
+    }
+    async loadLatestCheckpoint(goalId, taskId) {
+        return (await this.goalTaskStateStore()).loadLatestCheckpoint(goalId, taskId);
+    }
+    async listCheckpointEntries(goalId) {
+        return (await this.goalTaskStateStore()).listCheckpointEntries(goalId);
+    }
+    async deleteCheckpoint(goalId, checkpointId) {
+        return (await this.goalTaskStateStore()).deleteCheckpoint(goalId, checkpointId);
+    }
+    async garbageCollectCheckpoints(goalId, cutoffMs) {
+        return (await this.goalTaskStateStore()).garbageCollectCheckpoints(goalId, cutoffMs);
+    }
+    async loadStrategyPortfolio(goalId) {
+        return (await this.strategyDreamStateStore()).loadPortfolio(goalId);
+    }
+    async saveStrategyPortfolio(goalId, portfolio) {
+        await (await this.strategyDreamStateStore()).savePortfolio(goalId, PortfolioSchema.parse(portfolio));
+    }
+    async loadStrategyHistory(goalId) {
+        return (await this.strategyDreamStateStore()).loadStrategyHistory(goalId);
+    }
+    async saveStrategyHistory(goalId, history) {
+        await (await this.strategyDreamStateStore()).saveStrategyHistory(goalId, history.map((strategy) => parseStrategy(strategy)));
+    }
+    async loadWaitMetadata(goalId, strategyId) {
+        return (await this.strategyDreamStateStore()).loadWaitMetadata(goalId, strategyId);
+    }
+    async saveWaitMetadata(goalId, strategyId, metadata) {
+        await (await this.strategyDreamStateStore()).saveWaitMetadata(goalId, strategyId, metadata);
+    }
+    async loadRebalanceHistory(goalId) {
+        return (await this.strategyDreamStateStore()).loadRebalanceHistory(goalId);
+    }
+    async saveRebalanceHistory(goalId, history) {
+        await (await this.strategyDreamStateStore()).saveRebalanceHistory(goalId, history);
+    }
+    async loadCapabilityRegistry() {
+        return (await this.capabilityRegistryStateStore()).loadRegistry();
+    }
+    async saveCapabilityRegistry(registry) {
+        await (await this.capabilityRegistryStateStore()).saveRegistry(CapabilityRegistrySchema.parse(registry));
+    }
+    async isCapabilityAvailable(capabilityName) {
+        return (await this.capabilityRegistryStateStore()).isCapabilityAvailable(capabilityName);
+    }
     async appendObservationAndSaveGoal(goalId, entry, updateGoal) {
         const parsed = ObservationLogEntrySchema.parse(entry);
         this.assertObservationGoalId(goalId, parsed);
-        await this.goalWriteCoordinator.protectedReadModifyWrite(goalId, "append_observation_and_save_goal", async () => {
-            const goal = await this.loadGoal(goalId);
+        const store = await this.goalTaskStateStore();
+        await this.runGoalStateMutation(goalId, "append_observation_and_save_goal", { observation: parsed }, async () => {
+            const goal = await store.loadGoal(goalId, { includeArchived: true });
             if (goal === null) {
                 throw new StateError(`appendObservationAndSaveGoal: goal "${goalId}" not found`);
             }
-            const observationLog = (await this.loadObservationLog(goalId)) ?? { goal_id: goalId, entries: [] };
             const updatedGoal = GoalSchema.parse(updateGoal(goal));
             if (updatedGoal.id !== goalId) {
                 throw new StateError(`appendObservationAndSaveGoal: update changed goal id from "${goalId}" to "${updatedGoal.id}"`);
             }
-            return {
-                observationLog: {
-                    ...observationLog,
-                    entries: this.capHistoryEntries([...observationLog.entries, parsed]),
-                },
-                goal: updatedGoal,
-            };
-        }, async (data) => {
-            const dir = await this.goalDir(goalId);
-            await this.atomicWrite(path.join(dir, "observations.json"), data.observationLog);
-            await this.atomicWrite(path.join(dir, "goal.json"), data.goal);
+            await store.appendObservation(goalId, parsed, MAX_HISTORY_ENTRIES);
+            await store.saveGoal(updatedGoal);
         });
     }
     /**
@@ -398,9 +533,8 @@ export class StateManager {
             throw new StateError(`savePaceSnapshot: goal "${goalId}" not found`);
         }
         const updated = { ...goal, pace_snapshot: snapshot };
-        const dir = await this.goalDir(goalId);
-        await this.protectedWrite(goalId, "save_pace_snapshot", updated, async () => {
-            await this.atomicWrite(path.join(dir, "goal.json"), GoalSchema.parse(updated));
+        await this.runGoalStateMutation(goalId, "save_pace_snapshot", updated, async () => {
+            await (await this.goalTaskStateStore()).saveGoal(GoalSchema.parse(updated));
         });
     }
     // ─── Goal Tree Traversal ───
@@ -478,15 +612,7 @@ export class StateManager {
     // ─── Utility ───
     /** Check whether a goal directory exists */
     async goalExists(goalId) {
-        try {
-            await fsp.access(path.join(this.baseDir, "goals", goalId, "goal.json"));
-            return true;
-        }
-        catch (e) {
-            if (e.code !== "ENOENT")
-                throw e;
-            return false;
-        }
+        return (await this.goalTaskStateStore()).goalExists(goalId);
     }
     /**
      * Restore dimension values and trust balance from a loop crash-recovery checkpoint.
@@ -496,7 +622,7 @@ export class StateManager {
      */
     async restoreFromCheckpoint(goalId, adapterType, trustManager) {
         try {
-            const raw = await this.atomicRead(path.join(this.baseDir, "goals", goalId, "checkpoint.json"));
+            const raw = await (await this.goalTaskStateStore()).loadLoopCheckpoint(goalId);
             if (raw === null)
                 return 0;
             const parseResult = LoopCheckpointSchema.safeParse(raw);
@@ -534,20 +660,131 @@ export class StateManager {
             return 0;
         }
     }
-    /** Read raw JSON from any path relative to base dir */
+    /** Read a typed legacy route or an explicitly allowlisted raw artifact path. */
     async readRaw(relativePath) {
         const resolved = path.resolve(this.baseDir, relativePath);
         if (!resolved.startsWith(path.resolve(this.baseDir) + path.sep)) {
             throw new Error(`Path traversal detected: ${relativePath}`);
         }
+        assertSafeRawStateLogicalPath(relativePath);
+        if (isGoalTaskDurableStatePath(relativePath)) {
+            const routed = await (await this.goalTaskStateStore()).readRawPath(relativePath);
+            if (routed.handled) {
+                return routed.value;
+            }
+        }
+        const stallGoalId = parseStallStateRawPath(relativePath);
+        if (stallGoalId) {
+            return (await this.stallStateStore()).loadStallState(stallGoalId);
+        }
+        if (isLearningRuntimeRawPath(relativePath)) {
+            const routed = await (await this.learningRuntimeStateStore()).readRawPath(relativePath);
+            if (routed.handled) {
+                return routed.value;
+            }
+        }
+        if (isKnowledgeTransferRawPath(relativePath)) {
+            const routed = await (await this.knowledgeTransferStateStore()).readRawPath(relativePath);
+            if (routed.handled) {
+                return routed.value;
+            }
+        }
+        if (isCapabilityDependenciesRawPath(relativePath)) {
+            const routed = await (await this.capabilityRegistryStateStore()).readRawPath(relativePath);
+            if (routed.handled) {
+                return routed.value;
+            }
+        }
+        if (isTransferTrustRawPath(relativePath)) {
+            const routed = await (await this.transferTrustStateStore()).readRawPath(relativePath);
+            if (routed.handled) {
+                return routed.value;
+            }
+        }
+        if (isStrategyDreamDurableStatePath(relativePath)) {
+            const routed = await (await this.strategyDreamStateStore()).readRawPath(relativePath);
+            if (routed.handled) {
+                return routed.value;
+            }
+        }
+        if (isProcessSessionDurableStatePath(relativePath)) {
+            const routed = await (await this.processSessionStateStore()).readRawPath(relativePath);
+            if (routed.handled) {
+                return routed.value;
+            }
+        }
+        assertExplicitRawFallbackBoundary(relativePath);
         return this.atomicRead(resolved);
     }
-    /** Write raw JSON to any path relative to base dir (atomic) */
+    /** Write a typed legacy route or an explicitly allowlisted raw artifact path. */
     async writeRaw(relativePath, data) {
         const resolved = path.resolve(this.baseDir, relativePath);
         if (!resolved.startsWith(path.resolve(this.baseDir) + path.sep)) {
             throw new Error(`Path traversal detected: ${relativePath}`);
         }
+        assertSafeRawStateLogicalPath(relativePath);
+        const parts = relativePath.split("/");
+        if (isGoalTaskDurableStatePath(relativePath)) {
+            const routedStore = await this.goalTaskStateStore();
+            if (relativePath.startsWith("goals/") && parts.length >= 3) {
+                const goalId = parts[1];
+                const routed = await this.runGoalStateMutation(goalId, "write_raw", { path: relativePath, payload: data }, async () => routedStore.writeRawPath(relativePath, data));
+                if (routed) {
+                    return;
+                }
+            }
+            else if (await routedStore.writeRawPath(relativePath, data)) {
+                return;
+            }
+        }
+        const stallGoalId = parseStallStateRawPath(relativePath);
+        if (stallGoalId) {
+            const routedStore = await this.stallStateStore();
+            if (data === null) {
+                await routedStore.deleteStallState(stallGoalId);
+            }
+            else {
+                await routedStore.saveStallState(stallGoalId, data);
+            }
+            return;
+        }
+        if (isLearningRuntimeRawPath(relativePath)) {
+            const routedStore = await this.learningRuntimeStateStore();
+            if (await routedStore.writeRawPath(relativePath, data)) {
+                return;
+            }
+        }
+        if (isKnowledgeTransferRawPath(relativePath)) {
+            const routedStore = await this.knowledgeTransferStateStore();
+            if (await routedStore.writeRawPath(relativePath, data)) {
+                return;
+            }
+        }
+        if (isCapabilityDependenciesRawPath(relativePath)) {
+            const routedStore = await this.capabilityRegistryStateStore();
+            if (await routedStore.writeRawPath(relativePath, data)) {
+                return;
+            }
+        }
+        if (isTransferTrustRawPath(relativePath)) {
+            const routedStore = await this.transferTrustStateStore();
+            if (await routedStore.writeRawPath(relativePath, data)) {
+                return;
+            }
+        }
+        if (isStrategyDreamDurableStatePath(relativePath)) {
+            const routedStore = await this.strategyDreamStateStore();
+            if (await routedStore.writeRawPath(relativePath, data)) {
+                return;
+            }
+        }
+        if (isProcessSessionDurableStatePath(relativePath)) {
+            const routedStore = await this.processSessionStateStore();
+            if (await routedStore.writeRawPath(relativePath, data)) {
+                return;
+            }
+        }
+        assertExplicitRawFallbackBoundary(relativePath);
         const filePath = resolved;
         const dir = path.dirname(filePath);
         try {
@@ -558,17 +795,7 @@ export class StateManager {
                 return;
             throw err;
         }
-        // Use protectedWrite only for goal-scoped paths like goals/<goalId>/<filename>
-        const parts = relativePath.split("/");
-        if (relativePath.startsWith("goals/") && parts.length >= 3) {
-            const goalId = parts[1];
-            await this.protectedWrite(goalId, "write_raw", { path: relativePath, payload: data }, async () => {
-                await this.atomicWrite(filePath, data);
-            });
-        }
-        else {
-            await this.atomicWrite(filePath, data);
-        }
+        await this.atomicWrite(filePath, data);
     }
 }
 //# sourceMappingURL=state-manager.js.map