omnius 1.0.662 → 1.0.664

package/dist/index.js

@@ -663599,6 +663599,7 @@ ${notice}`;
       }
       _emitSteeringLifecycle(record, reason) {
         const receipt2 = this._steeringReceipt(record);
+        const reconciliation = record.state === "reconciled" && this._activeSteering?.input.inputId === record.inputId ? this._activeSteering.reconciliation : void 0;
         this.emit({
           type: "status",
           content: `Steering ${record.inputId} ${record.state}: ${reason}`,
@@ -663613,6 +663614,7 @@ ${notice}`;
           state: record.state,
           taskEpoch: record.taskEpoch,
           summary: reason,
+          ...reconciliation ? { reconciliation: { ...reconciliation } } : {},
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         appendSteeringLedgerEntry(this._workingDirectory || process.cwd(), {
@@ -663969,43 +663971,55 @@ ${notice}`;
         const active = this._activeSteering;
         if (!active || !active.requiresReconciliation || !content)
           return false;
-        const tagged = content.match(/\[STEERING_RECONCILIATION\]([\s\S]*?)(?:\[\/STEERING_RECONCILIATION\]|$)/i);
-        if (!tagged)
-          return false;
-        const candidate = this._firstJsonObject(tagged[1] ?? "");
-        if (!candidate)
+        const marker = /\[STEERING_RECONCILIATION(?:\]|(?=[\s{]))/gi;
+        const matches = [...content.matchAll(marker)];
+        let selected = null;
+        for (let index = 0; index < matches.length; index++) {
+          const current = matches[index];
+          const start2 = (current.index ?? 0) + current[0].length;
+          const end = matches[index + 1]?.index ?? content.length;
+          const candidate = this._firstJsonObject(content.slice(start2, end));
+          if (!candidate)
+            continue;
+          try {
+            const parsed = JSON.parse(candidate);
+            const status = parsed["status"];
+            const inputId = parsed["inputId"];
+            if (inputId !== active.input.inputId || status !== "applied" && status !== "not_applicable" && status !== "needs_clarification") {
+              continue;
+            }
+            const changedConstraints = Array.isArray(parsed["changedConstraints"]) ? parsed["changedConstraints"].filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean).slice(0, 12) : [];
+            const revisedNextAction = typeof parsed["revisedNextAction"] === "string" ? parsed["revisedNextAction"].trim().slice(0, 1e3) : "";
+            if (!revisedNextAction)
+              continue;
+            selected = {
+              inputId: active.input.inputId,
+              status,
+              changedConstraints,
+              revisedNextAction
+            };
+          } catch {
+            continue;
+          }
+        }
+        if (!selected)
           return false;
         try {
-          const parsed = JSON.parse(candidate);
-          const status = parsed["status"];
-          const inputId = parsed["inputId"];
-          if (inputId !== active.input.inputId || status !== "applied" && status !== "not_applicable" && status !== "needs_clarification") {
-            return false;
-          }
-          const changedConstraints = Array.isArray(parsed["changedConstraints"]) ? parsed["changedConstraints"].filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean).slice(0, 12) : [];
-          const revisedNextAction = typeof parsed["revisedNextAction"] === "string" ? parsed["revisedNextAction"].trim().slice(0, 1e3) : "";
-          if (!revisedNextAction)
-            return false;
-          active.reconciliation = {
-            inputId: active.input.inputId,
-            status,
-            changedConstraints,
-            revisedNextAction
-          };
+          active.reconciliation = selected;
           active.reconciledTurn = turn;
-          active.requiresReconciliation = status === "needs_clarification";
-          active.gatesOldPlan = status === "needs_clarification";
-          this._taskState.nextAction = revisedNextAction;
-          if (changedConstraints.length > 0) {
+          active.requiresReconciliation = selected.status === "needs_clarification";
+          active.gatesOldPlan = selected.status === "needs_clarification";
+          this._taskState.nextAction = selected.revisedNextAction;
+          if (selected.changedConstraints.length > 0) {
             this._taskState.steeringConstraints = [
               .../* @__PURE__ */ new Set([
                 ...this._taskState.steeringConstraints ?? [],
-                ...changedConstraints
+                ...selected.changedConstraints
               ])
             ].slice(-20);
           }
           active.input.state = "reconciled";
-          this._emitSteeringLifecycle(active.input, `reconciled by model at turn ${turn}: ${status}`);
+          this._emitSteeringLifecycle(active.input, `reconciled by model at turn ${turn}: ${selected.status}`);
           return true;
         } catch {
           return false;
@@ -700714,50 +700728,181 @@ var init_conversation_context = __esm({
 });
 
 // packages/cli/src/tui/steering-stream-filter.ts
-var OPEN_MARKER, CLOSE_MARKER, SteeringReconciliationStreamFilter;
+function firstBalancedJsonObject(text3) {
+  const start2 = text3.indexOf("{");
+  if (start2 < 0) return null;
+  let depth = 0;
+  let quoted = false;
+  let escaped = false;
+  for (let index = start2; index < text3.length; index++) {
+    const char = text3[index];
+    if (quoted) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') quoted = false;
+      continue;
+    }
+    if (char === '"') quoted = true;
+    else if (char === "{") depth++;
+    else if (char === "}") {
+      depth--;
+      if (depth === 0) return { start: start2, end: index + 1 };
+    }
+  }
+  return null;
+}
+function parseReconciliation(jsonText) {
+  try {
+    const parsed = JSON.parse(jsonText);
+    const status = parsed["status"];
+    if (status !== "applied" && status !== "not_applicable" && status !== "needs_clarification") {
+      return null;
+    }
+    const revisedNextAction = typeof parsed["revisedNextAction"] === "string" ? parsed["revisedNextAction"].trim().slice(0, 2e3) : "";
+    if (!revisedNextAction) return null;
+    const inputId = typeof parsed["inputId"] === "string" ? parsed["inputId"].trim().slice(0, 500) : "";
+    const changedConstraints = Array.isArray(parsed["changedConstraints"]) ? parsed["changedConstraints"].filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean).slice(0, 24) : [];
+    return {
+      ...inputId ? { inputId } : {},
+      status,
+      changedConstraints,
+      revisedNextAction
+    };
+  } catch {
+    return null;
+  }
+}
+function suffixMatchingMarkerPrefix(text3, marker) {
+  const upper = text3.toUpperCase();
+  for (let length4 = Math.min(upper.length, marker.length - 1); length4 > 0; length4--) {
+    if (marker.startsWith(upper.slice(-length4))) return length4;
+  }
+  return 0;
+}
+function stripSteeringReconciliationEnvelopes(text3, onReconciliation) {
+  if (!text3) return "";
+  const filter2 = new SteeringReconciliationStreamFilter({ onReconciliation });
+  return `${filter2.consume(text3)}${filter2.flush()}`;
+}
+var OPEN_STEM, CLOSE_STEM, SteeringReconciliationStreamFilter;
 var init_steering_stream_filter = __esm({
   "packages/cli/src/tui/steering-stream-filter.ts"() {
-    OPEN_MARKER = "[STEERING_RECONCILIATION]";
-    CLOSE_MARKER = "[/STEERING_RECONCILIATION]";
+    OPEN_STEM = "[STEERING_RECONCILIATION";
+    CLOSE_STEM = "[/STEERING_RECONCILIATION";
     SteeringReconciliationStreamFilter = class {
       constructor(options2 = {}) {
         this.options = options2;
       }
       options;
-      mode = "detect";
+      mode = "scan";
       buffer = "";
+      hasVisibleContent = false;
+      separatorAfterEnvelope = false;
       reset() {
-        this.mode = "detect";
+        this.mode = "scan";
         this.buffer = "";
+        this.hasVisibleContent = false;
+        this.separatorAfterEnvelope = false;
       }
       consume(chunk) {
-        if (!chunk) return "";
-        if (this.mode === "show") return chunk;
-        this.buffer += chunk;
-        if (this.mode === "detect") {
-          const leading = this.buffer.trimStart();
-          if (OPEN_MARKER.startsWith(leading)) return "";
-          if (!leading.startsWith(OPEN_MARKER)) {
-            const visible2 = this.buffer;
+        if (chunk) this.buffer += chunk;
+        return this.drain(false);
+      }
+      drain(final2) {
+        let visible = "";
+        const appendVisible = (text3) => {
+          if (!text3) return;
+          if (this.separatorAfterEnvelope) {
+            if (!/^\s/.test(text3)) visible += " ";
+            this.separatorAfterEnvelope = false;
+          }
+          visible += text3;
+          if (text3.trim()) this.hasVisibleContent = true;
+        };
+        while (this.buffer) {
+          if (this.mode === "discard") {
             this.buffer = "";
-            this.mode = "show";
-            return visible2;
+            break;
           }
-          this.mode = "suppress";
+          if (this.mode === "scan") {
+            const upper2 = this.buffer.toUpperCase();
+            let openAt = -1;
+            let pendingOpenAt = -1;
+            let searchAt = 0;
+            while (searchAt < upper2.length) {
+              const candidateAt = upper2.indexOf(OPEN_STEM, searchAt);
+              if (candidateAt < 0) break;
+              const after = upper2[candidateAt + OPEN_STEM.length];
+              if (after === void 0 && !final2) {
+                pendingOpenAt = candidateAt;
+                break;
+              }
+              if (after === void 0 || after === "]" || after === "{" || /\s/.test(after)) {
+                openAt = candidateAt;
+                break;
+              }
+              searchAt = candidateAt + OPEN_STEM.length;
+            }
+            if (openAt >= 0) {
+              const prefix = this.buffer.slice(0, openAt);
+              if (prefix.trim()) appendVisible(prefix);
+              this.separatorAfterEnvelope = this.hasVisibleContent;
+              this.buffer = this.buffer.slice(openAt + OPEN_STEM.length);
+              if (this.buffer.startsWith("]")) this.buffer = this.buffer.slice(1);
+              this.mode = "capture";
+              continue;
+            }
+            if (pendingOpenAt >= 0) {
+              const prefix = this.buffer.slice(0, pendingOpenAt);
+              if (prefix.trim()) appendVisible(prefix);
+              this.separatorAfterEnvelope = this.hasVisibleContent;
+              this.buffer = this.buffer.slice(pendingOpenAt);
+              break;
+            }
+            const retained = final2 ? 0 : suffixMatchingMarkerPrefix(this.buffer, OPEN_STEM);
+            if (retained > 0) {
+              const prefix = this.buffer.slice(0, -retained);
+              if (prefix.trim()) appendVisible(prefix);
+              this.buffer = this.buffer.slice(-retained);
+            } else {
+              if (!(final2 && OPEN_STEM.startsWith(upper2))) {
+                appendVisible(this.buffer);
+              }
+              this.buffer = "";
+            }
+            break;
+          }
+          if (this.mode === "capture") {
+            const span = firstBalancedJsonObject(this.buffer);
+            if (!span) {
+              if (final2) this.buffer = "";
+              break;
+            }
+            const parsed = parseReconciliation(
+              this.buffer.slice(span.start, span.end)
+            );
+            if (parsed) this.options.onReconciliation?.(parsed);
+            this.buffer = this.buffer.slice(span.end);
+            this.mode = "after-json";
+            continue;
+          }
+          const whitespace = this.buffer.match(/^\s*/)?.[0].length ?? 0;
+          if (whitespace > 0) this.buffer = this.buffer.slice(whitespace);
+          if (!this.buffer) break;
+          const upper = this.buffer.toUpperCase();
+          if (upper.startsWith(CLOSE_STEM)) {
+            this.buffer = this.buffer.slice(CLOSE_STEM.length);
+            if (this.buffer.startsWith("]")) this.buffer = this.buffer.slice(1);
+            this.mode = this.options.suppressTrailingContent ? "discard" : "scan";
+            continue;
+          }
+          if (!final2 && CLOSE_STEM.startsWith(upper)) break;
+          this.mode = this.options.suppressTrailingContent ? "discard" : "scan";
         }
-        const closeAt = this.buffer.indexOf(CLOSE_MARKER);
-        if (closeAt < 0) return "";
-        const visible = this.options.suppressTrailingContent ? "" : this.buffer.slice(closeAt + CLOSE_MARKER.length);
-        this.buffer = "";
-        this.mode = this.options.suppressTrailingContent ? "suppress" : "show";
         return visible;
       }
       flush() {
-        if (this.mode === "suppress") {
-          this.reset();
-          return "";
-        }
-        const visible = this.buffer;
+        const visible = this.drain(true);
         this.reset();
         return visible;
       }
@@ -773479,6 +773624,157 @@ function codeBlock(code8, language = "") {
   const inner = escapeHtml2(String(code8 ?? "").replace(/\s+$/, ""));
   return language ? `<pre><code class="language-${escapeHtml2(language)}">${inner}</code></pre>` : `<pre>${inner}</pre>`;
 }
+function telegramRichText(text3) {
+  return escapeHtml2(text3).replace(/\r?\n/g, "<br>");
+}
+function renderTelegramPanelPage(input) {
+  const metadata = (input.metadata ?? []).map((item) => ({
+    label: String(item.label ?? "").trim(),
+    value: String(item.value ?? "").trim()
+  })).filter((item) => item.label && item.value);
+  const sections = input.sections.map((section) => ({
+    title: section.title?.trim() || "",
+    packets: section.packets.map((packet) => ({
+      title: packet.title.trim() || "Details",
+      body: packet.body.trim(),
+      open: packet.open === true
+    })).filter((packet) => packet.body)
+  })).filter((section) => section.packets.length > 0);
+  const emptyText = input.emptyText?.trim() || "No data is available yet.";
+  const fallback = [`<b>${escapeHtml2(input.title)}</b>`];
+  if (input.subtitle?.trim()) {
+    fallback.push(`<i>${escapeHtml2(input.subtitle.trim())}</i>`);
+  }
+  if (metadata.length > 0) {
+    fallback.push(
+      "<b>Details</b>",
+      `<blockquote>${escapeHtml2(metadata.map((item) => `${item.label}: ${item.value}`).join("\n"))}</blockquote>`
+    );
+  }
+  if (sections.length === 0) {
+    fallback.push(`<i>${escapeHtml2(emptyText)}</i>`);
+  } else {
+    for (const section of sections) {
+      if (section.title) fallback.push(`<b>${escapeHtml2(section.title)}</b>`);
+      for (const packet of section.packets) {
+        const expandable = !packet.open && (packet.body.length > 180 || packet.body.split(/\r?\n/).length > 3);
+        fallback.push(
+          `<b>${escapeHtml2(packet.title)}</b>`,
+          `<blockquote${expandable ? " expandable" : ""}>${escapeHtml2(packet.body)}</blockquote>`
+        );
+      }
+    }
+  }
+  if (input.footer?.trim()) {
+    fallback.push(`<i>${escapeHtml2(input.footer.trim())}</i>`);
+  }
+  const rich = [`<h3>${escapeHtml2(input.title)}</h3>`];
+  if (input.subtitle?.trim()) {
+    rich.push(`<p><i>${telegramRichText(input.subtitle.trim())}</i></p>`);
+  }
+  if (metadata.length > 0) {
+    rich.push(
+      [
+        "<table bordered striped compact>",
+        "<tr><th>Field</th><th>Value</th></tr>",
+        ...metadata.map(
+          (item) => `<tr><td>${telegramRichText(item.label)}</td><td>${telegramRichText(item.value)}</td></tr>`
+        ),
+        "</table>"
+      ].join("")
+    );
+  }
+  if (sections.length === 0) {
+    rich.push(`<p><i>${telegramRichText(emptyText)}</i></p>`);
+  } else {
+    for (const section of sections) {
+      if (section.title) rich.push(`<h4>${escapeHtml2(section.title)}</h4>`);
+      for (const packet of section.packets) {
+        rich.push(
+          `<details${packet.open ? " open" : ""}><summary>${escapeHtml2(packet.title)}</summary><p>${telegramRichText(packet.body)}</p></details>`
+        );
+      }
+    }
+  }
+  if (input.footer?.trim()) {
+    rich.push(`<footer>${telegramRichText(input.footer.trim())}</footer>`);
+  }
+  return { html: fallback.join("\n\n"), richHtml: rich.join("\n") };
+}
+function telegramTitledTextPackets(text3, fallbackTitle = "Details", maxPackets = 16) {
+  const source = String(text3 ?? "").trim();
+  if (!source) return [];
+  const packets = [];
+  let currentTitle = "";
+  let currentLines = [];
+  const flush3 = () => {
+    const body = currentLines.join("\n").trim();
+    if (body) {
+      packets.push({
+        title: currentTitle || fallbackTitle,
+        body
+      });
+    }
+    currentTitle = "";
+    currentLines = [];
+  };
+  for (const line of source.split(/\r?\n/)) {
+    const heading = line.match(/^([^:\n]{1,100}):\s*$/);
+    if (heading) {
+      flush3();
+      currentTitle = heading[1].trim();
+    } else {
+      currentLines.push(line);
+    }
+  }
+  flush3();
+  if (packets.length <= 1 && !/^([^:\n]{1,100}):\s*$/m.test(source)) {
+    const paragraphs = source.split(/\r?\n\s*\r?\n+/).map((paragraph) => paragraph.trim()).filter(Boolean);
+    packets.length = 0;
+    packets.push(
+      ...paragraphs.map((paragraph, index) => ({
+        title: paragraphs.length === 1 ? fallbackTitle : `${fallbackTitle} ${index + 1}`,
+        body: paragraph
+      }))
+    );
+  }
+  if (packets.length <= maxPackets) return packets;
+  const retained = packets.slice(0, Math.max(1, maxPackets - 1));
+  retained.push({
+    title: `${fallbackTitle} ${maxPackets}`,
+    body: packets.slice(Math.max(1, maxPackets - 1)).map((packet) => `${packet.title}
+${packet.body}`).join("\n\n")
+  });
+  return retained;
+}
+function splitTelegramPlainText(text3, maxLength = 2500) {
+  const chunks = [];
+  let remaining = String(text3 ?? "").trim();
+  const limit2 = Math.max(200, Math.floor(maxLength));
+  while (remaining.length > limit2) {
+    let cut = remaining.lastIndexOf("\n\n", limit2);
+    if (cut < limit2 * 0.4) cut = remaining.lastIndexOf("\n", limit2);
+    if (cut < limit2 * 0.4) cut = remaining.lastIndexOf(". ", limit2);
+    if (cut < limit2 * 0.4) cut = remaining.lastIndexOf(" ", limit2);
+    if (cut < limit2 * 0.4) cut = limit2;
+    const chunk = remaining.slice(0, cut).trim();
+    if (chunk) chunks.push(chunk);
+    remaining = remaining.slice(cut).trim();
+  }
+  if (remaining || chunks.length === 0) chunks.push(remaining);
+  return chunks;
+}
+function telegramHtmlToPlainText(html) {
+  return String(html ?? "").replace(/<br\s*\/?>/gi, "\n").replace(
+    /<\/(?:p|h[1-6]|blockquote|details|summary|table|tr|ul|ol|li|footer)>/gi,
+    "\n"
+  ).replace(/<hr\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&#(x[0-9a-f]+|\d+);/gi, (_match, value2) => {
+    const radix = value2[0]?.toLowerCase() === "x" ? 16 : 10;
+    const raw = radix === 16 ? value2.slice(1) : value2;
+    const codePoint = Number.parseInt(raw, radix);
+    return Number.isFinite(codePoint) ? String.fromCodePoint(codePoint) : "";
+  }).replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 function safeJson(v, pretty) {
   try {
     return pretty ? JSON.stringify(v, null, 2) : JSON.stringify(v);
@@ -773492,11 +773788,14 @@ function tokenizeTelegramHtml(html) {
   let last2 = 0;
   let m2;
   while ((m2 = re.exec(html)) !== null) {
-    if (m2.index > last2) tokens3.push({ type: "text", raw: html.slice(last2, m2.index) });
+    if (m2.index > last2)
+      tokens3.push({ type: "text", raw: html.slice(last2, m2.index) });
     const closing = m2[1] === "/";
     const tag = (m2[2] || "").toLowerCase();
     if (SPAN_TAGS.has(tag)) {
-      tokens3.push(closing ? { type: "close", tag, raw: m2[0] } : { type: "open", tag, raw: m2[0] });
+      tokens3.push(
+        closing ? { type: "close", tag, raw: m2[0] } : { type: "open", tag, raw: m2[0] }
+      );
     } else {
       tokens3.push({ type: "text", raw: m2[0] });
     }
@@ -781653,6 +781952,44 @@ function convertMarkdownToTelegramHTML(md) {
 function escapeTelegramHTML(text3) {
   return text3.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+function upsertTelegramSteeringReconciliation(target, value2) {
+  const key = value2.inputId.trim();
+  if (!key) return;
+  target.delete(key);
+  target.set(key, {
+    inputId: key.slice(0, 500),
+    status: value2.status,
+    changedConstraints: value2.changedConstraints.map((item) => item.trim()).filter(Boolean).slice(0, 12),
+    revisedNextAction: value2.revisedNextAction.trim().slice(0, 1e3)
+  });
+  while (target.size > 12) {
+    const oldest = target.keys().next().value;
+    if (!oldest) break;
+    target.delete(oldest);
+  }
+}
+function formatTelegramSteeringReconciliationHTML(values) {
+  if (values.length === 0) return "";
+  const sections = values.slice(-4).map((value2) => {
+    const status = value2.status.replaceAll("_", " ");
+    const constraints = value2.changedConstraints.length ? ["Changes:", ...value2.changedConstraints.map((item) => `• ${item}`)] : ["Changes: none"];
+    return [
+      `Status: ${status}`,
+      ...constraints,
+      `Next: ${value2.revisedNextAction}`
+    ].join("\n");
+  });
+  return [
+    "<b>Plan update</b>",
+    `<blockquote expandable>${escapeTelegramHTML(sections.join("\n\n"))}</blockquote>`
+  ].join("\n");
+}
+function composeTelegramReplyWithSteeringHTML(replyText, reconciliations) {
+  return [
+    formatTelegramSteeringReconciliationHTML(reconciliations),
+    replyText.trim() ? convertMarkdownToTelegramHTML(replyText) : ""
+  ].filter(Boolean).join("\n\n");
+}
 function normalizeTelegramOutboundLinks(text3) {
   if (!text3) return text3;
   return text3.replace(
@@ -781763,7 +782100,7 @@ function isTelegramNoReplySentinel(text3) {
 }
 function telegramTextHasRunnerControlMarker(text3) {
   const upper = text3.toUpperCase();
-  return TELEGRAM_RUNNER_CONTROL_OPEN_MARKERS.some(
+  return /\[\/?STEERING_RECONCILIATION(?:\]|(?=[\s{\[]))/i.test(text3) || TELEGRAM_RUNNER_CONTROL_OPEN_MARKERS.some(
     (marker) => upper.includes(marker)
   ) || TELEGRAM_RUNNER_CONTROL_CLOSE_MARKERS.some(
     (marker) => upper.includes(marker)
@@ -781771,35 +782108,32 @@ function telegramTextHasRunnerControlMarker(text3) {
 }
 function sanitizeTelegramModelFacingContext(text3) {
   if (!text3) return "";
+  const structurallySanitized = stripSteeringReconciliationEnvelopes(text3);
   const kept = [];
   let insideControlEnvelope = false;
-  let quarantineTrailingRationale = false;
-  for (const line of text3.split(/\r?\n/)) {
+  let oneLineControlRemainder = 0;
+  for (const line of structurallySanitized.split(/\r?\n/)) {
     const upper = line.toUpperCase();
-    const hasOpen = TELEGRAM_RUNNER_CONTROL_OPEN_MARKERS.some(
-      (marker) => upper.includes(marker)
-    );
-    const hasClose = TELEGRAM_RUNNER_CONTROL_CLOSE_MARKERS.some(
-      (marker) => upper.includes(marker)
-    );
-    if (insideControlEnvelope) {
-      if (hasClose) {
-        insideControlEnvelope = false;
-        quarantineTrailingRationale = true;
-      }
+    if (oneLineControlRemainder > 0) {
+      oneLineControlRemainder--;
       continue;
     }
-    if (quarantineTrailingRationale) {
-      if (/^#{2,3}\s+/.test(line.trim())) {
-        quarantineTrailingRationale = false;
-      } else {
-        continue;
-      }
+    const hasOpen = upper.includes("[ACTIVE USER STEERING]");
+    const hasClose = upper.includes("[/ACTIVE USER STEERING]");
+    if (insideControlEnvelope) {
+      if (hasClose) insideControlEnvelope = false;
+      continue;
     }
     if (hasOpen) {
       if (!hasClose) insideControlEnvelope = true;
       continue;
     }
+    if (/\[(?:STEERING_RECONCILIATION_REQUIRED|STEERING_REPLAN_TURN_REQUIRED|STEERING_CLARIFICATION_REQUIRED)\]/i.test(
+      line
+    )) {
+      oneLineControlRemainder = 2;
+      continue;
+    }
     if (/["']revisedNextAction["']\s*:/i.test(line) && /["'](?:inputId|status|changedConstraints)["']\s*:/i.test(line)) {
       continue;
     }
@@ -781839,6 +782173,7 @@ function isTelegramInternalStatusText(text3) {
   ))
     return true;
   if (/^no further action needed\b/i.test(compact6)) return true;
+  if (/^no visible reply (?:is|was) warranted\.?$/i.test(compact6)) return true;
   if (/^no action needed\b.{0,120}\b(task|complete|completed|done)\b/i.test(
     compact6
   ))
@@ -781880,7 +782215,7 @@ function stripTelegramStuckSelfTalk(text3) {
 }
 function cleanTelegramVisibleReply(text3, options2 = {}) {
   const clean7 = normalizeTelegramOutboundLinks(
-    stripTelegramHiddenThinking(text3)
+    stripSteeringReconciliationEnvelopes(stripTelegramHiddenThinking(text3))
   ).trim();
   if (!clean7) return "";
   if (options2.suppressPotentialNoReplyPrefix && isTelegramPotentialNoReplyPrefix(clean7))
@@ -782190,15 +782525,19 @@ function formatTelegramProgressEvent(event) {
   }
   return null;
 }
-function renderTelegramLiveProgressHTML(progressLines, accumulated) {
+function renderTelegramLiveProgressHTML(progressLines, accumulated, steeringReconciliations = []) {
+  const steeringHtml = formatTelegramSteeringReconciliationHTML(
+    steeringReconciliations
+  );
   const draft = cleanTelegramVisibleReply(accumulated, {
     suppressPotentialNoReplyPrefix: true
   });
   if (draft) {
     const clipped = draft.length > 2e3 ? `${draft.slice(0, 1997).trimEnd()}...` : draft;
-    return convertMarkdownToTelegramHTML(clipped);
+    return [steeringHtml, convertMarkdownToTelegramHTML(clipped)].filter(Boolean).join("\n\n");
   }
-  return progressLines.slice(-6).map((line) => line.trim()).filter((line) => !isTelegramInternalStatusText(line)).filter(Boolean).join("\n");
+  const progress = progressLines.slice(-6).map((line) => line.trim()).filter((line) => !isTelegramInternalStatusText(line)).filter(Boolean).join("\n");
+  return [steeringHtml, progress].filter(Boolean).join("\n\n");
 }
 function telegramAdminLivePanelPageLabel(page2) {
   if (page2 === "response") return "Reply";
@@ -782207,11 +782546,78 @@ function telegramAdminLivePanelPageLabel(page2) {
   if (page2 === "evidence") return "Evidence";
   return "Context";
 }
+function telegramPanelHtmlFallback(html) {
+  const chunks = segmentTelegramHtml(html, 3600);
+  if (chunks.length <= 1) return chunks[0] ?? "";
+  return `${chunks[0]}
+
+<i>... (additional packet detail requires Rich Message support)</i>`;
+}
+function telegramAdminLinePackets(lines, fallbackTitle) {
+  return lines.map((line, index) => {
+    const structured = line.match(
+      /^([→✓✗])\s+([^\s:]+)(?::\s*|\s+)?([\s\S]*)$/
+    );
+    if (!structured) {
+      return { title: `${fallbackTitle} ${index + 1}`, body: line };
+    }
+    const marker = structured[1];
+    const toolName = structured[2] || "tool";
+    const detail = structured[3]?.trim();
+    const phase = marker === "→" ? "Call" : marker === "✓" ? "Result" : "Failure";
+    return {
+      title: `${phase} · ${toolName}`,
+      body: detail || (marker === "→" ? "Request admitted." : marker === "✓" ? "Completed." : "The tool reported a failure.")
+    };
+  });
+}
+function telegramContextMetadata(page2, pageIndex, pageCount) {
+  return [
+    { label: "Packet", value: `${pageIndex + 1} / ${pageCount}` },
+    { label: "Source", value: page2.source },
+    ...page2.metadata.map((line, index) => {
+      const equalsAt = line.indexOf("=");
+      return equalsAt > 0 ? {
+        label: line.slice(0, equalsAt).trim(),
+        value: line.slice(equalsAt + 1).trim()
+      } : { label: `Detail ${index + 1}`, value: line };
+    })
+  ];
+}
+function renderTelegramContextExplorerPagePayload(page2, pageIndex, pageCount, title = "Context used for this reply") {
+  if (!page2) {
+    const empty2 = renderTelegramPanelPage({
+      title,
+      sections: [],
+      emptyText: "No context packets are available."
+    });
+    return { text: empty2.html, rich_html: empty2.richHtml };
+  }
+  const rendered = renderTelegramPanelPage({
+    title,
+    subtitle: page2.title,
+    metadata: telegramContextMetadata(page2, pageIndex, pageCount),
+    sections: [
+      {
+        packets: telegramTitledTextPackets(page2.body, "Content")
+      }
+    ],
+    emptyText: "This context packet is empty.",
+    footer: `Context packet ${pageIndex + 1} of ${pageCount}`
+  });
+  return {
+    text: telegramPanelHtmlFallback(rendered.html),
+    rich_html: rendered.richHtml
+  };
+}
 function trimTelegramAdminPanelLines(lines, max = 80) {
   if (lines.length > max) lines.splice(0, lines.length - max);
 }
 function pushTelegramAdminPanelLine(state5, page2, line) {
-  const clean7 = stripTelegramHiddenThinking(line).replace(/\s+/g, " ").trim();
+  const clean7 = sanitizeTelegramProgressText(
+    stripTelegramHiddenThinking(line).replace(/\s+/g, " ").trim(),
+    1e3
+  );
   if (!clean7) return;
   const target = page2 === "tools" ? state5.toolLines : page2 === "logs" ? state5.logLines : state5.mutationLines;
   if (target[target.length - 1] !== clean7) target.push(clean7);
@@ -782220,7 +782626,10 @@ function pushTelegramAdminPanelLine(state5, page2, line) {
   if (state5.activePage !== page2) state5.dirtyPages[page2] = true;
 }
 function pushTelegramAdminPanelMutationLine(state5, line) {
-  const clean7 = stripTelegramHiddenThinking(line).replace(/\s+/g, " ").trim();
+  const clean7 = sanitizeTelegramProgressText(
+    stripTelegramHiddenThinking(line).replace(/\s+/g, " ").trim(),
+    1e3
+  );
   if (!clean7) return;
   if (state5.mutationLines[state5.mutationLines.length - 1] !== clean7)
     state5.mutationLines.push(clean7);
@@ -782240,6 +782649,37 @@ function telegramAdminLivePanelIntakeText(requestPreview) {
   void requestPreview;
   return "";
 }
+function telegramAdminEventTurn(event) {
+  const turn = event.turn;
+  return typeof turn === "number" && Number.isFinite(turn) ? turn : void 0;
+}
+function syncTelegramAdminResponseText(state5) {
+  state5.responseText = state5.responseSegments.map(
+    (segment) => cleanTelegramVisibleReply(segment.rawText, {
+      suppressPotentialNoReplyPrefix: true
+    })
+  ).filter(Boolean).join("\n\n");
+}
+function upsertTelegramAdminResponseSegment(state5, key, turn, rawText, complete) {
+  const existing = state5.responseSegments.find(
+    (segment) => segment.key === key
+  );
+  if (existing) {
+    existing.rawText = rawText;
+    existing.complete = complete;
+  } else {
+    state5.responseSegments.push({
+      key,
+      ...turn !== void 0 ? { turn } : {},
+      rawText,
+      complete
+    });
+  }
+  if (state5.responseSegments.length > 8) {
+    state5.responseSegments.splice(0, state5.responseSegments.length - 8);
+  }
+  syncTelegramAdminResponseText(state5);
+}
 function renderTelegramHalftoneProgressBar(elapsedSec, width = 12) {
   const safeWidth = Math.max(1, Math.floor(width));
   const phase = Math.max(0, elapsedSec) % 60 / 60 * safeWidth;
@@ -782272,6 +782712,9 @@ function createTelegramAdminLivePanelState(args) {
     requestPreview,
     intakeText: telegramAdminLivePanelIntakeText(requestPreview),
     responseText: "",
+    responseSegments: [],
+    responseSegmentSequence: 0,
+    steeringReconciliations: [],
     evidenceText: "",
     toolLines: [],
     mutationLines: [],
@@ -782281,24 +782724,40 @@ function createTelegramAdminLivePanelState(args) {
   };
 }
 function applyTelegramAdminLivePanelEvent(state5, event) {
+  if (event.type === "stream_start") {
+    const turn = telegramAdminEventTurn(event);
+    const key = turn !== void 0 ? `turn:${turn}` : `stream:${++state5.responseSegmentSequence}`;
+    upsertTelegramAdminResponseSegment(state5, key, turn, "", false);
+    state5.activeResponseSegmentKey = key;
+    return;
+  }
   if (event.type === "stream_token" && event.streamKind === "content" && event.content) {
-    const next = cleanTelegramVisibleReply(
-      `${state5.responseText}${event.content}`,
-      { suppressPotentialNoReplyPrefix: true }
+    const turn = telegramAdminEventTurn(event);
+    const key = state5.activeResponseSegmentKey ?? (turn !== void 0 ? `turn:${turn}` : `stream:${++state5.responseSegmentSequence}`);
+    const existing = state5.responseSegments.find(
+      (segment) => segment.key === key
     );
-    if (next) {
-      state5.responseText = next;
+    upsertTelegramAdminResponseSegment(
+      state5,
+      key,
+      turn,
+      `${existing?.rawText ?? ""}${event.content}`,
+      false
+    );
+    if (state5.responseText) {
       state5.updatedAt = Date.now();
       if (state5.activePage !== "response") state5.dirtyPages.response = true;
     }
     return;
   }
   if ((event.type === "assistant_text" || event.type === "stream_end") && event.content) {
-    const next = cleanTelegramVisibleReply(event.content, {
-      suppressPotentialNoReplyPrefix: true
-    });
-    if (next) {
-      state5.responseText = next;
+    const turn = telegramAdminEventTurn(event);
+    const key = turn !== void 0 ? `turn:${turn}` : state5.activeResponseSegmentKey ?? `event:${++state5.responseSegmentSequence}`;
+    upsertTelegramAdminResponseSegment(state5, key, turn, event.content, true);
+    if (state5.activeResponseSegmentKey === key) {
+      state5.activeResponseSegmentKey = void 0;
+    }
+    if (state5.responseText) {
       state5.updatedAt = Date.now();
       if (state5.activePage !== "response") state5.dirtyPages.response = true;
     }
@@ -782341,27 +782800,71 @@ function applyTelegramAdminLivePanelEvent(state5, event) {
   }
 }
 function renderTelegramAdminLivePanelPayload(state5) {
-  state5.dirtyPages[state5.activePage] = false;
-  const header = [
-    `<b>Admin run:</b> <code>${escapeTelegramHTML(state5.status)}</code>`,
-    state5.requestPreview ? `<i>${escapeTelegramHTML(state5.requestPreview)}</i>` : ""
-  ].filter(Boolean).join("\n");
+  const metadata = [
+    { label: "Run status", value: state5.status },
+    ...state5.requestPreview ? [{ label: "Request", value: state5.requestPreview }] : []
+  ];
   let body;
+  let richHtml;
   if (state5.activePage === "response") {
     const response = state5.responseText.trim();
     const clipped = response.length > 2600 ? `${response.slice(0, 2597).trimEnd()}...` : response;
-    body = clipped ? convertMarkdownToTelegramHTML(clipped) : "<i>Working…</i>";
+    const steeringHtml = formatTelegramSteeringReconciliationHTML(
+      state5.steeringReconciliations
+    );
+    body = [
+      steeringHtml,
+      clipped ? convertMarkdownToTelegramHTML(clipped) : "<i>Working…</i>"
+    ].filter(Boolean).join("\n\n");
   } else if (state5.activePage === "tools") {
     const lines = state5.toolLines.slice(-12);
-    body = lines.length > 0 ? `<blockquote>${escapeTelegramHTML(lines.join("\n"))}</blockquote>` : "<i>No tool calls yet.</i>";
+    const rendered = renderTelegramPanelPage({
+      title: "Tools",
+      subtitle: `${lines.length} recent tool event${lines.length === 1 ? "" : "s"}. Newest is last.`,
+      metadata,
+      sections: [{ packets: telegramAdminLinePackets(lines, "Tool event") }],
+      emptyText: "No tool calls yet.",
+      footer: "Page 2 of 5 · Tools"
+    });
+    body = telegramPanelHtmlFallback(rendered.html);
+    richHtml = rendered.richHtml;
   } else if (state5.activePage === "logs") {
-    const lines = [
-      ...state5.mutationLines.slice(-8),
-      ...state5.logLines.slice(-10)
-    ];
-    body = lines.length > 0 ? `<blockquote expandable>${escapeTelegramHTML(lines.join("\n"))}</blockquote>` : "<i>No mutations or logs yet.</i>";
+    const mutations = state5.mutationLines.slice(-8);
+    const logs = state5.logLines.slice(-10);
+    const rendered = renderTelegramPanelPage({
+      title: "Activity",
+      subtitle: `${mutations.length} workspace change event${mutations.length === 1 ? "" : "s"}; ${logs.length} runner event${logs.length === 1 ? "" : "s"}.`,
+      metadata,
+      sections: [
+        {
+          title: "Workspace changes",
+          packets: telegramAdminLinePackets(mutations, "Change")
+        },
+        {
+          title: "Run activity",
+          packets: telegramAdminLinePackets(logs, "Event")
+        }
+      ],
+      emptyText: "No workspace changes or runner activity yet.",
+      footer: "Page 3 of 5 · Activity"
+    });
+    body = telegramPanelHtmlFallback(rendered.html);
+    richHtml = rendered.richHtml;
   } else if (state5.activePage === "evidence") {
-    body = state5.evidenceText.trim() ? `<blockquote expandable>${escapeTelegramHTML(state5.evidenceText.trim())}</blockquote>` : "<i>No completion evidence yet.</i>";
+    const packets = telegramTitledTextPackets(
+      state5.evidenceText,
+      "Completion evidence"
+    );
+    const rendered = renderTelegramPanelPage({
+      title: "Evidence",
+      subtitle: `${packets.length} completion evidence packet${packets.length === 1 ? "" : "s"}.`,
+      metadata,
+      sections: [{ packets }],
+      emptyText: "No completion evidence yet.",
+      footer: "Page 4 of 5 · Evidence"
+    });
+    body = telegramPanelHtmlFallback(rendered.html);
+    richHtml = rendered.richHtml;
   } else {
     const pageCount = state5.contextPages.length;
     const pageIndex = Math.min(
@@ -782370,36 +782873,20 @@ function renderTelegramAdminLivePanelPayload(state5) {
     );
     state5.contextPageIndex = pageIndex;
     const page2 = state5.contextPages[pageIndex];
-    if (page2) {
-      const meta = page2.metadata.map((line) => `<code>${escapeTelegramHTML(line)}</code>`).join("\n");
-      body = [
-        `<b>${escapeTelegramHTML(page2.title)}</b>`,
-        `Source: <code>${escapeTelegramHTML(page2.source)}</code>`,
-        meta,
-        "",
-        page2.body.trim() ? `<blockquote expandable>${escapeTelegramHTML(page2.body)}</blockquote>` : "<i>Section was empty.</i>",
-        "",
-        `<i>Context ${pageIndex + 1}/${pageCount}</i>`
-      ].filter(Boolean).join("\n");
-    } else {
-      body = "<i>Full context has not been captured yet.</i>";
-    }
+    const rendered = renderTelegramContextExplorerPagePayload(
+      page2,
+      pageIndex,
+      pageCount,
+      "Context"
+    );
+    body = rendered.text;
+    richHtml = rendered.rich_html;
   }
-  const panelText = state5.activePage === "response" ? body : [
-    header,
-    "",
-    body,
-    "",
-    `<i>Page ${TELEGRAM_ADMIN_LIVE_PANEL_PAGES.indexOf(state5.activePage) + 1}/${TELEGRAM_ADMIN_LIVE_PANEL_PAGES.length}: ${telegramAdminLivePanelPageLabel(state5.activePage)}</i>`
-  ].join("\n");
-  const text3 = truncateTelegramUrlSafe(
-    panelText,
-    3900,
-    "\n\n<i>... (panel clipped)</i>"
-  );
+  const text3 = body;
   const pageButtons = TELEGRAM_ADMIN_LIVE_PANEL_PAGES.map((page2) => ({
     text: `${page2 === state5.activePage ? "●" : "○"} ${telegramAdminLivePanelPageLabel(page2)}${state5.dirtyPages[page2] ? " *" : ""}`,
-    callback_data: `omni:v1:tgadmin:${state5.nonce}:page:${page2}`
+    callback_data: `omni:v1:tgadmin:${state5.nonce}:page:${page2}`,
+    ...page2 === state5.activePage ? { style: "primary" } : {}
   }));
   const keyboard = [
     pageButtons.slice(0, 3),
@@ -782411,19 +782898,28 @@ function renderTelegramAdminLivePanelPayload(state5) {
     keyboard.push([
       {
         text: "Prev",
-        callback_data: `omni:v1:tgadmin:${state5.nonce}:ctx:${Math.max(0, pageIndex - 1)}`
+        ...pageIndex > 0 ? {
+          callback_data: `omni:v1:tgadmin:${state5.nonce}:ctx:${pageIndex - 1}`
+        } : { disabled: {} }
       },
       {
         text: `${pageIndex + 1}/${lastPage + 1}`,
-        callback_data: `omni:v1:tgadmin:${state5.nonce}:ctx:${pageIndex}`
+        disabled: {},
+        style: "primary"
       },
       {
         text: "Next",
-        callback_data: `omni:v1:tgadmin:${state5.nonce}:ctx:${Math.min(lastPage, pageIndex + 1)}`
+        ...pageIndex < lastPage ? {
+          callback_data: `omni:v1:tgadmin:${state5.nonce}:ctx:${pageIndex + 1}`
+        } : { disabled: {} }
       }
     ]);
   }
-  return { text: text3, reply_markup: { inline_keyboard: keyboard } };
+  return {
+    text: text3,
+    ...richHtml ? { rich_html: richHtml } : {},
+    reply_markup: { inline_keyboard: keyboard }
+  };
 }
 function splitTelegramReminderDue(raw) {
   const text3 = raw.trim().replace(/^set\s+/i, "").trim();
@@ -793345,10 +793841,14 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
        * Send a placeholder message that will be progressively edited with
        * streamed content. Returns the message_id for subsequent edits.
        */
-      async sendLiveMessage(chatId, initialText, replyToMessageId, replyMarkup) {
+      async sendLiveMessage(chatId, initialText, replyToMessageId, replyMarkup, richHtml) {
         const normalizedInitialText = normalizeTelegramOutboundLinks(initialText);
+        const normalizedRichHtml = richHtml ? normalizeTelegramOutboundLinks(richHtml) : "";
         try {
-          const body = {
+          const body = normalizedRichHtml ? {
+            chat_id: chatId,
+            rich_message: { html: normalizedRichHtml }
+          } : {
             chat_id: chatId,
             text: normalizedInitialText,
             parse_mode: "HTML"
@@ -793356,15 +793856,16 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
           const replyParameters = telegramReplyParameters(replyToMessageId);
           if (replyParameters) body["reply_parameters"] = replyParameters;
           if (replyMarkup) body["reply_markup"] = replyMarkup;
-          const result = await this.apiCall("sendMessage", body);
+          const method = normalizedRichHtml ? "sendRichMessage" : "sendMessage";
+          const result = await this.apiCall(method, body);
           if (result.ok === false) {
             throw new Error(
-              String(result.description || "Telegram sendMessage failed")
+              String(result.description || `Telegram ${method} failed`)
             );
           }
           const messageId = result.result?.message_id;
           if (!Number.isInteger(messageId)) {
-            throw new Error("Telegram sendMessage returned no valid message_id");
+            throw new Error(`Telegram ${method} returned no valid message_id`);
           }
           this.state.messagesSent++;
           this.updateTelegramTextDeliveryCapability(chatId, {
@@ -793374,10 +793875,43 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
           });
           return messageId;
         } catch {
+          if (normalizedRichHtml) {
+            try {
+              const body = {
+                chat_id: chatId,
+                text: normalizedInitialText,
+                parse_mode: "HTML"
+              };
+              const replyParameters = telegramReplyParameters(replyToMessageId);
+              if (replyParameters) body["reply_parameters"] = replyParameters;
+              if (replyMarkup) body["reply_markup"] = replyMarkup;
+              const result = await this.apiCall("sendMessage", body);
+              if (result.ok === false) {
+                throw new Error(
+                  String(result.description || "Telegram sendMessage failed")
+                );
+              }
+              const messageId = result.result?.message_id;
+              if (!Number.isInteger(messageId)) {
+                throw new Error(
+                  "Telegram sendMessage returned no valid message_id"
+                );
+              }
+              this.state.messagesSent++;
+              this.updateTelegramTextDeliveryCapability(chatId, {
+                status: "allowed",
+                canSendText: true,
+                source: "sendLiveMessage.html_fallback"
+              });
+              return messageId;
+            } catch {
+            }
+          }
           try {
+            const readablePlain = telegramHtmlToPlainText(normalizedInitialText);
             const body = {
               chat_id: chatId,
-              text: normalizedInitialText
+              text: readablePlain || "No displayable content."
             };
             const replyParameters = telegramReplyParameters(replyToMessageId);
             if (replyParameters) body["reply_parameters"] = replyParameters;
@@ -793425,19 +793959,18 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
        * Edit a live message with updated content. Used for progressive streaming.
        * Handles rate limits and Telegram's "message is not modified" error silently.
        */
-      async editLiveMessage(chatId, messageId, html, replyMarkup) {
+      async editLiveMessage(chatId, messageId, html, replyMarkup, richHtml) {
         const normalizedHtml = normalizeTelegramOutboundLinks(html);
-        const truncated = normalizedHtml.length > 4e3 ? truncateTelegramUrlSafe(
-          normalizedHtml,
-          4e3,
-          "\n\n<i>... (streaming)</i>"
-        ) : normalizedHtml;
+        const normalizedRichHtml = richHtml ? normalizeTelegramOutboundLinks(richHtml) : "";
+        const htmlSegments = segmentTelegramHtml(normalizedHtml, 3600);
+        const truncated = htmlSegments.length > 1 ? `${htmlSegments[0]}
+
+<i>... (additional detail clipped)</i>` : htmlSegments[0] ?? normalizedHtml;
         try {
           const result = await this.apiCall("editMessageText", {
             chat_id: chatId,
             message_id: messageId,
-            text: truncated,
-            parse_mode: "HTML",
+            ...normalizedRichHtml ? { rich_message: { html: normalizedRichHtml } } : { text: truncated, parse_mode: "HTML" },
             ...replyMarkup ? { reply_markup: replyMarkup } : {}
           });
           if (result.error_code === 400 && result.description?.includes("not modified"))
@@ -793449,8 +793982,24 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
             );
           return true;
         } catch {
+          if (normalizedRichHtml) {
+            try {
+              const result = await this.apiCall("editMessageText", {
+                chat_id: chatId,
+                message_id: messageId,
+                text: truncated,
+                parse_mode: "HTML",
+                ...replyMarkup ? { reply_markup: replyMarkup } : {}
+              });
+              if (result.error_code === 400 && result.description?.includes("not modified"))
+                return true;
+              if (result.error_code === 429) return false;
+              if (result.ok !== false) return true;
+            } catch {
+            }
+          }
           try {
-            const plain = normalizedHtml.replace(/<[^>]+>/g, "");
+            const plain = telegramHtmlToPlainText(normalizedHtml);
             const truncPlain = plain.length > 4e3 ? truncateTelegramUrlSafe(plain, 4e3, "\n\n... (streaming)") : plain;
             const result = await this.apiCall("editMessageText", {
               chat_id: chatId,
@@ -793565,24 +794114,32 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
       async renderTelegramAdminLivePanel(state5, replyToMessageId) {
         const payload = renderTelegramAdminLivePanelPayload(state5);
         if (state5.messageId !== void 0) {
-          return this.editLiveMessage(
+          const delivered = await this.editLiveMessage(
             state5.chatId,
             state5.messageId,
             payload.text,
-            payload.reply_markup
+            payload.reply_markup,
+            payload.rich_html
           );
+          if (delivered) state5.dirtyPages[state5.activePage] = false;
+          return delivered;
         }
         const messageId = await this.sendLiveMessage(
           state5.chatId,
           payload.text,
           replyToMessageId,
-          payload.reply_markup
+          payload.reply_markup,
+          payload.rich_html
         );
         state5.messageId = messageId;
+        state5.dirtyPages[state5.activePage] = false;
         return true;
       }
       updateTelegramAdminLivePanelFromEvent(subAgent, msg, event) {
         const state5 = this.ensureTelegramAdminLivePanel(subAgent, msg);
+        state5.steeringReconciliations = [
+          ...subAgent.steeringReconciliations.values()
+        ];
         applyTelegramAdminLivePanelEvent(state5, event);
         if (event.contextFrame || state5.contextPages.length === 0 && (subAgent.contextFrame || subAgent.promptSnapshot)) {
           this.refreshTelegramAdminLivePanelContextPages(state5, subAgent, msg);
@@ -793606,13 +794163,18 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
       async finalizeTelegramAdminLivePanel(subAgent, msg, replyText, status = "completed", evidenceText = "") {
         const state5 = this.ensureTelegramAdminLivePanel(subAgent, msg);
         state5.status = status;
+        state5.steeringReconciliations = [
+          ...subAgent.steeringReconciliations.values()
+        ];
         state5.responseText = replyText || (status === "failed" ? "I couldn't complete that request." : "Done.");
+        state5.responseSegments = [];
+        state5.activeResponseSegmentKey = void 0;
         if (evidenceText.trim()) {
           state5.evidenceText = evidenceText.trim();
           state5.dirtyPages.evidence = true;
         }
-        state5.activePage = "response";
-        state5.dirtyPages.response = false;
+        if (state5.activePage === "response") state5.dirtyPages.response = false;
+        else state5.dirtyPages.response = true;
         state5.updatedAt = Date.now();
         this.refreshTelegramAdminLivePanelContextPages(state5, subAgent, msg);
         if (subAgent.liveMessagePromise)
@@ -793747,6 +794309,7 @@ ${signals || summary || "Canonical runner status reported completed."}`
             [
               {
                 text: "Admin context",
+                style: "primary",
                 callback_data: this.telegramContextExplorerCallbackData(
                   id2,
                   "open",
@@ -793765,35 +794328,36 @@ ${signals || summary || "Canonical runner status reported completed."}`
             [
               {
                 text: "Prev",
-                callback_data: this.telegramContextExplorerCallbackData(
-                  state5.id,
-                  "page",
-                  Math.max(0, page2 - 1)
-                )
+                ...page2 > 0 ? {
+                  callback_data: this.telegramContextExplorerCallbackData(
+                    state5.id,
+                    "page",
+                    page2 - 1
+                  )
+                } : { disabled: {} }
               },
               {
                 text: `${page2 + 1}/${lastPage + 1}`,
-                callback_data: this.telegramContextExplorerCallbackData(
-                  state5.id,
-                  "noop",
-                  page2
-                )
+                disabled: {},
+                style: "primary"
               },
               {
                 text: "Next",
-                callback_data: this.telegramContextExplorerCallbackData(
-                  state5.id,
-                  "page",
-                  Math.min(lastPage, page2 + 1)
-                )
+                ...page2 < lastPage ? {
+                  callback_data: this.telegramContextExplorerCallbackData(
+                    state5.id,
+                    "page",
+                    page2 + 1
+                  )
+                } : { disabled: {} }
               }
             ],
             [
               {
-                text: "Reply",
+                text: "Close context",
                 callback_data: this.telegramContextExplorerCallbackData(
                   state5.id,
-                  "reply",
+                  "close",
                   page2
                 )
               }
@@ -793804,7 +794368,7 @@ ${signals || summary || "Canonical runner status reported completed."}`
       splitTelegramContextBody(text3, maxLength = 2500) {
         const cleaned = stripTelegramHiddenThinking(text3 || "").trim();
         if (!cleaned) return [""];
-        return splitTelegramMessageText(cleaned, maxLength);
+        return splitTelegramPlainText(cleaned, maxLength);
       }
       addTelegramContextExplorerPages(pages, title, source, body, metadata) {
         const chunks = this.splitTelegramContextBody(body);
@@ -793844,7 +794408,7 @@ ${signals || summary || "Canonical runner status reported completed."}`
           "",
           "Visible reply preview:",
           cleanTelegramVisibleReply(finalText).slice(0, 900) || "(empty)"
-        ].filter((line) => line !== "").join("\n");
+        ].join("\n").replace(/\n{3,}/g, "\n\n").trim();
         pages.push({
           title: "Overview",
           source: "telegram.final_reply",
@@ -793855,6 +794419,23 @@ ${signals || summary || "Canonical runner status reported completed."}`
             `chat_id=${String(msg.chatId)}`
           ]
         });
+        const reconciliations = [...subAgent.steeringReconciliations.values()];
+        if (reconciliations.length > 0) {
+          this.addTelegramContextExplorerPages(
+            pages,
+            "Plan updates",
+            "runner.steering_reconciliation",
+            reconciliations.map(
+              (value2, index) => [
+                `Update ${index + 1}:`,
+                `Status: ${value2.status.replaceAll("_", " ")}`,
+                ...value2.changedConstraints.length > 0 ? value2.changedConstraints.map((item) => `Change: ${item}`) : ["Change: none"],
+                `Next: ${value2.revisedNextAction}`
+              ].join("\n")
+            ).join("\n\n"),
+            [`count=${reconciliations.length}`, "visibility=admin-only"]
+          );
+        }
         if (frame2) {
           for (const section of frame2.sections) {
             this.addTelegramContextExplorerPages(
@@ -793945,23 +794526,43 @@ ${signals || summary || "Canonical runner status reported completed."}`
             [`count=${prompt.toolNames.length}`]
           );
         }
-        return pages;
+        const redactor = getSecretRedactor();
+        const redactedPages = pages.map((page2) => ({
+          title: redactor.redactText(page2.title),
+          source: redactor.redactText(page2.source),
+          body: redactor.redactText(page2.body),
+          metadata: page2.metadata.map((line) => redactor.redactText(line))
+        }));
+        const maxPages = 64;
+        if (redactedPages.length <= maxPages) return redactedPages;
+        const omitted = redactedPages.length - (maxPages - 1);
+        return [
+          ...redactedPages.slice(0, maxPages - 1),
+          {
+            title: "Omitted context packets",
+            source: "telegram.context_budget",
+            body: `${omitted} additional packet${omitted === 1 ? " was" : "s were"} omitted from this interactive view.`,
+            metadata: [
+              `retained=${maxPages - 1}`,
+              `omitted=${omitted}`,
+              `total=${redactedPages.length}`
+            ]
+          }
+        ];
       }
-      buildTelegramContextExplorerState(msg, subAgent, finalHtml, finalText) {
+      buildTelegramContextExplorerState(msg, subAgent, finalText) {
         const pages = this.buildTelegramContextExplorerPages(
           msg,
           subAgent,
           finalText
         );
         if (pages.length === 0) return null;
-        const finalHtmlFirstChunk = splitTelegramMessageText(finalHtml, 3900)[0] ?? finalHtml;
         const id2 = randomBytes29(6).toString("hex");
         const now2 = Date.now();
         return {
           id: id2,
-          chatId: msg.chatId,
-          messageId: null,
-          finalHtml: finalHtmlFirstChunk,
+          sourceChatId: msg.chatId,
+          sourceMessageId: null,
           activePage: 0,
           pages,
           createdAtMs: now2,
@@ -793974,20 +794575,10 @@ ${signals || summary || "Canonical runner status reported completed."}`
           Math.max(0, state5.pages.length - 1)
         );
         const page2 = state5.pages[pageIndex];
-        if (!page2) return "<b>Context frame</b>\n<i>No pages available.</i>";
-        const meta = page2.metadata.map((line) => `<code>${escapeTelegramHTML(line)}</code>`).join("\n");
-        const body = page2.body.trim() ? `<blockquote expandable>${escapeTelegramHTML(page2.body)}</blockquote>` : "<i>Section was empty.</i>";
-        return truncateTelegramUrlSafe(
-          [
-            `<b>Context frame</b>`,
-            `<i>Page ${pageIndex + 1}/${state5.pages.length}: ${escapeTelegramHTML(page2.title)}</i>`,
-            `Source: <code>${escapeTelegramHTML(page2.source)}</code>`,
-            meta,
-            "",
-            body
-          ].filter(Boolean).join("\n"),
-          3900,
-          "\n\n<i>... (context page clipped)</i>"
+        return renderTelegramContextExplorerPagePayload(
+          page2,
+          pageIndex,
+          state5.pages.length
         );
       }
       async handleTelegramContextExplorerCallback(callback) {
@@ -794014,36 +794605,94 @@ ${signals || summary || "Canonical runner status reported completed."}`
           }
           const action = parts[4];
           const requestedPage = Number.parseInt(parts[5] ?? "0", 10);
-          const messageId = state5.messageId ?? callback.messageId;
-          if (messageId === void 0) {
-            answerText = "Cannot identify context frame message.";
+          if (action === "open") {
+            if (callback.chatId !== state5.sourceChatId || callback.messageId !== state5.sourceMessageId) {
+              answerText = "This context button is not bound to this message.";
+              alert = true;
+              return;
+            }
+            const maxPage2 = Math.max(0, state5.pages.length - 1);
+            const nextPage2 = Number.isFinite(requestedPage) ? Math.min(maxPage2, Math.max(0, requestedPage)) : 0;
+            const previousPage2 = state5.activePage;
+            state5.activePage = nextPage2;
+            const payload2 = this.renderTelegramContextExplorerPage(state5);
+            const markup = this.telegramContextExplorerPageMarkup(state5);
+            try {
+              if (state5.panelMessageId !== void 0 && state5.panelChatId === callback.fromUserId) {
+                const edited2 = await this.editLiveMessage(
+                  callback.fromUserId,
+                  state5.panelMessageId,
+                  payload2.text,
+                  markup,
+                  payload2.rich_html
+                );
+                if (!edited2) throw new Error("Telegram did not apply the DM edit");
+              } else {
+                state5.panelMessageId = await this.sendLiveMessage(
+                  callback.fromUserId,
+                  payload2.text,
+                  void 0,
+                  markup,
+                  payload2.rich_html
+                );
+              }
+            } catch {
+              state5.activePage = previousPage2;
+              answerText = `Open a private chat with @${this.state.botUsername || "omnius_agent_bot"}, press Start, then try again.`;
+              alert = true;
+              return;
+            }
+            state5.viewerUserId = callback.fromUserId;
+            state5.panelChatId = callback.fromUserId;
+            answerText = "Opened the context packets in your private chat.";
+            return;
+          }
+          const panelChatId = state5.panelChatId;
+          const panelMessageId = state5.panelMessageId;
+          if (state5.viewerUserId !== callback.fromUserId || panelChatId === void 0 || panelMessageId === void 0 || callback.chatId !== panelChatId || callback.messageId !== panelMessageId) {
+            answerText = "This private context panel is not bound to this callback.";
             alert = true;
             return;
           }
-          state5.messageId = messageId;
           if (action === "noop") return;
-          if (action === "reply") {
-            await this.editLiveMessage(
-              state5.chatId,
-              messageId,
-              state5.finalHtml,
-              this.telegramContextExplorerReplyMarkup(state5.id)
+          if (action === "close") {
+            const closed = await this.editLiveMessage(
+              panelChatId,
+              panelMessageId,
+              "<b>Context panel closed.</b>"
             );
+            if (!closed) {
+              answerText = "Telegram did not close this context panel. Try again.";
+              alert = true;
+              return;
+            }
+            state5.panelMessageId = void 0;
+            state5.panelChatId = void 0;
+            state5.viewerUserId = void 0;
             return;
           }
-          if (action !== "open" && action !== "page") {
+          if (action !== "page") {
             answerText = "Unknown context frame action.";
             alert = true;
             return;
           }
           const maxPage = Math.max(0, state5.pages.length - 1);
-          state5.activePage = Number.isFinite(requestedPage) ? Math.min(maxPage, Math.max(0, requestedPage)) : 0;
-          await this.editLiveMessage(
-            state5.chatId,
-            messageId,
-            this.renderTelegramContextExplorerPage(state5),
-            this.telegramContextExplorerPageMarkup(state5)
+          const nextPage = Number.isFinite(requestedPage) ? Math.min(maxPage, Math.max(0, requestedPage)) : 0;
+          const previousPage = state5.activePage;
+          state5.activePage = nextPage;
+          const payload = this.renderTelegramContextExplorerPage(state5);
+          const edited = await this.editLiveMessage(
+            panelChatId,
+            panelMessageId,
+            payload.text,
+            this.telegramContextExplorerPageMarkup(state5),
+            payload.rich_html
           );
+          if (!edited) {
+            state5.activePage = previousPage;
+            answerText = "Telegram did not apply this context page. Try again.";
+            alert = true;
+          }
         } catch (err) {
           answerText = err instanceof Error ? err.message : String(err);
           alert = true;
@@ -794616,7 +795265,8 @@ Join: ${newUrl}`
           validatedMediaArtifacts: /* @__PURE__ */ new Set(),
           deliveredArtifacts: [],
           deliveredFileSends: /* @__PURE__ */ new Set(),
-          surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
+          surfacedToolCallFingerprints: /* @__PURE__ */ new Set(),
+          steeringReconciliations: /* @__PURE__ */ new Map()
         };
         this.subAgents.set(sessionKey, subAgent);
         for (const intake of work.intakeRecords) {
@@ -794803,11 +795453,12 @@ Join: ${newUrl}`
           }
           const deliveredFinalText = finalText;
           const adminEvidenceText = isAdminDM ? this.telegramAdminCompletionRunText(subAgent, finalText) : "";
-          const finalHtml = convertMarkdownToTelegramHTML(deliveredFinalText);
+          const finalHtml = isAdminDM ? composeTelegramReplyWithSteeringHTML(deliveredFinalText, [
+            ...subAgent.steeringReconciliations.values()
+          ]) : convertMarkdownToTelegramHTML(deliveredFinalText);
           const contextExplorerState = !isAdminDM && msg.chatType !== "private" && !msg.guestQueryId ? this.buildTelegramContextExplorerState(
             msg,
             subAgent,
-            finalHtml,
             deliveredFinalText
           ) : null;
           const contextExplorerReplyMarkup = contextExplorerState ? this.telegramContextExplorerReplyMarkup(contextExplorerState.id) : void 0;
@@ -794825,7 +795476,7 @@ Join: ${newUrl}`
           );
           if (contextExplorerState && sentMessageId !== null) {
             this.pruneTelegramContextExplorers();
-            contextExplorerState.messageId = sentMessageId;
+            contextExplorerState.sourceMessageId = sentMessageId;
             this.telegramContextExplorerStates.set(
               contextExplorerState.id,
               contextExplorerState
@@ -794967,7 +795618,8 @@ ${errMsg}`
           validatedMediaArtifacts: /* @__PURE__ */ new Set(),
           deliveredArtifacts: [],
           deliveredFileSends: /* @__PURE__ */ new Set(),
-          surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
+          surfacedToolCallFingerprints: /* @__PURE__ */ new Set(),
+          steeringReconciliations: /* @__PURE__ */ new Map()
         };
         this.subAgents.set(sessionKey, subAgent);
         const primaryIntake = this.telegramIntakeRecords.get(
@@ -795124,7 +795776,10 @@ ${errMsg}`
             subAgent,
             deliveredFinalText
           );
-          const finalHtml = convertMarkdownToTelegramHTML(deliveredFinalText);
+          const finalHtml = composeTelegramReplyWithSteeringHTML(
+            deliveredFinalText,
+            [...subAgent.steeringReconciliations.values()]
+          );
           const sentMessageId = !msg.guestQueryId ? await this.finalizeTelegramAdminLivePanel(
             subAgent,
             msg,
@@ -795681,6 +796336,20 @@ ${creativeWorkspace}` : ""
           // ── WO #03 (Typed Gateway Event Stream): structured event feed ──
           onTypedEvent: (event) => {
             this.forwardTelegramRunnerIntakeLifecycle(event);
+            if (event.type === "steering_lifecycle" && event.reconciliation) {
+              upsertTelegramSteeringReconciliation(
+                subAgent.steeringReconciliations,
+                event.reconciliation
+              );
+              if (isAdminDM) {
+                const state5 = this.ensureTelegramAdminLivePanel(subAgent, msg);
+                state5.steeringReconciliations = [
+                  ...subAgent.steeringReconciliations.values()
+                ];
+                if (state5.activePage !== "response")
+                  state5.dirtyPages.response = true;
+              }
+            }
             if (event.type === "run_finished") {
               subAgent.runnerCompleted = event.success;
               subAgent.runnerStatus = event.status;
@@ -795744,13 +796413,12 @@ ${creativeWorkspace}` : ""
           );
         }
         runner.registerTools(tools);
-        const telegramSteeringFilter = new SteeringReconciliationStreamFilter({
-          suppressTrailingContent: true
-        });
+        const telegramSteeringFilter = new SteeringReconciliationStreamFilter();
         runner.onEvent((event) => {
           if (subAgent.aborted) return;
           subAgent.lastActivityMs = Date.now();
           let suppressExternalEvent = false;
+          let telegramDisplayEvent = event;
           if (event.contextFrame) {
             subAgent.contextFrame = event.contextFrame;
           }
@@ -795822,6 +796490,7 @@ ${creativeWorkspace}` : ""
             }
           } else if (event.type === "assistant_text" && event.content && event.source !== "task_complete_summary") {
             subAgent.assistantText = cleanTelegramVisibleReply(event.content);
+            telegramDisplayEvent = subAgent.assistantText ? { ...event, content: subAgent.assistantText } : null;
           } else if (event.type === "stream_start") {
             this.retainTelegramVisibleReplyFromCompletedStream(subAgent);
             subAgent.accumulated = "";
@@ -795832,9 +796501,12 @@ ${creativeWorkspace}` : ""
             const finalBuffered = telegramSteeringFilter.flush();
             if (finalBuffered) subAgent.accumulated += finalBuffered;
             subAgent.streamText = cleanTelegramVisibleReply(event.content);
+            telegramDisplayEvent = subAgent.streamText ? { ...event, content: subAgent.streamText } : null;
           }
           if (event.type === "stream_token" && event.streamKind === "content" && event.content) {
-            subAgent.accumulated += telegramSteeringFilter.consume(event.content);
+            const visibleChunk = telegramSteeringFilter.consume(event.content);
+            subAgent.accumulated += visibleChunk;
+            telegramDisplayEvent = visibleChunk ? { ...event, content: visibleChunk } : null;
           }
           if (event.type === "stream_token" && event.streamKind === "thinking" && event.content && this.telegramThinkingVisible) {
             const trimmed = event.content.replace(/\s+/g, " ").slice(0, 200);
@@ -795849,7 +796521,13 @@ ${creativeWorkspace}` : ""
           }
           if (!msg.guestQueryId) {
             if (isAdminDM) {
-              this.updateTelegramAdminLivePanelFromEvent(subAgent, msg, event);
+              if (telegramDisplayEvent) {
+                this.updateTelegramAdminLivePanelFromEvent(
+                  subAgent,
+                  msg,
+                  telegramDisplayEvent
+                );
+              }
               return;
             }
             const html = renderTelegramLiveProgressHTML(
@@ -799689,8 +800367,14 @@ ${this.quoteTelegramContextBlock(msg.text, 800)}`,
               return;
             }
             state5.messageId = messageId;
-            await this.renderTelegramAdminLivePanel(state5);
-            answerText2 = "";
+            const delivered = await this.renderTelegramAdminLivePanel(state5);
+            if (!delivered) {
+              state5.dirtyPages[state5.activePage] = true;
+              answerText2 = "Telegram did not apply this panel update. Try again.";
+              alert2 = true;
+            } else {
+              answerText2 = "";
+            }
           } catch (err) {
             answerText2 = err instanceof Error ? err.message : String(err);
             alert2 = true;