pi-smart-compact 9.6.2 → 9.7.0

package/dist/index.js

@@ -1,13 +1,11 @@
 // @bun
-var __require = import.meta.require;
-
 // src/index.ts
 import {
   convertToLlm as convertToLlm5
 } from "@earendil-works/pi-coding-agent";
 
 // src/constants.ts
-var VERSION = "9.6.2";
+var VERSION = "9.7.0";
 var CHARS_PER_TOKEN = 3.8;
 var MIN_COMPACTION_SAVING_RATIO = 0.1;
 var ESTIMATOR_ROUNDING_TOLERANCE_TOKENS = 1;
@@ -63,16 +61,17 @@ var CONFIG_NUMERIC_LIMITS = {
   maxLlmInputTokens: { min: 0, max: 1e6, integer: true },
   codexMaxCallMs: {
     min: 5000,
-    max: 300000,
+    max: 3600000,
     integer: true,
     zeroOrRange: true
   },
   maxLatencyMs: {
     min: 5000,
-    max: 600000,
+    max: 7200000,
     integer: true,
     zeroOrRange: true
-  }
+  },
+  pendingTtlMs: { min: 1000, max: 3600000, integer: true }
 };
 var DEFAULT_CONFIG = {
   mode: "auto",
@@ -98,6 +97,7 @@ var DEFAULT_CONFIG = {
   maxLlmInputTokens: 0,
   codexMaxCallMs: 0,
   maxLatencyMs: 0,
+  pendingTtlMs: 300000,
   focusWeighting: true,
   zeroCallEnabled: true,
   contextGraphEnabled: true,
@@ -351,21 +351,24 @@ import crypto from "crypto";
 
 // src/utils/logger.ts
 var DEBUG = process.env.DEBUG?.includes("smart-compact") ?? false;
+function ts() {
+  return new Date().toISOString();
+}
 function warn(msg, err) {
   const detail = err instanceof Error ? err.message : err ?? "";
-  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
+  console.error(ts() + " " + LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
 }
 function error(msg, err) {
   const detail = err instanceof Error ? err.message + `
 ` + err.stack : err ?? "";
-  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
+  console.error(ts() + " " + LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
 }
 function info(msg, ...args) {
-  console.error(LOG_PREFIX + " [info] " + msg, ...args);
+  console.error(ts() + " " + LOG_PREFIX + " [info] " + msg, ...args);
 }
 function debug(msg, ...args) {
   if (DEBUG)
-    console.error(LOG_PREFIX + " [debug] " + msg, ...args);
+    console.error(ts() + " " + LOG_PREFIX + " [debug] " + msg, ...args);
 }
 function debugError(msg, err) {
   if (DEBUG)
@@ -420,18 +423,18 @@ function tryAcquireLock(target) {
   const token = process.pid + ":" + crypto.randomBytes(8).toString("hex");
   try {
     fs.mkdirSync(lockDir, { mode: 448 });
-  } catch (error2) {
-    if (error2?.code === "EEXIST")
+  } catch (error) {
+    if (error?.code === "EEXIST")
       return null;
-    throw new Error("Failed to acquire lock for " + target, { cause: error2 });
+    throw new Error("Failed to acquire lock for " + target, { cause: error });
   }
   try {
     fs.writeFileSync(ownerFile, token, { mode: 384, flag: "wx" });
-  } catch (error2) {
+  } catch (error) {
     try {
       fs.rmSync(lockDir, { recursive: true, force: true });
     } catch {}
-    throw new Error("Failed to acquire lock for " + target, { cause: error2 });
+    throw new Error("Failed to acquire lock for " + target, { cause: error });
   }
   return () => {
     try {
@@ -474,9 +477,9 @@ async function appendLineLockedAsync(target, line, maxBytes) {
     let stat = null;
     try {
       stat = await fsp.stat(target);
-    } catch (error2) {
-      if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "ENOENT")
-        throw error2;
+    } catch (error) {
+      if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT")
+        throw error;
     }
     if (maxBytes !== undefined && stat && stat.size + payload.length > maxBytes) {
       const retainedLength = Math.min(stat.size, Math.max(0, maxBytes - payload.length));
@@ -879,12 +882,17 @@ var NUMERIC_RULES = [
   {
     key: "codexMaxCallMs",
     valid: (value) => validNumericLimit("codexMaxCallMs", value),
-    message: () => "smart-compact config: codexMaxCallMs must be 0 or 5000\u2013300000; 0 derives a cap from maxTokens."
+    message: () => "smart-compact config: codexMaxCallMs must be 0 or 5000\u20133600000; 0 derives a cap from maxTokens."
   },
   {
     key: "maxLatencyMs",
     valid: (value) => validNumericLimit("maxLatencyMs", value),
-    message: () => "smart-compact config: maxLatencyMs must be 0 or 5000\u2013600000; 0 means unlimited."
+    message: () => "smart-compact config: maxLatencyMs must be 0 or 5000\u20137200000; 0 means unlimited."
+  },
+  {
+    key: "pendingTtlMs",
+    valid: (value) => validNumericLimit("pendingTtlMs", value),
+    message: () => "smart-compact config: pendingTtlMs must be 1000\u20133600000 (staged summary TTL)."
   },
   {
     key: "minContextPercent",
@@ -980,8 +988,8 @@ function loadConfig() {
     cachedMtime = stat.mtimeMs;
     cachedPath = file;
     return cloneConfig(cachedConfig);
-  } catch (error2) {
-    debug("loadConfig: settings.json not found or unreadable, using defaults", error2);
+  } catch (error) {
+    debug("loadConfig: settings.json not found or unreadable, using defaults", error);
     cachedConfig = defaultConfig();
     cachedPath = null;
     return cloneConfig(cachedConfig);
@@ -1497,8 +1505,8 @@ function buildKnownPathReferenceIndex(knownPaths) {
   const boundarySuffixes = new Set;
   const normalizedPaths = [];
   let hasUnindexedSuffixes = false;
-  for (const path3 of knownPaths) {
-    const normalizedPath = normalizePath(path3).replace(/^\/+/, "");
+  for (const path of knownPaths) {
+    const normalizedPath = normalizePath(path).replace(/^\/+/, "");
     if (!normalizedPath)
       continue;
     normalizedPaths.push(normalizedPath);
@@ -2077,7 +2085,7 @@ function buildExtractionContext(extraction, forRange) {
   const files = forRange ? extraction.modifiedFiles.filter((f) => inRange(f.lastModifiedIndex)) : extraction.modifiedFiles;
   const readFiles = forRange ? [] : extraction.readFiles;
   const deletedFiles = forRange ? [] : extraction.deletedFiles;
-  const errors = extraction.errors.filter((error2) => inRange(error2.index));
+  const errors = extraction.errors.filter((error) => inRange(error.index));
   const decisions = extraction.decisions.filter((decision) => inRange(decision.index));
   const constraints = extraction.constraints.filter((constraint) => inRange(constraint.index));
   const media = (extraction.mediaAttachments ?? []).filter((attachment) => inRange(attachment.index));
@@ -2314,7 +2322,7 @@ function buildSummaryPathEvidence(paths, budgetTokens = PROFILES.balanced.summar
   const unique = Array.from(new Set(paths.filter(Boolean)));
   if (!unique.length)
     return new Map;
-  const full = unique.map((path3) => [path3, summaryPathLine(path3)]);
+  const full = unique.map((path) => [path, summaryPathLine(path)]);
   const minimumPerLine = JSON.stringify("#" + "x".repeat(12)).length + 3;
   const budgetChars = Math.max(unique.length * minimumPerLine, Math.min(20000, Math.max(4000, Math.floor(budgetTokens * 2))));
   if (full.reduce((total, [, line]) => total + line.length + 3, 0) <= budgetChars) {
@@ -2322,21 +2330,21 @@ function buildSummaryPathEvidence(paths, budgetTokens = PROFILES.balanced.summar
   }
   const digests = new Map;
   const owners = new Map;
-  for (const path3 of unique) {
-    const fullDigest = createHash("sha256").update(path3).digest("base64url");
+  for (const path of unique) {
+    const fullDigest = createHash("sha256").update(path).digest("base64url");
     let digest = fullDigest.slice(0, 12);
     const owner = owners.get(digest);
-    if (owner && owner !== path3) {
+    if (owner && owner !== path) {
       digest = fullDigest;
       digests.set(owner, createHash("sha256").update(owner).digest("base64url"));
     }
-    owners.set(digest, path3);
-    digests.set(path3, digest);
+    owners.set(digest, path);
+    digests.set(path, digest);
   }
   const perPath = Math.max(JSON.stringify("#" + "x".repeat(12)).length, Math.floor((budgetChars - unique.length * 3) / unique.length));
-  return new Map(unique.map((path3) => [
-    path3,
-    compactPathLine(path3, perPath, digests.get(path3) ?? "")
+  return new Map(unique.map((path) => [
+    path,
+    compactPathLine(path, perPath, digests.get(path) ?? "")
   ]));
 }
 function mergeBodies(first, second) {
@@ -3008,7 +3016,7 @@ function extractOpenLoops(msgs, extraction) {
   }));
   for (const err of extraction.errors.filter((e) => !e.resolved)) {
     const errLower = err.message.toLowerCase();
-    const errFiles = fileNeedles.filter(({ needles }) => needles.some((n) => errLower.includes(n))).map(({ path: path4 }) => path4);
+    const errFiles = fileNeedles.filter(({ needles }) => needles.some((n) => errLower.includes(n))).map(({ path }) => path);
     loops.push({
       id: ID_PREFIX.OPEN_LOOP + ++loopId,
       type: "bugfix",
@@ -3536,27 +3544,27 @@ class SecretScrubber {
       findings.set("credential", (findings.get("credential") ?? 0) + 1);
       this.total++;
     };
-    const visit = (value2) => {
-      if (typeof value2 === "string") {
-        const result = this.scrubText(value2);
+    const visit = (value) => {
+      if (typeof value === "string") {
+        const result = this.scrubText(value);
         mergeFindings(findings, result.findings);
         return result.value;
       }
-      if (value2 == null || typeof value2 !== "object")
-        return value2;
-      const cached = seen.get(value2);
+      if (value == null || typeof value !== "object")
+        return value;
+      const cached = seen.get(value);
       if (cached !== undefined)
         return cached;
-      if (Array.isArray(value2)) {
-        const output2 = [];
-        seen.set(value2, output2);
-        for (const item of value2)
-          output2.push(visit(item));
-        return output2;
+      if (Array.isArray(value)) {
+        const output = [];
+        seen.set(value, output);
+        for (const item of value)
+          output.push(visit(item));
+        return output;
       }
       const output = {};
-      seen.set(value2, output);
-      for (const [key, item] of Object.entries(value2)) {
+      seen.set(value, output);
+      for (const [key, item] of Object.entries(value)) {
         const carriesSecret = typeof item === "string" && item.length >= 8;
         if (this.secretsEnabled && isSecretBearingKey(key) && carriesSecret) {
           output[key] = "[REDACTED:credential]";
@@ -3809,14 +3817,14 @@ function getDefaultServices() {
 }
 
 // src/domain/telemetry.ts
-function errorFields(error2, seen = new Set) {
-  if (!error2 || typeof error2 !== "object") {
-    return { name: "", message: String(error2 ?? ""), status: null, code: "" };
+function errorFields(error, seen = new Set) {
+  if (!error || typeof error !== "object") {
+    return { name: "", message: String(error ?? ""), status: null, code: "" };
   }
-  if (seen.has(error2) || seen.size >= 8)
+  if (seen.has(error) || seen.size >= 8)
     return { name: "", message: "", status: null, code: "" };
-  seen.add(error2);
-  const value = error2;
+  seen.add(error);
+  const value = error;
   const cause = value.cause ? errorFields(value.cause, seen) : null;
   const numericStatus = Number(value.status ?? value.statusCode);
   return {
@@ -3826,12 +3834,12 @@ function errorFields(error2, seen = new Set) {
     code: typeof value.code === "string" ? value.code : cause?.code ?? ""
   };
 }
-function classifyTelemetryFailure(error2, timedOut = false) {
-  const fields = errorFields(error2);
+function classifyTelemetryFailure(error, timedOut = false) {
+  const fields = errorFields(error);
   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))
+  if (/max(?:imum)? output|output.?limit|visible[ -]output|length limit|stop reason length/.test(text))
     return "output-limit";
   if (/timeout|timed out|watchdog|deadline/.test(text))
     return "timeout";
@@ -4187,21 +4195,21 @@ function scheduleExtractionCacheCleanup() {
   });
 }
 function reconcileCachedErrors(errors, deltaMessages, deltaToolCalls, baseMsgCount) {
-  return errors.map((error2) => {
-    if (error2.resolved)
-      return { ...error2 };
-    if (!error2.operationSignature)
-      return { ...error2 };
-    let retryAttempted = error2.retryAttempted;
+  return errors.map((error) => {
+    if (error.resolved)
+      return { ...error };
+    if (!error.operationSignature)
+      return { ...error };
+    let retryAttempted = error.retryAttempted;
     let resolved = false;
     for (let j = 0;j < deltaMessages.length; j++) {
       const globalIndex = baseMsgCount + j;
-      if (globalIndex <= error2.index || globalIndex > error2.index + ERROR_RETRY_WINDOW)
+      if (globalIndex <= error.index || globalIndex > error.index + ERROR_RETRY_WINDOW)
         continue;
       const message = deltaMessages[j];
       if (message.role !== "assistant" || !Array.isArray(message.content))
         continue;
-      const retry = message.content.flatMap(flattenToolCallBlock).find((call) => toolOperationSignature(call.name, call.arguments) === error2.operationSignature);
+      const retry = message.content.flatMap(flattenToolCallBlock).find((call) => toolOperationSignature(call.name, call.arguments) === error.operationSignature);
       if (!retry)
         continue;
       retryAttempted = true;
@@ -4210,7 +4218,7 @@ function reconcileCachedErrors(errors, deltaMessages, deltaToolCalls, baseMsgCou
         if (result.role !== "toolResult" || result.isError)
           continue;
         const resultCall = deltaToolCalls.get(result.toolCallId ?? "");
-        const matches = retry.id == null ? Boolean(resultCall && toolOperationSignature(resultCall.name, resultCall.arguments) === error2.operationSignature) : result.toolCallId === retry.id;
+        const matches = retry.id == null ? Boolean(resultCall && toolOperationSignature(resultCall.name, resultCall.arguments) === error.operationSignature) : result.toolCallId === retry.id;
         if (matches) {
           resolved = true;
           break;
@@ -4218,7 +4226,7 @@ function reconcileCachedErrors(errors, deltaMessages, deltaToolCalls, baseMsgCou
       }
       break;
     }
-    return { ...error2, retryAttempted, resolved };
+    return { ...error, retryAttempted, resolved };
   });
 }
 function boundedTail(items, limit) {
@@ -4242,9 +4250,9 @@ function recentUnique(items, limit) {
   };
 }
 function mergeExtractions(base, delta, baseMsgCount, deltaMessages = [], deltaToolCalls = new Map) {
-  const offsetErrors = delta.errors.map((error2) => ({
-    ...error2,
-    index: error2.index + baseMsgCount
+  const offsetErrors = delta.errors.map((error) => ({
+    ...error,
+    index: error.index + baseMsgCount
   }));
   const offsetDecisions = delta.decisions.map((decision) => ({
     ...decision,
@@ -4293,7 +4301,7 @@ function mergeExtractions(base, delta, baseMsgCount, deltaMessages = [], deltaTo
   const referencedFiles = recentUnique([...base.referencedFiles ?? [], ...delta.referencedFiles ?? []], EXTRACTION_LIMITS.REFERENCED_FILES);
   const mediaAttachments = boundedTail([...base.mediaAttachments ?? [], ...offsetMedia], EXTRACTION_LIMITS.MEDIA_ATTACHMENTS);
   const reconciledBaseErrors = reconcileCachedErrors(base.errors, deltaMessages, deltaToolCalls, baseMsgCount);
-  const errors = boundedTail([...reconciledBaseErrors, ...offsetErrors].filter((error2) => !isTransientToolDiagnostic(error2.message)), EXTRACTION_LIMITS.ERRORS);
+  const errors = boundedTail([...reconciledBaseErrors, ...offsetErrors].filter((error) => !isTransientToolDiagnostic(error.message)), EXTRACTION_LIMITS.ERRORS);
   const decisions = boundedTail([...base.decisions, ...offsetDecisions], EXTRACTION_LIMITS.DECISIONS);
   const constraints = boundedTail([...base.constraints, ...offsetConstraints], EXTRACTION_LIMITS.CONSTRAINTS);
   const topics = boundedTail([...base.topics, ...offsetTopics], EXTRACTION_LIMITS.TOPICS);
@@ -4332,7 +4340,7 @@ function mergeExtractions(base, delta, baseMsgCount, deltaMessages = [], deltaTo
       ...base.lastUserMessages,
       ...delta.lastUserMessages
     ].slice(-5),
-    lastErrors: errors.values.filter((error2) => !error2.resolved).map((error2) => error2.message).slice(-3),
+    lastErrors: errors.values.filter((error) => !error.resolved).map((error) => error.message).slice(-3),
     messageCount: baseMsgCount + delta.messageCount,
     ...Object.keys(evidenceOverflow).length ? { evidenceOverflow } : {}
   };
@@ -4349,8 +4357,8 @@ async function appendMetricsSnapshot(sessionId, snapshot) {
       ...snapshot
     });
     return true;
-  } catch (error2) {
-    warn("appendMetricsSnapshot failed", error2);
+  } catch (error) {
+    warn("appendMetricsSnapshot failed", error);
     return false;
   }
 }
@@ -4363,8 +4371,8 @@ async function appendMetricsLog(sessionId, extra, services) {
       ...extra
     });
     return true;
-  } catch (error2) {
-    warn("appendMetricsLog failed", error2);
+  } catch (error) {
+    warn("appendMetricsLog failed", error);
     return false;
   }
 }
@@ -4421,8 +4429,8 @@ function processAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch (error2) {
-    return error2.code === "EPERM";
+  } catch (error) {
+    return error.code === "EPERM";
   }
 }
 function readLease(file) {
@@ -4441,11 +4449,11 @@ function acquireFileLease(file, staleMs) {
       try {
         fs4.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: Date.now(), token }) + `
 `);
-      } catch (error2) {
+      } catch (error) {
         try {
           fs4.unlinkSync(file);
         } catch {}
-        throw error2;
+        throw error;
       } finally {
         fs4.closeSync(fd);
       }
@@ -4463,9 +4471,9 @@ function acquireFileLease(file, staleMs) {
       }, Math.max(1e4, Math.floor(staleMs / 3)));
       lease.heartbeat.unref();
       return lease;
-    } catch (error2) {
-      if (error2.code !== "EEXIST")
-        throw error2;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
       return null;
     }
   };
@@ -4671,7 +4679,7 @@ function resolveMode(requested, contextPercent, extraction, additionalRisk = 0)
     return "fast";
   if (!extraction)
     return contextPercent < 70 ? "fast" : "balanced";
-  const unresolved = extraction.errors.filter((error2) => !error2.resolved).length;
+  const unresolved = extraction.errors.filter((error) => !error.resolved).length;
   const risk = unresolved * 2 + extraction.decisions.length + extraction.constraints.length + Math.ceil(extraction.modifiedFiles.length / 5) + Math.ceil(extraction.topics.length / 4) + additionalRisk;
   if (risk >= 12)
     return "thorough";
@@ -4699,7 +4707,7 @@ function deterministicExtractionConfidence(extraction, context = {}) {
     score -= 0.25;
   if (extraction.topics.length > 6)
     score -= 0.15;
-  if (extraction.errors.filter((error2) => !error2.resolved).length > 2)
+  if (extraction.errors.filter((error) => !error.resolved).length > 2)
     score -= 0.2;
   if ((extraction.mediaAttachments?.length ?? 0) > 0)
     score -= 0.15;
@@ -5002,8 +5010,8 @@ async function saveProjectFingerprint(projectId, sessionId, extraction) {
       release();
     }
     return true;
-  } catch (error2) {
-    warn("saveProjectFingerprint failed", error2);
+  } catch (error) {
+    warn("saveProjectFingerprint failed", error);
     return false;
   }
 }
@@ -5811,8 +5819,8 @@ function freshState(fp, data) {
   if (Date.now() - updatedAt > SEVEN_DAYS_MS) {
     try {
       fs5.unlinkSync(fp);
-    } catch (error2) {
-      debug("stale state cleanup failed", error2);
+    } catch (error) {
+      debug("stale state cleanup failed", error);
     }
     return null;
   }
@@ -5828,12 +5836,12 @@ function pruneScopedStateSnapshots(target) {
     for (const snapshot of snapshots.slice(Math.max(0, STATE_SNAPSHOT_MAX_FILES - 1))) {
       try {
         fs5.unlinkSync(snapshot.file);
-      } catch (error2) {
-        debug("state snapshot cleanup failed", error2);
+      } catch (error) {
+        debug("state snapshot cleanup failed", error);
       }
     }
-  } catch (error2) {
-    debug("state snapshot retention failed", error2);
+  } catch (error) {
+    debug("state snapshot retention failed", error);
   }
 }
 function saveCompactionState(projectId, state) {
@@ -5843,19 +5851,19 @@ function saveCompactionState(projectId, state) {
     if (state.scope)
       pruneScopedStateSnapshots(target);
     return true;
-  } catch (error2) {
-    warn("saveCompactionState failed", error2);
+  } catch (error) {
+    warn("saveCompactionState failed", error);
     return false;
   }
 }
-function loadScopedCompactionState(scope, branchEntryIds2 = []) {
+function loadScopedCompactionState(scope, branchEntryIds = []) {
   const snapshotProbe = scopedCompactionStateFile(scope.projectId, scope.sessionId, "__snapshot__");
   let availableSnapshots = new Set;
   try {
     availableSnapshots = new Set(fs5.readdirSync(path8.dirname(snapshotProbe), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name));
   } catch {}
   const ancestry = Array.from(new Set([
-    ...branchEntryIds2,
+    ...branchEntryIds,
     ...scope.branchHeadId ? [scope.branchHeadId] : []
   ])).reverse();
   const valid = (state, branchHeadId) => Boolean(state?.scope?.schemaVersion === 2 && state.scope.projectId === scope.projectId && state.scope.sessionId === scope.sessionId && typeof state.scope.branchHeadId === "string" && (!branchHeadId || state.scope.branchHeadId === branchHeadId));
@@ -5874,8 +5882,8 @@ function loadScopedCompactionState(scope, branchEntryIds2 = []) {
   try {
     fs5.unlinkSync(legacyPath);
     writeJsonSync(getStatePath(scope.projectId, legacy), legacy, true);
-  } catch (error2) {
-    warn("branch state migration failed", error2);
+  } catch (error) {
+    warn("branch state migration failed", error);
   }
   return legacy;
 }
@@ -6010,7 +6018,7 @@ function mergeCompactionStates(previous, current) {
   const activePrevious = applyContinuityOverrides(previous, factOverrides);
   const currentPresent = new Set([...activeCurrent.modifiedFiles, ...activeCurrent.readFiles].map(normalizeFactKey));
   const currentDeleted = new Set(activeCurrent.deletedFiles.map(normalizeFactKey));
-  const resolvedKeys = new Set(activeCurrent.resolvedErrors.map((error2) => normalizeFactKey(error2.message)));
+  const resolvedKeys = new Set(activeCurrent.resolvedErrors.map((error) => normalizeFactKey(error.message)));
   const isResolvedLoop = (loop) => {
     if (loop.type !== "bugfix" || loop.status !== "open")
       return false;
@@ -6025,7 +6033,7 @@ function mergeCompactionStates(previous, current) {
   };
   const decisions = mergeBy(activeCurrent.decisions, activePrevious.decisions, (item) => normalizeFactKey(item.summary), 30).map((item, index) => ({ ...item, id: ID_PREFIX.DECISION + (index + 1) }));
   const constraints = mergeBy(activeCurrent.constraints, activePrevious.constraints, (item) => normalizeFactKey(item.text), 30).map((item, index) => ({ ...item, id: "constraint-" + (index + 1) }));
-  const unresolvedErrors = mergeBy(activeCurrent.unresolvedErrors, activePrevious.unresolvedErrors.filter((error2) => !resolvedKeys.has(normalizeFactKey(error2.message))), (item) => normalizeFactKey(item.message), 15).map((item, index) => ({ ...item, id: ID_PREFIX.ERROR + (index + 1) }));
+  const unresolvedErrors = mergeBy(activeCurrent.unresolvedErrors, activePrevious.unresolvedErrors.filter((error) => !resolvedKeys.has(normalizeFactKey(error.message))), (item) => normalizeFactKey(item.message), 15).map((item, index) => ({ ...item, id: ID_PREFIX.ERROR + (index + 1) }));
   const openLoops = mergeOpenLoops(activeCurrent.openLoops, activePrevious.openLoops.map((loop) => isResolvedLoop(loop) ? { ...loop, status: "resolved" } : loop));
   const currentGoalKey = activeCurrent.goalKey ?? (activeCurrent.goal ? normalizeFactKey(activeCurrent.goal) : "");
   const previousGoalKey = activePrevious.goalKey ?? (activePrevious.goal ? normalizeFactKey(activePrevious.goal) : "");
@@ -6122,7 +6130,7 @@ function computeDelta(prev, current) {
   const newModifiedFiles = current.modifiedFiles.filter((f) => !prevFiles.has(f));
   const prevErrorMsgs = new Set(prev.unresolvedErrors.map((e) => normalizeFactKey(e.message)));
   const resolvedErrorKeys = new Set([
-    ...current.resolvedErrors.map((error2) => normalizeFactKey(error2.message)),
+    ...current.resolvedErrors.map((error) => normalizeFactKey(error.message)),
     ...retired("error")
   ]);
   const resolvedErrors = prev.unresolvedErrors.filter((e) => resolvedErrorKeys.has(normalizeFactKey(e.message))).map((e) => e.message);
@@ -6196,7 +6204,7 @@ function ensurePinnedPaths(summary, pinned) {
   if (!pinned.length)
     return summary;
   const lower = summary.toLowerCase();
-  const missing = pinned.map((path9) => summaryEvidenceLine(path9, TRUNC.MESSAGE)).filter((path9) => path9 && !lower.includes(path9.toLowerCase()));
+  const missing = pinned.map((path) => summaryEvidenceLine(path, TRUNC.MESSAGE)).filter((path) => path && !lower.includes(path.toLowerCase()));
   if (!missing.length)
     return summary;
   const parsed = parseSummary(summary);
@@ -6225,7 +6233,7 @@ async function showOpenLoopsUI(ctx, sourceLoops, initialOverrides = []) {
   let changed = false;
   while (true) {
     const loops = applyLoopOverrides(sourceLoops, overrides);
-    const labels = loops.map((loop2, index) => index + 1 + ". [" + loop2.status + "/" + loop2.priority + "] " + loop2.summary.slice(0, TRUNC.TOPIC_LABEL));
+    const labels = loops.map((loop, index) => index + 1 + ". [" + loop.status + "/" + loop.priority + "] " + loop.summary.slice(0, TRUNC.TOPIC_LABEL));
     const choice = await ctx.ui.select("Open loops", [...labels, "Done"]);
     if (!choice || choice === "Done")
       return changed ? overrides : null;
@@ -6418,13 +6426,13 @@ var SOFT_BOUNDARY_COPY = {
 function formatPreflightSummary(preflight, modelLabel, details = false) {
   const plan = preflight.plan;
   if (!plan) {
-    const lines2 = [
+    const lines = [
       "Plan unavailable \xB7 " + explainPreflightReason(preflight.reason),
       "\u2713 Complete tool pairs \xB7 \u2713 zero-gap verification before apply"
     ];
     if (details)
-      lines2.push("Estimator  messages ~" + tokenCount(preflight.rawEstimatedMessageTokens) + " \xB7 normalization unavailable", "Route  " + modelLabel + " \xB7 viability " + preflight.reason);
-    return lines2;
+      lines.push("Estimator  messages ~" + tokenCount(preflight.rawEstimatedMessageTokens) + " \xB7 normalization unavailable", "Route  " + modelLabel + " \xB7 viability " + preflight.reason);
+    return lines;
   }
   const stateReserve = Math.max(0, (plan.finalSummaryAllowanceTokens ?? plan.summaryBudgetTokens + Math.ceil(plan.summaryBudgetTokens * POST_SUMMARY_RESERVE_RATIO)) - plan.summaryBudgetTokens);
   const lines = [
@@ -6716,8 +6724,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 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;
+            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;
             lines.push(cell(index === selected ? theme.fg("accent", theme.bold(line)) : theme.fg(viable ? mode === recommended.mode ? "success" : "text" : "muted", line)));
           }
           lines.push(divider);
@@ -6864,7 +6872,7 @@ async function* streamJsonlLines(file, chunkSize = 64 * 1024) {
     if (leftover.length > 0)
       yield leftover;
   } finally {
-    await handle.close().catch((error2) => debug("streamJsonlLines close failed", error2));
+    await handle.close().catch((error) => debug("streamJsonlLines close failed", error));
   }
 }
 var LOG_PATH_CACHE_TTL_MS = 30000;
@@ -6906,26 +6914,26 @@ function findSessionLogFile(sessionId, cwd) {
     const cached = lruGet(logPathCache, cacheKey);
     if (cached && cached.home === home2 && cached.expiresAt > now)
       return cached.path;
-    const sessionsDir2 = getSessionsDir();
-    if (!fs6.existsSync(sessionsDir2))
+    const sessionsDir = getSessionsDir();
+    if (!fs6.existsSync(sessionsDir))
       return remember(null);
     if (directDirectory) {
       const direct = findLogInDirectory(directDirectory, sessionId);
       if (direct)
         return remember(direct);
     }
-    for (const subdir of fs6.readdirSync(sessionsDir2, { withFileTypes: true })) {
+    for (const subdir of fs6.readdirSync(sessionsDir, { withFileTypes: true })) {
       if (!subdir.isDirectory())
         continue;
-      const subdirPath = path10.join(sessionsDir2, subdir.name);
+      const subdirPath = path10.join(sessionsDir, subdir.name);
       if (subdirPath === directDirectory)
         continue;
       const found = findLogInDirectory(subdirPath, sessionId);
       if (found)
         return remember(found);
     }
-  } catch (error2) {
-    debug("findSessionLogFile failed", error2);
+  } catch (error) {
+    debug("findSessionLogFile failed", error);
   }
   return remember(null);
 }
@@ -6990,8 +6998,8 @@ async function readOriginalMessageMap(sessionId, wantedIds, cwd) {
       map
     }, getMaxEntries());
     return map;
-  } catch (error2) {
-    debug("readOriginalMessageMap failed", error2);
+  } catch (error) {
+    debug("readOriginalMessageMap failed", error);
     return null;
   }
 }
@@ -7284,12 +7292,12 @@ function prunePass(dir) {
       try {
         if (isOwnedBackupFile(full))
           fs7.unlinkSync(full);
-      } catch (error2) {
-        debug("prunePass unlink failed", error2);
+      } catch (error) {
+        debug("prunePass unlink failed", error);
       }
     }
-  } catch (error2) {
-    debug("prunePass scan failed", error2);
+  } catch (error) {
+    debug("prunePass scan failed", error);
   }
 }
 function schedulePruneBackups(dir) {
@@ -7323,8 +7331,8 @@ function prepareConversationBackup(source, sessionId, metadata = {}) {
       branchLeafId: metadata.branchLeafId,
       contextTokens: metadata.contextTokens
     };
-  } catch (error2) {
-    warn("prepareConversationBackup failed", error2);
+  } catch (error) {
+    warn("prepareConversationBackup failed", error);
     return null;
   }
 }
@@ -7342,8 +7350,8 @@ async function commitPreparedConversationBackup(prepared) {
     await atomicWriteFile(prepared.path, metadata + body);
     schedulePruneBackups(path11.dirname(prepared.path));
     return prepared.path;
-  } catch (error2) {
-    warn("commitPreparedConversationBackup failed", error2);
+  } catch (error) {
+    warn("commitPreparedConversationBackup failed", error);
     return null;
   }
 }
@@ -7376,8 +7384,8 @@ function listBackups(limit = 20) {
     }
     out.sort((left, right) => left.date < right.date ? 1 : left.date > right.date ? -1 : 0);
     return out.slice(0, limit);
-  } catch (error2) {
-    warn("listBackups failed", error2);
+  } catch (error) {
+    warn("listBackups failed", error);
     return [];
   }
 }
@@ -7405,8 +7413,8 @@ function readConversationBackup(file) {
       ...branchLeafId ? { branchLeafId } : {},
       ...contextTokens !== undefined && Number.isSafeInteger(contextTokens) ? { contextTokens } : {}
     };
-  } catch (error2) {
-    warn("readConversationBackup failed", error2);
+  } catch (error) {
+    warn("readConversationBackup failed", error);
     return null;
   }
 }
@@ -7554,10 +7562,10 @@ function extractWithCache(rc) {
 
 // src/phases/explore.ts
 import { Type } from "typebox";
-function explicitlyRejectsTools(error2) {
-  if (!error2 || typeof error2 !== "object")
+function explicitlyRejectsTools(error) {
+  if (!error || typeof error !== "object")
     return false;
-  const record = error2;
+  const record = error;
   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);
@@ -7925,13 +7933,13 @@ async function exploreConversation(llmMessages, extraction, model, auth, prevSum
     if (cachedSupport === false) {
       if (notify)
         notify("Tool support cached: unsupported (" + cacheLabel + ")", "info");
-      const report2 = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal, svc);
-      if (!report2.boundaries.length) {
+      const report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal, svc);
+      if (!report.boundaries.length) {
         const retried = await explorationRetry(model, auth, llmMessages, extraction, userNote, signal, svc);
         if (retried.boundaries.length)
           return { report: retried, rounds: 1, toolSupported: false };
       }
-      return { report: report2, rounds: 1, toolSupported: false };
+      return { report, rounds: 1, toolSupported: false };
     }
     const probeResp = await trackedComplete("explore", model, {
       systemPrompt: COMPACT_SYSTEM_PREFIX + `
@@ -7999,13 +8007,13 @@ async function exploreConversation(llmMessages, extraction, model, auth, prevSum
         if (nextToolCalls.length === 0) {
           const text = response.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `).trim();
-          let report2 = parseExplorationReport(text, llmMessages);
-          if (!report2.boundaries.length) {
-            report2 = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal, svc);
-            if (report2.boundaries.length)
+          let report = parseExplorationReport(text, llmMessages);
+          if (!report.boundaries.length) {
+            report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal, svc);
+            if (report.boundaries.length)
               rounds++;
           }
-          return { report: report2, rounds, toolSupported: true };
+          return { report, rounds, toolSupported: true };
         }
         messages.push(response);
         for (const tc of nextToolCalls) {
@@ -8024,21 +8032,21 @@ async function exploreConversation(llmMessages, extraction, model, auth, prevSum
       if (lastAssistant?.content) {
         const text = lastAssistant.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `).trim();
-        const report2 = parseExplorationReport(text, llmMessages);
-        if (report2.boundaries.length)
-          return { report: report2, rounds, toolSupported: true };
+        const report = parseExplorationReport(text, llmMessages);
+        if (report.boundaries.length)
+          return { report, rounds, toolSupported: true };
       }
     } else {
       const text = probeResp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `).trim();
-      let report2 = parseExplorationReport(text, llmMessages);
-      const parsedOk = report2.boundaries.length > 0;
+      let report = parseExplorationReport(text, llmMessages);
+      const parsedOk = report.boundaries.length > 0;
       if (!parsedOk) {
-        report2 = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal, svc);
+        report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal, svc);
       }
       if (parsedOk)
         toolSupport.set(cacheKey, true, svc.clock.now());
-      return { report: report2, rounds: 1, toolSupported: parsedOk };
+      return { report, rounds: 1, toolSupported: parsedOk };
     }
   } catch (e) {
     const rejected = explicitlyRejectsTools(e);
@@ -8639,42 +8647,58 @@ async function summarizeBatch(batch, extraction, model, auth, signal, services,
   const cached = cacheKey ? getCachedBatch(cacheKey) : null;
   if (cached)
     return cached;
-  const resp = await trackedComplete("batch", model, {
-    systemPrompt: COMPACT_SYSTEM_PREFIX,
-    messages: [
-      {
-        role: "user",
-        content: [{ type: "text", text: promptPrefix }],
-        timestamp: Date.now()
-      },
-      {
-        role: "user",
-        content: [{ type: "text", text: dynamicSuffix }],
-        timestamp: Date.now()
-      }
-    ]
-  }, {
+  const messages = [
+    {
+      role: "user",
+      content: [{ type: "text", text: promptPrefix }],
+      timestamp: Date.now()
+    },
+    {
+      role: "user",
+      content: [{ type: "text", text: dynamicSuffix }],
+      timestamp: Date.now()
+    }
+  ];
+  const baseOpts = {
     apiKey: auth.apiKey,
     headers: auth.headers,
     maxTokens: maxOutputTokens ?? Math.min(Math.max(1000, batch.length * 250), 4096, getProviderCaps(model.provider).maxOutputTokens),
     signal
-  }, services);
-  const output = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+  };
+  const attempt = async (reasoning) => {
+    const resp = await trackedComplete("batch", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages
+    }, reasoning === undefined ? baseOpts : { ...baseOpts, reasoning }, services);
+    const output = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `);
-  const sectionMap = new Map;
-  const duplicateIds = new Set;
-  const sections = output.split(/^### /m).filter((s) => s.trim());
-  for (const sec of sections) {
-    const m = sec.match(/^CHUNK\s+(\d+):\s*(.*?)\n/i);
-    if (m) {
-      const id = parseInt(m[1], 10);
-      if (sectionMap.has(id))
-        duplicateIds.add(id);
-      else
-        sectionMap.set(id, sec);
+    const sectionMap = new Map;
+    const duplicateIds = new Set;
+    const sections = output.split(/^### /m).filter((s) => s.trim());
+    for (const sec of sections) {
+      const m = sec.match(/^CHUNK\s+(\d+):\s*(.*?)\n/i);
+      if (m) {
+        const id = parseInt(m[1], 10);
+        if (sectionMap.has(id))
+          duplicateIds.add(id);
+        else
+          sectionMap.set(id, sec);
+      }
+    }
+    assertCompleteBatchResponse(resp.stopReason, sectionMap, duplicateIds, batch.length);
+    return sectionMap;
+  };
+  let sectionMap;
+  try {
+    sectionMap = await attempt();
+  } catch (err) {
+    if (err instanceof BatchSummaryFormatError && /non-terminal stop reason length/.test(err.message) && services?.thinkingLevels.summaryThinkingLevel !== "minimal") {
+      info("Batch synthesis exhausted the output budget (reasoning shared it); retrying once with minimal reasoning");
+      sectionMap = await attempt("minimal");
+    } else {
+      throw err;
     }
   }
-  assertCompleteBatchResponse(resp.stopReason, sectionMap, duplicateIds, batch.length);
   const result = batch.map((ch, i) => {
     const id = i + 1;
     const sec = sectionMap.get(id) ?? "";
@@ -8714,9 +8738,9 @@ function deterministicFileEvidence(extraction, budgetTokens, continuity = null)
   const deletedPaths = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
   const evidence = buildSummaryPathEvidence([...modifiedPaths, ...readPaths, ...deletedPaths], budgetTokens);
   return {
-    modified: modifiedPaths.map((path12) => evidence.get(path12)).filter((path12) => Boolean(path12)),
-    read: readPaths.map((path12) => evidence.get(path12)).filter((path12) => Boolean(path12)),
-    deleted: deletedPaths.map((path12) => evidence.get(path12)).filter((path12) => Boolean(path12))
+    modified: modifiedPaths.map((path) => evidence.get(path)).filter((path) => Boolean(path)),
+    read: readPaths.map((path) => evidence.get(path)).filter((path) => Boolean(path)),
+    deleted: deletedPaths.map((path) => evidence.get(path)).filter((path) => Boolean(path))
   };
 }
 async function assembleLLM(summaries, extraction, report, model, auth, budget, prevContext, signal, services, focus, continuity = null) {
@@ -8756,8 +8780,8 @@ function assembleFallback(summaries, extraction, steering = {}, budgetTokens = 6
   const detModified = files.modified;
   const detRead = files.read;
   const detDeleted = files.deleted;
-  const unresolved = extraction.errors.filter((error2) => !error2.resolved).map((error2) => safe(error2.message, TRUNC.PREVIEW)).filter(Boolean);
-  const resolved = extraction.errors.filter((error2) => error2.resolved).slice(-5).map((error2) => safe(error2.message, TRUNC.PREVIEW)).filter(Boolean);
+  const unresolved = extraction.errors.filter((error) => !error.resolved).map((error) => safe(error.message, TRUNC.PREVIEW)).filter(Boolean);
+  const resolved = extraction.errors.filter((error) => error.resolved).slice(-5).map((error) => safe(error.message, TRUNC.PREVIEW)).filter(Boolean);
   const constraints = extraction.constraints.map((item) => "- [" + item.category + "] " + safe(item.text)).filter((line) => !line.endsWith("] "));
   if (steering.focus?.trim())
     constraints.push("- [focus] Preserve detail about: " + safe(steering.focus, TRUNC.CONSTRAINT_TEXT));
@@ -8777,8 +8801,8 @@ function assembleFallback(summaries, extraction, steering = {}, budgetTokens = 6
   const goal = safe(extraction.mainGoal ?? "", TRUNC.DETAIL) || "Continue the current task.";
   const overflow = Object.entries(extraction.evidenceOverflow ?? {}).filter(([, count]) => typeof count === "number" && count > 0).map(([kind, count]) => "- Safety bound omitted " + count + " older " + kind + " item(s) from the human summary.");
   const critical = [
-    ...unresolved.map((error2) => "- Unresolved error: " + safe(error2, TRUNC.TOPIC_LABEL)),
-    ...resolved.map((error2) => "- Resolved error: " + safe(error2, TRUNC.TOPIC_LABEL)),
+    ...unresolved.map((error) => "- Unresolved error: " + safe(error, TRUNC.TOPIC_LABEL)),
+    ...resolved.map((error) => "- Resolved error: " + safe(error, TRUNC.TOPIC_LABEL)),
     ...overflow
   ];
   return [
@@ -8794,7 +8818,7 @@ function assembleFallback(summaries, extraction, steering = {}, budgetTokens = 6
     "### In Progress",
     ...inProgress.length ? inProgress : ["- Continue current work."],
     "### Blocked",
-    ...unresolved.length ? unresolved.map((error2) => "- " + error2) : ["- None recorded."],
+    ...unresolved.length ? unresolved.map((error) => "- " + error) : ["- None recorded."],
     "",
     "## Key Decisions",
     ...decisions.length ? decisions : ["- None recorded."],
@@ -8946,7 +8970,7 @@ function hasListedPath(listed, file, display, normalizedOwners) {
   return false;
 }
 function outcomeClaims(summary, pathEvidence) {
-  const pathLines = new Set(Array.from(pathEvidence, ([path12, display]) => [path12, display, "`" + path12 + "`"]).flat());
+  const pathLines = new Set(Array.from(pathEvidence, ([path, display]) => [path, display, "`" + path + "`"]).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) {
@@ -9016,7 +9040,7 @@ function successfulToolEvidence(messages) {
 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)))
+  if (category === "error" && extraction.errors.some((error) => error.resolved && hasSemanticEvidence(claim, error.message)))
     return true;
   if (category === "file" && extraction.modifiedFiles.some((file) => claim.toLowerCase().includes(file.path.toLowerCase())))
     return true;
@@ -9381,15 +9405,15 @@ function uniqueByText(items, text) {
 }
 function collectVerificationEvidence(extraction, continuity, evidence) {
   const unresolved = uniqueByText([
-    ...extraction.errors.flatMap((error2) => !error2.resolved ? [{ message: error2.message }] : []),
-    ...(continuity?.unresolvedErrors ?? []).map((error2) => ({
-      message: error2.message
+    ...extraction.errors.flatMap((error) => !error.resolved ? [{ message: error.message }] : []),
+    ...(continuity?.unresolvedErrors ?? []).map((error) => ({
+      message: error.message
     }))
   ], (item) => item.message);
   const resolved = uniqueByText([
-    ...extraction.errors.flatMap((error2) => error2.resolved ? [{ message: error2.message }] : []),
-    ...(continuity?.resolvedErrors ?? []).map((error2) => ({
-      message: error2.message
+    ...extraction.errors.flatMap((error) => error.resolved ? [{ message: error.message }] : []),
+    ...(continuity?.resolvedErrors ?? []).map((error) => ({
+      message: error.message
     }))
   ], (item) => item.message).slice(-5);
   const steeringConstraints = [];
@@ -9476,16 +9500,16 @@ function verifyPathCoverage(parsed, extraction, continuity, evidence, accumulato
   return { modified, read, deleted, rendered };
 }
 function verifyErrorEvidence(normalizedSummary, collected, accumulator) {
-  for (const error2 of collected.unresolved) {
-    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
+  for (const error of collected.unresolved) {
+    const snippet = summaryEvidenceLine(error.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
-      addGap(accumulator, { kind: "missing-error", message: error2.message }, 5);
+      addGap(accumulator, { kind: "missing-error", message: error.message }, 5);
     }
   }
-  for (const error2 of collected.resolved) {
-    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
+  for (const error of collected.resolved) {
+    const snippet = summaryEvidenceLine(error.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
-      addGap(accumulator, { kind: "missing-error", message: error2.message, resolved: true }, 2);
+      addGap(accumulator, { kind: "missing-error", message: error.message, resolved: true }, 2);
     }
   }
 }
@@ -9565,7 +9589,7 @@ function verifyFileReferences(summary, extraction, continuity, evidence, collect
     ...renderedPaths.flatMap(extractFileRefs),
     ...continuity?.modifiedFiles ?? [],
     ...continuity?.readFiles ?? [],
-    ...(continuity?.unresolvedErrors ?? []).flatMap((error2) => error2.files),
+    ...(continuity?.unresolvedErrors ?? []).flatMap((error) => error.files),
     ...(continuity?.openLoops ?? []).flatMap((loop) => loop.files)
   ]));
   const knownFileIndex = buildKnownPathReferenceIndex(knownFiles);
@@ -9593,8 +9617,8 @@ function verifyProgressConsistency(parsed, extraction, collected, paths, accumul
     const needles = buildUniquePathNeedlesFromIndex(file.path, modifiedPathOwners);
     if (!needles.some((needle) => doneRefs.has(needle)))
       continue;
-    const unresolved = collected.unresolved.find((error2) => {
-      const firstLine = error2.message.split(/\r?\n/, 1)[0] ?? "";
+    const unresolved = collected.unresolved.find((error) => {
+      const firstLine = error.message.split(/\r?\n/, 1)[0] ?? "";
       const refs = extractFileRefs(firstLine).map(normalizePath);
       return needles.some((needle) => refs.includes(normalizePath(needle)));
     });
@@ -9645,19 +9669,19 @@ function patchDeterministic(summary, gaps, extraction, continuity = null, eviden
   const deletedPaths = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
   const pathEvidence = buildSummaryPathEvidence([...modifiedPaths, ...readPaths, ...deletedPaths], evidence.summaryBudgetTokens);
   const replaceFileSection = (kind, paths) => {
-    const body = paths.map((path12) => "- " + (pathEvidence.get(path12) ?? JSON.stringify(path12))).join(`
+    const body = paths.map((path) => "- " + (pathEvidence.get(path) ?? JSON.stringify(path))).join(`
 `);
     canonical = upsertSection(canonical, kind, body || "- None recorded.");
   };
   const safe = (value, max = TRUNC.MESSAGE) => summaryEvidenceLine(value, max);
   const unresolvedMessages = Array.from(new Set([
-    ...extraction.errors.filter((error2) => !error2.resolved).map((error2) => error2.message),
-    ...(continuity?.unresolvedErrors ?? []).map((error2) => error2.message)
+    ...extraction.errors.filter((error) => !error.resolved).map((error) => error.message),
+    ...(continuity?.unresolvedErrors ?? []).map((error) => error.message)
   ]));
   const unresolvedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved");
   const blockedItems = [
     ...unresolvedMessages.map((message) => safe(message)).filter(Boolean).map((message) => "- " + message),
-    ...unresolvedLoops.map((loop) => safe(loop.summary)).filter(Boolean).map((summary2) => "- " + summary2)
+    ...unresolvedLoops.map((loop) => safe(loop.summary)).filter(Boolean).map((summary) => "- " + summary)
   ];
   const patchBlockedNone = () => {
     const progress = findSection(canonical, "progress");
@@ -9732,8 +9756,8 @@ function patchDeterministic(summary, gaps, extraction, continuity = null, eviden
         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 current = extraction.errors.filter((error) => !error.resolved).map((error) => safe(error.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
+        const carriedErrors = (continuity?.unresolvedErrors ?? []).map((error) => safe(error.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)
@@ -9828,8 +9852,8 @@ Return the COMPLETE corrected summary in the same format.`;
     ]));
     const preserved = originalSections.every((section) => !section.body.trim() || Boolean(patchedBodies.get(sectionIdentity(section))));
     return preserved ? patched : summary;
-  } catch (error2) {
-    debug("patchSummary LLM failed", error2);
+  } catch (error) {
+    debug("patchSummary LLM failed", error);
     return summary;
   }
 }
@@ -9905,20 +9929,20 @@ function failureAction(kind) {
       return "For local stack diagnostics, restart Pi with DEBUG=smart-compact and reproduce.";
   }
 }
-function formatGenerationFailureForUi(error2) {
-  const kind = classifyTelemetryFailure(error2);
+function formatGenerationFailureForUi(error) {
+  const kind = classifyTelemetryFailure(error);
   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.";
+function formatCompactErrorForUi(error) {
+  if (error instanceof VerificationGateError) {
+    const kinds = error.gapKinds.slice(0, 4).join(", ") || "unknown";
+    return "Verification stopped apply at the " + error.stage + " gate: " + error.score + "/100, " + error.gapCount + (error.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.";
+  if (error instanceof YieldGateError) {
+    const reason = error.reason === "target-miss" ? "target missed" : "saving below 10%";
+    return "Yield check stopped apply: estimated " + error.estimatedAfterTokens.toLocaleString() + "t after vs " + error.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));
+  return "Smart compact failed [" + classifyTelemetryFailure(error) + "]. Conversation unchanged. " + failureAction(classifyTelemetryFailure(error));
 }
 
 // src/app/steps/synthesize.ts
@@ -9931,8 +9955,8 @@ async function summarizeConversation(rc) {
     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);
+      const policy = MODE_POLICIES[refined];
+      rc.services.budget.setLimits(resolveCallBudget(rc.config.maxLlmCalls, refined, rc.maxLlmCalls, rc.flags.autoTriggered && !rc.flags.skipCompact), effectiveBudget(rc.config.maxLlmInputTokens, policy.maxInputTokens, rc.maxLlmInputTokens), policy.maxOutputTokens);
       rc.notify("Auto strategy refined to " + refined + " within the planned " + rc.profile + " window", "info");
     }
   }
@@ -9972,9 +9996,9 @@ async function summarizeConversation(rc) {
       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);
+    const finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
     setCachedSynthesis(cacheKey, {
-      finalSummary: finalSummary2,
+      finalSummary,
       method: "heuristic",
       summaries: [],
       explorationReport: null,
@@ -9983,7 +10007,7 @@ async function summarizeConversation(rc) {
     });
     rc.notify("Zero-call deterministic compaction (high-confidence extraction)", "info");
     Object.assign(rc, {
-      finalSummary: finalSummary2,
+      finalSummary,
       method: "heuristic",
       methodForMetrics: "zero-call",
       generationFallbacks: [],
@@ -10012,11 +10036,11 @@ async function summarizeConversation(rc) {
   let summaryAuth;
   try {
     summaryAuth = await resolveStageAuth(rc, "summary");
-  } catch (error2) {
+  } catch (error) {
     cacheable = false;
     generationFallbacks.push("summary route unavailable");
-    debugError("Summary route unavailable", error2);
-    rc.notify("Summary route unavailable \xB7 using deterministic fallback [" + formatGenerationFailureForUi(error2) + "]", "warning");
+    debugError("Summary route unavailable", error);
+    rc.notify("Summary route unavailable \xB7 using deterministic fallback [" + formatGenerationFailureForUi(error) + "]", "warning");
   }
   if (!summaryAuth) {
     showProgressOverlay(rc.ctx, {
@@ -10128,6 +10152,9 @@ async function summarizeConversation(rc) {
       totalBatches
     });
     const concurrency = rc.providerCaps.concurrencyLimit;
+    if (rc.services.thinkingLevels.summaryThinkingLevel == null) {
+      rc.notify("Summary thinking level unset \u2014 provider-default reasoning may share the batch output budget (length-truncated batches retry once at minimal reasoning)", "info");
+    }
     if (totalBatches <= 1) {
       const single = batches[0];
       if (single) {
@@ -10213,8 +10240,8 @@ async function summarizeConversation(rc) {
         if (r)
           summaries.push(...r);
       const failedBatches = errors.filter(Boolean);
-      for (const error2 of failedBatches)
-        debugError("Synthesis batch used deterministic fallback", error2);
+      for (const error of failedBatches)
+        debugError("Synthesis batch used deterministic fallback", error);
       if (failedBatches.length) {
         cacheable = false;
         generationFallbacks.push(failedBatches.length + " synthesis batch fallback(s)");
@@ -10331,8 +10358,8 @@ async function verifyAndPatch(rc) {
     try {
       const verifyAuth = await resolveStageAuth(rc, "verify");
       summary = await patchSummary(summary, verification.gaps, rc.verifyModel ?? rc.summaryModel, verifyAuth, rc.cancellation.signal, rc.services);
-    } catch (error2) {
-      debugError("LLM verification patch used deterministic fallback", error2);
+    } catch (error) {
+      debugError("LLM verification patch used deterministic fallback", error);
     }
     if (summary !== beforePatch) {
       llmPatched = true;
@@ -10543,11 +10570,11 @@ function bunSqliteAdapter(db) {
         const result = fn(...args);
         db.exec("COMMIT");
         return result;
-      } catch (error2) {
+      } catch (error) {
         try {
           db.exec("ROLLBACK");
         } catch {}
-        throw error2;
+        throw error;
       }
     },
     close: () => db.close()
@@ -10563,11 +10590,11 @@ function nodeSqliteAdapter(db) {
         const result = fn(...args);
         db.exec("COMMIT");
         return result;
-      } catch (error2) {
+      } catch (error) {
         try {
           db.exec("ROLLBACK");
         } catch {}
-        throw error2;
+        throw error;
       }
     },
     close: () => db.close()
@@ -10810,7 +10837,10 @@ function addFact(db, scope, sessionNodeId, kind, title, content, relatedPaths =
   });
   node.factKey = factKey(keyText);
   node.id = stableId(scope.projectId, scope.sessionId, kind, node.factKey, scope.branchHeadId ?? "");
-  if (sameActiveFact(latestLineageFact(db, scope, kind, node.factKey), node))
+  const latest = latestLineageFact(db, scope, kind, node.factKey);
+  if (sameActiveFact(latest, node))
+    return;
+  if (latest && latest.status !== "active" && node.status === "active")
     return;
   upsertNode(db, node);
   linkNodes(db, scope.projectId, sessionNodeId, node.id, "contains", 1, node.updatedAt);
@@ -10895,7 +10925,10 @@ function indexCompactionState(projectId, state) {
           relatedPaths: item.files,
           confidence: item.priority === "critical" || item.priority === "high" ? 0.98 : 0.88
         });
-        if (sameActiveFact(latestLineageFact(db, scope, "loop", node.factKey), node))
+        const latestLoop = latestLineageFact(db, scope, "loop", node.factKey);
+        if (sameActiveFact(latestLoop, node))
+          continue;
+        if (latestLoop && latestLoop.status !== "active" && node.status === "active")
           continue;
         upsertNode(db, node);
         linkNodes(db, projectId, sessionNode.id, node.id, "contains", 1, now);
@@ -10935,8 +10968,8 @@ function indexCompactionState(projectId, state) {
     });
     transaction();
     return true;
-  } catch (error2) {
-    warn("indexCompactionState failed", error2);
+  } catch (error) {
+    warn("indexCompactionState failed", error);
     return false;
   }
 }
@@ -10944,8 +10977,8 @@ var pendingCompactionIndexes = new Map;
 var compactionIndexDrainScheduled = false;
 var MAX_PENDING_COMPACTION_INDEXES = 64;
 function settleIndexJob(job, indexed) {
-  for (const resolve2 of job.resolve)
-    resolve2(indexed);
+  for (const resolve of job.resolve)
+    resolve(indexed);
 }
 function drainCompactionIndexes() {
   compactionIndexDrainScheduled = false;
@@ -10959,8 +10992,8 @@ function drainCompactionIndexes() {
     for (const job of jobs) {
       settleIndexJob(job, indexCompactionState(job.projectId, job.state));
     }
-  } catch (error2) {
-    warn("context graph index drain failed", error2);
+  } catch (error) {
+    warn("context graph index drain failed", error);
     for (const job of jobs)
       settleIndexJob(job, false);
   } finally {
@@ -10981,22 +11014,25 @@ function scheduleCompactionStateIndex(projectId, state) {
   if (!sessionId || !branchHeadId || state.scope?.projectId !== projectId)
     return Promise.resolve(false);
   const key = projectId + "\x00" + sessionId + "\x00" + branchHeadId;
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const existing = pendingCompactionIndexes.get(key);
     if (existing) {
       existing.state = state;
-      existing.resolve.push(resolve2);
+      existing.resolve.push(resolve);
       return;
     }
     if (pendingCompactionIndexes.size >= MAX_PENDING_COMPACTION_INDEXES) {
       warn("context graph index queue full; new derived update was rejected");
-      resolve2(false);
+      resolve(false);
       return;
     }
-    pendingCompactionIndexes.set(key, { projectId, state, resolve: [resolve2] });
+    pendingCompactionIndexes.set(key, { projectId, state, resolve: [resolve] });
     armCompactionIndexDrain();
   });
 }
+function flushCompactionStateIndexes() {
+  drainCompactionIndexes();
+}
 function closeContextMemory(projectId, kind, content, status) {
   const db = openDatabase();
   const rows = db.query(`
@@ -11225,8 +11261,8 @@ function recallContext(scope, query, options = {}) {
         break;
     }
     return [...deduped.values()];
-  } catch (error2) {
-    warn("recallContext failed", error2);
+  } catch (error) {
+    warn("recallContext failed", error);
     return [];
   }
 }
@@ -11260,6 +11296,42 @@ function formatRecallResults(results, maxChars = 6000) {
 
 `);
 }
+function getContextGraphStats(projectId) {
+  try {
+    const db = openDatabase();
+    const row = db.query(`
+      SELECT count(*) AS totalNodes,
+        sum(CASE WHEN status = 'active' THEN 1 ELSE 0 END) AS activeNodes,
+        count(DISTINCT CASE WHEN kind = 'session' THEN session_id END) AS sessions,
+        max(updated_at) AS lastUpdatedAt
+      FROM context_nodes WHERE project_id = ? AND kind NOT IN ('project')
+    `).get(projectId);
+    return {
+      totalNodes: Number(row?.totalNodes ?? 0),
+      activeNodes: Number(row?.activeNodes ?? 0),
+      sessions: Number(row?.sessions ?? 0),
+      lastUpdatedAt: row?.lastUpdatedAt == null ? null : Number(row.lastUpdatedAt)
+    };
+  } catch {
+    return { totalNodes: 0, activeNodes: 0, sessions: 0, lastUpdatedAt: null };
+  }
+}
+function forgetProjectGraph(projectId) {
+  try {
+    flushCompactionStateIndexes();
+    const db = openDatabase();
+    const transaction = db.transaction(() => {
+      db.query("DELETE FROM context_nodes_fts WHERE node_id IN (SELECT id FROM context_nodes WHERE project_id = ?)").run(projectId);
+      db.query("DELETE FROM context_edges WHERE project_id = ?").run(projectId);
+      db.query("DELETE FROM context_nodes WHERE project_id = ?").run(projectId);
+    });
+    transaction();
+    return true;
+  } catch (error) {
+    warn("forgetProjectGraph failed", error);
+    return false;
+  }
+}
 
 // src/domain/provider-evaluation.ts
 function providerStage(phase) {
@@ -11804,10 +11876,10 @@ var POLICY_PATHS = new Set([
   "autoTrigger",
   "showStatus"
 ]);
-function applyGlobalSettingRuntime(path14, ctx, policy, contextTools) {
-  if (POLICY_PATHS.has(path14))
+function applyGlobalSettingRuntime(path, ctx, policy, contextTools) {
+  if (POLICY_PATHS.has(path))
     policy.restore(ctx);
-  if (path14 === "contextGraphEnabled")
+  if (path === "contextGraphEnabled")
     contextTools.apply();
 }
 
@@ -12073,8 +12145,8 @@ function createNativeContinuityBridge(opts = {}) {
             fs10.chmodSync(target, 384);
           } catch {}
         });
-      } catch (error2) {
-        debug("native continuity stage failed", error2);
+      } catch (error) {
+        debug("native continuity stage failed", error);
       }
     },
     take(scope) {
@@ -12094,8 +12166,8 @@ function createNativeContinuityBridge(opts = {}) {
           }
           return sameScope(entry.scope, scope) && now() - entry.createdAt <= ttlMs ? entry.text : null;
         });
-      } catch (error2) {
-        debug("native continuity take failed", error2);
+      } catch (error) {
+        debug("native continuity take failed", error);
         return null;
       }
     },
@@ -12114,15 +12186,15 @@ function createNativeContinuityBridge(opts = {}) {
             } catch {}
           }
         });
-      } catch (error2) {
-        debug("native continuity clear failed", error2);
+      } catch (error) {
+        debug("native continuity clear failed", error);
       }
     },
     size() {
       try {
         return locked(() => prune(0).length);
-      } catch (error2) {
-        debug("native continuity size failed", error2);
+      } catch (error) {
+        debug("native continuity size failed", error);
         return 0;
       }
     }
@@ -12163,7 +12235,7 @@ function createSettledAutoTrigger(options = {}) {
       return;
     const requestToken = Symbol(sessionId);
     active.set(sessionId, requestToken);
-    await new Promise((resolve2) => {
+    await new Promise((resolve) => {
       let finished = false;
       const finish = () => {
         if (finished)
@@ -12171,7 +12243,7 @@ function createSettledAutoTrigger(options = {}) {
         finished = true;
         if (active.get(sessionId) === requestToken)
           active.delete(sessionId);
-        resolve2();
+        resolve();
       };
       try {
         ctx.compact({
@@ -12180,13 +12252,13 @@ function createSettledAutoTrigger(options = {}) {
               noteCompaction(sessionId);
             finish();
           },
-          onError: (error2) => {
-            debugError("Settled smart compact request failed", error2);
+          onError: (error) => {
+            debugError("Settled smart compact request failed", error);
             finish();
           }
         });
-      } catch (error2) {
-        debugError("Settled smart compact request failed", error2);
+      } catch (error) {
+        debugError("Settled smart compact request failed", error);
         finish();
       }
     });
@@ -12430,14 +12502,13 @@ Paths: ` + relatedPaths.join(", ") : ""));
           ],
           details: { memory, redactions: scrubber.count() }
         };
-      } catch (error2) {
-        debugError("Project memory persistence failed", error2);
-        const message = scrubber.scrubText(error2 instanceof Error ? error2.message : String(error2)).value;
+      } catch (error) {
+        debugError("Project memory persistence failed", error);
+        const message = scrubber.scrubText(error instanceof Error ? error.message : String(error)).value;
         throw new Error("Project memory could not be saved: " + message);
       }
     }
   });
-  availability.apply();
   pi.on("session_start", availability.apply);
   return availability;
 }
@@ -12468,8 +12539,8 @@ function createContextToolAvailability(pi) {
           hiddenByConfig.clear();
           disabledByConfig = false;
         }
-      } catch (error2) {
-        debugError("Context tool availability update failed", error2);
+      } catch (error) {
+        debugError("Context tool availability update failed", error);
       }
     }
   };
@@ -12856,14 +12927,14 @@ function summarizeDashboard(entries) {
   const durations = entries.map(metricDuration).filter(Boolean);
   const success = entries.filter((e) => statusLabel(e.status) === "success").length;
   const timeout = entries.filter((e) => e.status === "timeout").length;
-  const error2 = entries.filter((e) => e.status === "error").length;
+  const error = entries.filter((e) => e.status === "error").length;
   const dryRun = entries.filter((e) => e.status === "dry-run").length;
   const scored = entries.map((e) => e.verificationScore).filter((v) => typeof v === "number");
   return {
     runs: entries.length,
     success,
     timeout,
-    error: error2,
+    error,
     dryRun,
     successRate: entries.length ? success / entries.length : 0,
     avgDuration: Math.round(average(durations)),
@@ -13202,7 +13273,8 @@ var ACTIONS = {
   dashboard: "dashboard",
   restore: "restore",
   loops: "loops",
-  settings: "settings"
+  settings: "settings",
+  forget: "forget"
 };
 var MODES = {
   auto: "auto",
@@ -13415,12 +13487,12 @@ Dashboard: ` + dashboard : ""));
       const usage = ctx.getContextUsage?.();
       const totalTokens = usage?.tokens ?? 0;
       const contextPercent = safeContextPercent(totalTokens, ctx.model?.contextWindow);
-      const percent2 = Math.round(contextPercent);
+      const percent = Math.round(contextPercent);
       if (!totalTokens || totalTokens < MIN_TOKEN_THRESHOLD) {
-        return textResult("Context is not large enough for compaction (" + totalTokens.toLocaleString() + " tokens, " + percent2 + "%). No action needed.");
+        return textResult("Context is not large enough for compaction (" + totalTokens.toLocaleString() + " tokens, " + percent + "%). No action needed.");
       }
       if (contextPercent < config.minContextPercent) {
-        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.");
+        return textResult("Compaction skipped: context " + percent + "% (" + 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);
@@ -13475,9 +13547,9 @@ Dashboard: ` + dashboard : ""));
           return textResult("Smart compact cancelled by " + outcome.source + "; no summary was staged.");
         }
         return textResult("Smart compact skipped: " + outcome.reason.replace(/-/g, " ") + ". No summary was staged.");
-      } catch (error2) {
-        debugError("Smart compact tool failed", error2);
-        throw new Error(formatCompactErrorForUi(error2));
+      } catch (error) {
+        debugError("Smart compact tool failed", error);
+        throw new Error(formatCompactErrorForUi(error));
       }
     }
   });
@@ -13751,7 +13823,7 @@ var LIMIT_SETTINGS = [
     id: "codexMaxCallMs",
     label: "Codex call watchdog",
     description: "Zero derives the per-call watchdog automatically.",
-    placeholder: "0 or 5000\u2013300000; blank uses default",
+    placeholder: "0 or 5000\u20133600000; blank uses default",
     parse: numberParser(CONFIG_NUMERIC_LIMITS.codexMaxCallMs),
     format: scalarFormat
   },
@@ -13759,9 +13831,17 @@ var LIMIT_SETTINGS = [
     id: "maxLatencyMs",
     label: "Pipeline latency limit",
     description: "Zero disables the overall pipeline deadline.",
-    placeholder: "0 or 5000\u2013600000; blank uses default",
+    placeholder: "0 or 5000\u20137200000; blank uses default",
     parse: numberParser(CONFIG_NUMERIC_LIMITS.maxLatencyMs),
     format: scalarFormat
+  },
+  {
+    id: "pendingTtlMs",
+    label: "Staged summary TTL",
+    description: "How long a staged summary waits for commit before expiry.",
+    placeholder: "1000\u20133600000; blank uses default",
+    parse: numberParser(CONFIG_NUMERIC_LIMITS.pendingTtlMs),
+    format: scalarFormat
   }
 ];
 var PATH_SETTINGS = [
@@ -13865,17 +13945,17 @@ class InputSettingEditor extends Container3 {
       let parsed;
       try {
         parsed = setting.parse(value);
-      } catch (error2) {
-        this.status.setText(error2 instanceof Error ? error2.message : String(error2));
+      } catch (error) {
+        this.status.setText(error instanceof Error ? error.message : String(error));
         this.requestRender();
         return;
       }
       this.saving = true;
       this.status.setText("Saving\u2026");
       this.requestRender();
-      this.pending = this.save(parsed).then(() => this.done()).catch((error2) => {
+      this.pending = this.save(parsed).then(() => this.done()).catch((error) => {
         this.saving = false;
-        this.status.setText(error2 instanceof Error ? error2.message : String(error2));
+        this.status.setText(error instanceof Error ? error.message : String(error));
         this.requestRender();
       });
     };
@@ -13934,9 +14014,9 @@ class ModelSettingEditor extends Container3 {
       const selected = models.find((candidate) => candidate.value === item.value);
       if (!selected)
         return;
-      this.pending = save(selected.settingValue).then(done).catch((error2) => {
+      this.pending = save(selected.settingValue).then(done).catch((error) => {
         this.saving = false;
-        this.status.setText(error2 instanceof Error ? error2.message : String(error2));
+        this.status.setText(error instanceof Error ? error.message : String(error));
         this.requestRender();
       });
     };
@@ -14024,9 +14104,9 @@ function modelSettingsItems(ctx, requestRender, writeConfig = writeGlobalConfigV
         });
       }
       return new ModelSettingEditor(choices, selectedValue, requestRender, async (selected) => {
-        const effective2 = await writeConfig(setting.id, selected === "default" ? undefined : selected);
+        const effective = await writeConfig(setting.id, selected === "default" ? undefined : selected);
         item.currentValue = selected;
-        item.description = `${setting.description} Effective global value: ${String(effective2[setting.id])}.`;
+        item.description = `${setting.description} Effective global value: ${String(effective[setting.id])}.`;
       }, close);
     };
     return item;
@@ -14128,8 +14208,8 @@ class GlobalSettingsCoordinator {
           this.pending.delete(id);
           this.emit(id, { display, config });
         }
-      } catch (error2) {
-        onError(error2 instanceof Error ? error2.message : String(error2));
+      } catch (error) {
+        onError(error instanceof Error ? error.message : String(error));
         if (this.pending.get(id)?.revision === revision) {
           this.pending.delete(id);
           this.emit(id, {
@@ -14413,8 +14493,8 @@ function sessionSettingsList(policy, ctx, done) {
         ctx.ui.notify(result.error, "error");
         list.updateValue(id, displayValue(field, policy));
       }
-    } catch (error2) {
-      ctx.ui.notify(error2 instanceof Error ? error2.message : String(error2), "error");
+    } catch (error) {
+      ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
       list.updateValue(id, displayValue(policyField(id), policy));
     }
   }, done);
@@ -14511,9 +14591,9 @@ function createSettingsController(root, display, requestRender) {
   };
 }
 async function showSmartCompactSettings(ctx, policy, coordinator = new GlobalSettingsCoordinator, onApplied = () => {}) {
-  const writeConfig = async (path16, value) => {
-    const config = await writeGlobalConfigValue(path16, value);
-    await onApplied(path16, config);
+  const writeConfig = async (path, value) => {
+    const config = await writeGlobalConfigValue(path, value);
+    await onApplied(path, config);
     return config;
   };
   await ctx.ui.custom((tui, theme, _keybindings, done) => {
@@ -14592,10 +14672,10 @@ async function restoreBackup(ctx) {
       if (result.cancelled)
         ctx.ui.notify("Restore cancelled", "info");
       return;
-    } catch (error2) {
-      debugError("Exact backup restore fork unavailable", error2);
-      if (!/Invalid entry ID for forking/i.test(error2 instanceof Error ? error2.message : String(error2))) {
-        ctx.ui.notify("Exact restore failed: " + (error2 instanceof Error ? error2.message : String(error2)), "error");
+    } catch (error) {
+      debugError("Exact backup restore fork unavailable", error);
+      if (!/Invalid entry ID for forking/i.test(error instanceof Error ? error.message : String(error))) {
+        ctx.ui.notify("Exact restore failed: " + (error instanceof Error ? error.message : String(error)), "error");
         return;
       }
     }
@@ -14611,10 +14691,36 @@ async function restoreBackup(ctx) {
     });
     if (result.cancelled)
       ctx.ui.notify("Restore cancelled", "info");
-  } catch (error2) {
-    debugError("Backup restore into new session failed", error2);
-    ctx.ui.notify("Restore failed: " + (error2 instanceof Error ? error2.message : String(error2)), "error");
+  } catch (error) {
+    debugError("Backup restore into new session failed", error);
+    ctx.ui.notify("Restore failed: " + (error instanceof Error ? error.message : String(error)), "error");
+  }
+}
+async function forgetProjectMemory(ctx) {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify("Forgetting project memory requires TUI mode for its confirmation dialog", "warning");
+    return;
+  }
+  const projectId = deriveProjectIdFromCwd(ctx.cwd);
+  if (!projectId) {
+    ctx.ui.notify("Project memory must be forgotten from a project directory", "warning");
+    return;
+  }
+  const stats = getContextGraphStats(projectId);
+  if (!stats.totalNodes) {
+    ctx.ui.notify("No persisted memory for this project", "info");
+    return;
+  }
+  const confirmed = await ctx.ui.confirm("Forget project memory?", "Permanently delete " + stats.totalNodes + " memory nodes (" + stats.sessions + " session" + (stats.sessions === 1 ? "" : "s") + ") for this project, including FTS copies and edges. This cannot be undone. Compaction state (restore data) and backups are kept.");
+  if (!confirmed) {
+    ctx.ui.notify("Forget cancelled \u2014 project memory untouched", "info");
+    return;
   }
+  if (!forgetProjectGraph(projectId)) {
+    ctx.ui.notify("Forget failed \u2014 the graph database reported an error (see DEBUG=smart-compact log)", "error");
+    return;
+  }
+  ctx.ui.notify("Forgotten: deleted " + stats.totalNodes + " memory nodes for this project", "info");
 }
 async function manageOpenLoops(ctx) {
   const projectId = deriveProjectIdFromCwd(ctx.cwd);
@@ -14712,6 +14818,7 @@ function registerSmartCompactCommand(pi, dependencies) {
         "restore",
         "loops",
         "settings",
+        "forget",
         "fast",
         "balanced",
         "thorough",
@@ -14747,12 +14854,16 @@ function registerSmartCompactCommand(pi, dependencies) {
           await manageOpenLoops(ctx);
           return;
         }
+        if (input.action === "forget") {
+          await forgetProjectMemory(ctx);
+          return;
+        }
         if (input.action === "settings") {
           if (ctx.mode !== "tui") {
             ctx.ui.notify("Smart Compact settings require TUI mode. Use settings.json for permanent defaults.", "warning");
             return;
           }
-          await showSmartCompactSettings(ctx, dependencies.policy, settingsCoordinator, (path16) => dependencies.onGlobalSettingApplied?.(path16, ctx));
+          await showSmartCompactSettings(ctx, dependencies.policy, settingsCoordinator, (path) => dependencies.onGlobalSettingApplied?.(path, ctx));
           return;
         }
         const config = loadConfig();
@@ -14788,9 +14899,9 @@ function registerSmartCompactCommand(pi, dependencies) {
           timeoutMs: input.timeoutMs,
           force: true
         });
-      } catch (error2) {
-        debugError("Manual smart compact failed", error2);
-        ctx.ui.notify(formatCompactErrorForUi(error2), "error");
+      } catch (error) {
+        debugError("Manual smart compact failed", error);
+        ctx.ui.notify(formatCompactErrorForUi(error), "error");
       }
     }
   });
@@ -14888,12 +14999,12 @@ function createSmartCompactPolicy(pi) {
     ctx.ui.setStatus(STATUS_KEY, current.showStatus ? statusText(effective) : undefined);
     return effective;
   };
-  const restoreToolMembership = (enabled2) => {
+  const restoreToolMembership = (enabled) => {
     const active = pi.getActiveTools();
     const hasTool = active.includes(SMART_COMPACT_TOOL_NAME);
-    if (enabled2 && !hasTool) {
+    if (enabled && !hasTool) {
       pi.setActiveTools([...new Set([...active, SMART_COMPACT_TOOL_NAME])]);
-    } else if (!enabled2 && hasTool) {
+    } else if (!enabled && hasTool) {
       pi.setActiveTools(active.filter((name) => name !== SMART_COMPACT_TOOL_NAME));
     }
   };
@@ -14905,8 +15016,8 @@ function createSmartCompactPolicy(pi) {
       const effective = apply(ctx);
       pi.appendEntry(SMART_COMPACT_POLICY_ENTRY, { version: POLICY_VERSION, overrides: { ...overrides } });
       return { ok: true, policy: effective };
-    } catch (error2) {
-      debugError("Smart Compact policy update failed", error2);
+    } catch (error) {
+      debugError("Smart Compact policy update failed", error);
       overrides = previous;
       try {
         restoreToolMembership(previousToolEnabled);
@@ -15001,6 +15112,7 @@ function smartCompactExtension(pi) {
     return write;
   };
   const commitCandidates = createCompactionCommitStore({
+    ttlMs: loadConfig().pendingTtlMs,
     onDiscard: (pending, reason) => {
       recordApplyFailure(pending, reason);
     }
@@ -15022,8 +15134,8 @@ function smartCompactExtension(pi) {
       else
         signal.addEventListener("abort", discardOnAbort, { once: true });
       return !signal.aborted;
-    } catch (error2) {
-      warn("Failed to stage smart compaction commit candidate", error2);
+    } catch (error) {
+      warn("Failed to stage smart compaction commit candidate", error);
       recordApplyFailure(pending, "apply-error");
       return false;
     }
@@ -15034,11 +15146,11 @@ function smartCompactExtension(pi) {
     runLock: isRunning,
     onNativeApplyError,
     policy,
-    onGlobalSettingApplied(path16, ctx) {
+    onGlobalSettingApplied(path, ctx) {
       try {
-        applyGlobalSettingRuntime(path16, ctx, policy, contextToolAvailability);
-      } catch (error2) {
-        debugError("Smart Compact runtime settings refresh failed", error2);
+        applyGlobalSettingRuntime(path, ctx, policy, contextToolAvailability);
+      } catch (error) {
+        debugError("Smart Compact runtime settings refresh failed", error);
       }
     }
   });
@@ -15056,8 +15168,8 @@ function smartCompactExtension(pi) {
         ...loadConfig(),
         autoTrigger: true
       });
-    } catch (error2) {
-      debugError("Settled smart compact trigger stopped", error2);
+    } catch (error) {
+      debugError("Settled smart compact trigger stopped", error);
     }
   });
   pi.on("session_before_compact", async (event, ctx) => {
@@ -15158,9 +15270,9 @@ function smartCompactExtension(pi) {
           ctx.ui.notify("Compaction applied, but durable persistence was incomplete: " + persistenceFailures.join(", "), "warning");
         }
         activateOnlineDamage(candidate);
-      } catch (error2) {
+      } catch (error) {
         clearCompactProgress(ctx);
-        warn("Failed to commit applied smart compaction", error2);
+        warn("Failed to commit applied smart compaction", error);
       }
       return;
     }
@@ -15236,8 +15348,8 @@ function smartCompactExtension(pi) {
       if (observation.report.damageScore > 0) {
         ctx.ui.notify("Post-compaction damage detected: " + observation.report.summary, "warning");
       }
-    } catch (error2) {
-      warn("online damage monitor message_end failed", error2);
+    } catch (error) {
+      warn("online damage monitor message_end failed", error);
     }
   });
   pi.on("session_shutdown", async (_event, ctx) => {
@@ -15255,7 +15367,7 @@ function smartCompactExtension(pi) {
   });
 }
 export {
-  resolveModels,
+  smartCompactExtension as default,
   findModelById,
-  smartCompactExtension as default
+  resolveModels
 };