pi-smart-compact 9.6.1 → 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.1";
+var VERSION = "9.6.2";
 var CHARS_PER_TOKEN = 3.8;
 var MIN_COMPACTION_SAVING_RATIO = 0.1;
 var ESTIMATOR_ROUNDING_TOLERANCE_TOKENS = 1;
@@ -1861,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 = [];
@@ -3816,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",
@@ -3929,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;
   }
@@ -4537,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";
@@ -5020,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) });
@@ -5242,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");
@@ -5328,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));
@@ -6222,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",
@@ -6512,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);
@@ -6606,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(() => {
@@ -6627,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();
 }
@@ -6779,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)
@@ -6812,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)
@@ -6837,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);
@@ -6854,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) {
@@ -7021,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";
@@ -7249,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) {
@@ -7257,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");
@@ -7364,207 +7554,26 @@ 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: "" };
+function explicitlyRejectsTools(error2) {
+  if (!error2 || typeof error2 !== "object")
+    return false;
+  const record = error2;
+  const status = Number(record.status ?? record.statusCode ?? record.response?.status);
+  const message = String(record.message ?? "");
+  return (status === 400 || status === 404 || status === 422) && /(?:(?:tools?|function(?:[ -]calling)?).{0,60}(?:unsupported|not supported|unknown|unavailable|invalid)|(?:unsupported|does not support|doesn't support).{0,60}(?:tools?|function))/i.test(message);
+}
+function shouldExplore(extraction) {
+  const unresolvedErrors = extraction.errors.filter((e) => !e.resolved).length;
+  const topicCount = extraction.topics.length;
+  const decisionCount = extraction.decisions.length;
+  const crossFileWork = new Set(extraction.modifiedFiles.map((f) => {
+    const parts = f.path.split("/");
+    return parts.length > 1 ? parts.slice(0, -1).join("/") : "root";
+  })).size;
+  if (topicCount <= 3 && unresolvedErrors <= 1 && decisionCount <= 2 && crossFileWork <= 2) {
+    return false;
   }
-  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;
-  const record = error2;
-  const status = Number(record.status ?? record.statusCode ?? record.response?.status);
-  const message = String(record.message ?? "");
-  return (status === 400 || status === 404 || status === 422) && /(?:(?:tools?|function(?:[ -]calling)?).{0,60}(?:unsupported|not supported|unknown|unavailable|invalid)|(?:unsupported|does not support|doesn't support).{0,60}(?:tools?|function))/i.test(message);
-}
-function shouldExplore(extraction) {
-  const unresolvedErrors = extraction.errors.filter((e) => !e.resolved).length;
-  const topicCount = extraction.topics.length;
-  const decisionCount = extraction.decisions.length;
-  const crossFileWork = new Set(extraction.modifiedFiles.map((f) => {
-    const parts = f.path.split("/");
-    return parts.length > 1 ? parts.slice(0, -1).join("/") : "root";
-  })).size;
-  if (topicCount <= 3 && unresolvedErrors <= 1 && decisionCount <= 2 && crossFileWork <= 2) {
-    return false;
-  }
-  return true;
+  return true;
 }
 var EXPLORATION_TOOLS = [
   {
@@ -8863,541 +8872,186 @@ 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;
+  if (nonEmpty.length === 1 && NONE_BLOCKER_VALUE_RE.test(nonEmpty[0].text)) {
+    indexes.add(nonEmpty[0].index);
   }
-  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;
+  return indexes;
+}
+function collectListedPaths(body, expectedPaths) {
+  const values = new Set;
+  const encodedValues = new Set;
+  for (const line of body.split(`
+`)) {
+    const raw = line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").trim();
+    if (!raw)
+      continue;
+    if (raw.startsWith('"')) {
+      try {
+        const decoded = JSON.parse(raw);
+        if (typeof decoded === "string") {
+          values.add(decoded);
+          encodedValues.add(decoded);
+          continue;
+        }
+      } catch {}
+    }
+    values.add(raw);
+    if (expectedPaths.has(raw))
+      continue;
+    const unwrapped = raw.startsWith("`") && raw.endsWith("`") ? raw.slice(1, -1) : raw;
+    const unchecked = unwrapped.replace(/^\[[ x]\]\s+/i, "");
+    if (expectedPaths.has(unchecked))
+      values.add(unchecked);
   }
-  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;
+  return {
+    values,
+    encodedValues,
+    normalizedValues: new Set(Array.from(values, normalizePath))
+  };
+}
+function decodePathDisplay(display) {
   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");
+    const decoded = JSON.parse(display);
+    return typeof decoded === "string" ? decoded : display;
+  } catch {
+    return display;
   }
-  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
-      }));
+}
+function hasListedPath(listed, file, display, normalizedOwners) {
+  const decodedDisplay = decodePathDisplay(display);
+  if (listed.encodedValues.has(decodedDisplay))
+    return true;
+  if (PATH_PLACEHOLDER_RE.test(file))
+    return false;
+  if (listed.values.has(file))
+    return true;
+  for (const candidate of [file, decodedDisplay]) {
+    const normalized = normalizePath(candidate);
+    if (normalizedOwners.get(normalized) === 1 && listed.normalizedValues.has(normalized))
+      return true;
+  }
+  return false;
+}
+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();
+  if (/\btests?\b|\btestler?\b/.test(lower))
+    return "test";
+  if (/\bbuild\b|\bcompil(?:e|ed|ation)\b|\btypecheck\b/.test(lower))
+    return "build";
+  if (/\bdeploy(?:ed|ment)?\b|\bpublish(?:ed)?\b|\breleas(?:e|ed)\b/.test(lower))
+    return "release";
+  if (/\bbug\b|\bissue\b|\berror\b|\bfail(?:ed|ure)?\b|\bhata\b/.test(lower))
+    return "error";
+  if (/\bfile\b|\bdosya\b/.test(lower))
+    return "file";
+  return "generic";
+}
+var successfulToolEvidenceCache = new WeakMap;
+var sourceTextCache = new WeakMap;
+function sourceSupportsFileReference(ref, messages) {
+  let texts = sourceTextCache.get(messages);
+  if (!texts) {
+    texts = messages.map((message) => extractText(message.content).replace(/\\/g, "/").toLowerCase());
+    sourceTextCache.set(messages, texts);
+  }
+  const needle = ref.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+  if (!needle)
+    return false;
+  for (const text of texts) {
+    let index = text.indexOf(needle);
+    while (index >= 0) {
+      const before = text[index - 1] ?? "";
+      const after = text[index + needle.length] ?? "";
+      if ((!before || !/[\w.-]/.test(before)) && (!after || !/[\w.-]/.test(after)))
+        return true;
+      index = text.indexOf(needle, index + 1);
     }
-    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
+  }
+  return false;
+}
+function successfulToolEvidence(messages) {
+  const cached = successfulToolEvidenceCache.get(messages);
+  if (cached)
+    return cached;
+  const toolCalls = buildToolCallIndex(messages);
+  const evidence = [];
+  for (const message of messages) {
+    if (message.role !== "toolResult" || message.isError)
+      continue;
+    const call = toolCalls.get(message.toolCallId ?? "");
+    if (!call)
+      continue;
+    const result = extractText(message.content).slice(0, 8000);
+    if (!result.trim() || LIKELY_ERROR_RE.test(result))
+      continue;
+    const command = [call.arguments.command, call.arguments.cmd, call.arguments.script].find((value) => typeof value === "string") ?? "";
+    evidence.push({
+      name: normalizeToolName(call.name),
+      operation: classifyToolOperation(call.arguments, call.name),
+      command,
+      path: extractToolPath(call.arguments),
+      result
     });
-    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);
-  }
-  return indexes;
-}
-function collectListedPaths(body, expectedPaths) {
-  const values = new Set;
-  const encodedValues = new Set;
-  for (const line of body.split(`
-`)) {
-    const raw = line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").trim();
-    if (!raw)
-      continue;
-    if (raw.startsWith('"')) {
-      try {
-        const decoded = JSON.parse(raw);
-        if (typeof decoded === "string") {
-          values.add(decoded);
-          encodedValues.add(decoded);
-          continue;
-        }
-      } catch {}
-    }
-    values.add(raw);
-    if (expectedPaths.has(raw))
-      continue;
-    const unwrapped = raw.startsWith("`") && raw.endsWith("`") ? raw.slice(1, -1) : raw;
-    const unchecked = unwrapped.replace(/^\[[ x]\]\s+/i, "");
-    if (expectedPaths.has(unchecked))
-      values.add(unchecked);
-  }
-  return {
-    values,
-    encodedValues,
-    normalizedValues: new Set(Array.from(values, normalizePath))
-  };
-}
-function decodePathDisplay(display) {
-  try {
-    const decoded = JSON.parse(display);
-    return typeof decoded === "string" ? decoded : display;
-  } catch {
-    return display;
   }
+  successfulToolEvidenceCache.set(messages, evidence);
+  return evidence;
 }
