conatus 0.1.0

package/dist/cross-goal-portfolio.js

@@ -0,0 +1,790 @@
+import { scoreDeadline } from "./drive/drive-scorer.js";
+import { CrossGoalPortfolioConfigSchema, } from "./types/cross-portfolio.js";
+// ─── Helpers ───
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * CrossGoalPortfolio manages resource allocation and priority across multiple
+ * active goals. It sits above individual PortfolioManager instances and answers
+ * the question: "given N active goals, how should overall resources be split?"
+ *
+ * Responsibilities:
+ *   - Calculate per-goal priority scores from 4 factors
+ *   - Allocate resource shares proportionally
+ *   - Rebalance on 4 trigger types
+ *   - Recommend strategy templates using vector similarity
+ *
+ * CrossGoalPortfolio does NOT manage strategies within a single goal —
+ * that remains the responsibility of PortfolioManager.
+ */
+export class CrossGoalPortfolio {
+    stateManager;
+    goalDependencyGraph;
+    vectorIndex;
+    embeddingClient;
+    config;
+    /** goalId → cached GoalPriorityFactors from the last calculation */
+    lastPriorities = new Map();
+    constructor(stateManager, goalDependencyGraph, vectorIndex, embeddingClient, config) {
+        this.stateManager = stateManager;
+        this.goalDependencyGraph = goalDependencyGraph;
+        this.vectorIndex = vectorIndex;
+        this.embeddingClient = embeddingClient;
+        this.config = CrossGoalPortfolioConfigSchema.parse(config ?? {});
+    }
+    // ─── Priority Calculation ───
+    /**
+     * Calculate priority factors for each goal in the provided list.
+     *
+     * The 4 factors and their weights:
+     *   w1=0.35  deadline_urgency    — how soon the goal must be finished
+     *   w2=0.25  gap_severity        — worst-case normalized gap across dimensions
+     *   w3=0.25  dependency_weight   — how many goals depend on this one
+     *   w4=0.15  user_priority       — user-specified priority (1-5 → 0-1)
+     *
+     * After the weighted sum is computed, synergy/conflict edges from
+     * GoalDependencyGraph adjust the final score before clamping to [0,1].
+     *
+     * @param goalIds — IDs of goals to evaluate (missing goals are skipped)
+     * @returns GoalPriorityFactors[] sorted by computed_priority descending
+     */
+    calculateGoalPriorities(goalIds) {
+        if (goalIds.length === 0)
+            return [];
+        const totalGoals = goalIds.length;
+        const now = new Date();
+        const rawList = [];
+        for (const goalId of goalIds) {
+            const goal = this.stateManager.loadGoal(goalId);
+            if (!goal)
+                continue;
+            // deadline_urgency — use scoreDeadline with maxGap=1 as the
+            // normalized_weighted_gap input, then read the urgency value.
+            let deadlineUrgency = 0;
+            if (goal.deadline) {
+                const deadlineMs = new Date(goal.deadline).getTime();
+                const timeRemainingHours = (deadlineMs - now.getTime()) / (1000 * 60 * 60);
+                const result = scoreDeadline(1, timeRemainingHours);
+                // Normalize urgency to [0,1]. scoreDeadline with gap=1 means score == urgency.
+                // urgency >= 1 (at minimum). We normalise by capping at the urgency-at-zero cap.
+                // Use urgency directly but clamp to [0,1] after dividing by a reasonable max.
+                // default urgency_steepness=2, deadline_horizon=168h → urgencyAtZero = exp(2) ≈ 7.39
+                const urgencyAtZero = Math.exp(2); // exp(urgency_steepness)
+                deadlineUrgency = clamp(result.urgency / urgencyAtZero, 0, 1);
+            }
+            // gap_severity — max normalized_weighted_gap across all dimensions
+            // We approximate by treating each dimension's gap as proportional
+            // to how far it is from its threshold relative to a known scale.
+            // For simplicity (no GapCalculator instance injected), we derive a
+            // rough severity from the dimension values directly.
+            let gapSeverity = 0;
+            for (const dim of goal.dimensions) {
+                const dimGap = this._estimateDimensionGap(dim);
+                if (dimGap > gapSeverity) {
+                    gapSeverity = dimGap;
+                }
+            }
+            gapSeverity = clamp(gapSeverity, 0, 1);
+            // dependency_weight — how many goals in the provided list depend on this goal
+            const graph = this.goalDependencyGraph.getGraph();
+            const dependentCount = graph.edges.filter((e) => e.from_goal_id === goalId &&
+                e.type === "prerequisite" &&
+                e.status === "active" &&
+                goalIds.includes(e.to_goal_id)).length;
+            const dependencyWeight = totalGoals > 1 ? dependentCount / (totalGoals - 1) : 0;
+            // user_priority — extract from goal constraints or metadata
+            // Assume format "priority:N" (N in 1-5) anywhere in constraints
+            let userPriority = 0.5; // default
+            for (const constraint of goal.constraints) {
+                const match = constraint.match(/\bpriority[:\s=]+(\d+)\b/i);
+                if (match) {
+                    const level = parseInt(match[1], 10);
+                    userPriority = clamp(level / 5, 0, 1);
+                    break;
+                }
+            }
+            rawList.push({
+                goalId,
+                goal,
+                deadlineUrgency,
+                gapSeverity,
+                dependencyWeight: clamp(dependencyWeight, 0, 1),
+                userPriority,
+            });
+        }
+        if (rawList.length === 0)
+            return [];
+        // --- Step 2: compute weighted priority ---
+        const W1 = 0.35;
+        const W2 = 0.25;
+        const W3 = 0.25;
+        const W4 = 0.15;
+        const withBase = rawList.map((r) => {
+            const basePriority = W1 * r.deadlineUrgency +
+                W2 * r.gapSeverity +
+                W3 * r.dependencyWeight +
+                W4 * r.userPriority;
+            return { ...r, basePriority };
+        });
+        // --- Step 3: apply synergy / conflict adjustments ---
+        const synergyBonus = this.config.synergy_bonus / 2; // split the config bonus equally
+        const CONFLICT_PENALTY = 0.15;
+        const goalIdSet = new Set(rawList.map((r) => r.goalId));
+        // Build a lookup: goalId → index in withBase
+        const indexMap = new Map();
+        withBase.forEach((r, i) => indexMap.set(r.goalId, i));
+        // Adjust scores based on dependency edges between goals in the set
+        const adjustments = new Array(withBase.length).fill(0);
+        const graph = this.goalDependencyGraph.getGraph();
+        const seenPairs = new Set();
+        for (const edge of graph.edges) {
+            if (edge.status !== "active")
+                continue;
+            if (!goalIdSet.has(edge.from_goal_id) || !goalIdSet.has(edge.to_goal_id))
+                continue;
+            const pairKey = [edge.from_goal_id, edge.to_goal_id].sort().join("||");
+            if (edge.type === "synergy") {
+                if (!seenPairs.has(pairKey)) {
+                    seenPairs.add(pairKey);
+                    const idxA = indexMap.get(edge.from_goal_id);
+                    const idxB = indexMap.get(edge.to_goal_id);
+                    if (idxA !== undefined)
+                        adjustments[idxA] += synergyBonus;
+                    if (idxB !== undefined)
+                        adjustments[idxB] += synergyBonus;
+                }
+            }
+            else if (edge.type === "conflict") {
+                if (!seenPairs.has(pairKey)) {
+                    seenPairs.add(pairKey);
+                    // Penalise the lower-priority goal
+                    const idxA = indexMap.get(edge.from_goal_id);
+                    const idxB = indexMap.get(edge.to_goal_id);
+                    if (idxA !== undefined && idxB !== undefined) {
+                        const scoreA = withBase[idxA].basePriority;
+                        const scoreB = withBase[idxB].basePriority;
+                        if (scoreA <= scoreB) {
+                            adjustments[idxA] -= CONFLICT_PENALTY;
+                        }
+                        else {
+                            adjustments[idxB] -= CONFLICT_PENALTY;
+                        }
+                    }
+                }
+            }
+        }
+        // --- Step 4: produce final factors ---
+        const result = withBase.map((r, i) => {
+            const computedPriority = clamp(r.basePriority + (adjustments[i] ?? 0), 0, 1);
+            return {
+                goal_id: r.goalId,
+                deadline_urgency: r.deadlineUrgency,
+                gap_severity: r.gapSeverity,
+                dependency_weight: r.dependencyWeight,
+                user_priority: r.userPriority,
+                computed_priority: computedPriority,
+            };
+        });
+        // Sort descending by computed_priority
+        result.sort((a, b) => b.computed_priority - a.computed_priority);
+        // Cache for rebalance
+        for (const f of result) {
+            this.lastPriorities.set(f.goal_id, f);
+        }
+        return result;
+    }
+    // ─── Resource Allocation ───
+    /**
+     * Allocate resource shares across goals based on their priority scores.
+     *
+     * Rules:
+     *   1. If goals > max_concurrent_goals, lowest priority goals get allocation=0
+     *      and are labelled "waiting".
+     *   2. Active goals (up to max_concurrent_goals) share 1.0 proportionally to
+     *      computed_priority, with a floor of min_goal_share.
+     *   3. Sum of active allocations = 1.0.
+     *
+     * @param priorities — output from calculateGoalPriorities
+     * @param strategy   — optional AllocationStrategy (default: 'priority')
+     * @param momentumMap — goalId → MomentumInfo, required when strategy.type === 'momentum'
+     * @param depSchedule — DependencySchedule, required when strategy.type === 'dependency_aware'
+     * @returns CrossGoalAllocation[] in the same order as priorities
+     */
+    allocateResources(priorities, strategy, momentumMap, depSchedule) {
+        if (priorities.length === 0)
+            return [];
+        const { max_concurrent_goals, min_goal_share } = this.config;
+        // Split into active (top N) and waiting (rest), already sorted desc
+        const activeCount = Math.min(priorities.length, max_concurrent_goals);
+        const activePriorities = priorities.slice(0, activeCount);
+        const waitingPriorities = priorities.slice(activeCount);
+        // Build allocations for waiting goals (zero share)
+        const waitingAllocations = waitingPriorities.map((p) => ({
+            goal_id: p.goal_id,
+            priority: p.computed_priority,
+            resource_share: 0,
+            adjustment_reason: `waiting: exceeds max_concurrent_goals (${max_concurrent_goals})`,
+        }));
+        if (activePriorities.length === 0)
+            return waitingAllocations;
+        // Single goal gets everything
+        if (activePriorities.length === 1) {
+            return [
+                {
+                    goal_id: activePriorities[0].goal_id,
+                    priority: activePriorities[0].computed_priority,
+                    resource_share: 1.0,
+                    adjustment_reason: "sole active goal",
+                },
+                ...waitingAllocations,
+            ];
+        }
+        const n = activePriorities.length;
+        // --- Strategy-specific weight computation ---
+        const strategyType = strategy?.type ?? "priority";
+        let weights;
+        let strategyReason;
+        if (strategyType === "equal") {
+            weights = activePriorities.map(() => 1);
+            strategyReason = "equal allocation";
+        }
+        else if (strategyType === "momentum" && momentumMap && momentumMap.size > 0) {
+            const momentumWeight = strategy?.momentumWeight ?? 0.5;
+            // Blend priority and momentum velocity
+            weights = activePriorities.map((p) => {
+                const mom = momentumMap.get(p.goal_id);
+                const vel = mom ? Math.max(mom.velocity, 0) : 0;
+                return (1 - momentumWeight) * p.computed_priority + momentumWeight * vel;
+            });
+            strategyReason = "momentum-weighted";
+        }
+        else if (strategyType === "dependency_aware" && depSchedule) {
+            // Goals on critical path and unblocked goals get a boost
+            const criticalSet = new Set(depSchedule.criticalPath);
+            // Determine which goals are currently unblocked (in phase 0 or phase whose blockedBy are empty)
+            const unblockedGoals = new Set();
+            for (const phase of depSchedule.phases) {
+                if (phase.blockedBy.length === 0) {
+                    for (const id of phase.goalIds)
+                        unblockedGoals.add(id);
+                }
+            }
+            weights = activePriorities.map((p) => {
+                let w = p.computed_priority;
+                if (criticalSet.has(p.goal_id))
+                    w *= 1.5;
+                if (unblockedGoals.has(p.goal_id))
+                    w *= 1.2;
+                return w;
+            });
+            strategyReason = "dependency_aware";
+        }
+        else {
+            // Default: priority-proportional
+            weights = activePriorities.map((p) => p.computed_priority);
+            strategyReason = "priority";
+        }
+        // Proportional allocation with guaranteed min_goal_share floor.
+        //
+        // Algorithm:
+        //   1. Reserve min_goal_share for every active goal.
+        //   2. Distribute the remaining budget (1 - n * min_goal_share) proportionally
+        //      by computed weight.
+        //   3. This guarantees every active goal has at least min_goal_share.
+        //
+        // Edge case: if n * min_goal_share >= 1 (too many goals for the floor to
+        // allow proportional distribution), fall back to equal distribution.
+        const reservedTotal = n * min_goal_share;
+        let finalShares;
+        if (reservedTotal >= 1) {
+            // No room for proportional top-up — give everyone an equal share
+            finalShares = activePriorities.map(() => 1 / n);
+        }
+        else {
+            const remainingBudget = 1 - reservedTotal;
+            const totalWeight = weights.reduce((sum, w) => sum + w, 0);
+            if (totalWeight === 0) {
+                // All zero — split remaining budget equally
+                finalShares = activePriorities.map(() => min_goal_share + remainingBudget / n);
+            }
+            else {
+                finalShares = weights.map((w) => min_goal_share + remainingBudget * (w / totalWeight));
+            }
+        }
+        // Track which goals received the floor for reason strings
+        const totalWeightForReason = weights.reduce((sum, w) => sum + w, 0);
+        const rawShares = totalWeightForReason === 0
+            ? activePriorities.map(() => 1 / n)
+            : weights.map((w) => w / totalWeightForReason);
+        const activeAllocations = activePriorities.map((p, i) => {
+            const share = finalShares[i];
+            const raw = rawShares[i];
+            let reason;
+            if (raw < min_goal_share) {
+                reason = `min_goal_share floor applied (raw=${raw.toFixed(3)}, strategy=${strategyReason})`;
+            }
+            else {
+                reason = `${strategyReason}: weight=${weights[i].toFixed(3)}`;
+            }
+            return {
+                goal_id: p.goal_id,
+                priority: p.computed_priority,
+                resource_share: share,
+                adjustment_reason: reason,
+            };
+        });
+        return [...activeAllocations, ...waitingAllocations];
+    }
+    // ─── Rebalancing ───
+    /**
+     * Recalculate priorities for all currently active goals and produce a new
+     * allocation plan.
+     *
+     * @param trigger — what caused this rebalance
+     * @param goalIds — explicit list of goal IDs to consider; if omitted, the
+     *                  IDs from the last calculateGoalPriorities call are used
+     */
+    rebalanceGoals(trigger, goalIds) {
+        const ids = goalIds ?? Array.from(this.lastPriorities.keys());
+        const priorities = this.calculateGoalPriorities(ids);
+        const allocations = this.allocateResources(priorities);
+        return {
+            timestamp: new Date().toISOString(),
+            allocations,
+            triggered_by: trigger,
+        };
+    }
+    // ─── Template Recommendation ───
+    /**
+     * Search the VectorIndex for strategy templates that match the given goal.
+     *
+     * Matching is based on:
+     *   1. Semantic similarity between the goal text and template hypothesis_pattern
+     *   2. domain_tags overlap (at least 1 tag in common with the goal's domain tags)
+     *   3. Final ranking: similarity × effectiveness_score (descending)
+     *
+     * The caller is responsible for having added StrategyTemplate objects to the
+     * VectorIndex with their `template_id` as the entry id and metadata shaped
+     * as StrategyTemplate fields.
+     *
+     * @param goalId — goal for which templates are requested
+     * @param vectorIndex — the index to search (typically the instance-level one,
+     *                      but callers may pass a different one for testing)
+     * @param limit — number of results to return (default 3)
+     */
+    async getRecommendedTemplates(goalId, vectorIndex, limit = 3) {
+        const goal = this.stateManager.loadGoal(goalId);
+        if (!goal)
+            return [];
+        // Build a query string from the goal
+        const queryText = [goal.title, goal.description, ...goal.constraints]
+            .filter(Boolean)
+            .join(" ");
+        if (!queryText.trim())
+            return [];
+        // Search index — retrieve more than `limit` so we can filter by domain_tags
+        const searchResults = await vectorIndex.search(queryText, limit * 5);
+        if (searchResults.length === 0)
+            return [];
+        // Derive goal domain tags from constraints (format "domain:tag") or title words
+        const goalDomainTags = this._extractDomainTags(goal);
+        // Filter and score
+        const scored = [];
+        for (const result of searchResults) {
+            const meta = result.metadata;
+            // Must have the required StrategyTemplate fields in metadata
+            if (typeof meta["template_id"] !== "string" ||
+                typeof meta["hypothesis_pattern"] !== "string" ||
+                !Array.isArray(meta["domain_tags"]) ||
+                typeof meta["effectiveness_score"] !== "number") {
+                continue;
+            }
+            const domainTags = meta["domain_tags"];
+            const effectivenessScore = meta["effectiveness_score"];
+            // Require at least 1 domain tag overlap — unless goal has no tags (then include all)
+            if (goalDomainTags.length > 0) {
+                const overlap = domainTags.filter((t) => goalDomainTags.includes(t)).length;
+                if (overlap < 1)
+                    continue;
+            }
+            const template = {
+                template_id: meta["template_id"],
+                source_goal_id: typeof meta["source_goal_id"] === "string"
+                    ? meta["source_goal_id"]
+                    : "",
+                source_strategy_id: typeof meta["source_strategy_id"] === "string"
+                    ? meta["source_strategy_id"]
+                    : "",
+                hypothesis_pattern: meta["hypothesis_pattern"],
+                domain_tags: domainTags,
+                effectiveness_score: effectivenessScore,
+                applicable_dimensions: Array.isArray(meta["applicable_dimensions"])
+                    ? meta["applicable_dimensions"]
+                    : [],
+                embedding_id: typeof meta["embedding_id"] === "string"
+                    ? meta["embedding_id"]
+                    : null,
+                created_at: typeof meta["created_at"] === "string"
+                    ? meta["created_at"]
+                    : new Date().toISOString(),
+            };
+            const finalScore = result.similarity * effectivenessScore;
+            scored.push({ template, finalScore });
+        }
+        // Sort by finalScore descending and return top `limit`
+        scored.sort((a, b) => b.finalScore - a.finalScore);
+        return scored.slice(0, limit).map((s) => s.template);
+    }
+    // ─── Momentum ───
+    /**
+     * Calculate momentum for a single goal based on recent state snapshots.
+     *
+     * @param goalId — goal to evaluate
+     * @param snapshots — array of recent progress values (0-1), ordered oldest → newest
+     *                    (typically last 5 iterations). Minimum 2 values required.
+     * @returns MomentumInfo
+     */
+    calculateMomentum(goalId, snapshots) {
+        if (snapshots.length === 0) {
+            return { goalId, recentProgress: 0, velocity: 0, trend: "stalled" };
+        }
+        if (snapshots.length === 1) {
+            return { goalId, recentProgress: 0, velocity: 0, trend: "stalled" };
+        }
+        // recentProgress = total delta from first to last snapshot
+        const recentProgress = snapshots[snapshots.length - 1] - snapshots[0];
+        // velocity = smoothed average per-step delta (EMA-style: weight recent steps more)
+        const deltas = [];
+        for (let i = 1; i < snapshots.length; i++) {
+            deltas.push(snapshots[i] - snapshots[i - 1]);
+        }
+        // Simple smoothed velocity: weighted average where later deltas have higher weight
+        let weightedSum = 0;
+        let weightTotal = 0;
+        for (let i = 0; i < deltas.length; i++) {
+            const w = i + 1; // weight increases for more recent deltas
+            weightedSum += deltas[i] * w;
+            weightTotal += w;
+        }
+        const velocity = weightTotal > 0 ? weightedSum / weightTotal : 0;
+        // Trend detection:
+        //   stalled:       velocity ≈ 0 (< 0.005)
+        //   accelerating:  later half average > earlier half average
+        //   decelerating:  later half average < earlier half average (by ≥ threshold)
+        //   steady:        otherwise
+        let trend;
+        const STALL_THRESHOLD = 0.005;
+        if (Math.abs(velocity) < STALL_THRESHOLD) {
+            trend = "stalled";
+        }
+        else if (deltas.length >= 2) {
+            const mid = Math.floor(deltas.length / 2);
+            const earlyAvg = deltas.slice(0, mid).reduce((s, d) => s + d, 0) / mid;
+            const lateAvg = deltas.slice(mid).reduce((s, d) => s + d, 0) / (deltas.length - mid);
+            const ACCEL_THRESHOLD = 0.002;
+            if (lateAvg > earlyAvg + ACCEL_THRESHOLD) {
+                trend = "accelerating";
+            }
+            else if (lateAvg < earlyAvg - ACCEL_THRESHOLD) {
+                trend = "decelerating";
+            }
+            else {
+                trend = "steady";
+            }
+        }
+        else {
+            // Only 1 delta — classify by sign
+            trend = velocity > 0 ? "steady" : "stalled";
+        }
+        return { goalId, recentProgress, velocity, trend };
+    }
+    // ─── Dependency Scheduling ───
+    /**
+     * Build a phased dependency schedule for the given goals using the provided
+     * GoalDependencyGraph instance.
+     *
+     * The schedule uses topological sort to group goals into phases where all
+     * goals in a phase can run concurrently. Phase 0 contains goals with no
+     * prerequisites; subsequent phases contain goals whose prerequisites are
+     * all satisfied by earlier phases.
+     *
+     * The critical path is the longest chain of prerequisite edges through the
+     * DAG (measured in number of nodes).
+     *
+     * @param goalIds — IDs of goals to schedule
+     * @param graph — the GoalDependencyGraph instance to query
+     * @returns DependencySchedule
+     */
+    buildDependencySchedule(goalIds, graph) {
+        if (goalIds.length === 0) {
+            return { phases: [], criticalPath: [] };
+        }
+        const goalSet = new Set(goalIds);
+        // Build adjacency: prereqMap[child] = Set of parents that must complete first
+        const prereqMap = new Map();
+        for (const id of goalIds) {
+            prereqMap.set(id, new Set());
+        }
+        for (const id of goalIds) {
+            const blockers = graph.getBlockingGoals(id).filter((b) => goalSet.has(b));
+            for (const blocker of blockers) {
+                prereqMap.get(id).add(blocker);
+            }
+        }
+        // Kahn's algorithm for topological sort into phases
+        const phases = [];
+        const completed = new Set();
+        const remaining = new Set(goalIds);
+        let phaseIndex = 0;
+        while (remaining.size > 0) {
+            // Goals whose all prerequisites are completed
+            const readyGoals = [];
+            for (const id of remaining) {
+                const prereqs = prereqMap.get(id);
+                const allSatisfied = [...prereqs].every((p) => completed.has(p));
+                if (allSatisfied) {
+                    readyGoals.push(id);
+                }
+            }
+            if (readyGoals.length === 0) {
+                // Cycle detected or unresolvable — put all remaining in one phase
+                const cycleGoals = [...remaining];
+                const blockedBy = cycleGoals.flatMap((id) => [...(prereqMap.get(id) ?? [])].filter((p) => !completed.has(p)));
+                phases.push({
+                    phase: phaseIndex,
+                    goalIds: cycleGoals,
+                    blockedBy: [...new Set(blockedBy)],
+                });
+                break;
+            }
+            // Collect the set of blockers for this phase's goals
+            const phaseBlockedBy = readyGoals.flatMap((id) => [...(prereqMap.get(id) ?? [])]);
+            phases.push({
+                phase: phaseIndex,
+                goalIds: readyGoals,
+                blockedBy: [...new Set(phaseBlockedBy)],
+            });
+            for (const id of readyGoals) {
+                completed.add(id);
+                remaining.delete(id);
+            }
+            phaseIndex++;
+        }
+        // Critical path: longest chain of prerequisite edges (BFS/DFS from each node)
+        const criticalPath = this._computeCriticalPath(goalIds, prereqMap);
+        return { phases, criticalPath };
+    }
+    // ─── Stall Rebalancing ───
+    /**
+     * Detect stalled goals and redistribute their resources to progressing goals.
+     *
+     * A goal is considered stalled if its MomentumInfo.trend === 'stalled'.
+     * Resources from stalled goals are redistributed proportionally to
+     * non-stalled goals based on their velocity.
+     *
+     * @param currentAllocations — current CrossGoalAllocation array
+     * @param momentumMap — goalId → MomentumInfo
+     * @returns array of RebalanceActions taken (empty if no stalled goals)
+     */
+    rebalanceOnStall(currentAllocations, momentumMap) {
+        const actions = [];
+        if (currentAllocations.length === 0)
+            return actions;
+        const stalled = [];
+        const progressing = [];
+        for (const alloc of currentAllocations) {
+            const mom = momentumMap.get(alloc.goal_id);
+            if (!mom || mom.trend === "stalled") {
+                stalled.push(alloc);
+            }
+            else {
+                progressing.push(alloc);
+            }
+        }
+        if (stalled.length === 0)
+            return actions;
+        // Nothing to redistribute to
+        if (progressing.length === 0)
+            return actions;
+        // Calculate total share to redistribute
+        const redistributeTotal = stalled.reduce((s, a) => s + a.resource_share, 0);
+        // Compute target shares for progressing goals, weighted by velocity
+        const totalVelocity = progressing.reduce((s, a) => {
+            const mom = momentumMap.get(a.goal_id);
+            return s + Math.max(mom?.velocity ?? 0, 0);
+        }, 0);
+        for (const alloc of stalled) {
+            actions.push({
+                goalId: alloc.goal_id,
+                action: "reduce",
+                reason: "stalled: momentum velocity ≈ 0",
+                previousShare: alloc.resource_share,
+                newShare: 0,
+            });
+        }
+        for (const alloc of progressing) {
+            const mom = momentumMap.get(alloc.goal_id);
+            const vel = Math.max(mom?.velocity ?? 0, 0);
+            const bonus = totalVelocity > 0
+                ? redistributeTotal * (vel / totalVelocity)
+                : redistributeTotal / progressing.length;
+            const newShare = clamp(alloc.resource_share + bonus, 0, 1);
+            actions.push({
+                goalId: alloc.goal_id,
+                action: "increase",
+                reason: `received share from stalled goals (velocity=${vel.toFixed(4)})`,
+                previousShare: alloc.resource_share,
+                newShare,
+            });
+        }
+        return actions;
+    }
+    // ─── Private helpers ───
+    /**
+     * Compute the critical path (longest prerequisite chain) among the given goals.
+     * Returns the sequence of goalIds on the critical path.
+     */
+    _computeCriticalPath(goalIds, prereqMap) {
+        // dp[id] = longest path length ending at id (in nodes)
+        const dp = new Map();
+        const parent = new Map();
+        function longestFrom(id) {
+            const cached = dp.get(id);
+            if (cached !== undefined)
+                return cached;
+            const prereqs = prereqMap.get(id) ?? new Set();
+            if (prereqs.size === 0) {
+                dp.set(id, 1);
+                parent.set(id, null);
+                return 1;
+            }
+            let best = 0;
+            let bestParent = null;
+            for (const p of prereqs) {
+                const len = longestFrom(p);
+                if (len > best) {
+                    best = len;
+                    bestParent = p;
+                }
+            }
+            dp.set(id, best + 1);
+            parent.set(id, bestParent);
+            return best + 1;
+        }
+        // Compute for all goals
+        for (const id of goalIds) {
+            longestFrom(id);
+        }
+        // Find the goal with the highest dp value
+        let maxLen = 0;
+        let maxGoal = goalIds[0] ?? "";
+        for (const id of goalIds) {
+            const len = dp.get(id) ?? 0;
+            if (len > maxLen) {
+                maxLen = len;
+                maxGoal = id;
+            }
+        }
+        if (maxLen === 0)
+            return [];
+        // Reconstruct path by following parent pointers
+        const path = [];
+        let current = maxGoal;
+        while (current !== null) {
+            path.unshift(current);
+            current = parent.get(current) ?? null;
+        }
+        return path;
+    }
+    /**
+     * Produce a rough [0,1] severity for a single goal dimension.
+     *
+     * For numeric thresholds we compute gap / scale.
+     * For binary thresholds (present/match) we return 0 or 1.
+     * Returns 0 when the dimension is already satisfied.
+     */
+    _estimateDimensionGap(dim) {
+        const { current_value, threshold } = dim;
+        if (current_value === null)
+            return 1;
+        switch (threshold.type) {
+            case "min": {
+                if (typeof current_value !== "number")
+                    return 0;
+                const gap = threshold.value - current_value;
+                if (gap <= 0)
+                    return 0;
+                return threshold.value !== 0 ? clamp(gap / threshold.value, 0, 1) : 1;
+            }
+            case "max": {
+                if (typeof current_value !== "number")
+                    return 0;
+                const gap = current_value - threshold.value;
+                if (gap <= 0)
+                    return 0;
+                return threshold.value !== 0 ? clamp(gap / threshold.value, 0, 1) : 1;
+            }
+            case "range": {
+                if (typeof current_value !== "number")
+                    return 0;
+                const span = threshold.high - threshold.low;
+                if (current_value < threshold.low) {
+                    const gap = threshold.low - current_value;
+                    return span > 0 ? clamp(gap / span, 0, 1) : 1;
+                }
+                if (current_value > threshold.high) {
+                    const gap = current_value - threshold.high;
+                    return span > 0 ? clamp(gap / span, 0, 1) : 1;
+                }
+                return 0;
+            }
+            case "present": {
+                return current_value ? 0 : 1;
+            }
+            case "match": {
+                return current_value === threshold.value ? 0 : 1;
+            }
+            default:
+                return 0;
+        }
+    }
+    /**
+     * Extract domain tags from a goal's constraints and title.
+     * Recognises constraints with format "domain:tagname" or "tag:tagname".
+     */
+    _extractDomainTags(goal) {
+        const tags = [];
+        for (const constraint of goal.constraints) {
+            const match = constraint.match(/^(?:domain|tag)[:\s]+(.+)$/i);
+            if (match) {
+                tags.push(match[1].trim().toLowerCase());
+            }
+        }
+        return tags;
+    }
+    // ─── Allocation Map ───
+    /**
+     * Get a goal_id → resource_share map for the given goal IDs.
+     *
+     * Recomputes allocations based on current goal states.
+     * Returns a Map suitable for use by PortfolioManager.selectNextStrategyAcrossGoals().
+     */
+    getAllocationMap(goalIds) {
+        const priorities = this.calculateGoalPriorities(goalIds);
+        const allocations = this.allocateResources(priorities);
+        const map = new Map();
+        for (const alloc of allocations) {
+            map.set(alloc.goal_id, alloc.resource_share);
+        }
+        // Fill in any goal IDs that were not computed (e.g. loadGoal returned null)
+        const equalShare = goalIds.length > 0 ? 1.0 / goalIds.length : 0;
+        for (const goalId of goalIds) {
+            if (!map.has(goalId)) {
+                map.set(goalId, equalShare);
+            }
+        }
+        return map;
+    }
+}
+//# sourceMappingURL=cross-goal-portfolio.js.map