pulseed 0.4.18 → 0.4.20

package/dist/orchestrator/loop/core-loop/decision-engine.js

@@ -0,0 +1,141 @@
+export class CoreDecisionEngine {
+    shouldRunStallInvestigation(result) {
+        return result.stallDetected && !!result.stallReport;
+    }
+    shouldRunReplanningOptions(input) {
+        return !input.skipTaskGeneration && !input.taskCycleBlocked && input.gapAggregate > 0;
+    }
+    shouldRunVerificationEvidence(result) {
+        return !!result.taskResult;
+    }
+    evaluateKnowledgeAcquisition(input) {
+        if (!input.hasKnowledgeManager || !input.hasToolExecutor || !input.phase?.output) {
+            return { shouldAcquire: false };
+        }
+        const output = input.phase.output;
+        if (input.phase.status === "failed" || input.phase.status === "skipped") {
+            return { shouldAcquire: false };
+        }
+        if (!output.worthwhile || output.confidence < 0.7 || output.required_knowledge.length === 0) {
+            return { shouldAcquire: false };
+        }
+        const question = [
+            output.summary,
+            ...output.required_knowledge,
+            ...output.acquisition_candidates,
+        ]
+            .filter((value) => typeof value === "string" && value.trim().length > 0)
+            .join("\n");
+        if (question.length === 0) {
+            return { shouldAcquire: false };
+        }
+        return { shouldAcquire: true, question };
+    }
+    shouldPreferReplanningContext(input) {
+        const output = input.phase?.output;
+        if (!output)
+            return false;
+        return input.phase?.status !== "failed" && output.confidence >= 0.6 && output.candidates.length > 0;
+    }
+    buildTaskGenerationHints(input) {
+        if (!this.shouldPreferReplanningContext({ phase: input.phase })) {
+            return {};
+        }
+        const output = input.phase?.output;
+        if (!output)
+            return {};
+        const topCandidate = output.candidates[0];
+        const matchedDimension = topCandidate?.target_dimensions.find((dimension) => input.goalDimensions.includes(dimension));
+        const detailLines = output.candidates.slice(0, 3).map((candidate, index) => {
+            const dimensions = candidate.target_dimensions.length > 0
+                ? ` dimensions=${candidate.target_dimensions.join(", ")}`
+                : "";
+            return `${index + 1}. ${candidate.title}${dimensions} | rationale=${candidate.rationale} | evidence_gain=${candidate.expected_evidence_gain} | blast_radius=${candidate.blast_radius}`;
+        });
+        return {
+            ...(matchedDimension ? { targetDimensionOverride: matchedDimension } : {}),
+            knowledgeContextPrefix: [
+                "Replanning directive:",
+                output.summary,
+                "Prefer task generation that follows these candidate directions in order:",
+                ...detailLines,
+                "If a candidate conflicts with current workspace evidence, prefer the smallest verifiable task that preserves the candidate intent.",
+            ].join("\n"),
+        };
+    }
+    buildStallActionHints(input) {
+        if (!this.shouldPreferReplanningContext({ phase: input.phase })) {
+            return {};
+        }
+        const action = input.phase?.output?.recommended_action;
+        return action ? { recommendedAction: action } : {};
+    }
+    buildNextIterationDirective(input) {
+        const knowledgeOutput = input.knowledgeRefreshPhase?.output;
+        if (knowledgeOutput &&
+            input.knowledgeRefreshPhase?.status !== "failed" &&
+            knowledgeOutput.worthwhile &&
+            knowledgeOutput.confidence >= 0.7) {
+            return {
+                sourcePhase: "knowledge_refresh",
+                reason: knowledgeOutput.summary,
+                focusDimension: input.fallbackFocusDimension,
+                requestedPhase: "knowledge_refresh",
+            };
+        }
+        if (this.shouldPreferReplanningContext({ phase: input.replanningPhase })) {
+            const replanningOutput = input.replanningPhase?.output;
+            const topCandidate = replanningOutput?.candidates[0];
+            const focusDimension = topCandidate?.target_dimensions.find((dimension) => input.goalDimensions.includes(dimension)) ?? input.fallbackFocusDimension;
+            return {
+                sourcePhase: "replanning_options",
+                reason: replanningOutput?.summary ?? "replanning directive",
+                focusDimension,
+                preferredAction: replanningOutput?.recommended_action,
+                requestedPhase: "normal",
+            };
+        }
+        return undefined;
+    }
+    evaluateRunDecision(input) {
+        const next = { ...input.counters };
+        const taskAction = input.iterationResult.taskResult?.action ?? null;
+        if (input.iterationResult.completionJudgment.is_complete && input.loopIndex >= input.minIterations - 1) {
+            return { counters: next, shouldStop: true, finalStatus: "completed" };
+        }
+        if (input.iterationResult.error !== null) {
+            next.consecutiveErrors++;
+            if (next.consecutiveErrors >= input.maxConsecutiveErrors) {
+                return { counters: next, shouldStop: true, finalStatus: "error" };
+            }
+        }
+        else {
+            next.consecutiveErrors = 0;
+        }
+        if (taskAction === "approval_denied") {
+            next.consecutiveDenied++;
+            if (next.consecutiveDenied >= 3) {
+                return { counters: next, shouldStop: true, finalStatus: "stopped" };
+            }
+        }
+        else {
+            next.consecutiveDenied = 0;
+        }
+        if (taskAction === "escalate") {
+            next.consecutiveEscalations++;
+            if (next.consecutiveEscalations >= 3) {
+                return { counters: next, shouldStop: true, finalStatus: "stalled" };
+            }
+        }
+        else {
+            next.consecutiveEscalations = 0;
+        }
+        if (input.iterationResult.stallDetected &&
+            input.iterationResult.stallReport &&
+            input.iterationResult.stallReport.escalation_level >= 3) {
+            return { counters: next, shouldStop: true, finalStatus: "stalled" };
+        }
+        return { counters: next, shouldStop: false };
+    }
+}
+//# sourceMappingURL=decision-engine.js.map

