clisbot 0.1.41 → 0.1.42

package/dist/main.js

@@ -59566,6 +59566,139 @@ var agentAuthOverrideSchema = exports_external.object({
   roles: exports_external.record(exports_external.string(), authRoleOverrideSchema).default({})
 });
 
+// src/config/runtime-monitor-backoff.ts
+var LEGACY_DEFAULT_RUNTIME_MONITOR_RESTART_BACKOFF = {
+  fastRetry: {
+    delaySeconds: 10,
+    maxRestarts: 3
+  },
+  stages: [
+    {
+      delayMinutes: 15,
+      maxRestarts: 4
+    },
+    {
+      delayMinutes: 30,
+      maxRestarts: 4
+    }
+  ]
+};
+var DEFAULT_RUNTIME_MONITOR_RESTART_BACKOFF = {
+  fastRetry: {
+    delaySeconds: 10,
+    maxRestarts: 3
+  },
+  stages: [
+    {
+      delayMinutes: 1,
+      maxRestarts: 2
+    },
+    {
+      delayMinutes: 3,
+      maxRestarts: 2
+    },
+    {
+      delayMinutes: 5,
+      maxRestarts: 2
+    },
+    {
+      delayMinutes: 10,
+      maxRestarts: 3
+    },
+    {
+      delayMinutes: 15,
+      maxRestarts: 4
+    },
+    {
+      delayMinutes: 30,
+      maxRestarts: 4
+    }
+  ]
+};
+var RUNTIME_MONITOR_RESTART_RESET_AFTER_MS = 15 * 60000;
+function cloneRestartBackoff(restartBackoff) {
+  return {
+    fastRetry: {
+      ...restartBackoff.fastRetry
+    },
+    stages: restartBackoff.stages.map((stage) => ({
+      ...stage
+    }))
+  };
+}
+function matchesRestartBackoffShape(left, right) {
+  if (left.fastRetry.delaySeconds !== right.fastRetry.delaySeconds || left.fastRetry.maxRestarts !== right.fastRetry.maxRestarts || left.stages.length !== right.stages.length) {
+    return false;
+  }
+  return left.stages.every((stage, index) => {
+    const other = right.stages[index];
+    return other != null && stage.delayMinutes === other.delayMinutes && stage.maxRestarts === other.maxRestarts;
+  });
+}
+function getDefaultRuntimeMonitorRestartBackoff() {
+  return cloneRestartBackoff(DEFAULT_RUNTIME_MONITOR_RESTART_BACKOFF);
+}
+function normalizeRuntimeMonitorRestartBackoff(restartBackoff) {
+  if (matchesRestartBackoffShape(restartBackoff, LEGACY_DEFAULT_RUNTIME_MONITOR_RESTART_BACKOFF)) {
+    return getDefaultRuntimeMonitorRestartBackoff();
+  }
+  return cloneRestartBackoff(restartBackoff);
+}
+function getConfiguredRuntimeMonitorRestartBudget(restartBackoff) {
+  const normalized = normalizeRuntimeMonitorRestartBackoff(restartBackoff);
+  return normalized.fastRetry.maxRestarts + normalized.stages.reduce((sum, stage) => sum + stage.maxRestarts, 0);
+}
+function getRuntimeMonitorRestartPlan(restartBackoff, restartNumber) {
+  const normalized = normalizeRuntimeMonitorRestartBackoff(restartBackoff);
+  const totalConfiguredRestarts = getConfiguredRuntimeMonitorRestartBudget(normalized);
+  const fastRetryMaxRestarts = normalized.fastRetry.maxRestarts;
+  if (restartNumber >= 1 && restartNumber <= fastRetryMaxRestarts) {
+    return {
+      mode: "fast-retry",
+      stageIndex: -1,
+      delayMs: normalized.fastRetry.delaySeconds * 1000,
+      restartAttemptInStage: restartNumber,
+      restartsRemaining: Math.max(0, totalConfiguredRestarts - restartNumber),
+      totalConfiguredRestarts,
+      stageMaxRestarts: fastRetryMaxRestarts,
+      repeatingFinalStage: false
+    };
+  }
+  let completedRestarts = fastRetryMaxRestarts;
+  for (let index = 0;index < normalized.stages.length; index += 1) {
+    const stage = normalized.stages[index];
+    const stageStart = completedRestarts + 1;
+    const stageEnd = completedRestarts + stage.maxRestarts;
+    if (restartNumber >= stageStart && restartNumber <= stageEnd) {
+      return {
+        mode: "backoff",
+        stageIndex: index,
+        delayMs: stage.delayMinutes * 60000,
+        restartAttemptInStage: restartNumber - completedRestarts,
+        restartsRemaining: Math.max(0, totalConfiguredRestarts - restartNumber),
+        totalConfiguredRestarts,
+        stageMaxRestarts: stage.maxRestarts,
+        repeatingFinalStage: false
+      };
+    }
+    completedRestarts = stageEnd;
+  }
+  const finalStage = normalized.stages.at(-1);
+  if (!finalStage) {
+    return null;
+  }
+  return {
+    mode: "backoff",
+    stageIndex: normalized.stages.length - 1,
+    delayMs: finalStage.delayMinutes * 60000,
+    restartAttemptInStage: Math.max(1, restartNumber - completedRestarts),
+    restartsRemaining: 0,
+    totalConfiguredRestarts,
+    stageMaxRestarts: finalStage.maxRestarts,
+    repeatingFinalStage: true
+  };
+}
+
 // src/config/schema.ts
 var defaultSessionIdPattern = "\\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\\b";
 var runnerSessionIdCreateSchema = exports_external.object({
@@ -60017,6 +60150,7 @@ var appControlLoopSchema = exports_external.object({
   defaultIntervalMinutes: exports_external.number().int().positive().optional(),
   maxTimes: exports_external.number().int().positive().optional()
 });
+var defaultRuntimeMonitorRestartBackoff = getDefaultRuntimeMonitorRestartBackoff();
 var appControlRuntimeMonitorSchema = exports_external.object({
   restartBackoff: exports_external.object({
     fastRetry: exports_external.object({
@@ -60029,32 +60163,8 @@ var appControlRuntimeMonitorSchema = exports_external.object({
     stages: exports_external.array(exports_external.object({
       delayMinutes: exports_external.number().int().positive().default(15),
       maxRestarts: exports_external.number().int().positive().default(4)
-    })).min(1).default([
-      {
-        delayMinutes: 15,
-        maxRestarts: 4
-      },
-      {
-        delayMinutes: 30,
-        maxRestarts: 4
-      }
-    ])
-  }).default({
-    fastRetry: {
-      delaySeconds: 10,
-      maxRestarts: 3
-    },
-    stages: [
-      {
-        delayMinutes: 15,
-        maxRestarts: 4
-      },
-      {
-        delayMinutes: 30,
-        maxRestarts: 4
-      }
-    ]
-  }),
+    })).min(1).default(defaultRuntimeMonitorRestartBackoff.stages)
+  }).default(defaultRuntimeMonitorRestartBackoff),
   ownerAlerts: exports_external.object({
     enabled: exports_external.boolean().default(true),
     minIntervalMinutes: exports_external.number().int().positive().default(30)
@@ -60222,10 +60332,10 @@ var agentsDefaultsSchema = exports_external.object({
 });
 var clisbotConfigSchema = exports_external.object({
   meta: exports_external.object({
-    schemaVersion: exports_external.string().min(1).default("0.1.41"),
+    schemaVersion: exports_external.string().min(1).default("0.1.42"),
     lastTouchedAt: exports_external.string().optional()
   }).default({
-    schemaVersion: "0.1.41"
+    schemaVersion: "0.1.42"
   }),
   app: exports_external.object({
     session: appSessionSchema.default({
@@ -60248,22 +60358,7 @@ var clisbotConfigSchema = exports_external.object({
         maxActiveLoops: 10
       }),
       runtimeMonitor: appControlRuntimeMonitorSchema.default({
-        restartBackoff: {
-          fastRetry: {
-            delaySeconds: 10,
-            maxRestarts: 3
-          },
-          stages: [
-            {
-              delayMinutes: 15,
-              maxRestarts: 4
-            },
-            {
-              delayMinutes: 30,
-              maxRestarts: 4
-            }
-          ]
-        },
+        restartBackoff: defaultRuntimeMonitorRestartBackoff,
         ownerAlerts: {
           enabled: true,
           minIntervalMinutes: 30
@@ -60283,22 +60378,7 @@ var clisbotConfigSchema = exports_external.object({
         maxActiveLoops: 10
       },
       runtimeMonitor: {
-        restartBackoff: {
-          fastRetry: {
-            delaySeconds: 10,
-            maxRestarts: 3
-          },
-          stages: [
-            {
-              delayMinutes: 15,
-              maxRestarts: 4
-            },
-            {
-              delayMinutes: 30,
-              maxRestarts: 4
-            }
-          ]
-        },
+        restartBackoff: defaultRuntimeMonitorRestartBackoff,
         ownerAlerts: {
           enabled: true,
           minIntervalMinutes: 30
@@ -60326,22 +60406,7 @@ var clisbotConfigSchema = exports_external.object({
         maxActiveLoops: 10
       },
       runtimeMonitor: {
-        restartBackoff: {
-          fastRetry: {
-            delaySeconds: 10,
-            maxRestarts: 3
-          },
-          stages: [
-            {
-              delayMinutes: 15,
-              maxRestarts: 4
-            },
-            {
-              delayMinutes: 30,
-              maxRestarts: 4
-            }
-          ]
-        },
+        restartBackoff: defaultRuntimeMonitorRestartBackoff,
         ownerAlerts: {
           enabled: true,
           minIntervalMinutes: 30
@@ -61022,6 +61087,8 @@ function materializeLoadedConfig(expandedConfigPath, validated) {
       socketPath: expandHomePath(validated.agents.defaults.runner.defaults.tmux.socketPath || getDefaultTmuxSocketPath())
     }
   };
+  runtimeRaw.app.control.runtimeMonitor.restartBackoff = normalizeRuntimeMonitorRestartBackoff(runtimeRaw.app.control.runtimeMonitor.restartBackoff);
+  runtimeRaw.control.runtimeMonitor.restartBackoff = normalizeRuntimeMonitorRestartBackoff(runtimeRaw.control.runtimeMonitor.restartBackoff);
   return {
     configPath: expandedConfigPath,
     processedEventsPath: getDefaultProcessedEventsPath(),
@@ -61104,9 +61171,10 @@ function renderDefaultConfigTemplate(options = {}) {
   const sessionStorePath = collapseHomePath(getDefaultSessionStorePath());
   const workspaceTemplate = collapseHomePath(getDefaultWorkspaceTemplate());
   const defaultTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  const defaultRuntimeMonitorRestartBackoff2 = getDefaultRuntimeMonitorRestartBackoff();
   return JSON.stringify({
     meta: {
-      schemaVersion: "0.1.41",
+      schemaVersion: "0.1.42",
       lastTouchedAt: new Date().toISOString()
     },
     app: {
@@ -61148,22 +61216,7 @@ function renderDefaultConfigTemplate(options = {}) {
           defaultTimezone
         },
         runtimeMonitor: {
-          restartBackoff: {
-            fastRetry: {
-              delaySeconds: 10,
-              maxRestarts: 3
-            },
-            stages: [
-              {
-                delayMinutes: 15,
-                maxRestarts: 4
-              },
-              {
-                delayMinutes: 30,
-                maxRestarts: 4
-              }
-            ]
-          },
+          restartBackoff: defaultRuntimeMonitorRestartBackoff2,
           ownerAlerts: {
             enabled: true,
             minIntervalMinutes: 30
@@ -64076,9 +64129,11 @@ function parseAgentCommand(text, options = {}) {
     };
   }
   if (lowered === "transcript") {
+    const transcriptMode = withoutSlash.slice(command.length).trim().toLowerCase() === "full" ? "full" : "default";
     return {
       type: "control",
-      name: "transcript"
+      name: "transcript",
+      mode: transcriptMode
     };
   }
   if (lowered === "attach") {
@@ -64123,6 +64178,10 @@ function parseAgentCommand(text, options = {}) {
   if (lowered === "followup") {
     return parseFollowUpSlashCommand(withoutSlash.slice(command.length).trim().toLowerCase());
   }
+  if (lowered === "mention") {
+    const scope = withoutSlash.slice(command.length).trim().toLowerCase();
+    return parseFollowUpSlashCommand(scope ? `mention-only ${scope}` : "mention-only");
+  }
   if (lowered === "pause") {
     return parseFollowUpSlashCommand("pause");
   }
@@ -64339,7 +64398,8 @@ function renderAgentControlSlashHelp() {
     "- `/status`: show the current route status and operator setup commands",
     "- `/help`: show available control slash commands",
     "- `/whoami`: show the current platform, route, and sender identity details",
-    "- `/transcript`: show the current conversation session transcript when the route verbose policy allows it",
+    "- `/transcript`: show a short recent session snapshot when the route verbose policy allows it",
+    "- `/transcript full`: show a longer session snapshot when you need the full pane context",
     "- `/attach`: attach this thread to the active run and resume live updates when it is still processing",
     "- `/detach`: stop live updates for this thread while still posting the final result here",
     "- `/watch every 30s [for 10m]`: post the latest state on an interval until the run settles or the watch window ends",
@@ -64347,11 +64407,11 @@ function renderAgentControlSlashHelp() {
     "- `/nudge`: send one extra Enter to the current tmux session without resending the prompt text",
     "- `/followup status`: show the current conversation follow-up policy",
     "- `/followup auto`: allow natural follow-up after the bot has replied in-thread",
-    "- `/followup mention-only`: require explicit mention for each later turn",
-    "- `/followup pause`: stop passive follow-up until the next explicit mention",
-    "- `/followup resume`: clear the runtime override and restore config defaults",
-    "- `/pause`: shortcut for `/followup pause`",
-    "- `/resume`: shortcut for `/followup resume`",
+    "- `/followup mention-only` or `/mention`: require explicit mention for each later turn",
+    "- `/followup mention-only channel` or `/mention channel`: persist mention-only as the default for the current channel or group",
+    "- `/followup mention-only all` or `/mention all`: persist mention-only as the default for all routed conversations on this bot",
+    "- `/followup pause` or `/pause`: stop passive follow-up until the next explicit mention",
+    "- `/followup resume` or `/resume`: clear the runtime override and restore config defaults",
     "- `/streaming status|on|off|latest|all`: show or change streaming mode for this surface",
     "- `/responsemode status`: show the configured response mode for this surface",
     "- `/responsemode capture-pane`: settle replies from captured pane output for this surface",
@@ -64401,31 +64461,44 @@ function parseWatchCommand(raw) {
     durationMs: parsedDurationMs ?? undefined
   };
 }
+function parseFollowUpScope(raw) {
+  if (raw === "channel") {
+    return "channel";
+  }
+  if (raw === "all") {
+    return "all";
+  }
+  return "conversation";
+}
 function parseFollowUpSlashCommand(action) {
-  if (!action || action === "status") {
+  const [rawAction = "", rawScope = ""] = action.split(/\s+/, 2).map((token) => token.trim().toLowerCase());
+  const scope = parseFollowUpScope(rawScope);
+  if (!rawAction || rawAction === "status") {
     return {
       type: "control",
       name: "followup",
       action: "status"
     };
   }
-  if (action === "auto") {
+  if (rawAction === "auto") {
     return {
       type: "control",
       name: "followup",
       action: "auto",
-      mode: "auto"
+      mode: "auto",
+      scope
     };
   }
-  if (action === "mention-only") {
+  if (rawAction === "mention-only") {
     return {
       type: "control",
       name: "followup",
       action: "mention-only",
-      mode: "mention-only"
+      mode: "mention-only",
+      scope
     };
   }
-  if (action === "pause") {
+  if (rawAction === "pause") {
     return {
       type: "control",
       name: "followup",
@@ -64433,7 +64506,7 @@ function parseFollowUpSlashCommand(action) {
       mode: "paused"
     };
   }
-  if (action === "resume") {
+  if (rawAction === "resume") {
     return {
       type: "control",
       name: "followup",
@@ -65126,7 +65199,7 @@ var REPLY_COMMAND = `{{reply_command_base}}
 <user-facing reply>
 __CLISBOT_MESSAGE__
 )" \\
-  [--media /absolute/path/to/file]`;
+  [--file /absolute/path/to/file]`;
 var REPLY_RULES = `When replying to the user:
 - put the user-facing message inside the --message body of that command
 {{progress_rules_block}}- {{final_rule_line}}`;
@@ -65159,8 +65232,10 @@ var TELEGRAM_REPLY_COMMAND_BASE = `{{command}} message send \\
 {{thread_clause}}  --input md \\
   --render native \\
 `;
-var SLACK_REPLY_STYLE_HINT = "Put readable hierarchical Markdown in the --message body.";
-var TELEGRAM_REPLY_STYLE_HINT = "Put readable hierarchical Markdown in the --message body.";
+var SLACK_REPLY_STYLE_HINT = `Put readable hierarchical Markdown in the --message body.
+Keep each paragraph, list, or code block under 2500 chars.`;
+var TELEGRAM_REPLY_STYLE_HINT = `Put readable hierarchical Markdown in the --message body.
+Keep the Markdown body under 3000 chars.`;
 var ACCOUNT_CLAUSE = "  --account {{account_id}} \\\n";
 var EMPTY_ACCOUNT_CLAUSE = "";
 var SLACK_THREAD_CLAUSE = "  --thread-id {{thread_ts}} \\\n";
@@ -66706,6 +66781,20 @@ function renderSlackTranscript(params) {
 ${body}
 \`\`\``;
 }
+function renderCompactChannelTranscript(params) {
+  const body = escapeCodeFence(truncateTail(params.snapshot || "(no tmux output yet)", params.maxChars));
+  const fullCommand = params.fullCommand ?? "/transcript full";
+  return [
+    "Transcript",
+    "",
+    "Recent session snapshot:",
+    "```",
+    body,
+    "```",
+    `Use \`${fullCommand}\` if you want the longer pane snapshot.`
+  ].join(`
+`);
+}
 var renderSlackSnapshot = renderSlackTranscript;
 var renderChannelSnapshot = renderSlackSnapshot;
 function resolveDetachedInteractionNote(params) {
@@ -66742,12 +66831,16 @@ var PASTE_SETTLE_POLL_INTERVAL_MS = 40;
 var PASTE_SETTLE_QUIET_WINDOW_MS = 60;
 var PASTE_SETTLE_MULTILINE_MAX_WAIT_MS = 800;
 var PASTE_SETTLE_SINGLE_LINE_MAX_WAIT_MS = 80;
+var PASTE_CONFIRM_MAX_ATTEMPTS = 3;
 var PASTE_CAPTURE_REVALIDATE_POLL_INTERVAL_MS = 40;
 var PASTE_CAPTURE_REVALIDATE_MAX_WAIT_MS = 160;
 var SUBMIT_CONFIRM_POLL_INTERVAL_MS = 40;
 var SUBMIT_CONFIRM_MAX_WAIT_MS = 160;
 var SUBMIT_SNAPSHOT_CONFIRM_POLL_INTERVAL_MS = 40;
 var SUBMIT_SNAPSHOT_CONFIRM_MAX_WAIT_MS = 320;
+var POST_STATUS_SETTLE_POLL_INTERVAL_MS = 40;
+var POST_STATUS_SETTLE_QUIET_WINDOW_MS = 80;
+var POST_STATUS_SETTLE_MAX_WAIT_MS = 240;
 var TMUX_MISSING_TARGET_PATTERN = /(?:no current target|can't find pane|can't find window)/i;
 var TMUX_MISSING_SESSION_PATTERN = /(?:can't find session:|no server running on )/i;
 var TMUX_SERVER_UNAVAILABLE_PATTERN = /(?:No such file or directory|error connecting to|failed to connect to server)/i;
@@ -66760,38 +66853,44 @@ class TmuxBootstrapSessionLostError extends Error {
     this.name = "TmuxBootstrapSessionLostError";
   }
 }
+
+class TmuxPasteUnconfirmedError extends Error {
+  attempts;
+  constructor(attempts) {
+    super(`tmux paste was not confirmed after ${attempts} delivery attempts. clisbot did not send Enter because the prompt was not truthfully visible in the pane.`);
+    this.attempts = attempts;
+    this.name = "TmuxPasteUnconfirmedError";
+  }
+}
+
+class TmuxSubmitUnconfirmedError extends Error {
+  constructor() {
+    super("tmux submit was not confirmed after Enter. The pane state did not change, so clisbot did not treat the prompt as truthfully submitted.");
+    this.name = "TmuxSubmitUnconfirmedError";
+  }
+}
 async function submitTmuxSessionInput(params) {
   const prePasteState = await params.tmux.getPaneState(params.sessionName);
   const captureLines = estimatePasteCaptureLines(params.text);
   const prePasteSnapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, captureLines));
-  await params.tmux.sendLiteral(params.sessionName, params.text);
-  const pasteSettlement = await waitForPanePasteSettlement({
+  const pasteDelivery = await deliverTmuxPasteWithConfirmation({
     tmux: params.tmux,
     sessionName: params.sessionName,
-    baseline: prePasteState,
     text: params.text,
-    minDelayMs: params.promptSubmitDelayMs
+    baselineState: prePasteState,
+    baselineSnapshot: prePasteSnapshot,
+    captureLines,
+    promptSubmitDelayMs: params.promptSubmitDelayMs,
+    timingContext: params.timingContext
   });
-  let preSubmitState = pasteSettlement.state;
-  if (!pasteSettlement.visible) {
-    logLatencyDebug("tmux-paste-retry", params.timingContext, {
-      sessionName: params.sessionName
-    });
-    const snapshotConfirmed = await waitForPanePasteSnapshotConfirmation({
-      tmux: params.tmux,
+  if (!pasteDelivery.confirmed) {
+    logLatencyDebug("tmux-paste-unconfirmed", params.timingContext, {
       sessionName: params.sessionName,
-      baselineSnapshot: prePasteSnapshot,
-      captureLines
+      attempts: pasteDelivery.attempts
     });
-    if (!snapshotConfirmed) {
-      logLatencyDebug("tmux-paste-unconfirmed", params.timingContext, {
-        sessionName: params.sessionName
-      });
-      preSubmitState = prePasteState;
-    } else {
-      preSubmitState = await params.tmux.getPaneState(params.sessionName);
-    }
+    throw new TmuxPasteUnconfirmedError(pasteDelivery.attempts);
   }
+  const preSubmitState = pasteDelivery.state;
   await params.tmux.sendKey(params.sessionName, "Enter");
   if (await waitForPaneSubmitConfirmation({
     tmux: params.tmux,
@@ -66815,13 +66914,10 @@ async function submitTmuxSessionInput(params) {
   })) {
     return;
   }
-  if (!pasteSettlement.visible) {
-    throw new Error("tmux paste was not confirmed before Enter, and submission still could not be confirmed after Enter. clisbot did not treat the prompt as truthfully delivered.");
-  }
   logLatencyDebug("tmux-submit-unconfirmed", params.timingContext, {
     sessionName: params.sessionName
   });
-  throw new Error("tmux submit was not confirmed after Enter. The pane state did not change, so clisbot did not treat the prompt as truthfully submitted.");
+  throw new TmuxSubmitUnconfirmedError;
 }
 async function captureTmuxSessionIdentity(params) {
   await submitTmuxSessionInput({
@@ -66864,6 +66960,14 @@ async function captureTmuxSessionIdentity(params) {
     }
     const sessionId = extractSessionId(snapshot, params.pattern);
     if (sessionId) {
+      await waitForTmuxPaneSettle({
+        tmux: params.tmux,
+        sessionName: params.sessionName,
+        captureLines: params.captureLines,
+        pollIntervalMs: POST_STATUS_SETTLE_POLL_INTERVAL_MS,
+        quietWindowMs: POST_STATUS_SETTLE_QUIET_WINDOW_MS,
+        maxWaitMs: POST_STATUS_SETTLE_MAX_WAIT_MS
+      });
       return sessionId;
     }
   }
@@ -67018,6 +67122,49 @@ async function waitForPaneSubmitSnapshotConfirmation(params) {
     await sleep(Math.min(SUBMIT_SNAPSHOT_CONFIRM_POLL_INTERVAL_MS, remainingMs));
   }
 }
+async function deliverTmuxPasteWithConfirmation(params) {
+  for (let attempt = 1;attempt <= PASTE_CONFIRM_MAX_ATTEMPTS; attempt += 1) {
+    if (attempt > 1) {
+      logLatencyDebug("tmux-paste-retry", params.timingContext, {
+        sessionName: params.sessionName,
+        attempt
+      });
+    }
+    await params.tmux.sendLiteral(params.sessionName, params.text);
+    const pasteSettlement = await waitForPanePasteSettlement({
+      tmux: params.tmux,
+      sessionName: params.sessionName,
+      baseline: params.baselineState,
+      text: params.text,
+      minDelayMs: params.promptSubmitDelayMs
+    });
+    if (pasteSettlement.visible) {
+      return {
+        confirmed: true,
+        state: pasteSettlement.state,
+        attempts: attempt
+      };
+    }
+    const snapshotConfirmed = await waitForPanePasteSnapshotConfirmation({
+      tmux: params.tmux,
+      sessionName: params.sessionName,
+      baselineSnapshot: params.baselineSnapshot,
+      captureLines: params.captureLines
+    });
+    if (snapshotConfirmed) {
+      return {
+        confirmed: true,
+        state: await params.tmux.getPaneState(params.sessionName),
+        attempts: attempt
+      };
+    }
+  }
+  return {
+    confirmed: false,
+    state: params.baselineState,
+    attempts: PASTE_CONFIRM_MAX_ATTEMPTS
+  };
+}
 async function waitForPanePasteSettlement(params) {
   await sleep(params.minDelayMs);
   let currentState = await params.tmux.getPaneState(params.sessionName);
@@ -67063,6 +67210,41 @@ async function waitForPanePasteSnapshotConfirmation(params) {
     await sleep(Math.min(PASTE_CAPTURE_REVALIDATE_POLL_INTERVAL_MS, remainingMs));
   }
 }
+async function waitForTmuxPaneSettle(params) {
+  let previousSnapshot = "";
+  let previousState = null;
+  let lastChangeAt = Date.now();
+  const deadline = Date.now() + params.maxWaitMs;
+  while (true) {
+    let snapshot = "";
+    let state;
+    try {
+      snapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines));
+      state = await params.tmux.getPaneState(params.sessionName);
+    } catch (error) {
+      if (isRetryableBootstrapTargetError(error)) {
+        if (Date.now() >= deadline) {
+          return;
+        }
+        await sleep(params.pollIntervalMs);
+        continue;
+      }
+      if (isBootstrapSessionGoneError(error)) {
+        throw buildBootstrapSessionLostError(params.sessionName, error);
+      }
+      throw error;
+    }
+    if (snapshot !== previousSnapshot || !previousState || !arePaneStatesEqual(previousState, state)) {
+      previousSnapshot = snapshot;
+      previousState = state;
+      lastChangeAt = Date.now();
+    }
+    if (Date.now() - lastChangeAt >= params.quietWindowMs || Date.now() >= deadline) {
+      return;
+    }
+    await sleep(params.pollIntervalMs);
+  }
+}
 function estimatePasteCaptureLines(text) {
   return Math.max(40, Math.min(160, text.split(`
 `).length + 24));
@@ -67284,6 +67466,9 @@ function isBootstrapSessionLostError(error) {
 function isRecoverableStartupSessionLoss(error) {
   return isMissingTmuxSessionError(error) || isTmuxServerUnavailableError(error) || isBootstrapSessionLostError(error);
 }
+function isFreshStartRetryablePromptDeliveryError(error) {
+  return error instanceof TmuxPasteUnconfirmedError;
+}
 
 class RunnerService {
   loadedConfig;
@@ -67398,7 +67583,7 @@ class RunnerService {
     });
   }
   async retryAfterStartupFault(target, resolved, error, remainingFreshRetries) {
-    if (!isRecoverableStartupSessionLoss(error)) {
+    if (!isRecoverableStartupSessionLoss(error) && !isFreshStartRetryablePromptDeliveryError(error)) {
       return null;
     }
     return this.retryFreshStartWithClearedSessionId(target, resolved, remainingFreshRetries);
@@ -67640,6 +67825,9 @@ class RunnerService {
   canRecoverMidRun(error) {
     return isRecoverableStartupSessionLoss(error);
   }
+  canRetryPromptAfterFreshStart(error) {
+    return isFreshStartRetryablePromptDeliveryError(error);
+  }
   async reopenRunContext(target, timingContext) {
     const resolved = this.resolveTarget(target);
     const existing = await this.sessionState.getEntry(resolved.sessionKey);
@@ -67654,7 +67842,10 @@ class RunnerService {
       return;
     });
     await this.sessionState.clearSessionIdEntry(resolved, { runnerCommand: resolved.runner.command });
-    return this.ensureSessionReady(target, { allowFreshRetry: false, timingContext });
+    return this.ensureRunnerReady(target, {
+      allowFreshRetryBeforePrompt: false,
+      timingContext
+    });
   }
   async captureTranscript(target) {
     const resolved = this.resolveTarget(target);
@@ -68295,6 +68486,55 @@ class SessionService {
     }
     this.activeRuns.delete(run.resolved.sessionKey);
   }
+  async recoverPromptDeliveryFailure(sessionKey, params, error) {
+    if (!params.prompt || params.promptRetryAttempt || !this.runnerSessions.canRetryPromptAfterFreshStart(error)) {
+      return false;
+    }
+    const run = this.getRun(sessionKey, params.runId);
+    if (!run) {
+      return true;
+    }
+    const target = {
+      agentId: run.resolved.agentId,
+      sessionKey: run.resolved.sessionKey
+    };
+    await this.notifyRecoveryStep(run, "Prompt delivery did not settle truthfully in the current runner session. clisbot is opening one fresh runner session and retrying the prompt once.");
+    try {
+      const fresh = await this.runnerSessions.startFreshSession(target, params.timingContext);
+      const currentRun = this.getRun(sessionKey, params.runId);
+      if (!currentRun) {
+        return true;
+      }
+      const restartedAt = Date.now();
+      currentRun.resolved = fresh.resolved;
+      currentRun.steeringReady = false;
+      currentRun.startedAt = restartedAt;
+      currentRun.latestUpdate = this.createRunUpdate({
+        resolved: currentRun.resolved,
+        status: currentRun.latestUpdate.status === "detached" ? "detached" : "running",
+        snapshot: "",
+        fullSnapshot: fresh.initialSnapshot,
+        initialSnapshot: fresh.initialSnapshot,
+        note: "Retrying the prompt in one fresh runner session.",
+        forceVisible: true
+      });
+      await this.sessionState.setSessionRuntime(currentRun.resolved, {
+        state: "running",
+        startedAt: restartedAt
+      });
+      await this.notifyRunObservers(currentRun, currentRun.latestUpdate);
+      this.startRunMonitor(sessionKey, {
+        ...params,
+        promptRetryAttempt: 1,
+        initialSnapshot: fresh.initialSnapshot,
+        startedAt: restartedAt
+      });
+      return true;
+    } catch (freshError) {
+      await this.failActiveRun(sessionKey, run.runId, await this.runnerSessions.mapRunError(freshError, run.resolved.sessionName, run.latestUpdate.fullSnapshot));
+      return true;
+    }
+  }
   async recoverLostMidRun(sessionKey, params, error) {
     if (!this.runnerSessions.canRecoverMidRun(error)) {
       return false;
@@ -68450,6 +68690,16 @@ class SessionService {
           }
         });
       } catch (error) {
+        if (await this.recoverPromptDeliveryFailure(sessionKey, {
+          runId: params.runId,
+          prompt: params.prompt,
+          startedAt: params.startedAt,
+          detachedAlready: params.detachedAlready,
+          timingContext: params.timingContext,
+          promptRetryAttempt: params.promptRetryAttempt
+        }, error)) {
+          return;
+        }
         if (await this.recoverLostMidRun(sessionKey, {
           runId: params.runId,
           timingContext: params.timingContext,
@@ -69331,43 +69581,188 @@ async function setConversationStreaming(params) {
   };
 }
 
-// src/channels/interaction-processing.ts
-var MESSAGE_TOOL_FINAL_GRACE_WINDOW_MS = 3000;
-var MESSAGE_TOOL_FINAL_GRACE_POLL_MS = 100;
-var MESSAGE_TOOL_PREVIEW_SIGNAL_POLL_MS = 100;
-function renderSensitiveCommandDisabledMessage() {
-  return [
-    "Shell execution is not allowed for your current role on this agent.",
-    "Ask an app or agent admin to grant `shellExecute` if this surface should allow `/bash`."
-  ].join(`
-`);
-}
-function renderTranscriptDisabledMessage() {
-  return [
-    "Transcript inspection is disabled for this route.",
-    'Set `verbose: "minimal"` on the route or channel to allow `/transcript`.'
-  ].join(`
-`);
-}
-function renderStartupSteeringUnavailableMessage() {
-  return [
-    "The active run is still starting and cannot accept steering input yet.",
-    "Send a normal follow-up message to keep it ordered behind the first prompt, or wait until startup finishes before using `/steer`."
-  ].join(`
-`);
+// src/channels/follow-up-mode-config.ts
+function getEditableConfigPath6() {
+  return process.env.CLISBOT_CONFIG_PATH;
 }
-function renderPrincipalFormat(identity) {
-  if (identity.platform === "slack") {
-    return "slack:<nativeUserId>";
+function getOrCreateFollowUp(source) {
+  const existing = source.followUp;
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return existing;
   }
-  return "telegram:<nativeUserId>";
+  const created = {};
+  source.followUp = created;
+  return created;
 }
-function renderPrincipalExample(identity) {
-  if (identity.senderId) {
-    return `${identity.platform}:${identity.senderId}`;
-  }
-  if (identity.platform === "slack") {
-    return "slack:U123ABC456";
+function createTelegramRouteOverride2() {
+  return {
+    enabled: true,
+    allowUsers: [],
+    blockUsers: [],
+    topics: {}
+  };
+}
+function getOrCreateTelegramGroupRoute2(bot, chatId) {
+  const existingGroup = bot.groups[chatId];
+  if (existingGroup) {
+    return existingGroup;
+  }
+  const createdGroup = createTelegramRouteOverride2();
+  bot.groups[chatId] = createdGroup;
+  return createdGroup;
+}
+function resolveSlackFollowUpModeTarget(config, params) {
+  const botId = resolveSlackBotId(config.bots.slack, params.botId);
+  const bot = getSlackBotRecord(config.bots.slack, botId);
+  if (!bot) {
+    throw new Error(`Unknown Slack bot: ${botId}`);
+  }
+  if (params.scope === "all") {
+    return {
+      get: () => bot.followUp?.mode,
+      set: (value) => {
+        getOrCreateFollowUp(bot).mode = value;
+      },
+      label: `slack bot ${botId}`
+    };
+  }
+  if (params.identity.conversationKind === "dm") {
+    const targetId = params.identity.senderId?.trim() || params.identity.channelId?.trim();
+    if (!targetId) {
+      throw new Error("Slack follow-up channel scope requires a senderId or channelId.");
+    }
+    const routeKey2 = `dm:${targetId}`;
+    const existingRoute = resolveDirectMessageExactRoute(bot.directMessages, targetId) ?? (bot.directMessages[routeKey2] = createDirectMessageBehaviorOverride());
+    return {
+      get: () => existingRoute.followUp?.mode ?? bot.followUp?.mode,
+      set: (value) => {
+        getOrCreateFollowUp(existingRoute).mode = value;
+      },
+      label: `slack ${routeKey2}`
+    };
+  }
+  const routeKind = params.identity.conversationKind === "group" ? "group" : "channel";
+  const channelId = params.identity.channelId?.trim();
+  if (!channelId) {
+    throw new Error("Slack follow-up channel scope requires a channelId.");
+  }
+  const routeKey = `${routeKind}:${channelId}`;
+  const route = bot.groups[routeKey];
+  if (!route) {
+    throw new Error(`Route not configured yet: slack ${routeKey}. Add the route first.`);
+  }
+  return {
+    get: () => route.followUp?.mode ?? bot.followUp?.mode,
+    set: (value) => {
+      getOrCreateFollowUp(route).mode = value;
+    },
+    label: `slack ${routeKey}`
+  };
+}
+function resolveTelegramFollowUpModeTarget(config, params) {
+  const botId = resolveTelegramBotId(config.bots.telegram, params.botId);
+  const bot = getTelegramBotRecord(config.bots.telegram, botId);
+  if (!bot) {
+    throw new Error(`Unknown Telegram bot: ${botId}`);
+  }
+  if (params.scope === "all") {
+    return {
+      get: () => bot.followUp?.mode,
+      set: (value) => {
+        getOrCreateFollowUp(bot).mode = value;
+      },
+      label: `telegram bot ${botId}`
+    };
+  }
+  if (params.identity.conversationKind === "dm") {
+    const targetId = params.identity.senderId?.trim() || params.identity.chatId?.trim();
+    if (!targetId) {
+      throw new Error("Telegram follow-up channel scope requires a senderId or chatId.");
+    }
+    const routeKey = `dm:${targetId}`;
+    const existingRoute = resolveDirectMessageExactRoute(bot.directMessages, targetId) ?? (bot.directMessages[routeKey] = createDirectMessageBehaviorOverride());
+    return {
+      get: () => existingRoute.followUp?.mode ?? bot.followUp?.mode,
+      set: (value) => {
+        getOrCreateFollowUp(existingRoute).mode = value;
+      },
+      label: `telegram ${routeKey}`
+    };
+  }
+  const chatId = params.identity.chatId?.trim();
+  if (!chatId) {
+    throw new Error("Telegram follow-up channel scope requires a chatId.");
+  }
+  const group = getOrCreateTelegramGroupRoute2(bot, chatId);
+  return {
+    get: () => group.followUp?.mode ?? bot.followUp?.mode,
+    set: (value) => {
+      getOrCreateFollowUp(group).mode = value;
+    },
+    label: `telegram group:${chatId}`
+  };
+}
+function resolveConfiguredFollowUpModeTarget(config, params) {
+  if (params.channel === "slack") {
+    return resolveSlackFollowUpModeTarget(config, params);
+  }
+  return resolveTelegramFollowUpModeTarget(config, params);
+}
+async function setScopedConversationFollowUpMode(params) {
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const target = resolveConfiguredFollowUpModeTarget(config, {
+    channel: params.identity.platform,
+    botId: resolveChannelIdentityBotId(params.identity),
+    scope: params.scope,
+    identity: params.identity
+  });
+  target.set(params.mode);
+  await writeEditableConfig(configPath, config);
+  return {
+    configPath,
+    label: target.label,
+    followUpMode: params.mode
+  };
+}
+
+// src/channels/interaction-processing.ts
+var MESSAGE_TOOL_FINAL_GRACE_WINDOW_MS = 3000;
+var MESSAGE_TOOL_FINAL_GRACE_POLL_MS = 100;
+var MESSAGE_TOOL_PREVIEW_SIGNAL_POLL_MS = 100;
+var TRANSCRIPT_PREVIEW_MAX_CHARS = 1200;
+function renderSensitiveCommandDisabledMessage() {
+  return [
+    "Shell execution is not allowed for your current role on this agent.",
+    "Ask an app or agent admin to grant `shellExecute` if this surface should allow `/bash`."
+  ].join(`
+`);
+}
+function renderTranscriptDisabledMessage() {
+  return [
+    "Transcript inspection is disabled for this route.",
+    'Set `verbose: "minimal"` on the route or channel to allow `/transcript`.'
+  ].join(`
+`);
+}
+function renderStartupSteeringUnavailableMessage() {
+  return [
+    "The active run is still starting and cannot accept steering input yet.",
+    "Send a normal follow-up message to keep it ordered behind the first prompt, or wait until startup finishes before using `/steer`."
+  ].join(`
+`);
+}
+function renderPrincipalFormat(identity) {
+  if (identity.platform === "slack") {
+    return "slack:<nativeUserId>";
+  }
+  return "telegram:<nativeUserId>";
+}
+function renderPrincipalExample(identity) {
+  if (identity.senderId) {
+    return `${identity.platform}:${identity.senderId}`;
+  }
+  if (identity.platform === "slack") {
+    return "slack:U123ABC456";
   }
   return "telegram:1276408333";
 }
@@ -69439,7 +69834,7 @@ function renderRouteStatusMessage(params) {
       lines.push(`- \`${loop.id}\` ${renderLoopStatusSchedule(loop)} remaining \`${loop.remainingRuns}\` nextRunAt \`${new Date(loop.nextRunAt).toISOString()}\``);
     }
   }
-  lines.push("", "Useful commands:", "- `/help`", "- `/whoami`", "- `/status`", "- `/attach`, `/detach`, `/watch every <duration>`", "- `/followup status`", "- `/streaming status|on|off|latest|all`", "- `/responsemode status`", "- `/additionalmessagemode status`", "- `/loop help`, `/loop status`, `/loop cancel`, `/loop cancel <id>`", "- `/queue help`, `/queue <message>`, `/steer <message>`", "- `/queue list`, `/queue clear`", params.route.verbose === "off" ? "- `/transcript` disabled on this route (`verbose: off`)" : "- `/transcript` enabled on this route (`verbose: minimal`)", "- `/bash` requires `shellExecute`");
+  lines.push("", "Useful commands:", "- `/help`", "- `/whoami`", "- `/status`", "- `/attach`, `/detach`, `/watch every <duration>`", "- `/followup status`, `/mention`, `/mention channel`, `/mention all`", "- `/streaming status|on|off|latest|all`", "- `/responsemode status`", "- `/additionalmessagemode status`", "- `/loop help`, `/loop status`, `/loop cancel`, `/loop cancel <id>`", "- `/queue help`, `/queue <message>`, `/steer <message>`", "- `/queue list`, `/queue clear`", params.route.verbose === "off" ? "- `/transcript` disabled on this route (`verbose: off`)" : "- `/transcript` enabled on this route (`verbose: minimal`)", "- `/bash` requires `shellExecute`");
   return lines.join(`
 `);
 }
@@ -69486,6 +69881,29 @@ function renderAdditionalMessageModeStatusMessage(params) {
   return lines.join(`
 `);
 }
+function renderFollowUpModeUpdateMessage(params) {
+  if (!params.persisted) {
+    if (params.mode === "paused") {
+      return "Follow-up paused for this conversation until the next explicit mention.";
+    }
+    return `Follow-up mode set to \`${params.mode}\` for this conversation.`;
+  }
+  const lines = [
+    `Updated follow-up mode for \`${params.persisted.label}\`.`,
+    `config.followUp.mode: \`${params.persisted.followUpMode}\``,
+    `config: \`${params.persisted.configPath}\``,
+    `currentConversation.overrideMode: \`${params.mode}\``,
+    "The current conversation changes immediately.",
+    "If config reload is enabled, the broader default should apply automatically shortly."
+  ];
+  if (params.scope === "all") {
+    lines.splice(4, 0, "This persists the bot-wide default for later routed conversations on this bot.");
+  } else if (params.scope === "channel") {
+    lines.splice(4, 0, "This persists the default for the current channel, group, or DM container.");
+  }
+  return lines.join(`
+`);
+}
 function buildChannelObserverId(identity) {
   return [
     identity.platform,
@@ -70132,14 +70550,18 @@ async function processChannelInteraction(params) {
         return interactionResult;
       }
       const transcript = await params.agentService.captureTranscript(params.sessionTarget);
-      await params.postText(renderChannelSnapshot({
+      await params.postText(slashCommand.mode === "full" ? renderChannelSnapshot({
         agentId: transcript.agentId,
         sessionName: transcript.sessionName,
         workspacePath: transcript.workspacePath,
         status: "completed",
         snapshot: transcript.snapshot || "(no tmux output yet)",
         maxChars: params.maxChars,
-        note: "transcript command"
+        note: "transcript command (full)"
+      }) : renderCompactChannelTranscript({
+        snapshot: transcript.snapshot || "(no tmux output yet)",
+        maxChars: Math.min(params.maxChars, TRANSCRIPT_PREVIEW_MAX_CHARS),
+        fullCommand: "/transcript full"
       }));
       return interactionResult;
     }
@@ -70202,8 +70624,25 @@ async function processChannelInteraction(params) {
         await params.agentService.resetConversationFollowUpMode(params.sessionTarget);
         await params.postText("Follow-up policy reset to route defaults for this conversation.");
       } else if (slashCommand.mode) {
-        await params.agentService.setConversationFollowUpMode(params.sessionTarget, slashCommand.mode);
-        await params.postText(slashCommand.mode === "paused" ? "Follow-up paused for this conversation until the next explicit mention." : `Follow-up mode set to \`${slashCommand.mode}\` for this conversation.`);
+        if (slashCommand.scope === "channel" || slashCommand.scope === "all") {
+          await params.agentService.setConversationFollowUpMode(params.sessionTarget, slashCommand.mode);
+          const persisted = await setScopedConversationFollowUpMode({
+            identity: params.identity,
+            scope: slashCommand.scope,
+            mode: slashCommand.mode
+          });
+          await params.postText(renderFollowUpModeUpdateMessage({
+            scope: slashCommand.scope,
+            mode: slashCommand.mode,
+            persisted
+          }));
+        } else {
+          await params.agentService.setConversationFollowUpMode(params.sessionTarget, slashCommand.mode);
+          await params.postText(renderFollowUpModeUpdateMessage({
+            scope: "conversation",
+            mode: slashCommand.mode
+          }));
+        }
       }
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
@@ -71518,7 +71957,7 @@ function renderSlackRouteChoiceMessage(params) {
     `- ${renderCliCommand(`routes add --channel slack channel:${params.channelId} --bot default`, { inline: true })}`,
     `- ${renderCliCommand(`routes set-agent --channel slack channel:${params.channelId} --bot default --agent <id>`, { inline: true })}`,
     "",
-    `After that, ${botReference} and send \`\\start\` or \`\\status\` here.`
+    `After that, ${botReference} and send \`\\start\`, \`\\status\`, or \`\\mention\` here.`
   ].join(`
 `);
 }
@@ -71526,7 +71965,7 @@ function renderSlackMentionRequiredMessage(botLabel) {
   const botReference = botLabel?.trim() ? `mention this bot (${botLabel.trim()})` : "mention this bot";
   return [
     "clisbot: this Slack channel requires a bot mention for new commands.",
-    `Try ${botReference} and send \`\\start\` or \`\\status\` here.`,
+    `Try ${botReference} and send \`\\status\` or \`\\mention\` here.`,
     "After the bot replies in a thread, normal follow-up messages there can continue according to the follow-up policy."
   ].join(`
 `);
@@ -74302,7 +74741,7 @@ function renderTelegramRouteChoiceMessage(params) {
   if (params.includeConfigPath) {
     lines.push("", topicId != null ? `Config path: \`bots.telegram.default.groups."${chatId}".topics."${topicId}"\`` : `Config path: \`bots.telegram.default.groups."${chatId}"\``);
   } else {
-    lines.push("", "After that, routed commands such as `/status`, `/stop`, `/nudge`, `/followup`, and `/bash` will work here.");
+    lines.push("", "After that, routed commands such as `/status`, `/mention`, `/stop`, `/nudge`, `/followup`, and `/bash` will work here.");
   }
   return lines.join(`
 `);
@@ -74368,6 +74807,7 @@ var TELEGRAM_FULL_COMMANDS = [
   { command: "stop", description: "Interrupt current run" },
   { command: "nudge", description: "Send one extra Enter to the session" },
   { command: "followup", description: "Show or change follow-up mode" },
+  { command: "mention", description: "Require explicit mention for later turns" },
   { command: "pause", description: "Pause passive follow-up for this conversation" },
   { command: "resume", description: "Restore route follow-up defaults for this conversation" },
   { command: "streaming", description: "Show or change streaming mode" },
@@ -74379,6 +74819,15 @@ var TELEGRAM_FULL_COMMANDS = [
   { command: "bash", description: "Run bash in the agent workspace" }
 ];
 var TELEGRAM_STARTUP_CONFLICT_MAX_WAIT_MS = 6000;
+var TELEGRAM_POLLING_CONFLICT_BACKOFF_MAX_DELAY_MS = 30000;
+var TELEGRAM_POLLING_CONFLICT_SLEEP_SLICE_MS = 250;
+var TELEGRAM_POLLING_CONFLICT_OWNER_ALERT_DELAY_MS = 60000;
+var TELEGRAM_POLLING_CONFLICT_OWNER_ALERT_REPEAT_MS = 15 * 60000;
+function computeTelegramPollingConflictBackoffDelayMs(baseDelayMs, attempt) {
+  const safeBaseDelayMs = Math.max(1, baseDelayMs);
+  const boundedAttempt = Math.max(1, attempt);
+  return Math.min(safeBaseDelayMs * 2 ** (boundedAttempt - 1), TELEGRAM_POLLING_CONFLICT_BACKOFF_MAX_DELAY_MS);
+}
 function renderTelegramUnroutedRouteMessage(params) {
   const lines = params.mode === "whoami" ? [
     "Who am I",
@@ -74460,6 +74909,8 @@ class TelegramPollingService {
   nextUpdateId;
   loopPromise;
   activePollController;
+  pollingConflictActive = false;
+  pollingConflictAttempt = 0;
   inFlightUpdates = new Set;
   processingIndicators = new ConversationProcessingIndicatorCoordinator;
   constructor(loadedConfig, agentService, processedEventsStore, activityStore, botId = "default", botCredentials, reportLifecycle) {
@@ -74509,7 +74960,13 @@ class TelegramPollingService {
     this.botUserId = me.id;
     this.botUsername = me.username ?? "";
     console.log(`telegram bot @${this.botUsername || this.botUserId} (${this.botId})`);
-    await this.initializeOffset();
+    try {
+      await this.initializeOffset();
+    } catch (error) {
+      if (!isTelegramPollingConflict(error)) {
+        throw error;
+      }
+    }
     await this.registerCommands();
     this.running = true;
     this.loopPromise = this.pollLoop();
@@ -74549,6 +75006,7 @@ class TelegramPollingService {
           timeoutMs: (telegramConfig.polling.timeoutSeconds + 5) * 1000
         });
         this.activePollController = undefined;
+        await this.recoverFromPollingConflictIfNeeded();
         const dispatched = dispatchTelegramUpdates({
           updates,
           handleUpdate: (update) => this.handleUpdate(update),
@@ -74568,24 +75026,54 @@ class TelegramPollingService {
           return;
         }
         if (isTelegramPollingConflict(error)) {
-          this.running = false;
-          await this.reportLifecycle?.({
-            connection: "failed",
-            summary: "Telegram polling stopped because another instance is already using this bot token.",
-            detail: error instanceof Error ? error.message : String(error),
-            actions: [
-              "stop the other Telegram poller that is using the same bot token",
-              `run ${renderCliCommand("start", { inline: true })} again after the token is no longer in use elsewhere`
-            ]
-          });
-          console.error("telegram polling stopped: another bot instance is already calling getUpdates for this token");
-          return;
+          await this.handlePollingConflict(error, telegramConfig.polling.retryDelayMs);
+          continue;
         }
         console.error("telegram polling error", error);
         await sleep(telegramConfig.polling.retryDelayMs);
       }
     }
   }
+  async handlePollingConflict(error, retryDelayMs) {
+    this.pollingConflictAttempt += 1;
+    const nextDelayMs = computeTelegramPollingConflictBackoffDelayMs(retryDelayMs, this.pollingConflictAttempt);
+    if (!this.pollingConflictActive) {
+      this.pollingConflictActive = true;
+      await this.reportLifecycle?.({
+        connection: "failed",
+        summary: "Telegram polling is temporarily blocked because another poller is already using this bot token.",
+        detail: error instanceof Error ? error.message : String(error),
+        actions: [
+          "stop the other Telegram poller that is using the same bot token if it is unintended",
+          "clisbot will keep retrying automatically with backoff until Telegram polling can recover"
+        ],
+        ownerAlertAfterMs: TELEGRAM_POLLING_CONFLICT_OWNER_ALERT_DELAY_MS,
+        ownerAlertRepeatMs: TELEGRAM_POLLING_CONFLICT_OWNER_ALERT_REPEAT_MS
+      });
+      console.error("telegram polling blocked: another bot instance is already calling getUpdates for this token; retrying with backoff");
+    }
+    await this.waitForPollingConflictRetryDelay(nextDelayMs);
+  }
+  async recoverFromPollingConflictIfNeeded() {
+    if (!this.pollingConflictActive) {
+      return;
+    }
+    this.pollingConflictActive = false;
+    this.pollingConflictAttempt = 0;
+    await this.reportLifecycle?.({
+      connection: "active",
+      detail: "Telegram polling recovered after a polling-conflict retry."
+    });
+    console.log("telegram polling recovered after polling conflict");
+  }
+  async waitForPollingConflictRetryDelay(delayMs) {
+    let remainingMs = Math.max(0, delayMs);
+    while (this.running && remainingMs > 0) {
+      const sliceMs = Math.min(remainingMs, TELEGRAM_POLLING_CONFLICT_SLEEP_SLICE_MS);
+      await sleep(sliceMs);
+      remainingMs -= sliceMs;
+    }
+  }
   trackInFlightUpdate(task) {
     this.inFlightUpdates.add(task);
     task.finally(() => {
@@ -75449,97 +75937,7 @@ function installRuntimeConsoleTimestamps() {
   };
 }
 
-// src/control/runtime-monitor.ts
-var defaultRuntimeMonitorDependencies = {
-  loadConfig,
-  listChannelPlugins,
-  writePid: async (pidPath, pid = process.pid) => {
-    await ensureDir2(dirname12(pidPath));
-    await writeTextFile(pidPath, `${pid}
-`);
-  },
-  readState: readRuntimeMonitorState,
-  writeState: writeRuntimeMonitorState,
-  removePid: (pidPath) => rmSync2(pidPath, { force: true }),
-  removeRuntimeCredentials: (runtimeCredentialsPath) => rmSync2(runtimeCredentialsPath, { force: true }),
-  sleep,
-  now: () => Date.now(),
-  spawnChild: (command, args, options) => spawn2(command, args, {
-    stdio: ["ignore", "inherit", "inherit"],
-    env: options.env
-  }),
-  sendSignal: kill
-};
-function isProcessAlive(pid) {
-  try {
-    kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readRuntimeMonitorState(statePath = getDefaultRuntimeMonitorStatePath()) {
-  if (!await fileExists(statePath)) {
-    return null;
-  }
-  try {
-    const raw = await readTextFile(statePath);
-    if (!raw.trim()) {
-      return null;
-    }
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function writeRuntimeMonitorState(statePath, state) {
-  await ensureDir2(dirname12(statePath));
-  await writeTextFile(statePath, `${JSON.stringify(state, null, 2)}
-`);
-}
-function dedupe(values) {
-  return [...new Set(values.filter(Boolean))];
-}
-function summarizeExit(params) {
-  if (params.signal) {
-    return `signal ${params.signal}`;
-  }
-  return `code ${params.code ?? 0}`;
-}
-function getRestartPlan(config, restartNumber) {
-  const fastRetryMaxRestarts = config.fastRetry.maxRestarts;
-  const totalRestarts = fastRetryMaxRestarts + config.stages.reduce((sum, stage) => sum + stage.maxRestarts, 0);
-  if (restartNumber >= 1 && restartNumber <= fastRetryMaxRestarts) {
-    return {
-      mode: "fast-retry",
-      stageIndex: -1,
-      delayMs: config.fastRetry.delaySeconds * 1000,
-      restartAttemptInStage: restartNumber,
-      restartsRemaining: totalRestarts - restartNumber,
-      totalRestarts,
-      stageMaxRestarts: fastRetryMaxRestarts
-    };
-  }
-  let completedRestarts = fastRetryMaxRestarts;
-  for (let index = 0;index < config.stages.length; index += 1) {
-    const stage = config.stages[index];
-    const stageStart = completedRestarts + 1;
-    const stageEnd = completedRestarts + stage.maxRestarts;
-    if (restartNumber >= stageStart && restartNumber <= stageEnd) {
-      return {
-        mode: "backoff",
-        stageIndex: index,
-        delayMs: stage.delayMinutes * 60000,
-        restartAttemptInStage: restartNumber - completedRestarts,
-        restartsRemaining: totalRestarts - restartNumber,
-        totalRestarts,
-        stageMaxRestarts: stage.maxRestarts
-      };
-    }
-    completedRestarts = stageEnd;
-  }
-  return null;
-}
+// src/control/owner-alerts.ts
 function parseOwnerPrincipal(principal) {
   const trimmed = principal.trim();
   if (!trimmed) {
@@ -75581,58 +75979,30 @@ function buildOwnerAlertCommand(params) {
     renderMode: "native"
   };
 }
+function dedupe(values) {
+  return [...new Set(values.filter(Boolean))];
+}
 async function sendOwnerAlert(params) {
-  const plugins = params.dependencies.listChannelPlugins();
-  const loadedByPlatform = new Map;
+  const plugins = params.listChannelPlugins();
   const delivered = [];
   const failed = [];
-  async function loadPlatform(platform) {
-    const existing = loadedByPlatform.get(platform);
-    if (existing) {
-      return existing;
-    }
-    const loaded = await params.dependencies.loadConfig(params.configPath, {
-      materializeChannels: [platform]
-    });
-    loadedByPlatform.set(platform, loaded);
-    return loaded;
-  }
-  const ownersByPlatform = new Map;
   for (const platform of ["slack", "telegram"]) {
-    try {
-      const loaded = await loadPlatform(platform);
-      const principals = dedupe(loaded.raw.app.auth.roles.owner?.users ?? []);
-      ownersByPlatform.set(platform, principals.map(parseOwnerPrincipal).filter((entry) => entry?.platform === platform).map((entry) => entry.userId));
-    } catch {
-      ownersByPlatform.set(platform, []);
-    }
-  }
-  for (const platform of ["slack", "telegram"]) {
-    const ownerIds = ownersByPlatform.get(platform) ?? [];
+    const principals = dedupe(params.loadedConfig.raw.app.auth.roles.owner?.users ?? []);
+    const ownerIds = principals.map(parseOwnerPrincipal).filter((entry) => entry?.platform === platform).map((entry) => entry.userId);
     if (ownerIds.length === 0) {
       continue;
     }
-    const loaded = await loadPlatform(platform).catch(() => null);
-    if (!loaded) {
-      for (const userId of ownerIds) {
-        failed.push({
-          principal: `${platform}:${userId}`,
-          detail: "config could not be loaded with resolved credentials"
-        });
-      }
-      continue;
-    }
     const plugin = plugins.find((entry) => entry.id === platform);
-    if (!plugin || !plugin.isEnabled(loaded)) {
+    if (!plugin || !plugin.isEnabled(params.loadedConfig)) {
       continue;
     }
-    const botIds = dedupe(plugin.listBots(loaded).map((entry) => entry.botId));
+    const botIds = dedupe(plugin.listBots(params.loadedConfig).map((entry) => entry.botId));
     for (const userId of ownerIds) {
       let deliveredToPrincipal = false;
       const principal = `${platform}:${userId}`;
       for (const botId of botIds) {
         try {
-          await plugin.runMessageCommand(loaded, buildOwnerAlertCommand({
+          await plugin.runMessageCommand(params.loadedConfig, buildOwnerAlertCommand({
             platform,
             botId,
             userId,
@@ -75661,16 +76031,73 @@ async function sendOwnerAlert(params) {
     failed
   };
 }
+
+// src/control/runtime-monitor.ts
+var defaultRuntimeMonitorDependencies = {
+  loadConfig,
+  listChannelPlugins,
+  writePid: async (pidPath, pid = process.pid) => {
+    await ensureDir2(dirname12(pidPath));
+    await writeTextFile(pidPath, `${pid}
+`);
+  },
+  readState: readRuntimeMonitorState,
+  writeState: writeRuntimeMonitorState,
+  removePid: (pidPath) => rmSync2(pidPath, { force: true }),
+  removeRuntimeCredentials: (runtimeCredentialsPath) => rmSync2(runtimeCredentialsPath, { force: true }),
+  sleep,
+  now: () => Date.now(),
+  spawnChild: (command, args, options) => spawn2(command, args, {
+    stdio: ["ignore", "inherit", "inherit"],
+    env: options.env
+  }),
+  sendSignal: kill
+};
+function isProcessAlive(pid) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readRuntimeMonitorState(statePath = getDefaultRuntimeMonitorStatePath()) {
+  if (!await fileExists(statePath)) {
+    return null;
+  }
+  try {
+    const raw = await readTextFile(statePath);
+    if (!raw.trim()) {
+      return null;
+    }
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeRuntimeMonitorState(statePath, state) {
+  await ensureDir2(dirname12(statePath));
+  await writeTextFile(statePath, `${JSON.stringify(state, null, 2)}
+`);
+}
+function summarizeExit(params) {
+  if (params.signal) {
+    return `signal ${params.signal}`;
+  }
+  return `code ${params.code ?? 0}`;
+}
 function renderBackoffAlertMessage(params) {
+  const restartLine = params.repeatingFinalStage ? `restart: ${params.restartNumber} (steady-state at final stage; configured ladder ${params.totalConfiguredRestarts})` : `restart: ${params.restartNumber}/${params.totalConfiguredRestarts}`;
+  const stageAttemptLine = params.repeatingFinalStage ? "stage attempt: steady-state retry on final stage" : `stage attempt: ${params.restartAttemptInStage}/${params.stageMaxRestarts}`;
   return [
     "clisbot runtime alert",
     "",
     "status: runtime exited unexpectedly and entered restart backoff",
     `last exit: ${summarizeExit(params.exit)} at ${params.exit.at}`,
     `next restart: ${params.nextRestartAt}`,
-    `restart: ${params.restartNumber}/${params.totalRestarts}`,
+    restartLine,
     `stage: ${params.stageIndex + 1}/${params.config.restartBackoff.stages.length}`,
-    `stage attempt: ${params.restartAttemptInStage}/${params.stageMaxRestarts}`
+    stageAttemptLine
   ].join(`
 `);
 }
@@ -75680,7 +76107,7 @@ function renderStoppedAlertMessage(params) {
     "",
     "status: runtime stopped after exhausting the configured restart budget",
     `last exit: ${summarizeExit(params.exit)} at ${params.exit.at}`,
-    `restart budget used: ${params.totalRestarts}`,
+    `restart budget used: ${params.totalConfiguredRestarts}`,
     `action: inspect ${renderCliCommand("logs", { inline: true })}, fix the fault, then start the service again`
   ].join(`
 `);
@@ -75697,6 +76124,7 @@ class RuntimeMonitor {
   stopRequested = false;
   activeChild = null;
   latestState = null;
+  loadedConfig;
   constructor(scriptPath, configPath, pidPath, statePath, runtimeCredentialsPath, dependencies) {
     this.scriptPath = scriptPath;
     this.configPath = configPath;
@@ -75710,13 +76138,16 @@ class RuntimeMonitor {
     this.registerProcessHandlers();
     try {
       const loadedConfig = await this.dependencies.loadConfig(this.configPath);
+      this.loadedConfig = loadedConfig;
       const monitorConfig = loadedConfig.raw.control.runtimeMonitor;
+      monitorConfig.restartBackoff = normalizeRuntimeMonitorRestartBackoff(monitorConfig.restartBackoff);
       let restartNumber = 0;
-      let totalRestarts = monitorConfig.restartBackoff.stages.reduce((sum, stage) => sum + stage.maxRestarts, 0);
+      let totalConfiguredRestarts = getConfiguredRuntimeMonitorRestartBudget(monitorConfig.restartBackoff);
       await this.writeState({
         phase: "starting"
       });
       while (!this.stopRequested) {
+        const runStartedAt = this.dependencies.now();
         const child = this.dependencies.spawnChild(process.execPath, [this.scriptPath, "serve-foreground"], {
           env: {
             ...process.env,
@@ -75738,11 +76169,14 @@ class RuntimeMonitor {
           break;
         }
         const exitAt = new Date().toISOString();
+        if (this.dependencies.now() - runStartedAt >= RUNTIME_MONITOR_RESTART_RESET_AFTER_MS) {
+          restartNumber = 0;
+        }
         const nextRestartNumber = restartNumber + 1;
-        const plan = getRestartPlan(monitorConfig.restartBackoff, nextRestartNumber);
+        const plan = getRuntimeMonitorRestartPlan(monitorConfig.restartBackoff, nextRestartNumber);
         if (!plan) {
           await this.maybeSendAlert("stopped", monitorConfig, renderStoppedAlertMessage({
-            totalRestarts,
+            totalConfiguredRestarts,
             exit: {
               code: exit.code,
               signal: exit.signal,
@@ -75762,7 +76196,7 @@ class RuntimeMonitor {
           return;
         }
         restartNumber = nextRestartNumber;
-        totalRestarts = plan.totalRestarts;
+        totalConfiguredRestarts = plan.totalConfiguredRestarts;
         const nextRestartAt = new Date(this.dependencies.now() + plan.delayMs).toISOString();
         if (plan.mode === "backoff") {
           await this.maybeSendAlert("backoff", monitorConfig, renderBackoffAlertMessage({
@@ -75771,8 +76205,9 @@ class RuntimeMonitor {
             stageIndex: plan.stageIndex,
             restartAttemptInStage: plan.restartAttemptInStage,
             stageMaxRestarts: plan.stageMaxRestarts,
-            totalRestarts,
+            totalConfiguredRestarts,
             nextRestartAt,
+            repeatingFinalStage: plan.repeatingFinalStage,
             exit: {
               code: exit.code,
               signal: exit.signal,
@@ -75873,10 +76308,13 @@ class RuntimeMonitor {
       }
     }
     try {
+      if (!this.loadedConfig) {
+        return;
+      }
       const result = await sendOwnerAlert({
-        configPath: this.configPath,
+        loadedConfig: this.loadedConfig,
         message,
-        dependencies: this.dependencies
+        listChannelPlugins: this.dependencies.listChannelPlugins
       });
       if (result.delivered.length === 0 && result.failed.length > 0) {
         console.error("clisbot runtime alert delivery failed", result.failed.map((entry) => `${entry.principal}: ${entry.detail}`).join("; "));
@@ -76021,6 +76459,20 @@ function resolveMonitorStatePath(monitorStatePath, configPath, options = {}) {
   }
   return expandHomePath(getDefaultRuntimeMonitorStatePath());
 }
+function resolveLiveMonitorPid(params) {
+  const processLiveness = params.processLiveness ?? getProcessLiveness;
+  if (params.pidFromFile && processLiveness(params.pidFromFile) === "running") {
+    return params.pidFromFile;
+  }
+  const monitorPid = params.monitorState?.monitorPid;
+  if (monitorPid && processLiveness(monitorPid) === "running") {
+    return monitorPid;
+  }
+  return null;
+}
+function resolveKnownMonitorPid(params) {
+  return params.pidFromFile ?? params.monitorState?.monitorPid ?? null;
+}
 function resolveRuntimeCredentialsPath(runtimeCredentialsPath, configPath, options = {}) {
   if (runtimeCredentialsPath) {
     return expandHomePath(runtimeCredentialsPath);
@@ -76125,11 +76577,18 @@ async function startDetachedRuntime(params) {
   const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath, configPath, { preferConfigSibling });
   const existingPid = await readRuntimePid(pidPath);
   const existingMonitorState = await readRuntimeMonitorState(monitorStatePath);
-  if (existingPid && isProcessRunning(existingPid)) {
+  const liveMonitorPid = resolveLiveMonitorPid({
+    pidFromFile: existingPid,
+    monitorState: existingMonitorState
+  });
+  if (liveMonitorPid) {
+    if (existingPid !== liveMonitorPid) {
+      await writeRuntimePid(pidPath, liveMonitorPid);
+    }
     return {
       alreadyRunning: true,
       createdConfig: false,
-      pid: existingPid,
+      pid: liveMonitorPid,
       configPath,
       logPath
     };
@@ -76208,10 +76667,14 @@ async function stopDetachedRuntime(params, dependencies = {}) {
   const processLiveness = dependencies.processLiveness ?? getProcessLiveness;
   const sendSignal = dependencies.sendSignal ?? kill2;
   const sleepFn = dependencies.sleep ?? sleep;
-  const existingLiveness = existingPid ? processLiveness(existingPid) : "missing";
-  if (existingPid && existingLiveness === "running") {
-    sendSignal(existingPid, "SIGTERM");
-    const exited = await waitForProcessExit(existingPid, STOP_WAIT_TIMEOUT_MS, {
+  const monitorPid = resolveKnownMonitorPid({
+    pidFromFile: existingPid,
+    monitorState
+  });
+  const monitorLiveness = monitorPid ? processLiveness(monitorPid) : "missing";
+  if (monitorPid && monitorLiveness === "running") {
+    sendSignal(monitorPid, "SIGTERM");
+    const exited = await waitForProcessExit(monitorPid, STOP_WAIT_TIMEOUT_MS, {
       processLiveness,
       sleep: sleepFn
     });
@@ -76219,7 +76682,7 @@ async function stopDetachedRuntime(params, dependencies = {}) {
       throw new Error(`clisbot did not stop within ${STOP_WAIT_TIMEOUT_MS}ms`);
     }
     stopped = true;
-  } else if (existingPid && existingLiveness === "zombie") {
+  } else if (monitorPid && monitorLiveness === "zombie") {
     stopped = true;
   }
   const runtimePid = monitorState?.runtimePid;
@@ -76235,7 +76698,7 @@ async function stopDetachedRuntime(params, dependencies = {}) {
       }
       stopped = true;
     } catch (error) {
-      if (!(existingPid && existingLiveness === "running")) {
+      if (!(monitorPid && monitorLiveness === "running")) {
         throw error;
       }
     }
@@ -76293,11 +76756,14 @@ async function getRuntimeStatus(params = {}) {
     preferConfigSibling
   });
   const pid = await readRuntimePid(pidPath);
-  const liveness = pid ? getProcessLiveness(pid) : "missing";
   const monitorState = await readRuntimeMonitorState(monitorStatePath);
+  const liveMonitorPid = resolveLiveMonitorPid({
+    pidFromFile: pid,
+    monitorState
+  });
   return {
-    running: liveness === "running",
-    pid: liveness === "running" && pid ? pid : undefined,
+    running: liveMonitorPid != null,
+    pid: liveMonitorPid ?? undefined,
     configPath,
     pidPath,
     logPath,
@@ -76495,7 +76961,7 @@ function extractLinuxProcState(raw) {
 }
 
 // src/control/bots-cli.ts
-function getEditableConfigPath6() {
+function getEditableConfigPath7() {
   return process.env.CLISBOT_CONFIG_PATH;
 }
 function parseOptionValue2(args, name) {
@@ -76685,7 +77151,7 @@ function summarizeBotConfig(provider, botId, bot) {
   };
 }
 async function listBots(args) {
-  const { config } = await readEditableConfig(getEditableConfigPath6());
+  const { config } = await readEditableConfig(getEditableConfigPath7());
   const provider = parseOptionValue2(args, "--channel");
   const printJson = hasFlag3(args, "--json");
   const summaries = [
@@ -76710,7 +77176,7 @@ async function addOrSetBotCredentials(args, deps, action) {
   const botId = getBotId(args);
   const persist = hasFlag3(args, "--persist");
   const runtimeStatus = await deps.getRuntimeStatus();
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   const exists = provider === "slack" ? botId in getSlackBots2(config) : (botId in getTelegramBots2(config));
   if (action === "add" && exists) {
     throw new Error(`Bot already exists: ${provider}/${botId}. Use ${renderCliCommand("bots set-agent ...", { inline: true })}, ${renderCliCommand("bots set-credentials ...", { inline: true })}, or another \`set-<key>\` command.`);
@@ -76838,7 +77304,7 @@ async function getBot(args) {
   const provider = parseProvider(args);
   const botId = getBotId(args);
   const printJson = hasFlag3(args, "--json");
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   const bot = ensureProviderBot(config, provider, botId);
   if (printJson) {
     console.log(JSON.stringify(bot, null, 2));
@@ -76849,7 +77315,7 @@ async function getBot(args) {
 async function setBotEnabled(args, enabled) {
   const provider = parseProvider(args);
   const botId = getBotId(args);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   const bot = ensureProviderBot(config, provider, botId);
   bot.enabled = enabled;
   reconcileProviderDefaults(config, provider);
@@ -76860,7 +77326,7 @@ async function setBotEnabled(args, enabled) {
 async function removeBot(args) {
   const provider = parseProvider(args);
   const botId = getBotId(args);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   const bot = ensureProviderBot(config, provider, botId);
   const directMessages = "directMessages" in bot ? Object.keys(bot.directMessages ?? {}) : [];
   const groups = "groups" in bot ? Object.keys(bot.groups ?? {}) : [];
@@ -76879,7 +77345,7 @@ async function removeBot(args) {
 }
 async function getOrSetDefaultBot(args, action) {
   const provider = parseProvider(args);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   if (action === "get-default") {
     const botId2 = provider === "slack" ? config.bots.slack.defaults.defaultBotId : config.bots.telegram.defaults.defaultBotId;
     console.log(`${provider} default bot: ${botId2}`);
@@ -76904,7 +77370,7 @@ async function getOrSetDefaultBot(args, action) {
 async function getOrSetBotAgent(args, action) {
   const provider = parseProvider(args);
   const botId = getBotId(args);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   const bot = ensureProviderBot(config, provider, botId);
   if (action === "get-agent") {
     console.log(`${provider}/${botId} agent: ${bot.agentId ?? "(inherit)"}`);
@@ -76934,7 +77400,7 @@ function ensureDefaultDmRoute(config, provider, botId) {
 async function getOrSetBotPolicy(args, action) {
   const provider = parseProvider(args);
   const botId = getBotId(args);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   const bot = ensureProviderBot(config, provider, botId);
   if (action === "get-dm-policy") {
     console.log(`${provider}/${botId} dmPolicy: ${ensureDefaultDmRoute(config, provider, botId).policy ?? "pairing"}`);
@@ -76989,7 +77455,7 @@ async function getOrSetBotPolicy(args, action) {
 async function getCredentialSource(args) {
   const provider = parseProvider(args);
   const botId = getBotId(args);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath6());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   ensureProviderBot(config, provider, botId);
   const source = provider === "slack" ? describeSlackCredentialSource({ config: config.bots.slack, botId }) : describeTelegramCredentialSource({ config: config.bots.telegram, botId });
   console.log(`${provider}/${botId} credentials: ${source.detail}`);
@@ -77580,14 +78046,14 @@ async function getScopedLoopCounts(params) {
 
 // src/control/loops-cli.ts
 var LOOP_BUSY_RETRY_MS = 250;
-function getEditableConfigPath7() {
+function getEditableConfigPath8() {
   return process.env.CLISBOT_CONFIG_PATH;
 }
 function getSessionState(sessionStorePath) {
   return new AgentSessionState(new SessionStore(sessionStorePath));
 }
 async function loadLoopControlState() {
-  const configPath = await ensureEditableConfigFile(getEditableConfigPath7());
+  const configPath = await ensureEditableConfigFile(getEditableConfigPath8());
   const loadedConfig = await loadConfigWithoutEnvResolution(configPath);
   const sessionStorePath = resolveSessionStorePath(loadedConfig);
   return {
@@ -78102,6 +78568,14 @@ function parseOptionValue4(args, name) {
   const values = parseRepeatedOption3(args, name);
   return values.length > 0 ? values.at(-1) : undefined;
 }
+function parseAliasedOptionValue2(args, preferredName, aliasName) {
+  const preferredValues = parseRepeatedOption3(args, preferredName);
+  const aliasValues = parseRepeatedOption3(args, aliasName);
+  if (preferredValues.length > 0 && aliasValues.length > 0) {
+    throw new Error(`${preferredName} and ${aliasName} are aliases; use only one`);
+  }
+  return preferredValues.at(-1) ?? aliasValues.at(-1);
+}
 function parseThreadingOptions(args, channel) {
   const threadId = parseOptionValue4(args, "--thread-id");
   const topicId = parseOptionValue4(args, "--topic-id");
@@ -78124,6 +78598,9 @@ function parseMessageBodyFileOption(args) {
   }
   return bodyFileValues.at(-1) ?? messageFileValues.at(-1);
 }
+function parseMessageAttachmentOption(args) {
+  return parseAliasedOptionValue2(args, "--file", "--media");
+}
 function parseIntegerOption(args, name) {
   const raw = parseOptionValue4(args, name);
   if (!raw) {
@@ -78165,7 +78642,7 @@ function parseMessageCommand(args) {
     target: parseOptionValue4(rest, "--target"),
     message: parseOptionValue4(rest, "--message") ?? parseOptionValue4(rest, "-m"),
     messageFile: parseMessageBodyFileOption(rest),
-    media: parseOptionValue4(rest, "--media"),
+    media: parseMessageAttachmentOption(rest),
     messageId: parseOptionValue4(rest, "--message-id"),
     emoji: parseOptionValue4(rest, "--emoji"),
     remove: hasFlag5(rest, "--remove"),
@@ -78189,7 +78666,7 @@ function renderMessageHelp() {
     renderCliCommand("message"),
     "",
     "Usage:",
-    `  ${renderCliCommand("message send --channel <slack|telegram> --target <dest> [--message <text> | --body-file <path>] [--input <plain|md|html|mrkdwn|blocks>] [--render <native|none|html|mrkdwn|blocks>] [--account <id>] [--media <path-or-url>] [--reply-to <id>] [--thread-id <slack-thread-ts>] [--topic-id <telegram-topic-id>] [--force-document] [--silent] [--progress|--final]")}`,
+    `  ${renderCliCommand("message send --channel <slack|telegram> --target <dest> [--message <text> | --body-file <path>] [--input <plain|md|html|mrkdwn|blocks>] [--render <native|none|html|mrkdwn|blocks>] [--account <id>] [--file <path-or-url>] [--reply-to <id>] [--thread-id <slack-thread-ts>] [--topic-id <telegram-topic-id>] [--force-document] [--silent] [--progress|--final]")}`,
     `  ${renderCliCommand("message poll --channel <slack|telegram> --target <dest> --poll-question <text> --poll-option <value> [--poll-option <value>] [--account <id>] [--thread-id <slack-thread-ts>] [--topic-id <telegram-topic-id>] [--silent]")}`,
     `  ${renderCliCommand("message react --channel <slack|telegram> --target <dest> --message-id <id> --emoji <emoji> [--account <id>] [--remove]")}`,
     `  ${renderCliCommand("message reactions --channel <slack|telegram> --target <dest> --message-id <id> [--account <id>]")}`,
@@ -78205,6 +78682,8 @@ function renderMessageHelp() {
     "  --message <text>              Inline message body",
     "  --body-file <path>            Read the message body from a file",
     "                                Alias: --message-file (compat only)",
+    "  --file <path-or-url>          Attach a file or remote URL",
+    "                                Alias: --media (compat only)",
     "  --input <plain|md|html|mrkdwn|blocks>",
     "                               Input content format. Default: md",
     "  --render <native|none|html|mrkdwn|blocks>",
@@ -78221,6 +78700,11 @@ function renderMessageHelp() {
     "  html                          Telegram only",
     "  mrkdwn                        Slack only",
     "",
+    "Length Guidance:",
+    "  Telegram native/html         Final payload must stay under 4096 chars; leave headroom after HTML-safe rendering",
+    "  Slack text/mrkdwn            Prefer text under 4000 chars; Slack truncates very long text after 40000",
+    "  Slack blocks                 Max 50 blocks; keep header text under 150 and section text under 3000",
+    "",
     "Threading:",
     "  --thread-id <id>              Slack thread ts",
     "  --topic-id <id>               Telegram topic id",
@@ -78291,7 +78775,7 @@ async function runMessageCli(args, dependencies = defaultMessageCliDependencies)
 }
 
 // src/control/routes-cli.ts
-function getEditableConfigPath8() {
+function getEditableConfigPath9() {
   return process.env.CLISBOT_CONFIG_PATH;
 }
 function getSlackBots3(config) {
@@ -78567,7 +79051,7 @@ function renderRoutesHelp() {
 `);
 }
 async function listRoutes(args) {
-  const { config } = await readEditableConfig(getEditableConfigPath8());
+  const { config } = await readEditableConfig(getEditableConfigPath9());
   const provider = parseOptionalProvider(args);
   const botIdFilter = parseOptionValue5(args, "--bot");
   const printJson = hasFlag6(args, "--json");
@@ -78628,7 +79112,7 @@ async function addRoute(args) {
   const policy = parseOptionValue5(args, "--policy");
   const requireMention = parseOptionValue5(args, "--require-mention");
   const allowBots = parseOptionValue5(args, "--allow-bots");
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath8());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath9());
   const existing = getOrCreateRoute(config, provider, botId, parsed);
   if (existing) {
     throw new Error(`Route already exists: ${provider}/${botId}/${parsed.routeId}. Use a matching \`set-<key>\` command instead.`);
@@ -78652,7 +79136,7 @@ async function getRoute(args) {
   const botId = getBotId2(args);
   const parsed = parseCommandRoute(args, provider);
   const printJson = hasFlag6(args, "--json");
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath8());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath9());
   const route = ensureRoute(config, provider, botId, parsed);
   if (printJson) {
     console.log(JSON.stringify(route, null, 2));
@@ -78665,7 +79149,7 @@ async function setRouteEnabled(args, enabled) {
   const botId = getBotId2(args);
   const parsed = parseCommandRoute(args, provider);
   rejectExactDirectMessageAdmissionChange(parsed, enabled ? "Enabling" : "Disabling");
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath8());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath9());
   const route = ensureRoute(config, provider, botId, parsed);
   route.enabled = enabled;
   await writeEditableConfig(configPath, config);
@@ -78676,7 +79160,7 @@ async function removeRoute(args) {
   const provider = parseProvider2(args);
   const botId = getBotId2(args);
   const parsed = parseCommandRoute(args, provider);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath8());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath9());
   ensureRoute(config, provider, botId, parsed);
   if (provider === "slack") {
     const bot = ensureSlackBot(config, botId);
@@ -78703,7 +79187,7 @@ async function getSetClearRouteField(args, action) {
   const provider = parseProvider2(args);
   const botId = getBotId2(args);
   const parsed = parseCommandRoute(args, provider);
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath8());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath9());
   const route = ensureRoute(config, provider, botId, parsed);
   if (action === "get-agent") {
     console.log(`${provider}/${botId}/${parsed.routeId} agent: ${route.agentId ?? "(inherit)"}`);
@@ -78809,7 +79293,7 @@ async function mutateRouteUsers(args, action) {
   if (!user) {
     throw new Error(renderRoutesHelp());
   }
-  const { config, configPath } = await readEditableConfig(getEditableConfigPath8());
+  const { config, configPath } = await readEditableConfig(getEditableConfigPath9());
   const route = parsed.storage === "directMessages" && isDirectMessageWildcardRouteId(parsed.routeId) ? ensureBotDirectMessageWildcardRoute(config, provider, botId) : ensureRoute(config, provider, botId, parsed);
   const field = action.includes("allow") ? "allowUsers" : "blockUsers";
   const current = Array.from(new Set((route[field] ?? []).filter(Boolean)));
@@ -79055,7 +79539,7 @@ function renderRunnerHelp() {
     `  ${renderCliCommand("runner smoke --backend all --suite launch-trio [--workspace <path>] [--agent <id>] [--artifact-dir <path>] [--timeout-ms <n>] [--keep-session] [--json]")}`,
     "",
     "Operator session debugging:",
-    "  - `list` shows current tmux runner sessions, newest admitted turn first when known",
+    "  - `list` shows current tmux runner sessions, newest admitted turn first when known, plus stored sessionId/state when available",
     "  - `inspect` captures one snapshot from a named tmux session",
     "  - `watch --latest` follows the session that most recently admitted a new prompt",
     "  - `watch --next` waits for the next newly admitted prompt, then follows that session",
@@ -79255,21 +79739,29 @@ async function runListCli() {
   console.log([
     renderCliCommand("runner list"),
     "",
-    ...sessions.map((session) => {
-      if (!session.entry) {
-        return `- ${session.sessionName}`;
-      }
-      return [
-        `- ${session.sessionName}`,
-        `  agent: ${session.entry.agentId}`,
-        `  sessionKey: ${session.entry.sessionKey}`,
-        `  lastAdmittedPromptAt: ${formatTimestamp(session.entry.lastAdmittedPromptAt)}`
-      ].join(`
-`);
-    })
+    ...sessions.map(renderRunnerListSession)
   ].join(`
 `));
 }
+function renderRunnerListSession(session) {
+  if (!session.entry) {
+    return [
+      `- sessionName: ${session.sessionName}`,
+      "  sessionId: none",
+      "  state: unmanaged"
+    ].join(`
+`);
+  }
+  return [
+    `- sessionName: ${session.sessionName}`,
+    `  agent: ${session.entry.agentId}`,
+    `  sessionKey: ${session.entry.sessionKey}`,
+    `  sessionId: ${session.entry.sessionId?.trim() || "none"}`,
+    `  state: ${session.entry.runtime?.state ?? "no-runtime"}`,
+    `  lastAdmittedPromptAt: ${formatTimestamp(session.entry.lastAdmittedPromptAt)}`
+  ].join(`
+`);
+}
 async function runInspectCli(args) {
   const options = parseInspectCommand(args);
   const { tmux } = await loadRunnerContext();
@@ -80377,6 +80869,40 @@ class ProcessedEventsStore {
 
 // src/control/runtime-supervisor.ts
 var SERVICE_START_TIMEOUT_MS = 8000;
+function buildChannelOwnerAlertKey(params) {
+  return `${params.runtimeId}:${params.channel}:${params.botId}`;
+}
+function formatElapsedDuration(elapsedMs) {
+  const totalMinutes = Math.max(1, Math.floor(elapsedMs / 60000));
+  if (totalMinutes < 60) {
+    return `${totalMinutes} minute${totalMinutes === 1 ? "" : "s"}`;
+  }
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (minutes === 0) {
+    return `${hours} hour${hours === 1 ? "" : "s"}`;
+  }
+  return `${hours} hour${hours === 1 ? "" : "s"} ${minutes} minute${minutes === 1 ? "" : "s"}`;
+}
+function renderChannelOwnerAlertMessage(params) {
+  const elapsed = formatElapsedDuration(params.elapsedMs);
+  const statusLine = params.incidentState === "failed" ? `status: ${params.channel} channel has remained failed for ${elapsed}` : params.incidentState === "still-failed" ? `status: ${params.channel} channel is still failing after ${elapsed}` : `status: ${params.channel} channel recovered after ${elapsed}`;
+  return [
+    "clisbot channel alert",
+    "",
+    statusLine,
+    `channel: ${params.channel}/${params.botId}`,
+    ...params.summary ? [`summary: ${params.summary}`] : [],
+    ...params.detail ? [`detail: ${params.detail}`] : [],
+    ...params.incidentState === "resolved" ? [
+      "note: the channel recovered without requiring a runtime restart"
+    ] : [
+      "note: the runtime process is still alive; clisbot is continuing automatic channel-level recovery attempts",
+      `action: inspect ${renderCliCommand("logs", { inline: true })} and fix the channel-level fault or conflicting poller`
+    ]
+  ].join(`
+`);
+}
 
 class RuntimeSupervisor {
   configPath;
@@ -80387,6 +80913,7 @@ class RuntimeSupervisor {
   reloadRequested = false;
   configWatchDebounceMs = 250;
   nextRuntimeId = 1;
+  channelOwnerAlertIncidents = new Map;
   dependencies;
   constructor(configPath, dependencies) {
     this.configPath = configPath;
@@ -80479,6 +81006,7 @@ class RuntimeSupervisor {
       });
       this.activeRuntime = nextRuntime;
       if (previousRuntime) {
+        this.clearChannelOwnerAlertsForRuntime(previousRuntime.id);
         for (const service of previousRuntime.channelServices) {
           await service.service.stop();
         }
@@ -80517,6 +81045,7 @@ class RuntimeSupervisor {
         this.activeRuntime = previousRuntime;
       }
       if (nextRuntime && nextRuntime !== this.activeRuntime) {
+        this.clearChannelOwnerAlertsForRuntime(nextRuntime.id);
         for (const service of nextRuntime.channelServices) {
           await service.service.stop();
         }
@@ -80640,11 +81169,18 @@ class RuntimeSupervisor {
     return channelServices.filter((entry) => entry.channel === channel).map((entry) => entry.service.getRuntimeIdentity?.()).filter((identity) => identity != null);
   }
   async reportChannelLifecycle(params) {
-    if (this.activeRuntime?.id !== params.runtimeId) {
+    const activeRuntime = this.activeRuntime;
+    if (activeRuntime?.id !== params.runtimeId) {
       return;
     }
     const instances = this.getChannelInstances(params.channelServices, params.plugin.id);
+    const incidentKey = buildChannelOwnerAlertKey({
+      runtimeId: params.runtimeId,
+      channel: params.plugin.id,
+      botId: params.botId
+    });
     if (params.event.connection === "active") {
+      await this.clearChannelOwnerAlert(incidentKey, params.event);
       await this.dependencies.runtimeHealthStore.setChannel({
         channel: params.plugin.id,
         connection: "active",
@@ -80667,6 +81203,14 @@ class RuntimeSupervisor {
       ],
       instances
     });
+    this.scheduleChannelOwnerAlert({
+      key: incidentKey,
+      runtimeId: params.runtimeId,
+      loadedConfig: activeRuntime.loadedConfig,
+      pluginId: params.plugin.id,
+      botId: params.botId,
+      event: params.event
+    });
   }
   async reconcileConfigWatcher(loadedConfig) {
     const configReload = loadedConfig.raw.control.configReload;
@@ -80712,12 +81256,151 @@ class RuntimeSupervisor {
     if (!this.activeRuntime) {
       return;
     }
+    this.clearChannelOwnerAlertsForRuntime(this.activeRuntime.id);
     for (const service of this.activeRuntime.channelServices) {
       await service.service.stop();
     }
     await this.activeRuntime.agentService.stop();
     this.activeRuntime = undefined;
   }
+  scheduleChannelOwnerAlert(params) {
+    const delayMs = params.event.ownerAlertAfterMs;
+    if (!delayMs || delayMs <= 0 || !params.loadedConfig.raw.control.runtimeMonitor.ownerAlerts.enabled) {
+      return;
+    }
+    const repeatAlertEveryMs = params.event.ownerAlertRepeatMs ?? params.loadedConfig.raw.control.runtimeMonitor.ownerAlerts.minIntervalMinutes * 60000;
+    const existingIncident = this.channelOwnerAlertIncidents.get(params.key);
+    const incident = existingIncident ?? {
+      runtimeId: params.runtimeId,
+      channel: params.pluginId,
+      botId: params.botId,
+      repeatAlertEveryMs: Math.max(1, repeatAlertEveryMs),
+      startedAtMs: Date.now(),
+      deliveredAlerts: 0
+    };
+    incident.channel = params.pluginId;
+    incident.botId = params.botId;
+    incident.summary = params.event.summary;
+    incident.detail = params.event.detail;
+    incident.repeatAlertEveryMs = Math.max(1, repeatAlertEveryMs);
+    this.channelOwnerAlertIncidents.set(params.key, incident);
+    if (incident.timer) {
+      return;
+    }
+    this.scheduleNextChannelOwnerAlert({
+      key: params.key,
+      runtimeId: params.runtimeId,
+      channel: params.pluginId,
+      botId: params.botId,
+      delayMs: existingIncident ? incident.repeatAlertEveryMs : delayMs
+    });
+  }
+  scheduleNextChannelOwnerAlert(params) {
+    const incident = this.channelOwnerAlertIncidents.get(params.key);
+    if (!incident || incident.runtimeId !== params.runtimeId) {
+      return;
+    }
+    incident.timer = setTimeout(() => {
+      this.fireChannelOwnerAlert({
+        key: params.key,
+        runtimeId: params.runtimeId,
+        channel: params.channel,
+        botId: params.botId
+      });
+    }, params.delayMs);
+    incident.timer.unref?.();
+    this.channelOwnerAlertIncidents.set(params.key, incident);
+  }
+  async fireChannelOwnerAlert(params) {
+    const incident = this.channelOwnerAlertIncidents.get(params.key);
+    if (!incident || incident.runtimeId !== params.runtimeId) {
+      return;
+    }
+    incident.timer = undefined;
+    const activeRuntime = this.activeRuntime;
+    if (activeRuntime?.id !== params.runtimeId) {
+      return;
+    }
+    try {
+      const message = renderChannelOwnerAlertMessage({
+        channel: params.channel,
+        botId: params.botId,
+        incidentState: incident.deliveredAlerts === 0 ? "failed" : "still-failed",
+        elapsedMs: Date.now() - incident.startedAtMs,
+        summary: incident.summary,
+        detail: incident.detail
+      });
+      const result = await sendOwnerAlert({
+        loadedConfig: activeRuntime.loadedConfig,
+        message,
+        listChannelPlugins: this.dependencies.listChannelPlugins
+      });
+      if (result.delivered.length > 0) {
+        incident.deliveredAlerts += 1;
+      }
+      this.channelOwnerAlertIncidents.set(params.key, incident);
+      if (result.delivered.length === 0 && result.failed.length > 0) {
+        console.error("clisbot channel alert delivery failed", result.failed.map((entry) => `${entry.principal}: ${entry.detail}`).join("; "));
+      }
+    } catch (error) {
+      console.error("clisbot channel alert dispatch failed", error);
+    }
+    const nextIncident = this.channelOwnerAlertIncidents.get(params.key);
+    if (!nextIncident || nextIncident.runtimeId !== params.runtimeId || nextIncident.timer || nextIncident.deliveredAlerts >= 2) {
+      return;
+    }
+    this.scheduleNextChannelOwnerAlert({
+      key: params.key,
+      runtimeId: params.runtimeId,
+      channel: params.channel,
+      botId: params.botId,
+      delayMs: nextIncident.repeatAlertEveryMs
+    });
+  }
+  async clearChannelOwnerAlert(key, activeEvent) {
+    const incident = this.channelOwnerAlertIncidents.get(key);
+    if (!incident) {
+      return;
+    }
+    if (incident.timer) {
+      clearTimeout(incident.timer);
+    }
+    this.channelOwnerAlertIncidents.delete(key);
+    if (incident.deliveredAlerts === 0) {
+      return;
+    }
+    const activeRuntime = this.activeRuntime;
+    if (!activeRuntime || activeRuntime.id !== incident.runtimeId) {
+      return;
+    }
+    try {
+      await sendOwnerAlert({
+        loadedConfig: activeRuntime.loadedConfig,
+        message: renderChannelOwnerAlertMessage({
+          channel: incident.channel,
+          botId: incident.botId,
+          incidentState: "resolved",
+          elapsedMs: Date.now() - incident.startedAtMs,
+          summary: activeEvent?.summary ?? "Channel recovered.",
+          detail: activeEvent?.detail
+        }),
+        listChannelPlugins: this.dependencies.listChannelPlugins
+      });
+    } catch (error) {
+      console.error("clisbot channel recovery alert dispatch failed", error);
+    }
+  }
+  clearChannelOwnerAlertsForRuntime(runtimeId) {
+    for (const [key, incident] of this.channelOwnerAlertIncidents.entries()) {
+      if (incident.runtimeId !== runtimeId) {
+        continue;
+      }
+      if (incident.timer) {
+        clearTimeout(incident.timer);
+      }
+      this.channelOwnerAlertIncidents.delete(key);
+    }
+  }
 }
 async function withStartupTimeout(name, start2) {
   let timer;
@@ -80738,6 +81421,9 @@ async function withStartupTimeout(name, start2) {
 }
 
 // src/control/runtime-management-cli.ts
+function getOperatorConfigPath() {
+  return expandHomePath(process.env.CLISBOT_CONFIG_PATH || DEFAULT_CONFIG_PATH);
+}
 function getPrimaryWorkspacePath2(summary) {
   const preferredAgentId = summary.channelSummaries.find((channel) => channel.enabled)?.defaultAgentId ?? "default";
   return summary.agentSummaries.find((agent) => agent.id === preferredAgentId)?.workspacePath ?? summary.agentSummaries[0]?.workspacePath;
@@ -80801,7 +81487,9 @@ function registerProcessHandlers(runtimeSupervisor, shutdown) {
   });
 }
 async function printStatusSummary() {
-  const runtimeStatus = await getRuntimeStatus();
+  const runtimeStatus = await getRuntimeStatus({
+    configPath: getOperatorConfigPath()
+  });
   console.log(`version: ${getClisbotVersion()}`);
   console.log(`running: ${runtimeStatus.running ? "yes" : "no"}`);
   if (runtimeStatus.pid) {
@@ -80860,7 +81548,9 @@ async function printStatusSummary() {
 }
 async function printDiagnosticsAfterLogTail() {
   try {
-    const runtimeStatus = await getRuntimeStatus();
+    const runtimeStatus = await getRuntimeStatus({
+      configPath: getOperatorConfigPath()
+    });
     const summary = await getRuntimeOperatorSummary({
       configPath: runtimeStatus.configPath,
       runtimeRunning: runtimeStatus.running
@@ -80948,6 +81638,7 @@ async function printCliError(error) {
 }
 async function stop(hard = false) {
   const result = await stopDetachedRuntime({
+    configPath: getOperatorConfigPath(),
     hard
   });
   if (!result.stopped && !hard) {
@@ -80968,6 +81659,7 @@ async function stop(hard = false) {
 }
 async function restart() {
   await stopDetachedRuntime({
+    configPath: getOperatorConfigPath(),
     hard: false
   });
 }
@@ -80975,7 +81667,11 @@ async function status() {
   await printStatusSummary();
 }
 async function logs(lines) {
+  const runtimeStatus = await getRuntimeStatus({
+    configPath: getOperatorConfigPath()
+  });
   const result = await readRuntimeLog({
+    logPath: runtimeStatus.logPath,
     lines
   });
   if (!result.text) {