-function hasListedPath(listed, file, display, normalizedOwners) {
-  const decodedDisplay = decodePathDisplay(display);
-  if (listed.encodedValues.has(decodedDisplay))
+function successfulToolSupportsClaim(claim, tools, extraction) {
+  const shape = semanticShape(claim);
+  const category = classifyOutcomeClaim(claim);
+  if (category === "error" && extraction.errors.some((error2) => error2.resolved && hasSemanticEvidence(claim, error2.message)))
     return true;
-  if (PATH_PLACEHOLDER_RE.test(file))
-    return false;
-  if (listed.values.has(file))
+  if (category === "file" && extraction.modifiedFiles.some((file) => claim.toLowerCase().includes(file.path.toLowerCase())))
     return true;
-  for (const candidate of [file, decodedDisplay]) {
-    const normalized = normalizePath(candidate);
-    if (normalizedOwners.get(normalized) === 1 && listed.normalizedValues.has(normalized))
+  for (const tool of tools) {
+    const operationText = tool.name + " " + tool.command;
+    const operationSupports = category === "test" ? /\b(?:test|tests|pytest|jest|vitest|mocha|rspec)\b/i.test(operationText) : category === "build" ? /\b(?:build|compile|typecheck|tsc|check)\b/i.test(operationText) : category === "release" ? /\b(?:deploy|publish|release)\b/i.test(operationText) : category === "file" ? tool.operation === "mutate" || tool.operation === "delete" : category === "error" ? tool.operation === "execute" || tool.operation === "mutate" || tool.operation === "delete" : tool.operation !== "read" && tool.operation !== "search" && tool.operation !== "list";
+    if (!operationSupports)
+      continue;
+    if (hasSemanticEvidence(claim, tool.result))
+      return true;
+    const lower = tool.result.toLowerCase();
+    if (category === "test" && /\b\d+\s+(?:tests?\s+)?pass(?:ed)?\b/.test(lower) && !/\b(?:fail(?:ed|ures?)?|errors?)\s*[:=]?\s*[1-9]\d*\b/.test(lower))
+      return true;
+    if (category === "build" && /\b(?:succeeded|successful|passed|exit(?:ed)?\s+(?:code\s+)?0)\b/.test(lower))
+      return true;
+    if (category === "release" && /\b(?:succeeded|successful|completed|published|deployed|released)\b/.test(lower))
+      return true;
+    if (category === "error" && shape.concepts.length > 0 && /\b(?:fixed|resolved|passed|succeeded|successful)\b/.test(lower) && hasSemanticEvidence(claim, tool.result))
       return true;
   }
   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 classifyOutcomeClaim(claim) {
-  const lower = claim.toLowerCase();
-  if (/\btests?\b|\btestler?\b/.test(lower))
-    return "test";
-  if (/\bbuild\b|\bcompil(?:e|ed|ation)\b|\btypecheck\b/.test(lower))
-    return "build";
-  if (/\bdeploy(?:ed|ment)?\b|\bpublish(?:ed)?\b|\breleas(?:e|ed)\b/.test(lower))
-    return "release";
-  if (/\bbug\b|\bissue\b|\berror\b|\bfail(?:ed|ure)?\b|\bhata\b/.test(lower))
-    return "error";
-  if (/\bfile\b|\bdosya\b/.test(lower))
-    return "file";
-  return "generic";
-}
-var successfulToolEvidenceCache = new WeakMap;
-var sourceTextCache = new WeakMap;
-function sourceSupportsFileReference(ref, messages) {
-  let texts = sourceTextCache.get(messages);
-  if (!texts) {
-    texts = messages.map((message) => extractText(message.content).replace(/\\/g, "/").toLowerCase());
-    sourceTextCache.set(messages, texts);
-  }
-  const needle = ref.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
-  if (!needle)
-    return false;
-  for (const text of texts) {
-    let index = text.indexOf(needle);
-    while (index >= 0) {
-      const before = text[index - 1] ?? "";
-      const after = text[index + needle.length] ?? "";
-      if ((!before || !/[\w.-]/.test(before)) && (!after || !/[\w.-]/.test(after)))
-        return true;
-      index = text.indexOf(needle, index + 1);
-    }
-  }
-  return false;
-}
-function successfulToolEvidence(messages) {
-  const cached = successfulToolEvidenceCache.get(messages);
-  if (cached)
-    return cached;
-  const toolCalls = buildToolCallIndex(messages);
-  const evidence = [];
-  for (const message of messages) {
-    if (message.role !== "toolResult" || message.isError)
-      continue;
-    const call = toolCalls.get(message.toolCallId ?? "");
-    if (!call)
-      continue;
-    const result = extractText(message.content).slice(0, 8000);
-    if (!result.trim() || LIKELY_ERROR_RE.test(result))
-      continue;
-    const command = [call.arguments.command, call.arguments.cmd, call.arguments.script].find((value) => typeof value === "string") ?? "";
-    evidence.push({
-      name: normalizeToolName(call.name),
-      operation: classifyToolOperation(call.arguments, call.name),
-      command,
-      path: extractToolPath(call.arguments),
-      result
-    });
-  }
-  successfulToolEvidenceCache.set(messages, evidence);
-  return evidence;
-}
-function successfulToolSupportsClaim(claim, tools, extraction) {
-  const shape = semanticShape(claim);
-  const category = classifyOutcomeClaim(claim);
-  if (category === "error" && extraction.errors.some((error2) => error2.resolved && hasSemanticEvidence(claim, error2.message)))
-    return true;
-  if (category === "file" && extraction.modifiedFiles.some((file) => claim.toLowerCase().includes(file.path.toLowerCase())))
-    return true;
-  for (const tool of tools) {
-    const operationText = tool.name + " " + tool.command;
-    const operationSupports = category === "test" ? /\b(?:test|tests|pytest|jest|vitest|mocha|rspec)\b/i.test(operationText) : category === "build" ? /\b(?:build|compile|typecheck|tsc|check)\b/i.test(operationText) : category === "release" ? /\b(?:deploy|publish|release)\b/i.test(operationText) : category === "file" ? tool.operation === "mutate" || tool.operation === "delete" : category === "error" ? tool.operation === "execute" || tool.operation === "mutate" || tool.operation === "delete" : tool.operation !== "read" && tool.operation !== "search" && tool.operation !== "list";
-    if (!operationSupports)
-      continue;
-    if (hasSemanticEvidence(claim, tool.result))
-      return true;
-    const lower = tool.result.toLowerCase();
-    if (category === "test" && /\b\d+\s+(?:tests?\s+)?pass(?:ed)?\b/.test(lower) && !/\b(?:fail(?:ed|ures?)?|errors?)\s*[:=]?\s*[1-9]\d*\b/.test(lower))
-      return true;
-    if (category === "build" && /\b(?:succeeded|successful|passed|exit(?:ed)?\s+(?:code\s+)?0)\b/.test(lower))
-      return true;
-    if (category === "release" && /\b(?:succeeded|successful|completed|published|deployed|released)\b/.test(lower))
-      return true;
-    if (category === "error" && shape.concepts.length > 0 && /\b(?:fixed|resolved|passed|succeeded|successful)\b/.test(lower) && hasSemanticEvidence(claim, tool.result))
-      return true;
-  }
-  return false;
-}
-function removeUnsupportedClaim(summary, claim) {
-  const normalized = claim.replace(/\s+/g, " ").trim().toLocaleLowerCase();
-  return {
-    sections: summary.sections.map((section) => ({
-      ...section,
-      body: section.body.split(`
-`).filter((line) => {
-        const candidate = line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").replace(/\s+/g, " ").trim().toLocaleLowerCase();
-        return candidate !== normalized;
-      }).join(`
-`).trim()
-    }))
-  };
+function removeUnsupportedClaim(summary, claim) {
+  const normalized = claim.replace(/\s+/g, " ").trim().toLocaleLowerCase();
+  return {
+    sections: summary.sections.map((section) => ({
+      ...section,
+      body: section.body.split(`
+`).filter((line) => {
+        const candidate = line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").replace(/\s+/g, " ").trim().toLocaleLowerCase();
+        return candidate !== normalized;
+      }).join(`
+`).trim()
+    }))
+  };
 }
 function formatVerificationGap(gap) {
   switch (gap.kind) {
@@ -9592,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;
@@ -9612,7 +9266,7 @@ function hasEffectiveTargetNegation(tokens, anchor) {
     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 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);
@@ -9661,12 +9315,13 @@ function hasSemanticEvidence(source, target) {
   });
 }
 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))
+    if (!tokens.includes(anchor) || sourceFragments.has(tokens.join(" ")))
       return false;
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
     if (overlap < required)
@@ -9951,7 +9606,7 @@ function verifyProgressConsistency(parsed, extraction, collected, paths, accumul
     }
   }
 }