package/dist/orchestrator/loop/core-loop/decision-engine.js.map

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

package/dist/orchestrator/loop/core-loop/evidence-ledger.d.ts

@@ -0,0 +1,22 @@
+import type { CorePhaseKind } from "../../execution/agent-loop/core-phase-runner.js";
+import type { CorePhaseIterationResult } from "../loop-result-types.js";
+export interface CoreLoopRecordedPhase {
+    phase: CorePhaseKind;
+    status: CorePhaseIterationResult["status"];
+    summary?: string;
+    traceId?: string;
+    sessionId?: string;
+    turnId?: string;
+    stopReason?: string;
+    lowConfidence?: boolean;
+    error?: string;
+}
+export declare class CoreLoopEvidenceLedger {
+    private readonly phases;
+    record(phase: CoreLoopRecordedPhase): void;
+    toIterationPhaseResults(): CorePhaseIterationResult[];
+    augmentKnowledgeContext(input?: string): string | undefined;
+    augmentWorkspaceContext(input?: string): string | undefined;
+    private append;
+}
+//# sourceMappingURL=evidence-ledger.d.ts.map

package/dist/orchestrator/loop/core-loop/evidence-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-ledger.d.ts","sourceRoot":"","sources":["../../../../src/orchestrator/loop/core-loop/evidence-ledger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAExE,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmD;IAE1E,MAAM,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI;IAI1C,uBAAuB,IAAI,wBAAwB,EAAE;IAIrD,uBAAuB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAU3D,uBAAuB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAU3D,OAAO,CAAC,MAAM;CAKf"}

package/dist/orchestrator/loop/core-loop/evidence-ledger.js

