open-multi-agent-kit 0.80.4 → 0.80.6

package/dist/core/compaction/compaction.js

@@ -5,6 +5,7 @@
  * and after compaction the session is reloaded.
  */
 import { completeSimple } from "@earendil-works/omk-ai";
+import { recordHarnessControlEvent } from "../harness-control-events.js";
 import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
 import { buildSessionContext } from "../session-manager.js";
 import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
@@ -64,11 +65,13 @@ function getMessageFromEntryForCompaction(entry) {
     return getMessageFromEntry(entry);
 }
 export const DEFAULT_COMPACTION_MAX_USAGE_RATIO = 0.9;
+export const DEFAULT_COMPACTION_SUMMARY_INPUT_TOKENS = 80000;
 export const DEFAULT_COMPACTION_SETTINGS = {
     enabled: true,
     reserveTokens: 16384,
     keepRecentTokens: 20000,
     maxUsageRatio: DEFAULT_COMPACTION_MAX_USAGE_RATIO,
+    summaryInputTokens: DEFAULT_COMPACTION_SUMMARY_INPUT_TOKENS,
 };
 // ============================================================================
 // Token calculation
@@ -374,6 +377,401 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
     };
 }
 // ============================================================================
+// Summarization Input Packing
+// ============================================================================
+const CHARS_PER_TOKEN_ESTIMATE = 4;
+const SUMMARY_INPUT_PROMPT_OVERHEAD_TOKENS = 2048;
+const SUMMARY_INPUT_TOKENIZER_SAFETY_MARGIN = 512;
+const MIN_SUMMARY_INPUT_TOKENS = 512;
+function estimateTextTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
+}
+function isFinitePositiveInteger(value) {
+    return value !== undefined && Number.isFinite(value) && value > 0;
+}
+export function resolveSummaryInputTokenBudgetV3(model, maxOutputTokens, options) {
+    const configuredSummaryInputTokens = typeof options === "number" ? options : options?.configuredSummaryInputTokens;
+    if (configuredSummaryInputTokens !== undefined && configuredSummaryInputTokens <= 0) {
+        return { emergency: false, fixedPromptTokens: 0 };
+    }
+    const configuredBudget = configuredSummaryInputTokens ?? DEFAULT_COMPACTION_SUMMARY_INPUT_TOKENS;
+    if (!isFinitePositiveInteger(configuredBudget)) {
+        return { emergency: false, fixedPromptTokens: 0 };
+    }
+    const contextWindow = model.contextWindow > 0 ? Math.floor(model.contextWindow) : Number.POSITIVE_INFINITY;
+    if (!Number.isFinite(contextWindow)) {
+        return { budgetTokens: Math.floor(configuredBudget), emergency: false, fixedPromptTokens: 0 };
+    }
+    const fixedPromptTokens = typeof options === "object"
+        ? estimateTextTokens([
+            options.systemPrompt,
+            options.basePrompt,
+            options.customInstructions,
+            options.previousSummary,
+            options.wrapperText,
+        ]
+            .filter((value) => typeof value === "string" && value.length > 0)
+            .join("\n"))
+        : SUMMARY_INPUT_PROMPT_OVERHEAD_TOKENS;
+    const safetyMarginTokens = typeof options === "object" ? (options.safetyMarginTokens ?? SUMMARY_INPUT_TOKENIZER_SAFETY_MARGIN) : 0;
+    const availableInputTokens = contextWindow - Math.max(0, Math.floor(maxOutputTokens)) - fixedPromptTokens - safetyMarginTokens;
+    if (availableInputTokens < MIN_SUMMARY_INPUT_TOKENS) {
+        return {
+            emergency: true,
+            reason: "fixed prompt overhead exceeds viable summarization input budget",
+            fixedPromptTokens,
+            availableInputTokens,
+        };
+    }
+    return {
+        budgetTokens: Math.max(MIN_SUMMARY_INPUT_TOKENS, Math.min(Math.floor(configuredBudget), availableInputTokens)),
+        emergency: false,
+        fixedPromptTokens,
+        availableInputTokens,
+    };
+}
+export function resolveSummaryInputTokenBudget(model, maxOutputTokens, options) {
+    return resolveSummaryInputTokenBudgetV3(model, maxOutputTokens, options).budgetTokens;
+}
+function scoreSummaryLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+        return 0;
+    let score = 0;
+    if (/\b(?:[\w.-]+\/)+[\w.-]+\.(?:ts|tsx|js|jsx|json|md|css|scss|py|rs|go|java|kt|swift|sh|yml|yaml|toml)\b/.test(trimmed)) {
+        score += 6;
+    }
+    if (/\b(?:error|failed|failure|exception|warning|blocked|regression|timeout|overflow|abort)\b/i.test(trimmed) ||
+        /(?:오류|실패|경고|차단|회귀|시간 초과|타임아웃)/.test(trimmed)) {
+        score += 5;
+    }
+    if (/\b(?:npm|node|pnpm|yarn|bun|git|gh|tsgo|vitest|biome|pytest|cargo|go test)\b/.test(trimmed)) {
+        score += 4;
+    }
+    if (/^(?:#{1,6}\s|[-*]\s|\d+\.\s|\[[ xX]\]|```)/.test(trimmed)) {
+        score += 3;
+    }
+    if (/\b(?:goal|constraint|decision|next step|todo|changed|created|modified|verified|passed|failed)\b/i.test(trimmed) ||
+        /(?:목표|제약|결정|다음 단계|검증|통과|수정|생성|변경|증거)/.test(trimmed)) {
+        score += 3;
+    }
+    if (trimmed.length <= 220) {
+        score += 1;
+    }
+    else if (trimmed.length > 1000) {
+        score -= 3;
+    }
+    return score;
+}
+function selectHighSignalLines(text, budgetChars) {
+    if (budgetChars <= 0)
+        return "";
+    const scoredLines = text
+        .split("\n")
+        .map((line, index) => ({ index, line, score: scoreSummaryLine(line) }))
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score || a.index - b.index);
+    const selected = [];
+    let usedChars = 0;
+    for (const item of scoredLines) {
+        const lineChars = item.line.length + 1;
+        if (usedChars + lineChars > budgetChars)
+            continue;
+        selected.push({ index: item.index, line: item.line });
+        usedChars += lineChars;
+    }
+    if (selected.length === 0) {
+        return text.slice(0, budgetChars);
+    }
+    return selected
+        .sort((a, b) => a.index - b.index)
+        .map((item) => item.line)
+        .join("\n");
+}
+function scoreSummaryUnit(unit) {
+    const lineScores = unit.split("\n").map(scoreSummaryLine);
+    const maxLineScore = Math.max(0, ...lineScores);
+    const aggregateScore = lineScores.reduce((sum, score) => sum + Math.max(0, score), 0);
+    let score = maxLineScore * 2 + Math.min(aggregateScore, 12);
+    if (/^```/m.test(unit))
+        score += 3;
+    if (/^#{1,6}\s/m.test(unit))
+        score += 2;
+    if (unit.length > 2400)
+        score -= 4;
+    return score;
+}
+function extractSummaryUnitSignals(text) {
+    const signals = new Set();
+    for (const match of text.matchAll(/\b(?:[\w.-]+\/)+[\w.-]+\.(?:ts|tsx|js|jsx|json|md|css|scss|py|rs|go|java|kt|swift|sh|yml|yaml|toml)\b/g)) {
+        signals.add(`path:${match[0]}`);
+    }
+    for (const match of text.matchAll(/\b(?:npm|node|pnpm|yarn|bun|git|gh|tsgo|vitest|biome|pytest|cargo|go test)\b[^\n]*/g)) {
+        signals.add(`cmd:${match[0].trim().slice(0, 160)}`);
+    }
+    for (const match of text.matchAll(/\b(?:HCP-\d+|R\d+)\b/g)) {
+        signals.add(`id:${match[0]}`);
+    }
+    for (const match of text.matchAll(/\.omk\/[\w./-]+/g)) {
+        signals.add(`evidence:${match[0]}`);
+    }
+    return [...signals];
+}
+function updateHeadingStack(headingStack, headingLine) {
+    const match = headingLine.match(/^(#{1,6})\s+(.+)$/);
+    if (!match)
+        return headingStack;
+    const level = match[1].length;
+    const title = match[2].replace(/\s+#+\s*$/, "").trim();
+    const nextStack = [...headingStack];
+    while (nextStack.length > 0 && nextStack.at(-1).level >= level) {
+        nextStack.pop();
+    }
+    nextStack.push({ level, title });
+    return nextStack;
+}
+function inferSummaryUnitStatus(text) {
+    if (/^- \[[xX]]/m.test(text) || /\b(?:completed|done|fixed)\b/i.test(text) || /(?:완료|수정됨)/.test(text)) {
+        return "done";
+    }
+    if (/^- \[ ]/m.test(text) || /\b(?:in progress|todo|next)\b/i.test(text) || /(?:진행|다음)/.test(text)) {
+        return "in_progress";
+    }
+    if (/\b(?:blocked|blocker)\b/i.test(text) || /(?:차단|블로커)/.test(text))
+        return "blocked";
+    if (/\b(?:failed|failure|error|exception|regression)\b/i.test(text) || /(?:실패|오류|회귀)/.test(text)) {
+        return "failed";
+    }
+    if (/\b(?:passed|success|ok)\b/i.test(text) || /(?:통과|성공)/.test(text))
+        return "passed";
+    return undefined;
+}
+function inferSummaryUnitKind(text, status) {
+    const trimmed = text.trim();
+    if (status === "blocked")
+        return "blocker";
+    if (trimmed.startsWith("```"))
+        return "code";
+    if (/\.omk\/[\w./-]+|\bevidence\b/i.test(text))
+        return "evidence";
+    if (/\b(?:npm|node|pnpm|yarn|bun|git|gh|tsgo|vitest|biome|pytest|cargo|go test)\b/.test(text))
+        return "command";
+    if (/^(?:[-*]\s+\[[ xX]])/m.test(text))
+        return "checklist";
+    if (/^#{1,6}\s/m.test(text))
+        return "heading";
+    return "text";
+}
+function createSummaryInputSemanticUnit(index, text, sectionPath) {
+    const status = inferSummaryUnitStatus(text);
+    return {
+        index,
+        text,
+        score: scoreSummaryUnit(text),
+        sectionPath,
+        kind: inferSummaryUnitKind(text, status),
+        refs: extractSummaryUnitSignals(text),
+        status,
+    };
+}
+export function splitSummaryInputSemanticUnits(text) {
+    const lines = text.split("\n");
+    const units = [];
+    let start = 0;
+    let current = [];
+    let inFence = false;
+    let activeHeadingStack = [];
+    let currentSectionPath = [];
+    function flush(nextIndex) {
+        while (current.length > 0 && current[0]?.trim() === "") {
+            current.shift();
+            start++;
+        }
+        while (current.length > 0 && current.at(-1)?.trim() === "") {
+            current.pop();
+        }
+        if (current.length === 0) {
+            start = nextIndex;
+            currentSectionPath = activeHeadingStack.map((heading) => heading.title);
+            return;
+        }
+        const unitText = current.join("\n");
+        units.push(createSummaryInputSemanticUnit(start, unitText, [...currentSectionPath]));
+        current = [];
+        start = nextIndex;
+        currentSectionPath = activeHeadingStack.map((heading) => heading.title);
+    }
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const trimmed = line.trim();
+        const startsFence = trimmed.startsWith("```");
+        const startsHeading = /^#{1,6}\s/.test(trimmed);
+        if (!inFence && startsHeading && current.some((entry) => entry.trim().length > 0)) {
+            flush(index);
+        }
+        if (!inFence && startsHeading) {
+            activeHeadingStack = updateHeadingStack(activeHeadingStack, trimmed);
+        }
+        if (current.length === 0) {
+            start = index;
+            currentSectionPath = activeHeadingStack.map((heading) => heading.title);
+        }
+        current.push(line);
+        if (startsFence) {
+            inFence = !inFence;
+            if (!inFence)
+                flush(index + 1);
+            continue;
+        }
+        if (!inFence && trimmed.length === 0) {
+            flush(index + 1);
+        }
+    }
+    flush(lines.length);
+    return units;
+}
+export function buildSummaryDependencyGraph(units) {
+    const edges = [];
+    const signalsByIndex = new Map();
+    for (const unit of units) {
+        signalsByIndex.set(unit.index, new Set(unit.refs));
+    }
+    for (let i = 0; i < units.length; i++) {
+        for (let j = i + 1; j < units.length; j++) {
+            const leftUnit = units[i];
+            const rightUnit = units[j];
+            const left = signalsByIndex.get(leftUnit.index) ?? new Set();
+            const right = signalsByIndex.get(rightUnit.index) ?? new Set();
+            const shared = [...left].find((signal) => right.has(signal));
+            const sameSection = leftUnit.sectionPath.length > 0 && leftUnit.sectionPath.join("/") === rightUnit.sectionPath.join("/");
+            if (shared || sameSection) {
+                const reason = shared ?? `section:${leftUnit.sectionPath.join("/")}`;
+                edges.push({ from: leftUnit.index, to: rightUnit.index, reason });
+                edges.push({ from: rightUnit.index, to: leftUnit.index, reason });
+            }
+        }
+    }
+    return { nodes: units, edges };
+}
+export function selectSummaryDependencyClosure(graph, seedIndexes, maxAdditionalNodes = 8) {
+    const selected = new Set(seedIndexes);
+    const queue = [...seedIndexes];
+    while (queue.length > 0 && selected.size < seedIndexes.length + maxAdditionalNodes) {
+        const index = queue.shift();
+        const neighbors = graph.edges
+            .filter((edge) => edge.from === index)
+            .map((edge) => edge.to)
+            .filter((neighbor) => !selected.has(neighbor));
+        for (const neighbor of neighbors) {
+            selected.add(neighbor);
+            queue.push(neighbor);
+            if (selected.size >= seedIndexes.length + maxAdditionalNodes)
+                break;
+        }
+    }
+    return selected;
+}
+function normalizeSummaryNovelty(text) {
+    return text
+        .toLowerCase()
+        .replace(/\b\d+\b/g, "#")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function deduplicateSummaryFactsByNovelty(units) {
+    const seen = new Set();
+    const result = [];
+    for (const unit of units) {
+        const sectionKey = unit.sectionPath.join("/");
+        const key = [sectionKey, unit.kind, unit.status ?? "", normalizeSummaryNovelty(unit.text)].join("|");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(unit);
+    }
+    return result;
+}
+function selectHighSignalSemanticUnits(text, budgetChars) {
+    if (budgetChars <= 0)
+        return "";
+    const candidateUnits = deduplicateSummaryFactsByNovelty(splitSummaryInputSemanticUnits(text).filter((unit) => unit.score > 0));
+    const graph = buildSummaryDependencyGraph(candidateUnits);
+    const rankedUnits = [...candidateUnits].sort((a, b) => b.score - a.score || a.index - b.index);
+    const seedIndexes = rankedUnits.slice(0, Math.min(12, rankedUnits.length)).map((unit) => unit.index);
+    const closureIndexes = selectSummaryDependencyClosure(graph, seedIndexes);
+    const units = rankedUnits
+        .filter((unit) => closureIndexes.has(unit.index))
+        .sort((a, b) => b.score - a.score || a.index - b.index);
+    const selected = [];
+    let usedChars = 0;
+    for (const unit of units) {
+        const unitChars = unit.text.length + 2;
+        if (unitChars > budgetChars) {
+            const excerpt = selectHighSignalLines(unit.text, Math.max(0, budgetChars - usedChars));
+            if (excerpt.length > 0) {
+                selected.push({ ...unit, text: excerpt });
+                usedChars += excerpt.length + 2;
+            }
+            continue;
+        }
+        if (usedChars + unitChars > budgetChars)
+            continue;
+        selected.push(unit);
+        usedChars += unitChars;
+    }
+    if (selected.length === 0) {
+        return text.slice(0, budgetChars);
+    }
+    return selected
+        .sort((a, b) => a.index - b.index)
+        .map((unit) => unit.text)
+        .join("\n\n");
+}
+function trimToCharBudget(text, budgetChars, fromEnd = false) {
+    if (budgetChars <= 0)
+        return "";
+    if (text.length <= budgetChars)
+        return text;
+    return fromEnd ? text.slice(text.length - budgetChars) : text.slice(0, budgetChars);
+}
+/**
+ * Pack serialized conversation text under a token budget using a deterministic
+ * extractive strategy: preserve the opening, recent tail, and high-signal
+ * middle lines such as paths, commands, errors, and decisions.
+ */
+export function packSummaryInputForTokenBudget(text, maxInputTokens) {
+    const originalTokens = estimateTextTokens(text);
+    if (!isFinitePositiveInteger(maxInputTokens) || originalTokens <= maxInputTokens) {
+        return {
+            text,
+            originalTokens,
+            packedTokens: originalTokens,
+            omittedTokens: 0,
+            wasCompressed: false,
+        };
+    }
+    const targetChars = Math.max(MIN_SUMMARY_INPUT_TOKENS * CHARS_PER_TOKEN_ESTIMATE, Math.floor(maxInputTokens) * 4);
+    const marker = `<omk-summary-input-compressed originalTokens="${originalTokens}" targetTokens="${Math.floor(maxInputTokens)}">\nOlder serialized history was packed before summarization. Opening context, high-signal semantic units, and the recent tail were retained; low-signal repeated text was omitted.\n</omk-summary-input-compressed>`;
+    const contentBudgetChars = Math.max(512, targetChars - marker.length - 64);
+    const headBudgetChars = Math.floor(contentBudgetChars * 0.18);
+    const tailBudgetChars = Math.floor(contentBudgetChars * 0.52);
+    const middleBudgetChars = Math.max(0, contentBudgetChars - headBudgetChars - tailBudgetChars);
+    const head = trimToCharBudget(text, headBudgetChars);
+    const tail = trimToCharBudget(text, tailBudgetChars, true);
+    const middleStart = Math.min(headBudgetChars, text.length);
+    const middleEnd = Math.max(middleStart, text.length - tailBudgetChars);
+    const middle = selectHighSignalSemanticUnits(text.slice(middleStart, middleEnd), middleBudgetChars);
+    const packedText = [head.trimEnd(), marker, middle.trim(), tail.trimStart()].filter(Boolean).join("\n\n");
+    const packedTokens = estimateTextTokens(packedText);
+    return {
+        text: packedText,
+        originalTokens,
+        packedTokens,
+        omittedTokens: Math.max(0, originalTokens - packedTokens),
+        wasCompressed: true,
+    };
+}
+// ============================================================================
 // Summarization
 // ============================================================================
 const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
@@ -407,7 +805,12 @@ Use this EXACT format:
 - [Any data, examples, or references needed to continue]
 - [Or "(none)" if not applicable]
 
-Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+## Resume Handoff
+- **First action**: [Single concrete next action after compaction]
+- **Re-check before editing**: [Workspace state, files, or commands to verify first; use "(none)" if not needed]
+- **Evidence status**: [Checks/tests already run and results, or "(not run)"]
+
+Keep each section concise. Preserve exact file paths, function names, command results, and error messages.`;
 const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
 
 Update the existing structured summary with new information. RULES:
@@ -445,7 +848,150 @@ Use this EXACT format:
 ## Critical Context
 - [Preserve important context, add new if needed]
 
-Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+## Resume Handoff
+- **First action**: [Single concrete next action after compaction]
+- **Re-check before editing**: [Workspace state, files, or commands to verify first; use "(none)" if not needed]
+- **Evidence status**: [Checks/tests already run and results, or "(not run)"]
+
+Keep each section concise. Preserve exact file paths, function names, command results, and error messages.`;
+const REQUIRED_SUMMARY_SECTIONS = [
+    "## Goal",
+    "## Constraints & Preferences",
+    "## Progress",
+    "### Done",
+    "### In Progress",
+    "### Blocked",
+    "## Key Decisions",
+    "## Next Steps",
+    "## Critical Context",
+    "## Resume Handoff",
+];
+export function parseCompactionSummary(summary) {
+    const sections = {};
+    for (const heading of REQUIRED_SUMMARY_SECTIONS) {
+        const value = extractSection(summary, heading);
+        if (value !== undefined)
+            sections[heading] = value;
+    }
+    return {
+        sections,
+        missingSections: REQUIRED_SUMMARY_SECTIONS.filter((heading) => sections[heading] === undefined),
+    };
+}
+function extractSection(summary, heading) {
+    const start = summary.indexOf(heading);
+    if (start < 0)
+        return undefined;
+    const nextHeading = summary.slice(start + heading.length).search(/\n#{2,3}\s/);
+    if (nextHeading < 0)
+        return summary.slice(start + heading.length).trim();
+    return summary.slice(start + heading.length, start + heading.length + nextHeading).trim();
+}
+function extractCriticalFactsFromText(text, limit = 12) {
+    return text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && scoreSummaryLine(line) >= 4)
+        .slice(0, limit);
+}
+export function createEmergencyCompactionHandoff(options) {
+    const facts = options.fallbackFacts ?? extractCriticalFactsFromText(options.conversationText, 16);
+    const previousBlocked = options.previousSummary
+        ? (extractSection(options.previousSummary, "### Blocked") ??
+            extractSection(options.previousSummary, "## Blocked"))
+        : undefined;
+    return [
+        "## Goal",
+        "Deterministic emergency compaction handoff because normal summarization could exceed context budget.",
+        "",
+        "## Constraints & Preferences",
+        `- Emergency reason: ${options.reason}`,
+        "- Preserve exact paths, commands, blockers, and evidence before continuing.",
+        "",
+        "## Progress",
+        "### Done",
+        "- [x] Created emergency handoff without calling the summarization model.",
+        "",
+        "### In Progress",
+        "- [ ] Re-check workspace state and continue from critical facts.",
+        "",
+        "### Blocked",
+        previousBlocked && previousBlocked.length > 0 ? previousBlocked : "- (none)",
+        "",
+        "## Key Decisions",
+        "- **Emergency handoff**: Avoided forced minimum input budget that could overflow the model context.",
+        "",
+        "## Next Steps",
+        "1. Re-check workspace state before editing.",
+        "2. Resume from Critical Context and run verification before completion.",
+        "",
+        "## Critical Context",
+        formatFallbackFacts(facts),
+        "",
+        "## Resume Handoff",
+        "- **First action**: Re-check workspace state and relevant files from Critical Context.",
+        "- **Re-check before editing**: git status and target file contents.",
+        "- **Evidence status**: emergency handoff generated; downstream checks not run by compaction.",
+    ].join("\n");
+}
+function formatFallbackFacts(fallbackFacts) {
+    if (!fallbackFacts || fallbackFacts.length === 0)
+        return "- (not captured)";
+    return fallbackFacts.map((fact) => `- ${fact}`).join("\n");
+}
+export function validateCompactionSummaryContract(summary, options = {}) {
+    const trimmedSummary = summary.trim();
+    const missingSections = REQUIRED_SUMMARY_SECTIONS.filter((section) => !trimmedSummary.includes(section));
+    const previousBlocked = options.previousSummary
+        ? (extractSection(options.previousSummary, "### Blocked") ??
+            extractSection(options.previousSummary, "## Blocked"))
+        : undefined;
+    const shouldPreservePreviousBlocked = previousBlocked !== undefined && previousBlocked.length > 0 && !trimmedSummary.includes(previousBlocked);
+    if (missingSections.length === 0 && !shouldPreservePreviousBlocked) {
+        return { summary: trimmedSummary, wasRepaired: false, missingSections: [] };
+    }
+    const repairedSections = [trimmedSummary || "## Goal\n(not captured)"];
+    if (!trimmedSummary.includes("## Constraints & Preferences")) {
+        repairedSections.push("## Constraints & Preferences\n- (not captured)");
+    }
+    if (!trimmedSummary.includes("## Progress")) {
+        repairedSections.push("## Progress");
+    }
+    if (!trimmedSummary.includes("### Done")) {
+        repairedSections.push("### Done\n- [x] (not captured)");
+    }
+    if (!trimmedSummary.includes("### In Progress")) {
+        repairedSections.push("### In Progress\n- [ ] Continue from preserved context");
+    }
+    if (!trimmedSummary.includes("### Blocked")) {
+        repairedSections.push(`### Blocked\n${previousBlocked && previousBlocked.length > 0 ? previousBlocked : "- (none)"}`);
+    }
+    else if (shouldPreservePreviousBlocked) {
+        repairedSections.push(`### Blocked\n${previousBlocked}`);
+    }
+    if (!trimmedSummary.includes("## Key Decisions")) {
+        repairedSections.push("## Key Decisions\n- **Preserved context**: Summary contract repaired deterministically.");
+    }
+    if (!trimmedSummary.includes("## Next Steps")) {
+        repairedSections.push("## Next Steps\n1. Re-check workspace state before editing.");
+    }
+    if (!trimmedSummary.includes("## Critical Context")) {
+        repairedSections.push(`## Critical Context\n${formatFallbackFacts(options.fallbackFacts)}`);
+    }
+    if (!trimmedSummary.includes("## Resume Handoff")) {
+        repairedSections.push([
+            "## Resume Handoff",
+            "- **First action**: Re-check workspace state and continue the latest requested task.",
+            "- **Re-check before editing**: git status and relevant files from Critical Context.",
+            "- **Evidence status**: (not run)",
+        ].join("\n"));
+    }
+    return {
+        summary: repairedSections.join("\n\n"),
+        wasRepaired: true,
+        missingSections,
+    };
+}
 function createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel) {
     const options = { maxTokens, signal, apiKey, headers };
     if (model.reasoning && thinkingLevel && thinkingLevel !== "off") {
@@ -464,7 +1010,7 @@ async function completeSummarization(model, context, options, streamFn) {
  * Generate a summary of the conversation using the LLM.
  * If previousSummary is provided, uses the update prompt to merge.
  */
-export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn) {
+export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, summaryInputTokens) {
     const maxTokens = Math.min(Math.floor(0.8 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
     // Use update prompt if we have a previous summary, otherwise initial prompt
     let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
@@ -475,8 +1021,37 @@ export async function generateSummary(currentMessages, model, reserveTokens, api
     // Convert to LLM messages first (handles custom types like bashExecution, custom, etc.)
     const llmMessages = convertToLlm(currentMessages);
     const conversationText = serializeConversation(llmMessages);
+    const summaryInputBudgetResolution = resolveSummaryInputTokenBudgetV3(model, maxTokens, {
+        configuredSummaryInputTokens: summaryInputTokens,
+        basePrompt,
+        previousSummary,
+        systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
+        wrapperText: "<conversation></conversation><previous-summary></previous-summary>",
+    });
+    if (summaryInputBudgetResolution.emergency) {
+        const summary = createEmergencyCompactionHandoff({
+            reason: summaryInputBudgetResolution.reason ?? "summary input budget unavailable",
+            conversationText,
+            previousSummary,
+        });
+        recordHarnessControlEvent("compaction.summary.generated", "completed", {
+            model: model.id,
+            provider: model.provider,
+            maxTokens,
+            emergency: true,
+            reason: summaryInputBudgetResolution.reason,
+            fixedPromptTokens: summaryInputBudgetResolution.fixedPromptTokens,
+            availableInputTokens: summaryInputBudgetResolution.availableInputTokens,
+        });
+        return validateCompactionSummaryContract(summary, {
+            previousSummary,
+            fallbackFacts: extractCriticalFactsFromText(conversationText),
+        }).summary;
+    }
+    const summaryInputBudget = summaryInputBudgetResolution.budgetTokens;
+    const packedConversation = packSummaryInputForTokenBudget(conversationText, summaryInputBudget);
     // Build the prompt with conversation wrapped in tags
-    let promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;
+    let promptText = `<conversation>\n${packedConversation.text}\n</conversation>\n\n`;
     if (previousSummary) {
         promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
     }
@@ -497,7 +1072,22 @@ export async function generateSummary(currentMessages, model, reserveTokens, api
         .filter((c) => c.type === "text")
         .map((c) => c.text)
         .join("\n");
-    return textContent;
+    const validation = validateCompactionSummaryContract(textContent, {
+        previousSummary,
+        fallbackFacts: extractCriticalFactsFromText(conversationText),
+    });
+    recordHarnessControlEvent("compaction.summary.generated", "completed", {
+        model: model.id,
+        provider: model.provider,
+        maxTokens,
+        summaryInputBudget,
+        packedTokens: packedConversation.packedTokens,
+        omittedTokens: packedConversation.omittedTokens,
+        wasCompressed: packedConversation.wasCompressed,
+        wasRepaired: validation.wasRepaired,
+        missingSections: validation.missingSections,
+    });
+    return validation.summary;
 }
 export function prepareCompaction(pathEntries, settings) {
     if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {
@@ -595,16 +1185,16 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
         // Generate both summaries in parallel
         const [historyResult, turnPrefixResult] = await Promise.all([
             messagesToSummarize.length > 0
-                ? generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn)
+                ? generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, settings.summaryInputTokens)
                 : Promise.resolve("No prior history."),
-            generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn),
+            generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn, settings.summaryInputTokens),
         ]);
         // Merge into single summary
         summary = `${historyResult}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult}`;
     }
     else {
         // Just generate history summary
-        summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn);
+        summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, settings.summaryInputTokens);
     }
     // Compute file lists and append to summary
     const { readFiles, modifiedFiles } = computeFileLists(fileOps);
@@ -622,11 +1212,17 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
 /**
  * Generate a summary for a turn prefix (when splitting a turn).
  */
-async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn) {
+async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn, summaryInputTokens) {
     const maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY); // Smaller budget for turn prefix
     const llmMessages = convertToLlm(messages);
     const conversationText = serializeConversation(llmMessages);
-    const promptText = `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
+    const packedConversation = packSummaryInputForTokenBudget(conversationText, resolveSummaryInputTokenBudget(model, maxTokens, {
+        configuredSummaryInputTokens: summaryInputTokens,
+        basePrompt: TURN_PREFIX_SUMMARIZATION_PROMPT,
+        systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
+        wrapperText: "<conversation></conversation>",
+    }));
+    const promptText = `<conversation>\n${packedConversation.text}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
     const summarizationMessages = [
         {
             role: "user",