omnius 1.0.471 → 1.0.472

package/dist/index.js

@@ -6288,8 +6288,8 @@ Hotspot: ${Math.round(decayHotspot(entry) * 100)}% | Accesses: ${entry.accessCou
           };
         }
         const entries = Object.values(map2.files);
-        const totalNotes = entries.reduce((sum, e2) => sum + e2.agentNotes.filter((n2) => decayConfidence(n2) > 0.1).length, 0);
-        const totalRelations = entries.reduce((sum, e2) => sum + e2.relationships.length, 0);
+        const totalNotes = entries.reduce((sum2, e2) => sum2 + e2.agentNotes.filter((n2) => decayConfidence(n2) > 0.1).length, 0);
+        const totalRelations = entries.reduce((sum2, e2) => sum2 + e2.relationships.length, 0);
         const hotspots = entries.map((e2) => ({ path: e2.path, score: decayHotspot(e2), notes: e2.agentNotes.filter((n2) => decayConfidence(n2) > 0.1).length })).filter((e2) => e2.score > 0.05).sort((a2, b) => b.score - a2.score).slice(0, 5);
         const lines = [
           `Codebase Semantic Map:`,
@@ -11053,7 +11053,7 @@ async function prepareHuggingFaceVisionCandidate(candidate, diagnostics) {
         safetyMarginBytes: gigabytesToBytes(2)
       });
       if (space.evicted.length > 0) {
-        diagnostics.push(`Hugging Face vision evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum, entry) => sum + entry.sizeBytes, 0))}) for ${candidate.modelId}`);
+        diagnostics.push(`Hugging Face vision evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum2, entry) => sum2 + entry.sizeBytes, 0))}) for ${candidate.modelId}`);
       }
     }
   } catch (err) {
@@ -14546,12 +14546,12 @@ var init_file_edit = __esm({
             const snippet = findClosestSnippet(content, oldString, 5);
             let errorMsg = `old_string not found in ${filePath}.`;
             if (snippet) {
-              const pct = Math.round(snippet.similarity * 100);
+              const pct2 = Math.round(snippet.similarity * 100);
               errorMsg += `
 
 Attempted old_string spans ${attemptedOldStringLines} line(s), ${attemptedOldStringChars} chars. The diagnostic below is the closest anchor-line match, not proof that the whole old_string exists.
 
-Current file content (closest anchor-line match, ${pct}% line similarity, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
+Current file content (closest anchor-line match, ${pct2}% line similarity, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
 ${snippet.content}
 
 Use the EXACT current content above to construct a working old_string. If the intended change is a contiguous line range, use file_patch with start_line/end_line from a fresh file_read. Do not retry with a different guess — the file on disk has changed since you last read it.`;
@@ -20043,9 +20043,9 @@ function selectInnerGraphCandidates(graph, candidates, options2 = {}) {
     const sourceEpisodeIds = [...new Set(allEdges.map((edge) => edge.sourceEpisodeId).filter((id2) => Boolean(id2)))];
     const selectedEpisodeIds = [...entry.candidateEpisodeIds];
     const sourceStrength = sourceEpisodeIds.length;
-    const candidateStrength = selectedEpisodeIds.reduce((sum, id2) => sum + (candidateScore.get(id2) ?? 0), 0);
-    const recency = selectedEpisodeIds.reduce((sum, id2) => sum + recencyScore(candidateTimestamp.get(id2), now2), 0);
-    const confidence2 = allEdges.reduce((sum, edge) => sum + (Number.isFinite(edge.confidence) ? edge.confidence : 0), 0) / Math.max(1, allEdges.length);
+    const candidateStrength = selectedEpisodeIds.reduce((sum2, id2) => sum2 + (candidateScore.get(id2) ?? 0), 0);
+    const recency = selectedEpisodeIds.reduce((sum2, id2) => sum2 + recencyScore(candidateTimestamp.get(id2), now2), 0);
+    const confidence2 = allEdges.reduce((sum2, edge) => sum2 + (Number.isFinite(edge.confidence) ? edge.confidence : 0), 0) / Math.max(1, allEdges.length);
     const score = degree * 1.5 + relationDiversity * 1.2 + sourceStrength * 1.4 + selectedEpisodeIds.length * 1.6 + candidateStrength + recency + confidence2 + Math.log1p(entry.node.mentionCount);
     results.push({
       node: entry.node,
@@ -20674,19 +20674,19 @@ function invertSPD(A, n2) {
   const L = new Float64Array(n2 * n2);
   for (let i2 = 0; i2 < n2; i2++) {
     for (let j = 0; j <= i2; j++) {
-      let sum = A[i2 * n2 + j];
+      let sum2 = A[i2 * n2 + j];
       for (let k = 0; k < j; k++)
-        sum -= L[i2 * n2 + k] * L[j * n2 + k];
+        sum2 -= L[i2 * n2 + k] * L[j * n2 + k];
       if (i2 === j) {
-        if (sum <= 0) {
+        if (sum2 <= 0) {
           const Areg = new Float64Array(A);
           for (let ii = 0; ii < n2; ii++)
             Areg[ii * n2 + ii] += 1e-6;
           return invertSPD(Areg, n2);
         }
-        L[i2 * n2 + j] = Math.sqrt(sum);
+        L[i2 * n2 + j] = Math.sqrt(sum2);
       } else {
-        L[i2 * n2 + j] = sum / L[j * n2 + j];
+        L[i2 * n2 + j] = sum2 / L[j * n2 + j];
       }
     }
   }
@@ -20695,16 +20695,16 @@ function invertSPD(A, n2) {
   for (let c9 = 0; c9 < n2; c9++) {
     col.fill(0);
     for (let i2 = 0; i2 < n2; i2++) {
-      let sum = i2 === c9 ? 1 : 0;
+      let sum2 = i2 === c9 ? 1 : 0;
       for (let k = 0; k < i2; k++)
-        sum -= L[i2 * n2 + k] * col[k];
-      col[i2] = sum / L[i2 * n2 + i2];
+        sum2 -= L[i2 * n2 + k] * col[k];
+      col[i2] = sum2 / L[i2 * n2 + i2];
     }
     for (let i2 = n2 - 1; i2 >= 0; i2--) {
-      let sum = col[i2];
+      let sum2 = col[i2];
       for (let k = i2 + 1; k < n2; k++)
-        sum -= L[k * n2 + i2] * col[k];
-      col[i2] = sum / L[i2 * n2 + i2];
+        sum2 -= L[k * n2 + i2] * col[k];
+      col[i2] = sum2 / L[i2 * n2 + i2];
     }
     for (let i2 = 0; i2 < n2; i2++)
       Ainv[i2 * n2 + c9] = col[i2];
@@ -25591,7 +25591,7 @@ function hashEmbedding(text2, dimensions = 256) {
     const sign2 = (h & 2147483648) === 0 ? 1 : -1;
     vector[idx] += sign2;
   }
-  const norm = Math.sqrt(vector.reduce((sum, value2) => sum + value2 * value2, 0));
+  const norm = Math.sqrt(vector.reduce((sum2, value2) => sum2 + value2 * value2, 0));
   return norm ? vector.map((value2) => value2 / norm) : vector;
 }
 function fnv1a(value2) {
@@ -25853,7 +25853,7 @@ function entityOverlap(a2, b) {
 function groupUtility(items, now2) {
   if (items.length === 0)
     return 0;
-  const raw = items.reduce((sum, item) => sum + itemUtility(item, now2), 0) / items.length;
+  const raw = items.reduce((sum2, item) => sum2 + itemUtility(item, now2), 0) / items.length;
   const evidenceBoost = Math.min(0.2, Math.log1p(items.length) / 15);
   return clamp019(raw + evidenceBoost);
 }
@@ -26152,7 +26152,7 @@ var init_semanticContext = __esm({
         return groups.map((g) => this.buildChunk(g.label, g.items, g.entities, now2, maxSummaryChars)).sort((a2, b) => b.utilityScore - a2.utilityScore || a2.label.localeCompare(b.label));
       }
       buildChunk(label, items, entities, now2, maxSummaryChars) {
-        const rawTokenEstimate = items.reduce((sum, item) => sum + tokenCount(item), 0);
+        const rawTokenEstimate = items.reduce((sum2, item) => sum2 + tokenCount(item), 0);
         const summary = summarize(items, maxSummaryChars);
         const tokenEstimate = Math.max(1, estimateTokens(summary));
         const utilityScore = groupUtility(items, now2);
@@ -26215,6 +26215,184 @@ var init_attention_select = __esm({
   }
 });
 
+// packages/memory/dist/context-folding.js
+function sum(ns) {
+  let t2 = 0;
+  for (const n2 of ns)
+    t2 += n2;
+  return t2;
+}
+var DEFAULT_SUMMARY_TOKENS, ContextFolder;
+var init_context_folding = __esm({
+  "packages/memory/dist/context-folding.js"() {
+    "use strict";
+    DEFAULT_SUMMARY_TOKENS = 40;
+    ContextFolder = class {
+      open = /* @__PURE__ */ new Map();
+      folded = [];
+      counter = 0;
+      /** Begin a subtask sub-trajectory; returns its segment id. */
+      openSegment(subtask, openedAtTurn) {
+        const id2 = `fold_${++this.counter}`;
+        this.open.set(id2, { id: id2, subtask, openedAtTurn });
+        return id2;
+      }
+      isOpen(id2) {
+        return this.open.has(id2);
+      }
+      /** Fold a completed subtask into a one-line outcome. */
+      closeSegment(id2, input) {
+        const seg = this.open.get(id2);
+        if (!seg)
+          throw new Error(`closeSegment: unknown segment ${id2}`);
+        this.open.delete(id2);
+        const folded = {
+          id: id2,
+          subtask: seg.subtask,
+          openedAtTurn: seg.openedAtTurn,
+          closedAtTurn: input.closedAtTurn,
+          outcome: input.outcome,
+          artifacts: input.artifacts ?? [],
+          verifierPassed: input.verifierPassed ?? false,
+          foldedTurns: [],
+          summaryTokens: Math.max(1, input.summaryTokens ?? DEFAULT_SUMMARY_TOKENS)
+        };
+        this.folded.push(folded);
+        return folded;
+      }
+      /** One-line summaries of every folded segment (for the active frame). */
+      summaries() {
+        return this.folded.map((f2) => `[folded ${f2.subtask}] ${f2.outcome}` + (f2.verifierPassed ? " (verified)" : "") + (f2.artifacts.length ? ` — ${f2.artifacts.join(", ")}` : ""));
+      }
+      /** Folded segments (persist these to disk for audit / re-expansion). */
+      foldedSegments() {
+        return [...this.folded];
+      }
+      /**
+       * Rewrite the active window: drop entries whose turn falls inside a folded
+       * segment's [openedAtTurn, closedAtTurn] range and replace each folded
+       * segment with a single summary entry. Entries outside any folded range
+       * (including the currently-open subtask's turns) stay in the active window.
+       */
+      fold(entries) {
+        const originalTokens = sum(entries.map((e2) => e2.tokens));
+        const active = [];
+        for (const entry of entries) {
+          const owning = this.folded.find((f2) => entry.turn >= f2.openedAtTurn && entry.turn <= f2.closedAtTurn);
+          if (owning) {
+            if (!owning.foldedTurns.includes(entry.turn)) {
+              owning.foldedTurns.push(entry.turn);
+            }
+            continue;
+          }
+          active.push(entry);
+        }
+        for (const f2 of this.folded) {
+          if (f2.foldedTurns.length > 0) {
+            active.push({ turn: f2.closedAtTurn, tokens: f2.summaryTokens, role: "folded" });
+          }
+        }
+        const activeTokens = sum(active.map((e2) => e2.tokens));
+        return {
+          activeEntries: active.sort((a2, b) => a2.turn - b.turn),
+          activeTokens,
+          originalTokens,
+          reductionFactor: activeTokens > 0 ? originalTokens / activeTokens : Infinity,
+          foldedSegments: this.foldedSegments()
+        };
+      }
+    };
+  }
+});
+
+// packages/memory/dist/compaction-policy.js
+function decideCompaction(input) {
+  const fireAt = input.fireAtPressure ?? 0.85;
+  const ceiling = Math.max(fireAt, input.hardCeiling ?? 0.95);
+  if (input.pressureRatio >= ceiling) {
+    return {
+      compact: true,
+      reason: `pressure ${pct(input.pressureRatio)} >= hard ceiling ${pct(ceiling)} — compact to avoid overflow`
+    };
+  }
+  if (input.pressureRatio < fireAt) {
+    return {
+      compact: false,
+      reason: `pressure ${pct(input.pressureRatio)} < ${pct(fireAt)} — below threshold, hold`
+    };
+  }
+  if (input.midDerivation) {
+    return {
+      compact: false,
+      reason: "mid-derivation: hold compaction until the current chain resolves"
+    };
+  }
+  if (input.convergenceStalled) {
+    return {
+      compact: false,
+      reason: "convergence stalled: hold the failure evidence for the breaker to act on"
+    };
+  }
+  return {
+    compact: true,
+    reason: input.lastSubtaskResolved ? "subtask resolved and over threshold — good moment to compact" : "over threshold and trajectory not mid-derivation/stuck — compact"
+  };
+}
+function validateCompaction(compactedText, pinned) {
+  const text2 = compactedText ?? "";
+  const dropped = [];
+  for (const s2 of pinned.symbols ?? [])
+    if (!text2.includes(s2))
+      dropped.push(`symbol:${s2}`);
+  for (const b of pinned.openBugs ?? [])
+    if (!text2.includes(b))
+      dropped.push(`bug:${b}`);
+  if (pinned.nextAction && !text2.includes(pinned.nextAction)) {
+    dropped.push(`nextAction:${pinned.nextAction}`);
+  }
+  const valid = dropped.length === 0;
+  return {
+    valid,
+    dropped,
+    reason: valid ? "compaction preserved all pinned invariants" : `compaction dropped ${dropped.length} pinned invariant(s): ${dropped.join(", ")} — roll back`
+  };
+}
+function computeSignalToNoise(frameText, noiseMarkers = DEFAULT_NOISE_MARKERS) {
+  let signalChars = 0;
+  let noiseChars = 0;
+  for (const line of (frameText ?? "").split(/\r?\n/)) {
+    const isNoise = noiseMarkers.some((m2) => line.includes(m2));
+    if (isNoise)
+      noiseChars += line.length;
+    else
+      signalChars += line.length;
+  }
+  return {
+    signalChars,
+    noiseChars,
+    ratio: signalChars / Math.max(1, noiseChars)
+  };
+}
+function pct(n2) {
+  return `${Math.round(n2 * 100)}%`;
+}
+var DEFAULT_NOISE_MARKERS;
+var init_compaction_policy = __esm({
+  "packages/memory/dist/compaction-policy.js"() {
+    "use strict";
+    DEFAULT_NOISE_MARKERS = [
+      "deduped",
+      "duplicate shell",
+      "duplicate tool",
+      "Do not retry ide",
+      "[FAILED] Took",
+      "[TOOL ACTION REASON CONTRACT]",
+      "RUNTIME TOOL ARGUMENT REPAIR",
+      "trust_tier:tool_output_untrusted"
+    ];
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -26230,6 +26408,7 @@ __export(dist_exports, {
   CRL_SYMBOLS: () => CRL_SYMBOLS,
   CodebaseMap: () => CodebaseMap,
   ConfidenceTracker: () => ConfidenceTracker,
+  ContextFolder: () => ContextFolder,
   ContextWindow: () => ContextWindow,
   DECAY_TAU: () => DECAY_TAU,
   DEFAULT_CRL_CONFIG: () => DEFAULT_CRL_CONFIG,
@@ -26288,6 +26467,7 @@ __export(dist_exports, {
   closeDb: () => closeDb,
   compressAndStore: () => compressAndStore,
   compressToGist: () => compressToGist,
+  computeSignalToNoise: () => computeSignalToNoise,
   conformityBias: () => conformityBias,
   congruenceMultiplier: () => congruenceMultiplier,
   contextItemsFromMessages: () => contextItemsFromMessages,
@@ -26296,6 +26476,7 @@ __export(dist_exports, {
   createCRLMemoryStore: () => createCRLMemoryStore,
   createHomeostaticState: () => createHomeostaticState,
   crystallize: () => crystallize,
+  decideCompaction: () => decideCompaction,
   decodeMemoryVector: () => decodeMemoryVector,
   detectStage: () => detectStage,
   developmentalReport: () => report,
@@ -26370,6 +26551,7 @@ __export(dist_exports, {
   suggestRegulationActions: () => suggestRegulationActions,
   thresholdsForStage: () => thresholdsForStage,
   tokenSimilarity: () => tokenSimilarity,
+  validateCompaction: () => validateCompaction,
   walkGraphFromSeed: () => walkGraphFromSeed,
   wasHesitant: () => wasHesitant
 });
@@ -26425,6 +26607,8 @@ var init_dist = __esm({
     init_maintenance();
     init_semanticContext();
     init_attention_select();
+    init_context_folding();
+    init_compaction_policy();
   }
 });
 
@@ -28840,9 +29024,9 @@ var init_batch_edit = __esm({
                 }
                 const snippet = findClosestSnippet(content, edit.old_string, 5);
                 if (snippet) {
-                  const pct = Math.round(snippet.similarity * 100);
+                  const pct2 = Math.round(snippet.similarity * 100);
                   results.push(`SKIP: old_string not found in ${edit.relPath}.
-  Closest match in current file (${pct}% similar, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
+  Closest match in current file (${pct2}% similar, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
 ${snippet.content}
   Use this exact content for old_string in your next attempt.`);
                 } else {
@@ -28922,7 +29106,7 @@ ${s2.content}`;
         ].join("\n") : dryRun ? [
           `BATCH_VALIDATED_ONLY: ${appliedCount} edit(s) validated, 0 failed across ${byFile.size} file(s).`,
           `NO FILES WERE MODIFIED. Call again with dry_run=false to apply this atomic batch.`
-        ].join("\n") : pendingWrites.length === 0 && alreadyAppliedCount > 0 ? `BATCH_NOOP_ALREADY_APPLIED: ${alreadyAppliedCount} edit(s) already satisfied, 0 failed across ${byFile.size} file(s).` : `BATCH_COMMITTED: ${appliedCount} edit(s) satisfied (${pendingWrites.reduce((sum, write2) => sum + write2.editCount, 0)} applied, ${alreadyAppliedCount} already applied), 0 failed across ${byFile.size} file(s).`;
+        ].join("\n") : pendingWrites.length === 0 && alreadyAppliedCount > 0 ? `BATCH_NOOP_ALREADY_APPLIED: ${alreadyAppliedCount} edit(s) already satisfied, 0 failed across ${byFile.size} file(s).` : `BATCH_COMMITTED: ${appliedCount} edit(s) satisfied (${pendingWrites.reduce((sum2, write2) => sum2 + write2.editCount, 0)} applied, ${alreadyAppliedCount} already applied), 0 failed across ${byFile.size} file(s).`;
         const detailOutput = failCount === 0 ? dryRun ? results.join("\n") : results.map((line) => line.replace(/^VALIDATED_ONLY:/, "APPLIED:").replace(/ pending atomic commit/g, "")).join("\n") : results.join("\n");
         return {
           success: failCount === 0,
@@ -44161,7 +44345,7 @@ var init_structured_file = __esm({
                 parts.push(jsonToMarkdownTable(data));
               }
               content = parts.join("\n");
-              byteInfo = sheets ? `${sheets.length} sections, ${sheets.reduce((s2, sh) => s2 + sh.data.length, 0)} total rows` : `${data.length} rows`;
+              byteInfo = sheets ? `${sheets.length} sections, ${sheets.reduce((s2, sh2) => s2 + sh2.data.length, 0)} total rows` : `${data.length} rows`;
               break;
             }
             default:
@@ -50462,13 +50646,13 @@ function kdfInputToBytes(data, errorTitle = "") {
   return abytes(data, void 0, errorTitle);
 }
 function concatBytes(...arrays) {
-  let sum = 0;
+  let sum2 = 0;
   for (let i2 = 0; i2 < arrays.length; i2++) {
     const a2 = arrays[i2];
     abytes(a2);
-    sum += a2.length;
+    sum2 += a2.length;
   }
-  const res = new Uint8Array(sum);
+  const res = new Uint8Array(sum2);
   for (let i2 = 0, pad = 0; i2 < arrays.length; i2++) {
     const a2 = arrays[i2];
     res.set(a2, pad);
@@ -124725,7 +124909,7 @@ var require_jsbn = __commonJS({
       }
       this.t = 0;
       this.s = 0;
-      var i2 = s2.length, mi = false, sh = 0;
+      var i2 = s2.length, mi = false, sh2 = 0;
       while (--i2 >= 0) {
         var x = k == 8 ? s2[i2] & 255 : intAt(s2, i2);
         if (x < 0) {
@@ -124733,19 +124917,19 @@ var require_jsbn = __commonJS({
           continue;
         }
         mi = false;
-        if (sh == 0)
+        if (sh2 == 0)
           this.data[this.t++] = x;
-        else if (sh + k > this.DB) {
-          this.data[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;
-          this.data[this.t++] = x >> this.DB - sh;
+        else if (sh2 + k > this.DB) {
+          this.data[this.t - 1] |= (x & (1 << this.DB - sh2) - 1) << sh2;
+          this.data[this.t++] = x >> this.DB - sh2;
         } else
-          this.data[this.t - 1] |= x << sh;
-        sh += k;
-        if (sh >= this.DB) sh -= this.DB;
+          this.data[this.t - 1] |= x << sh2;
+        sh2 += k;
+        if (sh2 >= this.DB) sh2 -= this.DB;
       }
       if (k == 8 && (s2[0] & 128) != 0) {
         this.s = -1;
-        if (sh > 0) this.data[this.t - 1] |= (1 << this.DB - sh) - 1 << sh;
+        if (sh2 > 0) this.data[this.t - 1] |= (1 << this.DB - sh2) - 1 << sh2;
       }
       this.clamp();
       if (mi) BigInteger.ZERO.subTo(this, this);
@@ -264287,14 +264471,14 @@ var init_src100 = __esm({
         if (this.isDirectory()) {
           return 0n;
         }
-        let sum = 0n;
+        let sum2 = 0n;
         this.blockSizes.forEach((size) => {
-          sum += size;
+          sum2 += size;
         });
         if (this.data != null) {
-          sum += BigInt(this.data.length);
+          sum2 += BigInt(this.data.length);
         }
-        return sum;
+        return sum2;
       }
       /**
        * encode to protobuf Uint8Array
@@ -279788,7 +279972,7 @@ ${errText.slice(0, 1200)}`,
           if (space.evicted.length > 0) {
             this.emitProgress({
               stage: "download",
-              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum, e2) => sum + e2.sizeBytes, 0))}) to make room for ${args.model}`
+              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum2, e2) => sum2 + e2.sizeBytes, 0))}) to make room for ${args.model}`
             });
           }
         } catch (err) {
@@ -280018,7 +280202,7 @@ ${errText.slice(0, 800)}`,
           if (space.evicted.length > 0) {
             this.emitProgress({
               stage: "download",
-              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum, e2) => sum + e2.sizeBytes, 0))}) to make room for ${args.model}`
+              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum2, e2) => sum2 + e2.sizeBytes, 0))}) to make room for ${args.model}`
             });
           }
         } catch (err) {
@@ -282073,7 +282257,7 @@ if __name__ == "__main__":
           if (space.evicted.length > 0) {
             this.emitProgress({
               stage: "download",
-              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum, e2) => sum + e2.sizeBytes, 0))}) to make room for ${args.model}`
+              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum2, e2) => sum2 + e2.sizeBytes, 0))}) to make room for ${args.model}`
             });
           }
         } catch (err) {
@@ -282398,7 +282582,7 @@ if __name__ == "__main__":
           if (space.evicted.length > 0) {
             this.emitProgress({
               stage: "download",
-              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum, e2) => sum + e2.sizeBytes, 0))}) to make room for ${args.model}`
+              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum2, e2) => sum2 + e2.sizeBytes, 0))}) to make room for ${args.model}`
             });
           }
         } catch (err) {
@@ -282562,7 +282746,7 @@ function discoverLegacyMediaRepos(roots, opts = {}) {
     out.push({
       repoRoot,
       legacyDirs,
-      approxBytes: measure ? legacyDirs.reduce((sum, d2) => sum + approxDirBytes(d2), 0) : 0
+      approxBytes: measure ? legacyDirs.reduce((sum2, d2) => sum2 + approxDirBytes(d2), 0) : 0
     });
   }
   out.sort((a2, b) => b.approxBytes - a2.approxBytes);
@@ -283768,8 +283952,8 @@ function normalizedEntropy(scores) {
   const positive2 = scores.filter((s2) => s2 > 0);
   if (positive2.length <= 1)
     return 0;
-  const sum = positive2.reduce((a2, b) => a2 + b, 0) || 1;
-  const probs = positive2.map((s2) => s2 / sum);
+  const sum2 = positive2.reduce((a2, b) => a2 + b, 0) || 1;
+  const probs = positive2.map((s2) => s2 / sum2);
   const h = -probs.reduce((a2, p2) => a2 + (p2 > 0 ? p2 * Math.log2(p2) : 0), 0);
   return h / Math.log2(positive2.length);
 }
@@ -286857,7 +287041,7 @@ ${llmAnnotation}` : result.llmContent;
           if (space.evicted.length > 0) {
             this.emitProgress({
               stage: "download",
-              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum, e2) => sum + e2.sizeBytes, 0))}) to make room for ${args.candidate.model}`
+              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum2, e2) => sum2 + e2.sizeBytes, 0))}) to make room for ${args.candidate.model}`
             });
           }
         } catch (err) {
@@ -287022,7 +287206,7 @@ ${llmAnnotation}` : result.llmContent;
           if (space.evicted.length > 0) {
             this.emitProgress({
               stage: "download",
-              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum, e2) => sum + e2.sizeBytes, 0))}) to make room for ${args.model}`
+              message: `Evicted ${space.evicted.length} cached model(s) (${formatBytes(space.evicted.reduce((sum2, e2) => sum2 + e2.sizeBytes, 0))}) to make room for ${args.model}`
             });
           }
         } catch (err) {
@@ -372879,7 +373063,7 @@ ${lanes.join("\n")}
             if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) {
               return namedUnions[0];
             }
