pulseed 0.6.0 → 0.6.2

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

@@ -0,0 +1,835 @@
+import * as path from "node:path";
+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, evaluateWaitStrategiesForObserveOnly, checkDependencyBlock, runTaskCycleWithContext, } from "./task-cycle.js";
+import { runStateDiffCheck, tryParallelExecution, } from "./control.js";
+import { handleCapabilityAcquisition } from "./capability.js";
+import { CoreLoopEvidenceLedger } from "./evidence-ledger.js";
+import { CorePhaseRuntime } from "./phase-runtime.js";
+import { buildDreamReviewCheckpointSpec, buildKnowledgeRefreshSpec, buildObserveEvidenceSpec, buildPublicResearchSpec, buildReplanningOptionsSpec, buildStallInvestigationSpec, buildWaitObservationSpec, buildVerificationEvidenceSpec, } from "./phase-specs.js";
+import { buildDeadlineFinalizationStatus, normalizeFinalizationPolicy, shouldStopExplorationForFinalization, } from "../../../platform/time/deadline-finalization.js";
+import { deriveExecutionModeFromDeadlineStatus } from "../../../platform/time/execution-mode.js";
+import { findActiveWaitObservationInput } from "./iteration-kernel-wait.js";
+import { autoAcquireKnowledgeForDreamStall, autoAcquireKnowledgeForRefresh, } from "./iteration-kernel-knowledge.js";
+import { buildDreamReviewCheckpointRequest, dreamCheckpointRawRefs, formatDreamRunControlRecommendationContext, normalizeDreamReviewCheckpoint, } from "./dream-review-checkpoint.js";
+import { buildPublicResearchRequest, normalizePublicResearchMemo, publicResearchSummary, researchRawRefs, } from "./public-research.js";
+import { RuntimeReproducibilityManifestStore } from "../../../runtime/store/reproducibility-manifest.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 activationContext = this.deps.getActivationContext();
+        const evidenceLedger = new CoreLoopEvidenceLedger();
+        const runtimeEvidenceScope = {
+            goal_id: goalId,
+            ...(activationContext?.backgroundRun?.backgroundRunId
+                ? { run_id: activationContext.backgroundRun.backgroundRunId }
+                : {}),
+            loop_index: loopIndex,
+        };
+        const appendRuntimeEvidence = async (entry) => {
+            if (config.dryRun || !this.deps.deps.evidenceLedger)
+                return;
+            try {
+                await this.deps.deps.evidenceLedger.append({
+                    ...entry,
+                    scope: {
+                        ...runtimeEvidenceScope,
+                        ...entry.scope,
+                    },
+                });
+            }
+            catch (err) {
+                this.deps.logger?.warn("CoreLoop: failed to append runtime evidence ledger entry", {
+                    goalId,
+                    loopIndex,
+                    kind: entry.kind,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        };
+        const corePhaseRuntime = new CorePhaseRuntime({
+            phaseRunner: this.deps.deps.corePhaseRunner,
+            policyRegistry: this.deps.corePhasePolicyRegistry,
+        });
+        let dreamReviewCheckpointRan = false;
+        const rememberPhase = (execution) => {
+            if (execution.status === "skipped")
+                return;
+            evidenceLedger.record(execution);
+            result.corePhaseResults = evidenceLedger.toIterationPhaseResults();
+        };
+        const maybeRunDreamReviewCheckpoint = async (input) => {
+            if (dreamReviewCheckpointRan)
+                return null;
+            const evidenceSummary = await loadDreamReviewEvidenceSummary(this.deps.deps.evidenceLedger, goalId);
+            const request = buildDreamReviewCheckpointRequest({
+                goal: input.goal,
+                loopIndex,
+                result,
+                driveScores: input.driveScores,
+                finalizationStatus: input.finalizationStatus,
+                executionMode: input.executionMode,
+                evidenceSummary,
+                recentCheckpoints: evidenceSummary?.dream_checkpoints,
+                ...(input.requestedTrigger ? { requestedTrigger: input.requestedTrigger } : {}),
+            });
+            if (!request)
+                return null;
+            const dreamReview = await runPhase("dream-review-checkpoint", () => corePhaseRuntime.run({
+                ...buildDreamReviewCheckpointSpec(),
+                requiredTools: ["soil_query"],
+                allowedTools: ["soil_query", "knowledge_query", "memory_recall"],
+                budget: {
+                    maxModelTurns: 3,
+                    maxToolCalls: 5,
+                    maxWallClockMs: 45_000,
+                    maxRepeatedToolCalls: 1,
+                },
+            }, {
+                goalTitle: input.goal.title,
+                trigger: request.trigger,
+                reason: request.reason,
+                activeDimensions: request.activeDimensions,
+                ...(request.bestEvidenceSummary ? { bestEvidenceSummary: request.bestEvidenceSummary } : {}),
+                recentStrategyFamilies: request.recentStrategyFamilies,
+                activeHypotheses: request.activeHypotheses,
+                rejectedApproaches: request.rejectedApproaches,
+                failedLineages: request.failedLineages,
+                ...(request.metricTrendSummary ? { metricTrendSummary: request.metricTrendSummary } : {}),
+                ...(request.finalizationReason ? { finalizationReason: request.finalizationReason } : {}),
+                ...(request.currentExecutionMode ? { currentExecutionMode: request.currentExecutionMode } : {}),
+                runControlPolicy: request.runControlPolicy,
+                memoryAuthorityPolicy: request.memoryAuthorityPolicy,
+                maxGuidanceItems: request.maxGuidanceItems,
+            }, { goalId, stallDetected: result.stallDetected, gapAggregate: input.gapAggregate }));
+            rememberPhase(dreamReview);
+            const checkpoint = await appendDreamReviewCheckpointEvidence(appendRuntimeEvidence, dreamReview, request, input.goal);
+            if (checkpoint?.run_control_recommendations.length) {
+                result.dreamRunControlRecommendations = checkpoint.run_control_recommendations;
+            }
+            dreamReviewCheckpointRan = dreamReview.status !== "skipped";
+            return checkpoint;
+        };
+        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);
+        await appendPhaseEvidence(appendRuntimeEvidence, observeEvidence, "observation");
+        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(", ")}`);
+        const finalizationStatus = await runPhase("deadline-finalization", async () => {
+            const bestArtifact = await loadBestFinalizationArtifact(this.deps.deps.evidenceLedger, goalId, normalizeFinalizationPolicy(goal.finalization_policy).best_artifact_selection);
+            const reproducibilityManifestId = await loadReadyFinalizationManifestId({
+                stateManager: this.deps.deps.stateManager,
+                goalId,
+                runId: runtimeEvidenceScope.run_id,
+                bestArtifact,
+                requireReproducibilityManifest: normalizeFinalizationPolicy(goal.finalization_policy).require_reproducibility_manifest,
+            });
+            return buildDeadlineFinalizationStatus({
+                goal,
+                bestArtifact,
+                reproducibilityManifestId,
+            });
+        });
+        result.finalizationStatus = finalizationStatus;
+        const executionMode = deriveExecutionModeFromDeadlineStatus(finalizationStatus);
+        result.executionMode = executionMode;
+        if (shouldStopExplorationForFinalization(finalizationStatus)) {
+            await maybeRunDreamReviewCheckpoint({
+                goal,
+                gapAggregate,
+                driveScores: [],
+                finalizationStatus,
+                executionMode,
+                requestedTrigger: "pre_finalization",
+            });
+            result.skipped = true;
+            result.skipReason =
+                finalizationStatus.mode === "missed_deadline"
+                    ? "deadline_missed_finalization"
+                    : "deadline_finalization";
+            await appendRuntimeEvidence({
+                kind: "decision",
+                summary: finalizationStatus.reason,
+                outcome: "blocked",
+                decision_reason: finalizationStatus.reason,
+                scope: { phase: "deadline_finalization" },
+                result: {
+                    status: finalizationStatus.mode,
+                    summary: finalizationStatus.finalization_plan?.deliverable_contract ?? finalizationStatus.reason,
+                },
+            });
+            await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
+            result.elapsedMs = Date.now() - startTime;
+            return result;
+        }
+        const activeWait = await findActiveWaitObservationInput(this.deps.deps, goalId, goal.title, activationContext?.waitResume?.strategyId);
+        if (activeWait) {
+            const waitObservationPhase = await runPhase("wait-observation-agentic", () => corePhaseRuntime.run({
+                ...buildWaitObservationSpec(),
+                requiredTools: [],
+                allowedTools: [],
+                budget: {},
+            }, activeWait, { goalId, gapAggregate }));
+            rememberPhase(waitObservationPhase);
+            await appendPhaseEvidence(appendRuntimeEvidence, waitObservationPhase, "observation");
+        }
+        const waitObservationDecision = await runPhase("wait-observation", () => evaluateWaitStrategiesForObserveOnly(ctx, goalId, goal, result, activationContext?.waitResume?.strategyId));
+        if (waitObservationDecision.observeOnly) {
+            result.skipped = true;
+            result.skipReason =
+                waitObservationDecision.outcome?.status === "not_due"
+                    ? "wait_not_due"
+                    : "wait_observe_only";
+            await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
+            result.elapsedMs = Date.now() - startTime;
+            return result;
+        }
+        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);
+        if (knowledgeRefresh)
+            await appendPhaseEvidence(appendRuntimeEvidence, knowledgeRefresh, "strategy");
+        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);
+        if (replanningOptions)
+            await appendPhaseEvidence(appendRuntimeEvidence, replanningOptions, "strategy");
+        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 (stallInvestigation)
+            await appendPhaseEvidence(appendRuntimeEvidence, stallInvestigation, "failure");
+        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 dreamCheckpoint = await maybeRunDreamReviewCheckpoint({
+            goal,
+            gapAggregate,
+            driveScores,
+            finalizationStatus,
+            executionMode,
+        });
+        const dreamRunControlRecommendationContext = formatDreamRunControlRecommendationContext(dreamCheckpoint?.run_control_recommendations);
+        const publicResearchRequest = buildPublicResearchRequest({
+            goal,
+            result,
+            gapAggregate,
+            driveScores,
+            knowledgeRefresh,
+        });
+        const publicResearch = publicResearchRequest
+            ? await runPhase("public-research", () => corePhaseRuntime.run({
+                ...buildPublicResearchSpec(),
+                requiredTools: ["research_answer_with_sources"],
+                allowedTools: ["research_web", "research_answer_with_sources"],
+                budget: {
+                    maxModelTurns: 4,
+                    maxToolCalls: 4,
+                    maxWallClockMs: 60_000,
+                    maxRepeatedToolCalls: 1,
+                },
+            }, {
+                goalTitle: goal.title,
+                trigger: publicResearchRequest.trigger,
+                question: publicResearchRequest.question,
+                targetDimensions: publicResearchRequest.targetDimensions,
+                sourcePreference: publicResearchRequest.sourcePreference,
+                maxSources: publicResearchRequest.maxSources,
+                sensitiveContextPolicy: publicResearchRequest.sensitiveContextPolicy,
+                untrustedContentPolicy: publicResearchRequest.untrustedContentPolicy,
+            }, { goalId, stallDetected: result.stallDetected, gapAggregate }))
+            : null;
+        if (publicResearch)
+            rememberPhase(publicResearch);
+        if (publicResearch && publicResearchRequest) {
+            await appendPublicResearchEvidence(appendRuntimeEvidence, publicResearch, publicResearchRequest);
+        }
+        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 acquiredCount = await autoAcquireKnowledgeForRefresh(this.deps.deps, this.deps.logger, goalId, knowledgeAcquisitionDecision.question);
+                if (acquiredCount > 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,
+                    });
+                    await appendDecisionEvidence(appendRuntimeEvidence, result.nextIterationDirective, "knowledge_refresh_auto_acquire");
+                    this.deps.logger?.info("CoreLoop: knowledge_refresh auto-acquired knowledge and skipped execution", {
+                        goalId,
+                        acquiredCount,
+                    });
+                    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 acquiredCount = await autoAcquireKnowledgeForDreamStall(this.deps.deps, this.deps.logger, goalId, goal, gapVector);
+                if (acquiredCount > 0) {
+                    this.deps.logger?.info("CoreLoop: dream auto-acquired knowledge and skipped execution for context refresh", { goalId, acquiredCount });
+                    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 appendDecisionEvidence(appendRuntimeEvidence, result.nextIterationDirective, "skip_task_generation");
+            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 runtimeBudgetContext = await this.deps.getRuntimeBudgetContext?.().catch((err) => {
+            this.deps.logger?.warn("CoreLoop: failed to load runtime budget context", {
+                goalId,
+                loopIndex,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return undefined;
+        });
+        const mergedTaskGenerationHints = {
+            targetDimensionOverride: taskGenerationHints.targetDimensionOverride ?? pendingDirective?.focusDimension,
+            knowledgeContextPrefix: taskGenerationHints.knowledgeContextPrefix,
+            budgetContext: runtimeBudgetContext,
+            executionMode,
+            runControlRecommendationContext: dreamRunControlRecommendationContext,
+        };
+        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 (completedTaskResult) {
+            await appendTaskCycleEvidence(appendRuntimeEvidence, completedTaskResult);
+        }
+        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);
+            await appendPhaseEvidence(appendRuntimeEvidence, verificationPhase, "verification", {
+                task_id: completedTaskResult.task.id,
+            });
+        }
+        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 appendDecisionEvidence(appendRuntimeEvidence, result.nextIterationDirective, "next_iteration_directive");
+        await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
+        result.elapsedMs = Date.now() - startTime;
+        return result;
+    }
+}
+async function appendPublicResearchEvidence(appendRuntimeEvidence, execution, request) {
+    if (execution.status === "skipped")
+        return;
+    const output = buildPublicResearchSpec().outputSchema.safeParse(execution.output);
+    if (!output.success) {
+        await appendRuntimeEvidence({
+            kind: "research",
+            scope: { phase: execution.phase },
+            summary: execution.summary ?? request.reason,
+            outcome: "inconclusive",
+            result: {
+                status: execution.status,
+                summary: request.reason,
+                error: output.error.issues.map((issue) => issue.message).join("; "),
+            },
+        });
+        return;
+    }
+    const memo = normalizePublicResearchMemo(output.data, request);
+    await appendRuntimeEvidence({
+        kind: "research",
+        scope: { phase: execution.phase },
+        summary: publicResearchSummary(memo),
+        outcome: phaseStatusToOutcome(execution.status),
+        research: [memo],
+        result: {
+            status: execution.status,
+            summary: memo.summary,
+            ...(execution.error ? { error: execution.error } : {}),
+        },
+        raw_refs: [
+            ...researchRawRefs(memo),
+            ...(execution.traceId ? [{ kind: "agentloop_trace", id: execution.traceId }] : []),
+            ...(execution.sessionId ? [{ kind: "agentloop_state", id: execution.sessionId }] : []),
+            ...(execution.turnId ? [{ kind: "agentloop_turn", id: execution.turnId }] : []),
+        ],
+    });
+}
+async function appendDreamReviewCheckpointEvidence(appendRuntimeEvidence, execution, request, goal) {
+    if (execution.status === "skipped")
+        return null;
+    const output = buildDreamReviewCheckpointSpec().outputSchema.safeParse(execution.output);
+    if (!output.success) {
+        await appendRuntimeEvidence({
+            kind: "dream_checkpoint",
+            scope: { phase: execution.phase },
+            summary: execution.summary ?? request.reason,
+            outcome: "inconclusive",
+            result: {
+                status: execution.status,
+                summary: request.reason,
+                error: output.error.issues.map((issue) => issue.message).join("; "),
+            },
+        });
+        return null;
+    }
+    const checkpoint = normalizeDreamReviewCheckpoint(output.data, request, goal);
+    await appendRuntimeEvidence({
+        kind: "dream_checkpoint",
+        scope: { phase: execution.phase },
+        summary: checkpoint.summary,
+        outcome: phaseStatusToOutcome(execution.status),
+        dream_checkpoints: [checkpoint],
+        result: {
+            status: execution.status,
+            summary: checkpoint.guidance,
+            ...(execution.error ? { error: execution.error } : {}),
+        },
+        raw_refs: [
+            ...dreamCheckpointRawRefs(checkpoint),
+            ...(execution.traceId ? [{ kind: "agentloop_trace", id: execution.traceId }] : []),
+            ...(execution.sessionId ? [{ kind: "agentloop_state", id: execution.sessionId }] : []),
+            ...(execution.turnId ? [{ kind: "agentloop_turn", id: execution.turnId }] : []),
+        ],
+    });
+    return checkpoint;
+}
+async function loadDreamReviewEvidenceSummary(evidenceLedger, goalId) {
+    if (!evidenceLedger?.summarizeGoal)
+        return null;
+    try {
+        return await evidenceLedger.summarizeGoal(goalId);
+    }
+    catch {
+        return null;
+    }
+}
+async function loadBestFinalizationArtifact(evidenceLedger, goalId, selection) {
+    if (!evidenceLedger)
+        return null;
+    try {
+        if (selection === "best_evidence") {
+            const summary = await evidenceLedger.summarizeGoal?.(goalId);
+            return summary?.best_evidence ? bestArtifactFromEvidence(summary.best_evidence) : null;
+        }
+        const entries = evidenceLedger.readByGoal
+            ? (await evidenceLedger.readByGoal(goalId)).entries
+            : (await evidenceLedger.summarizeGoal?.(goalId))?.recent_entries ?? [];
+        const newestFirst = [...entries].sort((a, b) => b.occurred_at.localeCompare(a.occurred_at));
+        const selected = selection === "latest_artifact"
+            ? newestFirst.find((entry) => entry.artifacts.length > 0 || entry.kind === "artifact")
+            : selectLatestVerifiedArtifact(newestFirst);
+        return selected ? bestArtifactFromEvidence(selected) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function loadReadyFinalizationManifestId(input) {
+    if (!input.requireReproducibilityManifest)
+        return null;
+    if (!input.bestArtifact)
+        return null;
+    try {
+        const store = new RuntimeReproducibilityManifestStore(path.join(input.stateManager.getBaseDir(), "runtime"));
+        const manifest = await store.findReadyForFinalization({
+            goalId: input.goalId,
+            runId: input.runId,
+            deliverable: input.bestArtifact
+                ? {
+                    ...(input.bestArtifact.id ? { id: input.bestArtifact.id } : {}),
+                    label: input.bestArtifact.label,
+                    ...(input.bestArtifact.path ? { path: input.bestArtifact.path } : {}),
+                    ...(input.bestArtifact.state_relative_path ? { state_relative_path: input.bestArtifact.state_relative_path } : {}),
+                    ...(input.bestArtifact.url ? { url: input.bestArtifact.url } : {}),
+                }
+                : null,
+        });
+        return manifest?.manifest_id ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function selectLatestVerifiedArtifact(entriesNewestFirst) {
+    for (const verification of entriesNewestFirst) {
+        const verified = verification.verification?.verdict === "pass"
+            || (verification.kind === "verification" && verification.outcome === "improved");
+        if (!verified)
+            continue;
+        if (verification.artifacts.length > 0)
+            return verification;
+        const taskId = verification.scope.task_id;
+        if (!taskId)
+            continue;
+        const matchedArtifact = entriesNewestFirst.find((entry) => entry.scope.task_id === taskId
+            && entry.occurred_at <= verification.occurred_at
+            && entry.artifacts.length > 0);
+        if (matchedArtifact)
+            return matchedArtifact;
+    }
+    return undefined;
+}
+function bestArtifactFromEvidence(entry) {
+    const primaryArtifact = entry.artifacts[0];
+    return {
+        id: primaryArtifact?.label ?? entry.id,
+        label: primaryArtifact?.label ?? entry.summary ?? entry.result?.summary ?? entry.id,
+        kind: primaryArtifact?.kind ?? entry.kind,
+        summary: entry.summary ?? entry.result?.summary ?? entry.verification?.summary,
+        path: primaryArtifact?.path,
+        state_relative_path: primaryArtifact?.state_relative_path,
+        url: primaryArtifact?.url,
+        occurred_at: entry.occurred_at,
+        source: "runtime_evidence_ledger",
+    };
+}
+async function appendPhaseEvidence(appendRuntimeEvidence, execution, kind, scope) {
+    if (execution.status === "skipped")
+        return;
+    await appendRuntimeEvidence({
+        kind,
+        scope: { ...scope, phase: execution.phase },
+        summary: execution.summary ?? `${execution.phase} ${execution.status}`,
+        outcome: phaseStatusToOutcome(execution.status),
+        result: {
+            status: execution.status,
+            ...(execution.error ? { error: execution.error } : {}),
+            ...(execution.summary ? { summary: execution.summary } : {}),
+        },
+        raw_refs: [
+            ...(execution.traceId ? [{ kind: "agentloop_trace", id: execution.traceId }] : []),
+            ...(execution.sessionId ? [{ kind: "agentloop_state", id: execution.sessionId }] : []),
+            ...(execution.turnId ? [{ kind: "agentloop_turn", id: execution.turnId }] : []),
+        ],
+    });
+}
+async function appendDecisionEvidence(appendRuntimeEvidence, directive, fallbackReason) {
+    if (!directive)
+        return;
+    await appendRuntimeEvidence({
+        kind: "decision",
+        summary: directive.reason,
+        strategy: directive.preferredAction,
+        outcome: "continued",
+        decision_reason: directive.reason,
+        scope: { phase: directive.sourcePhase },
+        result: {
+            status: fallbackReason,
+            summary: directive.reason,
+        },
+    });
+}
+async function appendTaskCycleEvidence(appendRuntimeEvidence, taskResult) {
+    const task = taskResult.task;
+    await appendRuntimeEvidence({
+        kind: "task_generation",
+        scope: { task_id: task.id },
+        hypothesis: task.rationale,
+        strategy: task.approach,
+        task: {
+            id: task.id,
+            description: task.work_description,
+            primary_dimension: task.primary_dimension,
+        },
+        summary: task.work_description,
+        outcome: "continued",
+        decision_reason: task.rationale,
+    });
+    await appendRuntimeEvidence({
+        kind: taskResult.action === "completed" ? "execution" : "failure",
+        scope: { task_id: task.id },
+        task: {
+            id: task.id,
+            description: task.work_description,
+            action: taskResult.action,
+            primary_dimension: task.primary_dimension,
+        },
+        artifacts: taskResult.verificationResult.file_diffs?.map((diff) => ({
+            label: diff.path,
+            path: diff.path,
+            kind: "diff",
+        })) ?? [],
+        result: {
+            status: taskResult.action,
+            ...(task.execution_output ? { summary: truncateOneLine(task.execution_output, 500) } : {}),
+        },
+        outcome: taskActionToOutcome(taskResult.action),
+        summary: `Task ${task.id} ${taskResult.action}`,
+    });
+    await appendRuntimeEvidence({
+        kind: taskResult.verificationResult.verdict === "pass" ? "verification" : "failure",
+        scope: { task_id: task.id },
+        verification: {
+            verdict: taskResult.verificationResult.verdict,
+            confidence: taskResult.verificationResult.confidence,
+            summary: summarizeVerificationEvidence(taskResult.verificationResult.evidence),
+        },
+        result: {
+            status: taskResult.verificationResult.verdict,
+            summary: summarizeVerificationEvidence(taskResult.verificationResult.evidence),
+        },
+        outcome: verificationToOutcome(taskResult.verificationResult.verdict),
+        summary: `Verification ${taskResult.verificationResult.verdict} for ${task.id}`,
+    });
+}
+function phaseStatusToOutcome(status) {
+    if (status === "completed")
+        return "continued";
+    if (status === "failed")
+        return "failed";
+    return "inconclusive";
+}
+function taskActionToOutcome(action) {
+    if (action === "completed")
+        return "improved";
+    if (action === "approval_denied" || action === "capability_acquiring")
+        return "blocked";
+    if (action === "discard" || action === "escalate")
+        return "failed";
+    return "inconclusive";
+}
+function verificationToOutcome(verdict) {
+    if (verdict === "pass")
+        return "improved";
+    if (verdict === "fail")
+        return "failed";
+    return "inconclusive";
+}
+function summarizeVerificationEvidence(evidence) {
+    const summary = evidence.map((item) => item.description).filter(Boolean).join("; ");
+    return summary ? truncateOneLine(summary, 500) : undefined;
+}
+function truncateOneLine(value, maxLength) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 3)}...` : normalized;
+}
+//# sourceMappingURL=iteration-kernel.js.map