@openclawbrain/cli 0.4.13 → 0.4.15

package/dist/src/local-learner.js

@@ -3,9 +3,10 @@ import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { buildRouteArtifactReference, CONTRACT_IDS, PACK_GRAPH_SCHEMAS, ROUTER_PG_PROFILE_V1, ROUTER_PG_PROFILE_V2, checksumJsonPayload, computeRouterCollectedLabelCounts, computeRouterFreshnessChecksum, computeRouterObjectiveChecksum, computeRouterQueryChecksum, computeRouterWeightsChecksum, sortNormalizedEvents, validateTeacherSupervisionArtifact } from "@openclawbrain/contracts";
 import { buildNormalizedEventDedupId, buildNormalizedEventExport, buildNormalizedEventExportBridge, createDefaultLearningSurface, createEventExportCursor, createExplicitEventRange, validateNormalizedEventExport, validateNormalizedEventExportBridge, validateNormalizedEventExportSlice } from "@openclawbrain/event-export";
-import { computePayloadChecksum, loadPack, PACK_LAYOUT, summarizeStructuralGraphEvolution, writePackFile } from "@openclawbrain/pack-format";
+import { computePayloadChecksum, loadPack, loadPackFromActivation, PACK_LAYOUT, summarizeStructuralGraphEvolution, writePackFile } from "@openclawbrain/pack-format";
 import { buildArtifactProvenance } from "@openclawbrain/provenance";
 import { createWorkspaceMetadata } from "@openclawbrain/workspace-metadata";
+import { createServeTimeDecisionMatcher } from "./teacher-decision-match.js";
 export const DEFAULT_ALWAYS_ON_LEARNING_LIVE_SLICES_PER_CYCLE = 1;
 export const DEFAULT_ALWAYS_ON_LEARNING_BACKFILL_SLICES_PER_CYCLE = 1;
 export const DEFAULT_TEACHER_SUPERVISION_STALE_AFTER_MS = 5 * 60 * 1_000;
