@matthewfl/pi-contemplator 0.0.10 → 0.1.1

package/src/tools/search-memories.ts

@@ -2,16 +2,13 @@ import { Type } from "@earendil-works/pi-ai";
 import type { AgentTool } from "@earendil-works/pi-agent-core";
 import type { Static } from "typebox";
 import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import {
-	searchMemories,
-	type MemorySearchResult,
-} from "../session-ledger/search.js";
-import type { Entry } from "../session-ledger/index.js";
 import { Text } from "@earendil-works/pi-tui";
+import { searchMemories, type MemorySearchResult, type SearchMemoriesOptions } from "../session-ledger/search.js";
+import type { Entry } from "../session-ledger/index.js";
 
 export const SEARCH_MEMORIES_TOOL_NAME = "search_memories";
 export const SEARCH_MEMORIES_DESCRIPTION =
-	"Search recorded observational-memory observations, reflections, and advisory review results by topic or keywords on the current branch. Use the returned memory id with recall to recover exact source context or a full advisory proposal.";
+	"Search recorded observations, cited summaries, and advisory review results by topic or keywords. Use recall with a result id to inspect exact evidence or walk summary citations.";
 
 export type SearchMemoriesArgs = Static<typeof SEARCH_MEMORIES_PARAMETERS>;
 
@@ -19,7 +16,7 @@ export type SearchDetails = {
 	query: string;
 	limit: number;
 	observationsSearched: number;
-	reflectionsSearched: number;
+	summariesSearched: number;
 	reviewsSearched: number;
 	results: MemorySearchResult[];
 };
@@ -29,101 +26,63 @@ function formatResult(result: MemorySearchResult): string {
 		const label = result.outcome === "proposal"
 			? `${result.scope} proposal${result.title ? ` — ${result.title}` : ""}`
 			: `${result.scope} review concluded with no proposal`;
-		return `- [${result.id}] ${label}: ${result.content}`;
+		const forward = result.citedBySummaryIds?.length ? `\n  cited by summaries: [${result.citedBySummaryIds.join(", ")}]` : "";
+		return `- [${result.id}] ${label}: ${result.content}${forward}`;
 	}
-	const status = result.status === "dropped" ? " [dropped]" : "";
+	const visibility = result.visibility === "summarized" ? " [summarized away]" : " [visible]";
 	const relevance = result.relevance ? ` [${result.relevance}]` : "";
+	const retention = result.retention ? ` [${result.retention}]` : "";
 	const timestamp = result.timestamp ? ` ${result.timestamp}` : "";
-	return `- ${result.kind} [${result.id}]${status}${timestamp}${relevance}: ${result.content}`;
+	const graph = [
+		result.consumedBySummaryId ? `consumed by [${result.consumedBySummaryId}]` : undefined,
+		result.citedBySummaryIds?.length ? `cited by [${result.citedBySummaryIds.join(", ")}]` : undefined,
+	].filter(Boolean).join("; ");
+	return `- ${result.kind} [${result.id}]${visibility}${timestamp}${relevance}${retention}: ${result.content}${graph ? `\n  ${graph}` : ""}`;
 }
 
 export const SEARCH_MEMORIES_PARAMETERS = Type.Object({
-	query: Type.String({
-		description: "Topic, phrase, or distinctive keywords to search for.",
-	}),
-	limit: Type.Optional(
-		Type.Integer({
-			minimum: 1,
-			maximum: 20,
-			description: "Maximum results to return (default 8).",
-		}),
-	),
+	query: Type.String({ description: "Topic, phrase, or distinctive keywords to search for." }),
+	limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Maximum results to return (default 8)." })),
 });
 