-            const namedTypesCount = reduceLeft(namedUnions, (sum, union) => sum + union.types.length, 0);
+            const namedTypesCount = reduceLeft(namedUnions, (sum2, union) => sum2 + union.types.length, 0);
             if (namedTypesCount + reducedTypes.length === typeSet.length) {
               for (const t2 of namedUnions) {
                 insertType(reducedTypes, t2);
@@ -449374,7 +449558,7 @@ ${lanes.join("\n")}
               reportCountStatistic("Lines of " + key, value2);
             }
           } else {
-            reportCountStatistic("Lines", reduceLeftIterator(lineCounts.values(), (sum, count) => sum + count, 0));
+            reportCountStatistic("Lines", reduceLeftIterator(lineCounts.values(), (sum2, count) => sum2 + count, 0));
           }
           reportCountStatistic("Identifiers", program.getIdentifierCount());
           reportCountStatistic("Symbols", program.getSymbolCount());
@@ -466566,7 +466750,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             }
           }
           return result;
-          function escapeRegExp2(str) {
+          function escapeRegExp3(str) {
             return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
           }
           function getTodoCommentsRegExp() {
@@ -466574,7 +466758,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             const multiLineCommentStart = /(?:\/\*+\s*)/.source;
             const anyNumberOfSpacesAndAsterisksAtStartOfLine = /(?:^(?:\s|\*)*)/.source;
             const preamble = "(" + anyNumberOfSpacesAndAsterisksAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")";
-            const literals = "(?:" + map2(descriptors, (d2) => "(" + escapeRegExp2(d2.text) + ")").join("|") + ")";
+            const literals = "(?:" + map2(descriptors, (d2) => "(" + escapeRegExp3(d2.text) + ")").join("|") + ")";
             const endOfLineOrEndOfComment = /(?:$|\*\/)/.source;
             const messageRemainder = /(?:.*?)/.source;
             const messagePortion = "(" + literals + messageRemainder + ")";
@@ -549124,7 +549308,7 @@ Context saved to: ${contextFile}`,
             }
           }
           profile.silenceSegments = silences;
-          const silenceTotal = silences.reduce((sum, item) => sum + item.durationSec, 0);
+          const silenceTotal = silences.reduce((sum2, item) => sum2 + item.durationSec, 0);
           if (durationSec > 0) {
             profile.silencePercentage = Math.max(0, Math.min(100, silenceTotal / durationSec * 100));
             profile.activeSegments = this.complementSegments(silences, durationSec);
@@ -558719,12 +558903,349 @@ var init_validationPipeline = __esm({
   }
 });
 
+// packages/execution/dist/adaptive-edit-strategy.js
+function classifyEditFailure(error) {
+  const e2 = (error ?? "").toLowerCase();
+  if (!e2)
+    return "other";
+  if (e2.includes("hash") && (e2.includes("mismatch") || e2.includes("expected")))
+    return "hash_mismatch";
+  if (e2.includes("not found") || e2.includes("no such file"))
+    return "not_found";
+  if (e2.includes("must be unique") || e2.includes("ambiguous") || e2.includes("multiple matches") || e2.includes("appears"))
+    return "ambiguous_match";
+  if (e2.includes("old_string") && (e2.includes("not present") || e2.includes("no match") || e2.includes("could not find") || e2.includes("does not match")))
+    return "no_match";
+  return "other";
+}
+var DEFAULT_SWITCH_THRESHOLD, AdaptiveEditStrategy;
+var init_adaptive_edit_strategy = __esm({
+  "packages/execution/dist/adaptive-edit-strategy.js"() {
+    "use strict";
+    DEFAULT_SWITCH_THRESHOLD = 2;
+    AdaptiveEditStrategy = class {
+      switchThreshold;
+      files = /* @__PURE__ */ new Map();
+      constructor(options2 = {}) {
+        this.switchThreshold = Math.max(1, options2.switchThreshold ?? DEFAULT_SWITCH_THRESHOLD);
+      }
+      /** Record an edit outcome and return the recommendation for that file. */
+      record(outcome) {
+        const state = this.files.get(outcome.path) ?? {
+          consecutiveFailures: 0,
+          recommendedRewrite: false
+        };
+        if (outcome.mutated) {
+          this.files.set(outcome.path, {
+            consecutiveFailures: 0,
+            recommendedRewrite: false
+          });
+          return { path: outcome.path, mode: "edit", consecutiveFailures: 0 };
+        }
+        state.consecutiveFailures += 1;
+        state.lastFailureClass = classifyEditFailure(outcome.error);
+        if (state.consecutiveFailures >= this.switchThreshold) {
+          state.recommendedRewrite = true;
+        }
+        this.files.set(outcome.path, state);
+        return this.recommendation(outcome.path, state);
+      }
+      /** Current recommendation for a file without recording a new outcome. */
+      peek(path12) {
+        const state = this.files.get(path12);
+        if (!state)
+          return { path: path12, mode: "edit", consecutiveFailures: 0 };
+        return this.recommendation(path12, state);
+      }
+      /** Explicitly clear a file (e.g. after a successful full-file rewrite). */
+      reset(path12) {
+        this.files.delete(path12);
+      }
+      recommendation(path12, state) {
+        if (state.recommendedRewrite) {
+          return {
+            path: path12,
+            mode: "rewrite",
+            consecutiveFailures: state.consecutiveFailures,
+            lastFailureClass: state.lastFailureClass,
+            guidance: `file_edit failed ${state.consecutiveFailures}× on ${path12} (${state.lastFailureClass}). Stop retrying the same edit. Read the current file, then replace it wholesale with file_write seeded from the current contents — do not re-issue file_edit on this file.`
+          };
+        }
+        return {
+          path: path12,
+          mode: "edit",
+          consecutiveFailures: state.consecutiveFailures,
+          lastFailureClass: state.lastFailureClass
+        };
+      }
+    };
+  }
+});
+
+// packages/execution/dist/boundary-verifier.js
+function isStructuralBoundary(path12) {
+  if (HEADER_EXT.test(path12))
+    return true;
+  const base3 = path12.replace(/\\/g, "/");
+  return CONTRACT_HINT.test(base3);
+}
+function detectLanguage2(path12) {
+  const p2 = path12.toLowerCase();
+  if (/\.(c|cc|cpp|cxx|h|hh|hpp|hxx|ino)$/.test(p2))
+    return "cpp";
+  if (/\.(ts|tsx|mts|cts)$/.test(p2))
+    return "typescript";
+  if (/\.py$/.test(p2))
+    return "python";
+  if (/\.rs$/.test(p2))
+    return "rust";
+  if (/\.go$/.test(p2))
+    return "go";
+  return "unknown";
+}
+function parseCompilerDiagnostics(text2, language = "unknown") {
+  const out = [];
+  if (!text2)
+    return out;
+  for (const raw of text2.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || !/error/i.test(line))
+      continue;
+    const loc = line.match(/^(.+?):(\d+):(?:\d+:)?\s*(?:fatal\s+)?error:\s*(.*)$/i);
+    const file = loc?.[1];
+    const lineNo = loc ? Number(loc[2]) : void 0;
+    const msg = loc?.[3] ?? line;
+    let kind = "other";
+    let symbol3;
+    if (/no declaration matches/i.test(msg)) {
+      kind = "signature_mismatch";
+      symbol3 = firstQuoted(msg) ?? extractCppQualified(msg);
+    } else if (/conflicting declaration|redefinition of|redeclared/i.test(msg)) {
+      kind = "duplicate_definition";
+      symbol3 = firstQuoted(msg);
+    } else if (/has no member named/i.test(msg)) {
+      kind = "unknown_member";
+      symbol3 = msg.match(/has no member named\s+'([^']+)'/i)?.[1] ?? firstQuoted(msg);
+    } else if (/was not declared in this scope|has not been declared|undeclared/i.test(msg)) {
+      kind = "unknown_symbol";
+      symbol3 = firstQuoted(msg);
+    } else if (/no matching function for call to/i.test(msg)) {
+      kind = "signature_mismatch";
+      symbol3 = firstQuoted(msg);
+    } else if (/^ts\d+:/i.test(msg) || /property '.*' does not exist/i.test(msg)) {
+      kind = /does not exist/i.test(msg) ? "unknown_member" : "type_error";
+      symbol3 = firstQuoted(msg);
+    } else {
+      kind = "type_error";
+    }
+    out.push({ file, line: lineNo, symbol: symbol3, kind, message: msg });
+  }
+  return out;
+}
+function firstQuoted(s2) {
+  const m2 = s2.match(/'([^']+)'/);
+  return m2?.[1];
+}
+function extractCppQualified(s2) {
+  const m2 = s2.match(/([A-Za-z_]\w*::[A-Za-z_]\w*)/);
+  return m2?.[1];
+}
+function summarizeDiagnostics(diags) {
+  if (diags.length === 0)
+    return "boundary verified: no diagnostics";
+  const byKind = /* @__PURE__ */ new Map();
+  const symbols = /* @__PURE__ */ new Set();
+  for (const d2 of diags) {
+    byKind.set(d2.kind, (byKind.get(d2.kind) ?? 0) + 1);
+    if (d2.symbol)
+      symbols.add(d2.symbol);
+  }
+  const kinds = [...byKind.entries()].map(([k, n2]) => `${k}×${n2}`).join(", ");
+  const syms = [...symbols].slice(0, 6).join(", ");
+  return `boundary FAILED: ${diags.length} diagnostic(s) [${kinds}]${syms ? ` — symbols: ${syms}` : ""}. Fix the contract before editing unrelated files.`;
+}
+async function verifyBoundary(input) {
+  const language = input.language ?? detectLanguage2(input.path);
+  if (!input.force && !isStructuralBoundary(input.path)) {
+    return {
+      ok: true,
+      tool: "none",
+      scope: input.path,
+      skipped: true,
+      diagnostics: [],
+      summary: "not a structural boundary — verification skipped"
+    };
+  }
+  const result = await input.runner({
+    projectRoot: input.projectRoot,
+    scope: input.path
+  });
+  if (result.skipped) {
+    return {
+      ok: true,
+      tool: result.tool,
+      scope: input.path,
+      skipped: true,
+      diagnostics: [],
+      summary: `no verifier configured for ${input.path} — skipped`
+    };
+  }
+  const diagnostics = parseCompilerDiagnostics(`${result.stdout}
+${result.stderr}`, language);
+  const ok3 = result.success && diagnostics.length === 0;
+  return {
+    ok: ok3,
+    tool: result.tool,
+    scope: input.path,
+    skipped: false,
+    diagnostics,
+    summary: ok3 ? "boundary verified: no diagnostics" : summarizeDiagnostics(diagnostics)
+  };
+}
+var HEADER_EXT, CONTRACT_HINT;
+var init_boundary_verifier = __esm({
+  "packages/execution/dist/boundary-verifier.js"() {
+    "use strict";
+    HEADER_EXT = /\.(h|hh|hpp|hxx|d\.ts)$/i;
+    CONTRACT_HINT = /(^|\/)(types|interfaces?|contract|schema|protocol|api|pal)\b/i;
+  }
+});
+
+// packages/execution/dist/harness-plan.js
+function pathEscapesRoot(p2) {
+  if (!p2)
+    return true;
+  if (p2.startsWith("/") || p2.startsWith("~"))
+    return true;
+  const parts = [];
+  for (const seg of p2.split("/")) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..") {
+      if (parts.length === 0)
+        return true;
+      parts.pop();
+      continue;
+    }
+    parts.push(seg);
+  }
+  return false;
+}
+function guardShell(command) {
+  for (const re of FORBIDDEN_SHELL) {
+    if (re.test(command))
+      return `forbidden shell pattern: ${re}`;
+  }
+  return null;
+}
+function sh(s2) {
+  return `'${s2.replace(/'/g, `'\\''`)}'`;
+}
+function planHarnessBatch(ops, opts) {
+  const accepted = [];
+  const rejected = [];
+  for (const op of ops) {
+    const reject = (reason) => rejected.push({ op, reason });
+    if (op.kind === "shell") {
+      if (!op.command) {
+        reject("shell op missing command");
+        continue;
+      }
+      const bad = guardShell(op.command);
+      if (bad) {
+        reject(bad);
+        continue;
+      }
+      accepted.push(op);
+      continue;
+    }
+    if (op.kind === "remove" && !opts.allowRemove) {
+      reject("remove not permitted (set allowRemove to enable)");
+      continue;
+    }
+    const targets = [op.path, op.to].filter((p2) => Boolean(p2));
+    if (targets.length === 0) {
+      reject(`${op.kind} op missing path`);
+      continue;
+    }
+    const escaping = targets.find((t2) => pathEscapesRoot(t2));
+    if (escaping) {
+      reject(`path escapes project root: ${escaping}`);
+      continue;
+    }
+    if (op.kind === "write" && op.content === void 0) {
+      reject("write op missing content");
+      continue;
+    }
+    accepted.push(op);
+  }
+  const script = accepted.length ? buildScript(accepted, opts) : "";
+  const ok3 = rejected.length === 0 && accepted.length === ops.length;
+  return {
+    ok: ok3,
+    script,
+    accepted,
+    rejected,
+    summary: ok3 ? `harness cell: ${accepted.length} op(s), all validated` : `harness plan: ${accepted.length} accepted, ${rejected.length} rejected — ${rejected.map((r2) => r2.reason).join("; ")}`
+  };
+}
+function buildScript(ops, opts) {
+  const lines = [
+    "set -euo pipefail",
+    `cd ${sh(opts.projectRoot)}`
+  ];
+  for (const op of ops) {
+    switch (op.kind) {
+      case "read":
+        lines.push(`cat ${sh(op.path)}`);
+        break;
+      case "mkdir":
+        lines.push(`mkdir -p ${sh(op.path)}`);
+        break;
+      case "move":
+        lines.push(`mkdir -p "$(dirname ${sh(op.to)})" && mv ${sh(op.path)} ${sh(op.to)}`);
+        break;
+      case "remove":
+        lines.push(`rm -f ${sh(op.path)}`);
+        break;
+      case "write": {
+        const b64 = Buffer.from(op.content ?? "", "utf8").toString("base64");
+        lines.push(`mkdir -p "$(dirname ${sh(op.path)})"`);
+        lines.push(`printf %s ${sh(b64)} | base64 -d > ${sh(op.path)}`);
+        break;
+      }
+      case "shell":
+        lines.push(op.command);
+        break;
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+var FORBIDDEN_SHELL;
+var init_harness_plan = __esm({
+  "packages/execution/dist/harness-plan.js"() {
+    "use strict";
+    FORBIDDEN_SHELL = [
+      /\bsudo\b/,
+      /\b(curl|wget|nc|ncat|telnet|ssh|scp|sftp|rsync)\b/,
+      /\b(ftp|git\s+push|git\s+clone|npm\s+publish|pip\s+install)\b/,
+      /rm\s+-rf\s+\/(?:\s|$)/,
+      /[:{]\s*\|\s*[:{]\s*&/,
+      // fork bomb-ish
+      />\s*\/dev\/(sd|nvme|mmcblk|disk)/,
+      /\bmkfs\b|\bdd\s+if=/,
+      /\bchmod\s+777\b/
+    ];
+  }
+});
+
 // packages/execution/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
   AUDIO_GENERATION_MODEL_PRESETS: () => AUDIO_GENERATION_MODEL_PRESETS,
   AVAdapterRegistry: () => AVAdapterRegistry,
   AVComprehendTool: () => AVComprehendTool,
+  AdaptiveEditStrategy: () => AdaptiveEditStrategy,
   AgendaTool: () => AgendaTool,
   AgentTool: () => AgentTool,
   AiwgHealthTool: () => AiwgHealthTool,
@@ -558925,6 +559446,7 @@ __export(dist_exports2, {
   canInvokeTool: () => canInvokeTool,
   checkConstraints: () => checkConstraints,
   checkDesktopDeps: () => checkDesktopDeps,
+  classifyEditFailure: () => classifyEditFailure,
   classifyTool: () => classifyTool,
   clearExploreNotes: () => clearExploreNotes,
   clearImportGraphCache: () => clearImportGraphCache,
@@ -558959,6 +559481,7 @@ __export(dist_exports2, {
   deleteTodos: () => deleteTodos,
   detectCudaDevices: () => detectCudaDevices,
   detectElevationMethod: () => detectElevationMethod,
+  detectLanguage: () => detectLanguage2,
   detectLegacyCaches: () => detectLegacyCaches,
   detectSceneCuts: () => detectSceneCuts,
   detectSearchProvider: () => detectSearchProvider,
@@ -559062,6 +559585,7 @@ __export(dist_exports2, {
   isMcpMarkdown: () => isMcpMarkdown,
   isProcessAlive: () => isProcessAlive,
   isProcessIdentityVerified: () => isProcessIdentityVerified,
+  isStructuralBoundary: () => isStructuralBoundary,
   isVideoPresetGated: () => isVideoPresetGated,
   killAllFullSubAgents: () => killAllFullSubAgents,
   killProcess: () => killProcess,
@@ -559112,11 +559636,13 @@ __export(dist_exports2, {
   normalizedEntropy: () => normalizedEntropy,
   omniusHomeDir: () => omniusHomeDir,
   packetPath: () => packetPath,
+  parseCompilerDiagnostics: () => parseCompilerDiagnostics,
   parseCudaComputeCapability: () => parseCudaComputeCapability,
   parseCudaDeviceInfo: () => parseCudaDeviceInfo,
   parseMcpMarkdown: () => parseMcpMarkdown,
   parseMcpToolName: () => parseMcpToolName,
   parseSponsorMediaCapability: () => parseSponsorMediaCapability,
+  planHarnessBatch: () => planHarnessBatch,
   planInspections: () => planInspections,
   playSoundFile: () => playSoundFile,
   predictNextBbox: () => predictNextBbox,
@@ -559202,6 +559728,7 @@ __export(dist_exports2, {
   startProcessLeaseSweeper: () => startProcessLeaseSweeper,
   stopFullSubAgent: () => stopFullSubAgent,
   stopProcessLease: () => stopProcessLease,
+  summarizeDiagnostics: () => summarizeDiagnostics,
   summarizeLog: () => summarizeLog,
   summarizeProvenance: () => summarizeProvenance,
   sweepProcessLeases: () => sweepProcessLeases,
@@ -559221,6 +559748,7 @@ __export(dist_exports2, {
   venvExe: () => venvExe,
   venvPip: () => venvPip,
   venvPython: () => venvPython,
+  verifyBoundary: () => verifyBoundary,
   verifyStorePermissions: () => verifyStorePermissions,
   videoDiffusersVenvDir: () => videoDiffusersVenvDir,
   videoGenerationDir: () => videoGenerationDir,
@@ -559399,6 +559927,9 @@ var init_dist5 = __esm({
     init_process_kill();
     init_constraints();
     init_validationPipeline();
+    init_adaptive_edit_strategy();
+    init_boundary_verifier();
+    init_harness_plan();
   }
 });
 
@@ -567962,7 +568493,7 @@ function regenerate(opts) {
   } else if (files.length === 0) {
     lines.push(`  No files found in workspace (excluding ignored paths).`);
   } else {
-    const totalBytes = files.reduce((sum, f2) => sum + f2.bytes, 0);
+    const totalBytes = files.reduce((sum2, f2) => sum2 + f2.bytes, 0);
     lines.push(`  ${files.length} file(s)${truncated ? " (truncated — more exist)" : ""}, total ${humanBytes2(totalBytes)}.`);
     if (lastWriteFile) {
       lines.push(`  Most recently modified: ${lastWriteFile.rel} (${humanBytes2(lastWriteFile.bytes)}, ${ago(nowMs - lastWriteFile.mtimeMs)}).`);
@@ -571616,7 +572147,7 @@ function textToHashEmbedding(text2, dimensions = DEFAULT_HASH_DIMS) {
     const sign2 = (h & 2147483648) === 0 ? 1 : -1;
     vec[idx] += sign2;
   }
-  const norm = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0));
+  const norm = Math.sqrt(vec.reduce((sum2, v) => sum2 + v * v, 0));
   if (!norm)
     return vec;
   return vec.map((v) => Math.round(v / norm * 1e6) / 1e6);
@@ -574107,7 +574638,7 @@ function analyzeContextWindowDumpRequest(request) {
       compactedDiscoveryChars += chars;
     }
   }
-  const toolSchemaChars = tools.reduce((sum, tool) => sum + JSON.stringify(tool).length, 0);
+  const toolSchemaChars = tools.reduce((sum2, tool) => sum2 + JSON.stringify(tool).length, 0);
   const structuralSignalChars = userChars + activeEvidenceChars + activeContextFrameChars + compactedDiscoveryChars + assistantChars;
   const structuralNoiseCandidateChars = rawDiscoveryToolChars;
   const ratio = structuralNoiseCandidateChars > 0 ? Number((structuralSignalChars / structuralNoiseCandidateChars).toFixed(3)) : null;
@@ -575711,6 +576242,9 @@ var init_focusSupervisor = __esm({
       lastReason = "";
       lastContext = null;
       failureFamilies = /* @__PURE__ */ new Map();
+      convergenceBreaker = null;
+      /** WO-3: set when a mutation lands, consumed by the next observed failure. */
+      sawMutationSinceFailure = false;
       ignoredDirectiveStreak = 0;
       lastIgnoredDirectiveTurn = null;
       availableTools = null;
@@ -575719,6 +576253,7 @@ var init_focusSupervisor = __esm({
         this.modelTier = options2.modelTier ?? "large";
         this.repeatGateMax = Math.max(0, Math.floor(options2.repeatGateMax ?? 3));
         this.availableTools = options2.availableTools ? new Set(Array.from(options2.availableTools)) : null;
+        this.convergenceBreaker = options2.convergenceBreaker ?? null;
       }
       get enabled() {
         return this.mode !== "off";
@@ -575907,6 +576442,7 @@ var init_focusSupervisor = __esm({
         if (!this.enabled)
           return;
         if (input.mutated) {
+          this.sawMutationSinceFailure = true;
           this.clearSatisfiedDirective("mutation landed", input.turn);
           return;
         }
@@ -575996,6 +576532,28 @@ var init_focusSupervisor = __esm({
             forbiddenActionFamilies: shellFailure ? [actionFamily(input.toolName, input.args)] : [actionFamily(input.toolName, input.args)]
           });
         }
+        if (this.convergenceBreaker) {
+          const verdict = this.convergenceBreaker.observe({
+            family,
+            sessionCount: next.count,
+            turn: input.turn,
+            sample: next.sample,
+            errorClass: next.errorClass,
+            mutatedSinceLast: this.sawMutationSinceFailure
+          });
+          this.sawMutationSinceFailure = false;
+          if (verdict.tier === "abandon") {
+            this.markTerminalIncomplete(verdict.reason, input.turn);
+          } else if (verdict.tier === "stalled") {
+            this.setDirective({
+              turn: input.turn,
+              state: "forced_replan",
+              reason: verdict.reason,
+              requiredNextAction: this.resolveRequiredNextAction("run_verification"),
+              forbiddenActionFamilies: [actionFamily(input.toolName, input.args)]
+            });
+          }
+        }
       }
       markCompletionBlocked(input) {
         if (!this.enabled)
@@ -576844,7 +577402,7 @@ var init_resolution_memory = __esm({
 
 // packages/orchestrator/dist/contextEngine.js
 function estimateTokens3(messages2) {
-  const chars = messages2.reduce((sum, message2) => sum + message2.content.length + message2.role.length + (message2.name?.length ?? 0), 0);
+  const chars = messages2.reduce((sum2, message2) => sum2 + message2.content.length + message2.role.length + (message2.name?.length ?? 0), 0);
   return Math.ceil(chars / 4);
 }
 function evidenceMessage(folded) {
@@ -578262,7 +578820,7 @@ function buildFallbackSemanticChunks(items, maxChunks = 7) {
     const bucketItems = normalized.filter((item) => bucket.kinds.includes(item.kind)).sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0));
     if (bucketItems.length === 0)
       continue;
-    const rawChars = bucketItems.reduce((sum, item) => sum + item.content.length, 0);
+    const rawChars = bucketItems.reduce((sum2, item) => sum2 + item.content.length, 0);
     const lines = bucketItems.slice(0, 5).map((item) => {
       const oneLine = item.content.replace(/\s+/g, " ").trim();
       return `- ${item.label}: ${oneLine.slice(0, 360)}`;
@@ -580881,7 +581439,7 @@ ${wbCtx}`,
         } catch {
         }
         const assembled = sections.map((s2) => s2.content).join("");
-        const totalTokenEstimate = sections.reduce((sum, s2) => sum + s2.tokenEstimate, 0);
+        const totalTokenEstimate = sections.reduce((sum2, s2) => sum2 + s2.tokenEstimate, 0);
         return {
           assembled,
           sections: sections.map((s2) => ({
@@ -580991,7 +581549,7 @@ Your hypotheses MUST address this specific error, not generic causes.
       gcSystemMessages(messages2) {
         const ctxTokens = this.options.contextWindowSize ?? 0;
         const systemMaxChars = ctxTokens > 0 ? Math.max(24e3, Math.floor(ctxTokens * 4 * 0.45)) : 0;
-        const beforeChars = messages2.reduce((sum, m2) => sum + (m2.role === "system" && typeof m2.content === "string" ? m2.content.length : 0), 0);
+        const beforeChars = messages2.reduce((sum2, m2) => sum2 + (m2.role === "system" && typeof m2.content === "string" ? m2.content.length : 0), 0);
         const result = this._signalExtractor.distillSystemMessages(messages2, {
           maxSystemChars: systemMaxChars || void 0,
           preserveFirstSystem: true,
@@ -581004,7 +581562,7 @@ Your hypotheses MUST address this specific error, not generic causes.
         messages2.push(...result.messages);
         const dropped = result.stats.droppedNoise + result.stats.droppedDuplicate + result.stats.droppedBudget;
         if (dropped > 0) {
-          const afterChars = messages2.reduce((sum, m2) => sum + (m2.role === "system" && typeof m2.content === "string" ? m2.content.length : 0), 0);
+          const afterChars = messages2.reduce((sum2, m2) => sum2 + (m2.role === "system" && typeof m2.content === "string" ? m2.content.length : 0), 0);
           this.emit({
             type: "status",
             content: `Signal distillation dropped ${dropped} system message(s) (noise=${result.stats.droppedNoise}, dup=${result.stats.droppedDuplicate}, budget=${result.stats.droppedBudget}; ${beforeChars} -> ${afterChars} chars)`,
@@ -584107,7 +584665,7 @@ ${latest.output || ""}`.trim();
             maxLines: artifactLines,
             sortBy: "recent"
           });
-          const totalBytes = scan.files.reduce((sum, file) => sum + file.bytes, 0);
+          const totalBytes = scan.files.reduce((sum2, file) => sum2 + file.bytes, 0);
           const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
           const focusSnapshot = this._focusSupervisor?.snapshot();
           const recentActions = this._recentToolActionsForWorldState().slice(-12).map((item) => ({
@@ -588876,7 +589434,7 @@ ${memoryLines.join("\n")}`
           estimatedTokens += Math.ceil((choiceContent.length + choiceArgs.length) / 4);
           const IMAGE_TOKEN_ESTIMATE = 1500;
           const imageBase64Pattern = /\[IMAGE_BASE64:[^\]]+\]/g;
-          const estimatedContextTokens = Math.ceil(compacted.reduce((sum, m2) => {
+          const estimatedContextTokens = Math.ceil(compacted.reduce((sum2, m2) => {
             let chars = 0;
             let imageCount = 0;
             if (typeof m2.content === "string") {
@@ -588898,7 +589456,7 @@ ${memoryLines.join("\n")}`
               for (const tc of m2.tool_calls)
                 chars += tc.function.arguments?.length ?? 0;
             }
-            return sum + chars + imageCount * IMAGE_TOKEN_ESTIMATE * 4;
+            return sum2 + chars + imageCount * IMAGE_TOKEN_ESTIMATE * 4;
           }, 0) / 4);
           this.emit({
             type: "token_usage",
@@ -592632,7 +593190,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             const choiceArgs2 = response.choices[0]?.message?.toolCalls?.map((tc) => JSON.stringify(tc.arguments)).join("") ?? "";
             estimatedTokens += Math.ceil((choiceContent2.length + choiceArgs2.length) / 4);
             const _bfImgPat = /\[IMAGE_BASE64:[^\]]+\]/g;
-            const bfEstCtx = Math.ceil(compactedMsgs.reduce((sum, m2) => {
+            const bfEstCtx = Math.ceil(compactedMsgs.reduce((sum2, m2) => {
               let chars = 0;
               let imgCount = 0;
               if (typeof m2.content === "string") {
@@ -592653,7 +593211,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 for (const tc of m2.tool_calls)
                   chars += tc.function.arguments?.length ?? 0;
               }
-              return sum + chars + imgCount * 1500 * 4;
+              return sum2 + chars + imgCount * 1500 * 4;
             }, 0) / 4);
             this.emit({
               type: "token_usage",
@@ -595658,7 +596216,7 @@ Describe what you see and integrate this into your current approach.` : "[User s
         if (messages2.length < 3)
           return messages2;
         const _compImgPat = /\[IMAGE_BASE64:[^\]]+\]/g;
-        const totalChars = messages2.reduce((sum, m2) => {
+        const totalChars = messages2.reduce((sum2, m2) => {
           let chars = 0;
           if (typeof m2.content === "string") {
             const imgMatches = m2.content.match(_compImgPat);
@@ -595680,7 +596238,7 @@ Describe what you see and integrate this into your current approach.` : "[User s
               chars += tc.function.name?.length ?? 0;
             }
           }
-          return sum + chars;
+          return sum2 + chars;
         }, 0);
         const estimatedTokens = totalChars / 4;
         const limits = this.contextLimits();
@@ -596151,7 +596709,7 @@ ${content.slice(0, 8e3)}
         const ctxWindow = this.options.contextWindowSize;
         if (ctxWindow > 0) {
           const _safetyImgPat = /\[IMAGE_BASE64:[^\]]+\]/g;
-          const estimateResult = (msgs) => msgs.reduce((sum, m2) => {
+          const estimateResult = (msgs) => msgs.reduce((sum2, m2) => {
             let chars = 0;
             let imgCount = 0;
             if (typeof m2.content === "string") {
@@ -596172,7 +596730,7 @@ ${content.slice(0, 8e3)}
               for (const tc of m2.tool_calls)
                 chars += tc.function.arguments?.length ?? 0;
             }
-            return sum + chars + imgCount * 1500 * 4;
+            return sum2 + chars + imgCount * 1500 * 4;
           }, 0) / 4;
           const safetyTarget = Math.floor(ctxWindow * 0.65);
           let trimmedRecent = [...filteredRecent];
@@ -600787,7 +601345,7 @@ var init_workEvaluator = __esm({
               feedback: pd?.feedback ?? ""
             };
           });
-          const overallScore = dimensions.reduce((sum, d2) => sum + d2.score / 10 * d2.weight, 0);
+          const overallScore = dimensions.reduce((sum2, d2) => sum2 + d2.score / 10 * d2.weight, 0);
           return {
             overallScore,
             dimensions,
@@ -601233,7 +601791,7 @@ function cascadeBudget(decisions, config) {
     for (const tier of ["A", "B", "C", "D"]) {
       const budget = config.budgetsTokens[tier];
       const inTier = decisions.filter((decision2) => decision2.tier === tier).sort((a2, b) => a2.item.weight - b.item.weight || b.item.id.localeCompare(a2.item.id));
-      let tokens = inTier.reduce((sum, decision2) => sum + decision2.estimatedTokens, 0);
+      let tokens = inTier.reduce((sum2, decision2) => sum2 + decision2.estimatedTokens, 0);
       while (tokens > budget && inTier.length > 0) {
         const demoted = inTier.shift();
         const oldTokens = demoted.estimatedTokens;
@@ -601308,7 +601866,7 @@ function renderPlan(decisions, includeHeader) {
   const memoryPrefix = stable.filter((decision2) => decision2.cacheEligible).map((decision2) => decision2.renderedText).join("\n\n");
   const renderedText = renderedParts.join("\n\n");
   const tokensEmitted = renderedTokenTotal(decisions);
-  const tokensBaselineNoWeighting = decisions.reduce((sum, decision2) => sum + decision2.item.contentTokens, 0);
+  const tokensBaselineNoWeighting = decisions.reduce((sum2, decision2) => sum2 + decision2.item.contentTokens, 0);
   const tierDistribution = tierDistributionFor(decisions);
   return {
     decisions,
@@ -601394,7 +601952,7 @@ function stabilityFor(id2, options2) {
   return options2.defaultStability ?? "new";
 }
 function renderedTokenTotal(decisions) {
-  return decisions.filter((decision2) => decision2.tier !== "E").reduce((sum, decision2) => sum + decision2.estimatedTokens, 0);
+  return decisions.filter((decision2) => decision2.tier !== "E").reduce((sum2, decision2) => sum2 + decision2.estimatedTokens, 0);
 }
 function tierDistributionFor(decisions) {
   const distribution = { A: 0, B: 0, C: 0, D: 0, E: 0 };
@@ -605672,6 +606230,146 @@ var init_dedup_gate = __esm({
   }
 });
 
+// packages/orchestrator/dist/convergence-breaker.js
+var InMemoryConvergenceStore, DEFAULTS2, ConvergenceBreaker;
+var init_convergence_breaker = __esm({
+  "packages/orchestrator/dist/convergence-breaker.js"() {
+    "use strict";
+    InMemoryConvergenceStore = class {
+      map = /* @__PURE__ */ new Map();
+      load(family) {
+        return this.map.get(family) ?? null;
+      }
+      save(entry) {
+        this.map.set(entry.family, { ...entry });
+      }
+      /** Test/telemetry helper. */
+      entries() {
+        return [...this.map.values()];
+      }
+    };
+    DEFAULTS2 = { warnRound: 2, stallRound: 3, abandonRound: 5 };
+    ConvergenceBreaker = class {
+      warnRound;
+      stallRound;
+      abandonRound;
+      store;
+      /** Live per-family total (session + carry) for snapshotting. */
+      live = /* @__PURE__ */ new Map();
+      /**
+       * Prior-session rounds, captured from the store exactly once per family the
+       * first time it is seen this session. Never re-read mid-session, so the
+       * breaker's own persisted writes are not double-counted back into the total.
+       */
+      baseline = /* @__PURE__ */ new Map();
+      /** Progress decay accumulated this session (one per productive mutation). */
+      decay = /* @__PURE__ */ new Map();
+      constructor(options2 = {}) {
+        this.warnRound = Math.max(1, options2.warnRound ?? DEFAULTS2.warnRound);
+        this.stallRound = Math.max(this.warnRound + 1, options2.stallRound ?? DEFAULTS2.stallRound);
+        this.abandonRound = Math.max(this.stallRound + 1, options2.abandonRound ?? DEFAULTS2.abandonRound);
+        this.store = options2.store ?? new InMemoryConvergenceStore();
+      }
+      /**
+       * Observe a failure and return the convergence verdict. Idempotent per
+       * (family, sessionCount): callers pass the focusSupervisor's monotonically
+       * increasing session count, so re-observing the same count does not
+       * double-advance the cliff.
+       */
+      observe(obs) {
+        if (!this.baseline.has(obs.family)) {
+          const carry2 = this.store.load(obs.family);
+          this.baseline.set(obs.family, carry2?.rounds ?? 0);
+        }
+        const base3 = this.baseline.get(obs.family) ?? 0;
+        let dec = this.decay.get(obs.family) ?? 0;
+        if (obs.mutatedSinceLast) {
+          dec += 1;
+          this.decay.set(obs.family, dec);
+        }
+        const sessionCount = Math.max(1, obs.sessionCount);
+        const totalRounds = Math.max(1, base3 + sessionCount - dec);
+        const tier = this.tierFor(totalRounds);
+        this.live.set(obs.family, { totalRounds, tier });
+        const carry = this.store.load(obs.family);
+        this.store.save({
+          family: obs.family,
+          rounds: Math.max(carry?.rounds ?? 0, totalRounds),
+          lastSample: obs.sample ?? carry?.lastSample,
+          updatedAtMs: Date.now()
+        });
+        return this.verdict(obs.family, totalRounds, tier, obs.sample);
+      }
+      /** Clear a family's carry when its underlying work is verified/complete. */
+      resolve(family) {
+        this.live.delete(family);
+        this.baseline.delete(family);
+        this.decay.delete(family);
+        this.store.save({ family, rounds: 0, updatedAtMs: Date.now() });
+      }
+      snapshot() {
+        return {
+          families: [...this.live.entries()].map(([family, v]) => ({
+            family,
+            totalRounds: v.totalRounds,
+            tier: v.tier
+          }))
+        };
+      }
+      tierFor(totalRounds) {
+        if (totalRounds >= this.abandonRound)
+          return "abandon";
+        if (totalRounds >= this.stallRound)
+          return "stalled";
+        if (totalRounds >= this.warnRound)
+          return "converging_warn";
+        return "healthy";
+      }
+      verdict(family, totalRounds, tier, sample) {
+        const suffix = sample ? `: ${sample}` : "";
+        switch (tier) {
+          case "abandon":
+            return {
+              tier,
+              tripped: true,
+              totalRounds,
+              family,
+              reason: `failure family "${family}" has not converged after ${totalRounds} rounds (>= ${this.abandonRound}); this trajectory is dead — stop iterating and report incomplete or regenerate from the locked contract${suffix}`,
+              recommendedAction: "report_incomplete"
+            };
+          case "stalled":
+            return {
+              tier,
+              tripped: true,
+              totalRounds,
+              family,
+              reason: `failure family "${family}" stalled after ${totalRounds} rounds (>= ${this.stallRound}); stop patching and regenerate the incoherent layer from the locked contract instead of editing again${suffix}`,
+              recommendedAction: "regenerate_incoherent_layer"
+            };
+          case "converging_warn":
+            return {
+              tier,
+              tripped: false,
+              totalRounds,
+              family,
+              reason: `failure family "${family}" repeated ${totalRounds} rounds; ~75% of reachable improvement is already spent — change approach on the next attempt${suffix}`,
+              recommendedAction: "replan"
+            };
+          default:
+            return {
+              tier,
+              tripped: false,
+              totalRounds,
+              family,
+              reason: `failure family "${family}" at ${totalRounds} round(s)`,
+              recommendedAction: "continue"
+            };
+        }
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/conversational-scrutiny.js
 function auditPerceptionClaims(text2, evidence) {
   if (!text2 || !text2.trim())
@@ -605744,6 +606442,189 @@ var init_conversational_scrutiny = __esm({
   }
 });
 
+// packages/orchestrator/dist/coherence-gate.js
+function scanDuplicateDefinitions(source, language = "unknown") {
+  if (!source)
+    return [];
+  const counts = /* @__PURE__ */ new Map();
+  const bump = (name10) => {
+    if (!name10)
+      return;
+    counts.set(name10, (counts.get(name10) ?? 0) + 1);
+  };
+  if (language === "cpp" || language === "unknown") {
+    for (const m2 of source.matchAll(/}\s*([A-Za-z_]\w*)\s*;/g))
+      bump(m2[1]);
+    for (const m2 of source.matchAll(/^\s*typedef\s+[^;{]+\s([A-Za-z_]\w*)\s*;/gm))
+      bump(m2[1]);
+    for (const m2 of source.matchAll(/\b(?:struct|class|enum|union)\s+([A-Za-z_]\w*)\s*[:{]/g))
+      bump(m2[1]);
+    for (const m2 of source.matchAll(/^\s*#define\s+([A-Za-z_]\w*)/gm))
+      bump(m2[1]);
+  }
+  if (language === "typescript" || language === "unknown") {
+    for (const m2 of source.matchAll(/\b(?:interface|type|class|enum)\s+([A-Za-z_]\w*)\b/g))
+      bump(m2[1]);
+  }
+  return [...counts.entries()].filter(([, n2]) => n2 > 1).map(([name10]) => name10);
+}
+function clamp0110(n2) {
+  if (Number.isNaN(n2))
+    return 0;
+  return Math.max(0, Math.min(1, n2));
+}
+var DEFAULT_WEIGHTS2, CoherenceGate;
+var init_coherence_gate = __esm({
+  "packages/orchestrator/dist/coherence-gate.js"() {
+    "use strict";
+    DEFAULT_WEIGHTS2 = {
+      duplicateDefinition: 0.34,
+      // 2 duplicate defs -> score ~0.32, below floor
+      signatureMismatch: 0.15,
+      unknownSymbol: 0.1,
+      typeError: 0.05
+    };
+    CoherenceGate = class {
+      regenThreshold;
+      weights;
+      constructor(options2 = {}) {
+        this.regenThreshold = clamp0110(options2.regenThreshold ?? 0.6);
+        this.weights = { ...DEFAULT_WEIGHTS2, ...options2.weights ?? {} };
+      }
+      evaluate(input) {
+        const diags = input.diagnostics ?? [];
+        const duplicateSymbols = input.source ? scanDuplicateDefinitions(input.source, input.language ?? "unknown") : [];
+        const signals = {
+          duplicateDefinitions: diags.filter((d2) => d2.kind === "duplicate_definition").length + duplicateSymbols.length,
+          signatureMismatches: diags.filter((d2) => d2.kind === "signature_mismatch").length,
+          unknownSymbols: diags.filter((d2) => d2.kind === "unknown_symbol" || d2.kind === "unknown_member").length,
+          otherTypeErrors: diags.filter((d2) => d2.kind === "type_error").length,
+          duplicateSymbols
+        };
+        let score = 1;
+        score -= signals.duplicateDefinitions * this.weights.duplicateDefinition;
+        score -= signals.signatureMismatches * this.weights.signatureMismatch;
+        score -= signals.unknownSymbols * this.weights.unknownSymbol;
+        score -= signals.otherTypeErrors * this.weights.typeError;
+        score = clamp0110(score);
+        const regime = score < this.regenThreshold ? "regenerate" : "patch";
+        return { score, regime, reason: this.reason(score, regime, signals), signals };
+      }
+      reason(score, regime, s2) {
+        if (regime === "regenerate") {
+          const dup = s2.duplicateSymbols.length ? ` Duplicate definitions: ${s2.duplicateSymbols.slice(0, 6).join(", ")}.` : "";
+          return `coherence ${score.toFixed(2)} < ${this.regenThreshold} — the contract is self-contradictory; regenerate this unit wholesale from the locked contract instead of patching.${dup}`;
+        }
+        return `coherence ${score.toFixed(2)} >= ${this.regenThreshold} — invariants hold; patch mode.`;
+      }
+    };
+  }
+});
+
+// packages/orchestrator/dist/spec-gate.js
+function definitionCount(source, name10) {
+  const n2 = escapeRegExp2(name10);
+  const patterns = [
+    new RegExp(`}\\s*${n2}\\s*;`, "g"),
+    // } Name;  (typedef struct/enum)
+    new RegExp(`\\b(?:struct|class|enum|union)\\s+${n2}\\s*[:{]`, "g"),
+    new RegExp(`\\b(?:interface|type|class|enum)\\s+${n2}\\b`, "g"),
+    new RegExp(`\\btypedef\\s+[^;{]+\\b${n2}\\s*;`, "g")
+  ];
+  let total = 0;
+  for (const re of patterns)
+    total += (source.match(re) ?? []).length;
+  return total;
+}
+function hasField(source, symbol3, field) {
+  const n2 = escapeRegExp2(symbol3);
+  const block = source.match(new RegExp(`(?:struct|class|enum|union|interface)\\s+${n2}[^{]*{([\\s\\S]*?)}|{([\\s\\S]*?)}\\s*${n2}\\s*;`));
+  const body = block?.[1] ?? block?.[2] ?? "";
+  if (!body)
+    return false;
+  return new RegExp(`\\b${escapeRegExp2(field)}\\b`).test(body);
+}
+function hasSignature(source, fragment) {
+  const norm = (s2) => s2.replace(/\s+/g, " ").trim();
+  return norm(source).includes(norm(fragment));
+}
+function evaluateSpecGate(unit, contract, opts = {}) {
+  const violations = [];
+  const expected = new Set(opts.expectedSymbols ?? []);
+  for (const spec of contract.symbols) {
+    const count = definitionCount(unit.source, spec.name);
+    const mustDefine = expected.has(spec.name);
+    if (count === 0) {
+      if (mustDefine) {
+        violations.push({
+          symbol: spec.name,
+          kind: "missing_symbol",
+          detail: `unit ${unit.path} must declare ${spec.kind} ${spec.name} but it is absent`
+        });
+      }
+      continue;
+    }
+    if (count > 1) {
+      violations.push({
+        symbol: spec.name,
+        kind: "duplicate_symbol",
+        detail: `${spec.name} is defined ${count}× in ${unit.path}; the contract permits exactly one`
+      });
+    }
+    for (const field of spec.fields ?? []) {
+      if (!hasField(unit.source, spec.name, field)) {
+        violations.push({
+          symbol: spec.name,
+          kind: "missing_field",
+          detail: `${spec.name} is missing required member "${field}"`
+        });
+      }
+    }
+    if (spec.signature && !hasSignature(unit.source, spec.signature)) {
+      violations.push({
+        symbol: spec.name,
+        kind: "signature_divergence",
+        detail: `${spec.name} does not match the contract signature "${spec.signature}"`
+      });
+    }
+  }
+  const pass = violations.length === 0;
+  return {
+    pass,
+    violations,
+    summary: pass ? `spec gate PASS for ${unit.path}` : `spec gate FAIL for ${unit.path}: ${violations.length} violation(s) — ${violations.map((v) => `${v.symbol}:${v.kind}`).join(", ")}`
+  };
+}
+function evaluateExecutorStep(input) {
+  const spec = evaluateSpecGate(input.unit, input.contract, {
+    expectedSymbols: input.expectedSymbols
+  });
+  if (input.convergenceTier === "abandon" || input.convergenceTier === "stalled") {
+    return {
+      decision: "replan",
+      spec,
+      reason: `convergence ${input.convergenceTier}: stop patching ${input.unit.path}; re-plan / regenerate from the locked contract`
+    };
+  }
+  const boundaryOk = input.boundaryOk ?? true;
+  if (spec.pass && boundaryOk) {
+    return { decision: "accept", spec, reason: `${input.unit.path} accepted` };
+  }
+  return {
+    decision: "reject_regenerate",
+    spec,
+    reason: spec.pass ? `${input.unit.path} passed the spec gate but failed to compile — regenerate` : spec.summary
+  };
+}
+function escapeRegExp2(s2) {
+  return s2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var init_spec_gate = __esm({
+  "packages/orchestrator/dist/spec-gate.js"() {
+    "use strict";
+  }
+});
+
 // packages/orchestrator/dist/index.js
 var dist_exports3 = {};
 __export(dist_exports3, {
@@ -605762,6 +606643,8 @@ __export(dist_exports3, {
   CRITIQUE_PRINCIPLES: () => CRITIQUE_PRINCIPLES,
   CallHistory: () => CallHistory,
   CascadeBackend: () => CascadeBackend,
+  CoherenceGate: () => CoherenceGate,
+  ConvergenceBreaker: () => ConvergenceBreaker,
   CoordinatorManager: () => CoordinatorManager,
   CostTracker: () => CostTracker,
   DEFAULT_COORDINATOR_CONFIG: () => DEFAULT_COORDINATOR_CONFIG,
@@ -605777,6 +606660,7 @@ __export(dist_exports3, {
   HookManager: () => HookManager,
   INFRA_WORKER_SKILL: () => INFRA_WORKER_SKILL,
   ImportanceBudget: () => ImportanceBudget,
+  InMemoryConvergenceStore: () => InMemoryConvergenceStore,
   MergeRunner: () => MergeRunner,
   NexusAgenticBackend: () => NexusAgenticBackend,
   OllamaAgenticBackend: () => OllamaAgenticBackend,
@@ -605864,6 +606748,8 @@ __export(dist_exports3, {
   detectTaskType: () => detectTaskType,
   discoverPlugins: () => discoverPlugins3,
   discoverSystemOllamaModelStore: () => discoverSystemOllamaModelStore,
+  evaluateExecutorStep: () => evaluateExecutorStep,
+  evaluateSpecGate: () => evaluateSpecGate,
   executeBatch: () => executeBatch,
   executeHook: () => executeHook,
   expandContextReference: () => expandContextReference,
@@ -605988,6 +606874,7 @@ __export(dist_exports3, {
   saveCompletionLedger: () => saveCompletionLedger,
   saveStabilityIndex: () => saveStabilityIndex,
   scanContextContent: () => scanContextContent,
+  scanDuplicateDefinitions: () => scanDuplicateDefinitions,
   scanOllamaProcesses: () => scanOllamaProcesses,
   scoreHandoff: () => scoreHandoff,
   scoreMemoryItem: () => scoreMemoryItem,
@@ -606085,11 +606972,14 @@ var init_dist8 = __esm({
     init_plugins();
     init_project_arc();
     init_dedup_gate();
+    init_convergence_breaker();
     init_memory_consolidation();
     init_exploration_fanout();
     init_consolidation_runtime();
     init_completion_evidence_gate();
     init_conversational_scrutiny();
+    init_coherence_gate();
+    init_spec_gate();
   }
 });
 
@@ -607595,28 +608485,28 @@ function updateListenLiveState(patch) {
 function getListenLiveState() {
   return listenLiveState;
 }
-function clamp0110(value2) {
+function clamp0111(value2) {
   if (!Number.isFinite(value2)) return 0;
   return Math.max(0, Math.min(1, value2));
 }
 function micColor(text2, level) {
-  const idx = Math.round(clamp0110(level) * (MIC_GRADIENT_256.length - 1));
+  const idx = Math.round(clamp0111(level) * (MIC_GRADIENT_256.length - 1));
   const code8 = MIC_GRADIENT_256[idx] ?? 21;
   return `\x1B[38;5;${code8}m${text2}\x1B[0m`;
 }
 function micLevelChar(level) {
-  const idx = Math.round(clamp0110(level) * (MIC_LEVEL_CHARS.length - 1));
+  const idx = Math.round(clamp0111(level) * (MIC_LEVEL_CHARS.length - 1));
   return MIC_LEVEL_CHARS[idx] ?? "▁";
 }
 function micSpectrumChar(level) {
-  const idx = Math.round(clamp0110(level) * (MIC_SPECTRUM_CHARS.length - 1));
+  const idx = Math.round(clamp0111(level) * (MIC_SPECTRUM_CHARS.length - 1));
   return MIC_SPECTRUM_CHARS[idx] ?? " ";
 }
 function renderMicWaveform(bucketSquares, bucketCounts, peak) {
-  return bucketSquares.map((sum, idx) => {
+  return bucketSquares.map((sum2, idx) => {
     const count = Math.max(1, bucketCounts[idx] ?? 1);
-    const level = Math.sqrt(sum / count);
-    const normalized = clamp0110(level / Math.max(0.02, peak || 0.02));
+    const level = Math.sqrt(sum2 / count);
+    const normalized = clamp0111(level / Math.max(0.02, peak || 0.02));
     return micColor(micLevelChar(normalized), normalized);
   }).join("");
 }
@@ -607640,7 +608530,7 @@ function renderMicSpectrum(samples) {
     }
     const mag = Math.sqrt(re * re + im * im) / n2;
     const db = 20 * Math.log10(Math.max(1e-7, mag));
-    const normalized = clamp0110((db + 75) / 75);
+    const normalized = clamp0111((db + 75) / 75);
     bands.push(micColor(micSpectrumChar(normalized), normalized));
   }
   return bands.join("");
@@ -608535,7 +609425,7 @@ var init_listen = __esm({
         const speech = hardwareFresh ? listenLiveState.speechActive : this.micLevelDb > Math.max(-58, floor + 6);
         const changed = speech !== this.micSpeechActive;
         this.micSpeechActive = speech;
-        const peak = Math.sqrt(Math.max(...bucketSquares.map((sum, idx) => sum / Math.max(1, bucketCounts[idx] ?? 1)), 0));
+        const peak = Math.sqrt(Math.max(...bucketSquares.map((sum2, idx) => sum2 / Math.max(1, bucketCounts[idx] ?? 1)), 0));
         const waveform = renderMicWaveform(bucketSquares, bucketCounts, peak);
         const spectrum = renderMicSpectrum(spectrumSamples);
         if (spectrum) {
@@ -609597,8 +610487,8 @@ function formatGpuRuntimeLine(broker) {
   }
   const parts = devices.map((device) => {
     const label = device.uuid === "jetson-uma" ? "jetson-uma" : `gpu${device.index}`;
-    const pct = device.total > 0 ? device.used / device.total : 0;
-    return `${label} ${pressureColor(pct, 0.78)(`${mbToGb(device.used)}/${mbToGb(device.total)}GB`)}`;
+    const pct2 = device.total > 0 ? device.used / device.total : 0;
+    return `${label} ${pressureColor(pct2, 0.78)(`${mbToGb(device.used)}/${mbToGb(device.total)}GB`)}`;
   });
   return `├─ accelerator: ${colorText("CUDA on", 82)}  ${parts.join("  ")}`;
 }
@@ -609623,8 +610513,8 @@ function formatSubsystemMemoryLine(loaded, width) {
 }
 function formatUnattributedMemoryLine(loaded, broker) {
   const resource = getLiveResourceArbiter().snapshot();
-  const trackedRam = loaded.reduce((sum, model) => sum + Math.max(0, Number(model.ramMB ?? 0)), 0);
-  const trackedVram = loaded.reduce((sum, model) => sum + Math.max(0, Number(model.vramMB ?? 0)), 0);
+  const trackedRam = loaded.reduce((sum2, model) => sum2 + Math.max(0, Number(model.ramMB ?? 0)), 0);
+  const trackedVram = loaded.reduce((sum2, model) => sum2 + Math.max(0, Number(model.vramMB ?? 0)), 0);
   const ramGap = Math.max(0, resource.usedMemMB - trackedRam);
   const vramGap = broker.vramMB ? Math.max(0, broker.vramMB.used - trackedVram) : null;
   return `├─ unattributed/system: ram=${mbToGb(ramGap)}G${vramGap !== null ? ` vram/uma=${mbToGb(vramGap)}G` : ""} ${colorText("(OS, camera ffmpeg, CV libs, CUDA overhead, untracked subprocesses)", 244)}`;
@@ -610076,7 +610966,7 @@ function chooseCameraOrientationFromScores(scores) {
   if (!best || best.score <= 0 || best.faces <= 0) return null;
   const second3 = sorted[1];
   const gap = best.score - (second3?.score ?? 0);
-  const total = sorted.reduce((sum, score) => sum + Math.max(0, score.score), 0);
+  const total = sorted.reduce((sum2, score) => sum2 + Math.max(0, score.score), 0);
   const share = total > 0 ? best.score / total : 1;
   const confidence2 = Math.max(0.55, Math.min(0.98, share * 0.75 + Math.min(0.23, gap / Math.max(1, best.score))));
   if (confidence2 < 0.58 && gap < 0.4) return null;
@@ -610343,9 +611233,9 @@ function readPcm16WavActivity(filePath, bins = 36) {
     }
     const rms = Math.sqrt(sumSquares / frames);
     const chars = "▁▂▃▄▅▆▇█";
-    const waveform = bucketSquares.map((sum, idx) => {
+    const waveform = bucketSquares.map((sum2, idx) => {
       const count = Math.max(1, bucketCounts[idx] ?? 1);
-      const level = Math.sqrt(sum / count);
+      const level = Math.sqrt(sum2 / count);
       const normalized = Math.max(0, Math.min(1, level / Math.max(0.02, peak || 0.02)));
       return chars[Math.min(chars.length - 1, Math.round(normalized * (chars.length - 1)))] ?? "▁";
     }).join("");
@@ -610780,11 +611670,11 @@ function formatCameraRotationDashboard(camera) {
 }
 function cameraPaneBadge(camera) {
   const classifications = camera.classifications ?? [];
-  const faceCount = classifications.filter((item) => item.kind === "face" || item.kind === "identity").reduce((sum, item) => sum + Math.max(1, item.count), 0);
-  const objectCount = classifications.filter((item) => item.kind === "object").reduce((sum, item) => sum + Math.max(1, item.count), 0);
-  const segmentCount = classifications.filter((item) => item.kind === "segment").reduce((sum, item) => sum + Math.max(1, item.count), 0);
-  const trackCount = classifications.filter((item) => item.kind === "track").reduce((sum, item) => sum + Math.max(1, item.count), 0);
-  const triggerCount = classifications.filter((item) => item.kind === "trigger").reduce((sum, item) => sum + Math.max(1, item.count), 0);
+  const faceCount = classifications.filter((item) => item.kind === "face" || item.kind === "identity").reduce((sum2, item) => sum2 + Math.max(1, item.count), 0);
+  const objectCount = classifications.filter((item) => item.kind === "object").reduce((sum2, item) => sum2 + Math.max(1, item.count), 0);
+  const segmentCount = classifications.filter((item) => item.kind === "segment").reduce((sum2, item) => sum2 + Math.max(1, item.count), 0);
+  const trackCount = classifications.filter((item) => item.kind === "track").reduce((sum2, item) => sum2 + Math.max(1, item.count), 0);
+  const triggerCount = classifications.filter((item) => item.kind === "trigger").reduce((sum2, item) => sum2 + Math.max(1, item.count), 0);
   const parts = [
     faceCount > 0 ? `F${faceCount}` : "",
     segmentCount > 0 ? `S${segmentCount}` : "",
@@ -613438,14 +614328,14 @@ function formatGenerativeProgress(kind, event, options2 = {}) {
   const width = Math.max(8, Math.min(32, options2.width ?? (options2.surface === "telegram" ? 12 : 20)));
   const label = kindLabel2(kind);
   const stage2 = stageLabel(event.stage);
-  const pct = finitePercent(event.percent);
+  const pct2 = finitePercent(event.percent);
   const bytes = formatProgressBytes(event);
   const elapsed = formatElapsed(event.elapsedMs);
   const message2 = compactProgressMessage(event.message);
-  if (typeof pct === "number") {
-    const filled = Math.max(0, Math.min(width, Math.round(pct / 100 * width)));
+  if (typeof pct2 === "number") {
+    const filled = Math.max(0, Math.min(width, Math.round(pct2 / 100 * width)));
     const bar = `${"#".repeat(filled)}${"-".repeat(width - filled)}`;
-    return `${label} ${stage2}: [${bar}] ${pct}% ${message2}${bytes}${elapsed}`;
+    return `${label} ${stage2}: [${bar}] ${pct2}% ${message2}${bytes}${elapsed}`;
   }
   return `${label} ${stage2}: ${message2}${bytes}${elapsed}`;
 }
@@ -619706,7 +620596,7 @@ var init_task_complete_box = __esm({
 // packages/cli/src/tui/syntax-highlight.ts
 var syntax_highlight_exports = {};
 __export(syntax_highlight_exports, {
-  detectLanguage: () => detectLanguage2,
+  detectLanguage: () => detectLanguage3,
   getHighlightStatus: () => getHighlightStatus,
   highlightBlock: () => highlightBlock,
   highlightCode: () => highlightCode,
@@ -619776,7 +620666,7 @@ function highlightCode(code8, language) {
   if (!code8) return code8;
   const fn = loadHighlighterSync();
   if (!fn) return code8;
-  const lang = (language ?? detectLanguage2(code8) ?? "").trim();
+  const lang = (language ?? detectLanguage3(code8) ?? "").trim();
   try {
     if (lang) {
       return fn(code8, { language: lang, ignoreIllegals: true });
@@ -619786,7 +620676,7 @@ function highlightCode(code8, language) {
     return code8;
   }
 }
-function detectLanguage2(text2) {
+function detectLanguage3(text2) {
   if (!text2) return null;
   const trimmed = text2.trimStart();
   const shebang = trimmed.match(/^#!\s*\/[^\n]+/);
@@ -619841,7 +620731,7 @@ function highlightBlock(code8, language) {
   if (!code8) return [""];
   const fn = loadHighlighterSync();
   if (!fn) return code8.split("\n");
-  const lang = (language ?? detectLanguage2(code8) ?? "").trim();
+  const lang = (language ?? detectLanguage3(code8) ?? "").trim();
   try {
     const out = lang ? fn(code8, { language: lang, ignoreIllegals: true }) : fn(code8, { ignoreIllegals: true });
     const lines = out.split("\n");
@@ -624706,15 +625596,15 @@ function formatUsageBar(options2) {
   const used = total > 0 ? Math.min(total, rawUsed) : 0;
   const width = Math.max(4, options2.width ?? 18);
   const labelWidth = Math.max(options2.label.length, options2.labelWidth ?? 16);
-  const pct = total > 0 ? Math.round(used / total * 100) : 0;
-  const filled = total > 0 ? Math.min(width, Math.round(pct / 100 * width)) : 0;
-  const color = pct >= 90 ? c3.red : pct >= 70 ? c3.yellow : c3.green;
+  const pct2 = total > 0 ? Math.round(used / total * 100) : 0;
+  const filled = total > 0 ? Math.min(width, Math.round(pct2 / 100 * width)) : 0;
+  const color = pct2 >= 90 ? c3.red : pct2 >= 70 ? c3.yellow : c3.green;
   const bar = color("█".repeat(filled)) + c3.dim("░".repeat(width - filled));
   const reset = options2.resetAt ? c3.dim(formatResetDelta(options2.resetAt)) : "";
   return [
     c3.cyan(options2.label.padEnd(labelWidth)),
     bar,
-    color(`${pct}%`.padStart(4)),
+    color(`${pct2}%`.padStart(4)),
     c3.dim(`${formatCompactCount(rawUsed)}/${formatCompactCount(total)}`),
     reset
   ].join(" ").trimEnd();
@@ -624779,7 +625669,7 @@ function safeNonNegativeInt(value2) {
 function currentTokenRate(samples, now2 = Date.now()) {
   while (samples.length > 0 && samples[0].at < now2 - 1e4) samples.shift();
   if (samples.length === 0) return 0;
-  const tokens = samples.reduce((sum, sample) => sum + sample.tokens, 0);
+  const tokens = samples.reduce((sum2, sample) => sum2 + sample.tokens, 0);
   const spanMs = Math.max(1e3, now2 - samples[0].at);
   return Math.round(tokens / (spanMs / 1e3) * 10) / 10;
 }
@@ -626140,9 +627030,9 @@ ${this.formatConnectionInfo()}`);
         lines.push(`  ${c3.cyan("Tokens out".padEnd(18))} ${fmtTokens(s2.totalTokensOut)}`);
         lines.push(`  ${c3.cyan("Tokens/sec".padEnd(18))} ${s2.tokensPerSecond.toFixed(s2.tokensPerSecond >= 10 ? 0 : 1)} t/s`);
         if (s2.budgetTokensTotal > 0) {
-          const pct = Math.round(s2.budgetTokensRemaining / s2.budgetTokensTotal * 100);
-          const budgetColor = pct > 50 ? c3.green : pct > 20 ? c3.yellow : c3.red;
-          lines.push(`  ${c3.cyan("Budget".padEnd(18))} ${budgetColor(fmtTokens(s2.budgetTokensRemaining))}${c3.dim("/")}${fmtTokens(s2.budgetTokensTotal)} ${c3.dim(`(${pct}% left)`)}`);
+          const pct2 = Math.round(s2.budgetTokensRemaining / s2.budgetTokensTotal * 100);
+          const budgetColor = pct2 > 50 ? c3.green : pct2 > 20 ? c3.yellow : c3.red;
+          lines.push(`  ${c3.cyan("Budget".padEnd(18))} ${budgetColor(fmtTokens(s2.budgetTokensRemaining))}${c3.dim("/")}${fmtTokens(s2.budgetTokensTotal)} ${c3.dim(`(${pct2}% left)`)}`);
         }
         if (s2.sponsorUsage) {
           lines.push("");
@@ -626870,9 +627760,9 @@ ${this.formatConnectionInfo()}`);
         lines.push(`  ${c3.cyan("Tokens out".padEnd(18))} ${fmtTokens(s2.totalTokensOut)}`);
         lines.push(`  ${c3.cyan("Tokens/sec".padEnd(18))} ${s2.tokensPerSecond.toFixed(s2.tokensPerSecond >= 10 ? 0 : 1)} t/s`);
         if (s2.budgetTokensTotal > 0) {
-          const pct = Math.round(s2.budgetTokensRemaining / s2.budgetTokensTotal * 100);
-          const budgetColor = pct > 50 ? c3.green : pct > 20 ? c3.yellow : c3.red;
-          lines.push(`  ${c3.cyan("Budget".padEnd(18))} ${budgetColor(fmtTokens(s2.budgetTokensRemaining))}${c3.dim("/")}${fmtTokens(s2.budgetTokensTotal)} ${c3.dim(`(${pct}% left)`)}`);
+          const pct2 = Math.round(s2.budgetTokensRemaining / s2.budgetTokensTotal * 100);
+          const budgetColor = pct2 > 50 ? c3.green : pct2 > 20 ? c3.yellow : c3.red;
+          lines.push(`  ${c3.cyan("Budget".padEnd(18))} ${budgetColor(fmtTokens(s2.budgetTokensRemaining))}${c3.dim("/")}${fmtTokens(s2.budgetTokensTotal)} ${c3.dim(`(${pct2}% left)`)}`);
         }
         if (s2.sponsorUsage) {
           lines.push("");
@@ -631510,9 +632400,9 @@ async function collectGpuMetrics() {
       });
     }
     if (devices.length === 0) return noGpu;
-    const vramUsed = devices.reduce((sum, gpu) => sum + gpu.vramUsedMB, 0);
-    const vramTotal = devices.reduce((sum, gpu) => sum + gpu.vramTotalMB, 0);
-    const avgUtil = Math.round(devices.reduce((sum, gpu) => sum + gpu.utilization, 0) / devices.length);
+    const vramUsed = devices.reduce((sum2, gpu) => sum2 + gpu.vramUsedMB, 0);
+    const vramTotal = devices.reduce((sum2, gpu) => sum2 + gpu.vramTotalMB, 0);
+    const avgUtil = Math.round(devices.reduce((sum2, gpu) => sum2 + gpu.utilization, 0) / devices.length);
     const firstName = devices[0]?.name ?? "";
     const allSameName = devices.every((gpu) => gpu.name === firstName);
     return {
@@ -633535,7 +634425,7 @@ var init_status_bar = __esm({
             w: NO_SUB_AGENTS_HEADER_LABEL.length
           });
         }
-        const sysSeparatorOffset = sysItems.reduce((sum, item) => sum + item.w, 0);
+        const sysSeparatorOffset = sysItems.reduce((sum2, item) => sum2 + item.w, 0);
         this._sysSeparatorOffset = sysSeparatorOffset;
         sysItems.push({
           render: () => `${BOX_FG}│${RESET4}${PANEL_BG_SEQ} `,
@@ -633672,7 +634562,7 @@ var init_status_bar = __esm({
           const buttons = panel.meta.buttons ?? [];
           const versionWidth = panel.meta.versionWidth ?? 0;
           const usedW = panel.meta.isFirstPage ? versionWidth : 0;
-          const btnTotalW = buttons.reduce((sum, btn) => sum + btn.w + 1, 0);
+          const btnTotalW = buttons.reduce((sum2, btn) => sum2 + btn.w + 1, 0);
           const gap = Math.max(1, innerW - usedW - btnTotalW);
           let col = chromeLayout.contentStartCol + usedW + gap;
           if (panel.meta.isFirstPage && this._updateLatest) {
@@ -636204,8 +637094,8 @@ ${CONTENT_BG_SEQ}`);
         }
         if (this._contentScrollOffset > 0) {
           const linesAbove = win.startIdx;
-          const pct = win.totalRows > 0 ? Math.round((win.startIdx + h) / win.totalRows * 100) : 100;
-          const indicator = ` ↑ ${linesAbove} lines above · ${pct}% · PgDn/End to return `;
+          const pct2 = win.totalRows > 0 ? Math.round((win.startIdx + h) / win.totalRows * 100) : 100;
+          const indicator = ` ↑ ${linesAbove} lines above · ${pct2}% · PgDn/End to return `;
           const pad = Math.max(0, w - indicator.length);
           buf += `\x1B[${this.scrollRegionTop};1H\x1B[7m${indicator}${" ".repeat(pad)}\x1B[0m`;
         }
@@ -636460,7 +637350,7 @@ ${CONTENT_BG_SEQ}`);
             return pm ? pm[1] : mdl.split(":")[0]?.split("/").pop() ?? mdl;
           });
           const modelStr = modelParams.join(",");
-          const visibleReqs = Array.from(this._expose.modelUsage.entries()).filter(([m3]) => !INTERNAL_CAPS.has(m3)).reduce((sum, [, n2]) => sum + n2, 0);
+          const visibleReqs = Array.from(this._expose.modelUsage.entries()).filter(([m3]) => !INTERNAL_CAPS.has(m3)).reduce((sum2, [, n2]) => sum2 + n2, 0);
           const reqStr = visibleReqs > 0 ? ` ${_StatusBar.digitBar(visibleReqs)}req` : "";
           const connStr = this._expose.activeConnections > 0 ? ` ${_StatusBar.digitBar(this._expose.activeConnections)}conn` : "";
           const exposeExpanded = statusEmoji + pastel2(183, (modelStr ? " " + modelStr : "") + reqStr + connStr);
@@ -642259,8 +643149,8 @@ var init_registry3 = __esm({
           degraded: statuses.filter((s2) => s2.state === "degraded").length,
           failed: statuses.filter((s2) => s2.state === "failed").length,
           unconfigured: statuses.filter((s2) => s2.state === "unconfigured").length,
-          queued: statuses.reduce((sum, s2) => sum + s2.health.queueDepth, 0),
-          activeSessions: statuses.reduce((sum, s2) => sum + s2.health.activeSessions, 0)
+          queued: statuses.reduce((sum2, s2) => sum2 + s2.health.queueDepth, 0),
+          activeSessions: statuses.reduce((sum2, s2) => sum2 + s2.health.activeSessions, 0)
         };
       }
       require(id2) {
@@ -646053,11 +646943,11 @@ function readSample(buffer2, offset, format3, bitsPerSample) {
 function frameAmplitude(buffer2, info, frame) {
   const bytesPerSample = info.bitsPerSample / 8;
   const offset = info.dataOffset + frame * info.frameSize;
-  let sum = 0;
+  let sum2 = 0;
   for (let channel = 0; channel < info.channels; channel++) {
-    sum += readSample(buffer2, offset + channel * bytesPerSample, info.format, info.bitsPerSample);
+    sum2 += readSample(buffer2, offset + channel * bytesPerSample, info.format, info.bitsPerSample);
   }
-  return Math.max(-1, Math.min(1, sum / info.channels));
+  return Math.max(-1, Math.min(1, sum2 / info.channels));
 }
 function renderAudioWaveform(file, options2 = {}) {
   let Canvas;
@@ -648531,7 +649421,7 @@ function endpointModelCountLabel(ep) {
 }
 async function stepModelSelection(config, rl, availableRows) {
   const enabled2 = config.endpoints.filter((ep) => ep.enabled);
-  const totalKnownModels = enabled2.reduce((sum, ep) => sum + ep.models.length, 0);
+  const totalKnownModels = enabled2.reduce((sum2, ep) => sum2 + ep.models.length, 0);
   if (totalKnownModels === 0) {
     renderWarning("No model lists were returned; sponsorship will expose each enabled endpoint's full model set.");
     return true;
@@ -654098,10 +654988,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`
             chunks.push(value2);
             received += value2.length;
             if (contentLength > 0) {
-              const pct = Math.round(received / contentLength * 100);
-              if (pct === 25 || pct === 50 || pct === 75 || pct === 100) {
+              const pct2 = Math.round(received / contentLength * 100);
+              if (pct2 === 25 || pct2 === 50 || pct2 === 75 || pct2 === 100) {
                 renderInfo(
-                  `  ${pct}% (${formatBytes11(received)} / ${formatBytes11(contentLength)})`
+                  `  ${pct2}% (${formatBytes11(received)} / ${formatBytes11(contentLength)})`
                 );
               }
             }
@@ -654880,8 +655770,8 @@ async function destroyOrphanProcesses(ctx3, global2) {
     myPpid
   );
   if (diagnostics.length > 0) {
-    const totalMb = diagnostics.reduce((sum, c9) => sum + c9.rssMb, 0);
-    const totalCpu = diagnostics.reduce((sum, c9) => sum + c9.cpuPct, 0);
+    const totalMb = diagnostics.reduce((sum2, c9) => sum2 + c9.rssMb, 0);
+    const totalCpu = diagnostics.reduce((sum2, c9) => sum2 + c9.cpuPct, 0);
     renderWarning(
       `untracked_omnius_like: ${diagnostics.length} process(es) matched legacy diagnostics only — not killed automatically (${totalMb}MB RAM, ${totalCpu.toFixed(1)}% CPU):`
     );
@@ -655106,7 +655996,7 @@ async function handleSlashCommand(input, ctx3) {
         const cached = listCachedModels();
         const legacyPaths = detectLegacyCaches(ctx3.repoRoot);
         const totalCachedBytes = cached.reduce(
-          (sum, e2) => sum + e2.sizeBytes,
+          (sum2, e2) => sum2 + e2.sizeBytes,
           0
         );
         renderInfo(`Model store: ${unifiedModelStoreDir()}`);
@@ -655316,10 +656206,10 @@ async function handleSlashCommand(input, ctx3) {
             newRoot: target,
             onProgress: (p2) => {
               if (p2.stage === "copy" && p2.bytesTotal > 0) {
-                const pct = Math.floor(p2.bytesDone / p2.bytesTotal * 100);
-                if (pct !== lastPct && pct % 5 === 0) {
-                  lastPct = pct;
-                  renderContentBlock(`  ${c3.dim(`copy ${pct}%`)} ${c3.dim(formatBytes(p2.bytesDone) + " / " + formatBytes(p2.bytesTotal))}`);
+                const pct2 = Math.floor(p2.bytesDone / p2.bytesTotal * 100);
+                if (pct2 !== lastPct && pct2 % 5 === 0) {
+                  lastPct = pct2;
+                  renderContentBlock(`  ${c3.dim(`copy ${pct2}%`)} ${c3.dim(formatBytes(p2.bytesDone) + " / " + formatBytes(p2.bytesTotal))}`);
                 }
               } else if (p2.stage !== "copy") {
                 renderContentBlock(`  ${c3.dim("∙")} ${c3.dim(p2.message || p2.stage)}`);
@@ -655754,13 +656644,13 @@ async function handleSlashCommand(input, ctx3) {
           );
           if (evalResult.success) {
             const lines = [];
-            const pct = Math.round(evalResult.overallScore * 100);
-            const scoreColor = pct >= 80 ? c3.green : pct >= 60 ? c3.yellow : c3.red;
+            const pct2 = Math.round(evalResult.overallScore * 100);
+            const scoreColor = pct2 >= 80 ? c3.green : pct2 >= 60 ? c3.yellow : c3.red;
             lines.push(
               `
   ${c3.bold("Task Evaluation")} (${evalResult.taskType})`
             );
-            lines.push(`  Overall: ${scoreColor(c3.bold(`${pct}%`))}`);
+            lines.push(`  Overall: ${scoreColor(c3.bold(`${pct2}%`))}`);
             lines.push("");
             for (const d2 of evalResult.dimensions) {
               const bar = "█".repeat(d2.score) + "░".repeat(10 - d2.score);
@@ -657304,10 +658194,10 @@ async function handleSlashCommand(input, ctx3) {
       );
       for (const [cat2, info] of sorted) {
         const name10 = cat2 || "root";
-        const pct = totalBytes > 0 ? Math.round(info.bytes / totalBytes * 100) : 0;
-        const bar = "█".repeat(Math.max(1, Math.round(pct / 5))) + "░".repeat(Math.max(0, 20 - Math.round(pct / 5)));
+        const pct2 = totalBytes > 0 ? Math.round(info.bytes / totalBytes * 100) : 0;
+        const bar = "█".repeat(Math.max(1, Math.round(pct2 / 5))) + "░".repeat(Math.max(0, 20 - Math.round(pct2 / 5)));
         lines.push(
-          `  ${c3.bold(name10.padEnd(20))} ${bar} ${formatFileSize(info.bytes).padStart(8)}  ${String(info.files).padStart(4)} files  ${String(pct).padStart(2)}%`
+          `  ${c3.bold(name10.padEnd(20))} ${bar} ${formatFileSize(info.bytes).padStart(8)}  ${String(info.files).padStart(4)} files  ${String(pct2).padStart(2)}%`
         );
       }
       lines.push(
@@ -662854,7 +663744,7 @@ function cachedModelDiskStats(root, model) {
   const paths = cacheCandidatePaths(root, model).filter(
     (path12) => existsSync142(path12)
   );
-  const bytes = paths.reduce((sum, path12) => sum + directorySizeBytes2(path12), 0);
+  const bytes = paths.reduce((sum2, path12) => sum2 + directorySizeBytes2(path12), 0);
   return { downloaded: paths.length > 0, bytes, paths };
 }
 function downloadedModelSuffix(stats) {
@@ -662903,7 +663793,7 @@ function imageModelDiskStats(ctx3, preset, ollamaSizes) {
       (model) => cachedModelDiskStats(root, model)
     );
     const paths = [...new Set(parts.flatMap((part) => part.paths))];
-    const bytes = parts.reduce((sum, part) => sum + part.bytes, 0);
+    const bytes = parts.reduce((sum2, part) => sum2 + part.bytes, 0);
     return { downloaded: paths.length > 0, bytes, paths };
   }
   return { downloaded: false, bytes: 0, paths: [] };
@@ -670566,14 +671456,14 @@ async function showExposeDashboard(gateway, rl, ctx3) {
         `  ${c3.dim("Req")} ${c3.bold(String(totalReqs))}  ${c3.dim("Active")} ${activeDot}  ${c3.dim("Err")} ${errors > 0 ? c3.magenta(String(errors)) : c3.dim("0")}  ${c3.dim("Tok")} ↑${c3.cyan(fmtDashTokens(tokIn))} ↓${c3.cyan(fmtDashTokens(tokOut))}`
       );
       if (s2.budgetTokensTotal > 0) {
-        const pct = Math.round(
+        const pct2 = Math.round(
           s2.budgetTokensRemaining / s2.budgetTokensTotal * 100
         );
-        const budgetColor = pct > 50 ? c3.green : pct > 20 ? c3.yellow : c3.red;
+        const budgetColor = pct2 > 50 ? c3.green : pct2 > 20 ? c3.yellow : c3.red;
         const barLen = 20;
-        const filledLen = Math.round(pct / 100 * barLen);
+        const filledLen = Math.round(pct2 / 100 * barLen);
         const bar = budgetColor("█".repeat(filledLen)) + c3.dim("░".repeat(barLen - filledLen));
-        lines.push(`  ${c3.dim("Budget")} ${bar} ${budgetColor(`${pct}%`)}`);
+        lines.push(`  ${c3.dim("Budget")} ${bar} ${budgetColor(`${pct2}%`)}`);
       }
     }
     const modelEntries = s2?.modelUsage ? Array.from(s2.modelUsage.entries()).filter(
@@ -673026,7 +673916,7 @@ function normalizePersonName(name10) {
 function personKey(name10) {
   return `person:${normalizePersonName(name10)}`;
 }
-function clamp0111(value2, fallback = 0) {
+function clamp0112(value2, fallback = 0) {
   if (typeof value2 !== "number" || !Number.isFinite(value2)) return fallback;
   return Math.max(0, Math.min(1, value2));
 }
@@ -673043,7 +673933,7 @@ function parseStructuredIdentifyResult(result) {
   const matches = faces.filter((face) => face["identified"] === true && typeof face["name"] === "string" && String(face["name"]).trim()).map((face) => ({
     name: String(face["name"]).trim(),
     personId: typeof face["person_id"] === "string" ? face["person_id"] : void 0,
-    confidence: clamp0111(face["confidence"], 0),
+    confidence: clamp0112(face["confidence"], 0),
     margin: typeof face["margin"] === "number" ? face["margin"] : void 0,
     bbox: Array.isArray(face["bbox"]) ? face["bbox"].map((n2) => Number(n2)).filter(Number.isFinite) : void 0
   }));
@@ -673126,7 +674016,7 @@ function activePendingVisualIdentities(store2, scope, sessionId, limit = 3) {
       pendingId,
       name: name10,
       relation: String(meta["relation"] || "depicts"),
-      confidence: clamp0111(meta["confidence"], 0.92),
+      confidence: clamp0112(meta["confidence"], 0.92),
       note: typeof meta["note"] === "string" ? meta["note"] : void 0,
       episodeId: ep.id,
       createdAt: ep.timestamp,
@@ -673235,7 +674125,7 @@ function stageVisualIdentityAssertion(options2) {
           target: "next_visual_media",
           name: name10,
           relation: options2.relation || "depicts",
-          confidence: clamp0111(options2.confidence, 0.92),
+          confidence: clamp0112(options2.confidence, 0.92),
           note: options2.note,
           createdAt: Date.now(),
           expiresAt
@@ -673243,7 +674133,7 @@ function stageVisualIdentityAssertion(options2) {
         identityAssertions: [{
           name: name10,
           relation: options2.relation || "named_as",
-          confidence: clamp0111(options2.confidence, 0.92),
+          confidence: clamp0112(options2.confidence, 0.92),
           assertedBy: options2.sender,
           note: options2.note || "Explicit user-provided identity staged for the next visual media."
         }],
@@ -673274,7 +674164,7 @@ function stageVisualIdentityAssertion(options2) {
           target: "next_visual_media",
           name: name10,
           relation: options2.relation || "depicts",
-          confidence: clamp0111(options2.confidence, 0.92),
+          confidence: clamp0112(options2.confidence, 0.92),
           note: options2.note,
           createdAt: Date.now(),
           expiresAt
@@ -673283,7 +674173,7 @@ function stageVisualIdentityAssertion(options2) {
       identityAssertions: [{
         name: name10,
         relation: options2.relation || "named_as",
-        confidence: clamp0111(options2.confidence, 0.92),
+        confidence: clamp0112(options2.confidence, 0.92),
         assertedBy: options2.sender,
         note: options2.note || "Explicit user-provided identity staged for the next visual media."
       }]
@@ -682593,7 +683483,7 @@ ${result.output}`,
 });
 
 // packages/cli/src/tui/stimulation.ts
-function clamp0112(value2) {
+function clamp0113(value2) {
   return Math.max(0, Math.min(1, value2));
 }
 function cloneState(state) {
@@ -682649,7 +683539,7 @@ var init_stimulation = __esm({
           ...DEFAULT_STATE,
           ...state,
           phase: normalizePhase(state.phase) ?? DEFAULT_STATE.phase,
-          attention: clamp0112(Number.isFinite(state.attention) ? Number(state.attention) : DEFAULT_STATE.attention),
+          attention: clamp0113(Number.isFinite(state.attention) ? Number(state.attention) : DEFAULT_STATE.attention),
           updatedAtMs: Number.isFinite(state.updatedAtMs) ? Number(state.updatedAtMs) : now2,
           lastStimulusAtMs: Number.isFinite(state.lastStimulusAtMs) ? Number(state.lastStimulusAtMs) : now2,
           messagesSinceAnalysis: Math.max(0, Math.floor(Number(state.messagesSinceAnalysis ?? 0))),
@@ -682690,11 +683580,11 @@ var init_stimulation = __esm({
       applyAgentDecision(channelId, decision2, nowMs = Date.now()) {
         const state = this.stateFor(channelId, nowMs);
         if (Number.isFinite(decision2.attentionScore)) {
-          state.attention = clamp0112(Number(decision2.attentionScore));
+          state.attention = clamp0113(Number(decision2.attentionScore));
         } else if (Number.isFinite(decision2.attentionDelta)) {
-          state.attention = clamp0112(state.attention + Number(decision2.attentionDelta));
+          state.attention = clamp0113(state.attention + Number(decision2.attentionDelta));
         } else {
-          state.attention = clamp0112(state.attention + (decision2.shouldReply ? 0.22 : -0.1));
+          state.attention = clamp0113(state.attention + (decision2.shouldReply ? 0.22 : -0.1));
         }
         if (decision2.phase) {
           state.attention = Math.max(state.attention, PHASE_FLOORS[decision2.phase]);
@@ -682750,7 +683640,7 @@ var init_stimulation = __esm({
 });
 
 // packages/cli/src/tui/pid-controller.ts
-function clamp0113(x) {
+function clamp0114(x) {
   if (!Number.isFinite(x)) return 0;
   if (x < 0) return 0;
   if (x > 1) return 1;
@@ -682814,7 +683704,7 @@ var init_pid_controller = __esm({
         const dt = st.lastSampleAt > 0 ? now2 - st.lastSampleAt : 1e3;
         const derivative = dt > 0 ? (error - st.lastError) / dt : 0;
         const u = st.config.kp * error + st.config.ki * st.integral + st.config.kd * derivative;
-        st.output = clamp0113(st.output + u);
+        st.output = clamp0114(st.output + u);
         st.lastError = error;
         st.lastSampleAt = now2;
         st.samples += 1;
@@ -683343,7 +684233,7 @@ function buildReplyOpportunities(input, openQuestions) {
 function daydreamOpportunityId(input, trigger) {
   return createHash42("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
 }
-function clamp0114(value2) {
+function clamp0115(value2) {
   if (!Number.isFinite(value2)) return 0;
   return Math.max(0, Math.min(1, value2));
 }
@@ -683360,7 +684250,7 @@ function pushStimulationSignal(signals, signal, source, weight) {
   signals.push({
     signal: cleanSignal,
     source: cleanSource,
-    weight: clamp0114(weight)
+    weight: clamp0115(weight)
   });
 }
 function buildMetaAnalysisSignals(input) {
@@ -683490,7 +684380,7 @@ function buildCuriosityThreads(input, openQuestions, stimulationSignals) {
       question: text2.endsWith("?") || text2.endsWith("？") ? text2 : `What should be learned or clarified from: ${text2 || entry.mediaSummary || "recent media"}?`,
       rationale: "Human curiosity, uncertainty, or multimodal content makes this a useful idle exploration target.",
       sourceMessages: messageId,
-      intensity: clamp0114(0.5 + replyBoost + mediaBoost + questionBoost)
+      intensity: clamp0115(0.5 + replyBoost + mediaBoost + questionBoost)
     });
   }
   for (const question of openQuestions.slice(-4)) {
@@ -683513,7 +684403,7 @@ function buildCuriosityThreads(input, openQuestions, stimulationSignals) {
       question: `Is there a useful clarification or memory consolidation around ${strongest.source}?`,
       rationale: "Strongest stimulation signal can seed a low-intrusion reflection target.",
       sourceMessages: [],
-      intensity: clamp0114(strongest.weight * 0.72)
+      intensity: clamp0115(strongest.weight * 0.72)
     });
   }
   return threads.sort((a2, b) => b.intensity - a2.intensity).slice(0, 8);
@@ -683593,7 +684483,7 @@ function buildOutreachPlans(input, curiosityThreads) {
       purpose: "Continue the public thread only when the live model judges that the group would benefit from a concise follow-up.",
       draftIntent: "Ask one concrete clarification, offer one useful synthesis, or stay silent if the room has moved on.",
       gate: "model_decision",
-      confidence: clamp0114(thread.intensity * 0.86)
+      confidence: clamp0115(thread.intensity * 0.86)
     });
     const participant = participantForThread(input, thread);
     if (!participant) continue;
@@ -683605,7 +684495,7 @@ function buildOutreachPlans(input, curiosityThreads) {
       purpose: "Offer a one-to-one follow-up only if private contact is allowed and the issue is personal, unresolved, or better handled outside the group.",
       draftIntent: "Reference the public thread briefly, ask permission to continue privately, and do not reveal hidden meta-analysis.",
       gate: "admin_review",
-      confidence: clamp0114(thread.intensity * 0.58)
+      confidence: clamp0115(thread.intensity * 0.58)
     });
   }
   return plans.slice(0, 8);
@@ -684937,7 +685827,7 @@ function numberOr(value2, fallback) {
 function isNumber(value2) {
   return typeof value2 === "number" && Number.isFinite(value2);
 }
-function clamp0115(value2) {
+function clamp0116(value2) {
   return Math.max(0, Math.min(1, Number.isFinite(value2) ? value2 : 0));
 }
 function iso(ts) {
@@ -685121,8 +686011,8 @@ function normalizeRelationship(raw) {
     kind: value2.kind,
     fromKey: String(value2.fromKey),
     toKey: String(value2.toKey),
-    confidence: clamp0115(numberOr(value2.confidence, 0)),
-    weight: clamp0115(numberOr(value2.weight, 0)),
+    confidence: clamp0116(numberOr(value2.confidence, 0)),
+    weight: clamp0116(numberOr(value2.weight, 0)),
     firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
     lastSeenAt: numberOr(value2.lastSeenAt, Date.now()),
     evidenceMessageIds: Array.isArray(value2.evidenceMessageIds) ? value2.evidenceMessageIds.filter(isNumber).slice(-40) : [],
@@ -685141,7 +686031,7 @@ function normalizePreferences(raw) {
       if (!evidence || typeof evidence !== "object") continue;
       out[actorKey][key] = {
         value: Math.max(-1, Math.min(1, numberOr(evidence.value, 0))),
-        confidence: clamp0115(numberOr(evidence.confidence, 0)),
+        confidence: clamp0116(numberOr(evidence.confidence, 0)),
         updatedAt: numberOr(evidence.updatedAt, Date.now()),
         evidenceMessageIds: Array.isArray(evidence.evidenceMessageIds) ? evidence.evidenceMessageIds.filter(isNumber).slice(-12) : [],
         note: compactOptional(evidence.note, 220)
@@ -685155,7 +686045,7 @@ function normalizePreferences(raw) {
         out[actorKey].replyMode = {
           mode,
           scope: normalizeReplyPreferenceScope(record["scope"]),
-          confidence: clamp0115(numberOr(record["confidence"], 0.8)),
+          confidence: clamp0116(numberOr(record["confidence"], 0.8)),
           updatedAt: numberOr(record["updatedAt"], Date.now()),
           evidenceMessageIds: Array.isArray(record["evidenceMessageIds"]) ? record["evidenceMessageIds"].filter(isNumber).slice(-12) : [],
           note: compactOptional(record["note"], 220),
@@ -685245,7 +686135,7 @@ function normalizeOutcome2(raw) {
     replyToMessageId: typeof value2.replyToMessageId === "number" ? value2.replyToMessageId : void 0,
     route: value2.route === "action" ? "action" : "chat",
     shouldReply: value2.shouldReply === true,
-    confidence: clamp0115(numberOr(value2.confidence, 0)),
+    confidence: clamp0116(numberOr(value2.confidence, 0)),
     reason: compact3(value2.reason || "", 280),
     source: compact3(value2.source || "unknown", 80),
     silentDisposition: compactOptional(value2.silentDisposition, 280),
@@ -685257,7 +686147,7 @@ function normalizeOutcome2(raw) {
     scenarioNote: compactOptional(value2.scenarioNote, 360),
     scenarioId: compactOptional(value2.scenarioId, 160),
     scenarioLabel: compactOptional(value2.scenarioLabel, 160),
-    scenarioConfidence: typeof value2.scenarioConfidence === "number" && Number.isFinite(value2.scenarioConfidence) ? clamp0115(value2.scenarioConfidence) : void 0,
+    scenarioConfidence: typeof value2.scenarioConfidence === "number" && Number.isFinite(value2.scenarioConfidence) ? clamp0116(value2.scenarioConfidence) : void 0,
     scenarioObjective: compactOptional(value2.scenarioObjective, 360),
     scenarioStateLoop: compactOptional(value2.scenarioStateLoop, 360),
     salienceSignals: Array.isArray(value2.salienceSignals) ? value2.salienceSignals.map(String).slice(0, 16) : [],
@@ -685275,7 +686165,7 @@ function normalizeDaydreamOpportunity(raw) {
     artifactId: String(value2.artifactId || "unknown"),
     generatedAt: String(value2.generatedAt || (/* @__PURE__ */ new Date()).toISOString()),
     trigger: compact3(value2.trigger || "", 240),
-    confidence: clamp0115(numberOr(value2.confidence, 0)),
+    confidence: clamp0116(numberOr(value2.confidence, 0)),
     lifecycle,
     firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
     updatedAt: numberOr(value2.updatedAt, Date.now()),
@@ -685332,7 +686222,7 @@ function commitTelegramSocialDecision(state, input) {
     replyToMessageId: input.replyToMessageId,
     route: input.route,
     shouldReply: input.shouldReply,
-    confidence: clamp0115(input.confidence),
+    confidence: clamp0116(input.confidence),
     reason: compact3(input.reason, 280),
     source: compact3(input.source, 80),
     silentDisposition: compactOptional(input.silentDisposition, 280),
@@ -685344,7 +686234,7 @@ function commitTelegramSocialDecision(state, input) {
     scenarioNote: compactOptional(input.scenarioNote, 360),
     scenarioId: compactOptional(input.scenarioId, 160),
     scenarioLabel: compactOptional(input.scenarioLabel, 160),
-    scenarioConfidence: input.scenarioConfidence === void 0 ? void 0 : clamp0115(input.scenarioConfidence),
+    scenarioConfidence: input.scenarioConfidence === void 0 ? void 0 : clamp0116(input.scenarioConfidence),
     scenarioObjective: compactOptional(input.scenarioObjective, 360),
     scenarioStateLoop: compactOptional(input.scenarioStateLoop, 360),
     salienceSignals: [...new Set((input.salienceSignals ?? []).map(String))].slice(0, 16),
@@ -685368,7 +686258,7 @@ function registerDaydreamOpportunities(state, opportunities, now2 = Date.now())
       artifactId: opportunity.artifactId || "unknown",
       generatedAt: opportunity.generatedAt || new Date(now2).toISOString(),
       trigger: compact3(opportunity.trigger, 240),
-      confidence: clamp0115(opportunity.confidence),
+      confidence: clamp0116(opportunity.confidence),
       lifecycle: "proposed",
       firstSeenAt: now2,
       updatedAt: now2,
@@ -685378,7 +686268,7 @@ function registerDaydreamOpportunities(state, opportunities, now2 = Date.now())
     };
     if (existing) {
       item.trigger = compact3(opportunity.trigger, 240) || item.trigger;
-      item.confidence = clamp0115(opportunity.confidence);
+      item.confidence = clamp0116(opportunity.confidence);
       item.updatedAt = now2;
     }
     state.daydreamOpportunities[id2] = item;
@@ -685405,7 +686295,7 @@ function setTelegramReplyModePreference(state, input) {
   const next = {
     mode: input.mode,
     scope: input.scope,
-    confidence: Math.max(existing?.confidence ?? 0, clamp0115(input.confidence ?? 0.84)),
+    confidence: Math.max(existing?.confidence ?? 0, clamp0116(input.confidence ?? 0.84)),
     updatedAt: now2,
     evidenceMessageIds: appendUnique(existing?.evidenceMessageIds ?? [], input.messageId, 12),
     note: compactOptional(input.note, 220),
@@ -685585,8 +686475,8 @@ function upsertRelationship(state, kind, fromKey, toKey, messageId, confidence2,
     evidenceMessageIds: [],
     source
   };
-  edge.confidence = Math.max(edge.confidence, clamp0115(confidence2));
-  edge.weight = Math.min(1, edge.weight + 0.12 + clamp0115(confidence2) * 0.2);
+  edge.confidence = Math.max(edge.confidence, clamp0116(confidence2));
+  edge.weight = Math.min(1, edge.weight + 0.12 + clamp0116(confidence2) * 0.2);
   edge.lastSeenAt = now2;
   edge.evidenceMessageIds = appendUnique(edge.evidenceMessageIds, messageId, 40);
   edge.note = compactOptional(note, 260) || edge.note;
@@ -685628,7 +686518,7 @@ function setPreference(vector, key, value2, confidence2, messageId, now2, note)
   const existing = vector[key];
   vector[key] = {
     value: existing ? existing.value * 0.7 + value2 * 0.3 : value2,
-    confidence: Math.max(existing?.confidence ?? 0, clamp0115(confidence2)),
+    confidence: Math.max(existing?.confidence ?? 0, clamp0116(confidence2)),
     updatedAt: now2,
     evidenceMessageIds: appendUnique(existing?.evidenceMessageIds ?? [], messageId, 12),
     note
@@ -685810,7 +686700,7 @@ async function queryVisionModel(modelName, imagePath, prompt = "Describe what yo
     return "";
   }
 }
-function clamp0116(value2, fallback = 0) {
+function clamp0117(value2, fallback = 0) {
   if (typeof value2 !== "number" || !Number.isFinite(value2)) return fallback;
   return Math.max(0, Math.min(1, value2));
 }
@@ -685827,9 +686717,9 @@ function parseVisualMemoryRecognize(raw) {
     label: String(match.label).trim(),
     objectId: typeof match.object_id === "string" ? match.object_id : void 0,
     matchedAlias: typeof match.matched_alias === "string" ? match.matched_alias : void 0,
-    blendedScore: clamp0116(match.blended_score, 0),
-    imageSimilarity: typeof match.image_similarity === "number" ? clamp0116(match.image_similarity, 0) : void 0,
-    textSimilarity: typeof match.text_similarity === "number" ? clamp0116(match.text_similarity, 0) : void 0
+    blendedScore: clamp0117(match.blended_score, 0),
+    imageSimilarity: typeof match.image_similarity === "number" ? clamp0117(match.image_similarity, 0) : void 0,
+    textSimilarity: typeof match.text_similarity === "number" ? clamp0117(match.text_similarity, 0) : void 0
   })).sort((a2, b) => b.blendedScore - a2.blendedScore).slice(0, 5);
 }
 function formatVisualFamiliarityContext(result) {
@@ -690301,7 +691191,7 @@ ${message2}`)
       }
       telegramModelCachedBytes(dependencies) {
         return dependencies.reduce(
-          (sum, dep) => sum + measureRepoCacheBytes(dep),
+          (sum2, dep) => sum2 + measureRepoCacheBytes(dep),
           0
         );
       }
@@ -690740,7 +691630,7 @@ install/prewarm: ${model.install}` : ""
           return `Deleted Ollama weights for ${model.id}.`;
         }
         const results = model.dependencies.map((repo) => deleteCachedModel(repo));
-        const freed = results.reduce((sum, item) => sum + item.bytesFreed, 0);
+        const freed = results.reduce((sum2, item) => sum2 + item.bytesFreed, 0);
         const lines = results.map(
           (item) => `- ${item.repo}: ${item.bytesFreed > 0 ? formatModelBytes(item.bytesFreed) : "not cached"}`
         );
@@ -704590,7 +705480,7 @@ __export(voicechat_exports, {
   isLikelyAgentSpeechEcho: () => isLikelyAgentSpeechEcho
 });
 import { EventEmitter as EventEmitter12 } from "node:events";
-function clamp0117(x) {
+function clamp0118(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -704643,9 +705533,9 @@ function computeSignalFromText(text2, confidence2) {
   score -= repeatingCharPenalty(t2) * 0.4;
   score -= gibberishTokenPenalty(t2) * 0.8;
   if (typeof confidence2 === "number" && !Number.isNaN(confidence2)) {
-    score = 0.7 * score + 0.3 * clamp0117(confidence2);
+    score = 0.7 * score + 0.3 * clamp0118(confidence2);
   }
-  return clamp0117(score);
+  return clamp0118(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -705139,7 +706029,7 @@ Rules:
             }
           }, MAX_SEGMENT_MS);
         }
-        const signalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp0117(snr) : computeSignalFromText(text2, confidence2);
+        const signalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp0118(snr) : computeSignalFromText(text2, confidence2);
         this.lastSignalScore = signalScore;
         if (consensus !== void 0) {
           this.consensusMetadataSeen = true;
@@ -732226,10 +733116,10 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           { encoding: "utf8", timeout: 3e3, stdio: "pipe" }
         );
         for (const line of util2.trim().split("\n")) {
-          const [pct, used, total] = line.split(",").map((s2) => parseInt(s2.trim(), 10));
-          if (!isNaN(pct) && !isNaN(used) && !isNaN(total)) {
+          const [pct2, used, total] = line.split(",").map((s2) => parseInt(s2.trim(), 10));
+          if (!isNaN(pct2) && !isNaN(used) && !isNaN(total)) {
             gpuUtil.push({
-              gpu_pct: pct,
+              gpu_pct: pct2,
               vram_used_gb: Math.round(used / 1024 * 10) / 10,
               vram_total_gb: Math.round(total / 1024)
             });
@@ -735358,12 +736248,12 @@ function sampleGpuUtil() {
     const arr = [];
     for (const line of out.trim().split("\n")) {
       const [pctS, usedS, totalS] = line.split(",").map((s2) => s2.trim());
-      const pct = parseInt(pctS, 10);
+      const pct2 = parseInt(pctS, 10);
       const usedGb = Math.round(parseInt(usedS, 10) / 1024 * 10) / 10;
       const totalGb = Math.round(parseInt(totalS, 10) / 1024);
-      if (!isNaN(pct) && !isNaN(usedGb) && !isNaN(totalGb))
+      if (!isNaN(pct2) && !isNaN(usedGb) && !isNaN(totalGb))
         arr.push({
-          gpu_pct: pct,
+          gpu_pct: pct2,
           vram_used_gb: usedGb,
           vram_total_gb: totalGb
         });