@@ -26,6 +27,7 @@ export const ALWAYS_ON_STRUCTURAL_PLASTICITY_OP_CEILING = {
 export const ALWAYS_ON_STRUCTURAL_PLASTICITY_MIN_INTERACTIONS = 2;
 export const ALWAYS_ON_STRUCTURAL_PLASTICITY_MIN_FEEDBACK = 1;
 const CONNECT_PAIR_SCORE_THRESHOLD = 2;
+const MAX_CARRY_FORWARD_SEED_BLOCKS = 12;
 export const DEFAULT_SPARSE_FEEDBACK_POLICY = {
     teacherBudget: 32,
     teacherDelayMs: 0,
@@ -4054,15 +4056,36 @@ function normalizeOutcomeMatchText(value) {
         ? value.replace(/\s+/g, " ").trim().toLowerCase()
         : null;
 }
+function normalizeObservationOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function buildObservationSelectionDigestKey(selectionDigest, activePackGraphChecksum) {
+    const normalizedSelectionDigest = normalizeObservationOptionalString(selectionDigest);
+    const normalizedGraphChecksum = normalizeObservationOptionalString(activePackGraphChecksum);
+    if (normalizedSelectionDigest === null || normalizedGraphChecksum === null) {
+        return null;
+    }
+    return `${normalizedGraphChecksum}|${normalizedSelectionDigest}`;
+}
 function parseObservationRouteMetadata(value) {
     if (typeof value !== "string" || value.trim().length === 0) {
         return {
+            serveDecisionRecordId: null,
+            selectionDigest: null,
+            turnCompileEventId: null,
+            activePackId: null,
+            activePackGraphChecksum: null,
             selectedNodeIds: [],
             selectedPathNodeIds: []
         };
     }
     try {
         const parsed = JSON.parse(value);
+        const serveDecisionRecordId = normalizeObservationOptionalString(parsed?.serveDecisionRecordId);
+        const selectionDigest = normalizeObservationOptionalString(parsed?.selectionDigest);
+        const turnCompileEventId = normalizeObservationOptionalString(parsed?.turnCompileEventId);
+        const activePackId = normalizeObservationOptionalString(parsed?.activePackId);
+        const activePackGraphChecksum = normalizeObservationOptionalString(parsed?.activePackGraphChecksum);
         const selectedNodeIds = Array.isArray(parsed?.selectedNodeIds)
             ? parsed.selectedNodeIds.filter((entry) => typeof entry === "string")
             : [];
@@ -4070,12 +4093,22 @@ function parseObservationRouteMetadata(value) {
             ? parsed.selectedPathNodeIds.filter((entry) => typeof entry === "string")
             : [];
         return {
+            serveDecisionRecordId,
+            selectionDigest,
+            turnCompileEventId,
+            activePackId,
+            activePackGraphChecksum,
             selectedNodeIds,
             selectedPathNodeIds
         };
     }
     catch {
         return {
+            serveDecisionRecordId: null,
+            selectionDigest: null,
+            turnCompileEventId: null,
+            activePackId: null,
+            activePackGraphChecksum: null,
             selectedNodeIds: [],
             selectedPathNodeIds: []
         };
@@ -4099,8 +4132,24 @@ function loadTeacherObservationOutcomesFromActivation(activationRoot) {
         if (table === undefined) {
             return [];
         }
+        const columns = new Set(db.prepare("PRAGMA table_info(brain_observations)").all().map((column) => String(column.name ?? "")));
+        const selectableColumns = [
+            "id",
+            "query_text",
+            "route_metadata_json",
+            "final_score",
+            "confidence",
+            "created_at",
+            "updated_at",
+            "evaluated_at",
+            columns.has("serve_decision_record_id") ? "serve_decision_record_id" : "NULL AS serve_decision_record_id",
+            columns.has("selection_digest") ? "selection_digest" : "NULL AS selection_digest",
+            columns.has("turn_compile_event_id") ? "turn_compile_event_id" : "NULL AS turn_compile_event_id",
+            columns.has("active_pack_id") ? "active_pack_id" : "NULL AS active_pack_id",
+            columns.has("active_pack_graph_checksum") ? "active_pack_graph_checksum" : "NULL AS active_pack_graph_checksum"
+        ];
         const rows = db.prepare(`
-      SELECT id, query_text, route_metadata_json, final_score, confidence, created_at, updated_at, evaluated_at
+      SELECT ${selectableColumns.join(", ")}
       FROM brain_observations
       WHERE final_score IS NOT NULL
       ORDER BY created_at DESC
@@ -4116,6 +4165,11 @@ function loadTeacherObservationOutcomesFromActivation(activationRoot) {
                 createdAt: Number.isFinite(Number(row.created_at)) ? Number(row.created_at) : null,
                 updatedAt: Number.isFinite(Number(row.updated_at)) ? Number(row.updated_at) : null,
                 evaluatedAt: Number.isFinite(Number(row.evaluated_at)) ? Number(row.evaluated_at) : null,
+                serveDecisionRecordId: normalizeObservationOptionalString(row.serve_decision_record_id) ?? routeMetadata.serveDecisionRecordId,
+                selectionDigest: normalizeObservationOptionalString(row.selection_digest) ?? routeMetadata.selectionDigest,
+                turnCompileEventId: normalizeObservationOptionalString(row.turn_compile_event_id) ?? routeMetadata.turnCompileEventId,
+                activePackId: normalizeObservationOptionalString(row.active_pack_id) ?? routeMetadata.activePackId,
+                activePackGraphChecksum: normalizeObservationOptionalString(row.active_pack_graph_checksum) ?? routeMetadata.activePackGraphChecksum,
                 selectedNodeIds: routeMetadata.selectedNodeIds,
                 selectedPathNodeIds: routeMetadata.selectedPathNodeIds
             };
@@ -4197,45 +4251,186 @@ function compareDecisionObservationMatch(left, right) {
     }
     return 0;
 }
+function emptyTeacherObservationBindingStats() {
+    return {
+        totalObservationCount: 0,
+        nonZeroObservationCount: 0,
+        skippedZeroRewardCount: 0,
+        accounting: {
+            exact: 0,
+            heuristic: 0,
+            unmatched: 0,
+            ambiguous: 0
+        },
+        matched: {
+            exactDecisionId: 0,
+            exactSelectionDigest: 0,
+            turnCompileEventId: 0,
+            legacyHeuristic: 0
+        },
+        unmatched: {
+            exactDecisionId: 0,
+            exactSelectionDigest: 0,
+            turnCompileEventId: 0,
+            legacyHeuristic: 0
+        },
+        ambiguous: {
+            exactDecisionId: 0,
+            exactSelectionDigest: 0,
+            turnCompileEventId: 0,
+            legacyHeuristic: 0
+        }
+    };
+}
+function summarizeTeacherObservationBindingStats(stats) {
+    return [
+        `accounting(exact=${stats.accounting.exact},heuristic=${stats.accounting.heuristic},unmatched=${stats.accounting.unmatched},ambiguous=${stats.accounting.ambiguous})`,
+        `matched(exact_decision_id=${stats.matched.exactDecisionId},exact_selection_digest=${stats.matched.exactSelectionDigest},turn_compile_event_id=${stats.matched.turnCompileEventId},legacy_heuristic=${stats.matched.legacyHeuristic})`,
+        `unmatched(exact_decision_id=${stats.unmatched.exactDecisionId},exact_selection_digest=${stats.unmatched.exactSelectionDigest},turn_compile_event_id=${stats.unmatched.turnCompileEventId},legacy_heuristic=${stats.unmatched.legacyHeuristic})`,
+        `ambiguous(exact_decision_id=${stats.ambiguous.exactDecisionId},exact_selection_digest=${stats.ambiguous.exactSelectionDigest},turn_compile_event_id=${stats.ambiguous.turnCompileEventId},legacy_heuristic=${stats.ambiguous.legacyHeuristic})`,
+        `non_zero=${stats.nonZeroObservationCount}`,
+        `skipped_zero=${stats.skippedZeroRewardCount}`
+    ].join(" ");
+}
+function buildTeacherObservationDecisionIndexes(decisions) {
+    const byRecordId = new Map();
+    const bySelectionDigest = new Map();
+    const ambiguousSelectionDigests = new Set();
+    const byTurnCompileEventId = new Map();
+    const ambiguousTurnCompileEventIds = new Set();
+    for (const decision of decisions) {
+        byRecordId.set(decision.recordId, decision);
+        const selectionDigestKey = buildObservationSelectionDigestKey(decision.selectionDigest, decision.activePackGraphChecksum);
+        if (selectionDigestKey !== null) {
+            if (bySelectionDigest.has(selectionDigestKey)) {
+                bySelectionDigest.delete(selectionDigestKey);
+                ambiguousSelectionDigests.add(selectionDigestKey);
+            }
+            else if (!ambiguousSelectionDigests.has(selectionDigestKey)) {
+                bySelectionDigest.set(selectionDigestKey, decision);
+            }
+        }
+        const turnCompileEventId = normalizeObservationOptionalString(decision.turnCompileEventId);
+        if (turnCompileEventId !== null) {
+            if (byTurnCompileEventId.has(turnCompileEventId)) {
+                byTurnCompileEventId.delete(turnCompileEventId);
+                ambiguousTurnCompileEventIds.add(turnCompileEventId);
+            }
+            else if (!ambiguousTurnCompileEventIds.has(turnCompileEventId)) {
+                byTurnCompileEventId.set(turnCompileEventId, decision);
+            }
+        }
+    }
+    return {
+        byRecordId,
+        bySelectionDigest,
+        ambiguousSelectionDigests,
+        byTurnCompileEventId,
+        ambiguousTurnCompileEventIds
+    };
+}
+function resolveLegacyTeacherObservationMatch(decisions, observation) {
+    const matches = decisions
+        .map((decision) => {
+        const key = decisionObservationMatchKey(decision, observation);
+        return key === null
+            ? null
+            : {
+                decision,
+                key
+            };
+    })
+        .filter((entry) => entry !== null)
+        .sort((left, right) => compareDecisionObservationMatch(left.key, right.key));
+    const best = matches[0] ?? null;
+    const runnerUp = matches[1] ?? null;
+    if (best === null) {
+        return { kind: "unmatched", mode: "legacyHeuristic" };
+    }
+    if (runnerUp !== null && compareDecisionObservationMatch(best.key, runnerUp.key) === 0) {
+        return { kind: "ambiguous", mode: "legacyHeuristic" };
+    }
+    return {
+        kind: "matched",
+        mode: "legacyHeuristic",
+        decision: best.decision
+    };
+}
+function resolveTeacherObservationDecisionMatch(decisions, observation, indexes) {
+    const serveDecisionRecordId = normalizeObservationOptionalString(observation.serveDecisionRecordId);
+    if (serveDecisionRecordId !== null) {
+        const decision = indexes.byRecordId.get(serveDecisionRecordId) ?? null;
+        return decision === null
+            ? { kind: "unmatched", mode: "exactDecisionId" }
+            : { kind: "matched", mode: "exactDecisionId", decision };
+    }
+    const selectionDigestKey = buildObservationSelectionDigestKey(observation.selectionDigest, observation.activePackGraphChecksum);
+    if (selectionDigestKey !== null) {
+        if (indexes.ambiguousSelectionDigests.has(selectionDigestKey)) {
+            return { kind: "ambiguous", mode: "exactSelectionDigest" };
+        }
+        const decision = indexes.bySelectionDigest.get(selectionDigestKey) ?? null;
+        return decision === null
+            ? { kind: "unmatched", mode: "exactSelectionDigest" }
+            : { kind: "matched", mode: "exactSelectionDigest", decision };
+    }
+    if (normalizeObservationOptionalString(observation.selectionDigest) !== null) {
+        return { kind: "unmatched", mode: "exactSelectionDigest" };
+    }
+    const turnCompileEventId = normalizeObservationOptionalString(observation.turnCompileEventId);
+    if (turnCompileEventId !== null) {
+        if (indexes.ambiguousTurnCompileEventIds.has(turnCompileEventId)) {
+            return { kind: "ambiguous", mode: "turnCompileEventId" };
+        }
+        const decision = indexes.byTurnCompileEventId.get(turnCompileEventId) ?? null;
+        return decision === null
+            ? { kind: "unmatched", mode: "turnCompileEventId" }
+            : { kind: "matched", mode: "turnCompileEventId", decision };
+    }
+    return resolveLegacyTeacherObservationMatch(decisions, observation);
+}
 function joinDecisionsWithTeacherObservationOutcomes(decisions, observationOutcomes) {
     const outcomes = new Map();
+    const stats = emptyTeacherObservationBindingStats();
     for (const decision of decisions) {
         outcomes.set(decision.recordId, 0);
     }
     if (!Array.isArray(observationOutcomes) || observationOutcomes.length === 0) {
-        return outcomes;
+        return { outcomes, stats };
     }
+    const indexes = buildTeacherObservationDecisionIndexes(decisions);
+    stats.totalObservationCount = observationOutcomes.length;
     for (const observation of observationOutcomes) {
-        const matches = decisions
-            .map((decision) => {
-            const key = decisionObservationMatchKey(decision, observation);
-            return key === null
-                ? null
-                : {
-                    decision,
-                    key
-                };
-        })
-            .filter((entry) => entry !== null)
-            .sort((left, right) => compareDecisionObservationMatch(left.key, right.key));
-        const best = matches[0] ?? null;
-        const runnerUp = matches[1] ?? null;
-        if (best === null) {
+        const reward = clampTeacherObservationOutcome(observation.finalScore);
+        if (reward === 0) {
+            stats.skippedZeroRewardCount += 1;
             continue;
         }
-        if (runnerUp !== null && compareDecisionObservationMatch(best.key, runnerUp.key) === 0) {
+        stats.nonZeroObservationCount += 1;
+        const match = resolveTeacherObservationDecisionMatch(decisions, observation, indexes);
+        if (match.kind === "unmatched") {
+            stats.accounting.unmatched += 1;
+            stats.unmatched[match.mode] += 1;
             continue;
         }
-        const reward = clampTeacherObservationOutcome(observation.finalScore);
-        if (reward === 0) {
+        if (match.kind === "ambiguous") {
+            stats.accounting.ambiguous += 1;
+            stats.ambiguous[match.mode] += 1;
             continue;
         }
-        const current = outcomes.get(best.decision.recordId) ?? 0;
+        if (match.mode === "legacyHeuristic") {
+            stats.accounting.heuristic += 1;
+        }
+        else {
+            stats.accounting.exact += 1;
+        }
+        stats.matched[match.mode] += 1;
+        const current = outcomes.get(match.decision.recordId) ?? 0;
         if (current === 0 || Math.abs(reward) > Math.abs(current)) {
-            outcomes.set(best.decision.recordId, reward);
+            outcomes.set(match.decision.recordId, reward);
         }
     }
-    return outcomes;
+    return { outcomes, stats };
 }
 
 export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 300_000) {
@@ -4247,149 +4442,7 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
         return outcomes;
     }
     const normalizeOptionalString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-    const toTimestamp = (value) => {
-        const normalized = normalizeOptionalString(value);
-        if (normalized === undefined) {
-            return null;
-        }
-        const parsed = Date.parse(normalized);
-        return Number.isFinite(parsed) ? parsed : null;
-    };
-    const buildSessionChannelKey = (sessionId, channel) => {
-        const normalizedSessionId = normalizeOptionalString(sessionId);
-        const normalizedChannel = normalizeOptionalString(channel);
-        if (normalizedSessionId === undefined || normalizedChannel === undefined) {
-            return null;
-        }
-        return `${normalizedSessionId}|${normalizedChannel}`;
-    };
-    const buildCandidateKey = (sessionId, channel, createdAt) => {
-        const sessionChannelKey = buildSessionChannelKey(sessionId, channel);
-        const normalizedCreatedAt = normalizeOptionalString(createdAt);
-        if (sessionChannelKey === null || normalizedCreatedAt === undefined) {
-            return null;
-        }
-        return `${sessionChannelKey}|${normalizedCreatedAt}`;
-    };
-    const buildDecisionTimestamps = (decision) => {
-        const timestamps = [];
-        const turnCreatedAt = toTimestamp(decision.turnCreatedAt);
-        const recordedAt = toTimestamp(decision.recordedAt);
-        if (turnCreatedAt !== null) {
-            timestamps.push(turnCreatedAt);
-        }
-        if (recordedAt !== null && !timestamps.includes(recordedAt)) {
-            timestamps.push(recordedAt);
-        }
-        return timestamps;
-    };
-    const operationalPatterns = [
-        /^NO_REPLY$/i,
-        /^HEARTBEAT_OK$/i,
-        /^read heartbeat\.md if it exists/i,
-        /^a new session was started via \/new or \/reset\./i,
-        /\[cron:[a-f0-9-]+\s/i,
-        /\[system message\]\s*\[sessionid:/i,
-    ];
-    const isOperationalDecision = (decision) => {
-        const userMessage = normalizeOptionalString(decision.userMessage);
-        if (userMessage === undefined) {
-            return true;
-        }
-        return operationalPatterns.some((pattern) => pattern.test(userMessage));
-    };
-    const selectNearestDecision = (entries, interactionAt) => {
-        const candidates = entries
-            .map((entry) => {
-                const deltas = entry.timestamps.map((timestamp) => Math.abs(timestamp - interactionAt));
-                const bestDelta = deltas.length === 0 ? null : Math.min(...deltas);
-                return bestDelta === null || bestDelta > maxDelayMs
-                    ? null
-                    : {
-                        decision: entry.decision,
-                        deltaMs: bestDelta,
-                        recordedAt: toTimestamp(entry.decision.recordedAt) ?? 0,
-                    };
-            })
-            .filter((entry) => entry !== null)
-            .sort((left, right) => {
-                if (left.deltaMs !== right.deltaMs) {
-                    return left.deltaMs - right.deltaMs;
-                }
-                return right.recordedAt - left.recordedAt;
-            });
-        const best = candidates[0] ?? null;
-        const runnerUp = candidates[1] ?? null;
-        if (best === null) {
-            return null;
-        }
-        if (runnerUp !== null && runnerUp.deltaMs === best.deltaMs && runnerUp.decision !== best.decision) {
-            return null;
-        }
-        return best.decision;
-    };
-    const exactDecisions = new Map();
-    const fallbackDecisions = new Map();
-    const decisionsBySessionChannel = new Map();
-    const globalFallbackDecisions = [];
-    for (const decision of [...decisions].sort((left, right) => Date.parse(right.recordedAt) - Date.parse(left.recordedAt))) {
-        const userMessage = normalizeOptionalString(decision.userMessage);
-        if (userMessage === undefined) {
-            continue;
-        }
-        const turnCompileEventId = normalizeOptionalString(decision.turnCompileEventId);
-        if (turnCompileEventId !== undefined && !exactDecisions.has(turnCompileEventId)) {
-            exactDecisions.set(turnCompileEventId, decision);
-        }
-        for (const candidateKey of [
-            buildCandidateKey(decision.sessionId, decision.channel, decision.turnCreatedAt),
-            buildCandidateKey(decision.sessionId, decision.channel, decision.recordedAt),
-        ]) {
-            if (candidateKey !== null && !fallbackDecisions.has(candidateKey)) {
-                fallbackDecisions.set(candidateKey, decision);
-            }
-        }
-        const sessionChannelKey = buildSessionChannelKey(decision.sessionId, decision.channel);
-        const indexedEntry = {
-            decision,
-            timestamps: buildDecisionTimestamps(decision),
-            operational: isOperationalDecision(decision),
-        };
-        if (sessionChannelKey !== null) {
-            const indexed = decisionsBySessionChannel.get(sessionChannelKey) ?? [];
-            indexed.push(indexedEntry);
-            decisionsBySessionChannel.set(sessionChannelKey, indexed);
-        }
-        if (!indexedEntry.operational) {
-            globalFallbackDecisions.push(indexedEntry);
-        }
-    }
-    const matchInteractionToDecision = (interaction) => {
-        const exact = exactDecisions.get(interaction.eventId);
-        if (exact !== undefined) {
-            return exact;
-        }
-        const exactFallbackKey = buildCandidateKey(interaction.sessionId, interaction.channel, interaction.createdAt);
-        if (exactFallbackKey !== null) {
-            const fallback = fallbackDecisions.get(exactFallbackKey);
-            if (fallback !== undefined) {
-                return fallback;
-            }
-        }
-        const interactionAt = toTimestamp(interaction.createdAt);
-        const sessionChannelKey = buildSessionChannelKey(interaction.sessionId, interaction.channel);
-        if (interactionAt === null) {
-            return null;
-        }
-        if (sessionChannelKey !== null) {
-            const sessionEntries = (decisionsBySessionChannel.get(sessionChannelKey) ?? []).filter((entry) => entry.operational !== true);
-            const sessionMatch = selectNearestDecision(sessionEntries, interactionAt);
-            if (sessionMatch !== null) {
-                return sessionMatch;
-            }
-        }
-        return selectNearestDecision(globalFallbackDecisions, interactionAt);
-    };
+    const matchInteractionToDecision = createServeTimeDecisionMatcher(decisions, { maxTimeDeltaMs: maxDelayMs });
     const interactionById = new Map();
     for (const interaction of eventExport.interactionEvents ?? []) {
         const interactionId = normalizeOptionalString(interaction.eventId);
@@ -4397,7 +4450,7 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
             interactionById.set(interactionId, interaction);
         }
     }
-    const matchedFeedbackIds = new Set();
+    const consumedFeedbackIds = new Set();
     for (const event of eventExport.feedbackEvents ?? []) {
         const relatedInteractionId = normalizeOptionalString(event.relatedInteractionId);
         if (relatedInteractionId === undefined) {
@@ -4407,6 +4460,8 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
         if (interaction === undefined) {
             continue;
         }
+        const feedbackId = normalizeOptionalString(event.eventId) ?? `${relatedInteractionId}|${normalizeOptionalString(event.createdAt) ?? 'unknown'}`;
+        consumedFeedbackIds.add(feedbackId);
         const matchedDecision = matchInteractionToDecision(interaction);
         if (matchedDecision === null) {
             continue;
@@ -4418,13 +4473,11 @@ export function joinDecisionsWithFeedback(decisions, eventExport, maxDelayMs = 3
                 outcomes.set(matchedDecision.recordId, reward);
             }
         }
-        const feedbackId = normalizeOptionalString(event.eventId) ?? `${relatedInteractionId}|${normalizeOptionalString(event.createdAt) ?? 'unknown'}`;
-        matchedFeedbackIds.add(feedbackId);
     }
     const feedbackBySession = new Map();
     for (const event of eventExport.feedbackEvents ?? []) {
         const feedbackId = normalizeOptionalString(event.eventId) ?? `${normalizeOptionalString(event.relatedInteractionId) ?? '__none__'}|${normalizeOptionalString(event.createdAt) ?? 'unknown'}`;
-        if (matchedFeedbackIds.has(feedbackId)) {
+        if (consumedFeedbackIds.has(feedbackId)) {
             continue;
         }
         const sessionId = event.sessionId ?? "__none__";
@@ -4627,8 +4680,8 @@ function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, se
     const remappedServeTimeDecisions = serveTimeDecisions.map((decision) => remapServeTimeDecisionToGraph(decision, resolveBlockId));
     // 2. Join serve-time decisions with explicit feedback first, then let teacher-v2 observations override when available.
     const outcomeMap = joinDecisionsWithFeedback(remappedServeTimeDecisions, eventExport);
-    const teacherObservationOutcomeMap = joinDecisionsWithTeacherObservationOutcomes(remappedServeTimeDecisions, teacherObservationOutcomes);
-    for (const [decisionId, reward] of teacherObservationOutcomeMap.entries()) {
+    const teacherObservationBindings = joinDecisionsWithTeacherObservationOutcomes(remappedServeTimeDecisions, teacherObservationOutcomes);
+    for (const [decisionId, reward] of teacherObservationBindings.outcomes.entries()) {
         if (reward !== 0) {
             outcomeMap.set(decisionId, reward);
         }
@@ -4695,7 +4748,8 @@ function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, se
         if (fallback.policyUpdates.length > 0) {
             return {
                 artifact: fallback,
-                updatedBaseline: currentBaseline
+                updatedBaseline: currentBaseline,
+                observationBindingStats: teacherObservationBindings.stats
             };
         }
     }
@@ -4717,7 +4771,7 @@ function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, se
         : remappedServeTimeDecisions.length === 0
             ? "no serve-time decisions supplied for V2 learned routing refresh"
             : supervisedTrajectoryCount === 0
-                ? "no outcomes found for serve-time decisions"
+                ? `no outcomes found for serve-time decisions (${summarizeTeacherObservationBindingStats(teacherObservationBindings.stats)})`
                 : "trajectory updates produced no learned routing delta";
     const artifact = {
         routerIdentity: `${packId}:route_fn`,
@@ -4765,7 +4819,11 @@ function createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, se
         traces,
         policyUpdates
     };
-    return { artifact, updatedBaseline: currentBaseline };
+    return {
+        artifact,
+        updatedBaseline: currentBaseline,
+        observationBindingStats: teacherObservationBindings.stats
+    };
 }
 function resolveEventExport(input) {
     if (input.eventExports === undefined) {
@@ -4788,6 +4846,55 @@ function defaultLearningSurface(workspace, offlineArtifacts, workspaceInit) {
         ...offlineArtifacts.map((artifact) => `offline:${artifact}`)
     ]));
 }
+function isCarryForwardSeedBlock(block) {
+    const role = block.learning?.role ?? "";
+    if (role !== "interaction" && role !== "feedback" && role !== "teacher_supervision" && role !== "label_surface") {
+        return false;
+    }
+    if (typeof block.text !== "string" || block.text.trim().length === 0) {
+        return false;
+    }
+    return block.initSeed !== undefined ||
+        block.semantic?.sourceKind === "recorded_session_seed" ||
+        block.source.includes("/seed:");
+}
+function carryForwardSeedBlockScore(block) {
+    return (block.initSeed?.score ?? 0) +
+        (block.state?.strength ?? 0) +
+        (block.learning?.humanLabels ?? 0) * 2 +
+        (block.learning?.selfLabels ?? 0);
+}
+function loadCarryForwardSeedBlocksFromActivation(activationRoot, currentGraphBlockIds) {
+    try {
+        const activePack = loadPackFromActivation(activationRoot, "active", { requireActivationReady: true });
+        if (activePack === null) {
+            return [];
+        }
+        const candidates = activePack.graph.blocks
+            .filter((block) => isCarryForwardSeedBlock(block) && !currentGraphBlockIds.has(block.id));
+        const preferred = candidates.filter((block) => block.learning?.role !== "interaction");
+        const selected = (preferred.length > 0 ? preferred : candidates)
+            .sort((left, right) => carryForwardSeedBlockScore(right) - carryForwardSeedBlockScore(left) ||
+            right.priority - left.priority ||
+            left.id.localeCompare(right.id))
+            .slice(0, MAX_CARRY_FORWARD_SEED_BLOCKS);
+        if (selected.length === 0) {
+            return [];
+        }
+        const selectedIds = new Set(selected.map((block) => block.id));
+        return selected.map((block) => ({
+            ...structuredClone(block),
+            ...(block.edges === undefined
+                ? {}
+                : {
+                    edges: block.edges.filter((edge) => selectedIds.has(edge.targetBlockId))
+                })
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 function cloneRuntimeGraphForPack(packId, runtimeGraph, builtAt) {
     const cloned = structuredClone(runtimeGraph);
     cloned.packId = packId;
@@ -4861,9 +4968,18 @@ function buildRuntimeGraphSnapshot(input) {
         rootDir: workspace.rootDir,
         observedAt: builtAt
     }));
+    const carryForwardSeedBlocks = input.activationRoot === undefined
+        ? []
+        : loadCarryForwardSeedBlocksFromActivation(input.activationRoot, new Set(graph.blocks.map((block) => block.id)));
+    const graphWithCarryForwardSeed = carryForwardSeedBlocks.length === 0
+        ? graph
+        : {
+            ...graph,
+            blocks: [...graph.blocks, ...carryForwardSeedBlocks]
+        };
     return {
-        graph,
-        plasticity: summarizeRuntimeGraphPlasticity("live_loop", graph, builtAt, null, normalizedEventExport)
+        graph: graphWithCarryForwardSeed,
+        plasticity: summarizeRuntimeGraphPlasticity("live_loop", graphWithCarryForwardSeed, builtAt, null, normalizedEventExport)
     };
 }
 export function buildCandidatePack(input) {
@@ -4922,6 +5038,7 @@ export function buildCandidatePack(input) {
     const vectors = createVectorsPayload(graph);
     let router = null;
     let updatedBaseline = null;
+    let observationBindingStats = null;
     const teacherObservationOutcomes = input.activationRoot === undefined
         ? []
         : loadTeacherObservationOutcomesFromActivation(input.activationRoot);
@@ -4930,6 +5047,7 @@ export function buildCandidatePack(input) {
             const v2Result = createRouterArtifactV2(packId, builtAt, graph, vectors, eventExport, input.serveTimeDecisions, input.baselineState ?? initBaseline(), input.sparseFeedback, input.principalBacklog, teacherObservationOutcomes);
             router = v2Result.artifact;
             updatedBaseline = v2Result.updatedBaseline;
+            observationBindingStats = v2Result.observationBindingStats;
         }
         else {
             router = createRouterArtifact(packId, builtAt, graph, vectors, eventExport, input.sparseFeedback, input.principalBacklog);
@@ -5045,7 +5163,8 @@ export function buildCandidatePack(input) {
             pgVersionUsed: input.learnedRouting ? (useV2 ? "v2" : "v1") : null,
             decisionLogCount,
             fallbackReason,
-            updatedBaseline
+            updatedBaseline,
+            observationBindingStats
         },
         summary: {
             packId,