-export function executeSearchMemories(branchEntries: Entry[], params: SearchMemoriesArgs): { content: [{ type: "text"; text: string }]; details: SearchDetails } {
+export function executeSearchMemories(branchEntries: Entry[], params: SearchMemoriesArgs, options: SearchMemoriesOptions = {}): { content: [{ type: "text"; text: string }]; details: SearchDetails } {
 	const query = params.query.trim();
 	const limit = params.limit ?? 8;
 	if (!query) {
-		const details: SearchDetails = {
-			query,
-			limit,
-			observationsSearched: 0,
-			reflectionsSearched: 0,
-			reviewsSearched: 0,
-			results: [],
-		};
+		const details: SearchDetails = { query, limit, observationsSearched: 0, summariesSearched: 0, reviewsSearched: 0, results: [] };
 		return { content: [{ type: "text", text: "Search query must not be empty." }], details };
 	}
-
-	const search = searchMemories(branchEntries, query, limit);
+	const search = searchMemories(branchEntries, query, limit, options);
 	const details: SearchDetails = { ...search, limit };
+	const counts = `${search.observationsSearched} observations, ${search.summariesSearched} summaries, and ${search.reviewsSearched} review results`;
 	const text = search.results.length
-		? [
-				`Found ${search.results.length} matching memories (searched ${search.observationsSearched} observations, ${search.reflectionsSearched} reflections, and ${search.reviewsSearched} review results):`,
-				...search.results.map(formatResult),
-				"Use recall(<id>) for exact source context.",
-			].join("\n")
-		: `No memories matched ${JSON.stringify(query)} (searched ${search.observationsSearched} observations, ${search.reflectionsSearched} reflections, and ${search.reviewsSearched} review results). Try alternate or more distinctive keywords.`;
+		? [`Found ${search.results.length} matching memories (searched ${counts}):`, ...search.results.map(formatResult), "Use recall(<id>) for exact content and immediate graph links."].join("\n")
+		: `No memories matched ${JSON.stringify(query)} (searched ${counts}). Try alternate or more distinctive keywords.`;
 	return { content: [{ type: "text", text }], details };
 }
 
-export function createSearchMemoriesAgentTool(getBranch: () => Entry[]): AgentTool<typeof SEARCH_MEMORIES_PARAMETERS> {
-	return {
-		name: SEARCH_MEMORIES_TOOL_NAME,
-		label: "Search memories",
-		description: SEARCH_MEMORIES_DESCRIPTION,
-		parameters: SEARCH_MEMORIES_PARAMETERS,
-		execute: async (_toolCallId, params) => executeSearchMemories(getBranch(), params),
-	};
+export function createSearchMemoriesAgentTool(getBranch: () => Entry[], options: SearchMemoriesOptions = {}): AgentTool<typeof SEARCH_MEMORIES_PARAMETERS> {
+	return { name: SEARCH_MEMORIES_TOOL_NAME, label: "Search memories", description: SEARCH_MEMORIES_DESCRIPTION, parameters: SEARCH_MEMORIES_PARAMETERS, execute: async (_id, params) => executeSearchMemories(getBranch(), params, options) };
 }
 
 export const searchMemoriesTool = defineTool({
 	name: SEARCH_MEMORIES_TOOL_NAME,
 	label: "Search observational memories",
 	description: SEARCH_MEMORIES_DESCRIPTION,
-	promptSnippet:
-		"Use search_memories(query) to find relevant older observations or reflections, then use recall(id) when exact source context matters.",
+	promptSnippet: "Use search_memories(query) to find older observations, summaries, or reviews, then use recall(id) when exact context matters.",
 	promptGuidelines: [
-		"Use search_memories when the current context may be missing earlier decisions, constraints, user preferences, completed work, or rationale.",
-		"Search with a few distinctive keywords or a short topic phrase; the search covers both active and dropped observations plus reflections on the current branch.",
-		"After finding a relevant memory, use recall with its exact 12-character id when you need supporting evidence or original source entries.",
-		"Do not assume the absence of results means the fact never occurred; search with alternate wording or narrower keywords.",
+		"Use search_memories when current context may be missing earlier decisions, constraints, preferences, outcomes, or rationale.",
+		"Search with distinctive keywords; visible and summarized-away memories are both searched.",
+		"Use recall with an exact 12-character id to inspect a node and walk its citation links.",
 	],
 	parameters: SEARCH_MEMORIES_PARAMETERS,
-	renderCall(args) {
-		return new Text(`search_memories ${JSON.stringify(args.query)}`, 0, 0);
-	},
+	renderCall(args) { return new Text(`search_memories ${JSON.stringify(args.query)}`, 0, 0); },
 	renderResult(result) {
 		const details = result.details as SearchDetails | undefined;
-		const text = result.content
-			.filter(
-				(part): part is { type: "text"; text: string } =>
-					part.type === "text" && typeof part.text === "string",
-			)
-			.map((part) => part.text)
-			.join("\n");
-		return new Text(
-			text ||
-				(details
-					? `${details.results.length} memory results`
-					: "search_memories"),
-			0,
-			0,
-		);
-	},
-	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-		return executeSearchMemories(ctx.sessionManager.getBranch() as Entry[], params);
+		const text = result.content.filter((part): part is { type: "text"; text: string } => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+		return new Text(text || (details ? `${details.results.length} memory results` : "search_memories"), 0, 0);
 	},
+	async execute(_id, params, _signal, _onUpdate, ctx) { return executeSearchMemories(ctx.sessionManager.getBranch() as Entry[], params); },
 });
 
 export function registerSearchMemoriesTool(pi: ExtensionAPI): void {

package/src/agents/dropper/agent.ts

@@ -1,291 +0,0 @@
-import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentTool } from "@earendil-works/pi-agent-core";
-import type { Message, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
-import { Type } from "@earendil-works/pi-ai";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
-import type { Static } from "typebox";
-import { debugLog } from "../../debug-log.js";
-import { AGENT_LOOP_MAX_TOKENS, boundedMaxTokens } from "../../model-budget.js";
-import { logAgentStreamError } from "../stream-errors.js";
-import { reflectionToSummaryLine, type Observation, type Reflection } from "../../session-ledger/index.js";
-import { DROPPER_SYSTEM } from "./prompts.js";
-import {
-	REFLECTION_COVERAGE_DROP_RANK,
-	coverageTierForObservation,
-	reflectionCoverageMap,
-	summarizeCoverageByRelevance,
-	summarizeCoverageByRelevanceForIds,
-	observationToDropperLine,
-} from "./coverage.js";
-import { observationPoolMetrics } from "./pool.js";
-import type { LlmUsageInput } from "../../runtime.js";
-export {
-	maxDropCountForPool,
-	observationPoolFullness,
-	observationPoolMetrics,
-} from "./pool.js";
-export type { ObservationPoolMetrics } from "./pool.js";
-export {
-	REFLECTION_COVERAGE_TIERS,
-	coverageTierForObservation,
-	emptyCoverageSummaryByRelevance,
-	observationToDropperLine,
-	reflectionCoverageMap,
-	reflectionCoverageTierForCount,
-	reflectionSupportCounts,
-	summarizeCoverageByRelevance,
-	summarizeCoverageByRelevanceForIds,
-	summarizeCoverageTransitionsByRelevance,
-} from "./coverage.js";
-export type { CoverageSummaryByRelevance, CoverageTransitionSummaryByRelevance, ReflectionCoverageTier } from "./coverage.js";
-
-interface RunDropperArgs {
-	model: Model<any>;
-	apiKey: string;
-	headers?: Record<string, string>;
-	reflections: Reflection[];
-	observations: Observation[];
-	targetTokens: number;
-	signal?: AbortSignal;
-	agentLoop?: typeof agentLoop;
-	maxTurns?: number;
-	thinkingLevel?: ModelThinkingLevel;
-	recordUsage?: (usage: LlmUsageInput) => void;
-}
-
-const RELEVANCE_DROP_RANK: Record<Observation["relevance"], number> = {
-	low: 0,
-	medium: 1,
-	high: 2,
-	critical: 3,
-};
-
-const DropObservationsSchema = Type.Object({
-	ids: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
-	reason: Type.Optional(Type.String()),
-});
-
-type DropObservationsArgs = Static<typeof DropObservationsSchema>;
-
-function joinOrEmpty(items: string[]): string {
-	return items.length ? items.join("\n") : "(none yet)";
-}
-
-function relevanceCounts(observations: readonly Observation[]): Record<Observation["relevance"], number> {
-	return observations.reduce<Record<Observation["relevance"], number>>((counts, observation) => {
-		counts[observation.relevance]++;
-		return counts;
-	}, { low: 0, medium: 0, high: 0, critical: 0 });
-}
-
-export function normalizeDropObservationIds(
-	ids: readonly string[] | undefined,
-	observations: readonly Observation[],
-): string[] | undefined {
-	if (!ids || ids.length === 0) return undefined;
-	const allowed = new Map(observations.map((observation) => [observation.id, observation]));
-	const result: string[] = [];
-	const seen = new Set<string>();
-	for (const id of ids) {
-		const observation = allowed.get(id);
-		if (!observation) continue;
-		if (seen.has(id)) continue;
-		seen.add(id);
-		result.push(id);
-	}
-	return result.length > 0 ? result : undefined;
-}
-
-function timestampRank(timestamp: string): number {
-	const parsed = Date.parse(timestamp);
-	return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
-}
-
-export function selectDropCandidates(
-	ids: readonly string[],
-	observations: readonly Observation[],
-	maxDrops: number,
-	reflections: readonly Reflection[] = [],
-): string[] {
-	if (maxDrops <= 0 || ids.length === 0) return [];
-
-	const byId = new Map(observations.map((observation) => [observation.id, observation]));
-	const coverageById = reflectionCoverageMap(observations, reflections);
-	const firstProposalIndex = new Map<string, number>();
-	for (let i = 0; i < ids.length; i++) {
-		const id = ids[i];
-		if (!firstProposalIndex.has(id)) firstProposalIndex.set(id, i);
-	}
-
-	return Array.from(firstProposalIndex.entries())
-		.map(([id, index]) => ({ id, index, observation: byId.get(id) }))
-		.filter((candidate): candidate is { id: string; index: number; observation: Observation } =>
-			candidate.observation !== undefined
-		)
-		.sort((a, b) => {
-			const coverageDelta = REFLECTION_COVERAGE_DROP_RANK[coverageTierForObservation(a.observation, coverageById)]
-				- REFLECTION_COVERAGE_DROP_RANK[coverageTierForObservation(b.observation, coverageById)];
-			const relevanceDelta = RELEVANCE_DROP_RANK[a.observation.relevance] - RELEVANCE_DROP_RANK[b.observation.relevance];
-			const ageDelta = timestampRank(a.observation.timestamp) - timestampRank(b.observation.timestamp);
-			return coverageDelta || relevanceDelta || ageDelta || a.index - b.index;
-		})
-		.slice(0, maxDrops)
-		.map((candidate) => candidate.id);
-}
-
-export async function runDropper(args: RunDropperArgs): Promise<string[] | undefined> {
-	const { model, apiKey, headers, reflections, observations, targetTokens, signal } = args;
-	if (observations.length === 0) return undefined;
-
-	const metrics = observationPoolMetrics(observations, targetTokens);
-	const { observationTokens, fullness, tokensOverTarget, maxDropsAllowed } = metrics;
-	const coverageById = reflectionCoverageMap(observations, reflections);
-	const coverageSummaryByRelevance = summarizeCoverageByRelevance(observations, coverageById);
-	debugLog("dropper.agent_start", {
-		activeObservationCount: observations.length,
-		reflectionCount: reflections.length,
-		observationTokens,
-		targetTokens,
-		tokensOverTarget,
-		fullness,
-		maxDropsAllowed,
-		relevanceCounts: relevanceCounts(observations),
-		coverageSummaryByRelevance,
-	});
-	if (maxDropsAllowed <= 0) {
-		debugLog("dropper.result", {
-			reason: "not_over_target",
-			toolCallCount: 0,
-			rawRequestedIdsCount: 0,
-			acceptedCandidateCount: 0,
-			selectedDropsCount: 0,
-			selectedDropTokens: 0,
-			selectedCoverageSummaryByRelevance: summarizeCoverageByRelevanceForIds([], observations, coverageById),
-			maxDropsAllowed,
-		});
-		return undefined;
-	}
-
-	const proposedDropIds: string[] = [];
-	const proposed = new Set<string>();
-	const allowed = new Map(observations.map((observation) => [observation.id, observation]));
-	let toolCallCount = 0;
-	let rawRequestedIdsCount = 0;
-	let missingIdsCount = 0;
-	let criticalCandidateIdsCount = 0;
-	let duplicateInRequestCount = 0;
-	let duplicateInRunCount = 0;
-
-	const dropObservations: AgentTool<typeof DropObservationsSchema> = {
-		name: "drop_observations",
-		label: "Drop observations",
-		description: "Propose active observation ids that are safe to remove from compacted memory.",
-		parameters: DropObservationsSchema,
-		execute: async (_id, params: DropObservationsArgs) => {
-			toolCallCount++;
-			rawRequestedIdsCount += params.ids.length;
-			const seenInRequest = new Set<string>();
-			let added = 0;
-			let requestMissingIds = 0;
-			let requestCriticalCandidateIds = 0;
-			let requestDuplicateIds = 0;
-			let requestDuplicateInRunIds = 0;
-			for (const id of params.ids) {
-				const observation = allowed.get(id);
-				if (!observation) {
-					missingIdsCount++;
-					requestMissingIds++;
-					continue;
-				}
-				if (seenInRequest.has(id)) {
-					duplicateInRequestCount++;
-					requestDuplicateIds++;
-					continue;
-				}
-				seenInRequest.add(id);
-				if (proposed.has(id)) {
-					duplicateInRunCount++;
-					requestDuplicateInRunIds++;
-					continue;
-				}
-				proposed.add(id);
-				proposedDropIds.push(id);
-				if (observation.relevance === "critical") {
-					criticalCandidateIdsCount++;
-					requestCriticalCandidateIds++;
-				}
-				added++;
-			}
-			debugLog("dropper.tool_call", {
-				toolCallCount,
-				rawRequestedIdsCount: params.ids.length,
-				acceptedIdsCount: added,
-				missingIdsCount: requestMissingIds,
-				criticalCandidateIdsCount: requestCriticalCandidateIds,
-				duplicateInRequestCount: requestDuplicateIds,
-				duplicateInRunCount: requestDuplicateInRunIds,
-				totalCandidates: proposedDropIds.length,
-				maxDropsAllowed,
-			});
-			return {
-				content: [{ type: "text", text: `Queued ${added} drop candidate${added === 1 ? "" : "s"}. Candidates this run: ${proposedDropIds.length}. Maximum drops allowed: ${maxDropsAllowed}.` }],
-				details: { added, totalCandidates: proposedDropIds.length, maxDropsAllowed },
-			};
-		},
-	};
-
-	const fullnessPercent = Math.round(fullness * 100);
-	const userText = `CURRENT REFLECTIONS:\n${joinOrEmpty(reflections.map(reflectionToSummaryLine))}\n\nCURRENT OBSERVATIONS:\n${joinOrEmpty(observations.map((observation) => observationToDropperLine(observation, coverageTierForObservation(observation, coverageById))))}\n\nActive observation pool: ~${observationTokens.toLocaleString()} tokens; target: ~${targetTokens.toLocaleString()} tokens; fullness against target: ~${fullnessPercent.toLocaleString()}%; over target by ~${tokensOverTarget.toLocaleString()} tokens.\nMaximum drops allowed this run: ${maxDropsAllowed.toLocaleString()} observation${maxDropsAllowed === 1 ? "" : "s"}. This maximum is sized to move the active pool toward the target if every proposed drop is clearly safe.\nThis maximum is a hard upper bound, not a target. Drop fewer or none if fewer observations are clearly safe.`;
-	const prompts: Message[] = [{ role: "user", content: [{ type: "text", text: userText }], timestamp: Date.now() }];
-	const context: AgentContext = { systemPrompt: DROPPER_SYSTEM, messages: [], tools: [dropObservations as AgentTool<any>] };
-	const reasoning = (model as { reasoning?: unknown }).reasoning;
-	const thinkingLevel = args.thinkingLevel ?? "low";
-	const effectiveMaxTurns = args.maxTurns && args.maxTurns > 0 ? args.maxTurns : undefined;
-	let turnCount = 0;
-	const config: AgentLoopConfig = {
-		model,
-		apiKey,
-		headers,
-		maxTokens: boundedMaxTokens(model, AGENT_LOOP_MAX_TOKENS),
-		convertToLlm: (msgs) => msgs as Message[],
-		toolExecution: "sequential",
-		...(reasoning && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
-		...(effectiveMaxTurns !== undefined ? { shouldStopAfterTurn: () => ++turnCount >= effectiveMaxTurns } : {}),
-	};
-
-	const loop = args.agentLoop ?? agentLoop;
-	const stream = loop(prompts, context, config, signal, streamSimple);
-	for await (const event of stream) {
-		// Tool execution collects candidate ids.
-		logAgentStreamError("dropper", event);
-	}
-	const result = await stream.result();
-	if (args.recordUsage) {
-		for (const message of result) {
-			if (message.role === "assistant" && message.usage) args.recordUsage(message.usage);
-		}
-	}
-	const droppedIds = selectDropCandidates(proposedDropIds, observations, maxDropsAllowed, reflections);
-	const reason = droppedIds.length > 0
-		? "selected_nonempty"
-		: toolCallCount === 0
-			? "no_tool_call"
-			: proposedDropIds.length === 0
-				? "all_filtered"
-				: "selected_empty";
-	const selectedDropTokens = droppedIds.reduce((sum, id) => sum + (allowed.get(id)?.tokenCount ?? 0), 0);
-	debugLog("dropper.result", {
-		reason,
-		toolCallCount,
-		rawRequestedIdsCount,
-		missingIdsCount,
-		criticalCandidateIdsCount,
-		duplicateInRequestCount,
-		duplicateInRunCount,
-		acceptedCandidateCount: proposedDropIds.length,
-		selectedDropsCount: droppedIds.length,
-		selectedDropTokens,
-		selectedCoverageSummaryByRelevance: summarizeCoverageByRelevanceForIds(droppedIds, observations, coverageById),
-		maxDropsAllowed,
-	});
-	return droppedIds.length > 0 ? droppedIds : undefined;
-}

package/src/agents/dropper/coverage.ts

@@ -1,128 +0,0 @@
-import type { Observation, Reflection } from "../../session-ledger/index.js";
-
-export const REFLECTION_COVERAGE_TIERS = ["none", "partial", "strong"] as const;
-export type ReflectionCoverageTier = typeof REFLECTION_COVERAGE_TIERS[number];
-
-type Relevance = Observation["relevance"];
-
-type CoverageBucket = Record<ReflectionCoverageTier, { count: number; tokens: number }>;
-export type CoverageSummaryByRelevance = Record<Relevance, CoverageBucket>;
-export type CoverageTransitionSummaryByRelevance = Record<Relevance, Record<string, { count: number; tokens: number }>>;
-
-export const REFLECTION_COVERAGE_DROP_RANK: Record<ReflectionCoverageTier, number> = {
-	strong: 0,
-	partial: 1,
-	none: 2,
-};
-
-export function reflectionSupportCounts(reflections: readonly Reflection[]): Map<string, number> {
-	const counts = new Map<string, number>();
-	for (const reflection of reflections) {
-		const uniqueIds = new Set(reflection.supportingObservationIds);
-		for (const id of uniqueIds) counts.set(id, (counts.get(id) ?? 0) + 1);
-	}
-	return counts;
-}
-
-export function reflectionCoverageTierForCount(count: number): ReflectionCoverageTier {
-	if (count <= 0) return "none";
-	if (count === 1) return "partial";
-	return "strong";
-}
-
-export function reflectionCoverageMap(
-	observations: readonly Observation[],
-	reflections: readonly Reflection[],
-): Map<string, ReflectionCoverageTier> {
-	const counts = reflectionSupportCounts(reflections);
-	return new Map(observations.map((observation) => [
-		observation.id,
-		reflectionCoverageTierForCount(counts.get(observation.id) ?? 0),
-	]));
-}
-
-function emptyCoverageBucket(): CoverageBucket {
-	return {
-		none: { count: 0, tokens: 0 },
-		partial: { count: 0, tokens: 0 },
-		strong: { count: 0, tokens: 0 },
-	};
-}
-
-export function emptyCoverageSummaryByRelevance(): CoverageSummaryByRelevance {
-	return {
-		low: emptyCoverageBucket(),
-		medium: emptyCoverageBucket(),
-		high: emptyCoverageBucket(),
-		critical: emptyCoverageBucket(),
-	};
-}
-
-export function summarizeCoverageByRelevance(
-	observations: readonly Observation[],
-	coverageById: ReadonlyMap<string, ReflectionCoverageTier>,
-): CoverageSummaryByRelevance {
-	const summary = emptyCoverageSummaryByRelevance();
-	for (const observation of observations) {
-		const tier = coverageById.get(observation.id) ?? "none";
-		const bucket = summary[observation.relevance][tier];
-		bucket.count++;
-		bucket.tokens += observation.tokenCount;
-	}
-	return summary;
-}
-
-export function summarizeCoverageByRelevanceForIds(
-	ids: readonly string[],
-	observations: readonly Observation[],
-	coverageById: ReadonlyMap<string, ReflectionCoverageTier>,
-): CoverageSummaryByRelevance {
-	const byId = new Map(observations.map((observation) => [observation.id, observation]));
-	const selected = ids.flatMap((id) => {
-		const observation = byId.get(id);
-		return observation ? [observation] : [];
-	});
-	return summarizeCoverageByRelevance(selected, coverageById);
-}
-
-export function emptyCoverageTransitionSummaryByRelevance(): CoverageTransitionSummaryByRelevance {
-	return {
-		low: {},
-		medium: {},
-		high: {},
-		critical: {},
-	};
-}
-
-export function summarizeCoverageTransitionsByRelevance(
-	observations: readonly Observation[],
-	beforeCoverageById: ReadonlyMap<string, ReflectionCoverageTier>,
-	afterCoverageById: ReadonlyMap<string, ReflectionCoverageTier>,
-): CoverageTransitionSummaryByRelevance {
-	const summary = emptyCoverageTransitionSummaryByRelevance();
-	for (const observation of observations) {
-		const before = beforeCoverageById.get(observation.id) ?? "none";
-		const after = afterCoverageById.get(observation.id) ?? "none";
-		if (before === after) continue;
-		const key = `${before}->${after}`;
-		const bucket = summary[observation.relevance][key] ?? { count: 0, tokens: 0 };
-		bucket.count++;
-		bucket.tokens += observation.tokenCount;
-		summary[observation.relevance][key] = bucket;
-	}
-	return summary;
-}
-
-export function observationToDropperLine(
-	observation: Observation,
-	coverage: ReflectionCoverageTier,
-): string {
-	return `[${observation.id}] ${observation.timestamp} [${observation.relevance}] [coverage: ${coverage}] ${observation.content}`;
-}
-
-export function coverageTierForObservation(
-	observation: Observation,
-	coverageById: ReadonlyMap<string, ReflectionCoverageTier>,
-): ReflectionCoverageTier {
-	return coverageById.get(observation.id) ?? "none";
-}

package/src/agents/dropper/pool.ts

@@ -1,67 +0,0 @@
-import type { Observation } from "../../session-ledger/index.js";
-
-export type ObservationPoolMetrics = {
-	observationTokens: number;
-	targetTokens: number;
-	tokensOverTarget: number;
-	fullness: number;
-	activeObservationCount: number;
-	droppableCount: number;
-	maxDropsAllowed: number;
-	overTarget: boolean;
-	ready: boolean;
-};
-
-export function observationTokenSum(observations: readonly { tokenCount: number }[]): number {
-	return observations.reduce((sum, observation) => sum + observation.tokenCount, 0);
-}
-
-export function observationPoolFullness(observationTokens: number, targetTokens: number): number {
-	if (!Number.isFinite(observationTokens) || observationTokens <= 0) return 0;
-	if (!Number.isFinite(targetTokens) || targetTokens <= 0) return 0;
-	return observationTokens / targetTokens;
-}
-
-export function droppableObservationCount(observations: readonly Observation[]): number {
-	return observations.length;
-}
-
-export function maxDropCountForPool(observations: readonly Observation[], observationTokens: number, targetTokens: number): number {
-	const activeObservationCount = observations.length;
-	if (activeObservationCount === 0) return 0;
-	if (!Number.isFinite(observationTokens) || observationTokens <= 0) return 0;
-	if (!Number.isFinite(targetTokens) || targetTokens < 0) return 0;
-
-	const tokensOverTarget = observationTokens - targetTokens;
-	if (tokensOverTarget <= 0) return 0;
-
-	const averageObservationTokens = observationTokens / activeObservationCount;
-	if (!Number.isFinite(averageObservationTokens) || averageObservationTokens <= 0) return 0;
-
-	const estimatedDrops = Math.ceil(tokensOverTarget / averageObservationTokens);
-	return Math.min(activeObservationCount, Math.max(1, estimatedDrops));
-}
-
-export function observationPoolMetrics(
-	observations: readonly Observation[],
-	targetTokens: number,
-): ObservationPoolMetrics {
-	const observationTokens = observationTokenSum(observations);
-	const fullness = observationPoolFullness(observationTokens, targetTokens);
-	const activeObservationCount = observations.length;
-	const droppableCount = droppableObservationCount(observations);
-	const tokensOverTarget = Math.max(0, observationTokens - targetTokens);
-	const maxDropsAllowed = maxDropCountForPool(observations, observationTokens, targetTokens);
-	const overTarget = Number.isFinite(targetTokens) && targetTokens >= 0 && observationTokens > targetTokens;
-	return {
-		observationTokens,
-		targetTokens,
-		tokensOverTarget,
-		fullness,
-		activeObservationCount,
-		droppableCount,
-		maxDropsAllowed,
-		overTarget,
-		ready: overTarget && maxDropsAllowed > 0,
-	};
-}