@integrity-labs/agt-cli 0.28.457 → 0.28.459

package/dist/mcp/telegram-channel.js

@@ -18906,7 +18906,7 @@ var require_filters = __commonJS({
       return r.copySafeness(str, res);
     }
     _exports.indent = indent;
-    function join17(arr, del, attr) {
+    function join18(arr, del, attr) {
       del = del || "";
       if (attr) {
         arr = lib.map(arr, function(v) {
@@ -18915,7 +18915,7 @@ var require_filters = __commonJS({
       }
       return arr.join(del);
     }
-    _exports.join = join17;
+    _exports.join = join18;
     function last(arr) {
       return arr[arr.length - 1];
     }
@@ -22516,11 +22516,11 @@ async function waitForResolution(cfg, callbackId, opts) {
       }
     } catch {
     }
-    await sleep2(interval);
+    await sleep3(interval);
   }
   return { kind: "timeout" };
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 function generateOptionToken() {
@@ -30132,18 +30132,18 @@ import {
   ftruncateSync,
   mkdirSync as mkdirSync9,
   openSync,
-  readFileSync as readFileSync16,
-  readdirSync as readdirSync5,
+  readFileSync as readFileSync17,
+  readdirSync as readdirSync6,
   realpathSync,
   renameSync as renameSync7,
-  statSync as statSync4,
+  statSync as statSync5,
   unlinkSync as unlinkSync8,
   watch,
   writeFileSync as writeFileSync11,
   writeSync
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { basename, extname, join as join16, resolve as resolve2 } from "path";
+import { basename, extname, join as join17, resolve as resolve2 } from "path";
 
 // src/channel-attachments.ts
 import { homedir } from "os";
@@ -34354,6 +34354,160 @@ function classifyTranscriptRateLimit(jsonl, startMs, endMs, now) {
   return newest;
 }
 
+// ../core/dist/claude-code-usage/turn-failure-classifier.js
+var UNKNOWN_TURN_FAILURE = Object.freeze({
+  outcome: "unknown",
+  atMs: null,
+  failureClass: null,
+  httpStatus: null,
+  attempt: null,
+  maxAttempts: null
+});
+var EXCLUDED_STATUSES = /* @__PURE__ */ new Set([429]);
+function classifyTransientStatus(status) {
+  if (!Number.isFinite(status))
+    return null;
+  if (EXCLUDED_STATUSES.has(status))
+    return null;
+  if (status === 529)
+    return "overloaded";
+  if (status >= 500 && status <= 599)
+    return "server_error";
+  return null;
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isErrorShaped(record2) {
+  if (record2.isApiErrorMessage === true)
+    return true;
+  if (record2.type === "system" && record2.level === "error")
+    return true;
+  if (record2.type === "assistant" && typeof record2.error === "string" && record2.error)
+    return true;
+  return false;
+}
+function classifyRecord(record2, tsMs) {
+  if (record2.isSidechain === true)
+    return null;
+  if (record2.type === "system" && record2.subtype === "api_error") {
+    const error2 = record2.error;
+    const status = typeof error2 === "object" && error2 !== null ? numberOrNull(error2.status) : null;
+    if (status === null)
+      return null;
+    const failureClass = classifyTransientStatus(status);
+    if (!failureClass)
+      return null;
+    return {
+      outcome: "retrying",
+      atMs: tsMs,
+      failureClass,
+      httpStatus: status,
+      attempt: numberOrNull(record2.retryAttempt),
+      maxAttempts: numberOrNull(record2.maxRetries)
+    };
+  }
+  if (record2.type !== "assistant")
+    return null;
+  if (record2.isApiErrorMessage === true) {
+    const status = numberOrNull(record2.apiErrorStatus);
+    const failureClass = status === null ? null : classifyTransientStatus(status);
+    if (!failureClass)
+      return null;
+    return {
+      outcome: "failed",
+      atMs: tsMs,
+      failureClass,
+      httpStatus: status,
+      attempt: null,
+      maxAttempts: null
+    };
+  }
+  const message = record2.message;
+  if (typeof message !== "object" || message === null)
+    return null;
+  const msg = message;
+  if (msg.model === "<synthetic>")
+    return null;
+  const usage = msg.usage;
+  if (typeof usage !== "object" || usage === null)
+    return null;
+  const u = usage;
+  const spent = Number(u.input_tokens ?? 0) + Number(u.output_tokens ?? 0) + Number(u.cache_creation_input_tokens ?? 0) + Number(u.cache_read_input_tokens ?? 0);
+  if (!Number.isFinite(spent) || spent <= 0)
+    return null;
+  return {
+    outcome: "served",
+    atMs: tsMs,
+    failureClass: null,
+    httpStatus: null,
+    attempt: null,
+    maxAttempts: null
+  };
+}
+function pickNewerTurnFailure(current, next) {
+  if (next.outcome === "unknown")
+    return current;
+  if (current.outcome === "unknown")
+    return next;
+  return (next.atMs ?? 0) >= (current.atMs ?? 0) ? next : current;
+}
+function isShapeRecognised(record2) {
+  if (record2.type === "system" && record2.subtype === "api_error") {
+    const error2 = record2.error;
+    return typeof error2 === "object" && error2 !== null && numberOrNull(error2.status) !== null;
+  }
+  if (record2.type === "assistant" && record2.isApiErrorMessage === true) {
+    return numberOrNull(record2.apiErrorStatus) !== null;
+  }
+  return false;
+}
+function analyzeTranscriptTurnFailure(jsonl, startMs, endMs, opts = {}) {
+  const maxKeys = opts.maxKeys ?? 40;
+  let newest = UNKNOWN_TURN_FAILURE;
+  let coarse = 0;
+  let fine = 0;
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of jsonl.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (typeof obj !== "object" || obj === null)
+      continue;
+    const record2 = obj;
+    const ts = record2.timestamp;
+    if (typeof ts !== "string" || !ts)
+      continue;
+    const tsMs = new Date(ts).getTime();
+    if (!Number.isFinite(tsMs) || tsMs < startMs || tsMs > endMs)
+      continue;
+    const classified = classifyRecord(record2, tsMs);
+    if (classified)
+      newest = pickNewerTurnFailure(newest, classified);
+    if (!isErrorShaped(record2) || record2.isSidechain === true)
+      continue;
+    coarse++;
+    if (isShapeRecognised(record2)) {
+      fine++;
+      continue;
+    }
+    if (keys.size < maxKeys) {
+      for (const key2 of Object.keys(record2)) {
+        if (keys.size >= maxKeys)
+          break;
+        keys.add(key2);
+      }
+    }
+  }
+  return { result: newest, coarse, fine, unrecognisedKeys: [...keys].sort() };
+}
+
 // ../core/dist/claude-code-usage/transcript-location.js
 function encodeClaudeProjectPath(projectDir) {
   return "-" + projectDir.replace(/^\//, "").replace(/[/.]/g, "-");
@@ -35210,7 +35364,7 @@ var FLAG_REGISTRY = [
   },
   {
     key: "wedge-transient-notice",
-    description: 'When a wedge-respawn was preceded by a transient LLM-API error (529/429/503/500 that exhausted its retries and wedged the turn), the manager writes the ENG-6058 give-up signal tagged reason=transient_overload so the channel sweeps post a friendly "I hit a brief overload \u2014 please resend" notice instead of leaving the user in silence (ENG-7360, extends ENG-6861 to the retry-exhaustion + wedge path). Boolean gate; ships dark \u2014 channel-visible copy soaks per host before going wide.',
+    description: `Tell the person waiting when their turn dies on a transient LLM-API failure (529 overloaded / 5xx). TWO consumers now share this gate. (1) ENG-7360: a wedge-respawn preceded by such an error writes the ENG-6058 give-up signal tagged reason=transient_overload so the channel sweeps post a "please resend" notice. (2) ENG-8269: the channel MCPs watch the dispatched turn in Claude Code's own transcript and notify the conversation that was actually waiting \u2014 Slack, Telegram AND direct chat \u2014 plus a "still working on this" notice after ~3min on Slack/Telegram only (direct chat already shows a client-side one at 90s). NOTE: (2) fires on a MUCH larger population than (1) \u2014 any dispatched turn that dies, not only one that also wedged the session \u2014 and (1) has never actually been able to fire, because its pane.log detector cannot match the banner Claude Code renders today. So flipping this on is in practice enabling (2) for the first time. Boolean gate; ships dark \u2014 channel-visible copy soaks per host before going wide. Materialized into the channel-MCP spawn env: a Docker-isolated agent never mounts the host flags-cache, so a central flip reaches it only that way.`,
     flagType: "boolean",
     defaultValue: false,
     envVar: "AGT_WEDGE_TRANSIENT_NOTICE_ENABLED"
@@ -35704,6 +35858,22 @@ var FLAG_REGISTRY = [
     // registry-only (ADR-0022). NOT `public`: it is resolved server-side only, so it
     // must never be serialized into the browser map.
     defaultValue: false
+  },
+  {
+    key: "ninjafy-brand",
+    description: 'Present the product under the Ninjafy brand instead of Augmented Team (ENG-8250). This is the UMBRELLA brand gate, not a one-off nav toggle: every subsequent rebrand surface (page titles, email templates, marketing-facing copy) reads THIS key rather than adding its own flag, so the whole rebrand keeps a single kill switch. First surface is the left-hand nav wordmark \u2014 ON replaces the human+robot mark and the "augmented.team" text with italic lowercase "ninjafy"; OFF renders exactly what shipped before. Scope is USER-FACING BRAND TEXT ONLY: it must never gate a code identifier, package name, env var or CLI name, which stay `Augmented`/`agt` per the CLAUDE.md naming contract (the deep code rename is workstream C of docs/runbooks/rebrand-ninjafy-migration.md and is out of scope here). Set the stage-wide default to flip a whole environment, or add a feature_flag_overrides row to pilot one organization while every other org still sees Augmented. Ships dark.',
+    flagType: "boolean",
+    // Declared safe value is `false`: the pre-rebrand brand. `false` is also the
+    // fail-closed direction — if the flag DB is unreachable we must show the brand
+    // that is currently live and contractually correct, never leak an unannounced
+    // rebrand to every customer at once.
+    defaultValue: false,
+    // Read CLIENT-SIDE: sidebar.tsx is a "use client" component and resolves this
+    // via usePublicBooleanFlag, so the key must be in the browser-exposed public
+    // map. Unlike onboarding-msteams-channel above there is no wrong-org hazard —
+    // the sidebar renders inside the active-org cookie's scope, which is exactly
+    // the org whose brand should be shown.
+    public: true
   }
 ];
 var REGISTRY_BY_KEY = new Map(FLAG_REGISTRY.map((definition) => [definition.key, definition]));
@@ -37480,6 +37650,149 @@ async function watchForRateLimitRefusal(opts) {
   }
 }
 
+// src/turn-failure-watch.ts
+import { readFileSync as readFileSync12, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join10 } from "path";
+function turnFailureNoticeEnabled(env2) {
+  return resolveHostBooleanFlag({
+    key: "wedge-transient-notice",
+    envVar: "AGT_WEDGE_TRANSIENT_NOTICE_ENABLED",
+    defaultValue: false,
+    ...env2 ? { env: env2 } : {}
+  });
+}
+var DEFAULT_FAILURE_WATCH_MS = 5 * 6e4;
+var FAST_POLL_MS = 500;
+var SLOW_POLL_MS = 3e3;
+var FAST_PHASE_MS = 1e4;
+var RETRYING_NOTICE_AFTER_MS = 3 * 6e4;
+var sleep2 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+function classifyTurnFailureSince(opts) {
+  const dir = opts.transcriptDir ?? agentTranscriptDir({ cwd: opts.cwd, home: opts.home });
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return { result: UNKNOWN_TURN_FAILURE, coarse: 0, fine: 0, unrecognisedKeys: [] };
+  }
+  let newest = UNKNOWN_TURN_FAILURE;
+  let coarse = 0;
+  let fine = 0;
+  const unrecognised = /* @__PURE__ */ new Set();
+  for (const name of entries) {
+    if (!name.endsWith(".jsonl")) continue;
+    const path = join10(dir, name);
+    let fingerprint;
+    try {
+      const st = statSync2(path);
+      if (!st.isFile() || st.mtimeMs < opts.sinceMs) continue;
+      fingerprint = `${st.mtimeMs}:${st.size}`;
+    } catch {
+      continue;
+    }
+    const cached2 = opts.cache?.get(path);
+    let scan;
+    if (cached2 && cached2.fingerprint === fingerprint) {
+      scan = cached2.scan;
+    } else {
+      let content;
+      try {
+        content = readFileSync12(path, "utf-8");
+      } catch {
+        continue;
+      }
+      const analysis = analyzeTranscriptTurnFailure(content, opts.sinceMs, opts.nowMs);
+      scan = {
+        result: analysis.result,
+        coarse: analysis.coarse,
+        fine: analysis.fine,
+        unrecognisedKeys: analysis.unrecognisedKeys
+      };
+      opts.cache?.set(path, { fingerprint, scan });
+    }
+    newest = pickNewerTurnFailure(newest, scan.result);
+    coarse += scan.coarse;
+    fine += scan.fine;
+    for (const key2 of scan.unrecognisedKeys) unrecognised.add(key2);
+  }
+  return { result: newest, coarse, fine, unrecognisedKeys: [...unrecognised].sort() };
+}
+function emitDriftTelemetryIfBlind(args) {
+  if (args.coarse <= 0 || args.fine > 0) return;
+  try {
+    process.stderr.write(
+      `agt.transcript.api_error.unclassified ${JSON.stringify({
+        channel: args.channel,
+        agent_code: process.env.AGT_AGENT_CODE_NAME ?? "unknown",
+        coarse: args.coarse,
+        keys: args.unrecognisedKeys.slice(0, 20)
+      })}
+`
+    );
+  } catch {
+  }
+}
+async function watchForTurnFailure(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const wait = opts.wait ?? sleep2;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_FAILURE_WATCH_MS;
+  const fastPollMs = opts.fastPollMs ?? FAST_POLL_MS;
+  const slowPollMs = opts.slowPollMs ?? SLOW_POLL_MS;
+  const fastPhaseMs = opts.fastPhaseMs ?? FAST_PHASE_MS;
+  const retryingAfterMs = opts.retryingNoticeAfterMs ?? RETRYING_NOTICE_AFTER_MS;
+  const startedAt = now();
+  const deadline = startedAt + timeoutMs;
+  let longRetryFired = false;
+  let driftEmitted = false;
+  const cache = /* @__PURE__ */ new Map();
+  for (; ; ) {
+    let scan;
+    try {
+      scan = classifyTurnFailureSince({
+        sinceMs: opts.sinceMs,
+        // No upper bound, deliberately. Two reasons, and the second is a
+        // correctness requirement of the cache above:
+        //  1. For a post-dispatch watch the question is "has anything since the
+        //     dispatch killed this turn?" — a future-dated entry is still an
+        //     answer, and rejecting it on clock skew would drop the notice.
+        //  2. A window that widens each poll makes a cached scan unsound: an
+        //     entry stamped a hair ahead of our clock would be parsed as
+        //     out-of-window, cached as "not seen", and — because a DEAD turn
+        //     produces no further appends to invalidate the entry — never looked
+        //     at again. That is exactly the silence this feature exists to end.
+        nowMs: Number.POSITIVE_INFINITY,
+        transcriptDir: opts.transcriptDir,
+        cwd: opts.cwd,
+        home: opts.home,
+        cache
+      });
+    } catch {
+      return null;
+    }
+    if (!driftEmitted && scan.coarse > 0 && scan.fine === 0) {
+      driftEmitted = true;
+      emitDriftTelemetryIfBlind({
+        channel: opts.channel ?? "unknown",
+        coarse: scan.coarse,
+        fine: scan.fine,
+        unrecognisedKeys: scan.unrecognisedKeys
+      });
+    }
+    const { result } = scan;
+    if (result.outcome === "failed") return result;
+    if (result.outcome === "served") return null;
+    if (result.outcome === "retrying" && !longRetryFired && opts.onLongRetry && now() - startedAt >= retryingAfterMs) {
+      longRetryFired = true;
+      try {
+        await opts.onLongRetry(result);
+      } catch {
+      }
+    }
+    if (now() >= deadline) return null;
+    await wait(now() - startedAt < fastPhaseMs ? fastPollMs : slowPollMs);
+  }
+}
+
 // src/usage-limit-reactive-decision.ts
 import { createHash } from "crypto";
 function shouldReadPredictiveMarker(mode) {
@@ -37506,7 +37819,7 @@ function describeUnparsedRefusal(text) {
 import { execFile as execFile2 } from "child_process";
 import { existsSync as existsSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var DEFAULT_CLAUDE_EVAL_MODEL = "claude-haiku-4-5-20251001";
 var DEFAULT_ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
 var ANTHROPIC_API_VERSION = "2023-06-01";
@@ -37605,12 +37918,12 @@ async function runAnthropicMessages(prompt, opts) {
 var emptyMcpConfigPath = null;
 function ensureEmptyMcpConfig() {
   if (emptyMcpConfigPath && existsSync5(emptyMcpConfigPath)) return emptyMcpConfigPath;
-  const dir = join10(homedir6(), ".augmented");
+  const dir = join11(homedir6(), ".augmented");
   try {
     mkdirSync6(dir, { recursive: true });
   } catch {
   }
-  const p2 = join10(dir, ".reply-intent-empty-mcp.json");
+  const p2 = join11(dir, ".reply-intent-empty-mcp.json");
   writeFileSync7(p2, JSON.stringify({ mcpServers: {} }));
   emptyMcpConfigPath = p2;
   return p2;
@@ -37757,17 +38070,17 @@ function emitTransientApiErrorTelemetry(channel, match, original) {
 }
 
 // src/telegram-pending-inbound-cleanup.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync2 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
+import { join as join12 } from "path";
 function markerArrivalMs(fullPath) {
   try {
-    const received = JSON.parse(readFileSync12(fullPath, "utf-8")).received_at;
+    const received = JSON.parse(readFileSync13(fullPath, "utf-8")).received_at;
     const parsed = received ? Date.parse(received) : Number.NaN;
     if (Number.isFinite(parsed)) return parsed;
   } catch {
   }
   try {
-    return statSync2(fullPath).mtimeMs;
+    return statSync3(fullPath).mtimeMs;
   } catch {
     return Number.POSITIVE_INFINITY;
   }
@@ -37783,7 +38096,7 @@ function applyToChatMarkers(pendingDir, chatId, op, cutoffMs) {
   const bounded = Number.isFinite(cutoffMs);
   let filenames;
   try {
-    filenames = readdirSync2(pendingDir);
+    filenames = readdirSync3(pendingDir);
   } catch {
     return 0;
   }
@@ -37791,7 +38104,7 @@ function applyToChatMarkers(pendingDir, chatId, op, cutoffMs) {
   for (const filename of filenames) {
     if (!filename.startsWith(prefix)) continue;
     if (!filename.endsWith(".json")) continue;
-    const fullPath = join11(pendingDir, filename);
+    const fullPath = join12(pendingDir, filename);
     if (bounded && markerArrivalMs(fullPath) > cutoffMs) continue;
     op(fullPath);
     applied++;
@@ -37801,12 +38114,12 @@ function applyToChatMarkers(pendingDir, chatId, op, cutoffMs) {
 
 // src/recovery-ledger.ts
 import { existsSync as existsSync6, unlinkSync as unlinkSync6 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function recoveryLedgerEntryExists(ledgerDir, markerName, exists = (p2) => existsSync6(p2)) {
   if (!ledgerDir || !markerName) return false;
   if (markerName.includes("/") || markerName.includes("\\") || markerName.includes("..")) return false;
   try {
-    return exists(join12(ledgerDir, markerName));
+    return exists(join13(ledgerDir, markerName));
   } catch {
     return false;
   }
@@ -37817,14 +38130,14 @@ function removeRecoveryLedgerEntry(ledgerDir, markerName, unlink = (p2) => {
   if (!ledgerDir || !markerName) return;
   if (markerName.includes("/") || markerName.includes("\\") || markerName.includes("..")) return;
   try {
-    unlink(join12(ledgerDir, markerName));
+    unlink(join13(ledgerDir, markerName));
   } catch {
   }
 }
 
 // src/inbound-delivery-ledger.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync3, readFileSync as readFileSync13, renameSync as renameSync5, writeFileSync as writeFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync4, readFileSync as readFileSync14, renameSync as renameSync5, writeFileSync as writeFileSync8 } from "fs";
+import { join as join14 } from "path";
 function safeInboundId(inboundId) {
   return inboundId.replace(/[^A-Za-z0-9_-]/g, "_");
 }
@@ -37832,8 +38145,8 @@ var defaultDeps = {
   mkdir: (dir) => mkdirSync7(dir, { recursive: true }),
   writeFile: (path, data) => writeFileSync8(path, data, "utf8"),
   rename: (from, to) => renameSync5(from, to),
-  readdir: (dir) => readdirSync3(dir),
-  readFile: (path) => readFileSync13(path, "utf8"),
+  readdir: (dir) => readdirSync4(dir),
+  readFile: (path) => readFileSync14(path, "utf8"),
   exists: (path) => existsSync7(path)
 };
 function writeInboundDeliveryLedgerEntry(dir, record2, deps = defaultDeps) {
@@ -37842,7 +38155,7 @@ function writeInboundDeliveryLedgerEntry(dir, record2, deps = defaultDeps) {
   if (!safe || safe.includes("/") || safe.includes("\\") || safe.includes("..")) return;
   try {
     deps.mkdir(dir);
-    const final = join13(dir, `${safe}.json`);
+    const final = join14(dir, `${safe}.json`);
     const tmp = `${final}.tmp`;
     deps.writeFile(tmp, JSON.stringify(record2));
     deps.rename(tmp, final);
@@ -38047,14 +38360,14 @@ function createKanbanCardActiveClient(args) {
 import {
   existsSync as existsSync8,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   renameSync as renameSync6,
-  statSync as statSync3,
+  statSync as statSync4,
   unlinkSync as unlinkSync7,
   utimesSync,
   writeFileSync as writeFileSync9
 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var STALE_LOCK_MS = 9e4;
 var HEARTBEAT_INTERVAL_MS = 3e4;
 function defaultIsPidAlive(pid) {
@@ -38077,7 +38390,7 @@ function acquireMcpSpawnLock(args) {
   const nowMs = options.nowMs ?? (() => Date.now());
   const lockMtimeMs = options.lockMtimeMs ?? defaultLockMtimeMs;
   const staleMs = options.staleMs ?? STALE_LOCK_MS;
-  const path = join14(agentDir, basename2);
+  const path = join15(agentDir, basename2);
   const existing = readLockHolder(path);
   if (existing) {
     if (existing.pid === selfPid) {
@@ -38136,7 +38449,7 @@ function startMcpSpawnLockHeartbeat(lockPath, opts = {}) {
 }
 function defaultLockMtimeMs(path) {
   try {
-    return statSync3(path).mtimeMs;
+    return statSync4(path).mtimeMs;
   } catch {
     return null;
   }
@@ -38144,7 +38457,7 @@ function defaultLockMtimeMs(path) {
 function readLockHolder(path) {
   if (!existsSync8(path)) return null;
   try {
-    const raw = readFileSync14(path, "utf8");
+    const raw = readFileSync15(path, "utf8");
     const parsed = JSON.parse(raw);
     const pid = typeof parsed.pid === "number" ? parsed.pid : Number(parsed.pid);
     if (!Number.isFinite(pid) || pid <= 0) return null;
@@ -38156,8 +38469,8 @@ function readLockHolder(path) {
 }
 
 // src/ack-reaction.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync10 } from "fs";
-import { join as join15 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync16, writeFileSync as writeFileSync10 } from "fs";
+import { join as join16 } from "path";
 var REPLY_WEDGED_THRESHOLD_MS = 5 * 60 * 1e3;
 var ACK_STARTUP_GRACE_MS = 6e4;
 var ACK_PANE_FRESH_THRESHOLD_MS = 6e4;
@@ -38230,7 +38543,7 @@ var GIVE_UP_SIGNAL_MAX_AGE_MS = 30 * 60 * 1e3;
 function readGiveUpSignal(path, now = Date.now()) {
   if (!path) return null;
   try {
-    const raw = JSON.parse(readFileSync15(path, "utf8"));
+    const raw = JSON.parse(readFileSync16(path, "utf8"));
     if (typeof raw.gave_up_at !== "string") return null;
     const t = Date.parse(raw.gave_up_at);
     if (!Number.isFinite(t) || t > now) return null;
@@ -38252,11 +38565,17 @@ function giveUpNoticeText(reason = null) {
   }
   return "\u26A0\uFE0F I couldn't read your last message \u2014 please resend it.";
 }
+function turnFailedNoticeText() {
+  return "\u26A0\uFE0F Something went wrong on my side and I couldn\u2019t finish that. Sorry \u2014 send it again when you get a chance and I\u2019ll pick it straight up.";
+}
+function turnRetryingNoticeText() {
+  return "\u23F3 Still working on this \u2014 things are running slower than usual on my side. I\u2019ll reply as soon as I have it.";
+}
 function oldestPendingMarkerAgeMs(dir, now = Date.now(), opts) {
   if (!dir) return null;
   let names;
   try {
-    names = readdirSync4(dir);
+    names = readdirSync5(dir);
   } catch {
     return null;
   }
@@ -38265,7 +38584,7 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now(), opts) {
     if (!name.endsWith(".json")) continue;
     let receivedAt;
     try {
-      const raw = JSON.parse(readFileSync15(join15(dir, name), "utf-8"));
+      const raw = JSON.parse(readFileSync16(join16(dir, name), "utf-8"));
       if (raw.discretionary === true) continue;
       if (!opts?.includeSeen && typeof raw.seen_at === "string" && raw.seen_at) continue;
       receivedAt = raw.received_at;
@@ -38342,14 +38661,14 @@ function isMarkerGenuinelyAged(receivedAt, nowMs, thresholdMs) {
 }
 var DEFLECTION_COUNTER_SUFFIX = "-deflections.json";
 function deflectionCounterPath(agentDir, channel) {
-  return join15(agentDir, `${channel}${DEFLECTION_COUNTER_SUFFIX}`);
+  return join16(agentDir, `${channel}${DEFLECTION_COUNTER_SUFFIX}`);
 }
 function recordChannelDeflection(agentDir, channel, cause) {
   if (!agentDir) return;
   const path = deflectionCounterPath(agentDir, channel);
   let counts = {};
   try {
-    const parsed = JSON.parse(readFileSync15(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync16(path, "utf-8"));
     if (parsed && typeof parsed === "object") counts = parsed;
   } catch {
   }
@@ -38430,7 +38749,7 @@ function redactId(id) {
 }
 var BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
 var AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME ?? "unknown";
-var TELEGRAM_AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join16(homedir7(), ".augmented", AGENT_CODE_NAME) : null;
+var TELEGRAM_AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join17(homedir7(), ".augmented", AGENT_CODE_NAME) : null;
 var AGT_HOST = process.env.AGT_HOST ?? null;
 var AGT_API_KEY = process.env.AGT_API_KEY ?? null;
 var AGT_AGENT_ID = process.env.AGT_AGENT_ID ?? null;
@@ -38533,11 +38852,11 @@ var peerRateLimiter = peerRateApiClient && parsePeerAgentModeEnv(process.env.TEL
   log: (line) => process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): ${line}
 `)
 }) : createPeerRateLimiter();
-var PEER_PRESENCE_STATE_FILE = TELEGRAM_AGENT_DIR ? join16(TELEGRAM_AGENT_DIR, "telegram-peer-presence.json") : null;
+var PEER_PRESENCE_STATE_FILE = TELEGRAM_AGENT_DIR ? join17(TELEGRAM_AGENT_DIR, "telegram-peer-presence.json") : null;
 function readPeerPresenceState() {
   if (!PEER_PRESENCE_STATE_FILE) return null;
   try {
-    const parsed = JSON.parse(readFileSync16(PEER_PRESENCE_STATE_FILE, "utf-8"));
+    const parsed = JSON.parse(readFileSync17(PEER_PRESENCE_STATE_FILE, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -38572,9 +38891,9 @@ if (!BOT_TOKEN) {
 var stderrLogStream = null;
 if (AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown") {
   try {
-    const logDir = join16(homedir7(), ".augmented", AGENT_CODE_NAME);
+    const logDir = join17(homedir7(), ".augmented", AGENT_CODE_NAME);
     mkdirSync9(logDir, { recursive: true });
-    stderrLogStream = createWriteStream(join16(logDir, "telegram-channel-stderr.log"), {
+    stderrLogStream = createWriteStream(join17(logDir, "telegram-channel-stderr.log"), {
       flags: "a",
       mode: 384
     });
@@ -39011,7 +39330,7 @@ function scheduleBusyAck(chatId, messageId, arrivedWhileBusy) {
     let paneLogFreshAgeMs = null;
     if (AGENT_DIR) {
       try {
-        const paneMtimeMs = statSync4(join16(AGENT_DIR, "pane.log")).mtimeMs;
+        const paneMtimeMs = statSync5(join17(AGENT_DIR, "pane.log")).mtimeMs;
         paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
       } catch {
       }
@@ -39041,7 +39360,7 @@ function scheduleBusyAck(chatId, messageId, arrivedWhileBusy) {
 function __resetBusyAckNoticeThrottle() {
   lastBusyAckNoticeAt.clear();
 }
-var RESTART_FLAGS_DIR = join16(homedir7(), ".augmented", "restart-flags");
+var RESTART_FLAGS_DIR = join17(homedir7(), ".augmented", "restart-flags");
 function actuateHostRestartTelegram() {
   return actuateHostRestart({
     agtHost: AGT_HOST,
@@ -39426,7 +39745,7 @@ async function handleRestartCommand(opts) {
       if (!existsSync9(RESTART_FLAGS_DIR)) {
         mkdirSync9(RESTART_FLAGS_DIR, { recursive: true });
       }
-      const flagPath = join16(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
+      const flagPath = join17(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
       const flag = {
         codeName: AGENT_CODE_NAME,
         source: "telegram",
@@ -39832,16 +40151,16 @@ async function classifyRestartCommand(text) {
   if (!ours) return "verification_failed";
   return target === ours ? "act" : "ignore";
 }
-var AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join16(homedir7(), ".augmented", AGENT_CODE_NAME) : null;
-var PENDING_INBOUND_DIR = AGENT_DIR ? join16(AGENT_DIR, "telegram-pending-inbound") : null;
-var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join16(AGENT_DIR, "telegram-recovery-outbox") : null;
-var RECOVERY_LEDGER_DIR = AGENT_DIR ? join16(AGENT_DIR, ".agt-telegram-recovery-ledger") : null;
-var DELIVERY_LEDGER_DIR = AGENT_DIR ? join16(AGENT_DIR, ".agt-inbound-delivery-ledger") : null;
-var RESTART_CONFIRM_FILE = AGENT_DIR ? join16(AGENT_DIR, "telegram-restart-confirm.json") : null;
+var AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join17(homedir7(), ".augmented", AGENT_CODE_NAME) : null;
+var PENDING_INBOUND_DIR = AGENT_DIR ? join17(AGENT_DIR, "telegram-pending-inbound") : null;
+var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join17(AGENT_DIR, "telegram-recovery-outbox") : null;
+var RECOVERY_LEDGER_DIR = AGENT_DIR ? join17(AGENT_DIR, ".agt-telegram-recovery-ledger") : null;
+var DELIVERY_LEDGER_DIR = AGENT_DIR ? join17(AGENT_DIR, ".agt-inbound-delivery-ledger") : null;
+var RESTART_CONFIRM_FILE = AGENT_DIR ? join17(AGENT_DIR, "telegram-restart-confirm.json") : null;
 var TELEGRAM_PROCESS_BOOT_MS = Date.now();
-var TELEGRAM_RECENT_DMS_FILE = AGENT_DIR ? join16(AGENT_DIR, "telegram-recent-dms.json") : null;
-var TELEGRAM_CHANNEL_ADD_RESTART_FILE = AGENT_DIR ? join16(AGENT_DIR, "telegram-channel-add-restart.json") : null;
-var TELEGRAM_OFFSET_FILE = AGENT_DIR ? join16(AGENT_DIR, "telegram-getupdates-offset.json") : null;
+var TELEGRAM_RECENT_DMS_FILE = AGENT_DIR ? join17(AGENT_DIR, "telegram-recent-dms.json") : null;
+var TELEGRAM_CHANNEL_ADD_RESTART_FILE = AGENT_DIR ? join17(AGENT_DIR, "telegram-channel-add-restart.json") : null;
+var TELEGRAM_OFFSET_FILE = AGENT_DIR ? join17(AGENT_DIR, "telegram-getupdates-offset.json") : null;
 var recentDms = /* @__PURE__ */ new Map();
 var recentDmPersister = TELEGRAM_RECENT_DMS_FILE ? createRecentDmPersister({
   filePath: TELEGRAM_RECENT_DMS_FILE,
@@ -39896,7 +40215,7 @@ function safeMarkerName(chatId, messageId) {
 }
 function pendingInboundPath(chatId, messageId) {
   if (!PENDING_INBOUND_DIR) return null;
-  return join16(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
+  return join17(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
 }
 function writePendingInboundMarker(chatId, messageId, chatType, undeliverable = false, payload) {
   const path = pendingInboundPath(chatId, messageId);
@@ -39944,7 +40263,7 @@ function rewriteTelegramMarkerInPlace(path, marker) {
 function clearTelegramMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync16(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync17(fullPath, "utf-8"));
   } catch {
   }
   if (marker && decideRecoveryHeal({
@@ -39961,7 +40280,7 @@ function clearTelegramMarkerFileWithHeal(fullPath) {
 function markTelegramMarkerSeenInPlace(fullPath) {
   let marker;
   try {
-    marker = JSON.parse(readFileSync16(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync17(fullPath, "utf-8"));
   } catch {
     return;
   }
@@ -39973,7 +40292,7 @@ function markTelegramMarkerSeenInPlace(fullPath) {
 function markTelegramMarkerSeenWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync16(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync17(fullPath, "utf-8"));
   } catch {
     return;
   }
@@ -39989,7 +40308,7 @@ function readPendingInboundMarker(chatId, messageId) {
   const path = pendingInboundPath(chatId, messageId);
   if (!path || !existsSync9(path)) return null;
   try {
-    return JSON.parse(readFileSync16(path, "utf-8"));
+    return JSON.parse(readFileSync17(path, "utf-8"));
   } catch {
     return null;
   }
@@ -40009,10 +40328,10 @@ function nextRetryName(filename) {
 async function processRecoveryOutboxFile(filename) {
   if (!RECOVERY_OUTBOX_DIR) return;
   if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return;
-  const fullPath = join16(RECOVERY_OUTBOX_DIR, filename);
+  const fullPath = join17(RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    const raw = readFileSync16(fullPath, "utf-8");
+    const raw = readFileSync17(fullPath, "utf-8");
     payload = JSON.parse(raw);
   } catch (err) {
     process.stderr.write(
@@ -40106,7 +40425,7 @@ async function processRecoveryOutboxFile(filename) {
   const next = nextRetryName(filename);
   if (next) {
     try {
-      renameSync7(fullPath, join16(RECOVERY_OUTBOX_DIR, next.next));
+      renameSync7(fullPath, join17(RECOVERY_OUTBOX_DIR, next.next));
       if (next.attempt >= MAX_RECOVERY_ATTEMPTS) {
         process.stderr.write(
           `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery exhausted retries \u2014 moved to ${next.next}
@@ -40138,7 +40457,7 @@ function scanRecoveryRetries() {
   if (!RECOVERY_OUTBOX_DIR) return;
   let entries;
   try {
-    entries = readdirSync5(RECOVERY_OUTBOX_DIR);
+    entries = readdirSync6(RECOVERY_OUTBOX_DIR);
   } catch {
     return;
   }
@@ -40147,7 +40466,7 @@ function scanRecoveryRetries() {
     if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync4(join16(RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+      mtimeMs = statSync5(join17(RECOVERY_OUTBOX_DIR, f)).mtimeMs;
     } catch {
       continue;
     }
@@ -40168,7 +40487,7 @@ function startRecoveryOutboxWatcher() {
     return;
   }
   try {
-    for (const f of readdirSync5(RECOVERY_OUTBOX_DIR)) {
+    for (const f of readdirSync6(RECOVERY_OUTBOX_DIR)) {
       if (isFirstAttemptOutboxFile(f)) void processRecoveryOutboxFile(f);
     }
   } catch {
@@ -40177,7 +40496,7 @@ function startRecoveryOutboxWatcher() {
     const watcher = watch(RECOVERY_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
       if (!isFirstAttemptOutboxFile(filename)) return;
-      if (existsSync9(join16(RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync9(join17(RECOVERY_OUTBOX_DIR, filename))) {
         void processRecoveryOutboxFile(filename);
       }
     });
@@ -40192,7 +40511,7 @@ function startRecoveryOutboxWatcher() {
   retryTimer.unref?.();
 }
 startRecoveryOutboxWatcher();
-var NOTICE_OUTBOX_DIR = AGENT_DIR ? join16(AGENT_DIR, "telegram-notice-outbox") : null;
+var NOTICE_OUTBOX_DIR = AGENT_DIR ? join17(AGENT_DIR, "telegram-notice-outbox") : null;
 var NOTICE_MAX_AGE_MS = 9e4;
 var NOTICE_INFLIGHT = /* @__PURE__ */ new Set();
 async function processNoticeOutboxFile(filename) {
@@ -40200,11 +40519,11 @@ async function processNoticeOutboxFile(filename) {
   if (filename.startsWith(".") || filename.endsWith(".tmp") || !filename.endsWith(".json")) return;
   if (NOTICE_INFLIGHT.has(filename)) return;
   NOTICE_INFLIGHT.add(filename);
-  const fullPath = join16(NOTICE_OUTBOX_DIR, filename);
+  const fullPath = join17(NOTICE_OUTBOX_DIR, filename);
   try {
     let mtimeMs;
     try {
-      mtimeMs = statSync4(fullPath).mtimeMs;
+      mtimeMs = statSync5(fullPath).mtimeMs;
     } catch {
       return;
     }
@@ -40217,7 +40536,7 @@ async function processNoticeOutboxFile(filename) {
     }
     let payload;
     try {
-      const parsed = JSON.parse(readFileSync16(fullPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync17(fullPath, "utf-8"));
       if (!parsed || typeof parsed !== "object") throw new Error("not an object");
       payload = parsed;
     } catch {
@@ -40288,13 +40607,13 @@ function startNoticeOutboxWatcher() {
     return;
   }
   try {
-    for (const f of readdirSync5(NOTICE_OUTBOX_DIR)) void processNoticeOutboxFile(f);
+    for (const f of readdirSync6(NOTICE_OUTBOX_DIR)) void processNoticeOutboxFile(f);
   } catch {
   }
   try {
     const watcher = watch(NOTICE_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
-      if (existsSync9(join16(NOTICE_OUTBOX_DIR, filename))) void processNoticeOutboxFile(filename);
+      if (existsSync9(join17(NOTICE_OUTBOX_DIR, filename))) void processNoticeOutboxFile(filename);
     });
     watcher.unref?.();
   } catch (err) {
@@ -40314,7 +40633,7 @@ function sweepTelegramStaleMarkers(thresholdMs) {
   if (!existsSync9(PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
-    filenames = readdirSync5(PENDING_INBOUND_DIR);
+    filenames = readdirSync6(PENDING_INBOUND_DIR);
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): stale-marker readdir failed: ${err.message}
@@ -40328,10 +40647,10 @@ function sweepTelegramStaleMarkers(thresholdMs) {
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
     if (filename.endsWith(".tmp")) continue;
-    const fullPath = join16(PENDING_INBOUND_DIR, filename);
+    const fullPath = join17(PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync16(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync17(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `telegram-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactId(filename)}: ${err.message}
@@ -40384,13 +40703,13 @@ var orphanSweepTimer = setInterval(() => {
   checkWatchdogGiveUpNotice();
 }, orphanSweepIntervalMs());
 orphanSweepTimer.unref?.();
-var TELEGRAM_PROGRESS_HEARTBEAT_PATH = AGENT_DIR ? join16(AGENT_DIR, "channel-progress-heartbeat.json") : null;
+var TELEGRAM_PROGRESS_HEARTBEAT_PATH = AGENT_DIR ? join17(AGENT_DIR, "channel-progress-heartbeat.json") : null;
 var telegramTrackedProgress = null;
 var telegramProgressTickRunning = false;
 function readTelegramProgressHeartbeat() {
   if (!TELEGRAM_PROGRESS_HEARTBEAT_PATH || !existsSync9(TELEGRAM_PROGRESS_HEARTBEAT_PATH)) return null;
   try {
-    return parseProgressHeartbeat(readFileSync16(TELEGRAM_PROGRESS_HEARTBEAT_PATH, "utf-8"));
+    return parseProgressHeartbeat(readFileSync17(TELEGRAM_PROGRESS_HEARTBEAT_PATH, "utf-8"));
   } catch {
     return null;
   }
@@ -40413,11 +40732,11 @@ function findTelegramProgressTarget() {
   let best = null;
   let bestMs = Infinity;
   try {
-    for (const name of readdirSync5(PENDING_INBOUND_DIR)) {
+    for (const name of readdirSync6(PENDING_INBOUND_DIR)) {
       if (!name.endsWith(".json")) continue;
       let m;
       try {
-        m = JSON.parse(readFileSync16(join16(PENDING_INBOUND_DIR, name), "utf-8"));
+        m = JSON.parse(readFileSync17(join17(PENDING_INBOUND_DIR, name), "utf-8"));
       } catch {
         continue;
       }
@@ -40544,11 +40863,11 @@ function listPendingInboundChatIds() {
   if (!PENDING_INBOUND_DIR || !existsSync9(PENDING_INBOUND_DIR)) return [];
   const chats = /* @__PURE__ */ new Set();
   try {
-    for (const name of readdirSync5(PENDING_INBOUND_DIR)) {
+    for (const name of readdirSync6(PENDING_INBOUND_DIR)) {
       if (!name.endsWith(".json")) continue;
       try {
         const marker = JSON.parse(
-          readFileSync16(join16(PENDING_INBOUND_DIR, name), "utf8")
+          readFileSync17(join17(PENDING_INBOUND_DIR, name), "utf8")
         );
         if (typeof marker.seen_at === "string" && marker.seen_at) continue;
         if (typeof marker.chat_id === "string" && marker.chat_id) chats.add(marker.chat_id);
@@ -40560,6 +40879,84 @@ function listPendingInboundChatIds() {
   }
   return [...chats];
 }
+var lastTurnFailedNoticeAt = /* @__PURE__ */ new Map();
+var lastTurnRetryingNoticeAt = /* @__PURE__ */ new Map();
+async function postTelegramTurnNotice(args) {
+  try {
+    const resp = await telegramApiCall(
+      "sendMessage",
+      {
+        chat_id: args.chatId,
+        text: args.text,
+        ...args.messageThreadId != null ? { message_thread_id: args.messageThreadId } : {}
+      },
+      1e4
+    );
+    return resp.ok === true;
+  } catch {
+    return false;
+  }
+}
+function armTelegramTurnFailureWatch(args) {
+  const conversationKey = args.messageThreadId != null ? `${args.chatId}:${args.messageThreadId}` : args.chatId;
+  void (async () => {
+    try {
+      const failure = await watchForTurnFailure({
+        sinceMs: args.sinceMs,
+        channel: "telegram",
+        onLongRetry: async () => {
+          const now2 = Date.now();
+          if (!shouldPostUndeliverableNotice(lastTurnRetryingNoticeAt.get(conversationKey), now2)) {
+            return;
+          }
+          lastTurnRetryingNoticeAt.set(conversationKey, now2);
+          const posted2 = await postTelegramTurnNotice({
+            chatId: args.chatId,
+            ...args.messageThreadId != null ? { messageThreadId: args.messageThreadId } : {},
+            text: turnRetryingNoticeText()
+          });
+          if (!posted2) lastTurnRetryingNoticeAt.delete(conversationKey);
+          process.stderr.write(
+            `telegram-channel(${AGENT_CODE_NAME}): [turn-failure] retrying notice ${posted2 ? "posted" : "FAILED"} chat=${redactId(args.chatId)}
+`
+          );
+        }
+      });
+      if (!failure) return;
+      const now = Date.now();
+      if (!shouldPostUndeliverableNotice(lastTurnFailedNoticeAt.get(conversationKey), now)) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): [turn-failure] suppressed (throttled) chat=${redactId(args.chatId)} class=${failure.failureClass}
+`
+        );
+        return;
+      }
+      lastTurnFailedNoticeAt.set(conversationKey, now);
+      const posted = await postTelegramTurnNotice({
+        chatId: args.chatId,
+        ...args.messageThreadId != null ? { messageThreadId: args.messageThreadId } : {},
+        text: turnFailedNoticeText()
+      });
+      if (!posted) {
+        lastTurnFailedNoticeAt.delete(conversationKey);
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): [turn-failure] NOTICE POST FAILED chat=${redactId(args.chatId)} - the user is still waiting on a dead turn
+`
+        );
+        return;
+      }
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): [turn-failure] notified chat=${redactId(args.chatId)} class=${failure.failureClass} status=${failure.httpStatus}
+`
+      );
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): [turn-failure] watch error: ${err.message}
+`
+      );
+    }
+  })();
+}
 async function notifyWatchdogGiveUp(chatId, reason) {
   const now = Date.now();
   if (!shouldPostUndeliverableNotice(lastUndeliverableNoticeAt.get(chatId), now)) return;
@@ -40590,7 +40987,7 @@ async function notifyWatchdogGiveUp(chatId, reason) {
 }
 function checkWatchdogGiveUpNotice() {
   if (!AGENT_DIR) return;
-  const signal = readGiveUpSignal(join16(AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
+  const signal = readGiveUpSignal(join17(AGENT_DIR, GIVE_UP_SIGNAL_FILENAME));
   const signalAtMs = signal?.atMs ?? null;
   const act = decideGiveUpNotice({
     signalAtMs,
@@ -40932,7 +41329,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     let bytes;
     let size;
     try {
-      const st = statSync4(realPath);
+      const st = statSync5(realPath);
       if (!st.isFile()) {
         return { content: [{ type: "text", text: `Upload refused: ${resolvedPath} is not a regular file.` }], isError: true };
       }
@@ -40946,7 +41343,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
           isError: true
         };
       }
-      bytes = readFileSync16(realPath);
+      bytes = readFileSync17(realPath);
     } catch (err) {
       return { content: [{ type: "text", text: `Failed to read file: ${err.message}` }], isError: true };
     }
@@ -41500,7 +41897,7 @@ async function replayPendingTelegramMarkers() {
   if (!sessionAlive) return;
   let filenames;
   try {
-    filenames = readdirSync5(PENDING_INBOUND_DIR);
+    filenames = readdirSync6(PENDING_INBOUND_DIR);
   } catch {
     return;
   }
@@ -41508,7 +41905,7 @@ async function replayPendingTelegramMarkers() {
   let paneFreshAgeMs = null;
   if (AGENT_DIR) {
     try {
-      paneFreshAgeMs = Math.max(0, now - statSync4(join16(AGENT_DIR, "pane.log")).mtimeMs);
+      paneFreshAgeMs = Math.max(0, now - statSync5(join17(AGENT_DIR, "pane.log")).mtimeMs);
     } catch {
     }
   }
@@ -41516,10 +41913,10 @@ async function replayPendingTelegramMarkers() {
   const entries = [];
   for (const name of filenames) {
     if (!name.endsWith(".json") || name.endsWith(".tmp")) continue;
-    const fullPath = join16(PENDING_INBOUND_DIR, name);
+    const fullPath = join17(PENDING_INBOUND_DIR, name);
     let marker;
     try {
-      marker = JSON.parse(readFileSync16(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync17(fullPath, "utf-8"));
     } catch {
       continue;
     }
@@ -41687,7 +42084,7 @@ async function pollLoop() {
           `telegram-channel(${AGENT_CODE_NAME}): getUpdates failed: ${resp.description ?? "unknown"}
 `
         );
-        await sleep3(5e3);
+        await sleep4(5e3);
         continue;
       }
       const offsetBeforeBatch = nextOffset;
@@ -42070,7 +42467,7 @@ async function pollLoop() {
         let paneLogFreshAgeMs = null;
         if (AGENT_DIR) {
           try {
-            const paneMtimeMs = statSync4(join16(AGENT_DIR, "pane.log")).mtimeMs;
+            const paneMtimeMs = statSync5(join17(AGENT_DIR, "pane.log")).mtimeMs;
             paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
           } catch {
           }
@@ -42190,6 +42587,13 @@ async function pollLoop() {
             sinceMs: dispatchedAtMs
           });
         }
+        if (!isFromBot && !peerAgentMeta && turnFailureNoticeEnabled()) {
+          armTelegramTurnFailureWatch({
+            chatId,
+            ...msg.message_thread_id != null ? { messageThreadId: msg.message_thread_id } : {},
+            sinceMs: dispatchedAtMs
+          });
+        }
         seedTelegramProgressHeartbeat();
         conversationIngestClient?.ingest({
           channel: "telegram",
@@ -42235,11 +42639,11 @@ async function pollLoop() {
         `telegram-channel(${AGENT_CODE_NAME}): poll error: ${err.message}
 `
       );
-      await sleep3(5e3);
+      await sleep4(5e3);
     }
   }
 }
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms).unref());
 }
 function shutdown(reason) {