@@ -0,0 +1,36 @@
+export class CoreLoopEvidenceLedger {
+    phases = new Map();
+    record(phase) {
+        this.phases.set(phase.phase, phase);
+    }
+    toIterationPhaseResults() {
+        return [...this.phases.values()];
+    }
+    augmentKnowledgeContext(input) {
+        const extraBlocks = [];
+        for (const phase of ["knowledge_refresh", "replanning_options", "verification_evidence"]) {
+            const record = this.phases.get(phase);
+            if (!record?.summary)
+                continue;
+            extraBlocks.push(`[${phase}]\n${record.summary}`);
+        }
+        return this.append(input, extraBlocks);
+    }
+    augmentWorkspaceContext(input) {
+        const extraBlocks = [];
+        for (const phase of ["observe_evidence", "stall_investigation"]) {
+            const record = this.phases.get(phase);
+            if (!record?.summary)
+                continue;
+            extraBlocks.push(`[${phase}]\n${record.summary}`);
+        }
+        return this.append(input, extraBlocks);
+    }
+    append(input, blocks) {
+        if (blocks.length === 0)
+            return input;
+        const addition = blocks.join("\n\n");
+        return input ? `${input}\n\n${addition}` : addition;
+    }
+}
+//# sourceMappingURL=evidence-ledger.js.map

package/dist/orchestrator/loop/core-loop/evidence-ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-ledger.js","sourceRoot":"","sources":["../../../../src/orchestrator/loop/core-loop/evidence-ledger.ts"],"names":[],"mappings":"AAeA,MAAM,OAAO,sBAAsB;IAChB,MAAM,GAAG,IAAI,GAAG,EAAwC,CAAC;IAE1E,MAAM,CAAC,KAA4B;QACjC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,uBAAuB;QACrB,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,uBAAuB,CAAC,KAAc;QACpC,MAAM,WAAW,GAAa,EAAE,CAAC;QACjC,KAAK,MAAM,KAAK,IAAI,CAAC,mBAAmB,EAAE,oBAAoB,EAAE,uBAAuB,CAAU,EAAE,CAAC;YAClG,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACtC,IAAI,CAAC,MAAM,EAAE,OAAO;gBAAE,SAAS;YAC/B,WAAW,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACzC,CAAC;IAED,uBAAuB,CAAC,KAAc;QACpC,MAAM,WAAW,GAAa,EAAE,CAAC;QACjC,KAAK,MAAM,KAAK,IAAI,CAAC,kBAAkB,EAAE,qBAAqB,CAAU,EAAE,CAAC;YACzE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACtC,IAAI,CAAC,MAAM,EAAE,OAAO;gBAAE,SAAS;YAC/B,WAAW,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACzC,CAAC;IAEO,MAAM,CAAC,KAAyB,EAAE,MAAgB;QACxD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QACtC,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC,OAAO,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,OAAO,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;IACtD,CAAC;CACF"}

package/dist/orchestrator/loop/core-loop/iteration-kernel.d.ts

@@ -0,0 +1,34 @@
+import type { Logger } from "../../../runtime/logger.js";
+import type { StateDiffCalculator } from "../state-diff.js";
+import type { LoopIterationResult, NextIterationDirective } from "../loop-result-types.js";
+import type { CoreLoopDeps, ResolvedLoopConfig } from "./contracts.js";
+import { type StateDiffState } from "./control.js";
+import type { CorePhasePolicyRegistry } from "./phase-policy.js";
+import { CoreDecisionEngine } from "./decision-engine.js";
+import type { ITimeHorizonEngine } from "../../../platform/time/time-horizon-engine.js";
+export interface CoreIterationKernelDeps {
+    deps: CoreLoopDeps;
+    getConfig: () => ResolvedLoopConfig;
+    setConfig: (config: ResolvedLoopConfig) => void;
+    logger?: Logger;
+    stateDiff?: StateDiffCalculator;
+    stateDiffState: Map<string, StateDiffState>;
+    decomposedGoals: Set<string>;
+    timeHorizonEngine?: ITimeHorizonEngine;
+    corePhasePolicyRegistry: CorePhasePolicyRegistry;
+    coreDecisionEngine: CoreDecisionEngine;
+    capabilityFailures: Map<string, number>;
+    incrementTransferCounter: () => number;
+    getPendingDirective: (goalId: string) => NextIterationDirective | undefined;
+}
+export interface RunCoreIterationInput {
+    goalId: string;
+    loopIndex: number;
+    isFirstIteration?: boolean;
+}
+export declare class CoreIterationKernel {
+    private readonly deps;
+    constructor(deps: CoreIterationKernelDeps);
+    run(input: RunCoreIterationInput): Promise<LoopIterationResult>;
+}
+//# sourceMappingURL=iteration-kernel.d.ts.map