-function verifyOpenLoopsAndClaims(summary, parsed, extraction, continuity, evidence, collected, accumulator) {
+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);
@@ -9959,7 +9614,7 @@ function verifyOpenLoopsAndClaims(summary, parsed, extraction, continuity, evide
   if (!evidence.sourceMessages)
     return;
   const tools = successfulToolEvidence(evidence.sourceMessages);
-  for (const claim of outcomeClaims(summary)) {
+  for (const claim of outcomeClaims(summary, paths.rendered)) {
     if (!successfulToolSupportsClaim(claim, tools, extraction)) {
       addGap(accumulator, { kind: "unsupported-claim", claim }, 20);
     }
@@ -9975,7 +9630,7 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
   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);
+  verifyOpenLoopsAndClaims(summary, parsed, paths, extraction, continuity, evidence, collected, accumulator);
   const score = Math.max(0, accumulator.score);
   return {
     ok: accumulator.gaps.length === 0 && score >= 85,
@@ -10065,118 +9720,563 @@ function patchDeterministic(summary, gaps, extraction, continuity = null, eviden
         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;
+        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;
+    }
+  }
+  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;
+    }
+  }
+  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;
+  }
+}
+
+// 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/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.";
+  }
+}
+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.";
+  }
+  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));
+}
+
+// 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 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 [" + formatGenerationFailureForUi(error2) + "]", "warning");
+  }
+  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 [" + formatGenerationFailureForUi(err) + "]", "warning");
+      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 [" + 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
+          });
+        }
+      };
+      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
@@ -10292,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;
@@ -10404,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;
@@ -11233,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);
@@ -11249,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
@@ -11410,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)"] : [];
@@ -11470,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];
@@ -11760,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");
     }
   }
 }
@@ -13045,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(`
@@ -13293,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%).",
@@ -13374,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;
@@ -13384,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);
@@ -13417,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
@@ -15075,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
@@ -15188,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);
@@ -15220,7 +15255,7 @@ function smartCompactExtension(pi) {
   });
 }
 export {
-  smartCompactExtension as default,
+  resolveModels,
   findModelById,
-  resolveModels
+  smartCompactExtension as default
 };