pulseed 0.6.6 → 0.7.0

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

@@ -1,801 +0,0 @@
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
-import { getPulseedDirPath } from "../utils/paths.js";
-import { StateError } from "../utils/errors.js";
-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 { 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 { 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 typed database owned by the configured base directory
- * (default: ~/.pulseed/).
- *
- * 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)
- */
-export class StateManager {
-    baseDir;
-    logger;
-    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;
-        void options;
-    }
-    /** Create required subdirectories. Must be called after construction before first use. */
-    async init() {
-        await initDirs(this.baseDir);
-        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.writeFences.set(goalId, fence);
-    }
-    clearWriteFence(goalId) {
-        this.writeFences.delete(goalId);
-    }
-    async assertWriteFence(goalId, op, data) {
-        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) {
-        return atomicWrite(filePath, data);
-    }
-    async atomicRead(filePath) {
-        return atomicRead(filePath, this.logger);
-    }
-    isEnoent(error) {
-        return error.code === "ENOENT";
-    }
-    async pathExists(filePath) {
-        try {
-            await fsp.access(filePath);
-            return true;
-        }
-        catch (e) {
-            if (!this.isEnoent(e))
-                throw e;
-            return false;
-        }
-    }
-    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 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))
-            return false;
-        visited.add(goalId);
-        return true;
-    }
-    capHistoryEntries(entries) {
-        return entries.slice(-MAX_HISTORY_ENTRIES);
-    }
-    assertObservationGoalId(goalId, entry) {
-        if (entry.goal_id !== goalId) {
-            throw new StateError(`appendObservation: entry.goal_id ("${entry.goal_id}") does not match goalId ("${goalId}")`);
-        }
-    }
-    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);
-        await this.runGoalStateMutation(parsed.id, "save_goal", parsed, async () => {
-            await (await this.goalTaskStateStore()).saveGoal(parsed);
-        });
-    }
-    async loadGoal(goalId) {
-        return (await this.goalTaskStateStore()).loadGoal(goalId, { includeArchived: true });
-    }
-    async deleteGoal(goalId, _visited = new Set()) {
-        if (!this.markGoalVisited(goalId, _visited))
-            return false;
-        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 DB-owned goal without falling back to legacy goal JSON. */
-    async archiveGoal(goalId, _visited = new Set()) {
-        if (!this.markGoalVisited(goalId, _visited))
-            return false;
-        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 DB-owned archived goal IDs. Legacy archive directories are exposed
-     * only through listRecoverableArchivedGoalIds() for explicit migration/recovery.
-     */
-    async listArchivedGoals() {
-        return (await this.goalTaskStateStore()).listGoalIds({ archived: true });
-    }
-    async listGoalIds() {
-        return (await this.goalTaskStateStore()).listGoalIds({ archived: false });
-    }
-    async listRecoverableArchivedGoalIds() {
-        return listRecoverableArchivedGoalIdsFromState(this.baseDir, (filePath) => this.pathExists(filePath));
-    }
-    async listTasks(goalId, options = {}) {
-        void options;
-        return (await this.goalTaskStateStore()).listTasks(goalId);
-    }
-    async listTasksByStatus(status) {
-        return (await this.goalTaskStateStore()).listTasksByStatus(status);
-    }
-    async loadTask(goalId, taskId, options = {}) {
-        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);
-        await (await this.goalTaskStateStore()).saveGoalTree(parsed);
-    }
-    async loadGoalTree(rootId) {
-        return (await this.goalTaskStateStore()).loadGoalTree(rootId);
-    }
-    async deleteGoalTree(rootId) {
-        return (await this.goalTaskStateStore()).deleteGoalTree(rootId);
-    }
-    // ─── Observation Log ───
-    async saveObservationLog(log) {
-        const parsed = ObservationLogSchema.parse(log);
-        await this.runGoalStateMutation(parsed.goal_id, "save_observation", parsed, async () => {
-            await (await this.goalTaskStateStore()).saveObservationLog(parsed);
-        });
-    }
-    async loadObservationLog(goalId) {
-        return (await this.goalTaskStateStore()).loadObservationLog(goalId);
-    }
-    async appendObservation(goalId, entry) {
-        const parsed = ObservationLogEntrySchema.parse(entry);
-        this.assertObservationGoalId(goalId, parsed);
-        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.runGoalStateMutation(goalId, "save_gap_history", { goalId, entries: parsed }, async () => {
-            await (await this.goalTaskStateStore()).saveGapHistory(goalId, parsed);
-        });
-    }
-    async loadGapHistory(goalId) {
-        return (await this.goalTaskStateStore()).loadGapHistory(goalId);
-    }
-    async appendGapHistoryEntry(goalId, entry) {
-        const parsed = GapHistoryEntrySchema.parse(entry);
-        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);
-        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 updatedGoal = GoalSchema.parse(updateGoal(goal));
-            if (updatedGoal.id !== goalId) {
-                throw new StateError(`appendObservationAndSaveGoal: update changed goal id from "${goalId}" to "${updatedGoal.id}"`);
-            }
-            await store.appendObservation(goalId, parsed, MAX_HISTORY_ENTRIES);
-            await store.saveGoal(updatedGoal);
-        });
-    }
-    /**
-     * Save a pace snapshot to a milestone goal (persists to disk).
-     */
-    async savePaceSnapshot(goalId, snapshot) {
-        const goal = await this.loadGoal(goalId);
-        if (!goal) {
-            throw new StateError(`savePaceSnapshot: goal "${goalId}" not found`);
-        }
-        const updated = { ...goal, pace_snapshot: snapshot };
-        await this.runGoalStateMutation(goalId, "save_pace_snapshot", updated, async () => {
-            await (await this.goalTaskStateStore()).saveGoal(GoalSchema.parse(updated));
-        });
-    }
-    // ─── Goal Tree Traversal ───
-    /**
-     * BFS traversal starting at rootId.
-     * Returns null if rootId doesn't exist, otherwise returns goals in BFS order.
-     */
-    async bfsCollect(rootId) {
-        const root = await this.loadGoal(rootId);
-        if (root === null)
-            return null;
-        const result = [];
-        const queue = [rootId];
-        const visited = new Set();
-        for (let index = 0; index < queue.length; index++) {
-            const currentId = queue[index];
-            if (visited.has(currentId))
-                continue;
-            visited.add(currentId);
-            const goal = await this.loadGoal(currentId);
-            if (goal === null)
-                continue;
-            result.push(goal);
-            for (const childId of goal.children_ids) {
-                if (!visited.has(childId)) {
-                    queue.push(childId);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Get the full goal tree rooted at rootId.
-     * Returns null if the root goal doesn't exist.
-     * Returns goals in BFS order: root first, then children level by level.
-     */
-    async getGoalTree(rootId) {
-        return this.bfsCollect(rootId);
-    }
-    /**
-     * Get all goals in the subtree of goalId (including goalId itself).
-     * Returns [] if goal not found.
-     */
-    async getSubtree(goalId) {
-        return (await this.bfsCollect(goalId)) ?? [];
-    }
-    /**
-     * Update a goal that belongs to a tree, handling both goal and tree consistency.
-     * Merges updates into the existing goal, preserving its id.
-     * If the goal has a parent_id, ensures the parent's children_ids still includes this goal.
-     */
-    async updateGoalInTree(goalId, updates) {
-        const existingGoal = await this.loadGoal(goalId);
-        if (existingGoal === null) {
-            throw new StateError(`updateGoalInTree: goal "${goalId}" not found`);
-        }
-        const updatedGoal = {
-            ...existingGoal,
-            ...updates,
-            id: existingGoal.id, // id is immutable
-        };
-        await this.saveGoal(updatedGoal);
-        // Ensure parent's children_ids still includes this goal
-        if (existingGoal.parent_id !== null) {
-            const parent = await this.loadGoal(existingGoal.parent_id);
-            if (parent !== null && !parent.children_ids.includes(goalId)) {
-                await this.saveGoal({
-                    ...parent,
-                    children_ids: [...parent.children_ids, goalId],
-                    updated_at: new Date().toISOString(),
-                });
-            }
-        }
-    }
-    // ─── Utility ───
-    /** Check whether a goal directory exists */
-    async goalExists(goalId) {
-        return (await this.goalTaskStateStore()).goalExists(goalId);
-    }
-    /**
-     * Restore dimension values and trust balance from a loop crash-recovery checkpoint.
-     * Uses Zod validation on both the checkpoint and the goal.
-     * Returns the saved cycle_number so the caller can resume iteration counting,
-     * or 0 if no checkpoint exists or restoration fails (non-fatal).
-     */
-    async restoreFromCheckpoint(goalId, adapterType, trustManager) {
-        try {
-            const raw = await (await this.goalTaskStateStore()).loadLoopCheckpoint(goalId);
-            if (raw === null)
-                return 0;
-            const parseResult = LoopCheckpointSchema.safeParse(raw);
-            if (!parseResult.success) {
-                this.logger?.warn(`[StateManager] Invalid checkpoint for "${goalId}": ${parseResult.error.message}`);
-                return 0;
-            }
-            const cp = parseResult.data;
-            // Restore dimension values from snapshot
-            if (cp.dimension_snapshot) {
-                const goal = await this.loadGoal(goalId);
-                if (goal !== null) {
-                    const updatedDimensions = goal.dimensions.map((dim) => {
-                        const snapshotVal = cp.dimension_snapshot[dim.name];
-                        return typeof snapshotVal === "number"
-                            ? { ...dim, current_value: snapshotVal }
-                            : dim;
-                    });
-                    await this.saveGoal({ ...goal, dimensions: updatedDimensions });
-                }
-            }
-            // Restore trust balance for the adapter domain
-            if (typeof cp.trust_snapshot === "number" && trustManager) {
-                try {
-                    await trustManager.setOverride(adapterType, cp.trust_snapshot, "checkpoint_restore");
-                }
-                catch {
-                    // Non-fatal — trust restore failure should not abort the run
-                }
-            }
-            return cp.cycle_number;
-        }
-        catch {
-            // Checkpoint restore failure is non-fatal — caller starts from beginning
-            return 0;
-        }
-    }
-    /** 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 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 {
-            await fsp.mkdir(dir, { recursive: true });
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                return;
-            throw err;
-        }
-        await this.atomicWrite(filePath, data);
-    }
-}
-//# sourceMappingURL=state-manager.js.map