pulseed 0.5.3 → 0.6.0

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

@@ -1,13 +1,20 @@
+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 { loadDreamActivationState } from "../../../platform/dream/dream-activation.js";
 import { CoreLoopEvidenceLedger } from "./evidence-ledger.js";
 import { CorePhaseRuntime } from "./phase-runtime.js";
-import { buildKnowledgeRefreshSpec, buildObserveEvidenceSpec, buildReplanningOptionsSpec, buildStallInvestigationSpec, buildWaitObservationSpec, buildVerificationEvidenceSpec, } from "./phase-specs.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) {
@@ -48,17 +55,99 @@ export class CoreIterationKernel {
             }
         };
         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)
@@ -91,6 +180,7 @@ export class CoreIterationKernel {
             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);
@@ -104,7 +194,54 @@ export class CoreIterationKernel {
         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 activeWait = await this.findActiveWaitObservationInput(goalId, goal.title);
+        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(),
@@ -113,8 +250,9 @@ export class CoreIterationKernel {
                 budget: {},
             }, activeWait, { goalId, gapAggregate }));
             rememberPhase(waitObservationPhase);
+            await appendPhaseEvidence(appendRuntimeEvidence, waitObservationPhase, "observation");
         }
-        const waitObservationDecision = await runPhase("wait-observation", () => evaluateWaitStrategiesForObserveOnly(ctx, goalId, goal, result));
+        const waitObservationDecision = await runPhase("wait-observation", () => evaluateWaitStrategiesForObserveOnly(ctx, goalId, goal, result, activationContext?.waitResume?.strategyId));
         if (waitObservationDecision.observeOnly) {
             result.skipped = true;
             result.skipReason =
@@ -156,6 +294,8 @@ export class CoreIterationKernel {
             : null;
         if (knowledgeRefresh)
             rememberPhase(knowledgeRefresh);
+        if (knowledgeRefresh)
+            await appendPhaseEvidence(appendRuntimeEvidence, knowledgeRefresh, "strategy");
         const replanningOptions = this.deps.coreDecisionEngine.shouldRunReplanningOptions({
             skipTaskGeneration: Boolean(skipTaskGeneration),
             taskCycleBlocked: false,
@@ -174,6 +314,8 @@ export class CoreIterationKernel {
             : 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;
@@ -200,6 +342,8 @@ export class CoreIterationKernel {
             : 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,
@@ -215,6 +359,48 @@ export class CoreIterationKernel {
                 },
             });
         }
+        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,
@@ -225,26 +411,18 @@ export class CoreIterationKernel {
             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) {
+                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: acquired.length,
+                        acquiredCount,
                     });
                     await generateLoopReport(goalId, loopIndex, result, goal, this.deps.deps.reportingEngine, this.deps.logger);
                     result.skipped = true;
@@ -262,40 +440,14 @@ export class CoreIterationKernel {
         }
         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;
-                        }
-                    }
+                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) {
@@ -312,6 +464,7 @@ export class CoreIterationKernel {
                 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;
@@ -328,9 +481,20 @@ export class CoreIterationKernel {
             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", {
@@ -347,6 +511,9 @@ export class CoreIterationKernel {
         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(),
@@ -362,6 +529,9 @@ export class CoreIterationKernel {
                 hasTaskResult: true,
             }));
             rememberPhase(verificationPhase);
+            await appendPhaseEvidence(appendRuntimeEvidence, verificationPhase, "verification", {
+                task_id: completedTaskResult.task.id,
+            });
         }
         result.nextIterationDirective = this.deps.coreDecisionEngine.buildNextIterationDirective({
             knowledgeRefreshPhase: knowledgeRefresh,
@@ -369,47 +539,297 @@ export class CoreIterationKernel {
             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 findActiveWaitObservationInput(goalId, goalTitle) {
-        if (typeof this.deps.deps.strategyManager.getPortfolio !== "function")
-            return null;
-        const portfolio = await Promise.resolve(this.deps.deps.strategyManager.getPortfolio(goalId)).catch(() => null);
-        if (!portfolio || !this.deps.deps.portfolioManager)
-            return null;
-        const strategy = portfolio.strategies.find((candidate) => candidate.state === "active" && this.deps.deps.portfolioManager?.isWaitStrategy(candidate));
-        if (!strategy || typeof strategy.wait_until !== "string")
-            return null;
-        const metadataPath = `strategies/${goalId}/wait-meta/${strategy.id}.json`;
-        const rawMetadata = await Promise.resolve(this.deps.deps.stateManager.readRaw(metadataPath)).catch(() => null);
-        const metadata = rawMetadata && typeof rawMetadata === "object" ? rawMetadata : {};
-        const nextObserveAt = typeof metadata["next_observe_at"] === "string" ? metadata["next_observe_at"] : strategy.wait_until;
-        const nextObserveAtMs = Date.parse(nextObserveAt);
-        if (!Number.isFinite(nextObserveAtMs) || nextObserveAtMs > Date.now())
-            return null;
-        const conditions = Array.isArray(metadata["conditions"]) ? metadata["conditions"] : [];
-        const processRefs = Array.isArray(metadata["process_refs"]) ? metadata["process_refs"] : [];
-        const artifactRefs = Array.isArray(metadata["artifact_refs"]) ? metadata["artifact_refs"] : [];
-        const latestObservation = metadata["latest_observation"];
-        const latest = latestObservation && typeof latestObservation === "object"
-            ? latestObservation
-            : {};
-        const latestEvidence = latest["evidence"] && typeof latest["evidence"] === "object"
-            ? latest["evidence"]
-            : {};
-        return {
-            goalTitle,
-            waitStrategyId: strategy.id,
-            waitReason: typeof strategy.wait_reason === "string" ? strategy.wait_reason : "waiting",
-            waitUntil: strategy.wait_until,
-            nextObserveAt,
-            conditions: conditions.map((condition) => JSON.stringify(condition)),
-            processRefs: processRefs.map((ref) => JSON.stringify(ref)),
-            artifactRefs: artifactRefs.map((ref) => JSON.stringify(ref)),
-            approvalPending: Boolean(metadata["approval_pending"] ?? latestEvidence["approval_pending"]),
-        };
+}
+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