pi-smart-compact 9.6.0 → 9.6.2

package/dist/index.js

@@ -3,11 +3,11 @@ var __require = import.meta.require;
 
 // src/index.ts
 import {
-  convertToLlm as convertToLlm4
+  convertToLlm as convertToLlm5
 } from "@earendil-works/pi-coding-agent";
 
 // src/constants.ts
-var VERSION = "9.6.0";
+var VERSION = "9.6.2";
 var CHARS_PER_TOKEN = 3.8;
 var MIN_COMPACTION_SAVING_RATIO = 0.1;
 var ESTIMATOR_ROUNDING_TOLERANCE_TOKENS = 1;
@@ -1455,38 +1455,117 @@ function buildPathNeedles(filePath) {
   }
   return needles;
 }
-function buildUniquePathNeedles(filePath, allPaths) {
-  const normalized = allPaths.map(normalizePath);
+var MAX_INDEXED_SUFFIX_CHARS = 1024;
+function buildPathNeedleOwnershipIndex(allPaths) {
+  const owners = new Map;
+  const normalizedPaths = allPaths.map(normalizePath);
+  let hasUnindexedSuffixes = false;
+  for (const normalized of normalizedPaths) {
+    const suffixes = new Set([normalized]);
+    for (let index = 0;index < normalized.length; index++) {
+      if (normalized[index] !== "/")
+        continue;
+      if (normalized.length - index - 1 <= MAX_INDEXED_SUFFIX_CHARS) {
+        suffixes.add(normalized.slice(index + 1));
+      } else {
+        hasUnindexedSuffixes = true;
+      }
+    }
+    for (const suffix of suffixes) {
+      owners.set(suffix, (owners.get(suffix) ?? 0) + 1);
+    }
+  }
+  return { counts: owners, normalizedPaths, hasUnindexedSuffixes };
+}
+function buildUniquePathNeedlesFromIndex(filePath, owners) {
   return buildPathNeedles(filePath).filter((needle) => {
-    let owners = 0;
-    for (const candidate of normalized) {
+    if (!owners.hasUnindexedSuffixes)
+      return owners.counts.get(needle) === 1;
+    let count = 0;
+    for (const candidate of owners.normalizedPaths) {
       if (candidate === needle || candidate.endsWith("/" + needle))
-        owners++;
-      if (owners > 1)
+        count++;
+      if (count > 1)
         return false;
     }
-    return owners === 1;
+    return count === 1;
   });
 }
-function isKnownPathReference(ref, knownPaths) {
-  const normalizedRef = normalizePath(ref).replace(/^\/+/, "");
-  if (!normalizedRef)
-    return false;
-  const pathShaped = normalizedRef.includes("/");
-  return knownPaths.some((path3) => {
+var PATH_CANDIDATE_CHAR_RE = /[\w./-]/;
+function buildKnownPathReferenceIndex(knownPaths) {
+  const segmentSuffixes = new Set;
+  const boundarySuffixes = new Set;
+  const normalizedPaths = [];
+  let hasUnindexedSuffixes = false;
+  for (const path3 of knownPaths) {
     const normalizedPath = normalizePath(path3).replace(/^\/+/, "");
+    if (!normalizedPath)
+      continue;
+    normalizedPaths.push(normalizedPath);
+    segmentSuffixes.add(normalizedPath);
+    for (let index = 0;index < normalizedPath.length; index++) {
+      if (normalizedPath[index] === "/") {
+        if (normalizedPath.length - index - 1 <= MAX_INDEXED_SUFFIX_CHARS) {
+          segmentSuffixes.add(normalizedPath.slice(index + 1));
+        } else {
+          hasUnindexedSuffixes = true;
+        }
+      }
+      if (index > 0 && !PATH_CANDIDATE_CHAR_RE.test(normalizedPath[index - 1])) {
+        if (normalizedPath.length - index <= MAX_INDEXED_SUFFIX_CHARS) {
+          boundarySuffixes.add(normalizedPath.slice(index));
+        } else {
+          hasUnindexedSuffixes = true;
+        }
+      }
+    }
+  }
+  return {
+    segmentSuffixes,
+    sortedSegmentSuffixes: [...segmentSuffixes].sort(),
+    boundarySuffixes,
+    normalizedPaths,
+    hasUnindexedSuffixes
+  };
+}
+function matchesKnownPathReference(normalizedRef, normalizedPaths) {
+  const pathShaped = normalizedRef.includes("/");
+  return normalizedPaths.some((normalizedPath) => {
     if (normalizedPath === normalizedRef || normalizedPath.endsWith("/" + normalizedRef))
       return true;
     if (normalizedPath.endsWith(normalizedRef)) {
       const boundary = normalizedPath[normalizedPath.length - normalizedRef.length - 1];
-      if (boundary && !/[\w./-]/.test(boundary))
+      if (boundary && !PATH_CANDIDATE_CHAR_RE.test(boundary))
         return true;
     }
     if (!pathShaped)
       return false;
-    return normalizedPath.split("/").some((_, index, parts) => parts.slice(index).join("/").startsWith(normalizedRef + "/"));
+    return normalizedPath.startsWith(normalizedRef + "/") || normalizedPath.includes("/" + normalizedRef + "/");
   });
 }
+function sortedHasPrefix(values, prefix) {
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (values[middle] < prefix)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return values[low]?.startsWith(prefix) ?? false;
+}
+function isKnownPathReferenceInIndex(ref, index) {
+  const normalizedRef = normalizePath(ref).replace(/^\/+/, "");
+  if (!normalizedRef)
+    return false;
+  if (index.segmentSuffixes.has(normalizedRef) || index.boundarySuffixes.has(normalizedRef)) {
+    return true;
+  }
+  if (normalizedRef.includes("/") && sortedHasPrefix(index.sortedSegmentSuffixes, normalizedRef + "/"))
+    return true;
+  return index.hasUnindexedSuffixes ? matchesKnownPathReference(normalizedRef, index.normalizedPaths) : false;
+}
 
 // src/domain/tool-semantics.ts
 var PATH_KEYS = [
@@ -1704,8 +1783,12 @@ function classifyToolOperation(args, toolName) {
 function stableValue(value) {
   if (Array.isArray(value))
     return value.map(stableValue);
-  if (!value || typeof value !== "object")
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
     return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value !== "object")
+    return;
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stableValue(item)]));
 }
 function commandIdentity(args) {
@@ -1778,16 +1861,8 @@ function findLastAnchorIndex(branchEntries) {
   return -1;
 }
 function branchIndexToMsgIndex(branchEntries, branchIdx, msgs) {
-  let msgCount = 0;
-  for (let i = 0;i <= branchIdx && i < branchEntries.length; i++) {
-    const e = branchEntries[i];
-    if (e?.type === "message") {
-      if (msgCount >= msgs.length)
-        return msgs.length - 1;
-      msgCount++;
-    }
-  }
-  return Math.max(0, Math.min(msgCount - 1, msgs.length - 1));
+  const id = branchEntries[branchIdx]?.id;
+  return Math.max(0, msgs.findIndex((entry) => entry.id === id));
 }
 function smartKeepBoundaryCandidates(msgs, keepFromIndex, branchEntries) {
   const candidates = [];
@@ -2091,7 +2166,12 @@ function buildExplorationContext(report) {
 // src/utils/file-ref-detect.ts
 var CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs|rs|py|go|java|rb|cs|cpp|c|h|hpp|swift|kt|scala|php|css|scss|html|json|yaml|yml|toml|md|mdx|sh|sql|tf|ini|env|lock|gradle|xml)$/i;
 var VERSION_RE = /^v?\d+(?:\.\d+)+(?:[-+][\w.-]+)?$/i;
-var FILE_REF_CANDIDATE_RE = /[\w.\/-]+\.[\w]+/g;
+function isAsciiWordCode(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code === 95 || code >= 97 && code <= 122;
+}
+function isCandidateCode(code) {
+  return isAsciiWordCode(code) || code === 45 || code === 46 || code === 47;
+}
 function isLikelyFileRef(candidate) {
   if (candidate.startsWith("//") || VERSION_RE.test(candidate))
     return false;
@@ -2102,13 +2182,32 @@ function isLikelyFileRef(candidate) {
   return CODE_EXT_RE.test(candidate);
 }
 function extractFileRefs(summary) {
-  const matcher = new RegExp(FILE_REF_CANDIDATE_RE.source, FILE_REF_CANDIDATE_RE.flags);
   const refs = [];
-  for (const match of summary.matchAll(matcher)) {
-    if (/[\\/]/.test(summary[(match.index ?? 0) + match[0].length] ?? ""))
+  let cursor = 0;
+  while (cursor < summary.length) {
+    while (cursor < summary.length && !isCandidateCode(summary.charCodeAt(cursor)))
+      cursor++;
+    const runStart = cursor;
+    while (cursor < summary.length && isCandidateCode(summary.charCodeAt(cursor)))
+      cursor++;
+    const runEnd = cursor;
+    let extensionDot = -1;
+    for (let index = runStart + 1;index + 1 < runEnd; index++) {
+      if (summary.charCodeAt(index) === 46 && isAsciiWordCode(summary.charCodeAt(index + 1))) {
+        extensionDot = index;
+      }
+    }
+    if (extensionDot < 0)
       continue;
-    if (isLikelyFileRef(match[0]))
-      refs.push(match[0]);
+    let matchEnd = extensionDot + 2;
+    while (matchEnd < runEnd && isAsciiWordCode(summary.charCodeAt(matchEnd))) {
+      matchEnd++;
+    }
+    const candidate = summary.slice(runStart, matchEnd);
+    if (/[\\/]/.test(summary[matchEnd] ?? ""))
+      continue;
+    if (isLikelyFileRef(candidate))
+      refs.push(candidate);
   }
   return refs;
 }
@@ -3709,6 +3808,190 @@ function getDefaultServices() {
   return _default;
 }
 
+// src/domain/telemetry.ts
+function errorFields(error2, seen = new Set) {
+  if (!error2 || typeof error2 !== "object") {
+    return { name: "", message: String(error2 ?? ""), status: null, code: "" };
+  }
+  if (seen.has(error2) || seen.size >= 8)
+    return { name: "", message: "", status: null, code: "" };
+  seen.add(error2);
+  const value = error2;
+  const cause = value.cause ? errorFields(value.cause, seen) : null;
+  const numericStatus = Number(value.status ?? value.statusCode);
+  return {
+    name: typeof value.name === "string" ? value.name : cause?.name ?? "",
+    message: (typeof value.message === "string" ? value.message : "") + (cause?.message ? " " + cause.message : ""),
+    status: Number.isFinite(numericStatus) ? numericStatus : cause?.status ?? null,
+    code: typeof value.code === "string" ? value.code : cause?.code ?? ""
+  };
+}
+function classifyTelemetryFailure(error2, timedOut = false) {
+  const fields = errorFields(error2);
+  const text = (fields.name + " " + fields.code + " " + fields.message).toLowerCase();
+  if (timedOut)
+    return "timeout";
+  if (/max(?:imum)? output|output.?limit|visible[ -]output|length limit/.test(text))
+    return "output-limit";
+  if (/timeout|timed out|watchdog|deadline/.test(text))
+    return "timeout";
+  if (fields.name.toLowerCase() === "verificationgateerror")
+    return "verification";
+  if (fields.name.toLowerCase() === "yieldgateerror")
+    return "yield";
+  if (/budgetexceeded|token budget|call budget|latency budget/.test(text))
+    return "budget";
+  if (fields.status === 429 || /rate.?limit|too many requests|quota/.test(text))
+    return "rate-limit";
+  if (fields.status === 401 || fields.status === 403 || /unauthori[sz]ed|authentication|api.?key|credential/.test(text))
+    return "authentication";
+  if (/abort|cancel/.test(text))
+    return "cancelled";
+  if (/native compaction|persist|write|rename|filesystem|sqlite|database/.test(text))
+    return "persistence";
+  if (/verificationgateerror|verification gate|verification.*(?:gap|summary)/.test(text))
+    return "verification";
+  if (/invalid|validation|schema|malformed|required/.test(text))
+    return "validation";
+  if (fields.status != null && fields.status >= 500 || /provider|api error|stream|network|fetch failed|socket/.test(text))
+    return "provider";
+  return "internal";
+}
+function p95(values) {
+  if (!values.length)
+    return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.max(0, Math.ceil(sorted.length * 0.95) - 1)] ?? 0;
+}
+function stats(entries, damage) {
+  const evidence = entries.filter((entry) => entry.status !== "dry-run");
+  const successfulRuns = evidence.filter((entry) => entry.status === "success");
+  const quality = successfulRuns.filter((entry) => typeof entry.verificationScore === "number");
+  const appliedRunIds = new Set(successfulRuns.filter((entry) => typeof entry.runId === "string" && entry.runId.length >= 8).map((entry) => entry.runId));
+  const observedScores = new Map;
+  for (const observation of damage) {
+    if (!observation.runId || !appliedRunIds.has(observation.runId) || typeof observation.damageScore !== "number" || !Number.isFinite(observation.damageScore))
+      continue;
+    observedScores.set(observation.runId, Math.max(observedScores.get(observation.runId) ?? 0, Math.max(0, Math.min(100, observation.damageScore))));
+  }
+  const damaging = [...observedScores.values()].filter((score) => score > 0).length;
+  return {
+    runs: entries.length,
+    appliedRuns: evidence.length,
+    successRate: evidence.length ? successfulRuns.length / evidence.length : 1,
+    avgQuality: quality.length ? quality.reduce((sum, entry) => sum + (entry.verificationScore ?? 0), 0) / quality.length : null,
+    qualityCoverage: evidence.length ? quality.length / evidence.length : 0,
+    p95LatencyMs: p95(evidence.map((entry) => entry.durationMs ?? entry.avgLatency).filter(Number.isFinite)),
+    avgTokens: evidence.length ? evidence.reduce((sum, entry) => sum + entry.totalInput + entry.totalCacheHit + (entry.totalCacheWrite ?? 0) + entry.totalOutput, 0) / evidence.length : 0,
+    fallbackRate: evidence.length ? evidence.filter((entry) => entry.method === "heuristic" || Array.isArray(entry.providerRoutes) && entry.providerRoutes.some((route) => route.successes < route.calls)).length / evidence.length : 0,
+    damageRate: observedScores.size ? damaging / observedScores.size : 0,
+    damageCoverage: successfulRuns.length ? observedScores.size / successfulRuns.length : 0
+  };
+}
+function roundStats(value) {
+  return {
+    ...value,
+    successRate: Math.round(value.successRate * 1000) / 1000,
+    avgQuality: value.avgQuality == null ? null : Math.round(value.avgQuality * 10) / 10,
+    qualityCoverage: Math.round(value.qualityCoverage * 1000) / 1000,
+    p95LatencyMs: Math.round(value.p95LatencyMs),
+    avgTokens: Math.round(value.avgTokens),
+    fallbackRate: Math.round(value.fallbackRate * 1000) / 1000,
+    damageRate: Math.round(value.damageRate * 1000) / 1000,
+    damageCoverage: Math.round(value.damageCoverage * 1000) / 1000
+  };
+}
+function assessCanary(entries, damageEntries, options) {
+  const minCanaryRuns = Math.max(5, options.minCanaryRuns ?? 20);
+  const canaryEntries = entries.filter((entry) => entry.metricsSchemaVersion === 2 && entry.version === options.version && entry.releaseChannel === "canary").slice(-Math.max(100, minCanaryRuns));
+  const baselineEntries = entries.filter((entry) => entry.metricsSchemaVersion === 2 && (entry.releaseChannel ?? "stable") === "stable").slice(-(options.baselineRuns ?? Math.max(50, minCanaryRuns * 2)));
+  const baseline = stats(baselineEntries, damageEntries);
+  const canary = stats(canaryEntries, damageEntries);
+  const triggers = [];
+  const failureBaseline = 1 - baseline.successRate;
+  const failureCanary = 1 - canary.successRate;
+  if (canary.appliedRuns >= 3 && (failureCanary > 0.050001 || failureCanary - failureBaseline >= 0.050001)) {
+    triggers.push({
+      metric: "failure-rate",
+      baseline: failureBaseline,
+      canary: failureCanary,
+      threshold: failureCanary > 0.050001 ? ">5% absolute" : "+5pp regression"
+    });
+  }
+  if (canary.avgQuality != null && (canary.avgQuality < 85 || baseline.avgQuality != null && baseline.avgQuality - canary.avgQuality >= 5)) {
+    triggers.push({
+      metric: "quality",
+      baseline: baseline.avgQuality ?? 0,
+      canary: canary.avgQuality,
+      threshold: canary.avgQuality < 85 ? "<85 absolute" : "-5 points"
+    });
+  }
+  if (baseline.p95LatencyMs >= 1000 && canary.p95LatencyMs >= baseline.p95LatencyMs * 1.5) {
+    triggers.push({ metric: "latency", baseline: baseline.p95LatencyMs, canary: canary.p95LatencyMs, threshold: "+50% p95" });
+  }
+  if (baseline.avgTokens >= 1000 && canary.avgTokens >= baseline.avgTokens * 1.5) {
+    triggers.push({ metric: "tokens", baseline: baseline.avgTokens, canary: canary.avgTokens, threshold: "+50%" });
+  }
+  if (canary.fallbackRate - baseline.fallbackRate >= 0.1) {
+    triggers.push({ metric: "fallback", baseline: baseline.fallbackRate, canary: canary.fallbackRate, threshold: "+10pp" });
+  }
+  if (canary.damageRate - baseline.damageRate >= 0.1) {
+    triggers.push({ metric: "damage", baseline: baseline.damageRate, canary: canary.damageRate, threshold: "+10pp" });
+  }
+  const canarySampleAdequacy = Math.min(1, canary.appliedRuns / minCanaryRuns);
+  const baselineSampleAdequacy = Math.min(1, baseline.appliedRuns / Math.max(20, minCanaryRuns));
+  const dataConfidence = Math.round(100 * (canarySampleAdequacy * 0.25 + baselineSampleAdequacy * 0.15 + canary.qualityCoverage * canarySampleAdequacy * 0.2 + canary.damageCoverage * canarySampleAdequacy * 0.2 + baseline.damageCoverage * baselineSampleAdequacy * 0.2));
+  const reasons = [];
+  let decision = "hold";
+  if (triggers.length && canary.appliedRuns >= 3) {
+    decision = "rollback";
+    reasons.push(...triggers.map((trigger) => trigger.metric + " crossed " + trigger.threshold));
+  } else if (canary.appliedRuns < minCanaryRuns) {
+    reasons.push("need " + (minCanaryRuns - canary.appliedRuns) + " more canary runs with applied outcomes");
+  } else if (baseline.appliedRuns < Math.max(20, minCanaryRuns)) {
+    reasons.push("stable baseline is too small");
+  } else if (canary.qualityCoverage < 0.7) {
+    reasons.push("schema-v2 quality coverage is below 70%");
+  } else if (canary.damageCoverage < 0.7) {
+    reasons.push("correlated canary damage-observation coverage is below 70%");
+  } else if (baseline.damageCoverage < 0.7) {
+    reasons.push("correlated stable damage-observation coverage is below 70%");
+  } else if ((canary.avgQuality ?? 0) < 85) {
+    reasons.push("absolute verifier quality is below 85");
+  } else if (canary.successRate < 0.949999) {
+    reasons.push("absolute success rate is below 95%");
+  } else {
+    decision = "promote";
+    reasons.push("sample, absolute quality, reliability, latency, token, fallback, and damage gates passed");
+  }
+  return {
+    version: options.version,
+    decision,
+    dataConfidence,
+    baseline: roundStats(baseline),
+    canary: roundStats(canary),
+    triggers,
+    reasons
+  };
+}
+var TELEMETRY_FAILURE_KINDS = new Set([
+  "cancelled",
+  "timeout",
+  "rate-limit",
+  "authentication",
+  "budget",
+  "output-limit",
+  "provider",
+  "persistence",
+  "validation",
+  "verification",
+  "yield",
+  "internal"
+]);
+function isTelemetryFailureKind(value) {
+  return typeof value === "string" && TELEMETRY_FAILURE_KINDS.has(value);
+}
+
 // src/utils/cache.ts
 var INTERNAL_PHASES = new Set([
   "explore-retry",
@@ -3822,7 +4105,8 @@ async function trackedComplete(phase, model, reqBody, opts, services) {
       cacheHitTokens: 0,
       cacheWriteTokens: 0,
       latencyMs: Date.now() - start,
-      success: false
+      success: false,
+      failureKind: classifyTelemetryFailure(err)
     }, svc);
     throw err;
   }
@@ -4430,11 +4714,17 @@ function batchOutputLimit(mode, chunks, providerMax) {
   const budget = MODE_POLICIES[mode].batchOutput;
   return Math.min(Math.max(budget.min, chunks * budget.perChunk), budget.max, providerMax);
 }
-function effectiveBudget(configured, modeDefault) {
+function effectiveBudget(configured, modeDefault, override) {
+  if (override !== undefined && override > 0)
+    return override;
   if (configured <= 0)
     return modeDefault;
   return Math.min(configured, modeDefault);
 }
+function resolveCallBudget(configured, mode, override, automatic = false) {
+  const budget = effectiveBudget(configured, MODE_POLICIES[mode].maxLlmCalls, override);
+  return automatic ? Math.min(budget, AUTO_TRIGGER_MAX_LLM_CALLS) : budget;
+}
 
 // src/ui/overlays.ts
 import { DynamicBorder as DynamicBorder2 } from "@earendil-works/pi-coding-agent";
@@ -4913,6 +5203,27 @@ function readRemediationHints(projectId) {
   return data.files.filter((f) => typeof f === "string");
 }
 
+// src/infra/ai-messages.ts
+import { contentText } from "@earendil-works/pi-ai";
+import { convertToLlm, sessionEntryToContextMessages, serializeConversation } from "@earendil-works/pi-coding-agent";
+function contextMessageEntries(entries) {
+  return entries.flatMap((entry) => convertToLlm(sessionEntryToContextMessages(entry)).map((message) => ({ type: "message", id: entry.id, message })));
+}
+function serializeConversationText(messages) {
+  return asSerializableMessages(messages).map((message) => message.role === "toolResult" ? "[Tool result]: " + contentText(message.content, "") : serializeConversation([message])).filter(Boolean).join(`
+
+`);
+}
+function asBranchMessage(message) {
+  return message;
+}
+function asSerializableMessages(msgs) {
+  return msgs;
+}
+function scrubLlmMessages(msgs, scrubber) {
+  return scrubber.scrubValue(msgs).value;
+}
+
 // src/app/run-context.ts
 function markMeasuredPhase(rc, phase, startMs, endMs = Date.now()) {
   rc.phaseTimings.push({ phase, durationMs: Math.max(0, endMs - startMs) });
@@ -4947,12 +5258,9 @@ function advance(rc, stage) {
   const marker = stage;
   const index = STAGE_ORDER.indexOf(marker);
   const record = rc;
-  const hasStageHistory = STAGE_ORDER.some((candidate) => record[candidate] === true);
-  if (hasStageHistory) {
-    for (let prior = 0;prior < index; prior++) {
-      if (record[STAGE_ORDER[prior]] !== true) {
-        throw new Error("Pipeline stage out of order: " + marker + " requires " + STAGE_ORDER[prior]);
-      }
+  for (let prior = 0;prior < index; prior++) {
+    if (record[STAGE_ORDER[prior]] !== true) {
+      throw new Error("Pipeline stage out of order: " + marker + " requires " + STAGE_ORDER[prior]);
     }
   }
   for (const field of STAGE_REQUIRED_FIELDS[marker]) {
@@ -5138,7 +5446,7 @@ function resolveCompactionWindow(rc) {
   const totalTokens = rc.ctx.getContextUsage()?.tokens ?? 0;
   const manager = rc.ctx.sessionManager;
   const branch = typeof manager.buildContextEntries === "function" ? manager.buildContextEntries() : manager.getBranch();
-  const msgs = branch.filter((entry) => entry.type === "message" && entry.message != null);
+  const msgs = contextMessageEntries(branch);
   if (msgs.length < 3) {
     if (rc.flags.force)
       rc.notify("Manual compaction skipped: fewer than 3 active messages are available.", "warning");
@@ -5224,12 +5532,12 @@ function preparePreflightProfile(input) {
 }
 function prepareManualPreflightContext(ctx, summaryModel, tokenCalibration) {
   const branch = typeof ctx.sessionManager.buildContextEntries === "function" ? ctx.sessionManager.buildContextEntries() : ctx.sessionManager.getBranch();
-  const msgs = branch.filter((entry) => entry.type === "message" && entry.message != null);
+  const msgs = contextMessageEntries(branch);
   const totalTokens = ctx.getContextUsage()?.tokens ?? 0;
   const modelContextWindow = ctx.model?.contextWindow;
   const contextWindowTokens = Number.isFinite(modelContextWindow) && (modelContextWindow ?? 0) > 0 ? modelContextWindow : 0;
   const contextPercent = safeContextPercent(totalTokens, modelContextWindow);
-  const toolPercent = computeToolCharPercentage(branch);
+  const toolPercent = computeToolCharPercentage(msgs);
   const overflowedContext = contextWindowTokens > 0 && totalTokens > contextWindowTokens;
   const estimator = makeTokenEstimator(summaryModel.provider, summaryModel.id, tokenCalibration);
   const messageTokens = msgs.map((entry) => estimator.message(entry.message));
@@ -6118,7 +6426,7 @@ function formatPreflightSummary(preflight, modelLabel, details = false) {
       lines2.push("Estimator  messages ~" + tokenCount(preflight.rawEstimatedMessageTokens) + " \xB7 normalization unavailable", "Route  " + modelLabel + " \xB7 viability " + preflight.reason);
     return lines2;
   }
-  const stateReserve = Math.ceil(plan.summaryBudgetTokens * POST_SUMMARY_RESERVE_RATIO);
+  const stateReserve = Math.max(0, (plan.finalSummaryAllowanceTokens ?? plan.summaryBudgetTokens + Math.ceil(plan.summaryBudgetTokens * POST_SUMMARY_RESERVE_RATIO)) - plan.summaryBudgetTokens);
   const lines = [
     "Plan  " + compactTokenCount(preflight.totalTokens) + " \u2192 ~" + compactTokenCount(plan.projectedAfterTokens) + " \xB7 ~" + compactTokenCount(plan.projectedSavedTokens) + " saved (" + percent(plan.projectedYield * 100) + ")",
     "Keep  ~" + compactTokenCount(plan.retainedTokens) + " recent \xB7 summary up to " + compactTokenCount(plan.summaryBudgetTokens) + " + ~" + compactTokenCount(stateReserve) + " verified-state reserve",
@@ -6298,12 +6606,15 @@ async function showResultScreen(ctx, details, extraction, services, opts = {}) {
       c.addChild(new Text2(theme.fg("text", opts.summary), 2, 0));
       c.addChild(new Text2("", 0, 0));
     }
+    const scrollbarStyle = (text) => theme.fg("borderMuted", text);
     const scroll = new ScrollView(c, {
       follow: "none",
       primary: true,
       overscroll: "contain",
       scrollbar: "auto",
-      scrollbarStyle: (text) => theme.fg("borderMuted", text)
+      scrollbarStyle,
+      scrollbarTrackStyle: scrollbarStyle,
+      scrollbarThumbStyle: scrollbarStyle
     });
     const footer = new Container2;
     footer.addChild(new DynamicBorder2((s) => theme.fg("accent", s)));
@@ -6405,8 +6716,8 @@ async function showCompactUI(ctx, opts) {
             const marker = index === selected ? "\u203A " : "  ";
             const recommendedMark = mode === recommended.mode ? "  recommended" : "             ";
             const trait = mode === "fast" ? "quickest" : mode === "balanced" ? "default" : "deepest";
-            const stats = (viable && plan ? "~" + compactTokenCount(plan.projectedAfterTokens) + " after \xB7 " + percent(plan.projectedYield * 100) + " saved" : "unavailable \xB7 " + explainPreflightReason(preview.reason)) + " \xB7 " + trait;
-            const line = " " + marker + MODE_LABELS[mode].padEnd(9) + recommendedMark + "  " + stats;
+            const stats2 = (viable && plan ? "~" + compactTokenCount(plan.projectedAfterTokens) + " after \xB7 " + percent(plan.projectedYield * 100) + " saved" : "unavailable \xB7 " + explainPreflightReason(preview.reason)) + " \xB7 " + trait;
+            const line = " " + marker + MODE_LABELS[mode].padEnd(9) + recommendedMark + "  " + stats2;
             lines.push(cell(index === selected ? theme.fg("accent", theme.bold(line)) : theme.fg(viable ? mode === recommended.mode ? "success" : "text" : "muted", line)));
           }
           lines.push(divider);
@@ -6499,8 +6810,8 @@ async function prepareRun(rc) {
     rc.timeoutMs = rc.timeoutMs > 0 ? Math.min(rc.timeoutMs, config.maxLatencyMs) : config.maxLatencyMs;
   }
   const policy = MODE_POLICIES[rc.mode];
-  const callBudget = rc.maxLlmCalls ?? effectiveBudget(config.maxLlmCalls, policy.maxLlmCalls);
-  const inputBudget = rc.maxLlmInputTokens ?? effectiveBudget(config.maxLlmInputTokens, policy.maxInputTokens);
+  const callBudget = resolveCallBudget(config.maxLlmCalls, rc.mode, rc.maxLlmCalls, rc.flags.autoTriggered && !rc.flags.skipCompact);
+  const inputBudget = effectiveBudget(config.maxLlmInputTokens, policy.maxInputTokens, rc.maxLlmInputTokens);
   rc.services.budget = new BudgetGuard(callBudget, rc.timeoutMs, rc.services.clock, inputBudget, policy.maxOutputTokens);
   if (rc.timeoutMs > 0) {
     rc.cancellation.timeoutId = setTimeout(() => {
@@ -6520,24 +6831,13 @@ async function prepareRun(rc) {
 }
 
 // src/app/steps/recover.ts
-import { convertToLlm as convertToLlm2 } from "@earendil-works/pi-coding-agent";
-
-// src/infra/ai-messages.ts
-function asBranchMessage(message) {
-  return message;
-}
-function asSerializableMessages(msgs) {
-  return msgs;
-}
-function scrubLlmMessages(msgs, scrubber) {
-  return scrubber.scrubValue(msgs).value;
-}
+import { convertToLlm as convertToLlm3 } from "@earendil-works/pi-coding-agent";
 
 // src/utils/session-log.ts
 import * as fs6 from "fs";
 import * as path10 from "path";
 import { StringDecoder } from "string_decoder";
-import { convertToLlm } from "@earendil-works/pi-coding-agent";
+import { convertToLlm as convertToLlm2 } from "@earendil-works/pi-coding-agent";
 function getSessionsDir() {
   return sessionsDir();
 }
@@ -6672,10 +6972,10 @@ async function readOriginalMessageMap(sessionId, wantedIds, cwd) {
       } catch {
         continue;
       }
-      if (entry.type !== "message" || !entry.id || !remaining.has(entry.id) || !entry.message)
+      if (!entry.id || !remaining.has(entry.id))
         continue;
       remaining.delete(entry.id);
-      const normalized = normalizeLogMessage(entry.message, entry.timestamp);
+      const normalized = entry.type === "message" && entry.message ? normalizeLogMessage(entry.message, entry.timestamp) : contextMessageEntries([entry])[0]?.message;
       if (normalized)
         map.set(entry.id, normalized);
       if (remaining.size === 0)
@@ -6705,7 +7005,7 @@ async function resolveCompactionMessages(sessionId, toCompactEntries, cwd) {
   for (const entry of toCompactEntries) {
     if (!entry.id)
       continue;
-    const converted = convertToLlm([
+    const converted = convertToLlm2([
       asBranchMessage(entry.message)
     ]);
     if (!converted.length)
@@ -6730,7 +7030,7 @@ async function recoverSessionLog(rc) {
   let resolved = rc.toCompact.flatMap((entry) => {
     if (!entry.id)
       return [];
-    return convertToLlm2([asBranchMessage(entry.message)]).map((message) => ({ entryId: entry.id, message }));
+    return convertToLlm3([asBranchMessage(entry.message)]).map((message) => ({ entryId: entry.id, message }));
   });
   if (hasTruncatedMessages(resolved.map((item) => item.message))) {
     const fromLog = await resolveCompactionMessages(rc.sessionId, rc.toCompact, rc.ctx.cwd);
@@ -6747,7 +7047,7 @@ async function recoverSessionLog(rc) {
 
 // src/app/steps/tier.ts
 function selectTier(rc) {
-  const toolPercent = computeToolCharPercentage(rc.branch);
+  const toolPercent = computeToolCharPercentage(rc.msgs);
   const tier = rc.flags.overflowRecovery ? "full" : rc.flags.force ? rc.contextPercent >= 80 ? "full" : "light" : selectCompactionTier(rc.contextPercent, rc.totalTokens, MIN_TOKEN_THRESHOLD, rc.config.minContextPercent);
   if (tier === "none") {
     if (!rc.flags.autoTriggered) {
@@ -6914,9 +7214,6 @@ function pruneRedundant(msgs, precomputedTcIdx) {
   };
 }
 
-// src/app/steps/extract.ts
-import { serializeConversation } from "@earendil-works/pi-coding-agent";
-
 // src/utils/backups.ts
 import fs7 from "fs";
 import path11 from "path";
@@ -7142,7 +7439,7 @@ function extractWithCache(rc) {
   const pruneEnd = Date.now();
   markMeasuredPhase(rc, "prune", extractStepStart, pruneEnd);
   const extractionStart = pruneEnd;
-  const convText = rc.services.scrubber.scrubText(serializeConversation(asSerializableMessages(rc.llmMessages))).value;
+  const convText = rc.services.scrubber.scrubText(serializeConversationText(rc.llmMessages)).value;
   const convTokens = rc.estimator.text(convText);
   let preparedBackup;
   if (rc.config.backupEnabled) {
@@ -7150,7 +7447,7 @@ function extractWithCache(rc) {
       if (pruningUnchanged)
         return convText;
       const safeMessages = scrubLlmMessages(selectedMessages, rc.services.scrubber);
-      const backupText = serializeConversation(asSerializableMessages(safeMessages));
+      const backupText = serializeConversationText(safeMessages);
       const scrubbed = rc.services.scrubber.scrubText(backupText);
       if (scrubbed.findings.length > 0) {
         rc.notify("Backup written with redactions (" + scrubbed.findings.map((f) => f.count + "x " + f.kind).join(", ") + ") \u2014 restore will lack that data", "info");
@@ -7257,187 +7554,6 @@ function extractWithCache(rc) {
 
 // src/phases/explore.ts
 import { Type } from "typebox";
-
-// src/domain/telemetry.ts
-function errorFields(error2) {
-  if (!error2 || typeof error2 !== "object") {
-    return { name: "", message: String(error2 ?? ""), status: null, code: "" };
-  }
-  const value = error2;
-  const cause = value.cause && value.cause !== error2 ? errorFields(value.cause) : null;
-  const numericStatus = Number(value.status ?? value.statusCode);
-  return {
-    name: typeof value.name === "string" ? value.name : cause?.name ?? "",
-    message: (typeof value.message === "string" ? value.message : "") + (cause?.message ? " " + cause.message : ""),
-    status: Number.isFinite(numericStatus) ? numericStatus : cause?.status ?? null,
-    code: typeof value.code === "string" ? value.code : cause?.code ?? ""
-  };
-}
-function classifyTelemetryFailure(error2, timedOut = false) {
-  const fields = errorFields(error2);
-  const text = (fields.name + " " + fields.code + " " + fields.message).toLowerCase();
-  if (timedOut || /timeout|timed out|watchdog|deadline/.test(text))
-    return "timeout";
-  if (fields.name.toLowerCase() === "verificationgateerror")
-    return "verification";
-  if (fields.name.toLowerCase() === "yieldgateerror")
-    return "yield";
-  if (/budgetexceeded|token budget|call budget|latency budget/.test(text))
-    return "budget";
-  if (fields.status === 429 || /rate.?limit|too many requests|quota/.test(text))
-    return "rate-limit";
-  if (fields.status === 401 || fields.status === 403 || /unauthori[sz]ed|authentication|api.?key|credential/.test(text))
-    return "authentication";
-  if (/max(?:imum)? output|output.?limit|visible output|length limit/.test(text))
-    return "output-limit";
-  if (/abort|cancel/.test(text))
-    return "cancelled";
-  if (/native compaction|persist|write|rename|filesystem|sqlite|database/.test(text))
-    return "persistence";
-  if (/verificationgateerror|verification gate|verification.*(?:gap|summary)/.test(text))
-    return "verification";
-  if (/invalid|validation|schema|malformed|required/.test(text))
-    return "validation";
-  if (fields.status != null && fields.status >= 500 || /provider|api error|stream|network|fetch failed|socket/.test(text))
-    return "provider";
-  return "internal";
-}
-function p95(values) {
-  if (!values.length)
-    return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  return sorted[Math.max(0, Math.ceil(sorted.length * 0.95) - 1)] ?? 0;
-}
-function stats(entries, damage) {
-  const evidence = entries.filter((entry) => entry.status !== "dry-run");
-  const successfulRuns = evidence.filter((entry) => entry.status === "success");
-  const quality = successfulRuns.filter((entry) => typeof entry.verificationScore === "number");
-  const appliedRunIds = new Set(successfulRuns.filter((entry) => typeof entry.runId === "string" && entry.runId.length >= 8).map((entry) => entry.runId));
-  const observedScores = new Map;
-  for (const observation of damage) {
-    if (!observation.runId || !appliedRunIds.has(observation.runId) || typeof observation.damageScore !== "number" || !Number.isFinite(observation.damageScore))
-      continue;
-    observedScores.set(observation.runId, Math.max(observedScores.get(observation.runId) ?? 0, Math.max(0, Math.min(100, observation.damageScore))));
-  }
-  const damaging = [...observedScores.values()].filter((score) => score > 0).length;
-  return {
-    runs: entries.length,
-    appliedRuns: evidence.length,
-    successRate: evidence.length ? successfulRuns.length / evidence.length : 1,
-    avgQuality: quality.length ? quality.reduce((sum, entry) => sum + (entry.verificationScore ?? 0), 0) / quality.length : null,
-    qualityCoverage: evidence.length ? quality.length / evidence.length : 0,
-    p95LatencyMs: p95(evidence.map((entry) => entry.durationMs ?? entry.avgLatency).filter(Number.isFinite)),
-    avgTokens: evidence.length ? evidence.reduce((sum, entry) => sum + entry.totalInput + entry.totalCacheHit + (entry.totalCacheWrite ?? 0) + entry.totalOutput, 0) / evidence.length : 0,
-    fallbackRate: evidence.length ? evidence.filter((entry) => entry.method === "heuristic" || Array.isArray(entry.providerRoutes) && entry.providerRoutes.some((route) => route.successes < route.calls)).length / evidence.length : 0,
-    damageRate: observedScores.size ? damaging / observedScores.size : 0,
-    damageCoverage: successfulRuns.length ? observedScores.size / successfulRuns.length : 0
-  };
-}
-function roundStats(value) {
-  return {
-    ...value,
-    successRate: Math.round(value.successRate * 1000) / 1000,
-    avgQuality: value.avgQuality == null ? null : Math.round(value.avgQuality * 10) / 10,
-    qualityCoverage: Math.round(value.qualityCoverage * 1000) / 1000,
-    p95LatencyMs: Math.round(value.p95LatencyMs),
-    avgTokens: Math.round(value.avgTokens),
-    fallbackRate: Math.round(value.fallbackRate * 1000) / 1000,
-    damageRate: Math.round(value.damageRate * 1000) / 1000,
-    damageCoverage: Math.round(value.damageCoverage * 1000) / 1000
-  };
-}
-function assessCanary(entries, damageEntries, options) {
-  const minCanaryRuns = Math.max(5, options.minCanaryRuns ?? 20);
-  const canaryEntries = entries.filter((entry) => entry.metricsSchemaVersion === 2 && entry.version === options.version && entry.releaseChannel === "canary").slice(-Math.max(100, minCanaryRuns));
-  const baselineEntries = entries.filter((entry) => entry.metricsSchemaVersion === 2 && (entry.releaseChannel ?? "stable") === "stable").slice(-(options.baselineRuns ?? Math.max(50, minCanaryRuns * 2)));
-  const baseline = stats(baselineEntries, damageEntries);
-  const canary = stats(canaryEntries, damageEntries);
-  const triggers = [];
-  const failureBaseline = 1 - baseline.successRate;
-  const failureCanary = 1 - canary.successRate;
-  if (canary.appliedRuns >= 3 && (failureCanary > 0.050001 || failureCanary - failureBaseline >= 0.050001)) {
-    triggers.push({
-      metric: "failure-rate",
-      baseline: failureBaseline,
-      canary: failureCanary,
-      threshold: failureCanary > 0.050001 ? ">5% absolute" : "+5pp regression"
-    });
-  }
-  if (canary.avgQuality != null && (canary.avgQuality < 85 || baseline.avgQuality != null && baseline.avgQuality - canary.avgQuality >= 5)) {
-    triggers.push({
-      metric: "quality",
-      baseline: baseline.avgQuality ?? 0,
-      canary: canary.avgQuality,
-      threshold: canary.avgQuality < 85 ? "<85 absolute" : "-5 points"
-    });
-  }
-  if (baseline.p95LatencyMs >= 1000 && canary.p95LatencyMs >= baseline.p95LatencyMs * 1.5) {
-    triggers.push({ metric: "latency", baseline: baseline.p95LatencyMs, canary: canary.p95LatencyMs, threshold: "+50% p95" });
-  }
-  if (baseline.avgTokens >= 1000 && canary.avgTokens >= baseline.avgTokens * 1.5) {
-    triggers.push({ metric: "tokens", baseline: baseline.avgTokens, canary: canary.avgTokens, threshold: "+50%" });
-  }
-  if (canary.fallbackRate - baseline.fallbackRate >= 0.1) {
-    triggers.push({ metric: "fallback", baseline: baseline.fallbackRate, canary: canary.fallbackRate, threshold: "+10pp" });
-  }
-  if (canary.damageRate - baseline.damageRate >= 0.1) {
-    triggers.push({ metric: "damage", baseline: baseline.damageRate, canary: canary.damageRate, threshold: "+10pp" });
-  }
-  const canarySampleAdequacy = Math.min(1, canary.appliedRuns / minCanaryRuns);
-  const baselineSampleAdequacy = Math.min(1, baseline.appliedRuns / Math.max(20, minCanaryRuns));
-  const dataConfidence = Math.round(100 * (canarySampleAdequacy * 0.25 + baselineSampleAdequacy * 0.15 + canary.qualityCoverage * canarySampleAdequacy * 0.2 + canary.damageCoverage * canarySampleAdequacy * 0.2 + baseline.damageCoverage * baselineSampleAdequacy * 0.2));
-  const reasons = [];
-  let decision = "hold";
-  if (triggers.length && canary.appliedRuns >= 3) {
-    decision = "rollback";
-    reasons.push(...triggers.map((trigger) => trigger.metric + " crossed " + trigger.threshold));
-  } else if (canary.appliedRuns < minCanaryRuns) {
-    reasons.push("need " + (minCanaryRuns - canary.appliedRuns) + " more canary runs with applied outcomes");
-  } else if (baseline.appliedRuns < Math.max(20, minCanaryRuns)) {
-    reasons.push("stable baseline is too small");
-  } else if (canary.qualityCoverage < 0.7) {
-    reasons.push("schema-v2 quality coverage is below 70%");
-  } else if (canary.damageCoverage < 0.7) {
-    reasons.push("correlated canary damage-observation coverage is below 70%");
-  } else if (baseline.damageCoverage < 0.7) {
-    reasons.push("correlated stable damage-observation coverage is below 70%");
-  } else if ((canary.avgQuality ?? 0) < 85) {
-    reasons.push("absolute verifier quality is below 85");
-  } else if (canary.successRate < 0.949999) {
-    reasons.push("absolute success rate is below 95%");
-  } else {
-    decision = "promote";
-    reasons.push("sample, absolute quality, reliability, latency, token, fallback, and damage gates passed");
-  }
-  return {
-    version: options.version,
-    decision,
-    dataConfidence,
-    baseline: roundStats(baseline),
-    canary: roundStats(canary),
-    triggers,
-    reasons
-  };
-}
-var TELEMETRY_FAILURE_KINDS = new Set([
-  "cancelled",
-  "timeout",
-  "rate-limit",
-  "authentication",
-  "budget",
-  "output-limit",
-  "provider",
-  "persistence",
-  "validation",
-  "verification",
-  "yield",
-  "internal"
-]);
-function isTelemetryFailureKind(value) {
-  return typeof value === "string" && TELEMETRY_FAILURE_KINDS.has(value);
-}
-
-// src/phases/explore.ts
 function explicitlyRejectsTools(error2) {
   if (!error2 || typeof error2 !== "object")
     return false;
@@ -7501,8 +7617,12 @@ function boundedExplorationValue(value, depth = 0) {
   if (typeof value === "string") {
     return value.length > TRUNC.PREVIEW_XL ? value.slice(0, TRUNC.PREVIEW_XL) + "\u2026" : value;
   }
-  if (value == null || typeof value !== "object")
+  if (value == null || typeof value === "number" || typeof value === "boolean")
     return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value !== "object")
+    return;
   if (depth >= 3)
     return "[bounded]";
   if (Array.isArray(value))
@@ -7511,7 +7631,7 @@ function boundedExplorationValue(value, depth = 0) {
 }
 function serializeExplorationResult(value, scrubber) {
   const safe = boundedExplorationValue(scrubber.scrubValue(value).value);
-  const serialized = JSON.stringify(safe);
+  const serialized = JSON.stringify(safe) ?? "null";
   if (serialized.length <= MAX_EXPLORER_OUTPUT_CHARS)
     return serialized;
   let excerptChars = Math.max(0, Math.floor((MAX_EXPLORER_OUTPUT_CHARS - 160) / 2));
@@ -8160,16 +8280,75 @@ function batchFieldPattern(name) {
   let pattern = batchFieldPatterns.get(name);
   if (!pattern) {
     const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    pattern = new RegExp("\\*\\*" + escaped + "\\*\\*:\\s*(.+?)(?:\\n|$)", "i");
+    pattern = new RegExp("(?:^|\\n)\\*\\*" + escaped + "\\*\\*:\\s*(.+?)(?:\\n|$)", "i");
     batchFieldPatterns.set(name, pattern);
   }
   return pattern;
 }
+
+class BatchSummaryFormatError extends Error {
+  name = "BatchSummaryFormatError";
+  constructor(reason) {
+    super("Malformed batch summary response: " + reason);
+  }
+}
+var BATCH_REQUIRED_FIELDS = [
+  "Priority",
+  "Summary",
+  "Decisions",
+  "Modified",
+  "Deleted",
+  "Read"
+];
+function assertCompleteBatchResponse(stopReason, sectionMap, duplicateIds, batchSize) {
+  const reason = String(stopReason ?? "");
+  if (reason !== "stop" && reason !== "endTurn") {
+    throw new BatchSummaryFormatError("non-terminal stop reason " + (reason || "unknown"));
+  }
+  if (duplicateIds.size > 0) {
+    throw new BatchSummaryFormatError("duplicate chunk id(s): " + [...duplicateIds].sort((a, b) => a - b).join(", "));
+  }
+  const unexpected = [...sectionMap.keys()].filter((id) => id < 1 || id > batchSize);
+  if (unexpected.length > 0) {
+    throw new BatchSummaryFormatError("unexpected chunk id(s): " + unexpected.sort((a, b) => a - b).join(", "));
+  }
+  const missingSections = [];
+  for (let id = 1;id <= batchSize; id++) {
+    if (!sectionMap.has(id))
+      missingSections.push(id);
+  }
+  if (missingSections.length > 0) {
+    throw new BatchSummaryFormatError("missing chunk section(s): " + missingSections.join(", "));
+  }
+  for (let id = 1;id <= batchSize; id++) {
+    const section = sectionMap.get(id) ?? "";
+    const missingFields = BATCH_REQUIRED_FIELDS.filter((field) => !batchFieldPattern(field).test(section));
+    if (missingFields.length > 0) {
+      throw new BatchSummaryFormatError("chunk " + id + " missing field(s): " + missingFields.join(", "));
+    }
+  }
+  const missing = [];
+  for (let id = 1;id <= batchSize; id++) {
+    const section = sectionMap.get(id);
+    const summary = section?.match(batchFieldPattern("Summary"))?.[1].trim();
+    if (!summary || summary.toLowerCase() === "none")
+      missing.push(id);
+  }
+  if (missing.length > 0) {
+    throw new BatchSummaryFormatError("missing usable Summary for chunk(s): " + missing.join(", "));
+  }
+}
 function boundedToolArgs(value, depth = 0) {
   if (typeof value === "string")
     return value.length > TRUNC.DETAIL ? value.slice(0, TRUNC.DETAIL) + "\u2026" : value;
-  if (value == null || typeof value !== "object" || depth >= 2)
+  if (value == null || typeof value === "number" || typeof value === "boolean")
     return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value !== "object")
+    return;
+  if (depth >= 2)
+    return "[bounded]";
   if (Array.isArray(value))
     return value.slice(0, 8).map((item) => boundedToolArgs(item, depth + 1));
   return Object.fromEntries(Object.entries(value).slice(0, 12).map(([key, item]) => [key, boundedToolArgs(item, depth + 1)]));
@@ -8483,13 +8662,19 @@ async function summarizeBatch(batch, extraction, model, auth, signal, services,
   const output = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `);
   const sectionMap = new Map;
+  const duplicateIds = new Set;
   const sections = output.split(/^### /m).filter((s) => s.trim());
   for (const sec of sections) {
     const m = sec.match(/^CHUNK\s+(\d+):\s*(.*?)\n/i);
     if (m) {
-      sectionMap.set(parseInt(m[1], 10), sec);
+      const id = parseInt(m[1], 10);
+      if (sectionMap.has(id))
+        duplicateIds.add(id);
+      else
+        sectionMap.set(id, sec);
     }
   }
+  assertCompleteBatchResponse(resp.stopReason, sectionMap, duplicateIds, batch.length);
   const result = batch.map((ch, i) => {
     const id = i + 1;
     const sec = sectionMap.get(id) ?? "";
@@ -8687,377 +8872,21 @@ async function resolveStageAuth(rc, stage) {
   return resolved;
 }
 
-// src/app/steps/synthesize.ts
-async function summarizeConversation(rc) {
-  let synthPhaseStart = Date.now();
-  const extraction = rc.extraction;
-  rc.mode ??= rc.profile ? modeFromLegacyProfile(rc.profile) : "balanced";
-  rc.requestedMode ??= rc.mode;
-  if (rc.requestedMode === "auto") {
-    const refined = resolveMode("auto", rc.contextPercent, extraction, continuityRisk(rc.previousState) + (rc.adapted ? 12 : 0));
-    if (refined !== rc.mode) {
-      rc.mode = refined;
-      const policy2 = MODE_POLICIES[refined];
-      rc.services.budget.setLimits(rc.maxLlmCalls ?? effectiveBudget(rc.config.maxLlmCalls, policy2.maxLlmCalls), rc.maxLlmInputTokens ?? effectiveBudget(rc.config.maxLlmInputTokens, policy2.maxInputTokens), policy2.maxOutputTokens);
-      rc.notify("Auto strategy refined to " + refined + " within the planned " + rc.profile + " window", "info");
-    }
+// src/phases/verify.ts
+var HIGH_RISK_OUTCOME_RE = /(?:\ball\s+tests?\s+(?:pass|passed|passing)\b|\btests?\s+(?:pass|passed|passing)\b|\b(?:build|deployment|migration)\s+(?:completed|succeeded|passed|successful)\b|\b(?:deployed|published|released)\b|\b(?:bug|issue|error)\s+(?:fixed|resolved)\b|\bno\s+(?:errors?|failures?)\b|\bcompleted successfully\b|\btestler?\s+(?:ge\u00E7ti|ba\u015Far\u0131l\u0131)\b|\bba\u015Far\u0131yla\s+(?:tamamland\u0131|da\u011F\u0131t\u0131ld\u0131|yay\u0131nland\u0131)\b|\b(?:deploy edildi|yay\u0131nland\u0131|hata yok)\b)/iu;
+var NEGATED_OUTCOME_RE = /\b(?:not|never|pending|failed|failing|unresolved|hen\u00FCz|de\u011Fil|ba\u015Far\u0131s\u0131z)\b/iu;
+var NONE_BLOCKER_VALUE_RE = /^(?:none|no blockers?|yok)\s*(?:recorded|known)?[.!]?$/i;
+var BULLET_NONE_BLOCKER_RE = /^(?:[-*+]|\d+[.)])\s+(?:none|no blockers?|yok)\s*(?:recorded|known)?[.!]?$/i;
+var PATH_PLACEHOLDER_RE = /^(?:none|none recorded|no blockers?|yok)[.!]?$/i;
+function noneBlockerLineIndexes(lines) {
+  const indexes = new Set;
+  const nonEmpty = lines.map((line, index) => ({ index, text: line.trim() })).filter((item) => item.text);
+  for (const item of nonEmpty) {
+    if (BULLET_NONE_BLOCKER_RE.test(item.text))
+      indexes.add(item.index);
   }
-  const pc = rc.profileCfg;
-  const policy = MODE_POLICIES[rc.mode];
-  const cacheKey = synthesisCacheKey(rc);
-  const cached = getCachedSynthesis(cacheKey);
-  if (cached) {
-    rc.notify("Synthesis cache hit \u2014 no LLM calls", "info");
-    showProgressOverlay(rc.ctx, {
-      phase: 3,
-      phaseName: "Synthesize",
-      detail: "Reusing the cached continuation summary \xB7 no LLM call"
-    });
-    Object.assign(rc, {
-      finalSummary: cached.finalSummary,
-      method: cached.method,
-      methodForMetrics: cached.method + "-cache",
-      generationFallbacks: [],
-      llmCalls: 0,
-      summaries: cached.summaries,
-      explorationReport: cached.explorationReport,
-      explorationRounds: cached.explorationRounds,
-      chunkCount: cached.chunkCount
-    });
-    const hit = advance(rc, "_synthesized");
-    markMeasuredPhase(hit, "synthesize", synthPhaseStart);
-    return hit;
-  }
-  const zeroCall = rc.config.zeroCallEnabled !== false && rc.mode === "fast" && !rc.focus && !rc.userNote && deterministicExtractionConfidence(extraction, {
-    conversationTokens: rc.convTokens,
-    toolPercent: rc.toolPercent
-  }) >= 0.85;
-  if (zeroCall) {
-    showProgressOverlay(rc.ctx, {
-      phase: 3,
-      phaseName: "Synthesize",
-      detail: "Building a deterministic continuation summary \xB7 no LLM call"
-    });
-    const finalSummary2 = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
-    setCachedSynthesis(cacheKey, {
-      finalSummary: finalSummary2,
-      method: "heuristic",
-      summaries: [],
-      explorationReport: null,
-      explorationRounds: 0,
-      chunkCount: 0
-    });
-    rc.notify("Zero-call deterministic compaction (high-confidence extraction)", "info");
-    Object.assign(rc, {
-      finalSummary: finalSummary2,
-      method: "heuristic",
-      methodForMetrics: "zero-call",
-      generationFallbacks: [],
-      llmCalls: 0,
-      summaries: [],
-      explorationReport: null,
-      explorationRounds: 0,
-      chunkCount: 0
-    });
-    const deterministic = advance(rc, "_synthesized");
-    markMeasuredPhase(deterministic, "synthesize", synthPhaseStart);
-    return deterministic;
-  }
-  const shouldSkipExplore = !policy.explore;
-  const convText = rc.convText;
-  const singlePassMaxTokens = Math.round(pc.singlePassMaxTokens * rc.providerCaps.singlePassTokenMultiplier * policy.singlePassMultiplier);
-  rc.vlog("Tier=" + rc.tier + " | convTokens=" + rc.convTokens + " | singlePassMax=" + singlePassMaxTokens);
-  let finalSummary;
-  let method;
-  const summaries = [];
-  let explorationReport = null;
-  let explorationRounds = 0;
-  let chunkCount = 0;
-  let cacheable = true;
-  const generationFallbacks = [];
-  let summaryAuth;
-  try {
-    summaryAuth = await resolveStageAuth(rc, "summary");
-  } catch (error2) {
-    cacheable = false;
-    generationFallbacks.push("summary route unavailable");
-    debugError("Summary route unavailable", error2);
-    rc.notify("Summary route unavailable \xB7 using deterministic fallback", "info");
-  }
-  if (!summaryAuth) {
-    showProgressOverlay(rc.ctx, {
-      phase: 3,
-      phaseName: "Synthesize",
-      detail: "Summary route unavailable \xB7 building a deterministic summary"
-    });
-    finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
-    method = "heuristic";
-  } else if (rc.convTokens < singlePassMaxTokens) {
-    showProgressOverlay(rc.ctx, {
-      phase: 3,
-      phaseName: "Synthesize",
-      detail: "Writing one continuation summary from " + rc.convTokens.toLocaleString() + " tokens",
-      model: rc.modelLabel,
-      profile: rc.profile,
-      extraction
-    });
-    try {
-      const r = await singlePassCompact(convText, extraction, null, rc.prevContext + rc.projectCtx, rc.summaryModel, summaryAuth, pc.summaryBudgetTokens, rc.cancellation.signal, rc.services, rc.config.focusWeighting ? rc.focus : undefined);
-      finalSummary = r.summary;
-      method = "single-pass";
-    } catch (err) {
-      cacheable = false;
-      generationFallbacks.push("single-pass generation failed");
-      debugError("Single-pass synthesis used deterministic fallback", err);
-      rc.notify("Single-pass generation stopped \xB7 using deterministic fallback", "info");
-      finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
-      method = "heuristic";
-    }
-  } else {
-    const needsExploration = !shouldSkipExplore && shouldExplore(extraction);
-    if (needsExploration) {
-      const exploreStart = Date.now();
-      showProgressOverlay(rc.ctx, {
-        phase: 2,
-        phaseName: "Explore",
-        detail: "Mapping topic shifts and continuity risks",
-        model: rc.modelLabel,
-        profile: rc.profile,
-        extraction
-      });
-      try {
-        const segAuth = await resolveStageAuth(rc, "explore");
-        const expResult = await exploreConversation(rc.llmMessages, extraction, rc.segModel, segAuth, rc.prevContext || undefined, [
-          rc.userNote,
-          rc.config.focusWeighting && rc.focus ? "Focus extra preservation on: " + rc.focus : undefined
-        ].filter(Boolean).join(`
-`) || undefined, rc.cancellation.signal, MAX_EXPLORATION_ROUNDS, rc.notify, rc.services);
-        explorationReport = expResult.report;
-        explorationRounds = expResult.rounds;
-        rc.notify("Phase 2 Explore: " + expResult.rounds + " rounds, " + explorationReport.boundaries.length + " boundaries" + (expResult.toolSupported ? "" : " (no tool support)"), "info");
-        rc.vlog("Explore boundaries: " + explorationReport.boundaries.map((b) => b.afterIndex + "(" + b.confidence.toFixed(2) + ")").join(", "));
-      } catch (err) {
-        cacheable = false;
-        generationFallbacks.push("exploration unavailable");
-        debugError("Explore used deterministic topic boundaries", err);
-        rc.notify("Explore unavailable \xB7 using deterministic topic boundaries", "info");
-      } finally {
-        const exploreEnd = Date.now();
-        markMeasuredPhase(rc, "explore", exploreStart, exploreEnd);
-        synthPhaseStart = exploreEnd;
-      }
-    } else {
-      rc.notify("Phase 2 Explore: skipped (simple session: " + extraction.topics.length + " topics, " + extraction.errors.filter((e) => !e.resolved).length + " unresolved errors)", "info");
-    }
-    let boundaries;
-    if (explorationReport?.boundaries.length) {
-      const llmBounds = explorationReport.boundaries.filter((b) => b.confidence >= 0.4);
-      const heuristicBounds = extraction.topics.map((t) => ({
-        afterIndex: t.endIndex,
-        topic: t.primaryFile ? "Working on " + t.primaryFile.split("/").pop() : "Segment",
-        priority: t.errorDensity > 2 ? "high" : "normal",
-        confidence: 0.6
-      }));
-      if (llmBounds.length > 0) {
-        const merged = [...llmBounds];
-        for (const hb of heuristicBounds) {
-          const nearby = merged.find((m) => Math.abs(m.afterIndex - hb.afterIndex) <= 3);
-          if (!nearby)
-            merged.push(hb);
-        }
-        boundaries = merged.sort((a, b) => a.afterIndex - b.afterIndex);
-      } else {
-        boundaries = heuristicBounds;
-      }
-    } else {
-      boundaries = extraction.topics.map((t) => ({
-        afterIndex: t.endIndex,
-        topic: t.primaryFile ? "Working on " + t.primaryFile.split("/").pop() : "Segment",
-        priority: t.errorDensity > 2 ? "high" : "normal",
-        confidence: 0.6
-      }));
-    }
-    const chunks = chunkLlmMessages(rc.llmMessages, boundaries, pc, rc.estimator, rc.config.focusWeighting ? rc.focus : undefined);
-    chunkCount = chunks.length;
-    rc.notify("Chunked: " + chunkCount + " chunks", "info");
-    rc.vlog("Chunk topics: " + chunks.map((c) => c.topic + "[" + c.startIndex + "-" + c.endIndex + "]").join(", "));
-    const batches = createBatches(chunks, pc.batchMaxTokens);
-    const totalBatches = batches.length;
-    showProgressOverlay(rc.ctx, {
-      phase: 3,
-      phaseName: "Synthesize",
-      detail: "Compressing older history \xB7 batch 0/" + totalBatches,
-      model: rc.modelLabel,
-      profile: rc.profile,
-      extraction,
-      explorationRounds,
-      totalBatches
-    });
-    const concurrency = rc.providerCaps.concurrencyLimit;
-    if (totalBatches <= 1) {
-      const single = batches[0];
-      if (single) {
-        if (rc.services.budget.remainingCalls() <= 1) {
-          summaries.push(...single.map((ch) => failedChunkSummary(ch)));
-          cacheable = false;
-          generationFallbacks.push("call budget reserved for final assembly");
-          rc.notify("Call budget: chunk synthesis uses deterministic evidence so final assembly remains available", "info");
-        } else {
-          try {
-            summaries.push(...await summarizeBatch(single, extraction, rc.summaryModel, summaryAuth, rc.cancellation.signal, rc.services, batchOutputLimit(rc.mode, single.length, rc.providerCaps.maxOutputTokens), rc.sessionId));
-          } catch (err) {
-            summaries.push(...single.map((ch) => failedChunkSummary(ch)));
-            cacheable = false;
-            generationFallbacks.push("1 synthesis batch fallback");
-            debugError("Synthesis batch used deterministic fallback", err);
-            rc.notify("Synthesis batch stopped \xB7 deterministic evidence fallback preserved coverage", "info");
-            showProgressOverlay(rc.ctx, {
-              phase: 3,
-              phaseName: "Synthesize",
-              detail: "1 batch fallback \xB7 preserving coverage from deterministic evidence",
-              explorationRounds
-            });
-          }
-        }
-      } else {
-        rc.vlog("Synthesize: 0 batches \u2014 skipping summarization, using fallback assembly");
-      }
-    } else {
-      const results = new Array(totalBatches);
-      const errors = new Array(totalBatches).fill(null);
-      const batchCallLimit = Math.max(0, Math.min(totalBatches, rc.services.budget.remainingCalls() - 1));
-      for (let index = batchCallLimit;index < totalBatches; index++) {
-        results[index] = batches[index].map((chunk) => failedChunkSummary(chunk));
-      }
-      if (batchCallLimit < totalBatches) {
-        rc.notify("Call budget: " + (totalBatches - batchCallLimit) + " batch(es) use deterministic fallback to reserve assembly", "info");
-        cacheable = false;
-        generationFallbacks.push(totalBatches - batchCallLimit + " synthesis batch budget fallback(s)");
-      }
-      let completed = totalBatches - batchCallLimit;
-      let nextBatch = 0;
-      let budgetStopped = false;
-      const runWorker = async () => {
-        while (true) {
-          const idx = nextBatch++;
-          if (idx >= batchCallLimit)
-            return;
-          if (budgetStopped || rc.services.budget.reason()) {
-            budgetStopped = true;
-            results[idx] = batches[idx].map((chunk) => failedChunkSummary(chunk));
-          } else {
-            try {
-              const batch = batches[idx];
-              results[idx] = await summarizeBatch(batch, extraction, rc.summaryModel, summaryAuth, rc.cancellation.signal, rc.services, batchOutputLimit(rc.mode, batch.length, rc.providerCaps.maxOutputTokens), rc.sessionId);
-            } catch (err) {
-              errors[idx] = err instanceof Error ? err : new Error(String(err));
-              results[idx] = batches[idx].map((chunk) => failedChunkSummary(chunk));
-            }
-          }
-          completed++;
-          showProgressOverlay(rc.ctx, {
-            phase: 3,
-            phaseName: "Synthesize",
-            detail: "Compressing older history \xB7 batch " + completed + "/" + totalBatches,
-            model: rc.modelLabel,
-            profile: rc.profile,
-            extraction,
-            explorationRounds,
-            totalBatches,
-            currentBatch: completed
-          });
-        }
-      };
-      const workerCount = Math.max(1, Math.min(concurrency, batchCallLimit));
-      await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
-      if (budgetStopped) {
-        rc.notify("Synthesis budget reached \xB7 remaining batches use deterministic fallback", "info");
-        cacheable = false;
-        generationFallbacks.push("synthesis budget exhausted during batch pool");
-      }
-      for (const r of results)
-        if (r)
-          summaries.push(...r);
-      const failedBatches = errors.filter(Boolean);
-      for (const error2 of failedBatches)
-        debugError("Synthesis batch used deterministic fallback", error2);
-      if (failedBatches.length) {
-        cacheable = false;
-        generationFallbacks.push(failedBatches.length + " synthesis batch fallback(s)");
-        rc.notify(failedBatches.length + " synthesis batch(es) stopped \xB7 deterministic evidence fallback preserved coverage", "info");
-        showProgressOverlay(rc.ctx, {
-          phase: 3,
-          phaseName: "Synthesize",
-          detail: failedBatches.length + " batch fallback(s) \xB7 preserving coverage from deterministic evidence",
-          explorationRounds
-        });
-      }
-    }
-    showProgressOverlay(rc.ctx, {
-      phase: 3,
-      phaseName: "Synthesize",
-      detail: "Merging summaries with project continuity",
-      model: rc.modelLabel,
-      profile: rc.profile,
-      extraction,
-      explorationRounds,
-      totalBatches: batches.length
-    });
-    try {
-      const r = await assembleLLM(summaries, extraction, explorationReport, rc.summaryModel, summaryAuth, pc.summaryBudgetTokens, rc.prevContext, rc.cancellation.signal, rc.services, rc.config.focusWeighting ? rc.focus : undefined, rc.previousState);
-      if (r?.startsWith("##"))
-        finalSummary = r;
-      else
-        throw new Error("bad");
-    } catch (err) {
-      cacheable = false;
-      generationFallbacks.push("assembly generation failed");
-      debugError("Assembly used deterministic fallback", err);
-      finalSummary = assembleFallback(summaries, extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
-    }
-    method = "eesv";
-  }
-  Object.assign(rc, {
-    finalSummary,
-    method,
-    methodForMetrics: method,
-    generationFallbacks,
-    llmCalls: rc.services.metrics.summary().totalCalls,
-    summaries,
-    explorationReport,
-    explorationRounds,
-    chunkCount
-  });
-  const out = advance(rc, "_synthesized");
-  if (cacheable) {
-    setCachedSynthesis(cacheKey, {
-      finalSummary,
-      method,
-      summaries,
-      explorationReport,
-      explorationRounds,
-      chunkCount
-    });
-  }
-  markMeasuredPhase(out, "synthesize", synthPhaseStart);
-  return out;
-}
-
-// src/phases/verify.ts
-var HIGH_RISK_OUTCOME_RE = /(?:\ball\s+tests?\s+(?:pass|passed|passing)\b|\btests?\s+(?:pass|passed|passing)\b|\b(?:build|deployment|migration)\s+(?:completed|succeeded|passed|successful)\b|\b(?:deployed|published|released)\b|\b(?:bug|issue|error)\s+(?:fixed|resolved)\b|\bno\s+(?:errors?|failures?)\b|\bcompleted successfully\b|\btestler?\s+(?:ge\u00E7ti|ba\u015Far\u0131l\u0131)\b|\bba\u015Far\u0131yla\s+(?:tamamland\u0131|da\u011F\u0131t\u0131ld\u0131|yay\u0131nland\u0131)\b|\b(?:deploy edildi|yay\u0131nland\u0131|hata yok)\b)/iu;
-var NEGATED_OUTCOME_RE = /\b(?:not|never|pending|failed|failing|unresolved|hen\u00FCz|de\u011Fil|ba\u015Far\u0131s\u0131z)\b/iu;
-var NONE_BLOCKER_VALUE_RE = /^(?:none|no blockers?|yok)\s*(?:recorded|known)?[.!]?$/i;
-var BULLET_NONE_BLOCKER_RE = /^(?:[-*+]|\d+[.)])\s+(?:none|no blockers?|yok)\s*(?:recorded|known)?[.!]?$/i;
-var PATH_PLACEHOLDER_RE = /^(?:none|none recorded|no blockers?|yok)[.!]?$/i;
-function noneBlockerLineIndexes(lines) {
-  const indexes = new Set;
-  const nonEmpty = lines.map((line, index) => ({ index, text: line.trim() })).filter((item) => item.text);
-  for (const item of nonEmpty) {
-    if (BULLET_NONE_BLOCKER_RE.test(item.text))
-      indexes.add(item.index);
-  }
-  if (nonEmpty.length === 1 && NONE_BLOCKER_VALUE_RE.test(nonEmpty[0].text)) {
-    indexes.add(nonEmpty[0].index);
+  if (nonEmpty.length === 1 && NONE_BLOCKER_VALUE_RE.test(nonEmpty[0].text)) {
+    indexes.add(nonEmpty[0].index);
   }
   return indexes;
 }
@@ -9116,8 +8945,9 @@ function hasListedPath(listed, file, display, normalizedOwners) {
   }
   return false;
 }
-function outcomeClaims(summary) {
-  return Array.from(new Set(summary.split(/\r?\n/).map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").trim()).filter((line) => line.length > 0 && !line.startsWith("#")).filter((line) => HIGH_RISK_OUTCOME_RE.test(line)).filter((line) => /\bno\s+(?:errors?|failures?)\b/i.test(line) || !NEGATED_OUTCOME_RE.test(line)))).slice(0, 12);
+function outcomeClaims(summary, pathEvidence) {
+  const pathLines = new Set(Array.from(pathEvidence, ([path12, display]) => [path12, display, "`" + path12 + "`"]).flat());
+  return Array.from(new Set(summary.split(/\r?\n/).map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").trim()).filter((line) => line.length > 0 && !line.startsWith("#") && !pathLines.has(line)).filter((line) => HIGH_RISK_OUTCOME_RE.test(line)).filter((line) => /\bno\s+(?:errors?|failures?)\b/i.test(line) || !NEGATED_OUTCOME_RE.test(line)))).slice(0, 12);
 }
 function classifyOutcomeClaim(claim) {
   const lower = claim.toLowerCase();
@@ -9416,7 +9246,7 @@ function stemToken(token) {
   return lower;
 }
 function semanticTokens(text) {
-  return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2);
+  return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2 || NEGATION_MARKERS.has(token));
 }
 var semanticShapeCache = new Map;
 var semanticFragmentCache = new Map;
@@ -9431,574 +9261,1022 @@ function semanticFragments(text) {
 function hasNearbyMarker(tokens, anchor, markers) {
   return tokens.some((token, index) => token === anchor && tokens.slice(Math.max(0, index - 2), index + 3).some((near) => markers.has(near)));
 }
-function hasEffectiveTargetNegation(tokens, anchor) {
-  return tokens.some((token, anchorIndex) => {
-    if (token !== anchor)
-      return false;
-    const nearbyStart = Math.max(0, anchorIndex - 2);
-    const nearbyNegations = tokens.slice(nearbyStart, anchorIndex + 3).map((near, offset) => NEGATION_MARKERS.has(near) ? nearbyStart + offset : -1).filter((index) => index >= 0);
-    const governingStart = Math.max(0, anchorIndex - 3);
-    const preceding = tokens.slice(governingStart, anchorIndex);
-    const nearbyGuards = preceding.map((near, offset) => POLARITY_INVERTING_GUARDS.has(near) ? governingStart + offset : -1).filter((index) => index >= 0);
-    const governingIndex = preceding.findIndex((near, offset) => NEGATION_MARKERS.has(near) && POLARITY_INVERTING_GUARDS.has(preceding[offset + 1] ?? ""));
-    if (governingIndex < 0)
-      return nearbyNegations.length > 0 || nearbyGuards.length > 0;
-    const absoluteGoverningIndex = governingStart + governingIndex;
-    const guardIndex = absoluteGoverningIndex + 1;
-    const nested = tokens.slice(guardIndex + 1, anchorIndex).some((inner) => NEGATION_MARKERS.has(inner) || POLARITY_INVERTING_GUARDS.has(inner));
-    return nested || nearbyNegations.some((index) => index !== absoluteGoverningIndex && index !== guardIndex) || nearbyGuards.some((index) => index !== guardIndex);
-  });
+function hasEffectiveTargetNegation(tokens, anchor) {
+  return tokens.some((token, anchorIndex) => {
+    if (token !== anchor)
+      return false;
+    const nearbyStart = Math.max(0, anchorIndex - 2);
+    const nearbyNegations = tokens.slice(nearbyStart, anchorIndex + 3).map((near, offset) => NEGATION_MARKERS.has(near) && !(near === "without" && nearbyStart + offset > anchorIndex) ? nearbyStart + offset : -1).filter((index) => index >= 0);
+    const governingStart = Math.max(0, anchorIndex - 3);
+    const preceding = tokens.slice(governingStart, anchorIndex);
+    const nearbyGuards = preceding.map((near, offset) => POLARITY_INVERTING_GUARDS.has(near) ? governingStart + offset : -1).filter((index) => index >= 0);
+    const governingIndex = preceding.findIndex((near, offset) => NEGATION_MARKERS.has(near) && POLARITY_INVERTING_GUARDS.has(preceding[offset + 1] ?? ""));
+    if (governingIndex < 0)
+      return nearbyNegations.length > 0 || nearbyGuards.length > 0;
+    const absoluteGoverningIndex = governingStart + governingIndex;
+    const guardIndex = absoluteGoverningIndex + 1;
+    const nested = tokens.slice(guardIndex + 1, anchorIndex).some((inner) => NEGATION_MARKERS.has(inner) || POLARITY_INVERTING_GUARDS.has(inner));
+    return nested || nearbyNegations.some((index) => index !== absoluteGoverningIndex && index !== guardIndex) || nearbyGuards.some((index) => index !== guardIndex);
+  });
+}
+function semanticShape(source) {
+  const cached = lruGet(semanticShapeCache, source);
+  if (cached)
+    return cached;
+  const sourceTokens = semanticTokens(source);
+  const concepts = Array.from(new Set(sourceTokens.filter((token) => !/^\d+$/.test(token) && !SEMANTIC_STOP.has(token) && !NEGATION_MARKERS.has(token) && !CONDITION_MARKERS.has(token))));
+  const negative = sourceTokens.some((token) => NEGATION_MARKERS.has(token));
+  const conditional = sourceTokens.some((token) => CONDITION_MARKERS.has(token));
+  const anchor = concepts.find((concept) => hasNearbyMarker(sourceTokens, concept, NEGATION_MARKERS)) ?? concepts[0] ?? "";
+  const shape = { sourceTokens, concepts, anchor, negative, conditional };
+  lruSet(semanticShapeCache, source, shape, 512);
+  return shape;
+}
+function hasSemanticEvidence(source, target) {
+  const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
+  if (!concepts.length)
+    return true;
+  const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
+  return semanticFragments(target).some((tokens) => {
+    const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
+    if (overlap < required)
+      return false;
+    const targetNegative = hasEffectiveTargetNegation(tokens, anchor);
+    if (negative && !targetNegative) {
+      const conditionalRestatement = sourceTokens.includes("without") && tokens.some((token) => CONDITION_MARKERS.has(token)) && overlap >= Math.min(2, concepts.length);
+      if (!conditionalRestatement)
+        return false;
+    }
+    if (!negative && targetNegative)
+      return false;
+    if (conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token)))
+      return false;
+    return true;
+  });
+}
+function hasSemanticContradiction(source, target) {
+  const sourceFragments = new Set(semanticFragments(source).map((tokens) => tokens.join(" ")));
+  const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
+  if (!anchor)
+    return false;
+  const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
+  return semanticFragments(target).some((tokens) => {
+    if (!tokens.includes(anchor) || sourceFragments.has(tokens.join(" ")))
+      return false;
+    const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
+    if (overlap < required)
+      return false;
+    const targetNegative = hasEffectiveTargetNegation(tokens, anchor);
+    if (negative && !targetNegative) {
+      const validConditional = sourceTokens.includes("without") && tokens.some((token) => CONDITION_MARKERS.has(token)) && overlap >= Math.min(2, concepts.length);
+      return !validConditional;
+    }
+    if (!negative && targetNegative)
+      return true;
+    return conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token));
+  });
+}
+function isDeterministicallyPatchable(gap) {
+  if (gap.kind === "fabricated-file")
+    return true;
+  if (gap.kind === "inconsistency")
+    return gap.detail.startsWith("blocked-none:");
+  return true;
+}
+function repairSummaryDeterministically(summary, result, extraction, continuity = null, evidence = {}, maxRounds = 3) {
+  const patched = [];
+  const seen = new Set;
+  for (let round = 0;round < maxRounds; round++) {
+    const patchable = result.gaps.filter(isDeterministicallyPatchable);
+    if (!patchable.length)
+      break;
+    const next = patchDeterministic(summary, patchable, extraction, continuity, evidence);
+    if (next === summary)
+      break;
+    for (const gap of patchable) {
+      const key = formatVerificationGap(gap);
+      if (!seen.has(key)) {
+        seen.add(key);
+        patched.push(gap);
+      }
+    }
+    summary = next;
+    result = verifySummary(summary, extraction, continuity, evidence);
+  }
+  return { summary, result, patched };
+}
+function addGap(accumulator, gap, penalty) {
+  accumulator.gaps.push(gap);
+  accumulator.score -= penalty;
+}
+function uniqueByText(items, text) {
+  const seen = new Set;
+  return items.filter((item) => {
+    const key = text(item).toLowerCase().replace(/\s+/g, " ").trim();
+    if (!key || seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function collectVerificationEvidence(extraction, continuity, evidence) {
+  const unresolved = uniqueByText([
+    ...extraction.errors.flatMap((error2) => !error2.resolved ? [{ message: error2.message }] : []),
+    ...(continuity?.unresolvedErrors ?? []).map((error2) => ({
+      message: error2.message
+    }))
+  ], (item) => item.message);
+  const resolved = uniqueByText([
+    ...extraction.errors.flatMap((error2) => error2.resolved ? [{ message: error2.message }] : []),
+    ...(continuity?.resolvedErrors ?? []).map((error2) => ({
+      message: error2.message
+    }))
+  ], (item) => item.message).slice(-5);
+  const steeringConstraints = [];
+  if (evidence.steering?.focus?.trim()) {
+    steeringConstraints.push({
+      text: "Preserve detail about: " + evidence.steering.focus
+    });
+  }
+  if (evidence.steering?.note?.trim()) {
+    steeringConstraints.push({ text: evidence.steering.note });
+  }
+  const constraints = uniqueByText([
+    ...extraction.constraints.flatMap((item) => item.confidence >= 0.8 ? [{ text: item.text }] : []),
+    ...(continuity?.constraints ?? []).flatMap((item) => item.confidence >= 0.8 ? [{ text: item.text }] : []),
+    ...steeringConstraints
+  ], (item) => item.text).filter((item) => !isDiagnosticConstraintText(item.text));
+  const decisions = uniqueByText([
+    ...extraction.decisions.flatMap((item) => item.type === "explicit" ? [{ summary: item.summary }] : []),
+    ...(continuity?.decisions ?? []).flatMap((item) => item.type === "explicit" ? [{ summary: item.summary }] : [])
+  ], (item) => item.summary);
+  return {
+    unresolved,
+    resolved,
+    constraints,
+    decisions,
+    goal: extraction.mainGoal ?? continuity?.goal ?? null
+  };
+}
+function verifyRequiredSections(parsed, accumulator) {
+  const required = [
+    { kind: "goal", penalty: 5 },
+    { kind: "progress", penalty: 5 },
+    { kind: "critical-context", penalty: 3 }
+  ];
+  for (const item of required) {
+    if (!findSection(parsed, item.kind)) {
+      addGap(accumulator, { kind: "missing-section", section: item.kind }, item.penalty);
+    }
+  }
+}
+function verifyPathCoverage(parsed, extraction, continuity, evidence, accumulator) {
+  const modified = extraction.modifiedFiles.map((file) => file.path);
+  const read = extraction.readFiles;
+  const deleted = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
+  const required = [...modified, ...read, ...deleted];
+  const expected = new Set(required);
+  const rendered = buildSummaryPathEvidence(required, evidence.summaryBudgetTokens);
+  const ownerSets = new Map;
+  for (const file of required) {
+    const display = rendered.get(file);
+    for (const candidate of [
+      file,
+      ...display ? [decodePathDisplay(display)] : []
+    ]) {
+      const normalized = normalizePath(candidate);
+      const owners = ownerSets.get(normalized) ?? new Set;
+      owners.add(file);
+      ownerSets.set(normalized, owners);
+    }
+  }
+  const ownerCounts = new Map(Array.from(ownerSets, ([file, owners]) => [file, owners.size]));
+  const listed = (kind) => collectListedPaths(findSection(parsed, kind)?.body ?? "", expected);
+  const modifiedListed = listed("files-modified");
+  const readListed = listed("files-read");
+  const deletedListed = listed("files-deleted");
+  for (const file of modified) {
+    const display = rendered.get(file);
+    if (display && !hasListedPath(modifiedListed, file, display, ownerCounts)) {
+      addGap(accumulator, { kind: "missing-file", path: file }, 5);
+    }
+  }
+  for (const file of read) {
+    const display = rendered.get(file);
+    if (display && !hasListedPath(readListed, file, display, ownerCounts)) {
+      addGap(accumulator, { kind: "missing-read-file", path: file }, 5);
+    }
+  }
+  for (const file of deleted) {
+    const display = rendered.get(file);
+    if (display && !hasListedPath(deletedListed, file, display, ownerCounts)) {
+      addGap(accumulator, { kind: "missing-deleted-file", path: file }, 5);
+    }
+  }
+  return { modified, read, deleted, rendered };
+}
+function verifyErrorEvidence(normalizedSummary, collected, accumulator) {
+  for (const error2 of collected.unresolved) {
+    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
+    if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
+      addGap(accumulator, { kind: "missing-error", message: error2.message }, 5);
+    }
+  }
+  for (const error2 of collected.resolved) {
+    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
+    if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
+      addGap(accumulator, { kind: "missing-error", message: error2.message, resolved: true }, 2);
+    }
+  }
+}
+function verifySemanticCoverage(parsed, collected, accumulator) {
+  const constraintTarget = [
+    findSection(parsed, "constraints")?.body ?? "",
+    findSection(parsed, "critical-context")?.body ?? ""
+  ].join(`
+`);
+  for (const constraint of collected.constraints) {
+    if (!hasSemanticEvidence(constraint.text, constraintTarget)) {
+      addGap(accumulator, { kind: "missing-constraint", text: constraint.text }, 8);
+    }
+    if (hasSemanticContradiction(constraint.text, constraintTarget)) {
+      addGap(accumulator, {
+        kind: "inconsistency",
+        detail: "semantic-contradiction: constraint contradicts " + constraint.text.slice(0, TRUNC.SNIPPET)
+      }, 20);
+    }
+  }
+  if (collected.goal) {
+    const goalTarget = findSection(parsed, "goal")?.body ?? "";
+    if (!hasSemanticEvidence(collected.goal, goalTarget)) {
+      addGap(accumulator, { kind: "missing-goal", goal: collected.goal }, 12);
+    }
+    if (hasSemanticContradiction(collected.goal, goalTarget)) {
+      addGap(accumulator, {
+        kind: "inconsistency",
+        detail: "semantic-contradiction: goal polarity or condition changed"
+      }, 20);
+    }
+  }
+  const decisionBody = findSection(parsed, "decisions")?.body ?? "";
+  for (const decision of collected.decisions) {
+    if (!hasSemanticEvidence(decision.summary, decisionBody)) {
+      addGap(accumulator, { kind: "missing-decision", summary: decision.summary }, 8);
+    }
+    if (hasSemanticContradiction(decision.summary, decisionBody)) {
+      addGap(accumulator, {
+        kind: "inconsistency",
+        detail: "semantic-contradiction: decision contradicts " + decision.summary.slice(0, TRUNC.SNIPPET)
+      }, 20);
+    }
+  }
+}
+function verifyFileReferences(summary, extraction, continuity, evidence, collected, paths, accumulator) {
+  const groundedEvidence = [
+    ...collected.unresolved.map((item) => item.message),
+    ...collected.resolved.map((item) => item.message),
+    ...collected.constraints.map((item) => item.text),
+    ...collected.decisions.map((item) => item.summary),
+    ...collected.goal ? [collected.goal] : [],
+    ...extraction.lastUserMessages,
+    ...extraction.timeline.map((item) => item.summary),
+    ...extraction.topics.map((item) => item.primaryFile ?? ""),
+    ...continuity?.openLoops.map((item) => item.summary) ?? [],
+    ...continuity?.criticalContext ?? []
+  ];
+  const groundedFiles = groundedEvidence.flatMap((value) => [
+    value,
+    summaryEvidenceLine(value, TRUNC.ERROR_SNIPPET),
+    summaryEvidenceLine(value, TRUNC.TOPIC_LABEL),
+    summaryEvidenceLine(value, TRUNC.PREVIEW),
+    summaryEvidenceLine(value, TRUNC.MESSAGE)
+  ]).flatMap(extractFileRefs);
+  const renderedPaths = Array.from(paths.rendered.values()).flatMap((line) => [
+    decodePathDisplay(line),
+    line.startsWith('"') && line.endsWith('"') ? line.slice(1, -1) : line
+  ]);
+  const knownFiles = Array.from(new Set([
+    ...paths.modified,
+    ...paths.read,
+    ...paths.deleted,
+    ...extraction.referencedFiles ?? [],
+    ...groundedFiles,
+    ...renderedPaths,
+    ...renderedPaths.flatMap(extractFileRefs),
+    ...continuity?.modifiedFiles ?? [],
+    ...continuity?.readFiles ?? [],
+    ...(continuity?.unresolvedErrors ?? []).flatMap((error2) => error2.files),
+    ...(continuity?.openLoops ?? []).flatMap((loop) => loop.files)
+  ]));
+  const knownFileIndex = buildKnownPathReferenceIndex(knownFiles);
+  for (const ref of new Set(extractFileRefs(summary))) {
+    const grounded = isKnownPathReferenceInIndex(ref, knownFileIndex) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
+    if (!grounded)
+      addGap(accumulator, { kind: "fabricated-file", ref }, 4);
+  }
 }
-function semanticShape(source) {
-  const cached = lruGet(semanticShapeCache, source);
-  if (cached)
-    return cached;
-  const sourceTokens = semanticTokens(source);
-  const concepts = Array.from(new Set(sourceTokens.filter((token) => !/^\d+$/.test(token) && !SEMANTIC_STOP.has(token) && !NEGATION_MARKERS.has(token) && !CONDITION_MARKERS.has(token))));
-  const negative = sourceTokens.some((token) => NEGATION_MARKERS.has(token));
-  const conditional = sourceTokens.some((token) => CONDITION_MARKERS.has(token));
-  const anchor = concepts.find((concept) => hasNearbyMarker(sourceTokens, concept, NEGATION_MARKERS)) ?? concepts[0] ?? "";
-  const shape = { sourceTokens, concepts, anchor, negative, conditional };
-  lruSet(semanticShapeCache, source, shape, 512);
-  return shape;
+function verifyProgressConsistency(parsed, extraction, collected, paths, accumulator) {
+  const progress = findSection(parsed, "progress");
+  if (!progress)
+    return;
+  const done = progress.body.match(/###\s*Done[\s\S]*?(?=###|$)/i)?.[0] ?? "";
+  const blocked = progress.body.match(/###\s*Blocked[\s\S]*?(?=###|$)/i)?.[0] ?? "";
+  if (collected.unresolved.length > 0 && noneBlockerLineIndexes(blocked.split(/\r?\n/).slice(1)).size > 0) {
+    addGap(accumulator, {
+      kind: "inconsistency",
+      detail: "blocked-none: Blocked says none despite unresolved errors"
+    }, 12);
+  }
+  const doneRefs = new Set(extractFileRefs(done).map(normalizePath));
+  const modifiedPathOwners = buildPathNeedleOwnershipIndex(paths.modified);
+  for (const file of extraction.modifiedFiles) {
+    const needles = buildUniquePathNeedlesFromIndex(file.path, modifiedPathOwners);
+    if (!needles.some((needle) => doneRefs.has(needle)))
+      continue;
+    const unresolved = collected.unresolved.find((error2) => {
+      const firstLine = error2.message.split(/\r?\n/, 1)[0] ?? "";
+      const refs = extractFileRefs(firstLine).map(normalizePath);
+      return needles.some((needle) => refs.includes(normalizePath(needle)));
+    });
+    if (unresolved) {
+      addGap(accumulator, {
+        kind: "inconsistency",
+        detail: file.path + " marked Done but has unresolved error"
+      }, 5);
+    }
+  }
 }
-function hasSemanticEvidence(source, target) {
-  const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
-  if (!concepts.length)
-    return true;
-  const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return semanticFragments(target).some((tokens) => {
-    const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
-    if (overlap < required)
-      return false;
-    const targetNegative = hasEffectiveTargetNegation(tokens, anchor);
-    if (negative && !targetNegative) {
-      const conditionalRestatement = sourceTokens.includes("without") && tokens.some((token) => CONDITION_MARKERS.has(token)) && overlap >= Math.min(2, concepts.length);
-      if (!conditionalRestatement)
-        return false;
+function verifyOpenLoopsAndClaims(summary, parsed, paths, extraction, continuity, evidence, collected, accumulator) {
+  const unresolvedCount = collected.unresolved.length + (continuity?.openLoops.filter((loop) => loop.status !== "resolved").length ?? 0);
+  if (unresolvedCount >= 1 && !findSection(parsed, "open-loops") && !summary.toLowerCase().replace(/\\/g, "/").includes("unresolved")) {
+    addGap(accumulator, { kind: "missing-open-loops", unresolvedCount }, 5);
+  }
+  if (!evidence.sourceMessages)
+    return;
+  const tools = successfulToolEvidence(evidence.sourceMessages);
+  for (const claim of outcomeClaims(summary, paths.rendered)) {
+    if (!successfulToolSupportsClaim(claim, tools, extraction)) {
+      addGap(accumulator, { kind: "unsupported-claim", claim }, 20);
     }
-    if (!negative && targetNegative)
-      return false;
-    if (conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token)))
-      return false;
-    return true;
-  });
+  }
 }
-function hasSemanticContradiction(source, target) {
-  const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
-  if (!anchor)
-    return false;
-  const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return semanticFragments(target).some((tokens) => {
-    if (!tokens.includes(anchor))
-      return false;
-    const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
-    if (overlap < required)
-      return false;
-    const targetNegative = hasEffectiveTargetNegation(tokens, anchor);
-    if (negative && !targetNegative) {
-      const validConditional = sourceTokens.includes("without") && tokens.some((token) => CONDITION_MARKERS.has(token)) && overlap >= Math.min(2, concepts.length);
-      return !validConditional;
+function verifySummary(summary, extraction, continuity = null, evidence = {}) {
+  const parsed = parseSummary(summary);
+  const accumulator = { gaps: [], score: 100 };
+  const collected = collectVerificationEvidence(extraction, continuity, evidence);
+  verifyRequiredSections(parsed, accumulator);
+  const paths = verifyPathCoverage(parsed, extraction, continuity, evidence, accumulator);
+  verifyErrorEvidence(summary.toLowerCase().replace(/\\/g, "/").replace(/\s+/g, " "), collected, accumulator);
+  verifySemanticCoverage(parsed, collected, accumulator);
+  verifyFileReferences(summary, extraction, continuity, evidence, collected, paths, accumulator);
+  verifyProgressConsistency(parsed, extraction, collected, paths, accumulator);
+  verifyOpenLoopsAndClaims(summary, parsed, paths, extraction, continuity, evidence, collected, accumulator);
+  const score = Math.max(0, accumulator.score);
+  return {
+    ok: accumulator.gaps.length === 0 && score >= 85,
+    gaps: accumulator.gaps,
+    score
+  };
+}
+function patchDeterministic(summary, gaps, extraction, continuity = null, evidence = {}) {
+  let canonical = parseSummary(summary);
+  const modifiedPaths = extraction.modifiedFiles.map((file) => file.path);
+  const readPaths = extraction.readFiles;
+  const deletedPaths = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
+  const pathEvidence = buildSummaryPathEvidence([...modifiedPaths, ...readPaths, ...deletedPaths], evidence.summaryBudgetTokens);
+  const replaceFileSection = (kind, paths) => {
+    const body = paths.map((path12) => "- " + (pathEvidence.get(path12) ?? JSON.stringify(path12))).join(`
+`);
+    canonical = upsertSection(canonical, kind, body || "- None recorded.");
+  };
+  const safe = (value, max = TRUNC.MESSAGE) => summaryEvidenceLine(value, max);
+  const unresolvedMessages = Array.from(new Set([
+    ...extraction.errors.filter((error2) => !error2.resolved).map((error2) => error2.message),
+    ...(continuity?.unresolvedErrors ?? []).map((error2) => error2.message)
+  ]));
+  const unresolvedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved");
+  const blockedItems = [
+    ...unresolvedMessages.map((message) => safe(message)).filter(Boolean).map((message) => "- " + message),
+    ...unresolvedLoops.map((loop) => safe(loop.summary)).filter(Boolean).map((summary2) => "- " + summary2)
+  ];
+  const patchBlockedNone = () => {
+    const progress = findSection(canonical, "progress");
+    if (!progress || !blockedItems.length)
+      return;
+    const lines = progress.body.split(/\r?\n/);
+    const start = lines.findIndex((line) => /^###\s*Blocked\s*$/i.test(line.trim()));
+    if (start < 0)
+      return;
+    let end = lines.findIndex((line, index) => index > start && /^###\s+/.test(line.trim()));
+    if (end < 0)
+      end = lines.length;
+    const existing = lines.slice(start + 1, end);
+    const noneIndexes = noneBlockerLineIndexes(existing);
+    if (!noneIndexes.size)
+      return;
+    const replacement = Array.from(new Set([
+      ...blockedItems,
+      ...existing.filter((line, index) => line.trim() && !noneIndexes.has(index))
+    ]));
+    lines.splice(start + 1, end - start - 1, ...replacement);
+    canonical = upsertSection(canonical, "progress", lines.join(`
+`));
+  };
+  for (const gap of gaps) {
+    switch (gap.kind) {
+      case "missing-section": {
+        if (gap.section === "goal") {
+          canonical = upsertSection(canonical, "goal", safe(extraction.mainGoal ?? "", TRUNC.DETAIL) || "Continue the current coding task.");
+        } else if (gap.section === "progress") {
+          canonical = upsertSection(canonical, "progress", `### Done
+- No explicit completion recorded.
+### In Progress
+- Continue from the latest user request.
+### Blocked
+` + (blockedItems.join(`
+`) || "- None recorded."));
+        } else if (gap.section === "critical-context") {
+          const critical = unresolvedMessages.flatMap((message) => {
+            const text = safe(message);
+            return text ? ["- Unresolved error: " + text] : [];
+          });
+          canonical = upsertSection(canonical, "critical-context", critical.join(`
+`) || "- None recorded.");
+        }
+        break;
+      }
+      case "missing-file":
+        replaceFileSection("files-modified", modifiedPaths);
+        break;
+      case "missing-read-file":
+        replaceFileSection("files-read", readPaths);
+        break;
+      case "missing-deleted-file":
+        replaceFileSection("files-deleted", deletedPaths);
+        break;
+      case "missing-error": {
+        const existing = findSection(canonical, "critical-context")?.body.toLowerCase() ?? "";
+        const message = safe(gap.message);
+        if (!existing.includes(message.toLowerCase())) {
+          canonical = appendToSection(canonical, "critical-context", "- " + (gap.resolved ? "Resolved error: " : "Unresolved error: ") + message);
+        }
+        break;
+      }
+      case "missing-constraint":
+        canonical = appendToSection(canonical, "constraints", "- " + safe(gap.text, TRUNC.CONSTRAINT_TEXT));
+        break;
+      case "missing-decision":
+        canonical = appendToSection(canonical, "decisions", "- **" + safe(gap.summary, TRUNC.DECISION_SUMMARY) + "**");
+        break;
+      case "missing-goal":
+        canonical = upsertSection(canonical, "goal", safe(gap.goal, TRUNC.DETAIL) || "Continue the current task.");
+        break;
+      case "missing-open-loops": {
+        const current = extraction.errors.filter((error2) => !error2.resolved).map((error2) => safe(error2.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
+        const carriedErrors = (continuity?.unresolvedErrors ?? []).map((error2) => safe(error2.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
+        const carriedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved").map((loop) => ({
+          priority: loop.priority,
+          summary: safe(loop.summary, TRUNC.SNIPPET)
+        })).filter((item) => item.summary).map((item) => "- [" + item.priority + "] " + item.summary);
+        const body = Array.from(new Set([...current, ...carriedErrors, ...carriedLoops])).slice(0, gap.unresolvedCount).join(`
+`);
+        canonical = upsertSection(canonical, "open-loops", body || "- Review unresolved errors.", "next-steps");
+        break;
+      }
+      case "fabricated-file": {
+        const normalizedRef = gap.ref.replace(/\\/g, "/").toLowerCase();
+        canonical = {
+          sections: canonical.sections.map((section) => ({
+            ...section,
+            body: section.body.split(`
+`).filter((line) => {
+              if (!/^\s*[-*]\s+/.test(line))
+                return true;
+              const matches = extractFileRefs(line).some((ref) => ref.replace(/\\/g, "/").toLowerCase() === normalizedRef);
+              return !matches;
+            }).join(`
+`).trim()
+          }))
+        };
+        break;
+      }
+      case "unsupported-claim":
+        canonical = removeUnsupportedClaim(canonical, gap.claim);
+        break;
+      case "inconsistency":
+        if (gap.detail.startsWith("blocked-none:"))
+          patchBlockedNone();
+        break;
     }
-    if (!negative && targetNegative)
-      return true;
-    return conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token));
-  });
-}
-function isDeterministicallyPatchable(gap) {
-  if (gap.kind === "fabricated-file")
-    return true;
-  if (gap.kind === "inconsistency")
-    return gap.detail.startsWith("blocked-none:");
-  return true;
+  }
+  return renderSummary(canonical, { canonicalHeadings: true });
 }
-function repairSummaryDeterministically(summary, result, extraction, continuity = null, evidence = {}, maxRounds = 3) {
-  const patched = [];
-  const seen = new Set;
-  for (let round = 0;round < maxRounds; round++) {
-    const patchable = result.gaps.filter(isDeterministicallyPatchable);
-    if (!patchable.length)
-      break;
-    const next = patchDeterministic(summary, patchable, extraction, continuity, evidence);
-    if (next === summary)
-      break;
-    for (const gap of patchable) {
-      const key = formatVerificationGap(gap);
-      if (!seen.has(key)) {
-        seen.add(key);
-        patched.push(gap);
-      }
+function hasUnclosedMarkdownFence(markdown) {
+  let open = null;
+  for (const line of markdown.split(/\r?\n/)) {
+    const match = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (!match)
+      continue;
+    const marker = match[1][0];
+    if (!open) {
+      open = { marker, length: match[1].length };
+    } else if (marker === open.marker && match[1].length >= open.length && !match[2].trim()) {
+      open = null;
     }
-    summary = next;
-    result = verifySummary(summary, extraction, continuity, evidence);
   }
-  return { summary, result, patched };
+  return open !== null;
 }
-function addGap(accumulator, gap, penalty) {
-  accumulator.gaps.push(gap);
-  accumulator.score -= penalty;
+function patchResponseIsTruncated(patched, stopReason) {
+  const reason = String(stopReason ?? "");
+  return /(?:length|truncat|max(?:imum)?[_ -]?(?:output[_ -]?)?tokens?|token[_ -]?limit)/i.test(reason) || /\u2026\u2702\d+\s*$/.test(patched) || hasUnclosedMarkdownFence(patched);
 }
-function uniqueByText(items, text) {
-  const seen = new Set;
-  return items.filter((item) => {
-    const key = text(item).toLowerCase().replace(/\s+/g, " ").trim();
-    if (!key || seen.has(key))
-      return false;
-    seen.add(key);
-    return true;
-  });
+function sectionIdentity(section) {
+  return section.kind === "unknown" ? "unknown:" + section.heading.trim().toLowerCase() : section.kind;
 }
-function collectVerificationEvidence(extraction, continuity, evidence) {
-  const unresolved = uniqueByText([
-    ...extraction.errors.flatMap((error2) => !error2.resolved ? [{ message: error2.message }] : []),
-    ...(continuity?.unresolvedErrors ?? []).map((error2) => ({
-      message: error2.message
-    }))
-  ], (item) => item.message);
-  const resolved = uniqueByText([
-    ...extraction.errors.flatMap((error2) => error2.resolved ? [{ message: error2.message }] : []),
-    ...(continuity?.resolvedErrors ?? []).map((error2) => ({
-      message: error2.message
-    }))
-  ], (item) => item.message).slice(-5);
-  const steeringConstraints = [];
-  if (evidence.steering?.focus?.trim()) {
-    steeringConstraints.push({
-      text: "Preserve detail about: " + evidence.steering.focus
-    });
-  }
-  if (evidence.steering?.note?.trim()) {
-    steeringConstraints.push({ text: evidence.steering.note });
+async function patchSummary(summary, gaps, model, auth, signal, services) {
+  const patchPrompt = `Correct every verification finding below WITHOUT restructuring the summary. Add missing evidence, remove fabricated references, and rewrite contradictory claims so they preserve the source constraint/decision polarity. Do not add a Verification Note.
+
+Findings:
+` + gaps.map((gap, index) => index + 1 + ". " + formatVerificationGap(gap)).join(`
+`) + `
+
+Current summary:
+` + summary + `
+
+Return the COMPLETE corrected summary in the same format.`;
+  try {
+    const maxTokens = Math.min(8192, getProviderCaps(model.provider).maxOutputTokens);
+    const response = await trackedComplete("patch", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [
+        {
+          role: "user",
+          content: [{ type: "text", text: patchPrompt }],
+          timestamp: Date.now()
+        }
+      ]
+    }, { apiKey: auth.apiKey, headers: auth.headers, maxTokens, signal }, services);
+    const patched = response.content.filter((content) => content.type === "text").map((content) => content.text).join(`
+`).trim();
+    if (!patched.startsWith("##") || patchResponseIsTruncated(patched, response.stopReason))
+      return summary;
+    const originalSections = parseSummary(summary).sections;
+    const patchedSections = parseSummary(patched).sections;
+    const patchedBodies = new Map(patchedSections.map((section) => [
+      sectionIdentity(section),
+      section.body.trim()
+    ]));
+    const preserved = originalSections.every((section) => !section.body.trim() || Boolean(patchedBodies.get(sectionIdentity(section))));
+    return preserved ? patched : summary;
+  } catch (error2) {
+    debug("patchSummary LLM failed", error2);
+    return summary;
   }
-  const constraints = uniqueByText([
-    ...extraction.constraints.flatMap((item) => item.confidence >= 0.8 ? [{ text: item.text }] : []),
-    ...(continuity?.constraints ?? []).flatMap((item) => item.confidence >= 0.8 ? [{ text: item.text }] : []),
-    ...steeringConstraints
-  ], (item) => item.text).filter((item) => !isDiagnosticConstraintText(item.text));
-  const decisions = uniqueByText([
-    ...extraction.decisions.flatMap((item) => item.type === "explicit" ? [{ summary: item.summary }] : []),
-    ...(continuity?.decisions ?? []).flatMap((item) => item.type === "explicit" ? [{ summary: item.summary }] : [])
-  ], (item) => item.summary);
-  return {
-    unresolved,
-    resolved,
-    constraints,
-    decisions,
-    goal: extraction.mainGoal ?? continuity?.goal ?? null
-  };
 }
-function verifyRequiredSections(parsed, accumulator) {
-  const required = [
-    { kind: "goal", penalty: 5 },
-    { kind: "progress", penalty: 5 },
-    { kind: "critical-context", penalty: 3 }
-  ];
-  for (const item of required) {
-    if (!findSection(parsed, item.kind)) {
-      addGap(accumulator, { kind: "missing-section", section: item.kind }, item.penalty);
-    }
+
+// src/domain/yield-gate.ts
+class YieldGateError extends Error {
+  reason;
+  name = "YieldGateError";
+  constructor(reason, estimate) {
+    super(reason === "target-miss" ? "Final summary estimate misses the planned compaction target" : "Final summary estimate does not meet the minimum saving policy");
+    this.reason = reason;
+    Object.assign(this, estimate);
   }
+  plannedAfterTokens;
+  plannedSavedTokens;
+  plannedYield;
+  estimatedAfterTokens;
+  estimatedSavedTokens;
+  estimatedYield;
+  retainedTailTokens;
+  summaryTokens;
+  summaryBudgetTokens;
+  targetAfterTokens;
+  relaxedSoftBoundaries;
+  hardBoundaryAdjusted;
 }
-function verifyPathCoverage(parsed, extraction, continuity, evidence, accumulator) {
-  const modified = extraction.modifiedFiles.map((file) => file.path);
-  const read = extraction.readFiles;
-  const deleted = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
-  const required = [...modified, ...read, ...deleted];
-  const expected = new Set(required);
-  const rendered = buildSummaryPathEvidence(required, evidence.summaryBudgetTokens);
-  const ownerSets = new Map;
-  for (const file of required) {
-    const display = rendered.get(file);
-    for (const candidate of [
-      file,
-      ...display ? [decodePathDisplay(display)] : []
-    ]) {
-      const normalized = normalizePath(candidate);
-      const owners = ownerSets.get(normalized) ?? new Set;
-      owners.add(file);
-      ownerSets.set(normalized, owners);
-    }
-  }
-  const ownerCounts = new Map(Array.from(ownerSets, ([file, owners]) => [file, owners.size]));
-  const listed = (kind) => collectListedPaths(findSection(parsed, kind)?.body ?? "", expected);
-  const modifiedListed = listed("files-modified");
-  const readListed = listed("files-read");
-  const deletedListed = listed("files-deleted");
-  for (const file of modified) {
-    const display = rendered.get(file);
-    if (display && !hasListedPath(modifiedListed, file, display, ownerCounts)) {
-      addGap(accumulator, { kind: "missing-file", path: file }, 5);
-    }
+function verifyCompactionYield(totalTokens, summaryTokens, plan) {
+  const estimatedAfterTokens = plan.fixedContextTokens + plan.retainedTokens + summaryTokens;
+  const estimatedSavedTokens = Math.max(0, totalTokens - estimatedAfterTokens);
+  const estimatedYield = totalTokens > 0 ? estimatedSavedTokens / totalTokens : 0;
+  const estimate = {
+    plannedAfterTokens: plan.projectedAfterTokens,
+    plannedSavedTokens: plan.projectedSavedTokens,
+    plannedYield: plan.projectedYield,
+    estimatedAfterTokens,
+    estimatedSavedTokens,
+    estimatedYield,
+    retainedTailTokens: plan.retainedTokens,
+    summaryTokens,
+    summaryBudgetTokens: plan.summaryBudgetTokens,
+    targetAfterTokens: plan.targetAfterTokens,
+    relaxedSoftBoundaries: plan.relaxedSoftBoundaries,
+    hardBoundaryAdjusted: plan.hardBoundaryAdjusted
+  };
+  if (estimatedAfterTokens > plan.targetAfterTokens + ESTIMATOR_ROUNDING_TOLERANCE_TOKENS) {
+    throw new YieldGateError("target-miss", estimate);
   }
-  for (const file of read) {
-    const display = rendered.get(file);
-    if (display && !hasListedPath(readListed, file, display, ownerCounts)) {
-      addGap(accumulator, { kind: "missing-read-file", path: file }, 5);
-    }
+  if (estimatedYield < MIN_COMPACTION_SAVING_RATIO) {
+    throw new YieldGateError("insufficient-saving", estimate);
   }
-  for (const file of deleted) {
-    const display = rendered.get(file);
-    if (display && !hasListedPath(deletedListed, file, display, ownerCounts)) {
-      addGap(accumulator, { kind: "missing-deleted-file", path: file }, 5);
-    }
+  return estimate;
+}
+
+// src/ui/error-format.ts
+function failureAction(kind) {
+  switch (kind) {
+    case "authentication":
+      return "Check the selected model's credentials or use /login.";
+    case "rate-limit":
+      return "Wait for the provider quota to recover before retrying.";
+    case "timeout":
+      return "Try Fast or review the latency budget in /smart-compact settings.";
+    case "budget":
+      return "Review call/token limits in /smart-compact settings.";
+    case "output-limit":
+      return "Review the model output limit and reasoning level.";
+    case "provider":
+    case "validation":
+      return "Check model availability and /smart-compact metrics; select another route manually if needed.";
+    case "cancelled":
+      return "Retry when ready.";
+    default:
+      return "For local stack diagnostics, restart Pi with DEBUG=smart-compact and reproduce.";
   }
-  return { modified, read, deleted, rendered };
 }
-function verifyErrorEvidence(normalizedSummary, collected, accumulator) {
-  for (const error2 of collected.unresolved) {
-    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
-    if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
-      addGap(accumulator, { kind: "missing-error", message: error2.message }, 5);
-    }
+function formatGenerationFailureForUi(error2) {
+  const kind = classifyTelemetryFailure(error2);
+  return kind + ". " + failureAction(kind);
+}
+function formatCompactErrorForUi(error2) {
+  if (error2 instanceof VerificationGateError) {
+    const kinds = error2.gapKinds.slice(0, 4).join(", ") || "unknown";
+    return "Verification stopped apply at the " + error2.stage + " gate: " + error2.score + "/100, " + error2.gapCount + (error2.gapCount === 1 ? " unresolved gap [" : " unresolved gaps [") + kinds + "]. Conversation unchanged. " + "Review /smart-compact metrics; do not bypass verification. For local evidence, restart Pi with DEBUG=smart-compact.";
   }
-  for (const error2 of collected.resolved) {
-    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
-    if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
-      addGap(accumulator, { kind: "missing-error", message: error2.message, resolved: true }, 2);
-    }
+  if (error2 instanceof YieldGateError) {
+    const reason = error2.reason === "target-miss" ? "target missed" : "saving below 10%";
+    return "Yield check stopped apply: estimated " + error2.estimatedAfterTokens.toLocaleString() + "t after vs " + error2.targetAfterTokens.toLocaleString() + "t target (" + reason + "). Conversation unchanged. Try /smart-compact balanced for a larger target; safety checks still apply.";
   }
+  return "Smart compact failed [" + classifyTelemetryFailure(error2) + "]. Conversation unchanged. " + failureAction(classifyTelemetryFailure(error2));
 }
-function verifySemanticCoverage(parsed, collected, accumulator) {
-  const constraintTarget = [
-    findSection(parsed, "constraints")?.body ?? "",
-    findSection(parsed, "critical-context")?.body ?? ""
-  ].join(`
-`);
-  for (const constraint of collected.constraints) {
-    if (!hasSemanticEvidence(constraint.text, constraintTarget)) {
-      addGap(accumulator, { kind: "missing-constraint", text: constraint.text }, 8);
-    }
-    if (hasSemanticContradiction(constraint.text, constraintTarget)) {
-      addGap(accumulator, {
-        kind: "inconsistency",
-        detail: "semantic-contradiction: constraint contradicts " + constraint.text.slice(0, TRUNC.SNIPPET)
-      }, 20);
-    }
-  }
-  if (collected.goal) {
-    const goalTarget = findSection(parsed, "goal")?.body ?? "";
-    if (!hasSemanticEvidence(collected.goal, goalTarget)) {
-      addGap(accumulator, { kind: "missing-goal", goal: collected.goal }, 12);
-    }
-    if (hasSemanticContradiction(collected.goal, goalTarget)) {
-      addGap(accumulator, {
-        kind: "inconsistency",
-        detail: "semantic-contradiction: goal polarity or condition changed"
-      }, 20);
+
+// src/app/steps/synthesize.ts
+async function summarizeConversation(rc) {
+  let synthPhaseStart = Date.now();
+  const extraction = rc.extraction;
+  rc.mode ??= rc.profile ? modeFromLegacyProfile(rc.profile) : "balanced";
+  rc.requestedMode ??= rc.mode;
+  if (rc.requestedMode === "auto") {
+    const refined = resolveMode("auto", rc.contextPercent, extraction, continuityRisk(rc.previousState) + (rc.adapted ? 12 : 0));
+    if (refined !== rc.mode) {
+      rc.mode = refined;
+      const policy2 = MODE_POLICIES[refined];
+      rc.services.budget.setLimits(resolveCallBudget(rc.config.maxLlmCalls, refined, rc.maxLlmCalls, rc.flags.autoTriggered && !rc.flags.skipCompact), effectiveBudget(rc.config.maxLlmInputTokens, policy2.maxInputTokens, rc.maxLlmInputTokens), policy2.maxOutputTokens);
+      rc.notify("Auto strategy refined to " + refined + " within the planned " + rc.profile + " window", "info");
     }
   }
-  const decisionBody = findSection(parsed, "decisions")?.body ?? "";
-  for (const decision of collected.decisions) {
-    if (!hasSemanticEvidence(decision.summary, decisionBody)) {
-      addGap(accumulator, { kind: "missing-decision", summary: decision.summary }, 8);
-    }
-    if (hasSemanticContradiction(decision.summary, decisionBody)) {
-      addGap(accumulator, {
-        kind: "inconsistency",
-        detail: "semantic-contradiction: decision contradicts " + decision.summary.slice(0, TRUNC.SNIPPET)
-      }, 20);
-    }
+  const pc = rc.profileCfg;
+  const policy = MODE_POLICIES[rc.mode];
+  const cacheKey = synthesisCacheKey(rc);
+  const cached = getCachedSynthesis(cacheKey);
+  if (cached) {
+    rc.notify("Synthesis cache hit \u2014 no LLM calls", "info");
+    showProgressOverlay(rc.ctx, {
+      phase: 3,
+      phaseName: "Synthesize",
+      detail: "Reusing the cached continuation summary \xB7 no LLM call"
+    });
+    Object.assign(rc, {
+      finalSummary: cached.finalSummary,
+      method: cached.method,
+      methodForMetrics: cached.method + "-cache",
+      generationFallbacks: [],
+      llmCalls: 0,
+      summaries: cached.summaries,
+      explorationReport: cached.explorationReport,
+      explorationRounds: cached.explorationRounds,
+      chunkCount: cached.chunkCount
+    });
+    const hit = advance(rc, "_synthesized");
+    markMeasuredPhase(hit, "synthesize", synthPhaseStart);
+    return hit;
   }
-}
-function verifyFileReferences(summary, extraction, continuity, evidence, collected, paths, accumulator) {
-  const groundedEvidence = [
-    ...collected.unresolved.map((item) => item.message),
-    ...collected.resolved.map((item) => item.message),
-    ...collected.constraints.map((item) => item.text),
-    ...collected.decisions.map((item) => item.summary),
-    ...collected.goal ? [collected.goal] : [],
-    ...extraction.lastUserMessages,
-    ...extraction.timeline.map((item) => item.summary),
-    ...extraction.topics.map((item) => item.primaryFile ?? ""),
-    ...continuity?.openLoops.map((item) => item.summary) ?? [],
-    ...continuity?.criticalContext ?? []
-  ];
-  const groundedFiles = groundedEvidence.flatMap((value) => [
-    value,
-    summaryEvidenceLine(value, TRUNC.ERROR_SNIPPET),
-    summaryEvidenceLine(value, TRUNC.TOPIC_LABEL),
-    summaryEvidenceLine(value, TRUNC.PREVIEW),
-    summaryEvidenceLine(value, TRUNC.MESSAGE)
-  ]).flatMap(extractFileRefs);
-  const renderedPaths = Array.from(paths.rendered.values()).flatMap((line) => [
-    decodePathDisplay(line),
-    line.startsWith('"') && line.endsWith('"') ? line.slice(1, -1) : line
-  ]);
-  const knownFiles = Array.from(new Set([
-    ...paths.modified,
-    ...paths.read,
-    ...paths.deleted,
-    ...extraction.referencedFiles ?? [],
-    ...groundedFiles,
-    ...renderedPaths,
-    ...renderedPaths.flatMap(extractFileRefs),
-    ...continuity?.modifiedFiles ?? [],
-    ...continuity?.readFiles ?? [],
-    ...(continuity?.unresolvedErrors ?? []).flatMap((error2) => error2.files),
-    ...(continuity?.openLoops ?? []).flatMap((loop) => loop.files)
-  ]));
-  for (const ref of new Set(extractFileRefs(summary))) {
-    const grounded = isKnownPathReference(ref, knownFiles) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
-    if (!grounded)
-      addGap(accumulator, { kind: "fabricated-file", ref }, 4);
+  const zeroCall = rc.config.zeroCallEnabled !== false && rc.mode === "fast" && !rc.focus && !rc.userNote && deterministicExtractionConfidence(extraction, {
+    conversationTokens: rc.convTokens,
+    toolPercent: rc.toolPercent
+  }) >= 0.85;
+  if (zeroCall) {
+    showProgressOverlay(rc.ctx, {
+      phase: 3,
+      phaseName: "Synthesize",
+      detail: "Building a deterministic continuation summary \xB7 no LLM call"
+    });
+    const finalSummary2 = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
+    setCachedSynthesis(cacheKey, {
+      finalSummary: finalSummary2,
+      method: "heuristic",
+      summaries: [],
+      explorationReport: null,
+      explorationRounds: 0,
+      chunkCount: 0
+    });
+    rc.notify("Zero-call deterministic compaction (high-confidence extraction)", "info");
+    Object.assign(rc, {
+      finalSummary: finalSummary2,
+      method: "heuristic",
+      methodForMetrics: "zero-call",
+      generationFallbacks: [],
+      llmCalls: 0,
+      summaries: [],
+      explorationReport: null,
+      explorationRounds: 0,
+      chunkCount: 0
+    });
+    const deterministic = advance(rc, "_synthesized");
+    markMeasuredPhase(deterministic, "synthesize", synthPhaseStart);
+    return deterministic;
   }
-}
-function verifyProgressConsistency(parsed, extraction, collected, paths, accumulator) {
-  const progress = findSection(parsed, "progress");
-  if (!progress)
-    return;
-  const done = progress.body.match(/###\s*Done[\s\S]*?(?=###|$)/i)?.[0] ?? "";
-  const blocked = progress.body.match(/###\s*Blocked[\s\S]*?(?=###|$)/i)?.[0] ?? "";
-  if (collected.unresolved.length > 0 && noneBlockerLineIndexes(blocked.split(/\r?\n/).slice(1)).size > 0) {
-    addGap(accumulator, {
-      kind: "inconsistency",
-      detail: "blocked-none: Blocked says none despite unresolved errors"
-    }, 12);
+  const shouldSkipExplore = !policy.explore;
+  const convText = rc.convText;
+  const singlePassMaxTokens = Math.round(pc.singlePassMaxTokens * rc.providerCaps.singlePassTokenMultiplier * policy.singlePassMultiplier);
+  rc.vlog("Tier=" + rc.tier + " | convTokens=" + rc.convTokens + " | singlePassMax=" + singlePassMaxTokens);
+  let finalSummary;
+  let method;
+  const summaries = [];
+  let explorationReport = null;
+  let explorationRounds = 0;
+  let chunkCount = 0;
+  let cacheable = true;
+  const generationFallbacks = [];
+  let summaryAuth;
+  try {
+    summaryAuth = await resolveStageAuth(rc, "summary");
+  } catch (error2) {
+    cacheable = false;
+    generationFallbacks.push("summary route unavailable");
+    debugError("Summary route unavailable", error2);
+    rc.notify("Summary route unavailable \xB7 using deterministic fallback [" + formatGenerationFailureForUi(error2) + "]", "warning");
   }
-  const doneRefs = new Set(extractFileRefs(done).map(normalizePath));
-  for (const file of extraction.modifiedFiles) {
-    const needles = buildUniquePathNeedles(file.path, paths.modified);
-    if (!needles.some((needle) => doneRefs.has(normalizePath(needle))))
-      continue;
-    const unresolved = collected.unresolved.find((error2) => {
-      const firstLine = error2.message.split(/\r?\n/, 1)[0] ?? "";
-      const refs = extractFileRefs(firstLine).map(normalizePath);
-      return needles.some((needle) => refs.includes(normalizePath(needle)));
+  if (!summaryAuth) {
+    showProgressOverlay(rc.ctx, {
+      phase: 3,
+      phaseName: "Synthesize",
+      detail: "Summary route unavailable \xB7 building a deterministic summary"
     });
-    if (unresolved) {
-      addGap(accumulator, {
-        kind: "inconsistency",
-        detail: file.path + " marked Done but has unresolved error"
-      }, 5);
+    finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
+    method = "heuristic";
+  } else if (rc.convTokens < singlePassMaxTokens) {
+    showProgressOverlay(rc.ctx, {
+      phase: 3,
+      phaseName: "Synthesize",
+      detail: "Writing one continuation summary from " + rc.convTokens.toLocaleString() + " tokens",
+      model: rc.modelLabel,
+      profile: rc.profile,
+      extraction
+    });
+    try {
+      const r = await singlePassCompact(convText, extraction, null, rc.prevContext + rc.projectCtx, rc.summaryModel, summaryAuth, pc.summaryBudgetTokens, rc.cancellation.signal, rc.services, rc.config.focusWeighting ? rc.focus : undefined);
+      finalSummary = r.summary;
+      method = "single-pass";
+    } catch (err) {
+      cacheable = false;
+      generationFallbacks.push("single-pass generation failed");
+      debugError("Single-pass synthesis used deterministic fallback", err);
+      rc.notify("Single-pass generation stopped \xB7 using deterministic fallback [" + formatGenerationFailureForUi(err) + "]", "warning");
+      finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
+      method = "heuristic";
     }
-  }
-}
-function verifyOpenLoopsAndClaims(summary, parsed, extraction, continuity, evidence, collected, accumulator) {
-  const unresolvedCount = collected.unresolved.length + (continuity?.openLoops.filter((loop) => loop.status !== "resolved").length ?? 0);
-  if (unresolvedCount >= 1 && !findSection(parsed, "open-loops") && !summary.toLowerCase().replace(/\\/g, "/").includes("unresolved")) {
-    addGap(accumulator, { kind: "missing-open-loops", unresolvedCount }, 5);
-  }
-  if (!evidence.sourceMessages)
-    return;
-  const tools = successfulToolEvidence(evidence.sourceMessages);
-  for (const claim of outcomeClaims(summary)) {
-    if (!successfulToolSupportsClaim(claim, tools, extraction)) {
-      addGap(accumulator, { kind: "unsupported-claim", claim }, 20);
+  } else {
+    const needsExploration = !shouldSkipExplore && shouldExplore(extraction);
+    if (needsExploration) {
+      const exploreStart = Date.now();
+      showProgressOverlay(rc.ctx, {
+        phase: 2,
+        phaseName: "Explore",
+        detail: "Mapping topic shifts and continuity risks",
+        model: rc.modelLabel,
+        profile: rc.profile,
+        extraction
+      });
+      try {
+        const segAuth = await resolveStageAuth(rc, "explore");
+        const expResult = await exploreConversation(rc.llmMessages, extraction, rc.segModel, segAuth, rc.prevContext || undefined, [
+          rc.userNote,
+          rc.config.focusWeighting && rc.focus ? "Focus extra preservation on: " + rc.focus : undefined
+        ].filter(Boolean).join(`
+`) || undefined, rc.cancellation.signal, MAX_EXPLORATION_ROUNDS, rc.notify, rc.services);
+        explorationReport = expResult.report;
+        explorationRounds = expResult.rounds;
+        rc.notify("Phase 2 Explore: " + expResult.rounds + " rounds, " + explorationReport.boundaries.length + " boundaries" + (expResult.toolSupported ? "" : " (no tool support)"), "info");
+        rc.vlog("Explore boundaries: " + explorationReport.boundaries.map((b) => b.afterIndex + "(" + b.confidence.toFixed(2) + ")").join(", "));
+      } catch (err) {
+        cacheable = false;
+        generationFallbacks.push("exploration unavailable");
+        debugError("Explore used deterministic topic boundaries", err);
+        rc.notify("Explore unavailable \xB7 using deterministic topic boundaries", "info");
+      } finally {
+        const exploreEnd = Date.now();
+        markMeasuredPhase(rc, "explore", exploreStart, exploreEnd);
+        synthPhaseStart = exploreEnd;
+      }
+    } else {
+      rc.notify("Phase 2 Explore: skipped (simple session: " + extraction.topics.length + " topics, " + extraction.errors.filter((e) => !e.resolved).length + " unresolved errors)", "info");
     }
-  }
-}
-function verifySummary(summary, extraction, continuity = null, evidence = {}) {
-  const parsed = parseSummary(summary);
-  const accumulator = { gaps: [], score: 100 };
-  const collected = collectVerificationEvidence(extraction, continuity, evidence);
-  verifyRequiredSections(parsed, accumulator);
-  const paths = verifyPathCoverage(parsed, extraction, continuity, evidence, accumulator);
-  verifyErrorEvidence(summary.toLowerCase().replace(/\\/g, "/").replace(/\s+/g, " "), collected, accumulator);
-  verifySemanticCoverage(parsed, collected, accumulator);
-  verifyFileReferences(summary, extraction, continuity, evidence, collected, paths, accumulator);
-  verifyProgressConsistency(parsed, extraction, collected, paths, accumulator);
-  verifyOpenLoopsAndClaims(summary, parsed, extraction, continuity, evidence, collected, accumulator);
-  const score = Math.max(0, accumulator.score);
-  return {
-    ok: accumulator.gaps.length === 0 && score >= 85,
-    gaps: accumulator.gaps,
-    score
-  };
-}
-function patchDeterministic(summary, gaps, extraction, continuity = null, evidence = {}) {
-  let canonical = parseSummary(summary);
-  const modifiedPaths = extraction.modifiedFiles.map((file) => file.path);
-  const readPaths = extraction.readFiles;
-  const deletedPaths = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
-  const pathEvidence = buildSummaryPathEvidence([...modifiedPaths, ...readPaths, ...deletedPaths], evidence.summaryBudgetTokens);
-  const replaceFileSection = (kind, paths) => {
-    const body = paths.map((path12) => "- " + (pathEvidence.get(path12) ?? JSON.stringify(path12))).join(`
-`);
-    canonical = upsertSection(canonical, kind, body || "- None recorded.");
-  };
-  const safe = (value, max = TRUNC.MESSAGE) => summaryEvidenceLine(value, max);
-  const unresolvedMessages = Array.from(new Set([
-    ...extraction.errors.filter((error2) => !error2.resolved).map((error2) => error2.message),
-    ...(continuity?.unresolvedErrors ?? []).map((error2) => error2.message)
-  ]));
-  const unresolvedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved");
-  const blockedItems = [
-    ...unresolvedMessages.map((message) => safe(message)).filter(Boolean).map((message) => "- " + message),
-    ...unresolvedLoops.map((loop) => safe(loop.summary)).filter(Boolean).map((summary2) => "- " + summary2)
-  ];
-  const patchBlockedNone = () => {
-    const progress = findSection(canonical, "progress");
-    if (!progress || !blockedItems.length)
-      return;
-    const lines = progress.body.split(/\r?\n/);
-    const start = lines.findIndex((line) => /^###\s*Blocked\s*$/i.test(line.trim()));
-    if (start < 0)
-      return;
-    let end = lines.findIndex((line, index) => index > start && /^###\s+/.test(line.trim()));
-    if (end < 0)
-      end = lines.length;
-    const existing = lines.slice(start + 1, end);
-    const noneIndexes = noneBlockerLineIndexes(existing);
-    if (!noneIndexes.size)
-      return;
-    const replacement = Array.from(new Set([
-      ...blockedItems,
-      ...existing.filter((line, index) => line.trim() && !noneIndexes.has(index))
-    ]));
-    lines.splice(start + 1, end - start - 1, ...replacement);
-    canonical = upsertSection(canonical, "progress", lines.join(`
-`));
-  };
-  for (const gap of gaps) {
-    switch (gap.kind) {
-      case "missing-section": {
-        if (gap.section === "goal") {
-          canonical = upsertSection(canonical, "goal", safe(extraction.mainGoal ?? "", TRUNC.DETAIL) || "Continue the current coding task.");
-        } else if (gap.section === "progress") {
-          canonical = upsertSection(canonical, "progress", `### Done
-- No explicit completion recorded.
-### In Progress
-- Continue from the latest user request.
-### Blocked
-` + (blockedItems.join(`
-`) || "- None recorded."));
-        } else if (gap.section === "critical-context") {
-          const critical = unresolvedMessages.flatMap((message) => {
-            const text = safe(message);
-            return text ? ["- Unresolved error: " + text] : [];
-          });
-          canonical = upsertSection(canonical, "critical-context", critical.join(`
-`) || "- None recorded.");
+    let boundaries;
+    if (explorationReport?.boundaries.length) {
+      const llmBounds = explorationReport.boundaries.filter((b) => b.confidence >= 0.4);
+      const heuristicBounds = extraction.topics.map((t) => ({
+        afterIndex: t.endIndex,
+        topic: t.primaryFile ? "Working on " + t.primaryFile.split("/").pop() : "Segment",
+        priority: t.errorDensity > 2 ? "high" : "normal",
+        confidence: 0.6
+      }));
+      if (llmBounds.length > 0) {
+        const merged = [...llmBounds];
+        for (const hb of heuristicBounds) {
+          const nearby = merged.find((m) => Math.abs(m.afterIndex - hb.afterIndex) <= 3);
+          if (!nearby)
+            merged.push(hb);
         }
-        break;
+        boundaries = merged.sort((a, b) => a.afterIndex - b.afterIndex);
+      } else {
+        boundaries = heuristicBounds;
       }
-      case "missing-file":
-        replaceFileSection("files-modified", modifiedPaths);
-        break;
-      case "missing-read-file":
-        replaceFileSection("files-read", readPaths);
-        break;
-      case "missing-deleted-file":
-        replaceFileSection("files-deleted", deletedPaths);
-        break;
-      case "missing-error": {
-        const existing = findSection(canonical, "critical-context")?.body.toLowerCase() ?? "";
-        const message = safe(gap.message);
-        if (!existing.includes(message.toLowerCase())) {
-          canonical = appendToSection(canonical, "critical-context", "- " + (gap.resolved ? "Resolved error: " : "Unresolved error: ") + message);
+    } else {
+      boundaries = extraction.topics.map((t) => ({
+        afterIndex: t.endIndex,
+        topic: t.primaryFile ? "Working on " + t.primaryFile.split("/").pop() : "Segment",
+        priority: t.errorDensity > 2 ? "high" : "normal",
+        confidence: 0.6
+      }));
+    }
+    const chunks = chunkLlmMessages(rc.llmMessages, boundaries, pc, rc.estimator, rc.config.focusWeighting ? rc.focus : undefined);
+    chunkCount = chunks.length;
+    rc.notify("Chunked: " + chunkCount + " chunks", "info");
+    rc.vlog("Chunk topics: " + chunks.map((c) => c.topic + "[" + c.startIndex + "-" + c.endIndex + "]").join(", "));
+    const batches = createBatches(chunks, pc.batchMaxTokens);
+    const totalBatches = batches.length;
+    showProgressOverlay(rc.ctx, {
+      phase: 3,
+      phaseName: "Synthesize",
+      detail: "Compressing older history \xB7 batch 0/" + totalBatches,
+      model: rc.modelLabel,
+      profile: rc.profile,
+      extraction,
+      explorationRounds,
+      totalBatches
+    });
+    const concurrency = rc.providerCaps.concurrencyLimit;
+    if (totalBatches <= 1) {
+      const single = batches[0];
+      if (single) {
+        if (rc.services.budget.remainingCalls() <= 1) {
+          summaries.push(...single.map((ch) => failedChunkSummary(ch)));
+          cacheable = false;
+          generationFallbacks.push("call budget reserved for final assembly");
+          rc.notify("Call budget: chunk synthesis uses deterministic evidence so final assembly remains available", "info");
+        } else {
+          try {
+            summaries.push(...await summarizeBatch(single, extraction, rc.summaryModel, summaryAuth, rc.cancellation.signal, rc.services, batchOutputLimit(rc.mode, single.length, rc.providerCaps.maxOutputTokens), rc.sessionId));
+          } catch (err) {
+            summaries.push(...single.map((ch) => failedChunkSummary(ch)));
+            cacheable = false;
+            generationFallbacks.push("1 synthesis batch fallback");
+            debugError("Synthesis batch used deterministic fallback", err);
+            rc.notify("Synthesis batch stopped \xB7 deterministic evidence fallback preserved coverage [" + formatGenerationFailureForUi(err) + "]", "warning");
+            showProgressOverlay(rc.ctx, {
+              phase: 3,
+              phaseName: "Synthesize",
+              detail: "1 batch fallback \xB7 preserving coverage from deterministic evidence",
+              explorationRounds
+            });
+          }
+        }
+      } else {
+        rc.vlog("Synthesize: 0 batches \u2014 skipping summarization, using fallback assembly");
+      }
+    } else {
+      const results = new Array(totalBatches);
+      const errors = new Array(totalBatches).fill(null);
+      const batchCallLimit = Math.max(0, Math.min(totalBatches, rc.services.budget.remainingCalls() - 1));
+      for (let index = batchCallLimit;index < totalBatches; index++) {
+        results[index] = batches[index].map((chunk) => failedChunkSummary(chunk));
+      }
+      if (batchCallLimit < totalBatches) {
+        rc.notify("Call budget: " + (totalBatches - batchCallLimit) + " batch(es) use deterministic fallback to reserve assembly", "info");
+        cacheable = false;
+        generationFallbacks.push(totalBatches - batchCallLimit + " synthesis batch budget fallback(s)");
+      }
+      let completed = totalBatches - batchCallLimit;
+      let nextBatch = 0;
+      let budgetStopped = false;
+      const runWorker = async () => {
+        while (true) {
+          const idx = nextBatch++;
+          if (idx >= batchCallLimit)
+            return;
+          if (budgetStopped || rc.services.budget.reason()) {
+            budgetStopped = true;
+            results[idx] = batches[idx].map((chunk) => failedChunkSummary(chunk));
+          } else {
+            try {
+              const batch = batches[idx];
+              results[idx] = await summarizeBatch(batch, extraction, rc.summaryModel, summaryAuth, rc.cancellation.signal, rc.services, batchOutputLimit(rc.mode, batch.length, rc.providerCaps.maxOutputTokens), rc.sessionId);
+            } catch (err) {
+              errors[idx] = err instanceof Error ? err : new Error(String(err));
+              results[idx] = batches[idx].map((chunk) => failedChunkSummary(chunk));
+            }
+          }
+          completed++;
+          showProgressOverlay(rc.ctx, {
+            phase: 3,
+            phaseName: "Synthesize",
+            detail: "Compressing older history \xB7 batch " + completed + "/" + totalBatches,
+            model: rc.modelLabel,
+            profile: rc.profile,
+            extraction,
+            explorationRounds,
+            totalBatches,
+            currentBatch: completed
+          });
         }
-        break;
-      }
-      case "missing-constraint":
-        canonical = appendToSection(canonical, "constraints", "- " + safe(gap.text, TRUNC.CONSTRAINT_TEXT));
-        break;
-      case "missing-decision":
-        canonical = appendToSection(canonical, "decisions", "- **" + safe(gap.summary, TRUNC.DECISION_SUMMARY) + "**");
-        break;
-      case "missing-goal":
-        canonical = upsertSection(canonical, "goal", safe(gap.goal, TRUNC.DETAIL) || "Continue the current task.");
-        break;
-      case "missing-open-loops": {
-        const current = extraction.errors.filter((error2) => !error2.resolved).map((error2) => safe(error2.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
-        const carriedErrors = (continuity?.unresolvedErrors ?? []).map((error2) => safe(error2.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
-        const carriedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved").map((loop) => ({
-          priority: loop.priority,
-          summary: safe(loop.summary, TRUNC.SNIPPET)
-        })).filter((item) => item.summary).map((item) => "- [" + item.priority + "] " + item.summary);
-        const body = Array.from(new Set([...current, ...carriedErrors, ...carriedLoops])).slice(0, gap.unresolvedCount).join(`
-`);
-        canonical = upsertSection(canonical, "open-loops", body || "- Review unresolved errors.", "next-steps");
-        break;
+      };
+      const workerCount = Math.max(1, Math.min(concurrency, batchCallLimit));
+      await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+      if (budgetStopped) {
+        rc.notify("Synthesis budget reached \xB7 remaining batches use deterministic fallback", "info");
+        cacheable = false;
+        generationFallbacks.push("synthesis budget exhausted during batch pool");
       }
-      case "fabricated-file": {
-        const normalizedRef = gap.ref.replace(/\\/g, "/").toLowerCase();
-        canonical = {
-          sections: canonical.sections.map((section) => ({
-            ...section,
-            body: section.body.split(`
-`).filter((line) => {
-              if (!/^\s*[-*]\s+/.test(line))
-                return true;
-              const matches = extractFileRefs(line).some((ref) => ref.replace(/\\/g, "/").toLowerCase() === normalizedRef);
-              return !matches;
-            }).join(`
-`).trim()
-          }))
-        };
-        break;
+      for (const r of results)
+        if (r)
+          summaries.push(...r);
+      const failedBatches = errors.filter(Boolean);
+      for (const error2 of failedBatches)
+        debugError("Synthesis batch used deterministic fallback", error2);
+      if (failedBatches.length) {
+        cacheable = false;
+        generationFallbacks.push(failedBatches.length + " synthesis batch fallback(s)");
+        rc.notify(failedBatches.length + " synthesis batch(es) stopped \xB7 deterministic evidence fallback preserved coverage [" + formatGenerationFailureForUi(failedBatches[0]) + "]", "warning");
+        showProgressOverlay(rc.ctx, {
+          phase: 3,
+          phaseName: "Synthesize",
+          detail: failedBatches.length + " batch fallback(s) \xB7 preserving coverage from deterministic evidence",
+          explorationRounds
+        });
       }
-      case "unsupported-claim":
-        canonical = removeUnsupportedClaim(canonical, gap.claim);
-        break;
-      case "inconsistency":
-        if (gap.detail.startsWith("blocked-none:"))
-          patchBlockedNone();
-        break;
     }
-  }
-  return renderSummary(canonical, { canonicalHeadings: true });
-}
-function hasUnclosedMarkdownFence(markdown) {
-  let open = null;
-  for (const line of markdown.split(/\r?\n/)) {
-    const match = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
-    if (!match)
-      continue;
-    const marker = match[1][0];
-    if (!open) {
-      open = { marker, length: match[1].length };
-    } else if (marker === open.marker && match[1].length >= open.length && !match[2].trim()) {
-      open = null;
+    showProgressOverlay(rc.ctx, {
+      phase: 3,
+      phaseName: "Synthesize",
+      detail: "Merging summaries with project continuity",
+      model: rc.modelLabel,
+      profile: rc.profile,
+      extraction,
+      explorationRounds,
+      totalBatches: batches.length
+    });
+    method = "eesv";
+    try {
+      const r = await assembleLLM(summaries, extraction, explorationReport, rc.summaryModel, summaryAuth, pc.summaryBudgetTokens, rc.prevContext, rc.cancellation.signal, rc.services, rc.config.focusWeighting ? rc.focus : undefined, rc.previousState);
+      if (r?.startsWith("##"))
+        finalSummary = r;
+      else
+        throw new Error("Invalid summary response");
+    } catch (err) {
+      cacheable = false;
+      generationFallbacks.push("assembly generation failed");
+      debugError("Assembly used deterministic fallback", err);
+      rc.notify("Assembly stopped \xB7 using deterministic fallback [" + formatGenerationFailureForUi(err) + "]", "warning");
+      method = "heuristic";
+      finalSummary = assembleFallback(summaries, extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
     }
   }
-  return open !== null;
-}
-function patchResponseIsTruncated(patched, stopReason) {
-  const reason = String(stopReason ?? "");
-  return /(?:length|truncat|max(?:imum)?[_ -]?(?:output[_ -]?)?tokens?|token[_ -]?limit)/i.test(reason) || /\u2026\u2702\d+\s*$/.test(patched) || hasUnclosedMarkdownFence(patched);
-}
-function sectionIdentity(section) {
-  return section.kind === "unknown" ? "unknown:" + section.heading.trim().toLowerCase() : section.kind;
-}
-async function patchSummary(summary, gaps, model, auth, signal, services) {
-  const patchPrompt = `Correct every verification finding below WITHOUT restructuring the summary. Add missing evidence, remove fabricated references, and rewrite contradictory claims so they preserve the source constraint/decision polarity. Do not add a Verification Note.
-
-Findings:
-` + gaps.map((gap, index) => index + 1 + ". " + formatVerificationGap(gap)).join(`
-`) + `
-
-Current summary:
-` + summary + `
-
-Return the COMPLETE corrected summary in the same format.`;
-  try {
-    const maxTokens = Math.min(8192, getProviderCaps(model.provider).maxOutputTokens);
-    const response = await trackedComplete("patch", model, {
-      systemPrompt: COMPACT_SYSTEM_PREFIX,
-      messages: [
-        {
-          role: "user",
-          content: [{ type: "text", text: patchPrompt }],
-          timestamp: Date.now()
-        }
-      ]
-    }, { apiKey: auth.apiKey, headers: auth.headers, maxTokens, signal }, services);
-    const patched = response.content.filter((content) => content.type === "text").map((content) => content.text).join(`
-`).trim();
-    if (!patched.startsWith("##") || patchResponseIsTruncated(patched, response.stopReason))
-      return summary;
-    const originalSections = parseSummary(summary).sections;
-    const patchedSections = parseSummary(patched).sections;
-    const patchedBodies = new Map(patchedSections.map((section) => [
-      sectionIdentity(section),
-      section.body.trim()
-    ]));
-    const preserved = originalSections.every((section) => !section.body.trim() || Boolean(patchedBodies.get(sectionIdentity(section))));
-    return preserved ? patched : summary;
-  } catch (error2) {
-    debug("patchSummary LLM failed", error2);
-    return summary;
+  Object.assign(rc, {
+    finalSummary,
+    method,
+    methodForMetrics: method,
+    generationFallbacks,
+    llmCalls: rc.services.metrics.summary().totalCalls,
+    summaries,
+    explorationReport,
+    explorationRounds,
+    chunkCount
+  });
+  const out = advance(rc, "_synthesized");
+  if (cacheable) {
+    setCachedSynthesis(cacheKey, {
+      finalSummary,
+      method,
+      summaries,
+      explorationReport,
+      explorationRounds,
+      chunkCount
+    });
   }
+  markMeasuredPhase(out, "synthesize", synthPhaseStart);
+  return out;
 }
 
 // src/app/steps/verify.ts
@@ -10114,57 +10392,6 @@ async function verifyAndPatch(rc) {
 // src/app/steps/state.ts
 import fs8 from "fs";
 import path12 from "path";
-
-// src/domain/yield-gate.ts
-class YieldGateError extends Error {
-  reason;
-  name = "YieldGateError";
-  constructor(reason, estimate) {
-    super(reason === "target-miss" ? "Final summary estimate misses the planned compaction target" : "Final summary estimate does not meet the minimum saving policy");
-    this.reason = reason;
-    Object.assign(this, estimate);
-  }
-  plannedAfterTokens;
-  plannedSavedTokens;
-  plannedYield;
-  estimatedAfterTokens;
-  estimatedSavedTokens;
-  estimatedYield;
-  retainedTailTokens;
-  summaryTokens;
-  summaryBudgetTokens;
-  targetAfterTokens;
-  relaxedSoftBoundaries;
-  hardBoundaryAdjusted;
-}
-function verifyCompactionYield(totalTokens, summaryTokens, plan) {
-  const estimatedAfterTokens = plan.fixedContextTokens + plan.retainedTokens + summaryTokens;
-  const estimatedSavedTokens = Math.max(0, totalTokens - estimatedAfterTokens);
-  const estimatedYield = totalTokens > 0 ? estimatedSavedTokens / totalTokens : 0;
-  const estimate = {
-    plannedAfterTokens: plan.projectedAfterTokens,
-    plannedSavedTokens: plan.projectedSavedTokens,
-    plannedYield: plan.projectedYield,
-    estimatedAfterTokens,
-    estimatedSavedTokens,
-    estimatedYield,
-    retainedTailTokens: plan.retainedTokens,
-    summaryTokens,
-    summaryBudgetTokens: plan.summaryBudgetTokens,
-    targetAfterTokens: plan.targetAfterTokens,
-    relaxedSoftBoundaries: plan.relaxedSoftBoundaries,
-    hardBoundaryAdjusted: plan.hardBoundaryAdjusted
-  };
-  if (estimatedAfterTokens > plan.targetAfterTokens + ESTIMATOR_ROUNDING_TOLERANCE_TOKENS) {
-    throw new YieldGateError("target-miss", estimate);
-  }
-  if (estimatedYield < MIN_COMPACTION_SAVING_RATIO) {
-    throw new YieldGateError("insufficient-saving", estimate);
-  }
-  return estimate;
-}
-
-// src/app/steps/state.ts
 function buildState(rc) {
   const extraction = rc.extraction;
   let summary = rc.finalSummary;
@@ -10226,7 +10453,8 @@ function buildState(rc) {
   compactionState = rc.services.scrubber.scrubValue(compactionState).value;
   const verificationEvidence = {
     sourceMessages: rc.llmMessages,
-    steering: { focus: rc.focus, note: rc.userNote }
+    steering: { focus: rc.focus, note: rc.userNote },
+    summaryBudgetTokens: rc.profileCfg?.summaryBudgetTokens ?? 6000
   };
   let postVerification = verifySummary(summary, extraction, compactionState, verificationEvidence);
   const postInitialScore = postVerification.score;
@@ -11055,11 +11283,14 @@ function aggregateProviderRoutes(metrics) {
       successes: 0,
       latency: 0,
       input: 0,
-      output: 0
+      output: 0,
+      failures: {}
     };
     group.calls++;
     if (metric.success)
       group.successes++;
+    else if (metric.failureKind)
+      group.failures[metric.failureKind] = (group.failures[metric.failureKind] ?? 0) + 1;
     group.latency += Math.max(0, metric.latencyMs);
     group.input += Math.max(0, metric.inputTokens) + Math.max(0, metric.cacheHitTokens) + Math.max(0, metric.cacheWriteTokens ?? 0);
     group.output += Math.max(0, metric.outputTokens);
@@ -11071,6 +11302,7 @@ function aggregateProviderRoutes(metrics) {
     model: group.model,
     calls: group.calls,
     successes: group.successes,
+    ...Object.keys(group.failures).length ? { failures: group.failures } : {},
     avgLatencyMs: group.calls ? Math.round(group.latency / group.calls) : 0,
     inputTokens: group.input,
     outputTokens: group.output
@@ -11232,28 +11464,7 @@ async function recordFailureMetrics(rc, err, fields) {
 }
 
 // src/app/steps/persist.ts
-import { convertToLlm as convertToLlm3 } from "@earendil-works/pi-coding-agent";
-
-// src/ui/error-format.ts
-var MAX_ERROR_TEXT = 240;
-var DEBUG_HINT = "Conversation unchanged. Set DEBUG=smart-compact for stack diagnostics.";
-function compactText(error2) {
-  const text = error2 instanceof Error ? error2.message : String(error2);
-  return text.replace(/\s+/g, " ").trim().slice(0, MAX_ERROR_TEXT) || "Unknown error";
-}
-function formatCompactErrorForUi(error2) {
-  if (error2 instanceof VerificationGateError) {
-    const kinds = error2.gapKinds.slice(0, 4).join(", ") || "unknown";
-    return "Verification stopped apply at the " + error2.stage + " gate: " + error2.score + "/100, " + error2.gapCount + (error2.gapCount === 1 ? " unresolved gap [" : " unresolved gaps [") + kinds + "]. " + DEBUG_HINT;
-  }
-  if (error2 instanceof YieldGateError) {
-    const reason = error2.reason === "target-miss" ? "target missed" : "saving below 10%";
-    return "Yield check stopped apply: estimated " + error2.estimatedAfterTokens.toLocaleString() + "t after vs " + error2.targetAfterTokens.toLocaleString() + "t target (" + reason + "). " + DEBUG_HINT;
-  }
-  return "Smart compact failed: " + compactText(error2) + ". " + DEBUG_HINT;
-}
-
-// src/app/steps/persist.ts
+import { convertToLlm as convertToLlm4 } from "@earendil-works/pi-coding-agent";
 async function persistAppliedState(pending) {
   if (!pending.projectId)
     return pending.compactionState || pending.extraction ? ["project state (project identity unavailable)"] : [];
@@ -11292,7 +11503,7 @@ async function commitAppliedCompaction(pending) {
 }
 function runDamageDetection(rc) {
   try {
-    const postCompactMsgs = rc.msgs.slice(rc.keepFrom).map((e) => convertToLlm3([asBranchMessage(e.message)])).flat();
+    const postCompactMsgs = rc.msgs.slice(rc.keepFrom).map((e) => convertToLlm4([asBranchMessage(e.message)])).flat();
     if (postCompactMsgs.length <= 2)
       return;
     const lastCompaction = rc.branch.filter((e) => e?.type === "compaction").slice(-1)[0];
@@ -11582,7 +11793,7 @@ async function runSmartCompact(opts) {
       const dur = pipelineMs < 1000 ? pipelineMs + "ms" : (pipelineMs / 1000).toFixed(1) + "s";
       const hasPending = base.pendingRef.isPresent(runSessionId);
       if (hasPending || runFailed || finalRc)
-        base.ctx.ui.notify(hasPending ? "Smart compact prepared in " + dur + " \u2014 awaiting native /compact" : runFailed ? "Smart compact stopped safely in " + dur + " \xB7 no summary applied \xB7 Pi fallback continues" : "Smart compact run finished in " + dur, runFailed ? "warning" : "info");
+        base.ctx.ui.notify(hasPending ? "Smart compact prepared in " + dur + " \u2014 awaiting native /compact" : runFailed ? "Smart compact stopped safely in " + dur + (base.flags.skipCompact ? " \xB7 no summary staged \xB7 context unchanged" : " \xB7 no summary applied \xB7 Pi fallback continues") : "Smart compact run finished in " + dur, runFailed ? "warning" : "info");
     }
   }
 }
@@ -12867,6 +13078,9 @@ function buildMetricsReport(entries = readMetricsLog(100), damageEntries, prebui
     "## Stage provider/model comparison",
     ...providerRoutes.length ? providerRoutes : ["- No stage-route evidence yet"],
     "",
+    "## Recent provider call failures (not compaction outcomes)",
+    ...entries.slice(-20).flatMap((entry) => (entry.providerRoutes ?? []).filter((route) => route.successes < route.calls).map((route) => "- " + route.stage + " / " + route.provider + "/" + route.model + ": " + (route.calls - route.successes) + "/" + route.calls + " calls failed; " + (route.failures ? JSON.stringify(route.failures) : "legacy cause unclassified"))),
+    "",
     "## Failure taxonomy",
     ...Object.keys(insights.failures).length ? Object.entries(insights.failures).map(([kind, count]) => "- " + kind + ": " + count) : ["- No schema-v2 failures classified"]
   ].join(`
@@ -13115,7 +13329,7 @@ function registerSmartCompactTool(pi, dependencies) {
   pi.registerTool({
     name: "smart_compact",
     label: "Smart Compact",
-    description: "EESV smart compaction v" + VERSION + " with deterministic extraction, exploration, and verification. Compacts the conversation into a structured summary preserving goals, decisions, open loops, modified files, and critical context. Call only when actual context usage is high; ignore pi-auto-context tool=XX% because that is tool-output ratio, not context fullness. The tool internally checks context usage and skips if not needed.",
+    description: "EESV smart compaction v" + VERSION + " with deterministic extraction, exploration, and verification. Prepares and stages a verified summary for the next /compact; this tool does not apply compaction mid-turn. The staged summary expires after 5 minutes. Call only when actual context usage is high; tool=XX% is tool-output ratio, not context fullness. Checks the configured context threshold before starting.",
     promptSnippet: "Smart compaction",
     promptGuidelines: [
       "Use only when actual context usage is high (for example pi-auto-context context>=60%).",
@@ -13196,7 +13410,7 @@ Dashboard: ` + dashboard : ""));
       const resolvedMode = mode ?? config.mode;
       const sessionId = resolveSessionId(ctx);
       if (!dryRun && pendingRef.peek(sessionId)?.sessionId === sessionId) {
-        return textResult("A smart summary is already staged for this session. The next /compact will use it; no LLM calls were made.");
+        return textResult("A smart summary is already staged; context is unchanged. Run /compact before the 5-minute staging TTL expires to apply it. No LLM calls were made.");
       }
       const usage = ctx.getContextUsage?.();
       const totalTokens = usage?.tokens ?? 0;
@@ -13206,7 +13420,7 @@ Dashboard: ` + dashboard : ""));
         return textResult("Context is not large enough for compaction (" + totalTokens.toLocaleString() + " tokens, " + percent2 + "%). No action needed.");
       }
       if (contextPercent < config.minContextPercent) {
-        return textResult("Context is only " + percent2 + "% full (" + totalTokens.toLocaleString() + " tokens). Compaction is not needed yet. The tool=97% in status means tool output ratio, NOT context usage.");
+        return textResult("Compaction skipped: context " + percent2 + "% (" + totalTokens.toLocaleString() + " / " + (ctx.model?.contextWindow ?? 0).toLocaleString() + " tokens), below the " + config.minContextPercent + "% agent-tool threshold. tool=XX% measures tool-output ratio, not context usage. " + "For deliberate early compaction, the user can run /smart-compact; preview and safety checks still apply.");
       }
       const current = ctx.model;
       const { segModel, sumModel, verifyModel } = resolveModels(ctx, current, config);
@@ -13239,7 +13453,7 @@ Dashboard: ` + dashboard : ""));
             content: [
               {
                 type: "text",
-                text: "Smart summary prepared (" + resolvedMode + " \u2192 " + (staged.details.mode ?? staged.details.profile) + "). Tokens: " + (staged.tokensBefore ?? 0).toLocaleString() + " \u2014 cached for " + Math.round(FIVE_MINUTES_MS / 60000) + " min. The next /compact will use it automatically."
+                text: "Smart summary prepared (" + resolvedMode + " \u2192 " + (staged.details.mode ?? staged.details.profile) + "). Tokens: " + (staged.tokensBefore ?? 0).toLocaleString() + " \u2014 staged, not applied, for " + Math.round(FIVE_MINUTES_MS / 60000) + " min. Context is unchanged. Run /compact within that time to apply it; expiry discards the candidate."
               }
             ],
             details: staged.details
@@ -14767,19 +14981,29 @@ function smartCompactExtension(pi) {
   const settledAutoTrigger = createSettledAutoTrigger();
   const policy = createSmartCompactPolicy(pi);
   const nativeContinuity = createNativeContinuityBridge();
+  const applyFailureWrites = new Map;
   const recordApplyFailure = (pending, reason) => {
     if (!pending.metricsSnapshot)
-      return;
+      return null;
     const cancelled = reason === "aborted" || reason === "shutdown";
-    appendMetricsSnapshot(pending.sessionId, {
+    const write = appendMetricsSnapshot(pending.sessionId, {
       ...pending.metricsSnapshot,
       status: cancelled ? "cancelled" : "error",
       failureKind: cancelled ? "cancelled" : reason === "evicted" ? "internal" : "persistence",
       fallbackReason: "native-apply:" + reason
     });
+    applyFailureWrites.set(pending.runId, write);
+    write.finally(() => {
+      if (applyFailureWrites.get(pending.runId) === write) {
+        applyFailureWrites.delete(pending.runId);
+      }
+    });
+    return write;
   };
   const commitCandidates = createCompactionCommitStore({
-    onDiscard: recordApplyFailure
+    onDiscard: (pending, reason) => {
+      recordApplyFailure(pending, reason);
+    }
   });
   const onNativeApplyError = (runId) => Boolean(commitCandidates.discard(runId, "apply-error"));
   const activateOnlineDamage = (pending) => {
@@ -14887,7 +15111,6 @@ function smartCompactExtension(pi) {
             onNativeApplyError,
             autoTriggered: true,
             overflowRecovery: event.reason === "overflow",
-            maxLlmCalls: Math.min(config.maxLlmCalls, AUTO_TRIGGER_MAX_LLM_CALLS),
             timeoutMs: effectiveTimeoutMs,
             abortSignal: event.signal,
             cancellationOut
@@ -14954,6 +15177,24 @@ function smartCompactExtension(pi) {
     if (state)
       nativeContinuity.stage({ projectId, sessionId, branchHeadId }, renderContinuityCapsule(state));
   });
+  const compactFailedEvents = pi;
+  compactFailedEvents.on("session_compact_failed", async (event, ctx) => {
+    if (!event.fromExtension)
+      return;
+    const sessionId = resolveSessionId(ctx);
+    clearCompactProgress(ctx);
+    const reason = event.aborted ? "aborted" : "apply-error";
+    const discarded = commitCandidates.clearSession(sessionId, reason);
+    const metricWrites = discarded.flatMap((pending) => {
+      const write = applyFailureWrites.get(pending.runId);
+      return write ? [write] : [];
+    });
+    if (metricWrites.length > 0)
+      await Promise.all(metricWrites);
+    if (discarded.length > 0) {
+      warn("Discarded " + discarded.length + " staged smart compaction after native apply " + (event.aborted ? "abort" : "failure") + (event.errorMessage ? ": " + event.errorMessage : ""));
+    }
+  });
   pi.on("before_agent_start", async (_event, ctx) => {
     const scope = resolveGraphScope(ctx);
     if (!scope?.branchHeadId)
@@ -14982,7 +15223,7 @@ function smartCompactExtension(pi) {
   pi.on("message_end", async (event, ctx) => {
     try {
       const sessionId = resolveSessionId(ctx);
-      const converted = convertToLlm4([event.message])[0];
+      const converted = convertToLlm5([event.message])[0];
       if (!converted)
         return;
       const observation = damageMonitor.observe(sessionId, converted);