omnius 1.0.166 → 1.0.167

package/dist/index.js

@@ -97800,7 +97800,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash35 } = __require("crypto");
+    var { createHash: createHash36 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -98111,14 +98111,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash35("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash36("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash35("sha256").update(result).digest("base64url");
+          return createHash36("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -240798,7 +240798,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes29, createHash: createHash35 } = __require("crypto");
+    var { randomBytes: randomBytes29, createHash: createHash36 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -241458,7 +241458,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash35("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash36("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -241825,7 +241825,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash35 } = __require("crypto");
+    var { createHash: createHash36 } = __require("crypto");
     var extension3 = require_extension2();
     var PerMessageDeflate3 = require_permessage_deflate2();
     var subprotocol3 = require_subprotocol();
@@ -242126,7 +242126,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash35("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash36("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -254933,13 +254933,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash35 } = await import("node:crypto");
+          const { createHash: createHash36 } = await import("node:crypto");
           const snapshotDir = join33(this.cwd, ".omnius", "identity", "snapshots");
           await mkdir7(snapshotDir, { recursive: true });
           const version4 = this.selfState.version;
           const snapshotPath = join33(snapshotDir, `v${version4}.json`);
           await writeFile12(snapshotPath, snapshot, "utf8");
-          const hash = createHash35("sha256").update(snapshot).digest("hex");
+          const hash = createHash36("sha256").update(snapshot).digest("hex");
           await writeFile12(join33(this.cwd, ".omnius", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -255072,8 +255072,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash35 } = __require("node:crypto");
-        const machineId = createHash35("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash36 } = __require("node:crypto");
+        const machineId = createHash36("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `omnius-${machineId}`,
           version: 1,
@@ -255155,9 +255155,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash35 } = await import("node:crypto");
+            const { createHash: createHash36 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash35("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash36("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join33(this.cwd, ".omnius", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -534419,7 +534419,7 @@ var init_world_state_disk_scan = __esm({
 import { existsSync as existsSync70, statSync as statSync29 } from "node:fs";
 import { isAbsolute as isAbsolute4, join as join83 } from "node:path";
 function tokenize3(content) {
-  const STOP = /* @__PURE__ */ new Set([
+  const STOP2 = /* @__PURE__ */ new Set([
     "the",
     "and",
     "or",
@@ -534450,7 +534450,7 @@ function tokenize3(content) {
     "into",
     "from"
   ]);
-  return Array.from(new Set(content.toLowerCase().split(/[^a-z0-9]+/g).filter((s2) => s2.length >= 3 && !STOP.has(s2))));
+  return Array.from(new Set(content.toLowerCase().split(/[^a-z0-9]+/g).filter((s2) => s2.length >= 3 && !STOP2.has(s2))));
 }
 function heuristicMatch(rel, tokens) {
   if (tokens.length === 0)
@@ -543572,6 +543572,480 @@ var init_embeddingDrift = __esm({
   }
 });
 
+// packages/memory/dist/semanticContext.js
+import { createHash as createHash20 } from "node:crypto";
+function estimateTokens(text) {
+  return Math.max(0, Math.ceil((text || "").length / 4));
+}
+function estimateContextTokens(content, supplied) {
+  return Number.isFinite(supplied) ? Math.max(0, Math.ceil(supplied)) : estimateTokens(content);
+}
+function stableId(parts) {
+  return createHash20("sha256").update(parts.join("\n")).digest("hex").slice(0, 16);
+}
+function clamp016(x) {
+  if (!Number.isFinite(x))
+    return 0;
+  if (x < 0)
+    return 0;
+  if (x > 1)
+    return 1;
+  return x;
+}
+function tokenCount(item) {
+  const supplied = Number.isFinite(item.tokenCount) ? item.tokenCount : item.tokenEstimate;
+  return estimateContextTokens(item.content, supplied);
+}
+function itemId(item) {
+  return item.id ?? `ctx_${stableId([item.source, item.kind, item.content.slice(0, 240)])}`;
+}
+function isConsolidated(item) {
+  if (item.consolidated !== void 0)
+    return item.consolidated;
+  const metadataConsolidated = item.metadata?.["consolidated"] ?? item.metadata?.["isConsolidated"];
+  if (typeof metadataConsolidated === "boolean")
+    return metadataConsolidated;
+  const haystack = `${item.kind} ${item.source} ${String(item.metadata?.["stage"] ?? "")}`.toLowerCase();
+  return /\b(gist|summary|semantic|memory|reflection|self_model|social_state|compressed|context_frame|anchor)\b/.test(haystack);
+}
+function addBucket(buckets, key, tokens, consolidated) {
+  const k = key || "unknown";
+  const bucket = buckets[k] ?? { items: 0, itemCount: 0, tokens: 0, totalTokens: 0, rawTokens: 0, consolidatedTokens: 0 };
+  bucket.items += 1;
+  bucket.itemCount += 1;
+  bucket.tokens += tokens;
+  bucket.totalTokens += tokens;
+  if (consolidated)
+    bucket.consolidatedTokens += tokens;
+  else
+    bucket.rawTokens += tokens;
+  buckets[k] = bucket;
+}
+function buildContextPressureSnapshot(items, opts = {}) {
+  const targetRawTokenBudget = Math.max(0, Math.floor(opts.targetRawTokenBudget ?? 2e3));
+  const perSource = {};
+  const perKind = {};
+  let rawTokens = 0;
+  let consolidatedTokens = 0;
+  for (const item of items) {
+    const tokens = tokenCount(item);
+    const consolidated = isConsolidated(item);
+    if (consolidated)
+      consolidatedTokens += tokens;
+    else
+      rawTokens += tokens;
+    addBucket(perSource, item.source, tokens, consolidated);
+    addBucket(perKind, item.kind, tokens, consolidated);
+  }
+  const totalTokens = rawTokens + consolidatedTokens;
+  const compressionTargetTokens = Math.ceil(rawTokens * 0.6);
+  return {
+    generatedAt: opts.now ?? Date.now(),
+    itemCount: items.length,
+    semanticChunkCount: opts.semanticChunkCount ?? new SemanticChunker().chunk(items, { now: opts.now }).length,
+    totalTokens,
+    rawTokens,
+    consolidatedTokens,
+    rawRatio: totalTokens > 0 ? rawTokens / totalTokens : 0,
+    consolidatedRatio: totalTokens > 0 ? consolidatedTokens / totalTokens : 0,
+    compressionTargetTokens,
+    targetRawTokenBudget,
+    rawTokensToTarget: Math.max(0, rawTokens - targetRawTokenBudget),
+    perSource,
+    perKind
+  };
+}
+function extractSemanticEntities(text) {
+  const out = /* @__PURE__ */ new Set();
+  const add2 = (raw) => {
+    const value2 = raw.trim().replace(/[.,;:!?)]$/, "");
+    if (value2.length < 2)
+      return;
+    if (STOP.has(value2.toLowerCase()))
+      return;
+    out.add(value2);
+  };
+  for (const m2 of text.matchAll(/(?:[\w.-]+\/)+[\w./-]+\.[A-Za-z0-9]+|[\w.-]+\.(?:ts|tsx|js|jsx|json|md|py|rs|go|c|cpp|h|css|html)\b/g))
+    add2(m2[0]);
+  for (const m2 of text.matchAll(/@[A-Za-z0-9_]{2,}/g))
+    add2(m2[0].toLowerCase());
+  for (const m2 of text.matchAll(/\b[A-Za-z_][A-Za-z0-9_]*(?:Error|Exception|Failure|Failed)\b/g))
+    add2(m2[0]);
+  for (const m2 of text.matchAll(/\b[a-z][a-z0-9]*(?:[A-Z][A-Za-z0-9]+)+\b/g))
+    add2(m2[0]);
+  for (const m2 of text.matchAll(/\b[A-Z][A-Za-z0-9]*(?:[A-Z][A-Za-z0-9]*)?\b/g))
+    add2(m2[0]);
+  for (const m2 of text.matchAll(/\b(?:memory|context|telegram|router|tool|shell|diagnostic|consolidation|forgetting|chunk|reply|notes|voice|trust|semantic)\b/gi))
+    add2(m2[0].toLowerCase());
+  return [...out].slice(0, 24);
+}
+function semanticLabelFor(item) {
+  const explicit = item.semanticLabels?.[0] || (Array.isArray(item.metadata?.["semanticLabels"]) ? String(item.metadata["semanticLabels"][0] ?? "") : "");
+  if (explicit.trim())
+    return explicit.trim().toLowerCase();
+  const h = `${item.kind} ${item.source} ${item.content}`.toLowerCase();
+  if (/telegram|@\w|reply|chat|relationship|social/.test(h))
+    return "telegram conversation and relationship state";
+  if (/error|failed|failure|diagnostic|stderr|exit code|exception/.test(h))
+    return "diagnostic errors and recovery";
+  if (/todo|task|goal|plan|current step|completed/.test(h))
+    return "active task and plan";
+  if (/memory|gist|reflection|lesson|prior experience/.test(h))
+    return "retrieved memory and lessons";
+  if (/tool|shell|command|output|stdout|stderr/.test(h))
+    return "tool results and execution evidence";
+  if (/identity|persona|voice|policy|instruction|system prompt/.test(h))
+    return "identity and behavioral constraints";
+  if (/(?:[\w.-]+\/)+[\w./-]+|\.ts\b|\.tsx\b|\.js\b|function|class|export/.test(h))
+    return "codebase files and symbols";
+  return "general working context";
+}
+function itemUtility(item, now) {
+  const priority = (item.priority ?? 0) / 100;
+  const importance = (item.importance ?? 5) / 10;
+  const strength = Math.min(1, Math.log2(Math.max(1, item.strength ?? 1)) / 4);
+  const reuse = Math.min(1, (item.reuseCount ?? 0) / 8);
+  const age = item.timestamp ? Math.max(0, now - item.timestamp) : 0;
+  const recency = item.timestamp ? Math.exp(-age / (24 * 60 * 6e4)) : 0.5;
+  return clamp016(0.25 + priority * 0.25 + importance * 0.25 + strength * 0.12 + reuse * 0.08 + recency * 0.05);
+}
+function stalenessFor(items, now) {
+  const timestamps = items.map((i2) => i2.timestamp).filter((v) => Number.isFinite(v));
+  if (timestamps.length === 0)
+    return 0.5;
+  const newest = Math.max(...timestamps);
+  return clamp016(1 - Math.exp(-Math.max(0, now - newest) / (6 * 60 * 6e4)));
+}
+function summarize(items, maxChars = 420) {
+  const ranked = [...items].sort((a2, b) => (b.priority ?? 0) - (a2.priority ?? 0) || tokenCount(b) - tokenCount(a2));
+  const parts = [];
+  for (const item of ranked.slice(0, 4)) {
+    const text = item.content.replace(/\s+/g, " ").trim();
+    if (!text)
+      continue;
+    parts.push(text.length > 140 ? text.slice(0, 139).trimEnd() + "..." : text);
+    if (parts.join(" ").length >= maxChars)
+      break;
+  }
+  const summary = parts.join(" ");
+  return summary.length > maxChars ? summary.slice(0, maxChars - 3).trimEnd() + "..." : summary;
+}
+function openQuestionsFor(items) {
+  const out = [];
+  for (const item of items) {
+    for (const line of item.content.split(/\n+/)) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      if (/[?]$|\b(unresolved|blocked|unknown|gap|needs?|todo|fixme)\b/i.test(trimmed)) {
+        out.push(trimmed.replace(/\s+/g, " ").slice(0, 180));
+      }
+      if (out.length >= 6)
+        return [...new Set(out)];
+    }
+  }
+  return [...new Set(out)];
+}
+function entityOverlap(a2, b) {
+  const as = new Set(a2.map((v) => v.toLowerCase()));
+  const bs = new Set(b.map((v) => v.toLowerCase()));
+  if (as.size === 0 || bs.size === 0)
+    return 0;
+  let inter = 0;
+  for (const x of as)
+    if (bs.has(x))
+      inter++;
+  return inter / Math.min(as.size, bs.size);
+}
+function groupUtility(items, now) {
+  if (items.length === 0)
+    return 0;
+  const raw = items.reduce((sum, item) => sum + itemUtility(item, now), 0) / items.length;
+  const evidenceBoost = Math.min(0.2, Math.log1p(items.length) / 15);
+  return clamp016(raw + evidenceBoost);
+}
+function chunkItemLike(chunk) {
+  const newest = Math.max(0, ...chunk.items.map((i2) => i2.timestamp ?? 0));
+  return {
+    id: chunk.id,
+    source: chunk.sourceKinds.join(","),
+    kind: chunk.kinds.join(","),
+    content: chunk.summary,
+    tokenCount: chunk.tokenEstimate,
+    priority: Math.round(chunk.utilityScore * 100),
+    timestamp: newest || void 0,
+    importance: chunk.items.reduce((s2, i2) => s2 + (i2.importance ?? 5), 0) / Math.max(1, chunk.items.length),
+    strength: chunk.items.reduce((s2, i2) => s2 + (i2.strength ?? 1), 0) / Math.max(1, chunk.items.length),
+    reuseCount: chunk.items.reduce((s2, i2) => s2 + (i2.reuseCount ?? 0), 0),
+    entities: chunk.entities
+  };
+}
+function buildActiveForgettingReport(chunksOrItems, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const items = chunksOrItems.map((entry) => "summary" in entry ? chunkItemLike(entry) : entry);
+  const selectiveForgetCandidates = [];
+  const rehearseCandidates = [];
+  const presentButUnused = [];
+  const interferencePairs = [];
+  for (const item of items) {
+    const utility = itemUtility(item, now);
+    const label = semanticLabelFor(item);
+    const unused = (item.reuseCount ?? 0) === 0 && (item.strength ?? 1) <= 1.2;
+    const ageMs = item.lastRetrieved ? Math.max(0, now - item.lastRetrieved) : item.timestamp ? Math.max(0, now - item.timestamp) : Infinity;
+    if (utility < 0.42 && (item.importance ?? 5) <= 5) {
+      selectiveForgetCandidates.push({ id: itemId(item), label, score: 1 - utility, reason: "low utility, low importance, or stale context" });
+    }
+    if ((item.importance ?? 5) >= 7 && ((item.reuseCount ?? 0) > 0 || (item.strength ?? 1) > 1) && ageMs > 30 * 6e4) {
+      rehearseCandidates.push({ id: itemId(item), label, score: utility, reason: "important memory has evidence of reuse but is aging" });
+    }
+    if (unused) {
+      presentButUnused.push({ id: itemId(item), label, score: utility, reason: "present in context without reuse evidence" });
+    }
+  }
+  for (let i2 = 0; i2 < items.length; i2++) {
+    for (let j = i2 + 1; j < items.length; j++) {
+      const a2 = items[i2];
+      const b = items[j];
+      const aEnt = a2.entities ?? extractSemanticEntities(a2.content);
+      const bEnt = b.entities ?? extractSemanticEntities(b.content);
+      const overlap = entityOverlap(aEnt, bEnt);
+      const contradiction = /\b(no longer|superseded|instead|not|failed|wrong|obsolete)\b/i.test(`${a2.content}
+${b.content}`);
+      const score = overlap + (contradiction ? 0.35 : 0);
+      if (score >= 0.45 && a2.content.trim() !== b.content.trim()) {
+        const aId = itemId(a2);
+        const bId = itemId(b);
+        const sharedEntities = aEnt.filter((entity) => bEnt.map((v) => v.toLowerCase()).includes(entity.toLowerCase()));
+        interferencePairs.push({
+          a: aId,
+          b: bId,
+          aId,
+          bId,
+          aLabel: semanticLabelFor(a2),
+          bLabel: semanticLabelFor(b),
+          score: clamp016(score),
+          overlap: clamp016(score),
+          sharedEntities,
+          reason: contradiction ? "overlapping entities with supersession/negation language" : "overlapping entities compete for recall"
+        });
+      }
+    }
+  }
+  const useful = items.filter((i2) => itemUtility(i2, now) >= 0.5 || (i2.reuseCount ?? 0) > 0).length;
+  const interferencePenalty = Math.min(0.25, interferencePairs.length * 0.03);
+  const activeRetentionEstimate = clamp016(items.length === 0 ? 1 : useful / items.length - interferencePenalty);
+  return {
+    generatedAt: now,
+    activeRetentionEstimate,
+    selectiveForgetCandidates: selectiveForgetCandidates.sort((a2, b) => b.score - a2.score).slice(0, 12),
+    rehearseCandidates: rehearseCandidates.sort((a2, b) => b.score - a2.score).slice(0, 12),
+    presentButUnused: presentButUnused.sort((a2, b) => a2.score - b.score).slice(0, 12),
+    interferencePairs: interferencePairs.sort((a2, b) => b.score - a2.score).slice(0, 20)
+  };
+}
+function shouldTriggerContextConsolidation(snapshot, forgetting, opts = {}) {
+  const minRawTokens = opts.minRawTokens ?? snapshot.targetRawTokenBudget;
+  const maxRawRatio = opts.maxRawRatio ?? 0.35;
+  const minRetention = opts.minRetention ?? 0.7;
+  const reasons = [];
+  let score = 0;
+  if (snapshot.rawTokens > minRawTokens) {
+    reasons.push(`raw tokens ${snapshot.rawTokens} exceed target ${minRawTokens}`);
+    score += 0.4;
+  }
+  if (snapshot.rawRatio > maxRawRatio) {
+    reasons.push(`raw ratio ${snapshot.rawRatio.toFixed(2)} exceeds ${maxRawRatio.toFixed(2)}`);
+    score += 0.25;
+  }
+  if (snapshot.rawTokensToTarget > 0) {
+    reasons.push(`${snapshot.rawTokensToTarget} raw tokens must move to reach target`);
+    score += Math.min(0.25, snapshot.rawTokensToTarget / Math.max(1, snapshot.rawTokens));
+  }
+  if (forgetting && forgetting.activeRetentionEstimate < minRetention) {
+    reasons.push(`active retention estimate ${forgetting.activeRetentionEstimate.toFixed(2)} below ${minRetention.toFixed(2)}`);
+    score += 0.25;
+  }
+  if (forgetting && forgetting.interferencePairs.length > 0) {
+    reasons.push(`${forgetting.interferencePairs.length} interference pair(s) detected`);
+    score += Math.min(0.2, forgetting.interferencePairs.length * 0.04);
+  }
+  const minScore = opts.minScore ?? 0.45;
+  return { shouldConsolidate: score >= minScore, reasons, score: clamp016(score) };
+}
+function ingestContextFeedbackMarkdown(markdown, opts = {}) {
+  const metrics2 = {};
+  for (const line of markdown.split(/\n/)) {
+    const m2 = line.match(/^\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|/);
+    if (!m2)
+      continue;
+    const key = m2[1].trim();
+    const value2 = m2[2].trim();
+    if (!key || key === "Metric" || /^-+$/.test(key))
+      continue;
+    metrics2[key] = parseMetricValue2(value2);
+  }
+  const gaps = [];
+  const gapRegex = /^##\s+GAP\s+(\d+):\s+(.+?)\s*$/gim;
+  const matches = [...markdown.matchAll(gapRegex)];
+  for (let i2 = 0; i2 < matches.length; i2++) {
+    const match = matches[i2];
+    const start2 = match.index + match[0].length;
+    const end = matches[i2 + 1]?.index ?? markdown.search(/\n## Summary:/);
+    const body = markdown.slice(start2, end === -1 ? void 0 : end).trim();
+    const title = match[2].trim();
+    const labels = [
+      "context_window",
+      title.toLowerCase().includes("sleep") ? "dynamic_consolidation" : "",
+      title.toLowerCase().includes("forget") ? "active_forgetting" : "",
+      title.toLowerCase().includes("chunk") ? "semantic_chunking" : ""
+    ].filter(Boolean);
+    gaps.push({ id: `gap_${match[1]}`, title, body, labels, metrics: extractInlineMetrics(body) });
+  }
+  const summary = gaps.map((g) => `${g.id}=${g.title}`).join("; ");
+  const source = opts.sourcePath ?? "context-feedback";
+  const items = gaps.map((gap) => ({
+    id: `feedback_${gap.id}`,
+    source,
+    kind: "agent_feedback_gap",
+    content: `${gap.title}
+${gap.body}`,
+    consolidated: false,
+    priority: 90,
+    timestamp: opts.now,
+    importance: 8,
+    semanticLabels: gap.labels,
+    metadata: { sourcePath: opts.sourcePath, gapId: gap.id }
+  }));
+  const episode = {
+    sessionId: opts.sessionId,
+    modality: "reflection",
+    toolName: "context_feedback_ingest",
+    content: `External agent memory feedback: ${summary || "context organization gaps"}`,
+    importance: 8,
+    decayClass: "procedural",
+    metadata: {
+      kind: "context_feedback",
+      sourcePath: opts.sourcePath,
+      metrics: metrics2,
+      gaps: gaps.map(({ id, title, labels }) => ({ id, title, labels })),
+      semanticLabels: ["context_window", "dynamic_consolidation", "active_forgetting", "semantic_chunking"]
+    }
+  };
+  return { episode, items, chunkItems: items, metrics: metrics2, gaps };
+}
+function parseMetricValue2(raw) {
+  const cleaned = raw.trim().replace(/\*\*/g, "");
+  const match = cleaned.match(/-?\d[\d,]*(?:\.\d+)?/);
+  if (!match)
+    return cleaned;
+  const n2 = Number(match[0].replace(/,/g, ""));
+  return Number.isFinite(n2) ? n2 : cleaned;
+}
+function extractInlineMetrics(text) {
+  const metrics2 = {};
+  for (const line of text.split(/\n/)) {
+    const bullet = line.match(/^\s*[-*]\s*(?:\*\*)?([^:*]+?)(?:\*\*)?:\s*(.+)$/);
+    if (bullet)
+      metrics2[bullet[1].trim()] = parseMetricValue2(bullet[2]);
+    const bold = line.match(/^\s*(?:\*\*)?([^:*]+):(?:\*\*)?\s*(.+)$/);
+    if (bold)
+      metrics2[bold[1].trim()] = parseMetricValue2(bold[2]);
+  }
+  return metrics2;
+}
+var STOP, SemanticChunker, snapshotContextPressure, analyzeActiveForgetting, buildFeedbackIngestion;
+var init_semanticContext = __esm({
+  "packages/memory/dist/semanticContext.js"() {
+    "use strict";
+    STOP = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "with",
+      "that",
+      "this",
+      "from",
+      "into",
+      "have",
+      "has",
+      "was",
+      "were",
+      "will",
+      "should",
+      "would",
+      "could",
+      "about",
+      "because"
+    ]);
+    SemanticChunker = class {
+      chunk(items, options2 = {}) {
+        const maxChunks = Math.max(1, Math.floor(options2.maxChunks ?? 7));
+        const now = options2.now ?? Date.now();
+        const groups = [];
+        for (const item of items.filter((i2) => i2.content.trim())) {
+          const entities = [.../* @__PURE__ */ new Set([...item.entities ?? [], ...extractSemanticEntities(item.content)])];
+          const label = semanticLabelFor(item);
+          let target = groups.find((g) => g.label === label && (entityOverlap(g.entities, entities) >= 0.2 || g.items.length < 3));
+          if (!target) {
+            target = groups.find((g) => entityOverlap(g.entities, entities) >= 0.45);
+          }
+          if (!target) {
+            target = { label, items: [], entities: [] };
+            groups.push(target);
+          }
+          target.items.push({ ...item, entities });
+          target.entities = [.../* @__PURE__ */ new Set([...target.entities, ...entities])].slice(0, 32);
+        }
+        while (groups.length > maxChunks) {
+          groups.sort((a2, b) => groupUtility(a2.items, now) - groupUtility(b.items, now));
+          const smallest = groups.shift();
+          let bestIdx = 0;
+          let bestScore = -1;
+          for (let i2 = 0; i2 < groups.length; i2++) {
+            const score = entityOverlap(smallest.entities, groups[i2].entities) + (smallest.label === groups[i2].label ? 1 : 0);
+            if (score > bestScore) {
+              bestScore = score;
+              bestIdx = i2;
+            }
+          }
+          groups[bestIdx].items.push(...smallest.items);
+          groups[bestIdx].entities = [.../* @__PURE__ */ new Set([...groups[bestIdx].entities, ...smallest.entities])].slice(0, 32);
+        }
+        const maxSummaryChars = Math.max(180, Math.floor((options2.targetRawTokenBudget ?? 2e3) / maxChunks) * 4);
+        return groups.map((g) => this.buildChunk(g.label, g.items, g.entities, now, maxSummaryChars)).sort((a2, b) => b.utilityScore - a2.utilityScore || a2.label.localeCompare(b.label));
+      }
+      buildChunk(label, items, entities, now, maxSummaryChars) {
+        const rawTokenEstimate = items.reduce((sum, item) => sum + tokenCount(item), 0);
+        const summary = summarize(items, maxSummaryChars);
+        const tokenEstimate = Math.max(1, estimateTokens(summary));
+        const utilityScore = groupUtility(items, now);
+        const kinds = [...new Set(items.map((i2) => i2.kind))].sort();
+        const sources = [...new Set(items.map((i2) => `${i2.source}:${i2.kind}`))].sort();
+        return {
+          id: `sem_${stableId([label, ...items.map((i2) => itemId(i2)).sort()])}`,
+          label,
+          summary,
+          sourceIds: items.map((i2) => itemId(i2)),
+          entities: entities.slice(0, 16),
+          kinds,
+          sourceKinds: sources,
+          tokenEstimate,
+          rawTokenEstimate,
+          density: tokenEstimate > 0 ? rawTokenEstimate / tokenEstimate : 1,
+          utilityScore,
+          staleness: stalenessFor(items, now),
+          openQuestions: openQuestionsFor(items),
+          evidenceCount: items.length,
+          items
+        };
+      }
+    };
+    snapshotContextPressure = buildContextPressureSnapshot;
+    analyzeActiveForgetting = buildActiveForgettingReport;
+    buildFeedbackIngestion = ingestContextFeedbackMarkdown;
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
@@ -543605,18 +544079,23 @@ __export(dist_exports2, {
   RepoProfileStore: () => RepoProfileStore,
   SYMBOL_MEANINGS: () => SYMBOL_MEANINGS,
   SelfModel: () => SelfModel,
+  SemanticChunker: () => SemanticChunker,
   SocialMemoryStore: () => SocialMemoryStore,
   TaskMemoryStore: () => TaskMemoryStore,
   TemporalGraph: () => TemporalGraph,
   ToolOutcomeTracker: () => ToolOutcomeTracker,
   ToolPatternStore: () => ToolPatternStore,
   ValidationStore: () => ValidationStore,
+  analyzeActiveForgetting: () => analyzeActiveForgetting,
   applyInfluence: () => applyInfluence,
   attachTrace: () => attachTrace,
   authorityBias: () => authorityBias,
   autoDecayClass: () => autoDecayClass,
   autoImportance: () => autoImportance,
   batchLink: () => batchLink,
+  buildActiveForgettingReport: () => buildActiveForgettingReport,
+  buildContextPressureSnapshot: () => buildContextPressureSnapshot,
+  buildFeedbackIngestion: () => buildFeedbackIngestion,
   buildGist: () => buildGist,
   buildSelfTrustInfluence: () => buildSelfTrustInfluence,
   buildTrace: () => buildTrace,
@@ -543640,7 +544119,9 @@ __export(dist_exports2, {
   emptyDevelopmentalMetrics: () => emptyMetrics,
   engagementScore: () => engagementScore,
   episodeCount: () => episodeCount,
+  estimateContextTokens: () => estimateContextTokens,
   extractQueryEntities: () => extractQueryEntities,
+  extractSemanticEntities: () => extractSemanticEntities,
   extractTrace: () => extractTrace,
   findNeighbors: () => findNeighbors,
   fingerprintSignature: () => fingerprintSignature,
@@ -543651,6 +544132,7 @@ __export(dist_exports2, {
   goalHashOf: () => goalHashOf,
   importanceMultiplier: () => importanceMultiplier,
   inferDomainFromEpisode: () => inferDomainFromEpisode,
+  ingestContextFeedbackMarkdown: () => ingestContextFeedbackMarkdown,
   initDb: () => initDb,
   isSessionGist: () => isSessionGist,
   lightSleep: () => lightSleep,
@@ -543672,7 +544154,9 @@ __export(dist_exports2, {
   selectAndWalkGraphCandidate: () => selectAndWalkGraphCandidate,
   selectInnerGraphCandidates: () => selectInnerGraphCandidates,
   selfTrustFor: () => selfTrustFor,
+  shouldTriggerContextConsolidation: () => shouldTriggerContextConsolidation,
   slowWaveReplay: () => slowWaveReplay,
+  snapshotContextPressure: () => snapshotContextPressure,
   splanifoldCosine: () => cosine,
   splanifoldDeserialize: () => deserialize,
   splanifoldEvaluate: () => evaluate2,
@@ -543724,6 +544208,7 @@ var init_dist7 = __esm({
     init_stagnationRecipes();
     init_codebaseMap();
     init_embeddingDrift();
+    init_semanticContext();
   }
 });
 
@@ -546196,7 +546681,7 @@ var init_failureHandoff = __esm({
 });
 
 // packages/orchestrator/dist/context-fabric.js
-function estimateTokens(text) {
+function estimateTokens2(text) {
   return Math.ceil(text.length / 4);
 }
 function normalizeSignalContent(content) {
@@ -546213,6 +546698,54 @@ function truncateText2(text, maxChars) {
     truncated: true
   };
 }
+function compactDiagnosticValue(value2, depth = 0) {
+  if (value2 == null)
+    return value2;
+  if (typeof value2 === "string") {
+    return value2.length > 240 ? `${value2.slice(0, 237)}...` : value2;
+  }
+  if (typeof value2 === "number" || typeof value2 === "boolean")
+    return value2;
+  if (Array.isArray(value2)) {
+    if (depth >= 2)
+      return `[array:${value2.length}]`;
+    return value2.slice(0, 8).map((entry) => compactDiagnosticValue(entry, depth + 1));
+  }
+  if (typeof value2 === "object") {
+    if (depth >= 2)
+      return "[object]";
+    const out = {};
+    for (const [key, entry] of Object.entries(value2).slice(0, 12)) {
+      if (/^(content|text|prompt|messages|transcript)$/i.test(key)) {
+        out[key] = typeof entry === "string" ? `[omitted:${entry.length}]` : "[omitted]";
+      } else {
+        out[key] = compactDiagnosticValue(entry, depth + 1);
+      }
+    }
+    return out;
+  }
+  return String(value2);
+}
+function collectMetadataReports(signals) {
+  const pressureReports = [];
+  const forgettingReports = [];
+  for (const signal of signals) {
+    const metadata = signal.metadata ?? {};
+    for (const [key, value2] of Object.entries(metadata)) {
+      if (value2 == null)
+        continue;
+      if (/pressure/i.test(key))
+        pressureReports.push(compactDiagnosticValue(value2));
+      if (/forgetting|retention|interference/i.test(key)) {
+        forgettingReports.push(compactDiagnosticValue(value2));
+      }
+    }
+  }
+  return {
+    pressureReports: pressureReports.length > 0 ? pressureReports : void 0,
+    forgettingReports: forgettingReports.length > 0 ? forgettingReports : void 0
+  };
+}
 function signalFromBlock(kind, source, content, options2 = {}) {
   const normalized = normalizeSignalContent(content ?? "");
   if (!normalized)
@@ -546243,6 +546776,7 @@ var init_context_fabric = __esm({
       "tool_cache",
       "skill_manifest",
       "memory",
+      "semantic_chunk",
       "session_history",
       "anchor",
       "handoff",
@@ -546258,6 +546792,7 @@ var init_context_fabric = __esm({
       tool_cache: "Tool Cache",
       skill_manifest: "Skill Manifest",
       memory: "Memory",
+      semantic_chunk: "Semantic Context",
       session_history: "Session History",
       anchor: "Relevant Anchors",
       handoff: "Handoff",
@@ -546273,6 +546808,7 @@ var init_context_fabric = __esm({
       tool_cache: 2200,
       skill_manifest: 900,
       memory: 1500,
+      semantic_chunk: 2200,
       session_history: 1400,
       anchor: 1100,
       handoff: 1600,
@@ -546362,6 +546898,7 @@ var init_context_fabric = __esm({
         const dropped = [];
         const sectionLines = [];
         const sectionDiagnostics = [];
+        const metadataReports = collectMetadataReports(sanitized);
         let truncatedSignals = 0;
         for (const kind of KIND_ORDER) {
           const bucket = byKind.get(kind);
@@ -546424,6 +546961,8 @@ var init_context_fabric = __esm({
               truncatedSignals: 0,
               estimatedTokens: 0,
               totalChars: 0,
+              semanticChunkCount: 0,
+              ...metadataReports,
               sections: []
             },
             included: [],
@@ -546443,7 +546982,7 @@ var init_context_fabric = __esm({
         if (options2.includeDiagnostics) {
           content += `
 
-context_fabric: included=${included.length} dropped=${dropped.length} truncated=${truncatedSignals} est_tokens=${estimateTokens(content)}`;
+context_fabric: included=${included.length} dropped=${dropped.length} truncated=${truncatedSignals} est_tokens=${estimateTokens2(content)}`;
         }
         return {
           content,
@@ -546451,8 +546990,10 @@ context_fabric: included=${included.length} dropped=${dropped.length} truncated=
             includedSignals: included.length,
             droppedSignals: dropped.length,
             truncatedSignals,
-            estimatedTokens: estimateTokens(content),
+            estimatedTokens: estimateTokens2(content),
             totalChars: content.length,
+            semanticChunkCount: included.filter((signal) => signal.kind === "semantic_chunk").length,
+            ...metadataReports,
             sections: sectionDiagnostics
           },
           included,
@@ -546474,7 +547015,7 @@ import { existsSync as existsSync81, readFileSync as readFileSync62, statSync as
 import { execSync as execSync46 } from "node:child_process";
 import { homedir as homedir29, platform as platform3, arch as arch2, totalmem as totalmem3, freemem as freemem3, hostname as hostname3 } from "node:os";
 import { join as join94 } from "node:path";
-import { createHash as createHash20 } from "node:crypto";
+import { createHash as createHash21 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
   const warnings = [];
   const configFingerprints = {};
@@ -546641,7 +547182,7 @@ function expandPath(p2) {
   return p2;
 }
 function sha2563(s2) {
-  return createHash20("sha256").update(s2).digest("hex").slice(0, 16);
+  return createHash21("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function freeDiskBytes(path12 = "/tmp") {
   try {
@@ -547517,6 +548058,115 @@ import { join as _pathJoin, resolve as _pathResolve } from "node:path";
 import { tmpdir as _osTmpdir } from "node:os";
 import { homedir as _osHomedir } from "node:os";
 import { z as z15 } from "zod";
+function textFromMessageContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => part.type === "text" ? part.text ?? "" : "[image]").join("\n");
+}
+function normalizeContextSnippet(text, maxChars = 900) {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  if (normalized.length <= maxChars)
+    return normalized;
+  return `${normalized.slice(0, maxChars - 18).trimEnd()}
+... [bounded]`;
+}
+function estimateMessagesTokens(messages2) {
+  let chars = 0;
+  for (const message2 of messages2) {
+    chars += textFromMessageContent(message2.content).length;
+    if (message2.tool_calls) {
+      for (const call of message2.tool_calls) {
+        chars += call.function.arguments.length + call.function.name.length;
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+function buildFallbackSemanticChunks(items, maxChunks = 7) {
+  const normalized = items.map((item) => ({ ...item, content: normalizeContextSnippet(item.content, 900) })).filter((item) => item.content.length > 0);
+  const bucketOrder = [
+    { label: "Goal and Plan", kinds: ["goal", "task_state"] },
+    { label: "Failure and Risk", kinds: ["recent_failure"] },
+    { label: "Files and Anchors", kinds: ["known_files", "anchor"] },
+    { label: "Knowledge and Memory", kinds: ["tool_cache", "memory"] },
+    { label: "Recent Dialogue", kinds: ["recent_message", "session_history"] },
+    { label: "Environment", kinds: ["environment"] }
+  ];
+  const chunks = [];
+  for (const bucket of bucketOrder) {
+    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 lines = bucketItems.slice(0, 5).map((item) => {
+      const oneLine = item.content.replace(/\s+/g, " ").trim();
+      return `- ${item.label}: ${oneLine.slice(0, 360)}`;
+    });
+    const content = normalizeContextSnippet(lines.join("\n"), 850);
+    chunks.push({
+      id: bucket.label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, ""),
+      label: bucket.label,
+      content,
+      sourceIds: bucketItems.map((item) => item.id).slice(0, 12),
+      priority: Math.max(...bucketItems.map((item) => item.priority ?? 0)),
+      metadata: {
+        labels: bucketItems.map((item) => item.label).slice(0, 8),
+        compression: {
+          rawChars,
+          chunkChars: content.length,
+          ratio: rawChars > 0 ? Number((content.length / rawChars).toFixed(3)) : 1
+        }
+      }
+    });
+    if (chunks.length >= maxChunks)
+      break;
+  }
+  if (chunks.length < maxChunks) {
+    const used = new Set(chunks.flatMap((chunk) => chunk.sourceIds));
+    const leftovers = normalized.filter((item) => !used.has(item.id));
+    for (const item of leftovers.slice(0, maxChunks - chunks.length)) {
+      chunks.push({
+        id: item.id,
+        label: item.label,
+        content: normalizeContextSnippet(item.content, 650),
+        sourceIds: [item.id],
+        priority: item.priority ?? 0,
+        metadata: {
+          labels: [item.label],
+          compression: {
+            rawChars: item.content.length,
+            chunkChars: item.content.length,
+            ratio: 1
+          }
+        }
+      });
+    }
+  }
+  return chunks.slice(0, maxChunks);
+}
+function shouldRunDynamicContextConsolidation(input) {
+  const reasons = [];
+  const rawRatio = input.snapshot.rawRatio;
+  if (input.snapshot.rawTokens > input.snapshot.targetTokens)
+    reasons.push("raw_tokens_over_target");
+  if (rawRatio >= 0.85)
+    reasons.push("raw_ratio_high");
+  const dropped = input.frameDiagnostics?.droppedSignals ?? input.snapshot.droppedSignals ?? 0;
+  const truncated = input.frameDiagnostics?.truncatedSignals ?? input.snapshot.truncatedSignals ?? 0;
+  if (dropped > 0 || truncated > 0)
+    reasons.push("fabric_pressure");
+  const retention = Number(input.forgettingReport?.["retentionScore"] ?? input.forgettingReport?.["retention"] ?? NaN);
+  const interference = Number(input.forgettingReport?.["interferenceScore"] ?? input.forgettingReport?.["interference"] ?? NaN);
+  if (Number.isFinite(retention) && retention < 0.45)
+    reasons.push("low_retention");
+  if (Number.isFinite(interference) && interference > 0.65)
+    reasons.push("high_interference");
+  if (input.memoryHelperDecision === true)
+    reasons.push("memory_helper_trigger");
+  return { shouldRun: reasons.length > 0, reasons: [...new Set(reasons)], rawRatio };
+}
 function repairJson(raw) {
   if (!raw || typeof raw !== "string")
     return null;
@@ -548254,6 +548904,10 @@ var init_agenticRunner = __esm({
       // ledger and emitted as one bounded frame before each model call.
       _contextLedger = new ContextLedger();
       _contextFrameBuilder = new ContextFrameBuilder();
+      _lastContextFrameDiagnostics = null;
+      _lastContextPressureSnapshot = null;
+      _lastActiveForgettingReport = null;
+      _lastContextConsolidationTurn = -1e3;
       /** WO-AM-10: Process pending episode embeddings in background batches */
       async processPendingEmbeddings() {
         if (this._pendingEmbeddings.length === 0 || !this._episodeStore)
@@ -550424,52 +551078,361 @@ ${latest.output || ""}`.trim();
         const insertAt = Math.max(0, messages2.length - 1);
         messages2.splice(insertAt, 0, { role: "system", content: frame });
       }
-      _buildTurnContextFrame(turn, messages2, recentToolResults, environmentBlock) {
+      _activeContextItem(kind, id, source, label, content, priority = 0, metadata) {
+        const normalized = normalizeContextSnippet(content ?? "", 1200);
+        if (!normalized)
+          return null;
+        return { id, kind, source, label, content: normalized, priority, metadata };
+      }
+      _normalizeExternalContextItems(raw) {
+        const arr = Array.isArray(raw) ? raw : [];
+        return arr.map((entry, index) => {
+          if (typeof entry === "string") {
+            return this._activeContextItem("recent_message", `external-message-${index}`, "memory.contextItemsFromMessages", "Recent message", entry, 20);
+          }
+          if (!entry || typeof entry !== "object")
+            return null;
+          const obj = entry;
+          const content = String(obj["content"] ?? obj["text"] ?? obj["summary"] ?? "");
+          const kind = String(obj["kind"] ?? obj["type"] ?? "recent_message");
+          return this._activeContextItem(kind, String(obj["id"] ?? `external-message-${index}`), String(obj["source"] ?? "memory.contextItemsFromMessages"), String(obj["label"] ?? obj["title"] ?? kind), content, typeof obj["priority"] === "number" ? obj["priority"] : 20, typeof obj["metadata"] === "object" && obj["metadata"] !== null ? obj["metadata"] : void 0);
+        }).filter(Boolean);
+      }
+      async _collectActiveSemanticContextItems(input) {
+        const items = [];
+        const add2 = (item) => {
+          if (item)
+            items.push(item);
+        };
+        add2(this._activeContextItem("goal", "active-task", "run.goal", "Active task", input.goalBlock, 100));
+        add2(this._activeContextItem("known_files", "filesystem-state", "turn.files", "Filesystem state", input.filesystemBlock, 70));
+        add2(this._activeContextItem("task_state", "todo-state", "turn.todos", "Todo state", input.todoBlock, 80));
+        add2(this._activeContextItem("recent_failure", "recent-failures", "turn.failures", "Recent failures", input.failureBlock, 95));
+        add2(this._activeContextItem("recent_failure", "write-churn", "turn.churn", "Write churn", input.churnBlock, 75));
+        add2(this._activeContextItem("tool_cache", "tool-cache", "turn.tool-cache", "Tool cache", input.toolCacheBlock, 65));
+        add2(this._activeContextItem("anchor", "anchors", "turn.anchors", "Relevant anchors", input.anchorsBlock, 50));
+        add2(this._activeContextItem("environment", "environment", "turn.environment", "Environment", input.environmentBlock, 35));
+        if (this._lastPprMemoryLines.length > 0) {
+          add2(this._activeContextItem("memory", "ppr-memory", "turn.ppr-memory", "Associative memory", this._lastPprMemoryLines.slice(0, 5).join("\n"), 60));
+        }
+        let helperItems = [];
+        try {
+          const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+          if (typeof memMod.contextItemsFromMessages === "function") {
+            helperItems = this._normalizeExternalContextItems(await memMod.contextItemsFromMessages(input.messages.slice(-12)));
+          }
+        } catch {
+          helperItems = [];
+        }
+        if (helperItems.length > 0) {
+          items.push(...helperItems.slice(0, 8));
+        } else {
+          const tail = input.messages.filter((message2) => message2.role !== "tool").slice(-8);
+          tail.forEach((message2, index) => {
+            const text = textFromMessageContent(message2.content);
+            add2(this._activeContextItem("recent_message", `recent-message-${index}`, "turn.messages", `${message2.role} message`, text, message2.role === "user" ? 45 : 25));
+          });
+        }
+        return items;
+      }
+      _normalizeSemanticChunks(raw) {
+        const arr = Array.isArray(raw) ? raw : [];
+        return arr.map((entry, index) => {
+          if (typeof entry === "string") {
+            const content2 = normalizeContextSnippet(entry, 850);
+            if (!content2)
+              return null;
+            return {
+              id: `semantic-${index}`,
+              label: `Semantic chunk ${index + 1}`,
+              content: content2,
+              sourceIds: [],
+              priority: 0,
+              metadata: { labels: [`Semantic chunk ${index + 1}`] }
+            };
+          }
+          if (!entry || typeof entry !== "object")
+            return null;
+          const obj = entry;
+          const content = normalizeContextSnippet(String(obj["content"] ?? obj["text"] ?? obj["summary"] ?? ""), 850);
+          if (!content)
+            return null;
+          const label = String(obj["label"] ?? obj["title"] ?? obj["topic"] ?? `Semantic chunk ${index + 1}`);
+          const sourceIds = Array.isArray(obj["sourceIds"]) ? obj["sourceIds"].map(String) : Array.isArray(obj["sources"]) ? obj["sources"].map(String) : [];
+          return {
+            id: String(obj["id"] ?? (label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || `semantic-${index}`)),
+            label,
+            content,
+            sourceIds,
+            priority: typeof obj["priority"] === "number" ? obj["priority"] : 0,
+            metadata: typeof obj["metadata"] === "object" && obj["metadata"] !== null ? obj["metadata"] : { labels: [label] }
+          };
+        }).filter(Boolean);
+      }
+      async _buildPressureSnapshot(input) {
+        let snapshot = {
+          rawTokens: input.rawTokens,
+          targetTokens: input.targetTokens,
+          rawRatio: input.targetTokens > 0 ? Number((input.rawTokens / input.targetTokens).toFixed(3)) : 0,
+          semanticChunkCount: input.semanticChunkCount
+        };
+        try {
+          const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+          if (typeof memMod.buildContextPressureSnapshot === "function") {
+            const helperSnapshot = await memMod.buildContextPressureSnapshot({
+              items: input.items,
+              messages: input.messages,
+              rawTokens: input.rawTokens,
+              targetTokens: input.targetTokens
+            });
+            if (helperSnapshot && typeof helperSnapshot === "object") {
+              snapshot = { ...snapshot, ...helperSnapshot };
+              snapshot.rawTokens = Number(snapshot.rawTokens ?? input.rawTokens);
+              snapshot.targetTokens = Number(snapshot.targetTokens ?? input.targetTokens);
+              snapshot.rawRatio = Number(snapshot.rawRatio ?? (snapshot.targetTokens > 0 ? (snapshot.rawTokens / snapshot.targetTokens).toFixed(3) : 0));
+            }
+          }
+        } catch {
+        }
+        return snapshot;
+      }
+      async _buildActiveForgettingReport(input) {
+        try {
+          const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+          if (typeof memMod.buildActiveForgettingReport !== "function")
+            return null;
+          const report2 = await memMod.buildActiveForgettingReport(input);
+          return report2 && typeof report2 === "object" ? report2 : null;
+        } catch {
+          return null;
+        }
+      }
+      async _buildSemanticContextSignals(input) {
+        let chunks = [];
+        try {
+          const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+          const Chunker = memMod.SemanticChunker;
+          if (typeof Chunker === "function") {
+            const chunker = new Chunker({ maxChunks: 7 });
+            const rawChunks = typeof chunker.chunk === "function" ? await chunker.chunk(input.items, { maxChunks: 7 }) : typeof chunker.buildChunks === "function" ? await chunker.buildChunks(input.items, { maxChunks: 7 }) : typeof chunker.run === "function" ? await chunker.run(input.items, { maxChunks: 7 }) : null;
+            chunks = this._normalizeSemanticChunks(rawChunks);
+          }
+        } catch {
+          chunks = [];
+        }
+        if (chunks.length === 0)
+          chunks = buildFallbackSemanticChunks(input.items, 7);
+        chunks = chunks.slice(0, 7);
+        const snapshot = await this._buildPressureSnapshot({
+          items: input.items,
+          messages: input.messages,
+          rawTokens: input.rawTokens,
+          targetTokens: input.targetTokens,
+          semanticChunkCount: chunks.length
+        });
+        const forgettingReport = await this._buildActiveForgettingReport({
+          items: input.items,
+          chunks,
+          snapshot
+        });
+        this._lastContextPressureSnapshot = snapshot;
+        this._lastActiveForgettingReport = forgettingReport;
+        const signals = chunks.map((chunk, index) => signalFromBlock("semantic_chunk", "turn.semantic", `### ${chunk.label}
+${chunk.content}`, {
+          id: `semantic-${index}-${chunk.id}`,
+          dedupeKey: `turn.semantic.${index}`,
+          priority: 62 + Math.max(0, Math.min(20, chunk.priority ?? 0)),
+          createdTurn: input.turn,
+          ttlTurns: 1,
+          tags: ["semantic_context"],
+          metadata: {
+            semanticLabels: chunk.metadata["labels"] ?? [chunk.label],
+            compressionMetrics: chunk.metadata["compression"],
+            sourceIds: chunk.sourceIds,
+            ...index === 0 ? { pressureSnapshot: snapshot, activeForgettingReport: forgettingReport } : {}
+          }
+        })).filter(Boolean);
+        return { signals, snapshot, forgettingReport };
+      }
+      async _memoryHelperWantsConsolidation(input) {
+        try {
+          const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+          if (typeof memMod.shouldTriggerConsolidation !== "function")
+            return null;
+          return Boolean(await memMod.shouldTriggerConsolidation({
+            pressure: input.snapshot,
+            forgetting: input.forgettingReport,
+            diagnostics: input.diagnostics
+          }));
+        } catch {
+          return null;
+        }
+      }
+      async _maybeRunDynamicContextConsolidation(input) {
+        if (process.env["OMNIUS_DISABLE_DYNAMIC_CONTEXT_CONSOLIDATION"] === "1")
+          return;
+        if (!this._episodeStore)
+          return;
+        const debounceTurns = Math.max(4, Number(process.env["OMNIUS_CONTEXT_CONSOLIDATION_DEBOUNCE_TURNS"] ?? 10));
+        if (input.turn - this._lastContextConsolidationTurn < debounceTurns)
+          return;
+        const helperDecision = await this._memoryHelperWantsConsolidation({
+          snapshot: input.snapshot,
+          forgettingReport: input.forgettingReport,
+          diagnostics: input.diagnostics
+        });
+        const decision2 = shouldRunDynamicContextConsolidation({
+          snapshot: input.snapshot,
+          forgettingReport: input.forgettingReport,
+          frameDiagnostics: input.diagnostics,
+          memoryHelperDecision: helperDecision
+        });
+        if (!decision2.shouldRun)
+          return;
+        this._lastContextConsolidationTurn = input.turn;
+        let cycleSummary = null;
+        try {
+          const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+          if (typeof memMod.runConsolidationCycle === "function" && typeof this._episodeStore.getDb === "function") {
+            const cycle = memMod.runConsolidationCycle(this._episodeStore.getDb(), {
+              slowWave: this._temporalGraph ? { graph: this._temporalGraph, maxReplay: 8 } : { maxReplay: 8 },
+              rem: this._temporalGraph ? { graph: this._temporalGraph, maxAssociations: 4 } : { maxAssociations: 4 },
+              light: { prunableClasses: ["session"], maxPrune: 8 }
+            });
+            cycleSummary = {
+              slowWaveReplayed: cycle?.slowWave?.replayedEpisodes?.length ?? 0,
+              lightPruned: cycle?.light?.prunedEpisodes?.length ?? 0,
+              remAssociations: cycle?.rem?.novelAssociations?.length ?? 0,
+              totalEnergy: cycle?.totalEnergy
+            };
+          }
+        } catch {
+          cycleSummary = { failed: true };
+        }
+        const semanticLabels = input.semanticSignals.flatMap((signal) => {
+          const labels = signal.metadata?.["semanticLabels"];
+          return Array.isArray(labels) ? labels.map(String) : [];
+        }).slice(0, 20);
+        const compressionMetrics = input.semanticSignals.map((signal) => signal.metadata?.["compressionMetrics"]).filter(Boolean).slice(0, 7);
+        const content = [
+          `Context pressure snapshot: ${decision2.reasons.join(", ")}.`,
+          `raw=${input.snapshot.rawTokens}/${input.snapshot.targetTokens} tokens ratio=${decision2.rawRatio.toFixed(2)}; semantic_chunks=${input.diagnostics.semanticChunkCount}.`,
+          input.diagnostics.droppedSignals || input.diagnostics.truncatedSignals ? `fabric dropped=${input.diagnostics.droppedSignals} truncated=${input.diagnostics.truncatedSignals}.` : null
+        ].filter(Boolean).join(" ");
+        try {
+          this._episodeStore.insert({
+            sessionId: this._sessionId,
+            modality: "reflection",
+            toolName: "context_pressure_snapshot",
+            content: content.slice(0, 600),
+            importance: 5,
+            decayClass: "session",
+            metadata: {
+              pressure: input.snapshot,
+              forgetting: input.forgettingReport,
+              reasons: decision2.reasons,
+              semanticLabels,
+              compressionMetrics,
+              frameDiagnostics: {
+                includedSignals: input.diagnostics.includedSignals,
+                droppedSignals: input.diagnostics.droppedSignals,
+                truncatedSignals: input.diagnostics.truncatedSignals,
+                estimatedTokens: input.diagnostics.estimatedTokens,
+                semanticChunkCount: input.diagnostics.semanticChunkCount
+              },
+              consolidation: cycleSummary
+            }
+          });
+          this.emit({
+            type: "status",
+            content: `Context consolidation: ${decision2.reasons.join(", ")} (semantic chunks=${input.diagnostics.semanticChunkCount})`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch {
+        }
+      }
+      async _buildTurnContextFrame(turn, messages2, recentToolResults, environmentBlock) {
         this._contextLedger.clearSources("turn.");
         this._contextLedger.prune(turn);
+        const goalBlock = this._taskState.goal ? `Active task: ${this._taskState.goal}` : null;
+        const filesystemBlock = this._renderFilesystemStateBlock(turn);
+        const todoBlock = this._renderTodoStateBlock(turn);
+        const failureBlock = this._renderRecentFailuresBlock(turn);
+        const churnBlock = this._renderWriteChurnBlock(turn);
+        const toolCacheBlock = recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null;
+        const anchorsBlock = this.surfaceAnchors(messages2);
+        const pprMemoryBlock = this._lastPprMemoryLines.length > 0 ? `[Associative Memory - related prior experience]
+${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
+        const activeItems = await this._collectActiveSemanticContextItems({
+          goalBlock,
+          filesystemBlock,
+          todoBlock,
+          failureBlock,
+          churnBlock,
+          toolCacheBlock,
+          anchorsBlock,
+          environmentBlock: environmentBlock ?? null,
+          messages: messages2
+        });
+        const targetTokens2 = this.contextLimits().compactionThreshold;
+        const semantic = await this._buildSemanticContextSignals({
+          turn,
+          items: activeItems,
+          messages: messages2,
+          rawTokens: estimateMessagesTokens(messages2),
+          targetTokens: targetTokens2
+        });
         const signals = [
-          signalFromBlock("goal", "run.goal", this._taskState.goal ? `Active task: ${this._taskState.goal}` : null, {
+          signalFromBlock("goal", "run.goal", goalBlock, {
             id: "active-task",
             dedupeKey: "run.goal",
             priority: 100,
             createdTurn: turn
           }),
-          signalFromBlock("known_files", "turn.files", this._renderFilesystemStateBlock(turn), {
+          signalFromBlock("known_files", "turn.files", filesystemBlock, {
             id: "filesystem-state",
             dedupeKey: "turn.files",
             priority: 70,
             createdTurn: turn,
             ttlTurns: 1
           }),
-          signalFromBlock("task_state", "turn.todos", this._renderTodoStateBlock(turn), {
+          signalFromBlock("task_state", "turn.todos", todoBlock, {
             id: "todo-state",
             dedupeKey: "turn.todos",
             priority: 80,
             createdTurn: turn,
             ttlTurns: 1
           }),
-          signalFromBlock("recent_failure", "turn.failures", this._renderRecentFailuresBlock(turn), {
+          signalFromBlock("recent_failure", "turn.failures", failureBlock, {
             id: "recent-failures",
             dedupeKey: "turn.failures",
             priority: 95,
             createdTurn: turn,
             ttlTurns: 1
           }),
-          signalFromBlock("recent_failure", "turn.churn", this._renderWriteChurnBlock(turn), {
+          signalFromBlock("recent_failure", "turn.churn", churnBlock, {
             id: "write-churn",
             dedupeKey: "turn.churn",
             priority: 75,
             createdTurn: turn,
             ttlTurns: 1
           }),
-          signalFromBlock("tool_cache", "turn.tool-cache", recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null, {
+          signalFromBlock("tool_cache", "turn.tool-cache", toolCacheBlock, {
             id: "tool-cache",
             dedupeKey: "turn.tool-cache",
             priority: 65,
             createdTurn: turn,
             ttlTurns: 1
           }),
-          signalFromBlock("anchor", "turn.anchors", this.surfaceAnchors(messages2), {
+          signalFromBlock("memory", "turn.ppr-memory", pprMemoryBlock, {
+            id: "ppr-memory",
+            dedupeKey: "turn.ppr-memory",
+            priority: 60,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
+          ...semantic.signals,
+          signalFromBlock("anchor", "turn.anchors", anchorsBlock, {
             id: "anchors",
             dedupeKey: "turn.anchors",
             priority: 50,
@@ -550490,6 +551453,18 @@ ${latest.output || ""}`.trim();
           maxChars: 1e4,
           includeDiagnostics: process.env["OMNIUS_CONTEXT_FABRIC_DIAGNOSTICS"] === "1"
         });
+        this._lastContextFrameDiagnostics = frame.diagnostics;
+        semantic.snapshot.frameTokens = frame.diagnostics.estimatedTokens;
+        semantic.snapshot.droppedSignals = frame.diagnostics.droppedSignals;
+        semantic.snapshot.truncatedSignals = frame.diagnostics.truncatedSignals;
+        semantic.snapshot.semanticChunkCount = frame.diagnostics.semanticChunkCount;
+        await this._maybeRunDynamicContextConsolidation({
+          turn,
+          snapshot: semantic.snapshot,
+          forgettingReport: semantic.forgettingReport,
+          diagnostics: frame.diagnostics,
+          semanticSignals: semantic.signals
+        });
         return frame.content;
       }
       makePhaseSummarizer() {
@@ -551331,7 +552306,14 @@ Respond with your assessment, then take action.`;
         this._contextTree = null;
         this._lastSurfacedAnchorIds.clear();
         this._contextLedger = new ContextLedger();
+        this._lastContextFrameDiagnostics = null;
+        this._lastContextPressureSnapshot = null;
+        this._lastActiveForgettingReport = null;
+        this._lastContextConsolidationTurn = -1e3;
         this._contextFrameBuilder = new ContextFrameBuilder();
+        this._lastContextPressureSnapshot = null;
+        this._lastActiveForgettingReport = null;
+        this._lastContextConsolidationTurn = -1e3;
         if (!this.options.disablePersistentMemory && !this._memoryInitialized) {
           try {
             const path12 = await import("node:path");
@@ -553052,8 +554034,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               if (process.env["OMNIUS_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
                 const goalForSig = (this._taskState.goal || "").slice(0, 200);
                 const recentTools = this._toolSequence.slice(-5).join("|");
-                const { createHash: createHash35 } = await import("node:crypto");
-                const sig = createHash35("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                const { createHash: createHash36 } = await import("node:crypto");
+                const sig = createHash36("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
                 if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
                   compacted.push({
                     role: "system",
@@ -553151,7 +554133,7 @@ ${memoryLines.join("\n")}`
           this._lastAssistantTimestamp = Date.now();
           this.proactivePrune(compacted, turn);
           this.microcompact(compacted, recentToolResults);
-          this._insertContextFrame(compacted, this._buildTurnContextFrame(turn, compacted, recentToolResults, environmentBlock));
+          this._insertContextFrame(compacted, await this._buildTurnContextFrame(turn, compacted, recentToolResults, environmentBlock));
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           const chatRequest = {
             messages: compacted,
@@ -555943,7 +556925,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               } catch {
               }
             }
-            this._insertContextFrame(compactedMsgs, this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
+            this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
             const chatRequest = {
               messages: compactedMsgs,
               tools: toolDefs,
@@ -569051,7 +570033,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes29, createHash: createHash35 } = __require("crypto");
+    var { randomBytes: randomBytes29, createHash: createHash36 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -569711,7 +570693,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash35("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash36("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -570078,7 +571060,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash35 } = __require("crypto");
+    var { createHash: createHash36 } = __require("crypto");
     var extension3 = require_extension3();
     var PerMessageDeflate3 = require_permessage_deflate3();
     var subprotocol3 = require_subprotocol2();
@@ -570379,7 +571361,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash35("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash36("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -575228,14 +576210,14 @@ var init_voice_session = __esm({
 });
 
 // packages/cli/src/tui/scoped-personality.ts
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 import { appendFileSync as appendFileSync5, existsSync as existsSync89, mkdirSync as mkdirSync49, readFileSync as readFileSync69, writeFileSync as writeFileSync44 } from "node:fs";
 import { join as join104, resolve as resolve39 } from "node:path";
 function safeName(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
 }
 function scopeHash(scope) {
-  return createHash21("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash22("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function scopedPersonalityDir(repoRoot, kind) {
   return resolve39(repoRoot, ".omnius", "scoped-personality", kind);
@@ -575607,7 +576589,7 @@ var init_scoped_personality = __esm({
 });
 
 // packages/cli/src/tui/voice-soul.ts
-import { createHash as createHash22 } from "node:crypto";
+import { createHash as createHash23 } from "node:crypto";
 import { existsSync as existsSync90, readdirSync as readdirSync29, readFileSync as readFileSync70 } from "node:fs";
 import { basename as basename20, join as join105, resolve as resolve40 } from "node:path";
 function compactText(text, limit) {
@@ -575622,7 +576604,7 @@ function blockText(text, limit) {
 ... [truncated]`;
 }
 function scopeStateKey(scope, surface) {
-  return createHash22("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash23("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function safeName2(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
@@ -578225,7 +579207,7 @@ var init_types = __esm({
 });
 
 // packages/cli/src/tui/p2p/secret-vault.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes21, scryptSync as scryptSync2, createHash as createHash23 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes21, scryptSync as scryptSync2, createHash as createHash24 } from "node:crypto";
 import { readFileSync as readFileSync72, writeFileSync as writeFileSync46, existsSync as existsSync92, mkdirSync as mkdirSync51 } from "node:fs";
 import { dirname as dirname28 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
@@ -578470,7 +579452,7 @@ var init_secret_vault = __esm({
       /** Generate a deterministic fingerprint of vault contents (for sync verification) */
       fingerprint() {
         const names = Array.from(this.secrets.keys()).sort();
-        const hash = createHash23("sha256");
+        const hash = createHash24("sha256");
         for (const name10 of names) {
           hash.update(name10 + ":");
           hash.update(this.secrets.get(name10).value);
@@ -578485,7 +579467,7 @@ var init_secret_vault = __esm({
 // packages/cli/src/tui/p2p/peer-mesh.ts
 import { EventEmitter as EventEmitter9 } from "node:events";
 import { createServer as createServer6 } from "node:http";
-import { randomBytes as randomBytes22, createHash as createHash24, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes22, createHash as createHash25, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/src/tui/p2p/peer-mesh.ts"() {
@@ -578502,7 +579484,7 @@ var init_peer_mesh = __esm({
         const { publicKey: publicKey2, privateKey } = generateKeyPairSync("ed25519");
         this.publicKey = publicKey2.export({ type: "spki", format: "der" });
         this.privateKey = privateKey.export({ type: "pkcs8", format: "der" });
-        this.peerId = createHash24("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
+        this.peerId = createHash25("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options2.capabilities;
         this.displayName = options2.displayName;
         this._authKey = options2.authKey ?? randomBytes22(24).toString("base64url");
@@ -579840,7 +580822,7 @@ __export(omnius_directory_exports, {
 import { appendFileSync as appendFileSync6, cpSync as cpSync2, existsSync as existsSync95, mkdirSync as mkdirSync53, readFileSync as readFileSync75, writeFileSync as writeFileSync48, readdirSync as readdirSync31, statSync as statSync36, unlinkSync as unlinkSync17, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync4, watch as fsWatch2 } from "node:fs";
 import { join as join111, relative as relative9, basename as basename21, dirname as dirname31, resolve as resolve41 } from "node:path";
 import { homedir as homedir34 } from "node:os";
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 function isGitRoot(dir) {
   const gitPath = join111(dir, ".git");
   if (!existsSync95(gitPath)) return false;
@@ -580294,7 +581276,7 @@ function buildHandoffPrompt(repoRoot) {
   return lines.join("\n");
 }
 function computeDedupeHash(task, savedAt) {
-  return createHash25("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
+  return createHash26("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
 }
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -600476,7 +601458,7 @@ __export(commands_exports, {
 });
 import * as nodeOs from "node:os";
 import { execSync as nodeExecSync } from "node:child_process";
-import { createHash as createHash26 } from "node:crypto";
+import { createHash as createHash27 } from "node:crypto";
 import {
   existsSync as existsSync108,
   readFileSync as readFileSync86,
@@ -610952,7 +611934,7 @@ async function collectSponsorMediaStream(args) {
     return { ok: false, error: `Artifact size mismatch for ${artifactId}: ${bytes.length}/${artifact.sizeBytes}` };
   }
   if (artifact.sha256) {
-    const sha = createHash26("sha256").update(bytes).digest("hex");
+    const sha = createHash27("sha256").update(bytes).digest("hex");
     if (sha !== artifact.sha256) return { ok: false, error: `Artifact hash mismatch for ${artifactId}` };
   }
   const safeName3 = basename23(artifact.filename).replace(/[^\w.-]/g, "_") || `artifact${defaultExtensionForMime(artifact.mime)}`;
@@ -614933,7 +615915,7 @@ function normalizePersonName(name10) {
 function personKey(name10) {
   return `person:${normalizePersonName(name10)}`;
 }
-function clamp016(value2, fallback = 0) {
+function clamp017(value2, fallback = 0) {
   if (typeof value2 !== "number" || !Number.isFinite(value2)) return fallback;
   return Math.max(0, Math.min(1, value2));
 }
@@ -614950,7 +615932,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: clamp016(face["confidence"], 0),
+    confidence: clamp017(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
   }));
@@ -615033,7 +616015,7 @@ function activePendingVisualIdentities(store2, scope, sessionId, limit = 3) {
       pendingId,
       name: name10,
       relation: String(meta["relation"] || "depicts"),
-      confidence: clamp016(meta["confidence"], 0.92),
+      confidence: clamp017(meta["confidence"], 0.92),
       note: typeof meta["note"] === "string" ? meta["note"] : void 0,
       episodeId: ep.id,
       createdAt: ep.timestamp,
@@ -615143,7 +616125,7 @@ function stageVisualIdentityAssertion(options2) {
           target: "next_visual_media",
           name: name10,
           relation: options2.relation || "depicts",
-          confidence: clamp016(options2.confidence, 0.92),
+          confidence: clamp017(options2.confidence, 0.92),
           note: options2.note,
           createdAt: Date.now(),
           expiresAt
@@ -615152,7 +616134,7 @@ function stageVisualIdentityAssertion(options2) {
       identityAssertions: [{
         name: name10,
         relation: options2.relation || "named_as",
-        confidence: clamp016(options2.confidence, 0.92),
+        confidence: clamp017(options2.confidence, 0.92),
         assertedBy: options2.sender,
         note: options2.note || "Explicit user-provided identity staged for the next visual media."
       }]
@@ -622977,7 +623959,7 @@ ${result.output}`,
 });
 
 // packages/cli/src/tui/stimulation.ts
-function clamp017(value2) {
+function clamp018(value2) {
   return Math.max(0, Math.min(1, value2));
 }
 function cloneState(state) {
@@ -623033,7 +624015,7 @@ var init_stimulation = __esm({
           ...DEFAULT_STATE,
           ...state,
           phase: normalizePhase(state.phase) ?? DEFAULT_STATE.phase,
-          attention: clamp017(Number.isFinite(state.attention) ? Number(state.attention) : DEFAULT_STATE.attention),
+          attention: clamp018(Number.isFinite(state.attention) ? Number(state.attention) : DEFAULT_STATE.attention),
           updatedAtMs: Number.isFinite(state.updatedAtMs) ? Number(state.updatedAtMs) : now,
           lastStimulusAtMs: Number.isFinite(state.lastStimulusAtMs) ? Number(state.lastStimulusAtMs) : now,
           messagesSinceAnalysis: Math.max(0, Math.floor(Number(state.messagesSinceAnalysis ?? 0))),
@@ -623074,11 +624056,11 @@ var init_stimulation = __esm({
       applyAgentDecision(channelId, decision2, nowMs = Date.now()) {
         const state = this.stateFor(channelId, nowMs);
         if (Number.isFinite(decision2.attentionScore)) {
-          state.attention = clamp017(Number(decision2.attentionScore));
+          state.attention = clamp018(Number(decision2.attentionScore));
         } else if (Number.isFinite(decision2.attentionDelta)) {
-          state.attention = clamp017(state.attention + Number(decision2.attentionDelta));
+          state.attention = clamp018(state.attention + Number(decision2.attentionDelta));
         } else {
-          state.attention = clamp017(state.attention + (decision2.shouldReply ? 0.22 : -0.1));
+          state.attention = clamp018(state.attention + (decision2.shouldReply ? 0.22 : -0.1));
         }
         if (decision2.phase) {
           state.attention = Math.max(state.attention, PHASE_FLOORS[decision2.phase]);
@@ -623134,7 +624116,7 @@ var init_stimulation = __esm({
 });
 
 // packages/cli/src/tui/pid-controller.ts
-function clamp018(x) {
+function clamp019(x) {
   if (!Number.isFinite(x)) return 0;
   if (x < 0) return 0;
   if (x > 1) return 1;
@@ -623198,7 +624180,7 @@ var init_pid_controller = __esm({
         const dt = st.lastSampleAt > 0 ? now - 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 = clamp018(st.output + u);
+        st.output = clamp019(st.output + u);
         st.lastError = error;
         st.lastSampleAt = now;
         st.samples += 1;
@@ -623430,7 +624412,7 @@ var init_soul_observations = __esm({
 // packages/cli/src/tui/telegram-channel-dmn.ts
 import { existsSync as existsSync119, mkdirSync as mkdirSync68, readdirSync as readdirSync42, readFileSync as readFileSync96, writeFileSync as writeFileSync61 } from "node:fs";
 import { join as join133 } from "node:path";
-import { createHash as createHash27 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 function safeFilePart(value2) {
   return value2.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 80) || "telegram";
 }
@@ -623438,7 +624420,7 @@ function daydreamRoot(repoRoot) {
   return join133(repoRoot, ".omnius", "telegram-daydreams");
 }
 function sessionDir(repoRoot, sessionKey) {
-  const hash = createHash27("sha1").update(sessionKey).digest("hex").slice(0, 20);
+  const hash = createHash28("sha1").update(sessionKey).digest("hex").slice(0, 20);
   return join133(daydreamRoot(repoRoot), safeFilePart(hash));
 }
 function compactLine2(value2, max = 220) {
@@ -623523,9 +624505,9 @@ function buildReplyOpportunities(input, openQuestions) {
   return opportunities;
 }
 function daydreamOpportunityId(input, trigger) {
-  return createHash27("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
+  return createHash28("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
 }
-function clamp019(value2) {
+function clamp0110(value2) {
   if (!Number.isFinite(value2)) return 0;
   return Math.max(0, Math.min(1, value2));
 }
@@ -623536,7 +624518,7 @@ function pushStimulationSignal(signals, signal, source, weight) {
   const cleanSignal = compactLine2(signal, 120);
   const cleanSource = compactLine2(source, 180);
   if (!cleanSignal || signals.some((entry) => entry.signal === cleanSignal && entry.source === cleanSource)) return;
-  signals.push({ signal: cleanSignal, source: cleanSource, weight: clamp019(weight) });
+  signals.push({ signal: cleanSignal, source: cleanSource, weight: clamp0110(weight) });
 }
 function buildMetaAnalysisSignals(input) {
   const chatLabel = input.chatTitle || input.chatId;
@@ -623611,7 +624593,7 @@ function buildCuriosityThreads(input, openQuestions, stimulationSignals) {
       question: text.endsWith("?") || text.endsWith("？") ? text : `What should be learned or clarified from: ${text || entry.mediaSummary || "recent media"}?`,
       rationale: "Human curiosity, uncertainty, or multimodal content makes this a useful idle exploration target.",
       sourceMessages: messageId,
-      intensity: clamp019(0.5 + replyBoost + mediaBoost + questionBoost)
+      intensity: clamp0110(0.5 + replyBoost + mediaBoost + questionBoost)
     });
   }
   for (const question of openQuestions.slice(-4)) {
@@ -623631,7 +624613,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: clamp019(strongest.weight * 0.72)
+      intensity: clamp0110(strongest.weight * 0.72)
     });
   }
   return threads.sort((a2, b) => b.intensity - a2.intensity).slice(0, 8);
@@ -623705,7 +624687,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: clamp019(thread.intensity * 0.86)
+      confidence: clamp0110(thread.intensity * 0.86)
     });
     const participant = participantForThread(input, thread);
     if (!participant) continue;
@@ -623717,7 +624699,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: clamp019(thread.intensity * 0.58)
+      confidence: clamp0110(thread.intensity * 0.58)
     });
   }
   return plans.slice(0, 8);
@@ -623843,7 +624825,7 @@ function buildTelegramChannelDaydream(input, corpus, extraction, extractionCommi
   const seed = `${input.sessionKey}:${input.generatedAtMs}:${input.history.length}`;
   return {
     version: 3,
-    id: createHash27("sha1").update(seed).digest("hex").slice(0, 16),
+    id: createHash28("sha1").update(seed).digest("hex").slice(0, 16),
     sessionKey: input.sessionKey,
     chatId: input.chatId,
     chatTitle: input.chatTitle,
@@ -624056,12 +625038,12 @@ var init_telegram_channel_dmn = __esm({
 });
 
 // packages/cli/src/tui/telegram-reflection-corpus.ts
-import { createHash as createHash28 } from "node:crypto";
+import { createHash as createHash29 } from "node:crypto";
 function telegramReflectionMemoryDbPaths(repoRoot) {
   return omniusMemoryDbPaths(repoRoot);
 }
 function stableHash2(value2, length4 = 16) {
-  return createHash28("sha1").update(value2).digest("hex").slice(0, length4);
+  return createHash29("sha1").update(value2).digest("hex").slice(0, length4);
 }
 function clean3(value2) {
   return String(value2 ?? "").replace(/\s+/g, " ").trim();
@@ -624791,7 +625773,7 @@ var init_telegram_reflection_extraction = __esm({
 });
 
 // packages/cli/src/tui/telegram-social-state-types.ts
-import { createHash as createHash29 } from "node:crypto";
+import { createHash as createHash30 } from "node:crypto";
 function telegramSocialActorKey(actor) {
   if (!actor) return "unknown";
   if (typeof actor.userId === "number") return `user:${actor.userId}`;
@@ -624824,7 +625806,7 @@ function appendUnique(items, value2, max) {
   return next.slice(-max);
 }
 function hashTelegramSocialId(parts) {
-  return createHash29("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
+  return createHash30("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
 }
 function cleanUsername(value2) {
   if (typeof value2 !== "string") return void 0;
@@ -624849,7 +625831,7 @@ function numberOr(value2, fallback) {
 function isNumber(value2) {
   return typeof value2 === "number" && Number.isFinite(value2);
 }
-function clamp0110(value2) {
+function clamp0111(value2) {
   return Math.max(0, Math.min(1, Number.isFinite(value2) ? value2 : 0));
 }
 function iso(ts) {
@@ -625033,8 +626015,8 @@ function normalizeRelationship(raw) {
     kind: value2.kind,
     fromKey: String(value2.fromKey),
     toKey: String(value2.toKey),
-    confidence: clamp0110(numberOr(value2.confidence, 0)),
-    weight: clamp0110(numberOr(value2.weight, 0)),
+    confidence: clamp0111(numberOr(value2.confidence, 0)),
+    weight: clamp0111(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) : [],
@@ -625053,7 +626035,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: clamp0110(numberOr(evidence.confidence, 0)),
+        confidence: clamp0111(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)
@@ -625067,7 +626049,7 @@ function normalizePreferences(raw) {
         out[actorKey].replyMode = {
           mode,
           scope: normalizeReplyPreferenceScope(record["scope"]),
-          confidence: clamp0110(numberOr(record["confidence"], 0.8)),
+          confidence: clamp0111(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),
@@ -625157,7 +626139,7 @@ function normalizeOutcome(raw) {
     replyToMessageId: typeof value2.replyToMessageId === "number" ? value2.replyToMessageId : void 0,
     route: value2.route === "action" ? "action" : "chat",
     shouldReply: value2.shouldReply === true,
-    confidence: clamp0110(numberOr(value2.confidence, 0)),
+    confidence: clamp0111(numberOr(value2.confidence, 0)),
     reason: compact2(value2.reason || "", 280),
     source: compact2(value2.source || "unknown", 80),
     silentDisposition: compactOptional(value2.silentDisposition, 280),
@@ -625169,7 +626151,7 @@ function normalizeOutcome(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) ? clamp0110(value2.scenarioConfidence) : void 0,
+    scenarioConfidence: typeof value2.scenarioConfidence === "number" && Number.isFinite(value2.scenarioConfidence) ? clamp0111(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) : [],
@@ -625187,7 +626169,7 @@ function normalizeDaydreamOpportunity(raw) {
     artifactId: String(value2.artifactId || "unknown"),
     generatedAt: String(value2.generatedAt || (/* @__PURE__ */ new Date()).toISOString()),
     trigger: compact2(value2.trigger || "", 240),
-    confidence: clamp0110(numberOr(value2.confidence, 0)),
+    confidence: clamp0111(numberOr(value2.confidence, 0)),
     lifecycle,
     firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
     updatedAt: numberOr(value2.updatedAt, Date.now()),
@@ -625244,7 +626226,7 @@ function commitTelegramSocialDecision(state, input) {
     replyToMessageId: input.replyToMessageId,
     route: input.route,
     shouldReply: input.shouldReply,
-    confidence: clamp0110(input.confidence),
+    confidence: clamp0111(input.confidence),
     reason: compact2(input.reason, 280),
     source: compact2(input.source, 80),
     silentDisposition: compactOptional(input.silentDisposition, 280),
@@ -625256,7 +626238,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 : clamp0110(input.scenarioConfidence),
+    scenarioConfidence: input.scenarioConfidence === void 0 ? void 0 : clamp0111(input.scenarioConfidence),
     scenarioObjective: compactOptional(input.scenarioObjective, 360),
     scenarioStateLoop: compactOptional(input.scenarioStateLoop, 360),
     salienceSignals: [...new Set((input.salienceSignals ?? []).map(String))].slice(0, 16),
@@ -625280,7 +626262,7 @@ function registerDaydreamOpportunities(state, opportunities, now = Date.now()) {
       artifactId: opportunity.artifactId || "unknown",
       generatedAt: opportunity.generatedAt || new Date(now).toISOString(),
       trigger: compact2(opportunity.trigger, 240),
-      confidence: clamp0110(opportunity.confidence),
+      confidence: clamp0111(opportunity.confidence),
       lifecycle: "proposed",
       firstSeenAt: now,
       updatedAt: now,
@@ -625290,7 +626272,7 @@ function registerDaydreamOpportunities(state, opportunities, now = Date.now()) {
     };
     if (existing) {
       item.trigger = compact2(opportunity.trigger, 240) || item.trigger;
-      item.confidence = clamp0110(opportunity.confidence);
+      item.confidence = clamp0111(opportunity.confidence);
       item.updatedAt = now;
     }
     state.daydreamOpportunities[id] = item;
@@ -625317,7 +626299,7 @@ function setTelegramReplyModePreference(state, input) {
   const next = {
     mode: input.mode,
     scope: input.scope,
-    confidence: Math.max(existing?.confidence ?? 0, clamp0110(input.confidence ?? 0.84)),
+    confidence: Math.max(existing?.confidence ?? 0, clamp0111(input.confidence ?? 0.84)),
     updatedAt: now,
     evidenceMessageIds: appendUnique(existing?.evidenceMessageIds ?? [], input.messageId, 12),
     note: compactOptional(input.note, 220),
@@ -625497,8 +626479,8 @@ function upsertRelationship(state, kind, fromKey, toKey, messageId, confidence2,
     evidenceMessageIds: [],
     source
   };
-  edge.confidence = Math.max(edge.confidence, clamp0110(confidence2));
-  edge.weight = Math.min(1, edge.weight + 0.12 + clamp0110(confidence2) * 0.2);
+  edge.confidence = Math.max(edge.confidence, clamp0111(confidence2));
+  edge.weight = Math.min(1, edge.weight + 0.12 + clamp0111(confidence2) * 0.2);
   edge.lastSeenAt = now;
   edge.evidenceMessageIds = appendUnique(edge.evidenceMessageIds, messageId, 40);
   edge.note = compactOptional(note, 260) || edge.note;
@@ -625540,7 +626522,7 @@ function setPreference(vector, key, value2, confidence2, messageId, now, note) {
   const existing = vector[key];
   vector[key] = {
     value: existing ? existing.value * 0.7 + value2 * 0.3 : value2,
-    confidence: Math.max(existing?.confidence ?? 0, clamp0110(confidence2)),
+    confidence: Math.max(existing?.confidence ?? 0, clamp0111(confidence2)),
     updatedAt: now,
     evidenceMessageIds: appendUnique(existing?.evidenceMessageIds ?? [], messageId, 12),
     note
@@ -625751,7 +626733,7 @@ import { mkdirSync as mkdirSync69, existsSync as existsSync121, unlinkSync as un
 import { join as join135, resolve as resolve48, basename as basename33, relative as relative13, isAbsolute as isAbsolute8, extname as extname16 } from "node:path";
 import { homedir as homedir43 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
-import { createHash as createHash30, randomBytes as randomBytes24, randomInt } from "node:crypto";
+import { createHash as createHash31, randomBytes as randomBytes24, randomInt } from "node:crypto";
 function cleanTelegramDecisionNote(value2, maxLength = 260) {
   if (typeof value2 !== "string") return void 0;
   const clean5 = stripTelegramHiddenThinking(value2).replace(/\s+/g, " ").trim();
@@ -626718,7 +627700,7 @@ function buildTelegramRuntimeContext(now = /* @__PURE__ */ new Date(), repoRoot)
   ].filter(Boolean).join("\n");
 }
 function telegramSessionIdFromKey(sessionKey) {
-  return `telegram-${createHash30("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+  return `telegram-${createHash31("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
 function normalizeTelegramSubAgentLimit(value2) {
   const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && value2.trim() ? Number(value2.trim()) : TELEGRAM_SUB_AGENT_DEFAULT_LIMIT;
@@ -627535,7 +628517,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("│")} ${c3.magenta("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, TELEGRAM_SUB_AGENT_MAX_LIMIT, TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
+var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA, TELEGRAM_INTERACTION_DECISION_REPAIR_SCHEMA, TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, TELEGRAM_SUB_AGENT_MAX_LIMIT, TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -627807,6 +628789,8 @@ External acquisition contract:
     TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT = {
       type: "json_object"
     };
+    TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA = `{"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"explicit durable cadence preference"}}`;
+    TELEGRAM_INTERACTION_DECISION_REPAIR_SCHEMA = `{"recoverable":true|false,"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"explicit durable cadence preference"}}`;
     TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT = {
       type: "json_schema",
       json_schema: {
@@ -628333,7 +629317,7 @@ External acquisition contract:
         return !!this.adminAuthChallenge && this.adminAuthChallenge.expiresAtMs > Date.now();
       }
       hashAdminAuthCode(code8) {
-        return createHash30("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
+        return createHash31("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
       }
       viewIdForMessage(msg) {
         return `telegram-${this.sessionKeyForMessage(msg).replace(/[^A-Za-z0-9_-]/g, "-")}`;
@@ -629260,11 +630244,11 @@ ${mediaContext}` : ""
         return payload;
       }
       telegramConversationPath(sessionKey) {
-        const safe = createHash30("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash31("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join135(this.telegramConversationDir, `${safe}.json`);
       }
       telegramConversationLedgerPath(sessionKey) {
-        const safe = createHash30("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash31("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join135(this.telegramConversationDir, `${safe}.events.jsonl`);
       }
       telegramDb() {
@@ -629492,7 +630476,7 @@ ${mediaContext}` : ""
           users,
           relationships: Array.isArray(raw.relationships) ? raw.relationships.slice(0, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
           actions: Array.isArray(raw.actions) ? raw.actions.slice(-TELEGRAM_ASSOCIATIVE_ACTION_LIMIT).map((action) => ({
-            id: String(action.id || createHash30("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)),
+            id: String(action.id || createHash31("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)),
             ts: typeof action.ts === "number" ? action.ts : Date.now(),
             role: action.role === "assistant" ? "assistant" : "user",
             speaker: String(action.speaker || "unknown"),
@@ -629509,7 +630493,7 @@ ${mediaContext}` : ""
         const text = String(raw.text || "").trim();
         const now = Date.now();
         return {
-          id: String(raw.id || createHash30("sha1").update(text || String(now)).digest("hex").slice(0, 12)),
+          id: String(raw.id || createHash31("sha1").update(text || String(now)).digest("hex").slice(0, 12)),
           text,
           tags: Array.isArray(raw.tags) ? raw.tags.map(String).slice(0, 16) : [],
           speakers: Array.isArray(raw.speakers) ? raw.speakers.map(String).slice(0, 16) : [],
@@ -629747,6 +630731,41 @@ ${mediaContext}` : ""
           scenarioStateLoop: void 0
         };
       }
+      synthesizeTelegramPostReplyDecision(decision2, msg, visibleReplyText) {
+        const base3 = this.stripTelegramDecisionNotes(decision2);
+        const replySummary = visibleReplyText ? sanitizeTelegramProgressText(cleanTelegramVisibleReply(visibleReplyText), 180) : "visible reply attempt completed";
+        return {
+          ...base3,
+          silentDisposition: "visible reply completed before internal note commit",
+          mentalNote: `post-reply: @${msg.username || "unknown"} was answered via ${decision2.route}; ${replySummary}`,
+          memoryNote: "message and visible reply were retained in scoped Telegram conversation memory"
+        };
+      }
+      notesThenReplyDecision(decision2, msg) {
+        if (decision2.silentDisposition || decision2.mentalNote || decision2.memoryNote || decision2.relationshipNote || decision2.procedureNote || decision2.voiceNote || decision2.scenarioNote || decision2.scenarioId) {
+          return decision2;
+        }
+        return {
+          ...decision2,
+          silentDisposition: "internal notes committed before visible reply by reply mode",
+          mentalNote: `pre-reply: @${msg.username || "unknown"} routed to ${decision2.route}; ${decision2.reason}`,
+          memoryNote: "message retained in scoped Telegram conversation memory before reply"
+        };
+      }
+      deliverTelegramPostReplyNotes(sessionKey, msg, viewId, decision2, salienceSignals, daydreamOpportunities, visibleReplyText) {
+        const postReplyDecision = this.synthesizeTelegramPostReplyDecision(decision2, msg, visibleReplyText);
+        if (viewId && this.subAgentViewCallbacks) {
+          this.subAgentViewCallbacks.onWrite(viewId, "post-reply/internal notes:");
+        }
+        this.deliverTelegramAttentionDecision(
+          sessionKey,
+          msg,
+          viewId,
+          postReplyDecision,
+          salienceSignals,
+          daydreamOpportunities
+        );
+      }
       telegramTextDeliveryCapability(sessionKey, chatId, messageThreadId) {
         try {
           return telegramTextDeliveryCapabilityFor(this.telegramSocialStateForSession(sessionKey), {
@@ -629863,7 +630882,7 @@ ${mediaContext}` : ""
       }
       telegramHistoryBackfillMessageId(sessionKey, entry, index) {
         if (typeof entry.messageId === "number" && Number.isFinite(entry.messageId)) return entry.messageId;
-        const digest3 = createHash30("sha1").update(`${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`).digest("hex").slice(0, 8);
+        const digest3 = createHash31("sha1").update(`${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`).digest("hex").slice(0, 8);
         return -Number.parseInt(digest3, 16);
       }
       backfillTelegramLoadedHistory(sessionKey, history) {
@@ -630780,7 +631799,7 @@ ${mediaContext}` : ""
         const now = entry.ts ?? Date.now();
         memory.updatedAt = now;
         const speaker = telegramHistorySpeaker(entry);
-        const actionId = createHash30("sha1").update(`${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now}:${entry.text}`).digest("hex").slice(0, 16);
+        const actionId = createHash31("sha1").update(`${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now}:${entry.text}`).digest("hex").slice(0, 16);
         if (!memory.actions.some((action) => action.id === actionId)) {
           memory.actions.push({
             id: actionId,
@@ -630902,7 +631921,7 @@ ${mediaContext}` : ""
         let fact = facts.find((item) => item.text.toLowerCase() === key);
         if (!fact) {
           fact = {
-            id: createHash30("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
+            id: createHash31("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
             text: clean5,
             tags: telegramMemoryTags(clean5, entry.mediaSummary),
             speakers: [],
@@ -630957,7 +631976,7 @@ ${mediaContext}` : ""
           const titleTags = tags.slice(0, 4);
           const title = titleTags.length > 0 ? `${speaker} / ${titleTags.join(" ")}` : `${speaker} / conversation`;
           const card = {
-            id: createHash30("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
+            id: createHash31("sha1").update(`${sessionKey}:${now}:${speaker}:${text}`).digest("hex").slice(0, 12),
             title,
             notes: [],
             tags: [],
@@ -632278,7 +633297,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           routeInstruction,
           ``,
           `Return JSON only with this schema:`,
-          `{"recoverable":true|false,"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition","reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"why this durable preference was explicitly expressed"}}`,
+          TELEGRAM_INTERACTION_DECISION_REPAIR_SCHEMA,
           ``,
           `Original router output:`,
           rawPreview,
@@ -632296,7 +633315,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 1500,
+            maxTokens: 800,
             timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 2e4),
             think: false
           }, diagnostics, "router-repair", sessionKey);
@@ -632342,7 +633361,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
           `Return exactly one JSON object and no prose. No <think> tags. No commentary.`,
           routeInstruction,
           ``,
-          `Required schema: {"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition","reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"why this durable preference was explicitly expressed"}}`,
+          `Required schema: ${TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA}`,
           ``,
           `Invalid previous output, for diagnostics only:`,
           invalidPreview,
@@ -632363,7 +633382,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 2400,
+            maxTokens: 1e3,
             timeoutMs: telegramRouterTimeoutMs(timeoutMs, 1e4, 3e4),
             think: false
           }, diagnostics, "router-strict-retry", sessionKey);
@@ -632666,19 +633685,12 @@ ${stimulationProbe.context}`,
         let reflectionNotes;
         let reflectionContext;
         if (consolidatedMode) {
-          reflectionNotes = this.fallbackTelegramSilentReflectionNotes(msg, "consolidated mode: reflection computed inline by router");
+          reflectionNotes = {};
           reflectionContext = [
-            "## Consolidated Reflection (you produce these fields as part of the same JSON)",
-            "Before emitting your final decision, internally reflect on:",
-            "  silent_disposition: what happens silently with this message",
-            "  mental_note: concise observation of the turn",
-            "  memory_note: what scoped memory should retain or connect",
-            "  relationship_note: relationship/thread implication",
-            "  procedure_note: active tree/branch/abort implication",
-            "  voice_note: final voice implication if a reply happens",
-            "  scenario_note: identified scenario and transition state",
-            "  scenario_id / scenario_label / scenario_confidence / scenario_objective / scenario_state_loop",
-            "Use these as your attention substrate, then decide route/should_reply/confidence. Return all fields in ONE JSON."
+            "## Router fast-path note policy",
+            "Do not generate silent_disposition, mental_note, memory_note, relationship_note, procedure_note, voice_note, scenario fields, or other internal notes in this router response.",
+            "Only decide route, should_reply, confidence, reason, optional stimulation cadence, and optional explicit reply_mode_preference.",
+            "If notes are needed, the bridge will synthesize or commit them after the visible reply according to the resolved reply mode."
           ].join("\n");
         } else {
           reflectionNotes = await this.inferTelegramSilentReflectionNotes(
@@ -632708,22 +633720,22 @@ ${stimulationProbe.context}`,
         }
         const userPrompt = [
           `You are the Telegram live routing and reply-discretion model.`,
-          `The attention decision must happen after reading the silent reflection deliverables below. The notes are not decorations: they are the decision substrate.`,
+          `Make the smallest sufficient live attention decision. Do not include internal notes unless explicitly supplied by deliberative mode context.`,
           `Use the persona docs below as binding behavioral guidance for whether speaking is appropriate and how to avoid over-eager or adversarially bad interventions.`,
           `Return JSON only, with no markdown and no explanation outside JSON.`,
           ``,
-          `Schema: {"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note","procedure_note":"short tree/procedure note","voice_note":"short final-voice note","scenario_note":"short scenario/transition note","scenario_id":"dynamic inferred scenario id","scenario_label":"human readable dynamic scenario label","scenario_confidence":0.0-1.0,"scenario_objective":"current scenario objective","scenario_state_loop":"state loop to maintain until transition","reply_mode_preference":null|{"scope":"current_user_in_chat"|"current_user_global"|"current_group","reply_mode":"reply_then_notes"|"notes_then_reply"|"reply_only","confidence":0.0-1.0,"note":"why this durable preference was explicitly expressed"}}`,
+          `Schema: ${TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA}`,
           ``,
           `Route meanings:`,
           `- chat: a short conversational answer can be produced without tools.`,
           `- action: tools, workspace context, media processing, web lookup, delegation, or a multi-step agent loop may be needed.`,
-          `Route discipline: infer whether the selected dynamic scenario can be completed as immediate conversation or needs an external capability. Do not route from keyword categories.`,
+          `Route discipline: infer whether the current request can be completed as immediate conversation or needs an external capability. Do not route from keyword categories.`,
           ``,
           `Reply discretion: make a human-like attention decision from the full social context. Observe the message, relationship stream, reply graph, conversation momentum, prior bot involvement, speaker intent, and notification-like signals, then decide whether a visible reply would be natural.`,
           `No hard triggers: direct address, @mentions, name/identity references, private-chat delivery, replies, active threads, and stimulation score are evidence only. They may raise or lower salience, but none guarantees should_reply=true or should_reply=false.`,
           `High-salience evidence: private DMs, exact @username matches, display-name self references, and replies to this bot are notification-like signals. They should usually move attention toward deeper processing and a likely response unless the surrounding context makes silence more natural.`,
           `No keyword routing: do not use static keyword rules. Infer whether identity references are actually aimed at this bot from syntax, tone, recent turns, and relationships.`,
-          `Observation notes: always fill silent_disposition, mental_note, memory_note, relationship_note, procedure_note, voice_note, scenario_note, scenario_id, scenario_label, scenario_confidence, scenario_objective, and scenario_state_loop with concise outcome-level notes for the TUI. Do not expose hidden chain-of-thought; summarize what the bot did with the heard message.`,
+          `Observation notes: omit note fields on the fast path. Do not expose hidden chain-of-thought or produce scratch notes in this router JSON.`,
           `Reply-mode preference capture: if and only if the current sender explicitly expresses a durable preference for reply cadence/order, populate reply_mode_preference as a typed update. Do not infer this from style, keywords, tone, or one-off task shape. Use null otherwise.`,
           `Reply-mode meanings: reply_then_notes means visible reply first and internal notes afterward; notes_then_reply means internal notes before visible reply; reply_only means one user-facing reply with tools/context and no extra internal notes stage.`,
           `Bot-to-bot discipline: sender labels include [bot] or [human]. Treat peer bots as autonomous actors, not human users. Avoid bot loops by replying only when the exchange context makes a response socially useful.`,
@@ -632790,11 +633802,9 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             ],
             tools: [],
             temperature: 0,
-            // Router JSON schema has ~18 string-valued fields when reflection is
-            // embedded (consolidated mode). 1000 tokens was the documented cause
-            // of truncated JSON → repair → strict-retry cascade. 2400 is enough
-            // for normal verbose values without slowing the call appreciably.
-            maxTokens: 2400,
+            // Minimal route JSON should fit comfortably; keeping this small avoids
+            // reintroducing truncated-note repair cascades.
+            maxTokens: 900,
             timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
             think: false
           }, diagnostics, "router", sessionKey);
@@ -632833,7 +633843,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
                 ],
                 tools: [],
                 temperature: 0,
-                maxTokens: 4096,
+                maxTokens: 1400,
                 timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
                 think: false
               }, diagnostics, "router", sessionKey);
@@ -633107,7 +634117,7 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
       }
       telegramRunnerStateDir(sessionKey) {
         if (!this.repoRoot) return void 0;
-        const safe = createHash30("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash31("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join135(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
@@ -633815,7 +634825,7 @@ Join: ${newUrl}`);
         );
         if (storedPreference) this.subAgentViewCallbacks?.onWrite(attentionViewId || this.viewIdForMessage(msg), `preference: ${storedPreference}`);
         const replyMode = this.resolvedTelegramReplyMode(sessionKey, msg);
-        const deliveredDecision = replyMode === "reply_only" ? this.stripTelegramDecisionNotes(decision2) : decision2;
+        const deliveredDecision = replyMode === "notes_then_reply" ? this.notesThenReplyDecision(decision2, msg) : this.stripTelegramDecisionNotes(decision2);
         const daydreamOpportunities = this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg);
         const shouldDeferNotes = replyMode === "reply_then_notes" && decision2.shouldReply;
         if (!shouldDeferNotes) {
@@ -633849,26 +634859,22 @@ Join: ${newUrl}`);
           this.enqueueTelegramSubAgentContext(sessionKey, existingAfterDecision, decisionContext, msg.username);
           await this.enqueueTelegramQueuedSessionWorkForExistingSubAgent(work, existingAfterDecision);
           if (shouldDeferNotes) {
-            this.deliverTelegramAttentionDecision(
-              sessionKey,
-              msg,
-              attentionViewId,
-              deliveredDecision,
-              this.telegramMessageIdentitySalienceSignals(msg),
-              daydreamOpportunities
+            this.subAgentViewCallbacks?.onWrite(
+              attentionViewId || existingAfterDecision.viewId,
+              "post-reply/internal notes deferred to active reply completion"
             );
           }
           return;
         }
         const subAgentProfile = decision2.route === "chat" ? "chat" : "action";
         if (decision2.route === "chat" && msg.chatType === "private") {
-          await this.handleTelegramChatCompletion(msg, toolContext, [decisionContext, rapidContext].filter(Boolean).join("\n\n"));
-          if (shouldDeferNotes) {
-            this.deliverTelegramAttentionDecision(
+          const visibleReplyAttempted = await this.handleTelegramChatCompletion(msg, toolContext, [decisionContext, rapidContext].filter(Boolean).join("\n\n"));
+          if (shouldDeferNotes && visibleReplyAttempted) {
+            this.deliverTelegramPostReplyNotes(
               sessionKey,
               msg,
               attentionViewId,
-              deliveredDecision,
+              decision2,
               this.telegramMessageIdentitySalienceSignals(msg),
               daydreamOpportunities
             );
@@ -633957,16 +634963,6 @@ Join: ${newUrl}`);
               await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
               });
             }
-            if (shouldDeferNotes) {
-              this.deliverTelegramAttentionDecision(
-                sessionKey,
-                msg,
-                attentionViewId,
-                deliveredDecision,
-                this.telegramMessageIdentitySalienceSignals(msg),
-                daydreamOpportunities
-              );
-            }
             return;
           }
           if (subAgent.liveMessagePromise) {
@@ -633989,19 +634985,20 @@ Join: ${newUrl}`);
             finalText,
             Boolean(subAgent.liveMessageId && !msg.guestQueryId)
           );
+          this.tuiWrite(() => renderTelegramSubAgentComplete(msg.username, finalText));
+          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${finalText}`);
+          this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
           if (shouldDeferNotes) {
-            this.deliverTelegramAttentionDecision(
+            this.deliverTelegramPostReplyNotes(
               sessionKey,
               msg,
               attentionViewId,
-              deliveredDecision,
+              decision2,
               this.telegramMessageIdentitySalienceSignals(msg),
-              daydreamOpportunities
+              daydreamOpportunities,
+              finalText
             );
           }
-          this.tuiWrite(() => renderTelegramSubAgentComplete(msg.username, finalText));
-          this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `completed: ${finalText}`);
-          this.subAgentViewCallbacks?.onStatus(subAgent.viewId, "completed");
         } catch (err) {
           if (subAgent.typingInterval) {
             clearInterval(subAgent.typingInterval);
@@ -634019,16 +635016,6 @@ Join: ${newUrl}`);
             await this.deleteLiveMessage(msg.chatId, subAgent.liveMessageId).catch(() => {
             });
           }
-          if (shouldDeferNotes) {
-            this.deliverTelegramAttentionDecision(
-              sessionKey,
-              msg,
-              attentionViewId,
-              deliveredDecision,
-              this.telegramMessageIdentitySalienceSignals(msg),
-              daydreamOpportunities
-            );
-          }
         } finally {
           this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
@@ -634156,7 +635143,7 @@ Join: ${newUrl}`);
       async handleTelegramChatCompletion(msg, toolContext, additionalContext = "") {
         if (toolContext === "telegram-admin-dm") {
           await this.handleTelegramAdminChatAgent(msg, toolContext, additionalContext);
-          return;
+          return true;
         }
         const viewId = `${this.viewIdForMessage(msg)}-chat`;
         const sessionKey = this.sessionKeyForMessage(msg);
@@ -634241,7 +635228,7 @@ Join: ${newUrl}`);
             }
             this.subAgentViewCallbacks?.onWrite(viewId, "completed: no model reply");
             this.subAgentViewCallbacks?.onStatus(viewId, "completed");
-            return;
+            return false;
           }
           const finalHtml = convertMarkdownToTelegramHTML(cleaned);
           const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, liveMessageId);
@@ -634255,6 +635242,7 @@ Join: ${newUrl}`);
           }
           this.subAgentViewCallbacks?.onWrite(viewId, `completed: ${cleaned}`);
           this.subAgentViewCallbacks?.onStatus(viewId, "completed");
+          return true;
         } catch (err) {
           if (typingInterval) {
             clearInterval(typingInterval);
@@ -634273,6 +635261,7 @@ Join: ${newUrl}`);
             await this.deleteLiveMessage(msg.chatId, liveMessageId).catch(() => {
             });
           }
+          return false;
         } finally {
           this.activeChatViews.delete(viewId);
           this.activeChatSessions.delete(sessionKey);
@@ -639815,14 +640804,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash31 } from "node:crypto";
+import { createHash as createHash32 } from "node:crypto";
 import { existsSync as existsSync124, mkdirSync as mkdirSync72, readFileSync as readFileSync101, renameSync as renameSync8, writeFileSync as writeFileSync66, unlinkSync as unlinkSync26 } from "node:fs";
 import { homedir as homedir46 } from "node:os";
 import { join as join138, resolve as resolve50 } from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve50(root);
-  return createHash31("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash32("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join138(PROJECTS_DIR, projectKey(root));
@@ -639914,7 +640903,7 @@ __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
 import { EventEmitter as EventEmitter13 } from "node:events";
-function clamp0111(x) {
+function clamp0112(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -639953,9 +640942,9 @@ function computeSignalFromText(text, confidence2) {
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
   if (typeof confidence2 === "number" && !Number.isNaN(confidence2)) {
-    score = 0.7 * score + 0.3 * clamp0111(confidence2);
+    score = 0.7 * score + 0.3 * clamp0112(confidence2);
   }
-  return clamp0111(score);
+  return clamp0112(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -640225,7 +641214,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp0111(snr) : computeSignalFromText(text, confidence2);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp0112(snr) : computeSignalFromText(text, confidence2);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);
@@ -641000,7 +641989,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash32 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -641063,7 +642052,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash32("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash33("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req2, res, etag) {
@@ -655494,7 +656483,7 @@ import { homedir as homedir53 } from "node:os";
 import { spawn as spawn31, execSync as execSync58 } from "node:child_process";
 import { mkdirSync as mkdirSync80, writeFileSync as writeFileSync72, readFileSync as readFileSync109, readdirSync as readdirSync48, existsSync as existsSync135, watch as fsWatch4, renameSync as renameSync9, unlinkSync as unlinkSync28 } from "node:fs";
 import { randomBytes as randomBytes27, randomUUID as randomUUID17 } from "node:crypto";
-import { createHash as createHash34 } from "node:crypto";
+import { createHash as createHash35 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join149(baseDir, ".omnius");
   return {
@@ -661447,7 +662436,7 @@ function listScheduledTasks() {
               const schedule = String(t2?.schedule || t2?.cron || t2?.when || "");
               const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
               const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-              const fallbackId = createHash34("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+              const fallbackId = createHash35("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
               const uid = realId || fallbackId;
               const key = `${uid}`;
               if (seen.has(key)) return;
@@ -661564,8 +662553,8 @@ function deleteScheduledById(id) {
     if (id) candidates.push(id);
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id)) candidates.push(entry.id);
     try {
-      const { createHash: createHash35 } = require4("node:crypto");
-      const fallback = createHash35("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash36 } = require4("node:crypto");
+      const fallback = createHash36("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -671714,13 +672703,13 @@ ${taskInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash35 } = await import("node:crypto");
+          const { createHash: createHash36 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash35("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash36("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,