pulseed 0.0.1 → 0.1.0

package/dist/goal/tree-loop-orchestrator.js

@@ -0,0 +1,268 @@
+import { hasValidatedDimensions } from "./goal-refiner.js";
+/**
+ * TreeLoopOrchestrator manages the execution of independent loops across
+ * all nodes in a goal tree.
+ *
+ * Responsibilities:
+ *   - Selecting the next node to execute (leaf-first priority)
+ *   - Enforcing parallel_loop_limit for concurrent execution
+ *   - Tracking loop_status transitions (idle → running → idle/paused)
+ *   - Triggering state aggregation on node completion
+ *   - Detecting and cascading completion up the tree
+ *
+ * Design ref: docs/design/goal-tree.md §14C
+ */
+export class TreeLoopOrchestrator {
+    stateManager;
+    goalTreeManager;
+    stateAggregator;
+    satisficingJudge;
+    goalRefiner;
+    /**
+     * GoalDecompositionConfig used to control parallel execution limits.
+     * Updated by startTreeExecution(); defaults applied until first call.
+     */
+    config = {
+        max_depth: 5,
+        min_specificity: 0.7,
+        auto_prune_threshold: 0.3,
+        parallel_loop_limit: 3,
+    };
+    constructor(stateManager, goalTreeManager, stateAggregator, satisficingJudge, goalRefiner) {
+        this.stateManager = stateManager;
+        this.goalTreeManager = goalTreeManager;
+        this.stateAggregator = stateAggregator;
+        this.satisficingJudge = satisficingJudge;
+        this.goalRefiner = goalRefiner;
+    }
+    // ─── Tree Execution Initialization ───
+    /**
+     * Initialize tree execution.
+     * Saves the config and optionally resets all node loop_status to "idle".
+     * The actual per-node loops are driven by CoreLoop calling selectNextNode()
+     * in a tree-mode iteration.
+     */
+    async startTreeExecution(rootId, config) {
+        this.config = config;
+        // Reset all nodes in the tree to loop_status: "idle" to ensure clean state
+        const root = await this.stateManager.loadGoal(rootId);
+        if (!root)
+            return;
+        const now = new Date().toISOString();
+        const allIds = [rootId, ...await this._collectAllDescendantIds(rootId)];
+        for (const id of allIds) {
+            const goal = await this.stateManager.loadGoal(id);
+            if (goal && goal.loop_status !== "idle") {
+                await this.stateManager.saveGoal({
+                    ...goal,
+                    loop_status: "idle",
+                    updated_at: now,
+                });
+            }
+        }
+    }
+    // ─── Node Selection ───
+    /**
+     * Ensure the goal at goalId has been refined (has validated leaves or children).
+     * When GoalRefiner is available and the goal has no validated leaf dimensions
+     * and no children, calls refiner.refine(goalId).
+     * Falls back to GoalTreeManager.decomposeGoal() if refiner is absent.
+     * No-op if the goal already has children or validated dimensions.
+     */
+    async ensureGoalRefined(goalId) {
+        const goal = await this.stateManager.loadGoal(goalId);
+        if (!goal)
+            return;
+        // Already has children — no refinement needed
+        if (goal.children_ids.length > 0)
+            return;
+        // Already has validated dimensions — no refinement needed
+        if (hasValidatedDimensions(goal))
+            return;
+        const defaultDecompConfig = {
+            max_depth: this.config.max_depth,
+            min_specificity: this.config.min_specificity,
+            auto_prune_threshold: this.config.auto_prune_threshold,
+            parallel_loop_limit: this.config.parallel_loop_limit,
+        };
+        if (this.goalRefiner) {
+            try {
+                await this.goalRefiner.refine(goalId);
+            }
+            catch {
+                // Non-fatal: fall back to raw decompose if refiner errors
+                try {
+                    await this.goalTreeManager.decomposeGoal(goalId, defaultDecompConfig);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        else {
+            try {
+                await this.goalTreeManager.decomposeGoal(goalId, defaultDecompConfig);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /**
+     * Select the next node to execute from the tree rooted at rootId.
+     *
+     * Algorithm (MVP: leaf-first):
+     *   1. Get tree state — if active_loops.length >= parallel_loop_limit, return null.
+     *   2. Collect all goal IDs in the tree (root + descendants).
+     *   3. Filter to active + idle nodes (not running, not paused).
+     *   4. Prefer leaf nodes (node_type === "leaf") over non-leaf nodes.
+     *   5. Return the first candidate's ID and set its loop_status to "running".
+     *
+     * Returns null when:
+     *   - parallel_loop_limit is already reached
+     *   - No eligible (active + idle) nodes remain
+     */
+    async selectNextNode(rootId) {
+        // Step 1: Check parallel limit
+        const treeState = await this.goalTreeManager.getTreeState(rootId);
+        if (treeState.active_loops.length >= this.config.parallel_loop_limit) {
+            return null;
+        }
+        // Step 2: Collect all IDs (root + all descendants)
+        const allIds = [rootId, ...await this._collectAllDescendantIds(rootId)];
+        const selectedId = await this._selectEligibleNodeId(allIds);
+        if (selectedId === null)
+            return null;
+        // Mark selected node as running
+        const selected = await this.stateManager.loadGoal(selectedId);
+        if (selected) {
+            await this.stateManager.saveGoal({
+                ...selected,
+                loop_status: "running",
+                updated_at: new Date().toISOString(),
+            });
+        }
+        return selectedId;
+    }
+    // ─── Node Loop Control ───
+    /**
+     * Pause the loop for a specific node.
+     * Sets loop_status to "paused".
+     * No-op if the goal is not found.
+     */
+    async pauseNodeLoop(goalId) {
+        const goal = await this.stateManager.loadGoal(goalId);
+        if (!goal)
+            return;
+        await this.stateManager.saveGoal({
+            ...goal,
+            loop_status: "paused",
+            updated_at: new Date().toISOString(),
+        });
+    }
+    /**
+     * Resume the loop for a specific node.
+     * Sets loop_status to "running".
+     * No-op if the goal is not found.
+     */
+    async resumeNodeLoop(goalId) {
+        const goal = await this.stateManager.loadGoal(goalId);
+        if (!goal)
+            return;
+        await this.stateManager.saveGoal({
+            ...goal,
+            loop_status: "running",
+            updated_at: new Date().toISOString(),
+        });
+    }
+    // ─── Node Completion Callback ───
+    /**
+     * Called when a node's execution cycle completes.
+     *
+     * Actions:
+     *   1. Reset loop_status to "idle" (release the execution slot).
+     *   2. Aggregate state bottom-up to the root.
+     *   3. Run completion cascade to auto-complete ancestor nodes whose
+     *      children are all done.
+     */
+    async onNodeCompleted(goalId) {
+        const now = new Date().toISOString();
+        // Step 1: Reset loop_status to "idle"
+        const goal = await this.stateManager.loadGoal(goalId);
+        if (goal) {
+            await this.stateManager.saveGoal({
+                ...goal,
+                loop_status: "idle",
+                updated_at: now,
+            });
+        }
+        // Step 2: Aggregate parent chain bottom-up
+        let parentId = goal?.parent_id ?? null;
+        while (parentId !== null) {
+            try {
+                await this.stateAggregator.aggregateChildStates(parentId);
+            }
+            catch {
+                // Non-fatal: parent may be missing or have no children
+                break;
+            }
+            const parent = await this.stateManager.loadGoal(parentId);
+            parentId = parent?.parent_id ?? null;
+        }
+        // Step 3: Completion cascade
+        await this._applyCompletionCascade(goalId, now);
+    }
+    // ─── Private Helpers ───
+    /**
+     * Collect all descendant IDs (not including rootId itself).
+     */
+    async _collectAllDescendantIds(goalId) {
+        const goal = await this.stateManager.loadGoal(goalId);
+        if (!goal)
+            return [];
+        const result = [];
+        for (const childId of goal.children_ids) {
+            result.push(childId);
+            result.push(...await this._collectAllDescendantIds(childId));
+        }
+        return result;
+    }
+    /**
+     * Select the best eligible node from the tree, preferring active idle leaves
+     * and deeper leaves before non-leaf nodes.
+     */
+    async _selectEligibleNodeId(allIds) {
+        const eligibleLeaves = [];
+        const eligibleNonLeaves = [];
+        for (const id of allIds) {
+            const goal = await this.stateManager.loadGoal(id);
+            if (!goal)
+                continue;
+            if (goal.status !== "active")
+                continue;
+            if (goal.loop_status === "running" || goal.loop_status === "paused")
+                continue;
+            if (goal.node_type === "leaf") {
+                eligibleLeaves.push({ id, depth: goal.decomposition_depth ?? 0 });
+            }
+            else {
+                eligibleNonLeaves.push(id);
+            }
+        }
+        eligibleLeaves.sort((a, b) => b.depth - a.depth);
+        return eligibleLeaves[0]?.id ?? eligibleNonLeaves[0] ?? null;
+    }
+    /**
+     * Apply completion cascade results by marking each ancestor as completed.
+     */
+    async _applyCompletionCascade(goalId, now) {
+        const cascadeIds = await this.stateAggregator.checkCompletionCascade(goalId);
+        for (const ancestorId of cascadeIds) {
+            const ancestor = await this.stateManager.loadGoal(ancestorId);
+            if (ancestor && ancestor.status !== "completed") {
+                await this.stateManager.saveGoal({
+                    ...ancestor,
+                    status: "completed",
+                    updated_at: now,
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=tree-loop-orchestrator.js.map

package/dist/goal/tree-loop-orchestrator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-loop-orchestrator.js","sourceRoot":"","sources":["../../src/goal/tree-loop-orchestrator.ts"],"names":[],"mappings":"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"}

package/dist/goal-dependency-graph.d.ts

@@ -0,0 +1,112 @@
+import type { StateManager } from "./state-manager.js";
+import type { ILLMClient } from "./llm/llm-client.js";
+import type { DependencyEdge, DependencyEdgeStatus, DependencyGraph } from "./types/dependency.js";
+import type { DependencyType } from "./types/core.js";
+/**
+ * GoalDependencyGraph manages a DAG of dependencies between goals.
+ *
+ * Supports 4 edge types:
+ *   - prerequisite: goal A must complete before goal B can start
+ *   - resource_conflict: goals A and B compete for the same resource
+ *   - synergy: progress on goal A helps goal B
+ *   - conflict: goals A and B have incompatible objectives
+ *
+ * Persistence: ~/.motiva/dependency-graph.json (via StateManager.readRaw/writeRaw)
+ */
+export declare class GoalDependencyGraph {
+    private stateManager;
+    private llmClient?;
+    private graph;
+    constructor(stateManager: StateManager, llmClient?: ILLMClient);
+    /**
+     * Adds an edge to the graph.
+     * For prerequisite edges, validates that the addition would not create a cycle.
+     */
+    addEdge(edge: Omit<DependencyEdge, "created_at">): DependencyEdge;
+    /**
+     * Removes an edge matching from/to/type from the graph.
+     */
+    removeEdge(fromGoalId: string, toGoalId: string, type: DependencyType): void;
+    /**
+     * Updates the status of an edge identified by from/to.
+     */
+    updateEdgeStatus(fromGoalId: string, toGoalId: string, status: DependencyEdgeStatus): void;
+    /**
+     * Returns all edges where goalId appears as either from or to.
+     */
+    getEdges(goalId: string): DependencyEdge[];
+    /**
+     * Returns the first edge matching from/to (and optionally type), or null.
+     */
+    getEdge(fromGoalId: string, toGoalId: string, type?: DependencyType): DependencyEdge | null;
+    /**
+     * Detects whether adding a prerequisite edge from→to would create a cycle.
+     *
+     * Uses BFS starting from "to" following active prerequisite edges.
+     * If we can reach "from", adding from→to would form a cycle.
+     */
+    detectCycle(fromGoalId: string, toGoalId: string): boolean;
+    /**
+     * Returns active prerequisite edges that must be satisfied before goalId can proceed.
+     */
+    getPrerequisites(goalId: string): DependencyEdge[];
+    /**
+     * Returns true if goalId has unresolved prerequisites.
+     */
+    isBlocked(goalId: string): boolean;
+    /**
+     * Returns the IDs of goals that must complete before goalId can proceed.
+     */
+    getBlockingGoals(goalId: string): string[];
+    /**
+     * Returns active resource_conflict edges involving goalId.
+     */
+    getResourceConflicts(goalId: string): DependencyEdge[];
+    /**
+     * Returns goal IDs that have a synergy relationship with goalId.
+     */
+    getSynergyPartners(goalId: string): string[];
+    /**
+     * Uses an LLM to automatically detect dependency relationships between a new goal
+     * and a set of existing goals. Detected dependencies are added to the graph.
+     *
+     * Returns an empty array if no LLM client is configured or no existing goals are provided.
+     */
+    autoDetectDependencies(newGoalId: string, existingGoalIds: string[]): Promise<DependencyEdge[]>;
+    /**
+     * Add a strategy-level dependency between two strategies.
+     * Uses DependencyType "strategy_dependency" for the underlying edge.
+     * The sourceStrategyId is stored in from_goal_id and targetStrategyId in to_goal_id.
+     */
+    addStrategyDependency(sourceStrategyId: string, targetStrategyId: string, dependencyType: "prerequisite" | "enhances", goalId: string): void;
+    /**
+     * Get all strategy dependencies for a given strategy.
+     * Returns edges where this strategy is either source or target.
+     */
+    getStrategyDependencies(strategyId: string): Array<{
+        source_strategy_id: string;
+        target_strategy_id: string;
+        dependency_type: "prerequisite" | "enhances";
+        goal_id: string;
+    }>;
+    /**
+     * Check if a strategy is blocked by a prerequisite dependency.
+     * Returns true if the strategy has a prerequisite dependency where
+     * the source strategy is NOT in completedStrategyIds.
+     */
+    isStrategyBlocked(strategyId: string, completedStrategyIds: string[]): boolean;
+    /**
+     * Loads the dependency graph from disk.
+     * Returns an empty graph if no file exists or parsing fails.
+     */
+    load(): DependencyGraph;
+    /**
+     * Persists the dependency graph to disk.
+     */
+    save(graph: DependencyGraph): void;
+    /**
+     * Returns the current in-memory graph.
+     */
+    getGraph(): DependencyGraph;
+}
+//# sourceMappingURL=goal-dependency-graph.d.ts.map

package/dist/goal-dependency-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goal-dependency-graph.d.ts","sourceRoot":"","sources":["../src/goal-dependency-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,SAAS,CAAC,CAAa;IAC/B,OAAO,CAAC,KAAK,CAAkB;gBAEnB,YAAY,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,UAAU;IAQ9D;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG,cAAc;IA0BjE;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI;IAa5E;;OAEG;IACH,gBAAgB,CACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,oBAAoB,GAC3B,IAAI;IASP;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE;IAM1C;;OAEG;IACH,OAAO,CACL,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,cAAc,GACpB,cAAc,GAAG,IAAI;IAaxB;;;;;OAKG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IA4B1D;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE;IASlD;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAI1C;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE;IAStD;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAe5C;;;;;OAKG;IACG,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EAAE,GACxB,OAAO,CAAC,cAAc,EAAE,CAAC;IA0D5B;;;;OAIG;IACH,qBAAqB,CACnB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,cAAc,GAAG,UAAU,EAC3C,MAAM,EAAE,MAAM,GACb,IAAI;IAcP;;;OAGG;IACH,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,CAAC;QACjD,kBAAkB,EAAE,MAAM,CAAC;QAC3B,kBAAkB,EAAE,MAAM,CAAC;QAC3B,eAAe,EAAE,cAAc,GAAG,UAAU,CAAC;QAC7C,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAqBF;;;;OAIG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,GAAG,OAAO;IAY9E;;;OAGG;IACH,IAAI,IAAI,eAAe;IAYvB;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAIlC;;OAEG;IACH,QAAQ,IAAI,eAAe;CAG5B"}

package/dist/goal-dependency-graph.js

@@ -0,0 +1,291 @@
+import { DependencyGraphSchema } from "./types/dependency.js";
+/**
+ * GoalDependencyGraph manages a DAG of dependencies between goals.
+ *
+ * Supports 4 edge types:
+ *   - prerequisite: goal A must complete before goal B can start
+ *   - resource_conflict: goals A and B compete for the same resource
+ *   - synergy: progress on goal A helps goal B
+ *   - conflict: goals A and B have incompatible objectives
+ *
+ * Persistence: ~/.motiva/dependency-graph.json (via StateManager.readRaw/writeRaw)
+ */
+export class GoalDependencyGraph {
+    stateManager;
+    llmClient;
+    graph;
+    constructor(stateManager, llmClient) {
+        this.stateManager = stateManager;
+        this.llmClient = llmClient;
+        this.graph = this.load();
+    }
+    // ─── CRUD ───
+    /**
+     * Adds an edge to the graph.
+     * For prerequisite edges, validates that the addition would not create a cycle.
+     */
+    addEdge(edge) {
+        if (edge.type === "prerequisite" && this.detectCycle(edge.from_goal_id, edge.to_goal_id)) {
+            throw new Error(`Adding prerequisite ${edge.from_goal_id} → ${edge.to_goal_id} would create a cycle`);
+        }
+        const fullEdge = {
+            ...edge,
+            created_at: new Date().toISOString(),
+        };
+        // Add nodes if not present
+        if (!this.graph.nodes.includes(edge.from_goal_id)) {
+            this.graph.nodes.push(edge.from_goal_id);
+        }
+        if (!this.graph.nodes.includes(edge.to_goal_id)) {
+            this.graph.nodes.push(edge.to_goal_id);
+        }
+        this.graph.edges.push(fullEdge);
+        this.graph.updated_at = new Date().toISOString();
+        this.save(this.graph);
+        return fullEdge;
+    }
+    /**
+     * Removes an edge matching from/to/type from the graph.
+     */
+    removeEdge(fromGoalId, toGoalId, type) {
+        this.graph.edges = this.graph.edges.filter((e) => !(e.from_goal_id === fromGoalId &&
+            e.to_goal_id === toGoalId &&
+            e.type === type));
+        this.graph.updated_at = new Date().toISOString();
+        this.save(this.graph);
+    }
+    /**
+     * Updates the status of an edge identified by from/to.
+     */
+    updateEdgeStatus(fromGoalId, toGoalId, status) {
+        const edge = this.getEdge(fromGoalId, toGoalId);
+        if (edge) {
+            edge.status = status;
+            this.graph.updated_at = new Date().toISOString();
+            this.save(this.graph);
+        }
+    }
+    /**
+     * Returns all edges where goalId appears as either from or to.
+     */
+    getEdges(goalId) {
+        return this.graph.edges.filter((e) => e.from_goal_id === goalId || e.to_goal_id === goalId);
+    }
+    /**
+     * Returns the first edge matching from/to (and optionally type), or null.
+     */
+    getEdge(fromGoalId, toGoalId, type) {
+        return (this.graph.edges.find((e) => e.from_goal_id === fromGoalId &&
+            e.to_goal_id === toGoalId &&
+            (!type || e.type === type)) ?? null);
+    }
+    // ─── DAG Validation ───
+    /**
+     * Detects whether adding a prerequisite edge from→to would create a cycle.
+     *
+     * Uses BFS starting from "to" following active prerequisite edges.
+     * If we can reach "from", adding from→to would form a cycle.
+     */
+    detectCycle(fromGoalId, toGoalId) {
+        const visited = new Set();
+        const queue = [toGoalId];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === fromGoalId)
+                return true;
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            // Follow active prerequisite edges where current is the from_goal_id
+            for (const edge of this.graph.edges) {
+                if (edge.type === "prerequisite" &&
+                    edge.from_goal_id === current &&
+                    edge.status === "active") {
+                    queue.push(edge.to_goal_id);
+                }
+            }
+        }
+        return false;
+    }
+    // ─── Scheduling Influence ───
+    /**
+     * Returns active prerequisite edges that must be satisfied before goalId can proceed.
+     */
+    getPrerequisites(goalId) {
+        return this.graph.edges.filter((e) => e.to_goal_id === goalId &&
+            e.type === "prerequisite" &&
+            e.status === "active");
+    }
+    /**
+     * Returns true if goalId has unresolved prerequisites.
+     */
+    isBlocked(goalId) {
+        return this.getPrerequisites(goalId).length > 0;
+    }
+    /**
+     * Returns the IDs of goals that must complete before goalId can proceed.
+     */
+    getBlockingGoals(goalId) {
+        return this.getPrerequisites(goalId).map((e) => e.from_goal_id);
+    }
+    /**
+     * Returns active resource_conflict edges involving goalId.
+     */
+    getResourceConflicts(goalId) {
+        return this.graph.edges.filter((e) => e.type === "resource_conflict" &&
+            e.status === "active" &&
+            (e.from_goal_id === goalId || e.to_goal_id === goalId));
+    }
+    /**
+     * Returns goal IDs that have a synergy relationship with goalId.
+     */
+    getSynergyPartners(goalId) {
+        return this.graph.edges
+            .filter((e) => e.type === "synergy" &&
+            e.status === "active" &&
+            (e.from_goal_id === goalId || e.to_goal_id === goalId))
+            .map((e) => e.from_goal_id === goalId ? e.to_goal_id : e.from_goal_id);
+    }
+    // ─── LLM Auto-detection ───
+    /**
+     * Uses an LLM to automatically detect dependency relationships between a new goal
+     * and a set of existing goals. Detected dependencies are added to the graph.
+     *
+     * Returns an empty array if no LLM client is configured or no existing goals are provided.
+     */
+    async autoDetectDependencies(newGoalId, existingGoalIds) {
+        if (!this.llmClient || existingGoalIds.length === 0)
+            return [];
+        const prompt = `Analyze dependencies between a new goal and existing goals.
+
+New goal ID: ${newGoalId}
+Existing goal IDs: ${existingGoalIds.join(", ")}
+
+For each relationship found, return a JSON array of objects with:
+- from_goal_id: string
+- to_goal_id: string
+- type: "prerequisite" | "resource_conflict" | "synergy" | "conflict"
+- condition: string or null (when is this dependency satisfied?)
+- affected_dimensions: string[] (which dimensions are affected)
+- reasoning: string (why this dependency exists)
+- detection_confidence: number 0-1
+
+Return empty array [] if no dependencies found.`;
+        const messages = [{ role: "user", content: prompt }];
+        try {
+            const response = await this.llmClient.sendMessage(messages);
+            const parsed = JSON.parse(response.content);
+            if (!Array.isArray(parsed))
+                return [];
+            const edges = [];
+            for (const item of parsed) {
+                try {
+                    const edge = this.addEdge({
+                        from_goal_id: String(item["from_goal_id"] ?? ""),
+                        to_goal_id: String(item["to_goal_id"] ?? ""),
+                        type: item["type"] ?? "conflict",
+                        status: "active",
+                        condition: typeof item["condition"] === "string" ? item["condition"] : null,
+                        affected_dimensions: Array.isArray(item["affected_dimensions"])
+                            ? item["affected_dimensions"]
+                            : [],
+                        mitigation: null,
+                        detection_confidence: typeof item["detection_confidence"] === "number"
+                            ? item["detection_confidence"]
+                            : 0.5,
+                        reasoning: typeof item["reasoning"] === "string" ? item["reasoning"] : null,
+                    });
+                    edges.push(edge);
+                }
+                catch {
+                    // Skip malformed items
+                }
+            }
+            return edges;
+        }
+        catch {
+            return [];
+        }
+    }
+    // ─── Strategy Dependencies ───
+    /**
+     * Add a strategy-level dependency between two strategies.
+     * Uses DependencyType "strategy_dependency" for the underlying edge.
+     * The sourceStrategyId is stored in from_goal_id and targetStrategyId in to_goal_id.
+     */
+    addStrategyDependency(sourceStrategyId, targetStrategyId, dependencyType, goalId) {
+        this.addEdge({
+            from_goal_id: sourceStrategyId,
+            to_goal_id: targetStrategyId,
+            type: "strategy_dependency",
+            status: "active",
+            condition: null,
+            affected_dimensions: [],
+            mitigation: null,
+            detection_confidence: 1.0,
+            reasoning: `strategy_dependency_type:${dependencyType};goal_id:${goalId}`,
+        });
+    }
+    /**
+     * Get all strategy dependencies for a given strategy.
+     * Returns edges where this strategy is either source or target.
+     */
+    getStrategyDependencies(strategyId) {
+        return this.graph.edges
+            .filter((e) => e.type === "strategy_dependency" &&
+            (e.from_goal_id === strategyId || e.to_goal_id === strategyId))
+            .map((e) => {
+            // Extract dependency_type and goal_id from the reasoning field
+            const reasoning = e.reasoning ?? "";
+            const dtMatch = reasoning.match(/strategy_dependency_type:(prerequisite|enhances)/);
+            const giMatch = reasoning.match(/goal_id:([^;]+)/);
+            return {
+                source_strategy_id: e.from_goal_id,
+                target_strategy_id: e.to_goal_id,
+                dependency_type: (dtMatch?.[1] ?? "prerequisite"),
+                goal_id: giMatch?.[1] ?? "",
+            };
+        });
+    }
+    /**
+     * Check if a strategy is blocked by a prerequisite dependency.
+     * Returns true if the strategy has a prerequisite dependency where
+     * the source strategy is NOT in completedStrategyIds.
+     */
+    isStrategyBlocked(strategyId, completedStrategyIds) {
+        const deps = this.getStrategyDependencies(strategyId);
+        return deps.some((d) => d.dependency_type === "prerequisite" &&
+            d.target_strategy_id === strategyId &&
+            !completedStrategyIds.includes(d.source_strategy_id));
+    }
+    // ─── Persistence ───
+    /**
+     * Loads the dependency graph from disk.
+     * Returns an empty graph if no file exists or parsing fails.
+     */
+    load() {
+        try {
+            const raw = this.stateManager.readRaw("dependency-graph.json");
+            if (raw !== null) {
+                return DependencyGraphSchema.parse(raw);
+            }
+        }
+        catch {
+            // ignore parse errors — start fresh
+        }
+        return { nodes: [], edges: [], updated_at: new Date().toISOString() };
+    }
+    /**
+     * Persists the dependency graph to disk.
+     */
+    save(graph) {
+        this.stateManager.writeRaw("dependency-graph.json", graph);
+    }
+    /**
+     * Returns the current in-memory graph.
+     */
+    getGraph() {
+        return this.graph;
+    }
+}
+//# sourceMappingURL=goal-dependency-graph.js.map