open-multi-agent-kit 0.78.0

package/dist/runtime/context-broker.js

@@ -0,0 +1,308 @@
+import { CONTEXT_BUDGET_PRESETS, DEFAULT_CONTEXT_BUDGET, } from './context-capsule.js';
+import { getProjectRoot } from "../util/fs.js";
+import { join } from "path";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { createContextBudgetOptimizer } from "./context-budget-optimizer.js";
+import { createDecisionTraceStore } from "../evidence/decision-trace.js";
+function resolveBudget(node) {
+    const preset = node.routing?.contextBudget ?? "small";
+    return CONTEXT_BUDGET_PRESETS[preset] ?? DEFAULT_CONTEXT_BUDGET;
+}
+function collectDependencySummaries(node, state) {
+    if (!state || !node.dependsOn.length)
+        return [];
+    const summaries = [];
+    for (const depId of node.dependsOn) {
+        const depNode = state.nodes.find((n) => n.id === depId);
+        if (!depNode)
+            continue;
+        const lastAttempt = depNode.attempts?.[depNode.attempts.length - 1];
+        if (lastAttempt) {
+            summaries.push(`[${depId}] provider=${lastAttempt.provider ?? "?"} status=${lastAttempt.status ?? "?"} duration=${lastAttempt.durationMs ?? "?"}ms`);
+        }
+        else {
+            summaries.push(`[${depId}] status=${depNode.status}`);
+        }
+    }
+    return summaries;
+}
+function collectPriorAttempts(node) {
+    if (!node.attempts?.length)
+        return [];
+    return node.attempts.map((a) => ({
+        attempt: a.attempt,
+        provider: a.provider ?? "unknown",
+        status: (a.status ?? "failed"),
+        durationMs: a.durationMs,
+        failureSummary: a.fallbackReason,
+    }));
+}
+function collectEvidenceRequirements(node) {
+    if (!node.outputs?.length)
+        return [];
+    return node.outputs
+        .filter((o) => o.gate && o.gate !== "none")
+        .map((o) => ({
+        gate: o.gate,
+        ref: o.ref,
+        required: o.required !== false,
+    }));
+}
+const GRAPH_MEMORY_PARSE_TIMEOUT_MS = 750;
+const GRAPH_MEMORY_PARSE_MAX_BYTES = 2 * 1024 * 1024;
+const GRAPH_MEMORY_CACHE_FACT_LIMIT = 250;
+const graphMemoryParseCache = new Map();
+async function loadGraphMemory(maxFacts, memoryPath) {
+    const filePath = memoryPath ?? join(getProjectRoot(), '.omk', 'memory', 'graph-state.json');
+    const safeMaxFacts = Math.max(1, Math.floor(maxFacts) || 1);
+    try {
+        const graphStat = await stat(filePath);
+        if (!graphStat.isFile())
+            return [];
+        const cached = graphMemoryParseCache.get(filePath);
+        if (cached && cached.mtimeMs === graphStat.mtimeMs && cached.size === graphStat.size) {
+            return cached.facts.slice(0, safeMaxFacts);
+        }
+        if (graphStat.size > GRAPH_MEMORY_PARSE_MAX_BYTES) {
+            if (cached)
+                return cached.facts.slice(0, safeMaxFacts);
+            return [
+                createGraphMemorySummaryFact(`Graph memory state is ${formatBytes(graphStat.size)}, above the ${formatBytes(GRAPH_MEMORY_PARSE_MAX_BYTES)} context-broker parse limit; using fail-soft summary.`),
+            ];
+        }
+        const facts = await withTimeout(readGraphMemoryFacts(filePath, Math.max(safeMaxFacts, GRAPH_MEMORY_CACHE_FACT_LIMIT)), GRAPH_MEMORY_PARSE_TIMEOUT_MS, `ContextBroker graph memory parse timed out after ${GRAPH_MEMORY_PARSE_TIMEOUT_MS}ms`);
+        graphMemoryParseCache.set(filePath, { mtimeMs: graphStat.mtimeMs, size: graphStat.size, facts });
+        return facts.slice(0, safeMaxFacts);
+    }
+    catch (err) {
+        if (errorCode(err) === "ENOENT")
+            return [];
+        const cached = graphMemoryParseCache.get(filePath);
+        if (cached)
+            return cached.facts.slice(0, safeMaxFacts);
+        return [createGraphMemorySummaryFact(`Graph memory unavailable: ${redactMemoryText(errorMessage(err))}`)];
+    }
+}
+async function readGraphMemoryFacts(filePath, maxFacts) {
+    const raw = await readFile(filePath, 'utf-8');
+    const data = JSON.parse(raw);
+    const rawNodes = data.nodes;
+    const nodes = Array.isArray(rawNodes) ? rawNodes.filter(isRecord) : [];
+    const facts = [];
+    for (const n of nodes) {
+        if (facts.length >= maxFacts)
+            break;
+        const type = typeof n.type === "string" ? n.type : undefined;
+        const kind = mapGraphTypeToKind(type);
+        if (!kind)
+            continue;
+        const label = String(n.label ?? n.id ?? '');
+        const summary = String(n.summary ?? n.content ?? '');
+        if (!summary)
+            continue;
+        facts.push({
+            kind,
+            subject: label,
+            predicate: summarizePredicate(kind),
+            object: summary,
+            confidence: 0.8,
+            key: label,
+            value: summary,
+            category: kind,
+        });
+    }
+    return facts;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function createGraphMemorySummaryFact(message) {
+    return {
+        kind: "project_constraint",
+        subject: "graph-memory",
+        predicate: "summarized_as",
+        object: message,
+        confidence: 0.5,
+        key: "graph-memory",
+        value: message,
+        category: "project_constraint",
+    };
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KiB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MiB`;
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function errorCode(err) {
+    if (typeof err !== "object" || err === null || !("code" in err))
+        return undefined;
+    const code = err.code;
+    return typeof code === "string" ? code : undefined;
+}
+async function writeContextBrokerMemoryRecallArtifact(input) {
+    if (!input.runId || input.runId.startsWith("local-"))
+        return;
+    const runDir = join(input.projectRoot, ".omk", "runs", input.runId);
+    await mkdir(runDir, { recursive: true });
+    const summary = [
+        "# Context Broker Memory Recall",
+        "",
+        `Run ID: ${input.runId}`,
+        `Node ID: ${input.nodeId}`,
+        `Facts: ${input.graphMemory.length}`,
+        "",
+        ...input.graphMemory.slice(0, 12).map((fact) => `- ${fact.kind}: ${redactMemoryText(fact.key)} -> ${redactMemoryText(fact.value).slice(0, 180)}`),
+        "",
+    ].join("\n");
+    await writeFile(join(runDir, `context-broker-memory-recall-${input.nodeId}.md`), summary, "utf-8");
+}
+function redactMemoryText(value) {
+    return value
+        .replace(/sk-[A-Za-z0-9_-]{12,}/g, "sk-***")
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]{12,}/gi, "Bearer ***")
+        .replace(/(api[_-]?key|token|secret|password)\s*[:=]\s*[^\s,;]+/gi, "$1=***");
+}
+function mapGraphTypeToKind(type) {
+    switch (type) {
+        case 'Memory': return 'file_responsibility';
+        case 'Decision': return 'architecture_decision';
+        case 'Goal': return 'project_constraint';
+        case 'Constraint': return 'project_constraint';
+        case 'Evidence': return 'failure_pattern';
+        case 'Provider': return 'provider_behavior';
+        case 'ProviderRoute': return 'provider_behavior';
+        case 'Risk': return 'failure_pattern';
+        default: return undefined;
+    }
+}
+function summarizePredicate(kind) {
+    switch (kind) {
+        case 'project_constraint': return 'requires';
+        case 'architecture_decision': return 'decided_that';
+        case 'file_responsibility': return 'responsible_for';
+        case 'api_contract': return 'defines';
+        case 'failure_pattern': return 'fails_when';
+        case 'successful_fix': return 'fixed_by';
+        case 'user_preference': return 'prefers';
+        case 'provider_behavior': return 'behaves_as';
+    }
+}
+export function createContextBroker(options = {}) {
+    const projectRoot = options.projectRoot ?? getProjectRoot();
+    const optimizer = createContextBudgetOptimizer();
+    async function loadFileContent(paths) {
+        const slices = [];
+        for (const p of paths) {
+            try {
+                const fullPath = p.startsWith("/") ? p : join(projectRoot, p);
+                const content = await readFile(fullPath, "utf-8");
+                const lineCount = content.split("\n").length;
+                slices.push({ path: p, startLine: 1, endLine: lineCount, content });
+            }
+            catch {
+                // File not found or unreadable — skip
+            }
+        }
+        return slices;
+    }
+    async function buildCapsule(node, state, adjustment) {
+        const goal = options.goal ?? state?.goalId ?? "unknown";
+        const system = options.system ?? "You are a coding agent executing a DAG node.";
+        const dependencySummaries = collectDependencySummaries(node, state);
+        const priorAttempts = collectPriorAttempts(node);
+        const evidenceRequirements = collectEvidenceRequirements(node);
+        const graphMemory = await loadGraphMemory(resolveBudget(node).maxMemoryFacts, options.graphMemoryPath);
+        await writeContextBrokerMemoryRecallArtifact({
+            projectRoot,
+            runId: state?.runId,
+            nodeId: node.id,
+            graphMemory,
+        }).catch(() => { });
+        const task = [
+            `Execute DAG node: ${node.id}`,
+            `Name: ${node.name}`,
+            `Role: ${node.role}`,
+            node.routing?.actionAtom ? `ActionAtom: ${node.routing.actionAtom.id} | ${node.routing.actionAtom.label} | ${node.routing.actionAtom.verb} ${node.routing.actionAtom.object ?? "assigned scope"} | evidence=${node.routing.actionAtom.evidenceTarget} | done=${node.routing.actionAtom.doneCondition}` : undefined,
+            node.routing?.skills?.length ? `Skills: ${node.routing.skills.join(", ")}` : undefined,
+            node.routing?.mcpServers?.length ? `MCP: ${node.routing.mcpServers.join(", ")}` : undefined,
+            node.routing?.tools?.length ? `Tools: ${node.routing.tools.join(", ")}` : undefined,
+            node.routing?.rationale ? `Rationale: ${node.routing.rationale}` : undefined,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        // Guard against empty task content
+        if (!task || task.trim().length === 0) {
+            throw new Error(`ContextBroker: unable to build non-empty task for node ${node.id}`);
+        }
+        // Load actual file content for adjustment.addFiles
+        let relevantFiles = [];
+        if (adjustment?.addFiles?.length) {
+            relevantFiles = await loadFileContent(adjustment.addFiles);
+        }
+        let budget = resolveBudget(node);
+        if (adjustment?.budgetChange) {
+            budget = { ...budget, ...adjustment.budgetChange };
+        }
+        let finalTask = task;
+        if (adjustment?.promptPatch) {
+            finalTask = `${task}\n\n--- Adjustment ---\n${adjustment.promptPatch}`;
+        }
+        const rawCapsule = {
+            runId: state?.runId ?? `local-${Date.now()}`,
+            nodeId: node.id,
+            goal,
+            system,
+            task: finalTask,
+            dependencySummaries,
+            relevantFiles,
+            graphMemory,
+            priorAttempts,
+            evidenceRequirements,
+            budget,
+            node,
+        };
+        // Optimize: priority-based trimming + token accounting
+        const attemptId = node.attempts?.length
+            ? String(node.attempts[node.attempts.length - 1].attempt)
+            : "0";
+        const optimized = optimizer.optimize(rawCapsule, attemptId);
+        // Record context-broker decision trace
+        const runId = state?.runId;
+        if (runId && !runId.startsWith("local-")) {
+            const traceStore = createDecisionTraceStore();
+            traceStore.record(runId, {
+                component: "context-broker",
+                inputSummary: `node=${node.id} budgetPreset=${node.routing?.contextBudget ?? "small"} adjustment=${adjustment ? "yes" : "no"}`,
+                outputDecision: `budget=${JSON.stringify(budget)} files=${relevantFiles.length} memoryFacts=${graphMemory.length}`,
+                reason: `Context capsule built with ${optimized.report.totalTokensEstimated} total tokens, ${optimized.report.toolResultTokens} tool tokens`,
+                scores: {
+                    totalTokens: optimized.report.totalTokensEstimated,
+                    toolResultTokens: optimized.report.toolResultTokens,
+                    droppedItems: optimized.report.droppedItems.length,
+                },
+                nodeId: node.id,
+                attemptId: `${node.id}__${attemptId}`,
+            });
+        }
+        return { capsule: optimized.capsule, report: optimized.report };
+    }
+    return { buildCapsule };
+}

package/dist/runtime/context-budget-optimizer.d.ts

@@ -0,0 +1,73 @@
+/**
+ * ContextBudgetOptimizer — priority-based context trimming with per-field token accounting.
+ *
+ * Key metric: evidence_pass_rate_per_token
+ * Goal: maximize verification pass probability per token spent.
+ *
+ * Priority order (highest first):
+ *   1. node goal
+ *   2. explicit user constraints (system prompt)
+ *   3. evidence requirements
+ *   4. failing evidence from previous attempt
+ *   5. directly changed files
+ *   6. dependency node summaries
+ *   7. relevant file slices
+ *   8. graph memory facts
+ *   9. broad project background
+ */
+import type { ContextCapsule, FileSlice, MemoryFact } from "./context-capsule.js";
+export interface ContextBudgetReport {
+    readonly nodeId: string;
+    readonly attemptId: string;
+    readonly totalTokensEstimated: number;
+    readonly systemTokens: number;
+    readonly taskTokens: number;
+    readonly dependencyTokens: number;
+    readonly fileTokens: number;
+    readonly memoryTokens: number;
+    readonly evidenceTokens: number;
+    readonly toolResultTokens: number;
+    readonly droppedItems: readonly DroppedContextItem[];
+}
+export interface DroppedContextItem {
+    readonly kind: "file" | "memory" | "dependency" | "tool-result" | "log";
+    readonly reason: "low-relevance" | "budget-limit" | "duplicate" | "too-large";
+    readonly summary: string;
+}
+export interface ContextTokenBreakdown {
+    readonly system: number;
+    readonly task: number;
+    readonly goal: number;
+    readonly dependencies: number;
+    readonly files: number;
+    readonly memory: number;
+    readonly evidence: number;
+    readonly priorAttempts: number;
+    readonly total: number;
+}
+export interface ContextBudgetOptimizationResult {
+    readonly capsule: ContextCapsule;
+    readonly report: ContextBudgetReport;
+    readonly breakdown: ContextTokenBreakdown;
+}
+/** Per-item evidence stats for pass-rate-per-token tracking. */
+export interface ContextItemEvidenceStats {
+    readonly itemId: string;
+    readonly kind: "file" | "memory" | "dependency" | "tool-result";
+    readonly tokens: number;
+    readonly evidencePassCount: number;
+    readonly evidenceFailCount: number;
+    readonly passRate: number;
+}
+export declare function estimateTokens(text: string): number;
+export declare function estimateFileSliceTokens(slice: FileSlice): number;
+export declare function estimateMemoryFactTokens(fact: MemoryFact): number;
+export declare function breakdownCapsuleTokens(capsule: ContextCapsule): ContextTokenBreakdown;
+export declare function optimizeContextBudget(capsule: ContextCapsule, attemptId: string): ContextBudgetOptimizationResult;
+export declare function createContextBudgetOptimizer(): {
+    optimize: typeof optimizeContextBudget;
+    breakdown: typeof breakdownCapsuleTokens;
+    estimateTokens: typeof estimateTokens;
+    estimateFileSliceTokens: typeof estimateFileSliceTokens;
+    estimateMemoryFactTokens: typeof estimateMemoryFactTokens;
+};

package/dist/runtime/context-budget-optimizer.js

@@ -0,0 +1,300 @@
+/**
+ * ContextBudgetOptimizer — priority-based context trimming with per-field token accounting.
+ *
+ * Key metric: evidence_pass_rate_per_token
+ * Goal: maximize verification pass probability per token spent.
+ *
+ * Priority order (highest first):
+ *   1. node goal
+ *   2. explicit user constraints (system prompt)
+ *   3. evidence requirements
+ *   4. failing evidence from previous attempt
+ *   5. directly changed files
+ *   6. dependency node summaries
+ *   7. relevant file slices
+ *   8. graph memory facts
+ *   9. broad project background
+ */
+// ─── Token estimation ────────────────────────────────────────────────────────
+const CHARS_PER_TOKEN = 4;
+export function estimateTokens(text) {
+    return Math.ceil((text ?? "").length / CHARS_PER_TOKEN);
+}
+export function estimateFileSliceTokens(slice) {
+    return estimateTokens(slice.content);
+}
+export function estimateMemoryFactTokens(fact) {
+    // SPO triple is the authoritative source; key/value are backward compat
+    const spo = estimateTokens(fact.subject) + estimateTokens(fact.predicate) + estimateTokens(fact.object);
+    const kv = estimateTokens(fact.key) + estimateTokens(fact.value);
+    return Math.max(spo, kv);
+}
+export function breakdownCapsuleTokens(capsule) {
+    const system = estimateTokens(capsule.system);
+    const task = estimateTokens(capsule.task);
+    const goal = estimateTokens(capsule.goal);
+    let dependencies = 0;
+    for (const s of capsule.dependencySummaries) {
+        dependencies += estimateTokens(s);
+    }
+    let files = 0;
+    for (const f of capsule.relevantFiles) {
+        files += estimateFileSliceTokens(f);
+    }
+    let memory = 0;
+    for (const m of capsule.graphMemory) {
+        memory += estimateMemoryFactTokens(m);
+    }
+    let evidence = 0;
+    for (const e of capsule.evidenceRequirements) {
+        evidence += estimateTokens(`${e.gate}: ${e.ref ?? ""}`);
+    }
+    let priorAttempts = 0;
+    for (const a of capsule.priorAttempts) {
+        priorAttempts += estimateTokens(`${a.attempt} ${a.provider} ${a.status} ${a.failureSummary ?? ""}`);
+    }
+    return {
+        system,
+        task,
+        goal,
+        dependencies,
+        files,
+        memory,
+        evidence,
+        priorAttempts,
+        total: system + task + goal + dependencies + files + memory + evidence + priorAttempts,
+    };
+}
+const PRIORITY_ORDER = [
+    { level: 1, kind: "goal" },
+    { level: 2, kind: "system" },
+    { level: 3, kind: "evidence" },
+    { level: 4, kind: "prior-attempts" },
+    { level: 5, kind: "files" },
+    { level: 6, kind: "dependencies" },
+    { level: 7, kind: "file-slices" },
+    { level: 8, kind: "memory" },
+    { level: 9, kind: "background" },
+];
+// ─── Core optimizer ──────────────────────────────────────────────────────────
+export function optimizeContextBudget(capsule, attemptId) {
+    const breakdown = breakdownCapsuleTokens(capsule);
+    const maxTokens = capsule.budget.maxInputTokens;
+    const dropped = [];
+    if (breakdown.total <= maxTokens) {
+        return {
+            capsule,
+            report: buildReport(capsule, attemptId, breakdown, dropped),
+            breakdown,
+        };
+    }
+    // Trim from lowest priority (9→1) until under budget
+    let currentCapsule = { ...capsule };
+    let currentBreakdown = breakdown;
+    for (let i = PRIORITY_ORDER.length - 1; i >= 0; i--) {
+        if (currentBreakdown.total <= maxTokens)
+            break;
+        const item = PRIORITY_ORDER[i];
+        const result = trimLevel(currentCapsule, currentBreakdown, item, maxTokens);
+        currentCapsule = result.capsule;
+        currentBreakdown = result.breakdown;
+        dropped.push(...result.dropped);
+    }
+    return {
+        capsule: currentCapsule,
+        report: buildReport(currentCapsule, attemptId, currentBreakdown, dropped),
+        breakdown: currentBreakdown,
+    };
+}
+function trimLevel(capsule, breakdown, item, maxTokens) {
+    const overBy = breakdown.total - maxTokens;
+    if (overBy <= 0)
+        return { capsule, breakdown, dropped: [] };
+    switch (item.kind) {
+        case "background":
+            return trimBackground(capsule, breakdown, overBy);
+        case "memory":
+            return trimMemory(capsule, breakdown, overBy);
+        case "file-slices":
+            return trimFileSlices(capsule, breakdown, overBy);
+        case "dependencies":
+            return trimDependencies(capsule, breakdown, overBy);
+        case "files":
+            return trimFiles(capsule, breakdown, overBy);
+        case "prior-attempts":
+            return trimPriorAttempts(capsule, breakdown, overBy);
+        default:
+            // Levels 1-3 (goal, system, evidence) are never trimmed
+            return { capsule, breakdown, dropped: [] };
+    }
+}
+function trimBackground(capsule, breakdown, _overBy) {
+    // Background = extra graphMemory facts beyond the essential ones
+    const dropped = [];
+    if (capsule.graphMemory.length <= 1)
+        return { capsule, breakdown, dropped };
+    const keepCount = Math.max(1, Math.floor(capsule.graphMemory.length * 0.5));
+    const removed = capsule.graphMemory.slice(keepCount);
+    const newMemory = capsule.graphMemory.slice(0, keepCount);
+    let savedTokens = 0;
+    for (const m of removed) {
+        savedTokens += estimateMemoryFactTokens(m);
+        dropped.push({
+            kind: "memory",
+            reason: "budget-limit",
+            summary: `${m.key} (${m.category})`,
+        });
+    }
+    const newCapsule = { ...capsule, graphMemory: newMemory };
+    const newBreakdown = {
+        ...breakdown,
+        memory: breakdown.memory - savedTokens,
+        total: breakdown.total - savedTokens,
+    };
+    return { capsule: newCapsule, breakdown: newBreakdown, dropped };
+}
+function trimMemory(capsule, breakdown, overBy) {
+    const dropped = [];
+    if (capsule.graphMemory.length === 0)
+        return { capsule, breakdown, dropped };
+    // Drop lowest-confidence facts first
+    const sorted = [...capsule.graphMemory].sort((a, b) => a.confidence - b.confidence);
+    const newMemory = [];
+    let savedTokens = 0;
+    for (const fact of sorted) {
+        const tokens = estimateMemoryFactTokens(fact);
+        if (savedTokens >= overBy) {
+            newMemory.push(fact);
+        }
+        else {
+            savedTokens += tokens;
+            dropped.push({
+                kind: "memory",
+                reason: "low-relevance",
+                summary: `${fact.key} (confidence=${fact.confidence})`,
+            });
+        }
+    }
+    const newCapsule = { ...capsule, graphMemory: newMemory };
+    const newBreakdown = {
+        ...breakdown,
+        memory: breakdown.memory - savedTokens,
+        total: breakdown.total - savedTokens,
+    };
+    return { capsule: newCapsule, breakdown: newBreakdown, dropped };
+}
+function trimFileSlices(capsule, breakdown, overBy) {
+    const dropped = [];
+    if (capsule.relevantFiles.length === 0)
+        return { capsule, breakdown, dropped };
+    // Drop largest files first (least efficient per-token)
+    const sorted = [...capsule.relevantFiles].sort((a, b) => estimateFileSliceTokens(b) - estimateFileSliceTokens(a));
+    const newFiles = [];
+    let savedTokens = 0;
+    for (const file of sorted) {
+        const tokens = estimateFileSliceTokens(file);
+        if (savedTokens >= overBy) {
+            newFiles.push(file);
+        }
+        else {
+            savedTokens += tokens;
+            dropped.push({
+                kind: "file",
+                reason: tokens > overBy ? "too-large" : "budget-limit",
+                summary: `${file.path} (${tokens} tokens)`,
+            });
+        }
+    }
+    const newCapsule = { ...capsule, relevantFiles: newFiles };
+    const newBreakdown = {
+        ...breakdown,
+        files: breakdown.files - savedTokens,
+        total: breakdown.total - savedTokens,
+    };
+    return { capsule: newCapsule, breakdown: newBreakdown, dropped };
+}
+function trimDependencies(capsule, breakdown, overBy) {
+    const dropped = [];
+    if (capsule.dependencySummaries.length === 0)
+        return { capsule, breakdown, dropped };
+    // Drop from end (least recent dependency)
+    const newSummaries = [];
+    let savedTokens = 0;
+    const reversed = [...capsule.dependencySummaries].reverse();
+    for (const summary of reversed) {
+        const tokens = estimateTokens(summary);
+        if (savedTokens >= overBy) {
+            newSummaries.unshift(summary);
+        }
+        else {
+            savedTokens += tokens;
+            dropped.push({
+                kind: "dependency",
+                reason: "budget-limit",
+                summary: summary.slice(0, 80),
+            });
+        }
+    }
+    const newCapsule = { ...capsule, dependencySummaries: newSummaries };
+    const newBreakdown = {
+        ...breakdown,
+        dependencies: breakdown.dependencies - savedTokens,
+        total: breakdown.total - savedTokens,
+    };
+    return { capsule: newCapsule, breakdown: newBreakdown, dropped };
+}
+function trimFiles(capsule, breakdown, overBy) {
+    // Same as trimFileSlices but more aggressive — remove all non-essential files
+    return trimFileSlices(capsule, breakdown, overBy);
+}
+function trimPriorAttempts(capsule, breakdown, _overBy) {
+    const dropped = [];
+    if (capsule.priorAttempts.length === 0)
+        return { capsule, breakdown, dropped };
+    // Keep only last 2 attempts, drop older ones
+    const keepCount = Math.min(2, capsule.priorAttempts.length);
+    const removed = capsule.priorAttempts.slice(0, capsule.priorAttempts.length - keepCount);
+    const newAttempts = capsule.priorAttempts.slice(capsule.priorAttempts.length - keepCount);
+    let savedTokens = 0;
+    for (const a of removed) {
+        savedTokens += estimateTokens(`${a.attempt} ${a.provider} ${a.status} ${a.failureSummary ?? ""}`);
+        dropped.push({
+            kind: "log",
+            reason: "budget-limit",
+            summary: `attempt ${a.attempt} (${a.provider}/${a.status})`,
+        });
+    }
+    const newCapsule = { ...capsule, priorAttempts: newAttempts };
+    const newBreakdown = {
+        ...breakdown,
+        priorAttempts: breakdown.priorAttempts - savedTokens,
+        total: breakdown.total - savedTokens,
+    };
+    return { capsule: newCapsule, breakdown: newBreakdown, dropped };
+}
+// ─── Report builder ──────────────────────────────────────────────────────────
+function buildReport(capsule, attemptId, breakdown, droppedItems) {
+    return {
+        nodeId: capsule.nodeId,
+        attemptId,
+        totalTokensEstimated: breakdown.total,
+        systemTokens: breakdown.system + breakdown.goal,
+        taskTokens: breakdown.task,
+        dependencyTokens: breakdown.dependencies,
+        fileTokens: breakdown.files,
+        memoryTokens: breakdown.memory,
+        evidenceTokens: breakdown.evidence + breakdown.priorAttempts,
+        toolResultTokens: 0,
+        droppedItems,
+    };
+}
+// ─── Factory ─────────────────────────────────────────────────────────────────
+export function createContextBudgetOptimizer() {
+    return {
+        optimize: optimizeContextBudget,
+        breakdown: breakdownCapsuleTokens,
+        estimateTokens,
+        estimateFileSliceTokens,
+        estimateMemoryFactTokens,
+    };
+}