pulseed 0.3.0 → 0.4.1

package/dist/orchestrator/loop/core-loop/control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../../../src/orchestrator/loop/core-loop/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG/E,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,EACb,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AAIxD,MAAM,WAAW,cAAc;IAC7B,gBAAgB,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC3C,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,mBAAmB,EAC9B,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,EAC9C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CAgDlC;AAID;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,YAAY,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAclB"}

package/dist/orchestrator/loop/core-loop/control.js

@@ -0,0 +1,72 @@
+import { tryRunParallel } from "../parallel-dispatch.js";
+import { generateLoopReport } from "../loop-report-helper.js";
+/**
+ * Runs the state diff check for a loop iteration.
+ *
+ * Returns an object indicating whether to skip the rest of the iteration.
+ * When `shouldSkip` is true, `result` has been fully populated with skip info
+ * and the caller should return it immediately.
+ * When `shouldSkip` is false, the loop should continue normally.
+ */
+export async function runStateDiffCheck(stateDiff, stateDiffStateMap, goalId, goal, loopIndex, config, deps, result, startTime, logger) {
+    const diffState = stateDiffStateMap.get(goalId) ?? { previousSnapshot: null, consecutiveSkips: 0 };
+    const snapshot = stateDiff.buildSnapshot(goal, loopIndex);
+    const diff = stateDiff.compare(diffState.previousSnapshot, snapshot);
+    diffState.previousSnapshot = snapshot;
+    if (!diff.hasChange && diffState.consecutiveSkips < config.maxConsecutiveSkips) {
+        diffState.consecutiveSkips++;
+        stateDiffStateMap.set(goalId, diffState);
+        logger?.info(`[CoreLoop] iteration ${loopIndex} skipped: no state change detected ` +
+            `(consecutiveSkips=${diffState.consecutiveSkips}/${config.maxConsecutiveSkips})`, { goalId });
+        result.skipped = true;
+        result.skipReason = "no_state_change";
+        deps.onProgress?.({
+            iteration: loopIndex + 1,
+            maxIterations: config.maxIterations,
+            phase: "Skipped",
+            skipReason: result.skipReason,
+        });
+        // Carry forward completion status from the already-loaded goal so a
+        // completed goal is not forced through 5 more iterations.
+        const goalState = await deps.stateManager.loadGoal(goalId);
+        if (goalState?.status === "completed") {
+            result.completionJudgment.is_complete = true;
+        }
+        deps.onProgress?.({
+            iteration: loopIndex + 1,
+            maxIterations: config.maxIterations,
+            phase: "Skipped (no state change)",
+        });
+        result.elapsedMs = Date.now() - startTime;
+        return { shouldSkip: true };
+    }
+    // Reset skip counter — full loop is running
+    diffState.consecutiveSkips = 0;
+    stateDiffStateMap.set(goalId, diffState);
+    if (!diff.hasChange) {
+        logger?.info(`[CoreLoop] max consecutive skips reached (${config.maxConsecutiveSkips}), ` +
+            "forcing full iteration for stall detection", { goalId });
+    }
+    return { shouldSkip: false };
+}
+// ─── Parallel execution check ───
+/**
+ * Attempts to run the iteration in parallel (TaskGroup mode).
+ *
+ * Returns `true` if the parallel path was taken (caller should return result),
+ * `false` if parallel was skipped/unavailable (fall through to normal task cycle).
+ */
+export async function tryParallelExecution(goalId, goal, gapAggregate, result, startTime, deps, loopIndex, logger) {
+    if (!deps.parallelExecutor || !deps.generateTaskGroupFn) {
+        return false;
+    }
+    const parallelResult = await tryRunParallel(goalId, goal, gapAggregate, result, startTime, deps, logger);
+    if (parallelResult !== null) {
+        // Parallel path completed — skip normal task cycle
+        await generateLoopReport(goalId, loopIndex, result, goal, deps.reportingEngine, logger);
+        result.elapsedMs = Date.now() - startTime;
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=control.js.map

package/dist/orchestrator/loop/core-loop/control.js.map

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

package/dist/orchestrator/loop/core-loop/learning.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Learning and transfer state that spans CoreLoop iterations.
+ */
+import type { Logger } from "../../../runtime/logger.js";
+import type { CoreLoopDeps } from "./contracts.js";
+import type { ToolExecutor } from "../../../tools/executor.js";
+export declare class CoreLoopLearning {
+    private lastLearningReviewAt;
+    private transferCheckCounter;
+    /** Tracks consecutive capability acquisition failures per capability name */
+    private capabilityAcquisitionFailures;
+    getCapabilityFailures(): Map<string, number>;
+    incrementTransferCounter(): number;
+    /**
+     * Returns the periodic learning review interval in milliseconds based on
+     * how much time remains until the goal's target_date.
+     */
+    getPeriodicReviewInterval(goalId: string, stateManager: CoreLoopDeps["stateManager"]): Promise<number>;
+    /**
+     * Checks whether it is time to run a periodic learning review and, if so,
+     * calls learningPipeline.onPeriodicReview(). Non-fatal — errors are logged
+     * but do not bubble up.
+     */
+    checkPeriodicReview(goalId: string, deps: CoreLoopDeps, logger: Logger | undefined, toolExecutor?: ToolExecutor): Promise<void>;
+    /**
+     * Called after the run loop completes with finalStatus === "completed".
+     * Triggers learningPipeline.onGoalCompleted(). Non-fatal.
+     */
+    onGoalCompleted(goalId: string, deps: CoreLoopDeps, logger: Logger | undefined, toolExecutor?: ToolExecutor): Promise<void>;
+}
+//# sourceMappingURL=learning.d.ts.map

package/dist/orchestrator/loop/core-loop/learning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning.d.ts","sourceRoot":"","sources":["../../../../src/orchestrator/loop/core-loop/learning.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAG/D,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,oBAAoB,CAAsB;IAClD,OAAO,CAAC,oBAAoB,CAAa;IACzC,6EAA6E;IAC7E,OAAO,CAAC,6BAA6B,CAAkC;IAEvE,qBAAqB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAI5C,wBAAwB,IAAI,MAAM;IAIlC;;;OAGG;IACG,yBAAyB,CAC7B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,CAAC,cAAc,CAAC,GACzC,OAAO,CAAC,MAAM,CAAC;IAYlB;;;;OAIG;IACG,mBAAmB,CACvB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,YAAY,CAAC,EAAE,YAAY,GAC1B,OAAO,CAAC,IAAI,CAAC;IA2BhB;;;OAGG;IACG,eAAe,CACnB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,YAAY,CAAC,EAAE,YAAY,GAC1B,OAAO,CAAC,IAAI,CAAC;CAsBjB"}

package/dist/orchestrator/loop/core-loop/learning.js

@@ -0,0 +1,92 @@
+/**
+ * Learning and transfer state that spans CoreLoop iterations.
+ */
+import { gatherLearningEvidence } from "../learning-evidence.js";
+export class CoreLoopLearning {
+    lastLearningReviewAt = Date.now();
+    transferCheckCounter = 0;
+    /** Tracks consecutive capability acquisition failures per capability name */
+    capabilityAcquisitionFailures = new Map();
+    getCapabilityFailures() {
+        return this.capabilityAcquisitionFailures;
+    }
+    incrementTransferCounter() {
+        return ++this.transferCheckCounter;
+    }
+    /**
+     * Returns the periodic learning review interval in milliseconds based on
+     * how much time remains until the goal's target_date.
+     */
+    async getPeriodicReviewInterval(goalId, stateManager) {
+        const goal = await stateManager.loadGoal(goalId);
+        if (!goal?.target_date) {
+            return 72 * 3600 * 1000; // default: 72 hours
+        }
+        const remainingDays = (new Date(goal.target_date).getTime() - Date.now()) / (1000 * 60 * 60 * 24);
+        if (remainingDays <= 30)
+            return 72 * 3600 * 1000; // 短期: 72h
+        if (remainingDays <= 180)
+            return 168 * 3600 * 1000; // 中期: 1week
+        return 336 * 3600 * 1000; // 長期: 2weeks
+    }
+    /**
+     * Checks whether it is time to run a periodic learning review and, if so,
+     * calls learningPipeline.onPeriodicReview(). Non-fatal — errors are logged
+     * but do not bubble up.
+     */
+    async checkPeriodicReview(goalId, deps, logger, toolExecutor) {
+        if (!deps.learningPipeline)
+            return;
+        const now = Date.now();
+        const intervalMs = await this.getPeriodicReviewInterval(goalId, deps.stateManager);
+        if (now - this.lastLearningReviewAt >= intervalMs) {
+            try {
+                if (toolExecutor) {
+                    const toolCtx = { cwd: ".", goalId, trustBalance: 0, preApproved: true, approvalFn: async () => false };
+                    const evidence = await gatherLearningEvidence(toolExecutor, toolCtx);
+                    if (evidence.errors.length > 0) {
+                        logger?.warn("CoreLoop: evidence gathering errors", { goalId, errors: evidence.errors });
+                    }
+                    logger?.debug("CoreLoop: periodic review evidence", { goalId, artifactCount: evidence.artifactCount, changesLen: evidence.recentChanges.length });
+                }
+                await deps.learningPipeline.onPeriodicReview(goalId);
+                this.lastLearningReviewAt = now;
+            }
+            catch (err) {
+                // non-fatal: learning pipeline failure should not block main loop
+                logger?.warn("CoreLoop: learningPipeline.onPeriodicReview failed", {
+                    goalId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    /**
+     * Called after the run loop completes with finalStatus === "completed".
+     * Triggers learningPipeline.onGoalCompleted(). Non-fatal.
+     */
+    async onGoalCompleted(goalId, deps, logger, toolExecutor) {
+        if (!deps.learningPipeline)
+            return;
+        try {
+            if (toolExecutor) {
+                const toolCtx = { cwd: ".", goalId, trustBalance: 0, preApproved: true, approvalFn: async () => false };
+                const evidence = await gatherLearningEvidence(toolExecutor, toolCtx);
+                if (evidence.errors.length > 0) {
+                    logger?.warn("CoreLoop: evidence gathering errors", { goalId, errors: evidence.errors });
+                }
+                // Evidence is informational — log artifact count for observability
+                logger?.debug("CoreLoop: goal completed evidence", { goalId, artifactCount: evidence.artifactCount });
+            }
+            await deps.learningPipeline.onGoalCompleted(goalId);
+        }
+        catch (err) {
+            // non-fatal
+            logger?.warn("CoreLoop: learningPipeline.onGoalCompleted failed", {
+                goalId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+//# sourceMappingURL=learning.js.map

package/dist/orchestrator/loop/core-loop/learning.js.map

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

package/dist/orchestrator/loop/core-loop/preparation.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Preparation and scoring steps for a single CoreLoop iteration.
+ */
+import type { Logger } from "../../../runtime/logger.js";
+import type { ToolExecutor } from "../../../tools/executor.js";
+import type { Goal } from "../../../base/types/goal.js";
+import type { GapVector } from "../../../base/types/gap.js";
+import type { DriveScore } from "../../../base/types/drive.js";
+import { type CoreLoopDeps, type ResolvedLoopConfig, type LoopIterationResult } from "./contracts.js";
+/** Minimal context passed to every phase function. */
+export interface PhaseCtx {
+    deps: CoreLoopDeps;
+    config: ResolvedLoopConfig;
+    logger: Logger | undefined;
+    toolExecutor?: ToolExecutor;
+    /**
+     * Optional TimeHorizonEngine for canAffordWait gate in rebalancePortfolio (Gap 1).
+     * When present, WaitStrategy processing is skipped if the engine reports the goal
+     * cannot afford to wait given the remaining time budget.
+     */
+    timeHorizonEngine?: import("../../../platform/time/time-horizon-engine.js").ITimeHorizonEngine;
+}
+/** Load goal from state, apply tree aggregation if applicable.
+ * Returns the loaded Goal, or null if an error occurred (result is mutated). */
+export declare function loadGoalWithAggregation(ctx: PhaseCtx, goalId: string, result: LoopIterationResult, startTime: number): Promise<Goal | null>;
+/**
+ * Automatically decompose an abstract goal into sub-goals using
+ * TreeLoopOrchestrator.ensureGoalRefined(). Skipped when disabled,
+ * when the goal already has children, or when the goal is a leaf.
+ * Only root goals (decomposition_depth === 0) are auto-decomposed to
+ * prevent recursive decomposition of child nodes.
+ * Specificity checks are delegated to ensureGoalRefined internally.
+ *
+ * @param decomposedGoals - Set of goal IDs already decomposed this run.
+ *   When provided, goals already in the set are skipped and the goal ID is
+ *   added to the set after a successful decomposition attempt.
+ */
+export declare function phaseAutoDecompose(goalId: string, goal: Goal, deps: CoreLoopDeps, config: ResolvedLoopConfig, logger: Logger | undefined, decomposedGoals?: Set<string>, isFirstIteration?: boolean): Promise<void>;
+/** Build a ToolCallContext from PhaseCtx for CoreLoop autonomous tool calls. */
+export declare function buildLoopToolContext(ctx: PhaseCtx, goalId: string): Promise<import("../../../tools/types.js").ToolCallContext>;
+/** Run observation engine, reload goal after observation.
+ * Observation failure is non-fatal — returns current goal state.
+ * When ctx.toolExecutor is present, routes through the observe-goal tool first
+ * and falls back to direct engine.observe() on tool failure. */
+export declare function observeAndReload(ctx: PhaseCtx, goalId: string, goal: Goal, loopIndex: number): Promise<Goal>;
+/** Calculate gap vector and aggregate.
+ * Returns null on error.
+ * When gap === 0, returns the gap result with skipTaskGeneration=true so the
+ * caller continues to Phase 5 (SatisficingJudge) instead of short-circuiting.
+ */
+export declare function calculateGapOrComplete(ctx: PhaseCtx, goalId: string, goal: Goal, loopIndex: number, result: LoopIterationResult, startTime: number): Promise<{
+    gapVector: GapVector;
+    gapAggregate: number;
+    skipTaskGeneration?: boolean;
+} | null>;
+/** Score drives, update DriveScoreAdapter, check knowledge gap.
+ * Returns ranked DriveScores with highDissatisfactionDimensions, or null if the caller should
+ * return result early (knowledge gap task generated or drive scoring failed). */
+export declare function scoreDrivesAndCheckKnowledge(ctx: PhaseCtx, goalId: string, goal: Goal, gapVector: GapVector, loopIndex: number, result: LoopIterationResult, startTime: number, tryGenerateReport: (goalId: string, loopIndex: number, result: LoopIterationResult, goal: Goal) => void): Promise<{
+    driveScores: DriveScore[];
+    highDissatisfactionDimensions: string[];
+} | null>;
+//# sourceMappingURL=preparation.d.ts.map

package/dist/orchestrator/loop/core-loop/preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preparation.d.ts","sourceRoot":"","sources":["../../../../src/orchestrator/loop/core-loop/preparation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACzB,MAAM,gBAAgB,CAAC;AAGxB,sDAAsD;AACtD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,+CAA+C,EAAE,kBAAkB,CAAC;CAChG;AAID;gFACgF;AAChF,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CA6BtB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAC7B,gBAAgB,CAAC,EAAE,OAAO,GACzB,OAAO,CAAC,IAAI,CAAC,CA4Cf;AAID,gFAAgF;AAChF,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,yBAAyB,EAAE,eAAe,CAAC,CAiB5D;AAID;;;gEAGgE;AAChE,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAuCf;AAID;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC,CAyF9F;AAID;;iFAEiF;AACjF,wBAAsB,4BAA4B,CAChD,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,GACtG,OAAO,CAAC;IAAE,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,6BAA6B,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CAoHxF"}

package/dist/orchestrator/loop/core-loop/preparation.js

@@ -0,0 +1,362 @@
+/**
+ * Preparation and scoring steps for a single CoreLoop iteration.
+ */
+import { buildDriveContext, } from "./contracts.js";
+import { logRewardComputation } from "../../../platform/drive/reward-log.js";
+// ─── Phase 1 ───
+/** Load goal from state, apply tree aggregation if applicable.
+ * Returns the loaded Goal, or null if an error occurred (result is mutated). */
+export async function loadGoalWithAggregation(ctx, goalId, result, startTime) {
+    let goal;
+    try {
+        const loaded = await ctx.deps.stateManager.loadGoal(goalId);
+        if (!loaded) {
+            result.error = `Goal "${goalId}" not found`;
+            result.elapsedMs = Date.now() - startTime;
+            return null;
+        }
+        goal = loaded;
+    }
+    catch (err) {
+        result.error = `Failed to load goal: ${err instanceof Error ? err.message : String(err)}`;
+        ctx.logger?.error(`CoreLoop: ${result.error}`, { goalId });
+        result.elapsedMs = Date.now() - startTime;
+        return null;
+    }
+    // Tree aggregation
+    if (ctx.deps.stateAggregator && goal.children_ids.length > 0) {
+        try {
+            await ctx.deps.stateAggregator.aggregateChildStates(goalId);
+            const reloaded = await ctx.deps.stateManager.loadGoal(goalId);
+            if (reloaded)
+                goal = reloaded;
+        }
+        catch {
+            // Tree aggregation failure is non-fatal
+        }
+    }
+    return goal;
+}
+// ─── Phase 1b: Auto-decompose ───
+/**
+ * Automatically decompose an abstract goal into sub-goals using
+ * TreeLoopOrchestrator.ensureGoalRefined(). Skipped when disabled,
+ * when the goal already has children, or when the goal is a leaf.
+ * Only root goals (decomposition_depth === 0) are auto-decomposed to
+ * prevent recursive decomposition of child nodes.
+ * Specificity checks are delegated to ensureGoalRefined internally.
+ *
+ * @param decomposedGoals - Set of goal IDs already decomposed this run.
+ *   When provided, goals already in the set are skipped and the goal ID is
+ *   added to the set after a successful decomposition attempt.
+ */
+export async function phaseAutoDecompose(goalId, goal, deps, config, logger, decomposedGoals, isFirstIteration) {
+    if (config.autoDecompose === false)
+        return;
+    if (!deps.treeLoopOrchestrator)
+        return;
+    if (goal.children_ids.length > 0) {
+        logger?.debug("[CoreLoop] phaseAutoDecompose: skipped — goal already has children", { goalId });
+        return;
+    }
+    if (goal.node_type === "leaf") {
+        logger?.debug("[CoreLoop] phaseAutoDecompose: skipped — goal is leaf", { goalId });
+        return;
+    }
+    // Only auto-decompose root goals — prevent recursive decomposition of children
+    if ((goal.decomposition_depth ?? 0) > 0) {
+        logger?.debug("[CoreLoop] phaseAutoDecompose: skipped — non-root goal (depth > 0)", { goalId, depth: goal.decomposition_depth });
+        return;
+    }
+    // Skip if already decomposed this run
+    if (decomposedGoals?.has(goalId)) {
+        logger?.debug("[CoreLoop] phaseAutoDecompose: skipped — already decomposed this run", { goalId });
+        return;
+    }
+    const force = isFirstIteration === true;
+    if (force) {
+        logger?.info("[decompose] forcing goal decomposition on first iteration", { goalId });
+    }
+    else {
+        logger?.info("[CoreLoop] phaseAutoDecompose: decomposing abstract goal", { goalId });
+    }
+    decomposedGoals?.add(goalId);
+    try {
+        await deps.treeLoopOrchestrator.ensureGoalRefined(goalId, { force });
+    }
+    catch (err) {
+        logger?.warn("[CoreLoop] phaseAutoDecompose: ensureGoalRefined failed (non-fatal)", {
+            goalId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return;
+    }
+    logger?.info("[CoreLoop] phaseAutoDecompose: decomposition complete", { goalId });
+}
+// ─── Phase 2 helpers ───
+/** Build a ToolCallContext from PhaseCtx for CoreLoop autonomous tool calls. */
+export async function buildLoopToolContext(ctx, goalId) {
+    let trustBalance = 0;
+    if (ctx.deps.trustManager) {
+        try {
+            const balance = await ctx.deps.trustManager.getBalance(goalId);
+            trustBalance = balance.balance;
+        }
+        catch {
+            // Non-fatal — default to 0
+        }
+    }
+    return {
+        cwd: process.cwd(),
+        goalId,
+        trustBalance,
+        preApproved: true,
+        approvalFn: async () => false,
+    };
+}
+// ─── Phase 2 ───
+/** Run observation engine, reload goal after observation.
+ * Observation failure is non-fatal — returns current goal state.
+ * When ctx.toolExecutor is present, routes through the observe-goal tool first
+ * and falls back to direct engine.observe() on tool failure. */
+export async function observeAndReload(ctx, goalId, goal, loopIndex) {
+    ctx.deps.onProgress?.({
+        iteration: loopIndex + 1,
+        maxIterations: ctx.config.maxIterations,
+        phase: "Observing...",
+    });
+    // Tool path: route through ToolExecutor when available
+    if (ctx.toolExecutor) {
+        try {
+            const toolCtx = await buildLoopToolContext(ctx, goalId);
+            const toolResult = await ctx.toolExecutor.execute("observe-goal", { goal_id: goalId }, toolCtx);
+            if (toolResult.success) {
+                const reloaded = await ctx.deps.stateManager.loadGoal(goalId);
+                if (reloaded)
+                    return reloaded;
+                return goal;
+            }
+            ctx.logger?.warn(`CoreLoop: observe-goal tool failed: ${toolResult.error}, falling back to direct call`);
+        }
+        catch (err) {
+            ctx.logger?.warn("CoreLoop: observe-goal tool threw (falling back to direct call)", { error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    // Direct path: fallback (or when toolExecutor is absent)
+    try {
+        const engine = ctx.deps.observationEngine;
+        ctx.logger?.debug("CoreLoop: engine.getDataSources exists", { exists: true });
+        const dataSources = engine.getDataSources();
+        ctx.logger?.debug("CoreLoop: observation setup", { dataSourceCount: dataSources.length });
+        await engine.observe(goalId, []);
+        const reloaded = await ctx.deps.stateManager.loadGoal(goalId);
+        if (reloaded)
+            return reloaded;
+    }
+    catch (err) {
+        ctx.logger?.warn("CoreLoop: observation failed (non-fatal)", { error: err instanceof Error ? err.message : String(err) });
+    }
+    return goal;
+}
+// ─── Phase 3 ───
+/** Calculate gap vector and aggregate.
+ * Returns null on error.
+ * When gap === 0, returns the gap result with skipTaskGeneration=true so the
+ * caller continues to Phase 5 (SatisficingJudge) instead of short-circuiting.
+ */
+export async function calculateGapOrComplete(ctx, goalId, goal, loopIndex, result, startTime) {
+    let gapVector;
+    let gapAggregate;
+    try {
+        // Refresh stale dimensions via tool measurement before gap calculation
+        if (ctx.toolExecutor && goal.dimensions) {
+            const { needsDirectMeasurement, measureDirectly } = await import("../../../platform/drive/gap-calculator-tools.js");
+            let anyRefreshed = false;
+            for (const dim of goal.dimensions) {
+                if (needsDirectMeasurement(dim)) {
+                    try {
+                        const refreshed = await measureDirectly(dim, ctx.toolExecutor, {
+                            cwd: process.cwd(),
+                            goalId,
+                            trustBalance: 0,
+                            preApproved: true,
+                            approvalFn: async () => false,
+                        });
+                        if (refreshed !== null) {
+                            dim.current_value = refreshed.value;
+                            dim.confidence = refreshed.confidence;
+                            anyRefreshed = true;
+                            ctx.logger?.debug(`[GapRefresh] Refreshed stale dimension ${dim.name}: confidence ${dim.confidence}`);
+                        }
+                    }
+                    catch (err) {
+                        ctx.logger?.warn(`[GapRefresh] Failed to refresh ${dim.name}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            // Persist refreshed dimension values to avoid re-measuring on the next iteration
+            if (anyRefreshed) {
+                try {
+                    await ctx.deps.stateManager.saveGoal(goal);
+                    ctx.logger?.debug('[GapRefresh] Persisted refreshed dimensions for goal ' + goalId);
+                }
+                catch (err) {
+                    ctx.logger?.warn?.('[GapRefresh] Failed to persist refreshed dimensions: ' + String(err));
+                }
+            }
+        }
+        gapVector = ctx.deps.gapCalculator.calculateGapVector(goalId, goal.dimensions, goal.uncertainty_weight);
+        const gapValues = gapVector.gaps.map((g) => g.normalized_weighted_gap);
+        gapAggregate = ctx.deps.gapCalculator.aggregateGaps(gapValues, goal.gap_aggregation);
+        result.gapAggregate = gapAggregate;
+        await ctx.deps.stateManager.appendGapHistoryEntry(goalId, {
+            iteration: loopIndex,
+            timestamp: new Date().toISOString(),
+            gap_vector: gapVector.gaps.map((g) => ({
+                dimension_name: g.dimension_name,
+                normalized_weighted_gap: g.normalized_weighted_gap,
+            })),
+            confidence_vector: gapVector.gaps.map((g) => ({
+                dimension_name: g.dimension_name,
+                confidence: g.confidence,
+            })),
+        });
+    }
+    catch (err) {
+        result.error = `Gap calculation failed: ${err instanceof Error ? err.message : String(err)}`;
+        ctx.logger?.error(`CoreLoop: ${result.error}`, { goalId });
+        result.elapsedMs = Date.now() - startTime;
+        return null;
+    }
+    // Gap zero check — gap is satisfied; skip task generation but continue to
+    // Phase 5 so SatisficingJudge can enforce confidence and double-confirmation.
+    if (gapAggregate === 0) {
+        ctx.logger?.info(`[CoreLoop] gap=0 for goal ${goalId} — skipping task generation, deferring to SatisficingJudge`);
+        return { gapVector, gapAggregate, skipTaskGeneration: true };
+    }
+    const avgConf = gapVector.gaps.length > 0
+        ? gapVector.gaps.reduce((s, g) => s + g.confidence, 0) / gapVector.gaps.length
+        : undefined;
+    ctx.deps.onProgress?.({
+        iteration: loopIndex + 1,
+        maxIterations: ctx.config.maxIterations,
+        phase: "Generating task...",
+        gap: gapAggregate,
+        confidence: avgConf,
+    });
+    return { gapVector, gapAggregate };
+}
+// ─── Phase 4 ───
+/** Score drives, update DriveScoreAdapter, check knowledge gap.
+ * Returns ranked DriveScores with highDissatisfactionDimensions, or null if the caller should
+ * return result early (knowledge gap task generated or drive scoring failed). */
+export async function scoreDrivesAndCheckKnowledge(ctx, goalId, goal, gapVector, loopIndex, result, startTime, tryGenerateReport) {
+    let driveScores;
+    let highDissatisfactionDimensions = [];
+    try {
+        const driveContext = buildDriveContext(goal);
+        driveScores = ctx.deps.driveScorer.scoreAllDimensions(gapVector, driveContext);
+        const rankedScores = ctx.deps.driveScorer.rankDimensions(driveScores);
+        result.driveScores = rankedScores;
+        driveScores = rankedScores;
+        if (ctx.deps.driveScoreAdapter) {
+            ctx.deps.driveScoreAdapter.update(driveScores);
+        }
+        // Extract dimensions with high dissatisfaction (> 0.7) for memory tier promotion
+        highDissatisfactionDimensions = driveScores
+            .filter((s) => s.dissatisfaction > 0.7)
+            .map((s) => s.dimension_name);
+        // Consolidated reward computation log (PULSEED_REWARD_LOG=1 to enable)
+        const confidenceAvg = gapVector.gaps.reduce((sum, g) => sum + g.confidence, 0) /
+            Math.max(gapVector.gaps.length, 1);
+        let trustScore = null;
+        if (ctx.deps.trustManager) {
+            try {
+                const balance = await ctx.deps.trustManager.getBalance(ctx.config.adapterType);
+                trustScore = balance.balance;
+            }
+            catch {
+                // Non-fatal: trust score is diagnostic-only
+            }
+        }
+        logRewardComputation({
+            goalId,
+            iteration: loopIndex,
+            gapAggregate: result.gapAggregate ?? 0,
+            confidenceAvg,
+            trustScore,
+            driveScores,
+            completionJudgment: null,
+        });
+    }
+    catch (err) {
+        result.error = `Drive scoring failed: ${err instanceof Error ? err.message : String(err)}`;
+        ctx.logger?.error(`CoreLoop: ${result.error}`, { goalId });
+        result.elapsedMs = Date.now() - startTime;
+        return null;
+    }
+    // Knowledge gap check
+    if (ctx.deps.knowledgeManager) {
+        try {
+            let strategies = null;
+            try {
+                const portfolio = await ctx.deps.strategyManager.getPortfolio(goalId);
+                strategies = portfolio !== null ? portfolio.strategies : null;
+            }
+            catch {
+                // If strategy loading fails, leave as null
+            }
+            const observationContext = {
+                observations: goal.dimensions.map((d) => ({
+                    name: d.name,
+                    current_value: d.current_value,
+                    confidence: d.confidence,
+                })),
+                strategies,
+                confidence: gapVector.gaps.reduce((sum, g) => sum + g.confidence, 0) /
+                    Math.max(gapVector.gaps.length, 1),
+            };
+            // Skip knowledge gap detection when:
+            // 1. Observations are purely self-report (confidence <= 0.3, no data sources)
+            // 2. Not the first iteration — prevents repeated gap detection from blocking
+            //    task execution every loop. Gap detection runs once; after that, let the
+            //    normal task cycle proceed.
+            const skipGapDetection = observationContext.confidence <= 0.3 ||
+                !Number.isFinite(observationContext.confidence) ||
+                loopIndex > 0;
+            const gapSignal = skipGapDetection
+                ? null
+                : await ctx.deps.knowledgeManager.detectKnowledgeGap(observationContext);
+            if (gapSignal !== null) {
+                const acquisitionTask = await ctx.deps.knowledgeManager.generateAcquisitionTask(gapSignal, goalId);
+                const acquisitionVerification = {
+                    task_id: acquisitionTask.id,
+                    verdict: "pass",
+                    confidence: 0.9,
+                    evidence: [
+                        {
+                            layer: "mechanical",
+                            description: "Knowledge acquisition task generated for gap: " + gapSignal.signal_type,
+                            confidence: 0.9,
+                        },
+                    ],
+                    dimension_updates: [],
+                    timestamp: new Date().toISOString(),
+                };
+                result.taskResult = {
+                    task: acquisitionTask,
+                    verificationResult: acquisitionVerification,
+                    action: "completed",
+                };
+                tryGenerateReport(goalId, loopIndex, result, goal);
+                result.elapsedMs = Date.now() - startTime;
+                return null;
+            }
+        }
+        catch {
+            // Knowledge gap detection failure is non-fatal
+        }
+    }
+    return { driveScores, highDissatisfactionDimensions };
+}
+//# sourceMappingURL=preparation.js.map