package/dist/orchestrator/loop/core-loop/iteration-kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-kernel.d.ts","sourceRoot":"","sources":["../../../../src/orchestrator/loop/core-loop/iteration-kernel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAG5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAC3F,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAgBvE,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAYtB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+CAA+C,CAAC;AAGxF,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,MAAM,kBAAkB,CAAC;IACpC,SAAS,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC5C,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;IACvC,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,wBAAwB,EAAE,MAAM,MAAM,CAAC;IACvC,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,sBAAsB,GAAG,SAAS,CAAC;CAC7E;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,qBAAa,mBAAmB;IAClB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,uBAAuB;IAEpD,GAAG,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAuetE"}

package/dist/orchestrator/loop/core-loop/iteration-kernel.js

@@ -0,0 +1,356 @@
+import { generateLoopReport } from "../loop-report-helper.js";
+import { makeEmptyIterationResult } from "../loop-result-types.js";
+import { loadGoalWithAggregation, observeAndReload, calculateGapOrComplete, scoreDrivesAndCheckKnowledge, phaseAutoDecompose, } from "./preparation.js";
+import { checkCompletionAndMilestones, detectStallsAndRebalance, checkDependencyBlock, runTaskCycleWithContext, } from "./task-cycle.js";
+import { runStateDiffCheck, tryParallelExecution, } from "./control.js";
+import { handleCapabilityAcquisition } from "./capability.js";
+import { loadDreamActivationState } from "../../../platform/dream/dream-activation.js";
+import { CoreLoopEvidenceLedger } from "./evidence-ledger.js";
+import { CorePhaseRuntime } from "./phase-runtime.js";
+import { buildKnowledgeRefreshSpec, buildObserveEvidenceSpec, buildReplanningOptionsSpec, buildStallInvestigationSpec, buildVerificationEvidenceSpec, } from "./phase-specs.js";
+export class CoreIterationKernel {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async run(input) {
+        const { goalId, loopIndex, isFirstIteration } = input;
+        const startTime = Date.now();
+        let config = this.deps.getConfig();
+        const pendingDirective = this.deps.getPendingDirective(goalId);
+        const ctx = {
+            deps: this.deps.deps,
+            config,
+            logger: this.deps.logger,
+            toolExecutor: this.deps.deps.toolExecutor,
+            timeHorizonEngine: this.deps.timeHorizonEngine,
+        };
+        const runPhase = async (phase, work) => {
+            const phaseStartedAt = Date.now();
+            this.deps.logger?.info(`[CoreLoop] phase ${phase} starting`, { goalId, loopIndex });
+            try {
+                const value = await work();
+                this.deps.logger?.info(`[CoreLoop] phase ${phase} completed`, {
+                    goalId,
+                    loopIndex,
+                    duration_ms: Date.now() - phaseStartedAt,
+                });
+                return value;
+            }
+            catch (err) {
+                this.deps.logger?.warn(`[CoreLoop] phase ${phase} failed`, {
+                    goalId,
+                    loopIndex,
+                    duration_ms: Date.now() - phaseStartedAt,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                throw err;
+            }
+        };
+        const result = makeEmptyIterationResult(goalId, loopIndex);
+        const evidenceLedger = new CoreLoopEvidenceLedger();
+        const corePhaseRuntime = new CorePhaseRuntime({
+            phaseRunner: this.deps.deps.corePhaseRunner,
+            policyRegistry: this.deps.corePhasePolicyRegistry,
+        });
+        const rememberPhase = (execution) => {
+            if (execution.status === "skipped")
+                return;
+            evidenceLedger.record(execution);
+            result.corePhaseResults = evidenceLedger.toIterationPhaseResults();
+        };
+        this.deps.logger?.info(`[CoreLoop] iteration ${loopIndex + 1} starting`, { goalId, loopIndex });
+        const loadedGoal = await runPhase("load-goal", () => loadGoalWithAggregation(ctx, goalId, result, startTime));
+        if (!loadedGoal)
+            return result;
+        let goal = loadedGoal;
+        await runPhase("auto-decompose", () => phaseAutoDecompose(goalId, goal, this.deps.deps, config, this.deps.logger, this.deps.decomposedGoals, isFirstIteration));
+        if (!goal.children_ids.length) {
+            const reloadedAfterDecompose = await this.deps.deps.stateManager.loadGoal(goalId);
+            if (reloadedAfterDecompose && reloadedAfterDecompose.children_ids.length > 0) {
+                goal = reloadedAfterDecompose;
+                if (this.deps.deps.treeLoopOrchestrator) {
+                    config = { ...config, treeMode: true };
+                    this.deps.setConfig(config);
+                    ctx.config = config;
+                    this.deps.logger?.info("[CoreLoop] treeMode enabled after auto-decomposition", {
+                        goalId,
+                        childrenCount: goal.children_ids.length,
+                    });
+                }
+            }
+        }
+        const observeEvidence = await runPhase("observe-evidence", () => corePhaseRuntime.run({
+            ...buildObserveEvidenceSpec(),
+            requiredTools: [],
+            allowedTools: [],
+            budget: {},
+        }, {
+            goalTitle: goal.title,
+            goalDescription: goal.description,
+            dimensions: goal.dimensions.map((dimension) => dimension.name),
+        }, { goalId, gapAggregate: result.gapAggregate }));
+        rememberPhase(observeEvidence);
+        goal = await runPhase("observe", () => observeAndReload(ctx, goalId, goal, loopIndex));
+        if (this.deps.stateDiff) {
+            const { shouldSkip } = await runStateDiffCheck(this.deps.stateDiff, this.deps.stateDiffState, goalId, goal, loopIndex, config, this.deps.deps, result, startTime, this.deps.logger);
+            if (shouldSkip)
+                return result;
+        }
+        const gapResult = await runPhase("gap-analysis", () => calculateGapOrComplete(ctx, goalId, goal, loopIndex, result, startTime));
+        if (!gapResult)
+            return result;
+        const { gapVector, gapAggregate, skipTaskGeneration } = gapResult;
+        this.deps.logger?.info(`[iter ${loopIndex}] gap: ${gapAggregate.toFixed(2)} | ${(gapVector.gaps ?? [])
+            .map((g) => `${g.dimension_name}=${g.normalized_weighted_gap.toFixed(2)}`)
+            .join(", ")}`);
+        let driveScores = [];
+        let highDissatisfactionDimensions = [];
+        if (!skipTaskGeneration) {
+            const driveResult = await runPhase("drive-scoring", () => scoreDrivesAndCheckKnowledge(ctx, goalId, goal, gapVector, loopIndex, result, startTime, (id, idx, r, g) => generateLoopReport(id, idx, r, g, this.deps.deps.reportingEngine, this.deps.logger)));
+            if (!driveResult)
+                return result;
+            driveScores = driveResult.driveScores;
+            highDissatisfactionDimensions = driveResult.highDissatisfactionDimensions;
+        }
+        const knowledgeRefresh = !skipTaskGeneration
+            ? await runPhase("knowledge-refresh", () => corePhaseRuntime.run({
+                ...buildKnowledgeRefreshSpec(),
+                requiredTools: [],
+                allowedTools: [],
+                budget: {},
+            }, {
+                goalTitle: goal.title,
+                topDimensions: highDissatisfactionDimensions.length > 0
+                    ? [
+                        ...(pendingDirective?.focusDimension ? [pendingDirective.focusDimension] : []),
+                        ...highDissatisfactionDimensions,
+                    ].filter((value, index, values) => values.indexOf(value) === index)
+                    : [
+                        ...(pendingDirective?.focusDimension ? [pendingDirective.focusDimension] : []),
+                        ...driveScores.map((score) => score.dimension_name),
+                    ].filter((value, index, values) => values.indexOf(value) === index),
+                gapAggregate,
+            }, { goalId, gapAggregate }))
+            : null;
+        if (knowledgeRefresh)
+            rememberPhase(knowledgeRefresh);
+        const replanningOptions = this.deps.coreDecisionEngine.shouldRunReplanningOptions({
+            skipTaskGeneration: Boolean(skipTaskGeneration),
+            taskCycleBlocked: false,
+            gapAggregate,
+        })
+            ? await runPhase("replanning-options", () => corePhaseRuntime.run({
+                ...buildReplanningOptionsSpec(),
+                requiredTools: [],
+                allowedTools: [],
+                budget: {},
+            }, {
+                goalTitle: goal.title,
+                targetDimensions: driveScores.map((score) => score.dimension_name),
+                gapAggregate,
+            }, { goalId, gapAggregate }))
+            : null;
+        if (replanningOptions)
+            rememberPhase(replanningOptions);
+        await runPhase("completion-check", () => checkCompletionAndMilestones(ctx, goalId, goal, result, startTime));
+        if (result.error)
+            return result;
+        const stallActionHints = this.deps.coreDecisionEngine.buildStallActionHints({
+            phase: replanningOptions,
+        });
+        await runPhase("stall-detection", () => detectStallsAndRebalance(ctx, goalId, goal, result, stallActionHints.recommendedAction
+            ? stallActionHints
+            : pendingDirective?.preferredAction
+                ? { recommendedAction: pendingDirective.preferredAction }
+                : undefined));
+        const stallInvestigation = this.deps.coreDecisionEngine.shouldRunStallInvestigation(result)
+            ? await runPhase("stall-investigation", () => corePhaseRuntime.run({
+                ...buildStallInvestigationSpec(),
+                requiredTools: [],
+                allowedTools: [],
+                budget: {},
+            }, {
+                goalTitle: goal.title,
+                stallType: result.stallReport?.stall_type ?? "unknown",
+                ...(result.stallReport?.dimension_name ? { dimensionName: result.stallReport.dimension_name } : {}),
+                ...(result.stallReport?.suggested_cause ? { suggestedCause: result.stallReport.suggested_cause } : {}),
+            }, { goalId, stallDetected: result.stallDetected, gapAggregate }))
+            : null;
+        if (stallInvestigation)
+            rememberPhase(stallInvestigation);
+        if (result.stallDetected && result.stallReport) {
+            this.deps.logger?.warn(`[iter ${loopIndex}] stall detected: ${result.stallReport.stall_type}`, {
+                escalation: result.stallReport.escalation_level,
+            });
+            void this.deps.deps.hookManager?.emit("StallDetected", {
+                goal_id: goalId,
+                dimension: result.stallReport.dimension_name ?? undefined,
+                data: {
+                    stall_type: result.stallReport.stall_type,
+                    escalation_level: result.stallReport.escalation_level,
+                    suggested_cause: result.stallReport.suggested_cause,
+                    task_id: result.stallReport.task_id ?? undefined,
+                },
+            });
+        }
+        const knowledgeAcquisitionDecision = this.deps.coreDecisionEngine.evaluateKnowledgeAcquisition({
+            phase: knowledgeRefresh,
+            hasKnowledgeManager: !!this.deps.deps.knowledgeManager,
+            hasToolExecutor: !!this.deps.deps.toolExecutor,
+        });
+        if (knowledgeAcquisitionDecision.shouldAcquire &&
+            knowledgeAcquisitionDecision.question &&
+            this.deps.deps.knowledgeManager &&
+            this.deps.deps.toolExecutor) {
+            try {
+                const acquired = await this.deps.deps.knowledgeManager.acquireWithTools(knowledgeAcquisitionDecision.question, goalId, this.deps.deps.toolExecutor, {
+                    cwd: process.cwd(),
+                    goalId,
+                    trustBalance: 0,
+                    preApproved: true,
+                    approvalFn: async () => false,
+                });
+                for (const entry of acquired) {
+                    await this.deps.deps.knowledgeManager.saveKnowledge(goalId, entry);
+                }
+                if (acquired.length > 0) {
+                    result.nextIterationDirective = this.deps.coreDecisionEngine.buildNextIterationDirective({
+                        knowledgeRefreshPhase: knowledgeRefresh,
+                        replanningPhase: replanningOptions,
+                        goalDimensions: goal.dimensions.map((dimension) => dimension.name),
+                        fallbackFocusDimension: driveScores[0]?.dimension_name ?? pendingDirective?.focusDimension,
+                    });
+                    this.deps.logger?.info("CoreLoop: knowledge_refresh auto-acquired knowledge and skipped execution", {
+                        goalId,
+                        acquiredCount: acquired.length,
+                    });
+                    await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
+                    result.skipped = true;
+                    result.skipReason = "knowledge_refresh_auto_acquire";
+                    result.elapsedMs = Date.now() - startTime;
+                    return result;
+                }
+            }
+            catch (err) {
+                this.deps.logger?.warn("CoreLoop: knowledge_refresh auto acquisition failed (non-fatal)", {
+                    goalId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        if (result.stallDetected && this.deps.deps.knowledgeManager && this.deps.deps.toolExecutor) {
+            try {
+                const activation = await loadDreamActivationState(this.deps.deps.stateManager.getBaseDir());
+                if (activation.flags.autoAcquireKnowledge) {
+                    const portfolio = await Promise.resolve(this.deps.deps.strategyManager.getPortfolio(goalId)).catch(() => null);
+                    const observationContext = {
+                        observations: goal.dimensions.map((dimension) => ({
+                            name: dimension.name,
+                            current_value: dimension.current_value,
+                            confidence: dimension.confidence,
+                        })),
+                        strategies: portfolio?.strategies ?? null,
+                        confidence: gapVector.gaps.reduce((sum, gap) => sum + gap.confidence, 0) /
+                            Math.max(gapVector.gaps.length, 1),
+                    };
+                    const gapSignal = await this.deps.deps.knowledgeManager.detectKnowledgeGap(observationContext);
+                    if (gapSignal) {
+                        const acquired = await this.deps.deps.knowledgeManager.acquireWithTools(gapSignal.missing_knowledge, goalId, this.deps.deps.toolExecutor, {
+                            cwd: process.cwd(),
+                            goalId,
+                            trustBalance: 0,
+                            preApproved: true,
+                            approvalFn: async () => false,
+                        });
+                        for (const entry of acquired) {
+                            await this.deps.deps.knowledgeManager.saveKnowledge(goalId, entry);
+                        }
+                        if (acquired.length > 0) {
+                            this.deps.logger?.info("CoreLoop: dream auto-acquired knowledge and skipped execution for context refresh", { goalId, acquiredCount: acquired.length });
+                            await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
+                            result.skipped = true;
+                            result.skipReason = "dream_auto_acquire_knowledge";
+                            result.elapsedMs = Date.now() - startTime;
+                            return result;
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                this.deps.logger?.warn("CoreLoop: autoAcquireKnowledge failed (non-fatal)", {
+                    goalId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        if (skipTaskGeneration) {
+            result.nextIterationDirective = this.deps.coreDecisionEngine.buildNextIterationDirective({
+                knowledgeRefreshPhase: knowledgeRefresh,
+                replanningPhase: replanningOptions,
+                goalDimensions: goal.dimensions.map((dimension) => dimension.name),
+                fallbackFocusDimension: driveScores[0]?.dimension_name ?? pendingDirective?.focusDimension,
+            });
+            await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
+            result.elapsedMs = Date.now() - startTime;
+            return result;
+        }
+        if (checkDependencyBlock(ctx, goalId, result))
+            return result;
+        const tookParallelPath = await tryParallelExecution(goalId, goal, gapAggregate, result, startTime, this.deps.deps, loopIndex, this.deps.logger);
+        if (tookParallelPath)
+            return result;
+        const shouldPreferReplanningContext = this.deps.coreDecisionEngine.shouldPreferReplanningContext({
+            phase: replanningOptions,
+        });
+        const taskGenerationHints = this.deps.coreDecisionEngine.buildTaskGenerationHints({
+            phase: replanningOptions,
+            goalDimensions: goal.dimensions.map((dimension) => dimension.name),
+        });
+        const mergedTaskGenerationHints = {
+            targetDimensionOverride: taskGenerationHints.targetDimensionOverride ?? pendingDirective?.focusDimension,
+            knowledgeContextPrefix: taskGenerationHints.knowledgeContextPrefix,
+        };
+        if (!shouldPreferReplanningContext && replanningOptions?.status === "completed") {
+            this.deps.logger?.debug("CoreLoop: replanning evidence collected but not adopted as preferred context", {
+                goalId,
+                loopIndex,
+            });
+        }
+        const loopCallbacks = {
+            handleCapabilityAcquisition: (task, gId, adapter) => handleCapabilityAcquisition(task, gId, adapter, this.deps.deps.capabilityDetector, this.deps.capabilityFailures, this.deps.logger),
+            incrementTransferCounter: () => this.deps.incrementTransferCounter(),
+            tryGenerateReport: (id, idx, r, g) => generateLoopReport(id, idx, r, g, this.deps.deps.reportingEngine, this.deps.logger),
+        };
+        const taskCycleOk = await runTaskCycleWithContext(ctx, goalId, goal, gapVector, driveScores, highDissatisfactionDimensions, loopIndex, result, startTime, loopCallbacks, evidenceLedger, mergedTaskGenerationHints);
+        if (!taskCycleOk)
+            return result;
+        const completedTaskResult = result.taskResult;
+        if (this.deps.coreDecisionEngine.shouldRunVerificationEvidence(result) && completedTaskResult) {
+            const verificationPhase = await runPhase("verification-evidence", () => corePhaseRuntime.run({
+                ...buildVerificationEvidenceSpec(),
+                budget: {},
+            }, {
+                taskId: completedTaskResult.task.id,
+                taskDescription: completedTaskResult.task.work_description,
+                successCriteria: completedTaskResult.task.success_criteria.map((criterion) => criterion.description),
+                executionAction: completedTaskResult.action,
+            }, {
+                goalId,
+                taskId: completedTaskResult.task.id,
+                hasTaskResult: true,
+            }));
+            rememberPhase(verificationPhase);
+        }
+        result.nextIterationDirective = this.deps.coreDecisionEngine.buildNextIterationDirective({
+            knowledgeRefreshPhase: knowledgeRefresh,
+            replanningPhase: replanningOptions,
+            goalDimensions: goal.dimensions.map((dimension) => dimension.name),
+            fallbackFocusDimension: driveScores[0]?.dimension_name ?? pendingDirective?.focusDimension,
+        });
+        await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
+        result.elapsedMs = Date.now() - startTime;
+        return result;
+    }
+}
+//# sourceMappingURL=iteration-kernel.js.map