clisbot 0.1.22 → 0.1.28

package/dist/main.js

@@ -54694,6 +54694,7 @@ function renderCliHelp() {
     "",
     "Commands:",
     `  start              Seed ${configPath} if missing, apply explicit channel-account bootstrap intent, and start clisbot in the background.`,
+    "                     See `clisbot start --help` for bootstrap-focused flags and examples.",
     "  restart            Stop the running clisbot process, then start it again.",
     "  stop               Stop the running clisbot process.",
     "  stop --hard        Stop clisbot and kill all tmux sessions on the configured clisbot socket.",
@@ -54710,20 +54711,26 @@ function renderCliHelp() {
     "                     remove slack-group <groupId>",
     "                     set-token <slack-app|slack-bot|telegram-bot> <value>",
     "                     clear-token <slack-app|slack-bot|telegram-bot>",
+    "                     See `clisbot channels --help` for route policy notes and defaults such as `requireMention`.",
     "  accounts           Manage Slack and Telegram provider accounts plus persistence state.",
     "                     add telegram --account <id> --token <ENV_NAME|${ENV_NAME}|literal> [--persist]",
     "                     add slack --account <id> --app-token <ENV_NAME|${ENV_NAME}|literal> --bot-token <ENV_NAME|${ENV_NAME}|literal> [--persist]",
     "                     persist --channel <slack|telegram> --account <id>",
     "                     persist --all",
+    "                     See `clisbot accounts --help` for env-vs-mem-vs-persist behavior.",
     "  loops              Inspect or cancel managed recurring loops persisted by `/loop`.",
     "                     list|status",
     "                     cancel <id>",
     "                     cancel --all",
+    "                     See `clisbot loops --help` for behavior notes.",
     "  message            Run provider message actions such as send, react, read, edit, delete, and pins.",
+    "                     See `clisbot message --help` for channel-specific syntax.",
     "  agents             Manage configured agents and top-level bindings.",
+    "                     See `clisbot agents --help` for focused add/bootstrap/binding help.",
     "  auth               Manage app and agent auth roles, principals, and permissions in config. See `clisbot auth --help`.",
-    "  pairing            Run the pairing control CLI.",
+    "  pairing            Run the pairing control CLI. See `clisbot pairing --help`.",
     `  init               Seed ${configPath} and optionally create the first agent without starting clisbot.`,
+    "                     See `clisbot init --help` for bootstrap-focused flags and examples.",
     "  --version, -v      Show the installed clisbot version.",
     "  --help             Show this help text.",
     "",
@@ -54766,6 +54773,35 @@ function buildPairingReply(params) {
   ].join(`
 `);
 }
+function buildPairingQueueFullReply(params) {
+  return [
+    "clisbot: access not configured.",
+    "",
+    params.idLine,
+    "",
+    "Pairing queue is full right now.",
+    "",
+    "Ask the bot owner to inspect or clear pending requests with:",
+    `clisbot pairing list ${params.channel}`,
+    `clisbot pairing reject ${params.channel} <code>`,
+    `clisbot pairing clear ${params.channel}`
+  ].join(`
+`);
+}
+function buildPairingReplyFromRequest(params) {
+  const code = params.pairingRequest.code.trim();
+  if (!code) {
+    return buildPairingQueueFullReply({
+      channel: params.channel,
+      idLine: params.idLine
+    });
+  }
+  return buildPairingReply({
+    channel: params.channel,
+    idLine: params.idLine,
+    code
+  });
+}
 function renderPairingRequests(params) {
   if (!params.requests.length) {
     return `No pending ${params.channel} pairing requests.`;
@@ -54788,7 +54824,7 @@ import path from "node:path";
 var PAIRING_CODE_LENGTH = 8;
 var PAIRING_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 var PAIRING_PENDING_TTL_MS = 60 * 60 * 1000;
-var PAIRING_PENDING_MAX = 3;
+var PAIRING_PENDING_MAX = 20;
 var PAIRING_STORE_LOCK_OPTIONS = {
   retries: {
     retries: 10,
@@ -55067,8 +55103,63 @@ async function approveChannelPairingCode(params) {
     return { id: entry.id, entry };
   });
 }
+async function rejectChannelPairingCode(params) {
+  const code = params.code.trim().toUpperCase();
+  if (!code) {
+    return null;
+  }
+  const filePath = resolvePairingPath(params.channel, params.baseDir);
+  return withFileLock(filePath, { version: 1, requests: [] }, async () => {
+    const { value } = await readJsonFile(filePath, {
+      version: 1,
+      requests: []
+    });
+    const requests = Array.isArray(value.requests) ? value.requests : [];
+    const { requests: pruned, removed } = pruneExpiredRequests(requests, Date.now());
+    const matchIndex = pruned.findIndex((request) => String(request.code ?? "").trim().toUpperCase() === code);
+    if (matchIndex < 0) {
+      if (removed) {
+        await writeJsonFile(filePath, {
+          version: 1,
+          requests: pruned
+        });
+      }
+      return null;
+    }
+    const [rejected] = pruned.splice(matchIndex, 1);
+    await writeJsonFile(filePath, {
+      version: 1,
+      requests: pruned
+    });
+    return rejected ?? null;
+  });
+}
+async function clearChannelPairingRequests(params) {
+  const filePath = resolvePairingPath(params.channel, params.baseDir);
+  return withFileLock(filePath, { version: 1, requests: [] }, async () => {
+    const { value } = await readJsonFile(filePath, {
+      version: 1,
+      requests: []
+    });
+    const requests = Array.isArray(value.requests) ? value.requests : [];
+    const { requests: pruned } = pruneExpiredRequests(requests, Date.now());
+    await writeJsonFile(filePath, {
+      version: 1,
+      requests: []
+    });
+    return { cleared: pruned.length };
+  });
+}
 
 // src/channels/pairing/cli.ts
+function resolvePairingBaseDir(env = process.env) {
+  const configured = env.CLISBOT_PAIRING_DIR?.trim();
+  if (configured) {
+    return configured;
+  }
+  const legacy = env.TMUX_TALK_PAIRING_DIR?.trim();
+  return legacy || undefined;
+}
 function parseChannel(raw) {
   const value = raw?.trim().toLowerCase();
   if (value === "slack" || value === "telegram") {
@@ -55076,9 +55167,33 @@ function parseChannel(raw) {
   }
   throw new Error("Channel required: slack | telegram");
 }
+function renderPairingCliHelp() {
+  return [
+    "clisbot pairing",
+    "",
+    "Usage:",
+    "  clisbot pairing --help",
+    "  clisbot pairing help",
+    "  clisbot pairing list <slack|telegram> [--json]",
+    "  clisbot pairing approve <slack|telegram> <code>",
+    "  clisbot pairing reject <slack|telegram> <code>",
+    "  clisbot pairing clear <slack|telegram>",
+    "",
+    "Notes:",
+    "  - `list` shows pending pairing requests for one channel only",
+    "  - `approve` moves that sender into the channel allowlist",
+    "  - `reject` removes one pending request without allowlisting the sender",
+    "  - `clear` drops every pending request for that channel when the queue needs a reset"
+  ].join(`
+`);
+}
 async function runPairingCli(args, writer = console) {
   const [command, ...rest] = args;
-  const baseDir = process.env.TMUX_TALK_PAIRING_DIR;
+  const baseDir = resolvePairingBaseDir();
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    writer.log(renderPairingCliHelp());
+    return;
+  }
   if (command === "list") {
     const wantsJson = rest.includes("--json");
     const channel = parseChannel(rest.find((value) => !value.startsWith("--")));
@@ -55103,7 +55218,34 @@ async function runPairingCli(args, writer = console) {
     writer.log(`Approved ${channel} sender ${approved.id}.`);
     return;
   }
-  throw new Error("Usage: pairing list <channel> [--json] | pairing approve <channel> <code>");
+  if (command === "reject") {
+    const [channelArg, code] = rest;
+    const channel = parseChannel(channelArg);
+    if (!code?.trim()) {
+      throw new Error("Usage: pairing reject <channel> <code>");
+    }
+    const rejected = await rejectChannelPairingCode({
+      channel,
+      code,
+      baseDir
+    });
+    if (!rejected) {
+      throw new Error(`No pending pairing request found for code: ${code}`);
+    }
+    writer.log(`Rejected ${channel} sender ${rejected.id}.`);
+    return;
+  }
+  if (command === "clear") {
+    const [channelArg] = rest;
+    const channel = parseChannel(channelArg);
+    const result = await clearChannelPairingRequests({
+      channel,
+      baseDir
+    });
+    writer.log(`Cleared ${result.cleared} pending ${channel} pairing request(s).`);
+    return;
+  }
+  throw new Error(renderPairingCliHelp());
 }
 
 // src/config/agent-tool-presets.ts
@@ -59283,7 +59425,7 @@ function formatConfiguredRuntimeLimit(params) {
   if (typeof params.maxRuntimeMin === "number" && Number.isFinite(params.maxRuntimeMin)) {
     return `${params.maxRuntimeMin} minute${params.maxRuntimeMin === 1 ? "" : "s"}`;
   }
-  return "15 minutes";
+  return "30 minutes";
 }
 function parseCommandDurationMs(raw) {
   const match = raw.trim().match(/^(\d+)(ms|s|m|h)$/i);
@@ -59932,7 +60074,7 @@ var sessionDmScopeSchema = exports_external.enum([
 ]);
 var sessionConfigSchema = exports_external.object({
   mainKey: exports_external.string().min(1).default("main"),
-  dmScope: sessionDmScopeSchema.default("main"),
+  dmScope: sessionDmScopeSchema.default("per-channel-peer"),
   identityLinks: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).default({}),
   storePath: exports_external.string().default("~/.clisbot/state/sessions.json")
 });
@@ -59991,7 +60133,7 @@ var agentDefaultsSchema = exports_external.object({
     updateIntervalMs: 2000,
     idleTimeoutMs: 6000,
     noOutputTimeoutMs: 20000,
-    maxRuntimeMin: 15,
+    maxRuntimeMin: 30,
     maxMessageChars: 3500
   }),
   session: sessionSchema.default({
@@ -60250,7 +60392,15 @@ var controlRuntimeMonitorRestartStageSchema = exports_external.object({
   delayMinutes: exports_external.number().int().positive().default(15),
   maxRestarts: exports_external.number().int().positive().default(4)
 });
+var controlRuntimeMonitorFastRetrySchema = exports_external.object({
+  delaySeconds: exports_external.number().int().positive().default(10),
+  maxRestarts: exports_external.number().int().min(0).default(3)
+});
 var controlRuntimeMonitorRestartBackoffSchema = exports_external.object({
+  fastRetry: controlRuntimeMonitorFastRetrySchema.default({
+    delaySeconds: 10,
+    maxRestarts: 3
+  }),
   stages: exports_external.array(controlRuntimeMonitorRestartStageSchema).min(1).default([
     {
       delayMinutes: 15,
@@ -60268,6 +60418,10 @@ var controlRuntimeMonitorOwnerAlertsSchema = exports_external.object({
 });
 var controlRuntimeMonitorSchema = exports_external.object({
   restartBackoff: controlRuntimeMonitorRestartBackoffSchema.default({
+    fastRetry: {
+      delaySeconds: 10,
+      maxRestarts: 3
+    },
     stages: [
       {
         delayMinutes: 15,
@@ -60328,7 +60482,7 @@ var clisbotConfigSchema = exports_external.object({
   }),
   session: sessionConfigSchema.default({
     mainKey: "main",
-    dmScope: "main",
+    dmScope: "per-channel-peer",
     identityLinks: {},
     storePath: "~/.clisbot/state/sessions.json"
   }),
@@ -60367,6 +60521,10 @@ var clisbotConfigSchema = exports_external.object({
     },
     runtimeMonitor: {
       restartBackoff: {
+        fastRetry: {
+          delaySeconds: 10,
+          maxRestarts: 3
+        },
         stages: [
           {
             delayMinutes: 15,
@@ -60581,7 +60739,7 @@ function renderDefaultConfigTemplate(options = {}) {
     },
     session: {
       mainKey: "main",
-      dmScope: "main",
+      dmScope: "per-channel-peer",
       identityLinks: {},
       storePath: sessionStorePath
     },
@@ -60663,7 +60821,7 @@ function renderDefaultConfigTemplate(options = {}) {
           updateIntervalMs: 2000,
           idleTimeoutMs: 6000,
           noOutputTimeoutMs: 20000,
-          maxRuntimeMin: 15,
+          maxRuntimeMin: 30,
           maxMessageChars: 3500
         },
         session: {
@@ -60691,6 +60849,10 @@ function renderDefaultConfigTemplate(options = {}) {
       },
       runtimeMonitor: {
         restartBackoff: {
+          fastRetry: {
+            delaySeconds: 10,
+            maxRestarts: 3
+          },
           stages: [
             {
               delayMinutes: 15,
@@ -61024,6 +61186,32 @@ function parseSingleOption(args, name) {
 function hasFlag(args, name) {
   return args.includes(name);
 }
+function renderAgentsHelp() {
+  return [
+    "clisbot agents",
+    "",
+    "Usage:",
+    "  clisbot agents --help",
+    "  clisbot agents help",
+    "  clisbot agents list [--bindings] [--json]",
+    "  clisbot agents add <id> --cli <codex|claude|gemini> [--workspace <path>] [--startup-option <arg>]... [--bootstrap <personal-assistant|team-assistant>] [--bind <channel[:accountId]>]...",
+    "  clisbot agents bootstrap <id> --mode <personal-assistant|team-assistant> [--force]",
+    "  clisbot agents bindings [--agent <id>] [--json]",
+    "  clisbot agents bind --agent <id> --bind <channel[:accountId]>",
+    "  clisbot agents unbind --agent <id> [--bind <channel[:accountId]> | --all]",
+    "  clisbot agents response-mode <status|set|clear> --agent <id> [capture-pane|message-tool]",
+    "  clisbot agents additional-message-mode <status|set|clear> --agent <id> [queue|steer]",
+    "",
+    "Notes:",
+    "  - `agents add` is the lower-level manual surface; first-run `clisbot start` and `clisbot init` can bootstrap the first `default` agent for you",
+    "  - `--cli` is required on `agents add`; supported tools are `codex`, `claude`, and `gemini`",
+    "  - omit `--startup-option` to inherit the built-in startup args for the selected CLI tool",
+    "  - `--bind slack`, `--bind telegram`, or `--bind <channel>:<accountId>` creates top-level fallback bindings",
+    "  - explicit route `agentId` on Slack or Telegram still wins before these fallback bindings",
+    "  - `response-mode` and `additional-message-mode` mutate per-agent overrides under `agents.list[]`"
+  ].join(`
+`);
+}
 function parseResponseMode(raw) {
   if (raw === "capture-pane" || raw === "message-tool") {
     return raw;
@@ -61353,7 +61541,11 @@ async function runAgentAdditionalMessageModeCli(args) {
 async function runAgentsCli(args) {
   const subcommand = args[0];
   const rest = args.slice(1);
-  if (!subcommand || subcommand === "list") {
+  if (!subcommand || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+    console.log(renderAgentsHelp());
+    return;
+  }
+  if (subcommand === "list") {
     await listAgents(rest);
     return;
   }
@@ -61385,7 +61577,7 @@ async function runAgentsCli(args) {
     await unbindAgent(rest);
     return;
   }
-  throw new Error(`Unknown agents subcommand: ${subcommand}`);
+  throw new Error(renderAgentsHelp());
 }
 
 // src/control/accounts-cli.ts
@@ -61731,8 +61923,8 @@ class RuntimeHealthStore {
 
 // src/control/runtime-process.ts
 import { execFileSync, spawn as spawn3 } from "node:child_process";
-import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync3 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
+import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
+import { dirname as dirname13, join as join11 } from "node:path";
 import { kill as kill2 } from "node:process";
 
 // src/control/clisbot-wrapper.ts
@@ -62719,43 +62911,151 @@ function hasActiveRuntime(entry) {
 }
 
 // src/channels/agent-prompt.ts
-function buildAgentPromptText(params) {
-  if (!params.config.enabled) {
-    return params.text;
-  }
-  const systemBlock = renderAgentPromptInstruction(params);
-  return `<system>
-${systemBlock}
+var CONFIGURATION_GUIDANCE = "When the user asks to change clisbot configuration, use clisbot CLI commands; see `clisbot --help`, `clisbot channels --help`, or `clisbot auth --help` for details.";
+var BASE_TEMPLATE = `<system>
+[{{timestamp}}] {{identity_summary}}
+
+You are operating inside clisbot.
+{{delivery_intro}}
+{{reply_command}}
+{{reply_rules}}
+${CONFIGURATION_GUIDANCE}{{protected_control_suffix}}
+</system>
+
+<user>
+{{message_body}}
+</user>`;
+var STEERING_TEMPLATE = `<system>
+A new user message arrived while you were still working.
+Adjust your current work if needed and continue.{{protected_control_suffix}}
 </system>
 
 <user>
-${params.text}
+{{message_body}}
 </user>`;
+var DELIVERY_INTRO = "To send a user-visible {{progress_phrase}}final reply, use the following CLI command:";
+var DELIVERY_INTRO_CAPTURE_PANE = "channel auto-delivery remains enabled for this conversation; do not send user-facing progress updates or the final response with clisbot message send";
+var REPLY_COMMAND = `{{reply_command_base}}
+  --final{{progress_flag_suffix}} \\
+  --message "$(cat <<\\__CLISBOT_MESSAGE__
+<user-facing reply>
+__CLISBOT_MESSAGE__
+)" \\
+  [--media /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}}`;
+var PROGRESS_PHRASE = "progress update or ";
+var EMPTY_PROGRESS_PHRASE = "";
+var PROGRESS_FLAG_SUFFIX = "|progress";
+var EMPTY_PROGRESS_FLAG_SUFFIX = "";
+var PROGRESS_RULES_BLOCK = `- use that command to send progress updates and the final reply back to the conversation
+- send at most {{max_progress_messages}} progress updates
+- keep progress updates short and meaningful
+- do not send progress updates for trivial internal steps
+`;
+var FINAL_ONLY_RULES_BLOCK = `- use that command only for the final user-facing reply
+- do not send user-facing progress updates for this conversation
+`;
+var FINAL_RULE_REQUIRED = "send exactly 1 final user-facing response";
+var FINAL_RULE_OPTIONAL = "final response is optional";
+var EMPTY_REPLY_COMMAND = "";
+var EMPTY_REPLY_RULES = "";
+var SLACK_REPLY_COMMAND_BASE = `{{command}} message send \\
+  --channel slack \\
+{{account_clause}}  --target channel:{{channel_id}} \\
+{{thread_clause}}`;
+var TELEGRAM_REPLY_COMMAND_BASE = `{{command}} message send \\
+  --channel telegram \\
+{{account_clause}}  --target {{chat_id}} \\
+{{thread_clause}}`;
+var ACCOUNT_CLAUSE = "  --account {{account_id}} \\\n";
+var EMPTY_ACCOUNT_CLAUSE = "";
+var SLACK_THREAD_CLAUSE = "  --thread-id {{thread_ts}} \\\n";
+var TELEGRAM_THREAD_CLAUSE = "  --thread-id {{topic_id}} \\\n";
+var EMPTY_THREAD_CLAUSE = "";
+function buildAgentPromptText(params) {
+  return buildChannelPromptText({
+    ...params,
+    mode: "message"
+  });
 }
-function renderAgentPromptInstruction(params) {
-  const messageToolMode = (params.responseMode ?? "message-tool") === "message-tool";
-  const progressAllowed = messageToolMode && (params.streaming ?? "off") === "off";
-  const lines = [
-    `[${renderPromptTimestamp()}] ${renderIdentitySummary(params.identity)}`,
-    "",
-    "You are operating inside clisbot.",
-    messageToolMode ? progressAllowed ? "To send a user-visible progress update or final reply, use the following CLI command:" : "To send the final user-visible reply, use the following CLI command:" : "channel auto-delivery remains enabled for this conversation; do not send user-facing progress updates or the final response with clisbot message send"
-  ];
-  if (messageToolMode) {
-    const replyCommand = buildReplyCommand({
-      command: getClisbotPromptCommand(),
-      identity: params.identity
+function buildSteeringPromptText(params) {
+  return buildChannelPromptText({
+    text: params.text,
+    mode: "steer",
+    protectedControlMutationRule: params.protectedControlMutationRule
+  });
+}
+function buildChannelPromptText(params) {
+  if (params.mode === "message" && !params.config?.enabled) {
+    return params.text;
+  }
+  if (params.mode === "steer") {
+    return renderTemplate(STEERING_TEMPLATE, {
+      message_body: params.text,
+      protected_control_suffix: renderProtectedControlSuffix(params.protectedControlMutationRule)
     });
-    lines.push(replyCommand, "When replying to the user:", "- put the user-facing message inside the --message body of that command", progressAllowed ? "- use that command to send progress updates and the final reply back to the conversation" : "- use that command only for the final user-facing reply", ...progressAllowed ? [`- send at most ${params.config.maxProgressMessages} progress updates`] : ["- do not send user-facing progress updates for this conversation"], params.config.requireFinalResponse ? "- send exactly 1 final user-facing response" : "- final response is optional", ...progressAllowed ? [
-      "- keep progress updates short and meaningful",
-      "- do not send progress updates for trivial internal steps"
-    ] : []);
   }
-  if (params.protectedControlMutationRule) {
-    lines.push("", params.protectedControlMutationRule);
+  const promptParts = renderMessagePromptParts({
+    identity: params.identity,
+    config: params.config,
+    responseMode: params.responseMode,
+    streaming: params.streaming
+  });
+  return renderTemplate(BASE_TEMPLATE, {
+    timestamp: renderPromptTimestamp(),
+    identity_summary: renderIdentitySummary(params.identity),
+    delivery_intro: promptParts.deliveryIntro,
+    reply_command: promptParts.replyCommand,
+    reply_rules: promptParts.replyRules,
+    protected_control_suffix: renderProtectedControlSuffix(params.protectedControlMutationRule),
+    message_body: params.text
+  });
+}
+function renderMessagePromptParts(params) {
+  const messageToolMode = (params.responseMode ?? "message-tool") === "message-tool";
+  if (!messageToolMode) {
+    return {
+      deliveryIntro: DELIVERY_INTRO_CAPTURE_PANE,
+      replyCommand: EMPTY_REPLY_COMMAND,
+      replyRules: EMPTY_REPLY_RULES
+    };
   }
-  return lines.join(`
-`);
+  const allowProgress = (params.streaming ?? "off") === "off";
+  const progressPhrase = allowProgress ? PROGRESS_PHRASE : EMPTY_PROGRESS_PHRASE;
+  const progressFlagSuffix = allowProgress ? PROGRESS_FLAG_SUFFIX : EMPTY_PROGRESS_FLAG_SUFFIX;
+  const progressRulesBlock = allowProgress ? PROGRESS_RULES_BLOCK : FINAL_ONLY_RULES_BLOCK;
+  const finalRuleLine = params.config.requireFinalResponse ? FINAL_RULE_REQUIRED : FINAL_RULE_OPTIONAL;
+  return {
+    deliveryIntro: renderTemplate(DELIVERY_INTRO, {
+      progress_phrase: progressPhrase
+    }),
+    replyCommand: renderTemplate(REPLY_COMMAND, {
+      reply_command_base: buildReplyCommandBase({
+        command: getClisbotPromptCommand(),
+        identity: params.identity
+      }).trimEnd(),
+      progress_flag_suffix: progressFlagSuffix
+    }),
+    replyRules: renderTemplate(REPLY_RULES, {
+      progress_rules_block: renderTemplate(progressRulesBlock, {
+        max_progress_messages: String(params.config.maxProgressMessages)
+      }),
+      final_rule_line: finalRuleLine
+    })
+  };
+}
+function renderProtectedControlSuffix(rule) {
+  if (!rule) {
+    return "";
+  }
+  return `
+
+${rule}`;
+}
+function renderTemplate(template, values) {
+  return template.replaceAll(/\{\{([a-zA-Z0-9_]+)\}\}/g, (_, key) => values[key] ?? "");
 }
 function renderPromptTimestamp() {
   const date = new Date;
@@ -62821,42 +63121,29 @@ function renderNamedValue(label, name, id) {
   const value = renderLabeledTarget(name, id);
   return value ? `${label} ${value}` : "";
 }
-function buildReplyCommand(params) {
-  const lines = [`${params.command} message send \\`];
+function buildReplyCommandBase(params) {
   if (params.identity.platform === "slack") {
-    lines.push("  --channel slack \\");
-    if (params.identity.accountId) {
-      lines.push(`  --account ${params.identity.accountId} \\`);
-    }
-    lines.push(`  --target channel:${params.identity.channelId ?? ""} \\`);
-    if (params.identity.threadTs) {
-      lines.push(`  --thread-id ${params.identity.threadTs} \\`);
-    }
-    lines.push("  --final \\");
-    lines.push('  --message "$(cat <<\\__CLISBOT_MESSAGE__');
-    lines.push("<user-facing reply>");
-    lines.push("__CLISBOT_MESSAGE__");
-    lines.push(')" \\');
-    lines.push("  [--media /absolute/path/to/file]");
-    return lines.join(`
-`);
-  }
-  lines.push("  --channel telegram \\");
-  if (params.identity.accountId) {
-    lines.push(`  --account ${params.identity.accountId} \\`);
+    return renderTemplate(SLACK_REPLY_COMMAND_BASE, {
+      command: params.command,
+      account_clause: params.identity.accountId ? renderTemplate(ACCOUNT_CLAUSE, {
+        account_id: params.identity.accountId
+      }) : EMPTY_ACCOUNT_CLAUSE,
+      channel_id: params.identity.channelId ?? "",
+      thread_clause: params.identity.threadTs ? renderTemplate(SLACK_THREAD_CLAUSE, {
+        thread_ts: params.identity.threadTs
+      }) : EMPTY_THREAD_CLAUSE
+    });
   }
-  lines.push(`  --target ${params.identity.chatId ?? ""} \\`);
-  if (params.identity.topicId) {
-    lines.push(`  --thread-id ${params.identity.topicId} \\`);
-  }
-  lines.push("  --final \\");
-  lines.push('  --message "$(cat <<\\__CLISBOT_MESSAGE__');
-  lines.push("<user-facing reply>");
-  lines.push("__CLISBOT_MESSAGE__");
-  lines.push(')" \\');
-  lines.push("  [--media /absolute/path/to/file]");
-  return lines.join(`
-`);
+  return renderTemplate(TELEGRAM_REPLY_COMMAND_BASE, {
+    command: params.command,
+    account_clause: params.identity.accountId ? renderTemplate(ACCOUNT_CLAUSE, {
+      account_id: params.identity.accountId
+    }) : EMPTY_ACCOUNT_CLAUSE,
+    chat_id: params.identity.chatId ?? "",
+    thread_clause: params.identity.topicId ? renderTemplate(TELEGRAM_THREAD_CLAUSE, {
+      topic_id: params.identity.topicId
+    }) : EMPTY_THREAD_CLAUSE
+  });
 }
 
 // src/channels/surface-notifications.ts
@@ -63390,6 +63677,12 @@ function collapseBlankLines(lines) {
   }
   return collapsed;
 }
+var DURATION_STATUS_PATTERN = String.raw`(?:\d+(?:h|m|s))(?:\s+\d+(?:h|m|s)){0,2}`;
+var CODEX_WORKING_STATUS_PATTERN = new RegExp(String.raw`^(?:[•◦·]\s*)?Working(?:\s*\()?${DURATION_STATUS_PATTERN}\b.*(?:esc to interrupt|interrupt)\)?$`, "i");
+var CODEX_INTERRUPT_FOOTER_PATTERN = new RegExp(String.raw`^(?:[•◦·]\s*)?${DURATION_STATUS_PATTERN}\s*[•◦·]?\s*esc to interrupt\)?$`, "i");
+var GEMINI_THINKING_STATUS_PATTERN = new RegExp(String.raw`^Thinking\.\.\. \(esc to cancel,\s*${DURATION_STATUS_PATTERN}\)$`, "i");
+var CLAUDE_WORKED_STATUS_PATTERN = new RegExp(String.raw`^(?:[✻✽*]\s*)?(?:Worked|Cooked) for ${DURATION_STATUS_PATTERN}$`, "i");
+var CLAUDE_TIMER_FOOTER_PATTERN = new RegExp(String.raw`\|\s*claude\s*\|.*\|\s*${DURATION_STATUS_PATTERN}\s*$`, "i");
 function looksLikeUrlContinuation(line) {
   const trimmed = line.trim();
   return trimmed.startsWith("(") || trimmed.startsWith("http://") || trimmed.startsWith("https://");
@@ -63587,7 +63880,14 @@ function isInterruptStatusLine(line) {
   if (!trimmed) {
     return false;
   }
-  return /^(?:[•◦·]\s*)?Working(?:\s*\()?\d+s\b.*(?:esc to interrupt|interrupt)\)?$/i.test(trimmed) || /^(?:[•◦·]\s*)?\d+s\s*[•◦·]?\s*esc to interrupt\)?$/i.test(trimmed);
+  return CODEX_WORKING_STATUS_PATTERN.test(trimmed) || CODEX_INTERRUPT_FOOTER_PATTERN.test(trimmed);
+}
+function isTimerDrivenStatusLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return isInterruptStatusLine(trimmed) || GEMINI_THINKING_STATUS_PATTERN.test(trimmed) || CLAUDE_WORKED_STATUS_PATTERN.test(trimmed) || CLAUDE_TIMER_FOOTER_PATTERN.test(trimmed);
 }
 function shouldDropCodexChromeLine(line) {
   const trimmed = line.trim();
@@ -63601,14 +63901,14 @@ function shouldDropClaudeChromeLine(line) {
   if (!trimmed) {
     return false;
   }
-  return trimmed.includes("Claude Code v") || trimmed.includes("Welcome back!") || trimmed.includes("Tips for getting started") || trimmed.includes("Ask Claude to create a new app or clone a repository") || trimmed.includes("Recent activity") || trimmed.includes("No recent activity") || trimmed.includes("API Usage Billing") || trimmed.includes("shift+tab to cycle") || trimmed.includes("ctrl+o to expand") || trimmed.includes("ctrl+b ctrl+b") || trimmed.includes("run in background") || /^~\/\.clisbot\/(?:workspace\/)?[a-z0-9._/-]+$/i.test(trimmed) || trimmed.includes("| claude |") || /^(?:[✻*]\s*)?(?:Worked|Cooked) for \d+s$/i.test(trimmed) || trimmed.startsWith("⏵⏵") || trimmed.startsWith("❯") || isProgressLine(trimmed) || /^[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+$/.test(trimmed) || /^[╭╰│]/.test(trimmed) || /^─+$/.test(trimmed) || /^[▐▛▜▌▝▘ ]+$/.test(trimmed) || /^[▐▛▜▌▝▘ ]+.+$/.test(trimmed);
+  return trimmed.includes("Claude Code v") || trimmed.includes("Welcome back!") || trimmed.includes("Tips for getting started") || trimmed.includes("Ask Claude to create a new app or clone a repository") || trimmed.includes("Recent activity") || trimmed.includes("No recent activity") || trimmed.includes("API Usage Billing") || trimmed.includes("shift+tab to cycle") || trimmed.includes("ctrl+o to expand") || trimmed.includes("ctrl+b ctrl+b") || trimmed.includes("run in background") || /^~\/\.clisbot\/(?:workspace\/)?[a-z0-9._/-]+$/i.test(trimmed) || trimmed.includes("| claude |") || isTimerDrivenStatusLine(trimmed) || trimmed.startsWith("⏵⏵") || trimmed.startsWith("❯") || isProgressLine(trimmed) || /^[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+$/.test(trimmed) || /^[╭╰│]/.test(trimmed) || /^─+$/.test(trimmed) || /^[▐▛▜▌▝▘ ]+$/.test(trimmed) || /^[▐▛▜▌▝▘ ]+.+$/.test(trimmed);
 }
 function shouldDropGeminiChromeLine(line) {
   const trimmed = line.trim();
   if (!trimmed) {
     return false;
   }
-  return trimmed.includes("Gemini CLI v") || trimmed.includes("Signed in with Google") || trimmed.includes("Plan:") || /^[▝▜▄▗▟▀ ]+$/.test(trimmed) || trimmed.includes("We're making changes to Gemini CLI") || trimmed.includes("What's Changing:") || trimmed.includes("How it affects you:") || trimmed.includes("Read more: https://goo.gle/geminicli-updates") || trimmed.includes("Skipping project agents due to untrusted folder.") || trimmed.includes("Do you trust the files in this folder?") || trimmed.includes("Trusting a folder allows Gemini CLI to load its local configurations") || trimmed === "1. Trust folder (default)" || trimmed === "2. Trust parent folder (workspaces)" || trimmed === "3. Don't trust" || trimmed.includes("Tips for getting started") || /^Create GEMINI\.md files to customize your interactions$/i.test(trimmed) || /^\/help for more information$/i.test(trimmed) || /^Ask coding questions, edit code or run commands$/i.test(trimmed) || /^Be specific for the best results$/i.test(trimmed) || trimmed.includes("? for shortcuts") || trimmed.includes("YOLO Ctrl+Y") || trimmed.includes("Type your message or @path/to/file") || trimmed.includes("workspace (/directory)") || /^~\/.+\s+\S+\s+no sandbox\s+\S+/i.test(trimmed) || /^Thinking\.\.\. \(esc to cancel,\s*\d+s\)$/i.test(trimmed) || /^[╭╰│]/.test(trimmed) || /^[-▀▄]{10,}$/.test(trimmed) || /^─+$/.test(trimmed);
+  return trimmed.includes("Gemini CLI v") || trimmed.includes("Signed in with Google") || trimmed.includes("Plan:") || /^[▝▜▄▗▟▀ ]+$/.test(trimmed) || trimmed.includes("We're making changes to Gemini CLI") || trimmed.includes("What's Changing:") || trimmed.includes("How it affects you:") || trimmed.includes("Read more: https://goo.gle/geminicli-updates") || trimmed.includes("Skipping project agents due to untrusted folder.") || trimmed.includes("Do you trust the files in this folder?") || trimmed.includes("Trusting a folder allows Gemini CLI to load its local configurations") || trimmed === "1. Trust folder (default)" || trimmed === "2. Trust parent folder (workspaces)" || trimmed === "3. Don't trust" || trimmed.includes("Tips for getting started") || /^Create GEMINI\.md files to customize your interactions$/i.test(trimmed) || /^\/help for more information$/i.test(trimmed) || /^Ask coding questions, edit code or run commands$/i.test(trimmed) || /^Be specific for the best results$/i.test(trimmed) || trimmed.includes("? for shortcuts") || trimmed.includes("YOLO Ctrl+Y") || trimmed.includes("Type your message or @path/to/file") || trimmed.includes("workspace (/directory)") || /^~\/.+\s+\S+\s+no sandbox\s+\S+/i.test(trimmed) || isTimerDrivenStatusLine(trimmed) || /^[╭╰│]/.test(trimmed) || /^[-▀▄]{10,}$/.test(trimmed) || /^─+$/.test(trimmed);
 }
 function normalizeBoundaryLine(line) {
   return line.trim().replace(/^(?::eight_spoked_asterisk:|[-*•◦·✽✶])\s+/, "");
@@ -63642,16 +63942,21 @@ function collapseAdjacentDuplicateLines(raw) {
   return collapseBlankLines(collapsed).join(`
 `).trim();
 }
-function cleanInteractionSnapshot(raw) {
+function cleanInteractionSnapshotInternal(raw, options) {
   const lines = splitNormalizedLines(raw);
   const isCodex = looksLikeCodexSnapshot(lines);
   const isClaude = looksLikeClaudeSnapshot(lines);
   const isGemini = looksLikeGeminiSnapshot(lines);
   const promptStripped = isCodex ? dropCodexPromptBlocks(lines) : isClaude ? dropClaudePromptBlocks(lines) : isGemini ? dropGeminiPromptBlocks(lines) : lines;
+  const timerStatusLines = [];
   const filtered = promptStripped.filter((line) => {
     if (shouldDropDeliveryReportLine(line)) {
       return false;
     }
+    if (options?.preserveTimerStatusLines && isTimerDrivenStatusLine(line)) {
+      timerStatusLines.push(line.trim());
+      return false;
+    }
     if (isCodex && shouldDropCodexChromeLine(line)) {
       return false;
     }
@@ -63665,8 +63970,21 @@ function cleanInteractionSnapshot(raw) {
   });
   const normalized = isCodex ? unwrapCodexMessageBlocks(filtered) : isClaude ? unwrapClaudeMessageBlocks(filtered) : isGemini ? filtered.map((line) => line.replace(/^\s*>\s*/, "")) : filtered;
   const unwrapped = unwrapSoftWrappedLines(normalized);
-  return collapseAdjacentDuplicateLines(collapseBlankLines(trimBlankLines(unwrapped)).join(`
+  const cleanedBody = collapseAdjacentDuplicateLines(collapseBlankLines(trimBlankLines(unwrapped)).join(`
 `));
+  const cleanedTimerStatus = options?.preserveTimerStatusLines ? collapseAdjacentDuplicateLines(collapseBlankLines(trimBlankLines(timerStatusLines)).join(`
+`)) : "";
+  return [cleanedBody, cleanedTimerStatus].filter(Boolean).join(`
+
+`).trim();
+}
+function cleanInteractionSnapshot(raw) {
+  return cleanInteractionSnapshotInternal(raw);
+}
+function cleanRunningInteractionSnapshot(raw) {
+  return cleanInteractionSnapshotInternal(raw, {
+    preserveTimerStatusLines: true
+  });
 }
 // src/shared/transcript-delta.ts
 function diffText(previous, current) {
@@ -63727,16 +64045,8 @@ function extractScrolledAppend(previous, current) {
   }
   return "";
 }
-function deriveRunningInteractionText(previousSnapshot, currentSnapshot) {
-  const previous = cleanInteractionSnapshot(previousSnapshot);
-  const current = cleanInteractionSnapshot(currentSnapshot);
-  if (!current || current === previous) {
-    return "";
-  }
-  if (!previous) {
-    return current;
-  }
-  return extractScrolledAppend(previous, current);
+function deriveRunningInteractionSnapshot(currentSnapshot) {
+  return cleanRunningInteractionSnapshot(currentSnapshot);
 }
 function deriveInteractionText(initialSnapshot, currentSnapshot) {
   const previous = cleanInteractionSnapshot(initialSnapshot);
@@ -63940,6 +64250,36 @@ function renderInteractionBody(params) {
   }
   return truncateTail(completedBody, params.maxChars);
 }
+function normalizeLeadingStatusLine(line) {
+  return line.trim().replace(/^[_*`\s]+|[_*`\s]+$/g, "");
+}
+function startsWithExplicitErrorLabel(body) {
+  const firstLine = body.split(`
+`).map((line) => normalizeLeadingStatusLine(line)).find((line) => line.length > 0);
+  if (!firstLine) {
+    return false;
+  }
+  return /^(error|failed|failure|denied|forbidden)(?::|\.)/i.test(firstLine);
+}
+function shouldInlineErrorPrefix(body) {
+  return !body.includes(`
+`) && !body.includes("```");
+}
+function renderErrorInteractionBody(body, footer) {
+  const trimmedBody = body.trim();
+  if (!trimmedBody) {
+    return footer;
+  }
+  if (startsWithExplicitErrorLabel(trimmedBody)) {
+    return trimmedBody;
+  }
+  if (shouldInlineErrorPrefix(trimmedBody)) {
+    return `Error: ${trimmedBody}`;
+  }
+  return `${trimmedBody}
+
+${footer}`;
+}
 function renderSlackInteraction(params) {
   const body = renderInteractionBody(params);
   if (params.status === "queued") {
@@ -63967,9 +64307,7 @@ _Timed out waiting for more output._` : "_Timed out waiting for visible output._
 _${note}_` : `_${note}_`;
   }
   if (params.status === "error") {
-    return body ? `${body}
-
-_Error._` : "_Error._";
+    return renderErrorInteractionBody(body, "_Error._");
   }
   return body || "_Completed with no new visible output._";
 }
@@ -64000,9 +64338,7 @@ Timed out waiting for more output.` : "Timed out waiting for visible output.";
 ${note}` : note;
   }
   if (params.status === "error") {
-    return body ? `${body}
-
-Error.` : "Error.";
+    return renderErrorInteractionBody(body, "Error.");
   }
   return body || "Completed with no new visible output.";
 }
@@ -64452,6 +64788,7 @@ var TMUX_DUPLICATE_SESSION_PATTERN = /duplicate session:/i;
 var TMUX_TRANSIENT_TARGET_PATTERN = /(?:no current target|can't find pane|can't find window)/i;
 var SESSION_READY_CAPTURE_RETRY_COUNT = 5;
 var SESSION_READY_CAPTURE_RETRY_DELAY_MS = 100;
+var SESSION_ID_CAPTURE_FAILURE_COOLDOWN_MS = 15000;
 function summarizeSnapshot(snapshot) {
   const compact = snapshot.split(`
 `).map((line) => line.trim()).filter(Boolean).join(" ").slice(0, 220);
@@ -64483,6 +64820,7 @@ class RunnerService {
   sessionState;
   resolveTarget;
   cleanupInFlight = false;
+  sessionIdentityCaptureRetryAt = new Map;
   constructor(loadedConfig, tmux, sessionState, resolveTarget) {
     this.loadedConfig = loadedConfig;
     this.tmux = tmux;
@@ -64534,12 +64872,24 @@ class RunnerService {
   async syncSessionIdentity(resolved) {
     const existing = await this.sessionState.getEntry(resolved.sessionKey);
     if (existing?.sessionId) {
+      this.sessionIdentityCaptureRetryAt.delete(resolved.sessionKey);
       return this.sessionState.touchSessionEntry(resolved, {
         sessionId: existing.sessionId,
         runnerCommand: resolved.runner.command
       });
     }
+    const retryAt = this.sessionIdentityCaptureRetryAt.get(resolved.sessionKey) ?? 0;
+    if (retryAt > Date.now()) {
+      return this.sessionState.touchSessionEntry(resolved, {
+        runnerCommand: resolved.runner.command
+      });
+    }
     const sessionId = await this.captureSessionIdentity(resolved);
+    if (sessionId) {
+      this.sessionIdentityCaptureRetryAt.delete(resolved.sessionKey);
+    } else {
+      this.sessionIdentityCaptureRetryAt.set(resolved.sessionKey, Date.now() + SESSION_ID_CAPTURE_FAILURE_COOLDOWN_MS);
+    }
     return this.sessionState.touchSessionEntry(resolved, {
       sessionId,
       runnerCommand: resolved.runner.command
@@ -64694,6 +65044,7 @@ class RunnerService {
       sessionName: resolved.sessionName,
       stateDir: this.loadedConfig.stateDir
     });
+    this.sessionIdentityCaptureRetryAt.delete(resolved.sessionKey);
     try {
       await this.tmux.newSession({
         sessionName: resolved.sessionName,
@@ -64936,15 +65287,19 @@ class RunnerService {
 }
 
 // src/agents/run-recovery.ts
+var MID_RUN_RECOVERY_MAX_ATTEMPTS = 2;
+var MID_RUN_RECOVERY_CONTINUE_PROMPT = "continue exactly where you left off";
 function mergeRunSnapshot(snapshotPrefix, snapshot) {
   return appendInteractionText(snapshotPrefix, snapshot);
 }
-function buildRunRecoveryNote(kind) {
+function buildRunRecoveryNote(kind, params) {
   if (kind === "resume-attempt") {
-    return "Runner session was lost. Attempting recovery 1/2 by reopening the same conversation context.";
+    const attempt = params?.attempt ?? 1;
+    const maxAttempts = params?.maxAttempts ?? MID_RUN_RECOVERY_MAX_ATTEMPTS;
+    return `Runner session was lost. Attempting recovery ${attempt}/${maxAttempts} by reopening the same conversation context.`;
   }
   if (kind === "resume-success") {
-    return "Recovery succeeded. Continuing the current run.";
+    return "Recovery succeeded. Asking the runner to continue exactly where it left off.";
   }
   if (kind === "fresh-attempt") {
     return "The previous runner session could not be resumed. Opening a fresh runner session 2/2 without replaying your prompt.";
@@ -64956,11 +65311,12 @@ function buildRunRecoveryNote(kind) {
 var FIRST_OUTPUT_POLL_INTERVAL_MS = 250;
 async function monitorTmuxRun(params) {
   let previousSnapshot = params.initialSnapshot;
-  let lastChangeAt = Date.now();
-  let sawChange = false;
-  let cumulativeInteractionSnapshot = "";
+  let previousRunningSnapshot = "";
+  let lastActivityAt = params.startedAt;
+  let sawActivity = false;
   let detachedNotified = params.detachedAlready;
   let firstMeaningfulDeltaLogged = false;
+  let noOutputThresholdLogged = false;
   if (params.prompt) {
     logLatencyDebug("tmux-submit-start", params.timingContext, {
       sessionName: params.sessionName,
@@ -64981,61 +65337,57 @@ async function monitorTmuxRun(params) {
     });
   }
   while (true) {
-    await sleep(sawChange ? params.updateIntervalMs : Math.min(params.updateIntervalMs, FIRST_OUTPUT_POLL_INTERVAL_MS));
+    await sleep(sawActivity ? params.updateIntervalMs : Math.min(params.updateIntervalMs, FIRST_OUTPUT_POLL_INTERVAL_MS));
     const snapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines));
     const now = Date.now();
-    if (snapshot !== previousSnapshot) {
-      const priorSnapshot = previousSnapshot;
-      lastChangeAt = now;
-      previousSnapshot = snapshot;
-      const interactionDelta = deriveRunningInteractionText(priorSnapshot, snapshot);
-      const nextInteractionSnapshot = appendInteractionText(cumulativeInteractionSnapshot, interactionDelta);
-      if (nextInteractionSnapshot && nextInteractionSnapshot !== cumulativeInteractionSnapshot) {
-        sawChange = true;
-        cumulativeInteractionSnapshot = nextInteractionSnapshot;
-        if (!firstMeaningfulDeltaLogged) {
-          firstMeaningfulDeltaLogged = true;
-          logLatencyDebug("tmux-first-meaningful-delta", params.timingContext, {
-            sessionName: params.sessionName,
-            elapsedMs: now - params.startedAt
-          });
-        }
-        await params.onRunning({
-          snapshot: cumulativeInteractionSnapshot,
-          fullSnapshot: snapshot,
-          initialSnapshot: params.initialSnapshot
+    const runningSnapshot = deriveRunningInteractionSnapshot(snapshot);
+    previousSnapshot = snapshot;
+    if (runningSnapshot && runningSnapshot !== previousRunningSnapshot) {
+      previousRunningSnapshot = runningSnapshot;
+      lastActivityAt = now;
+      sawActivity = true;
+      if (!firstMeaningfulDeltaLogged) {
+        firstMeaningfulDeltaLogged = true;
+        logLatencyDebug("tmux-first-meaningful-delta", params.timingContext, {
+          sessionName: params.sessionName,
+          elapsedMs: now - params.startedAt
         });
       }
+      await params.onRunning({
+        snapshot: runningSnapshot,
+        fullSnapshot: snapshot,
+        initialSnapshot: params.initialSnapshot
+      });
     }
     if (!detachedNotified && now - params.startedAt >= params.maxRuntimeMs) {
       detachedNotified = true;
       await params.onDetached({
-        snapshot: cumulativeInteractionSnapshot || deriveInteractionText(params.initialSnapshot, previousSnapshot),
+        snapshot: previousRunningSnapshot || deriveInteractionText(params.initialSnapshot, snapshot),
         fullSnapshot: previousSnapshot,
         initialSnapshot: params.initialSnapshot
       });
     }
-    if (sawChange && now - lastChangeAt >= params.idleTimeoutMs) {
+    if (sawActivity && now - lastActivityAt >= params.idleTimeoutMs) {
       await params.onCompleted({
-        snapshot: cumulativeInteractionSnapshot || deriveInteractionText(params.initialSnapshot, previousSnapshot),
+        snapshot: deriveInteractionText(params.initialSnapshot, previousSnapshot),
         fullSnapshot: previousSnapshot,
         initialSnapshot: params.initialSnapshot
       });
       return;
     }
-    if (!sawChange && now - params.startedAt >= params.noOutputTimeoutMs) {
-      await params.onTimeout({
-        snapshot: cumulativeInteractionSnapshot || deriveInteractionText(params.initialSnapshot, previousSnapshot),
-        fullSnapshot: previousSnapshot,
-        initialSnapshot: params.initialSnapshot
+    if (!noOutputThresholdLogged && !sawActivity && now - params.startedAt >= params.noOutputTimeoutMs) {
+      noOutputThresholdLogged = true;
+      logLatencyDebug("tmux-no-output-threshold-crossed", params.timingContext, {
+        sessionName: params.sessionName,
+        elapsedMs: now - params.startedAt
       });
-      return;
     }
   }
 }
 
 // src/agents/session-service.ts
 var OBSERVER_RETRYABLE_FAILURE_LIMIT = 3;
+var DETACHED_OBSERVER_INTERVAL_MS = 5 * 60000;
 function formatObserverError(error) {
   return error instanceof Error ? error.stack ?? error.message : String(error);
 }
@@ -65283,7 +65635,10 @@ class SessionService {
         detached: false
       };
     }
-    observer.mode = "passive-final";
+    observer.mode = "poll";
+    observer.intervalMs = DETACHED_OBSERVER_INTERVAL_MS;
+    observer.expiresAt = undefined;
+    observer.lastSentAt = Date.now();
     run.observerFailures.delete(observerId);
     return {
       detached: true
@@ -65306,7 +65661,19 @@ class SessionService {
     this.activeRuns.clear();
   }
   buildDetachedNote(resolved) {
-    return `This session has been running for over ${resolved.stream.maxRuntimeLabel}. clisbot will keep monitoring it and will post the final result here when it completes. Use \`/attach\` to resume live updates, \`/watch every 30s\` for interval updates, or \`/stop\` to interrupt it.`;
+    return `This session has been running for over ${resolved.stream.maxRuntimeLabel}. clisbot will keep monitoring it, switch this thread to sparse progress updates, and post the final result here when it completes. Use \`/attach\` to resume live updates, \`/watch every 30s\` for interval updates, or \`/stop\` to interrupt it.`;
+  }
+  applyDetachedObserverPolicy(run) {
+    const now = Date.now();
+    for (const observer of run.observers.values()) {
+      if (observer.mode !== "live") {
+        continue;
+      }
+      observer.mode = "poll";
+      observer.intervalMs = DETACHED_OBSERVER_INTERVAL_MS;
+      observer.expiresAt = undefined;
+      observer.lastSentAt = now;
+    }
   }
   createRunUpdate(params) {
     return {
@@ -65416,10 +65783,13 @@ class SessionService {
       agentId: run.resolved.agentId,
       sessionKey: run.resolved.sessionKey
     };
+    const recoveryAttempt = params.recoveryAttempt ?? 1;
     const snapshotPrefix = run.latestUpdate.snapshot;
-    const previousFullSnapshot = run.latestUpdate.fullSnapshot;
     const detachedAlready = run.latestUpdate.status === "detached";
-    await this.notifyRecoveryStep(run, buildRunRecoveryNote("resume-attempt"));
+    await this.notifyRecoveryStep(run, buildRunRecoveryNote("resume-attempt", {
+      attempt: recoveryAttempt,
+      maxAttempts: MID_RUN_RECOVERY_MAX_ATTEMPTS
+    }));
     try {
       const recovered = await this.runnerSessions.reopenRunContext(target, params.timingContext);
       const currentRun = this.activeRuns.get(sessionKey);
@@ -65438,15 +65808,22 @@ class SessionService {
       });
       await this.notifyRunObservers(currentRun, currentRun.latestUpdate);
       this.startRunMonitor(sessionKey, {
-        prompt: undefined,
-        initialSnapshot: previousFullSnapshot,
+        prompt: MID_RUN_RECOVERY_CONTINUE_PROMPT,
+        initialSnapshot: recovered.initialSnapshot,
         startedAt: currentRun.startedAt,
         detachedAlready,
         timingContext: params.timingContext,
-        snapshotPrefix
+        snapshotPrefix,
+        recoveryAttempt
       });
       return true;
-    } catch {
+    } catch (reopenError) {
+      if (recoveryAttempt < MID_RUN_RECOVERY_MAX_ATTEMPTS && this.runnerSessions.canRecoverMidRun(reopenError)) {
+        return await this.recoverLostMidRun(sessionKey, {
+          timingContext: params.timingContext,
+          recoveryAttempt: recoveryAttempt + 1
+        }, reopenError);
+      }
       const currentRun = this.activeRuns.get(sessionKey);
       if (!currentRun) {
         return true;
@@ -65527,7 +65904,8 @@ class SessionService {
               startedAt: params.startedAt,
               detachedAt: Date.now()
             });
-            currentRun.latestUpdate = detachedUpdate;
+            await this.notifyRunObservers(currentRun, detachedUpdate);
+            this.applyDetachedObserverPolicy(currentRun);
             currentRun.initialResult.resolve(detachedUpdate);
           },
           onCompleted: async (update) => {
@@ -65539,20 +65917,13 @@ class SessionService {
               initialSnapshot: update.initialSnapshot
             });
             await this.finishActiveRun(sessionKey, runUpdate);
-          },
-          onTimeout: async (update) => {
-            const runUpdate = this.createRunUpdate({
-              resolved: run.resolved,
-              status: "timeout",
-              snapshot: mergeRunSnapshot(params.snapshotPrefix ?? "", update.snapshot),
-              fullSnapshot: update.fullSnapshot,
-              initialSnapshot: update.initialSnapshot
-            });
-            await this.finishActiveRun(sessionKey, runUpdate);
           }
         });
       } catch (error) {
-        if (await this.recoverLostMidRun(sessionKey, { timingContext: params.timingContext }, error)) {
+        if (await this.recoverLostMidRun(sessionKey, {
+          timingContext: params.timingContext,
+          recoveryAttempt: (params.recoveryAttempt ?? 0) + 1
+        }, error)) {
           return;
         }
         await this.failActiveRun(sessionKey, await this.runnerSessions.mapRunError(error, run.resolved.sessionName, run.latestUpdate.fullSnapshot));
@@ -65562,6 +65933,28 @@ class SessionService {
 }
 
 // src/agents/agent-service.ts
+function shellQuote3(value) {
+  if (/^[a-zA-Z0-9_./:@=-]+$/.test(value)) {
+    return value;
+  }
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function buildCommandString2(command, args) {
+  return [command, ...args].map(shellQuote3).join(" ");
+}
+function stripWorkspaceArgs(args) {
+  const filtered = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === "-C") {
+      index += 1;
+      continue;
+    }
+    filtered.push(current);
+  }
+  return filtered;
+}
+
 class AgentService {
   loadedConfig;
   tmuxClient;
@@ -65652,6 +66045,15 @@ class AgentService {
   async getSessionRuntime(target) {
     return this.sessionState.getSessionRuntime(target);
   }
+  async getSessionDiagnostics(target) {
+    const resolved = this.resolveTarget(target);
+    const entry = await this.sessionState.getEntry(target.sessionKey);
+    const sessionId = entry?.sessionId?.trim() || undefined;
+    return {
+      sessionId,
+      resumeCommand: this.buildResumeCommandPreview(resolved, sessionId)
+    };
+  }
   async listActiveSessionRuntimes() {
     return this.sessionState.listActiveSessionRuntimes();
   }
@@ -65894,6 +66296,21 @@ class AgentService {
       this.scheduleIntervalLoopTimer(persisted.id, Math.max(0, persisted.nextRunAt - Date.now()));
     }
   }
+  buildResumeCommandPreview(resolved, sessionId) {
+    if (!sessionId || resolved.runner.sessionId.resume.mode !== "command") {
+      return;
+    }
+    const values = {
+      agentId: resolved.agentId,
+      workspace: resolved.workspacePath,
+      sessionName: resolved.sessionName,
+      sessionKey: resolved.sessionKey,
+      sessionId
+    };
+    const command = resolved.runner.sessionId.resume.command ?? resolved.runner.command;
+    const args = stripWorkspaceArgs(resolved.runner.sessionId.resume.args.map((value) => applyTemplate(value, values)));
+    return buildCommandString2(command, args);
+  }
   async isManagedLoopPersisted(managed) {
     const entry = await this.sessionState.getEntry(managed.target.sessionKey);
     return (entry?.intervalLoops ?? []).some((loop) => loop.id === managed.loop.id);
@@ -66398,6 +66815,12 @@ function parseAgentCommand(text, options = {}) {
   if (lowered === "loop") {
     const loopText = withoutSlash.slice(command.length).trim();
     const loweredLoopText = loopText.toLowerCase();
+    if (!loweredLoopText || loweredLoopText === "help") {
+      return {
+        type: "control",
+        name: "loop-help"
+      };
+    }
     if (loweredLoopText === "status") {
       return {
         type: "loop-control",
@@ -66445,6 +66868,12 @@ function parseAgentCommand(text, options = {}) {
     const queueText = withoutSlash.slice(command.length).trim();
     const normalizedQueueText = queueText.toLowerCase();
     if (lowered === "queue") {
+      if (normalizedQueueText === "help") {
+        return {
+          type: "control",
+          name: "queue-help"
+        };
+      }
       if (normalizedQueueText === "list") {
         return {
           type: "control",
@@ -66511,7 +66940,7 @@ function renderAgentControlSlashHelp() {
     "- `/whoami`: show the current platform, route, and sender identity details",
     "- `/transcript`: show the current conversation session transcript when the route verbose policy allows it",
     "- `/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 allowing final settlement here",
+    "- `/detach`: stop live updates for this thread, switch to sparse progress updates, and still allow final settlement here",
     "- `/watch every 30s [for 10m]`: post the latest state on an interval until the run settles or the watch window ends",
     "- `/stop`: send Escape to interrupt the current conversation session",
     "- `/nudge`: send one extra Enter to the current tmux session without resending the prompt text",
@@ -66528,9 +66957,11 @@ function renderAgentControlSlashHelp() {
     "- `/additionalmessagemode steer`: send later user messages straight into the active session",
     "- `/additionalmessagemode queue`: queue later user messages behind the active run for this surface",
     "- `/queue <message>` or `\\q <message>`: enqueue a later message behind the active run and let clisbot deliver it in order",
+    "- `/queue help`: show queue-specific help and examples",
     "- `/steer <message>` or `\\s <message>`: inject a steering message into the active run immediately",
     "- `/queue list`: show queued messages that have not started yet",
     "- `/queue clear`: clear queued messages that have not started yet",
+    "- `/loop help`: show loop-specific help and syntax examples",
     ...renderLoopHelpLines(),
     "- `/bash` followed by a shell command: requires `shellExecute` on the resolved agent role",
     "- shortcut prefixes such as `!` run bash only when the resolved agent role allows `shellExecute`",
@@ -66539,6 +66970,15 @@ function renderAgentControlSlashHelp() {
   ].join(`
 `);
 }
+function renderQueueHelpLines() {
+  return [
+    "- `/queue <message>` or `\\q <message>`: enqueue one later message behind the active run",
+    "- `/queue list`: show queued messages that have not started yet",
+    "- `/queue clear`: clear queued messages that have not started yet",
+    "- `/queue help`: show this queue help again",
+    "- `/steer <message>` or `\\s <message>`: inject an immediate steering message instead of queueing"
+  ];
+}
 function parseWatchCommand(raw) {
   const match = raw.match(/^every\s+(\S+)(?:\s+for\s+(\S+))?$/i);
   if (!match) {
@@ -66760,7 +67200,8 @@ function renderWhoAmIMessage(params) {
     `platform: \`${params.identity.platform}\``,
     `conversationKind: \`${params.identity.conversationKind}\``,
     `agentId: \`${params.route.agentId}\``,
-    `sessionKey: \`${params.sessionTarget.sessionKey}\``
+    `sessionKey: \`${params.sessionTarget.sessionKey}\``,
+    `storedSessionId: \`${params.sessionDiagnostics.sessionId ?? "(not captured yet)"}\``
   ];
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
@@ -66777,7 +67218,7 @@ function renderWhoAmIMessage(params) {
   if (params.identity.topicId) {
     lines.push(`topicId: \`${params.identity.topicId}\``);
   }
-  lines.push(`principal: \`${params.auth.principal ?? "(none)"}\``, `principalFormat: \`${renderPrincipalFormat(params.identity)}\``, `principalExample: \`${renderPrincipalExample(params.identity)}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayBypassPairing: \`${params.auth.mayBypassPairing}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `verbose: \`${params.route.verbose}\``);
+  lines.push(`resumeCommand: \`${params.sessionDiagnostics.resumeCommand ?? "(not available yet)"}\``, `principal: \`${params.auth.principal ?? "(none)"}\``, `principalFormat: \`${renderPrincipalFormat(params.identity)}\``, `principalExample: \`${renderPrincipalExample(params.identity)}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayBypassPairing: \`${params.auth.mayBypassPairing}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `verbose: \`${params.route.verbose}\``);
   return lines.join(`
 `);
 }
@@ -66788,7 +67229,8 @@ function renderRouteStatusMessage(params) {
     `platform: \`${params.identity.platform}\``,
     `conversationKind: \`${params.identity.conversationKind}\``,
     `agentId: \`${params.route.agentId}\``,
-    `sessionKey: \`${params.sessionTarget.sessionKey}\``
+    `sessionKey: \`${params.sessionTarget.sessionKey}\``,
+    `storedSessionId: \`${params.sessionDiagnostics.sessionId ?? "(not captured yet)"}\``
   ];
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
@@ -66805,7 +67247,7 @@ function renderRouteStatusMessage(params) {
   if (params.identity.topicId) {
     lines.push(`topicId: \`${params.identity.topicId}\``);
   }
-  lines.push(`principal: \`${params.auth.principal ?? "(none)"}\``, `principalFormat: \`${renderPrincipalFormat(params.identity)}\``, `principalExample: \`${renderPrincipalExample(params.identity)}\``, `streaming: \`${params.route.streaming}\``, `response: \`${params.route.response}\``, `responseMode: \`${params.route.responseMode}\``, `additionalMessageMode: \`${params.route.additionalMessageMode}\``, `surfaceNotifications.queueStart: \`${params.route.surfaceNotifications.queueStart}\``, `surfaceNotifications.loopStart: \`${params.route.surfaceNotifications.loopStart}\``, `verbose: \`${params.route.verbose}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `timezone: \`${params.route.timezone ?? "(inherit host/app)"}\``, `followUp.mode: \`${params.followUpState.overrideMode ?? params.route.followUp.mode}\``, `followUp.windowMinutes: \`${formatFollowUpTtlMinutes(params.route.followUp.participationTtlMs)}\``, `run.state: \`${params.runtimeState.state}\``);
+  lines.push(`resumeCommand: \`${params.sessionDiagnostics.resumeCommand ?? "(not available yet)"}\``, `principal: \`${params.auth.principal ?? "(none)"}\``, `principalFormat: \`${renderPrincipalFormat(params.identity)}\``, `principalExample: \`${renderPrincipalExample(params.identity)}\``, `streaming: \`${params.route.streaming}\``, `response: \`${params.route.response}\``, `responseMode: \`${params.route.responseMode}\``, `additionalMessageMode: \`${params.route.additionalMessageMode}\``, `surfaceNotifications.queueStart: \`${params.route.surfaceNotifications.queueStart}\``, `surfaceNotifications.loopStart: \`${params.route.surfaceNotifications.loopStart}\``, `verbose: \`${params.route.verbose}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `timezone: \`${params.route.timezone ?? "(inherit host/app)"}\``, `followUp.mode: \`${params.followUpState.overrideMode ?? params.route.followUp.mode}\``, `followUp.windowMinutes: \`${formatFollowUpTtlMinutes(params.route.followUp.participationTtlMs)}\``, `run.state: \`${params.runtimeState.state}\``);
   if (params.runtimeState.startedAt) {
     lines.push(`run.startedAt: \`${new Date(params.runtimeState.startedAt).toISOString()}\``);
   }
@@ -66819,7 +67261,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 30s`", "- `/followup status`", "- `/streaming status|on|off|latest|all`", "- `/responsemode status`", "- `/additionalmessagemode status`", "- `/loop status`, `/loop cancel`, `/loop cancel <id>`", "- `/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 30s`", "- `/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`");
   return lines.join(`
 `);
 }
@@ -66877,25 +67319,6 @@ function buildChannelObserverId(identity) {
     identity.topicId ?? ""
   ].join(":");
 }
-function buildSteeringMessage(text, protectedControlMutationRule) {
-  const systemLines = [
-    "A new user message arrived while you were still working.",
-    "Adjust your current work if needed and continue."
-  ];
-  if (protectedControlMutationRule) {
-    systemLines.push("", protectedControlMutationRule);
-  }
-  return [
-    "<system>",
-    ...systemLines,
-    "</system>",
-    "",
-    "<user>",
-    text,
-    "</user>"
-  ].join(`
-`);
-}
 function renderQueuedMessagesList(items) {
   if (items.length === 0) {
     return "Queue is empty.";
@@ -66910,9 +67333,22 @@ function renderQueuedMessagesList(items) {
   return lines.join(`
 `).trimEnd();
 }
+function renderQueueUsage() {
+  return [
+    "Queue commands",
+    "",
+    ...renderQueueHelpLines(),
+    "",
+    "Notes:",
+    "- use queue when the current run should finish first and the next user request can wait in order",
+    "- use steer when the active run should be nudged or redirected immediately"
+  ].join(`
+`);
+}
 function renderLoopUsage() {
   return [
     "Usage:",
+    "- `/loop help`",
     "- `/loop 5m check CI`",
     "- `/loop 1m --force check CI`",
     "- `/loop 5m`",
@@ -67463,6 +67899,7 @@ async function processChannelInteraction(params) {
   };
   let replyRecorded = false;
   let renderChain = Promise.resolve();
+  const sessionDiagnostics = await params.agentService.getSessionDiagnostics?.(params.sessionTarget) ?? {};
   async function recordReplyIfNeeded() {
     if (replyRecorded) {
       return;
@@ -67537,6 +67974,7 @@ async function processChannelInteraction(params) {
         route: params.route,
         auth,
         sessionTarget: params.sessionTarget,
+        sessionDiagnostics,
         followUpState,
         runtimeState,
         loopState: {
@@ -67557,7 +67995,8 @@ async function processChannelInteraction(params) {
         identity: params.identity,
         route: params.route,
         auth,
-        sessionTarget: params.sessionTarget
+        sessionTarget: params.sessionTarget,
+        sessionDiagnostics
       }));
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
@@ -67714,6 +68153,11 @@ async function processChannelInteraction(params) {
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
     }
+    if (slashCommand.name === "queue-help") {
+      await params.postText(renderQueueUsage());
+      await params.agentService.recordConversationReply(params.sessionTarget);
+      return interactionResult;
+    }
     if (slashCommand.name === "queue-clear") {
       const clearedCount = params.agentService.clearQueuedPrompts?.(params.sessionTarget) ?? 0;
       await params.postText(clearedCount > 0 ? `Cleared ${clearedCount} queued message${clearedCount === 1 ? "" : "s"}.` : "Queue was already empty.");
@@ -67721,6 +68165,11 @@ async function processChannelInteraction(params) {
       return interactionResult;
     }
   }
+  if (slashCommand?.type === "control" && slashCommand.name === "loop-help") {
+    await params.postText(renderLoopUsage());
+    await params.agentService.recordConversationReply(params.sessionTarget);
+    return interactionResult;
+  }
   if (slashCommand?.type === "loop-control") {
     if (slashCommand.action === "status") {
       await params.postText(renderLoopStatusMessage({
@@ -67943,7 +68392,10 @@ ${escapeCodeFence(shellResult.output)}
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
     }
-    await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringMessage(explicitSteerMessage, params.protectedControlMutationRule));
+    await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringPromptText({
+      text: explicitSteerMessage,
+      protectedControlMutationRule: params.protectedControlMutationRule
+    }));
     await params.postText("Steered.");
     await params.agentService.recordConversationReply(params.sessionTarget);
     return {
@@ -67952,7 +68404,10 @@ ${escapeCodeFence(shellResult.output)}
   }
   if (!forceQueuedDelivery && params.route.additionalMessageMode === "steer") {
     if (sessionBusy && canSteerActiveRun) {
-      await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringMessage(params.text, params.protectedControlMutationRule));
+      await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringPromptText({
+        text: params.text,
+        protectedControlMutationRule: params.protectedControlMutationRule
+      }));
       return {
         processingIndicatorLifecycle: "active-run"
       };
@@ -68126,6 +68581,43 @@ function resolveChannelAuth(params) {
 
 // src/auth/owner-claim.ts
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+import { statSync as statSync3 } from "node:fs";
+
+// src/control/config-reload-suppression.ts
+var suppressedReloads = new Map;
+var MTIME_MATCH_EPSILON_MS = 1;
+function normalizeConfigPath(configPath) {
+  return configPath.trim();
+}
+function suppressConfigReload(configPath, mtimeMs) {
+  const normalizedPath = normalizeConfigPath(configPath);
+  if (!normalizedPath || !Number.isFinite(mtimeMs)) {
+    return;
+  }
+  const existing = suppressedReloads.get(normalizedPath) ?? [];
+  existing.push(mtimeMs);
+  suppressedReloads.set(normalizedPath, existing);
+}
+function consumeSuppressedConfigReload(configPath, mtimeMs) {
+  const normalizedPath = normalizeConfigPath(configPath);
+  if (!normalizedPath || !Number.isFinite(mtimeMs)) {
+    return false;
+  }
+  const existing = suppressedReloads.get(normalizedPath);
+  if (!existing || existing.length === 0) {
+    return false;
+  }
+  const next = existing.filter((candidate) => Math.abs(candidate - mtimeMs) > MTIME_MATCH_EPSILON_MS);
+  const matched = next.length !== existing.length;
+  if (next.length === 0) {
+    suppressedReloads.delete(normalizedPath);
+  } else {
+    suppressedReloads.set(normalizedPath, next);
+  }
+  return matched;
+}
+
+// src/auth/owner-claim.ts
 var OWNER_CLAIM_RUNTIME_STARTED_AT_MS = Date.now();
 var CONFIG_LOCK_OPTIONS = {
   retries: {
@@ -68221,6 +68713,7 @@ async function claimFirstOwnerFromDirectMessage(params) {
     }
     freshConfig.app.auth.roles.owner.users = [...currentOwners, principal];
     await writeEditableConfig(expandedPath, freshConfig);
+    suppressConfigReload(expandedPath, statSync3(expandedPath).mtimeMs);
     syncOwnerUsers(params.config, freshConfig);
     ownerClaimRuntimeState.closed = true;
     console.log(`clisbot auto-claimed first owner ${principal}`);
@@ -68503,7 +68996,7 @@ async function clearSlackAssistantThreadStatus(client, target) {
 
 // src/channels/processing-indicator.ts
 function shouldResolveIndicatorWait(update) {
-  return isTerminalRunStatus(update.status) || update.status === "detached";
+  return isTerminalRunStatus(update.status);
 }
 async function waitForProcessingIndicatorLifecycle(params) {
   if (params.lifecycle !== "active-run") {
@@ -68634,6 +69127,7 @@ class ConversationProcessingIndicatorCoordinator {
 }
 
 // src/channels/slack/processing-decoration.ts
+var DEFAULT_STATUS_REFRESH_INTERVAL_MS = 2000;
 async function activateSlackProcessingDecoration(params) {
   const [reactionResult, statusResult] = await Promise.allSettled([
     params.addReaction(),
@@ -68655,7 +69149,38 @@ async function activateSlackProcessingDecoration(params) {
       throw statusResult.reason;
     }
   }
+  let statusRefreshTimer;
+  let closed = false;
+  let refreshInFlight = false;
+  let refreshPromise;
+  if (statusApplied) {
+    const refreshIntervalMs = Math.max(0, params.statusRefreshIntervalMs ?? DEFAULT_STATUS_REFRESH_INTERVAL_MS);
+    if (refreshIntervalMs > 0) {
+      statusRefreshTimer = setInterval(() => {
+        if (closed || refreshInFlight) {
+          return;
+        }
+        refreshInFlight = true;
+        refreshPromise = params.setStatus().then(() => {
+          return;
+        }).catch((error) => {
+          if (!closed) {
+            params.onUnexpectedError?.("refresh-status", error);
+          }
+        }).finally(() => {
+          refreshInFlight = false;
+          refreshPromise = undefined;
+        });
+      }, refreshIntervalMs);
+    }
+  }
   return async () => {
+    closed = true;
+    if (statusRefreshTimer) {
+      clearInterval(statusRefreshTimer);
+      statusRefreshTimer = undefined;
+    }
+    await refreshPromise;
     if (reactionApplied) {
       try {
         await params.removeReaction();
@@ -68726,6 +69251,14 @@ function stripBotMention(text, botUserId) {
   }
   return text.replaceAll(`<@${botUserId}>`, "").replaceAll(/<@[^>]+>/g, "").trim();
 }
+function resolveSlackDirectReplyThreadTs(params) {
+  const resolvedThreadTs = (params.resolvedThreadTs ?? "").trim();
+  if (resolvedThreadTs) {
+    return resolvedThreadTs;
+  }
+  const messageTs = (params.messageTs ?? "").trim();
+  return messageTs || undefined;
+}
 
 // src/channels/slack/reactions.ts
 function normalizeSlackReactionName(value) {
@@ -69501,6 +70034,10 @@ class SlackSocketService {
         await this.processedEventsStore.markCompleted(eventId);
         return;
       }
+      const directReplyThreadTs = resolveSlackDirectReplyThreadTs({
+        messageTs,
+        resolvedThreadTs: await this.resolveThreadTs(event)
+      });
       let ownerClaimed = false;
       let ownerPrincipal;
       try {
@@ -69518,6 +70055,7 @@ class SlackSocketService {
         try {
           await postSlackText(this.app.client, {
             channel: channelId,
+            threadTs: directReplyThreadTs,
             text: renderFirstOwnerClaimMessage({
               principal: ownerPrincipal,
               ownerClaimWindowMinutes: this.loadedConfig.raw.app.auth.ownerClaimWindowMinutes
@@ -69540,19 +70078,21 @@ class SlackSocketService {
         });
         if (!allowed) {
           if (dmConfig.policy === "pairing") {
-            const { code, created } = await upsertChannelPairingRequest({
+            const pairingRequest = await upsertChannelPairingRequest({
               channel: "slack",
               id: directUserId
             });
-            if (created && code) {
+            const pairingReply = buildPairingReplyFromRequest({
+              channel: "slack",
+              idLine: `Your Slack user id: ${directUserId}`,
+              pairingRequest
+            });
+            if (pairingReply) {
               try {
                 await postSlackText(this.app.client, {
                   channel: channelId,
-                  text: buildPairingReply({
-                    channel: "slack",
-                    idLine: `Your Slack user id: ${directUserId}`,
-                    code
-                  })
+                  threadTs: directReplyThreadTs,
+                  text: pairingReply
                 });
               } catch (error) {
                 console.error("slack pairing reply failed", error);
@@ -71123,6 +71663,7 @@ class TelegramPollingService {
         try {
           await callTelegramApi(this.accountConfig.botToken, "sendMessage", {
             chat_id: message.chat.id,
+            ...message.message_id != null ? { reply_to_message_id: message.message_id } : {},
             text: renderFirstOwnerClaimMessage({
               principal: ownerPrincipal,
               ownerClaimWindowMinutes: this.loadedConfig.raw.app.auth.ownerClaimWindowMinutes
@@ -71146,7 +71687,7 @@ class TelegramPollingService {
         });
         if (!allowed) {
           if (directMessages.policy === "pairing") {
-            const { code, created } = await upsertChannelPairingRequest({
+            const pairingRequest = await upsertChannelPairingRequest({
               channel: "telegram",
               id: senderId,
               meta: {
@@ -71155,15 +71696,16 @@ class TelegramPollingService {
                 lastName: message.from?.last_name
               }
             });
-            if (created && code) {
+            const pairingReply = buildPairingReplyFromRequest({
+              channel: "telegram",
+              idLine: `Your Telegram user id: ${senderId}`,
+              pairingRequest
+            });
+            if (pairingReply) {
               try {
                 await callTelegramApi(this.accountConfig.botToken, "sendMessage", {
                   chat_id: message.chat.id,
-                  text: buildPairingReply({
-                    channel: "telegram",
-                    idLine: `Your Telegram user id: ${senderId}`,
-                    code
-                  })
+                  text: pairingReply
                 });
               } catch (error) {
                 console.error("telegram pairing reply failed", error);
@@ -71809,19 +72351,33 @@ function summarizeExit(params) {
   return `code ${params.code ?? 0}`;
 }
 function getRestartPlan(config, restartNumber) {
-  let completedRestarts = 0;
-  const totalRestarts = config.stages.reduce((sum, stage) => sum + stage.maxRestarts, 0);
+  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,
-        delayMinutes: stage.delayMinutes,
+        delayMs: stage.delayMinutes * 60000,
         restartAttemptInStage: restartNumber - completedRestarts,
         restartsRemaining: totalRestarts - restartNumber,
-        totalRestarts
+        totalRestarts,
+        stageMaxRestarts: stage.maxRestarts
       };
     }
     completedRestarts = stageEnd;
@@ -71955,7 +72511,7 @@ function renderBackoffAlertMessage(params) {
     `next restart: ${params.nextRestartAt}`,
     `restart: ${params.restartNumber}/${params.totalRestarts}`,
     `stage: ${params.stageIndex + 1}/${params.config.restartBackoff.stages.length}`,
-    `stage attempt: ${params.restartAttemptInStage}/${params.config.restartBackoff.stages[params.stageIndex]?.maxRestarts ?? params.restartAttemptInStage}`
+    `stage attempt: ${params.restartAttemptInStage}/${params.stageMaxRestarts}`
   ].join(`
 `);
 }
@@ -72048,20 +72604,23 @@ class RuntimeMonitor {
         }
         restartNumber = nextRestartNumber;
         totalRestarts = plan.totalRestarts;
-        const nextRestartAt = new Date(this.dependencies.now() + plan.delayMinutes * 60000).toISOString();
-        await this.maybeSendAlert("backoff", monitorConfig, renderBackoffAlertMessage({
-          config: monitorConfig,
-          restartNumber,
-          stageIndex: plan.stageIndex,
-          restartAttemptInStage: plan.restartAttemptInStage,
-          totalRestarts,
-          nextRestartAt,
-          exit: {
-            code: exit.code,
-            signal: exit.signal,
-            at: exitAt
-          }
-        }));
+        const nextRestartAt = new Date(this.dependencies.now() + plan.delayMs).toISOString();
+        if (plan.mode === "backoff") {
+          await this.maybeSendAlert("backoff", monitorConfig, renderBackoffAlertMessage({
+            config: monitorConfig,
+            restartNumber,
+            stageIndex: plan.stageIndex,
+            restartAttemptInStage: plan.restartAttemptInStage,
+            stageMaxRestarts: plan.stageMaxRestarts,
+            totalRestarts,
+            nextRestartAt,
+            exit: {
+              code: exit.code,
+              signal: exit.signal,
+              at: exitAt
+            }
+          }));
+        }
         await this.writeState({
           phase: "backoff",
           runtimePid: undefined,
@@ -72071,6 +72630,7 @@ class RuntimeMonitor {
             at: exitAt
           },
           restart: {
+            mode: plan.mode,
             stageIndex: plan.stageIndex,
             restartNumber,
             restartAttemptInStage: plan.restartAttemptInStage,
@@ -72078,7 +72638,7 @@ class RuntimeMonitor {
             nextRestartAt
           }
         });
-        await this.sleepWithStop(plan.delayMinutes * 60000);
+        await this.sleepWithStop(plan.delayMs);
       }
     } finally {
       await this.stopActiveChild();
@@ -72239,17 +72799,87 @@ var PROCESS_POLL_INTERVAL_MS = 100;
 function resolveConfigPath(configPath) {
   return expandHomePath(configPath ?? process.env.CLISBOT_CONFIG_PATH ?? getDefaultConfigPath());
 }
-function resolvePidPath(pidPath) {
-  return expandHomePath(pidPath ?? process.env.CLISBOT_PID_PATH ?? getDefaultRuntimePidPath());
+function deriveRuntimeSiblingPath(configPath, filename) {
+  if (!configPath) {
+    return null;
+  }
+  return join11(dirname13(expandHomePath(configPath)), "state", filename);
+}
+function resolvePidPath(pidPath, configPath, options = {}) {
+  if (pidPath) {
+    return expandHomePath(pidPath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "clisbot.pid");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_PID_PATH) {
+    return expandHomePath(process.env.CLISBOT_PID_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "clisbot.pid");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimePidPath());
 }
-function resolveLogPath(logPath) {
-  return expandHomePath(logPath ?? process.env.CLISBOT_LOG_PATH ?? getDefaultRuntimeLogPath());
+function resolveLogPath(logPath, configPath, options = {}) {
+  if (logPath) {
+    return expandHomePath(logPath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "clisbot.log");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_LOG_PATH) {
+    return expandHomePath(process.env.CLISBOT_LOG_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "clisbot.log");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimeLogPath());
 }
-function resolveMonitorStatePath(monitorStatePath) {
-  return expandHomePath(monitorStatePath ?? process.env.CLISBOT_RUNTIME_MONITOR_STATE_PATH ?? getDefaultRuntimeMonitorStatePath());
+function resolveMonitorStatePath(monitorStatePath, configPath, options = {}) {
+  if (monitorStatePath) {
+    return expandHomePath(monitorStatePath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "clisbot-monitor.json");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_RUNTIME_MONITOR_STATE_PATH) {
+    return expandHomePath(process.env.CLISBOT_RUNTIME_MONITOR_STATE_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "clisbot-monitor.json");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimeMonitorStatePath());
 }
-function resolveRuntimeCredentialsPath(runtimeCredentialsPath) {
-  return expandHomePath(runtimeCredentialsPath ?? process.env.CLISBOT_RUNTIME_CREDENTIALS_PATH ?? getDefaultRuntimeCredentialsPath());
+function resolveRuntimeCredentialsPath(runtimeCredentialsPath, configPath, options = {}) {
+  if (runtimeCredentialsPath) {
+    return expandHomePath(runtimeCredentialsPath);
+  }
+  if (options.preferConfigSibling) {
+    const derivedFromExplicitConfig = deriveRuntimeSiblingPath(configPath, "runtime-credentials.json");
+    if (derivedFromExplicitConfig) {
+      return derivedFromExplicitConfig;
+    }
+  }
+  if (process.env.CLISBOT_RUNTIME_CREDENTIALS_PATH) {
+    return expandHomePath(process.env.CLISBOT_RUNTIME_CREDENTIALS_PATH);
+  }
+  const derivedFromConfig = deriveRuntimeSiblingPath(configPath ?? process.env.CLISBOT_CONFIG_PATH, "runtime-credentials.json");
+  if (derivedFromConfig) {
+    return derivedFromConfig;
+  }
+  return expandHomePath(getDefaultRuntimeCredentialsPath());
 }
 
 class StartDetachedRuntimeError extends Error {
@@ -72326,10 +72956,14 @@ async function ensureConfigFile(configPath, options = {}) {
   };
 }
 async function startDetachedRuntime(params) {
-  const pidPath = resolvePidPath(params.pidPath);
-  const logPath = resolveLogPath(params.logPath);
-  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath);
-  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath);
+  const configPath = resolveConfigPath(params.configPath);
+  const preferConfigSibling = params.configPath != null;
+  const pidPath = resolvePidPath(params.pidPath, configPath, { preferConfigSibling });
+  const logPath = resolveLogPath(params.logPath, configPath, { preferConfigSibling });
+  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath, configPath, {
+    preferConfigSibling
+  });
+  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath, configPath, { preferConfigSibling });
   const existingPid = await readRuntimePid(pidPath);
   const existingMonitorState = await readRuntimeMonitorState(monitorStatePath);
   if (existingPid && isProcessRunning(existingPid)) {
@@ -72337,7 +72971,7 @@ async function startDetachedRuntime(params) {
       alreadyRunning: true,
       createdConfig: false,
       pid: existingPid,
-      configPath: resolveConfigPath(params.configPath),
+      configPath,
       logPath
     };
   }
@@ -72402,9 +73036,13 @@ async function startDetachedRuntime(params) {
   };
 }
 async function stopDetachedRuntime(params, dependencies = {}) {
-  const pidPath = resolvePidPath(params.pidPath);
-  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath);
-  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath);
+  const configPath = resolveConfigPath(params.configPath);
+  const preferConfigSibling = params.configPath != null;
+  const pidPath = resolvePidPath(params.pidPath, configPath, { preferConfigSibling });
+  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath, configPath, {
+    preferConfigSibling
+  });
+  const runtimeCredentialsPath = resolveRuntimeCredentialsPath(params.runtimeCredentialsPath, configPath, { preferConfigSibling });
   const existingPid = await readRuntimePid(pidPath);
   const monitorState = await readRuntimeMonitorState(monitorStatePath);
   let stopped = false;
@@ -72445,7 +73083,7 @@ async function stopDetachedRuntime(params, dependencies = {}) {
   }
   rmSync3(pidPath, { force: true });
   removeRuntimeCredentials(runtimeCredentialsPath);
-  await disableExpiredMemAccountsInConfig(params.configPath);
+  await disableExpiredMemAccountsInConfig(configPath);
   if (monitorState) {
     await writeRuntimeMonitorState(monitorStatePath, {
       ...monitorState,
@@ -72456,7 +73094,7 @@ async function stopDetachedRuntime(params, dependencies = {}) {
     });
   }
   if (params.hard) {
-    const socketPath = await resolveTmuxSocketPath(params.configPath);
+    const socketPath = await resolveTmuxSocketPath(configPath);
     const tmux = new TmuxClient(socketPath);
     try {
       await tmux.killServer();
@@ -72489,9 +73127,12 @@ function removeRuntimePid(pidPath) {
 }
 async function getRuntimeStatus(params = {}) {
   const configPath = resolveConfigPath(params.configPath);
-  const pidPath = resolvePidPath(params.pidPath);
-  const logPath = resolveLogPath(params.logPath);
-  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath);
+  const preferConfigSibling = params.configPath != null;
+  const pidPath = resolvePidPath(params.pidPath, configPath, { preferConfigSibling });
+  const logPath = resolveLogPath(params.logPath, configPath, { preferConfigSibling });
+  const monitorStatePath = resolveMonitorStatePath(params.monitorStatePath, configPath, {
+    preferConfigSibling
+  });
   const pid = await readRuntimePid(pidPath);
   const liveness = pid ? getProcessLiveness(pid) : "missing";
   const monitorState = await readRuntimeMonitorState(monitorStatePath);
@@ -72508,6 +73149,7 @@ async function getRuntimeStatus(params = {}) {
     runtimePid: monitorState?.runtimePid && getProcessLiveness(monitorState.runtimePid) === "running" ? monitorState.runtimePid : undefined,
     nextRestartAt: monitorState?.restart?.nextRestartAt,
     restartNumber: monitorState?.restart?.restartNumber,
+    restartMode: monitorState?.restart?.mode,
     restartStageIndex: monitorState?.restart?.stageIndex,
     stopReason: monitorState?.stopReason
   };
@@ -72545,7 +73187,7 @@ function getLogSize(logPath) {
     return 0;
   }
   try {
-    return statSync3(logPath).size;
+    return statSync4(logPath).size;
   } catch {
     return 0;
   }
@@ -72737,10 +73379,17 @@ function renderAccountsHelp() {
     "",
     "Usage:",
     "  clisbot accounts --help",
+    "  clisbot accounts help",
     "  clisbot accounts add telegram --account <id> --token <ENV_NAME|${ENV_NAME}|literal> [--persist]",
     "  clisbot accounts add slack --account <id> --app-token <ENV_NAME|${ENV_NAME}|literal> --bot-token <ENV_NAME|${ENV_NAME}|literal> [--persist]",
     "  clisbot accounts persist --channel <slack|telegram> --account <id>",
-    "  clisbot accounts persist --all"
+    "  clisbot accounts persist --all",
+    "",
+    "Notes:",
+    "  - env-style input such as `TELEGRAM_BOT_TOKEN` or `${TELEGRAM_BOT_TOKEN}` keeps the account env-backed in config",
+    "  - literal token input without `--persist` stays runtime-only and requires a running clisbot runtime",
+    "  - `--persist` writes canonical token files so later plain `clisbot start` can reuse the account safely",
+    "  - `persist --all` converts every configured `credentialType=mem` account into canonical token files"
   ].join(`
 `);
 }
@@ -72917,7 +73566,7 @@ async function runAccountsCli(args, deps = {}) {
     ...deps
   };
   const action = args[0];
-  if (!action || action === "--help" || action === "-h") {
+  if (!action || action === "--help" || action === "-h" || action === "help") {
     console.log(renderAccountsHelp());
     return;
   }
@@ -73021,6 +73670,7 @@ function renderAuthCliHelp() {
     "  add-user/remove-user mutate roles.<role>.users",
     "  add-permission/remove-permission mutate roles.<role>.allow",
     "  agent role edits clone the inherited agent-defaults role into the target agent override on first write",
+    "  app `owner` and `admin` principals bypass DM pairing automatically once they are granted",
     "",
     "Examples:",
     "  clisbot auth add-user app --role owner --user telegram:1276408333",
@@ -73283,6 +73933,7 @@ function renderChannelsHelp() {
     "  - Slack private groups need channels.slack.groups.<groupId>",
     "  - Telegram groups need channels.telegram.groups.<chatId>",
     "  - Telegram forum topics need channels.telegram.groups.<chatId>.topics.<topicId>",
+    "  - route adds for Slack channels, Slack groups, Telegram groups, and Telegram topics default to `requireMention: true` unless you pass `--require-mention false`",
     "  - Adding a route puts that surface on the allowlist; other channels, groups, or topics still need to be added explicitly",
     "  - Tune route settings such as requireMention and followUp in clisbot.json when a surface should behave differently",
     `  - Manage routed auth and /bash access in ${AUTH_USER_GUIDE_DOC_PATH}`,
@@ -73361,6 +74012,7 @@ function renderRouteAddGuidance(params) {
     console.log(`  - route added: ${routePath}`);
     console.log("  - direct messages still follow channels.slack.directMessages.policy (`open`, `pairing`, `allowlist`, or `disabled`)");
     console.log(`  - this ${routeLabel} still follows channels.slack.groupPolicy and route settings such as requireMention and followUp`);
+    console.log("  - new Slack channel/group routes default to `requireMention: true` unless you passed `--require-mention false`");
     console.log("  - if you want pairing-style access control for DMs, set channels.slack.directMessages.policy to `pairing`");
     console.log("  - if you want stricter route access, keep Slack groups on allowlist and only add the channels/groups you trust");
     console.log(`  - manage routed auth and /bash access in ${AUTH_USER_GUIDE_DOC_PATH}`);
@@ -73371,6 +74023,7 @@ function renderRouteAddGuidance(params) {
     console.log(`  - route added: ${routePath}`);
     console.log("  - direct messages still follow channels.telegram.directMessages.policy (`open`, `pairing`, `allowlist`, or `disabled`)");
     console.log(`  - this ${params.kind} is now on the Telegram allowlist; other groups or topics still need to be added explicitly`);
+    console.log("  - new Telegram group/topic routes default to `requireMention: true` unless you passed `--require-mention false`");
     console.log("  - if you want pairing-style access control for DMs, set channels.telegram.directMessages.policy to `pairing`");
     console.log("  - tune route settings such as requireMention and followUp in clisbot.json if this surface should behave differently");
     console.log(`  - manage routed auth and /bash access in ${AUTH_USER_GUIDE_DOC_PATH}`);
@@ -73569,7 +74222,7 @@ async function addSlackRoute(kind, args) {
   }
   const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
   const agentId = getAgentId(args);
-  const requireMention = parseBooleanOption(args, "--require-mention", false);
+  const requireMention = parseBooleanOption(args, "--require-mention", true);
   const target = kind === "channel" ? config.channels.slack.channels : config.channels.slack.groups;
   target[routeId] = {
     ...target[routeId] ?? {},
@@ -74800,6 +75453,41 @@ function assertSupportedPlatform(command) {
 }
 
 // src/control/runtime-bootstrap-cli.ts
+function hasHelpFlag(args) {
+  return args.includes("--help") || args.includes("-h") || args.includes("help");
+}
+function renderBootstrapCommandHelp(commandName) {
+  const behavior = commandName === "start" ? "seed config if needed and start the detached runtime" : "seed config and optionally bootstrap the first agent without starting runtime";
+  return [
+    `clisbot ${commandName}`,
+    "",
+    "Usage:",
+    `  clisbot ${commandName} --help`,
+    `  clisbot ${commandName} [--cli <codex|claude|gemini>] [--bot-type <personal|team>] [--persist]`,
+    "                   [--slack-account <id> --slack-app-token <ENV_NAME|${ENV_NAME}|literal> --slack-bot-token <ENV_NAME|${ENV_NAME}|literal>]...",
+    "                   [--telegram-account <id> --telegram-bot-token <ENV_NAME|${ENV_NAME}|literal>]...",
+    "",
+    "Behavior:",
+    `  - ${behavior}`,
+    "  - first-run agent bootstrap needs both `--cli` and `--bot-type`",
+    "  - `--bot-type personal` maps to `personal-assistant`; `--bot-type team` maps to `team-assistant`",
+    "  - explicit credential flags only enable the channels and accounts you named in this command",
+    "  - env-style values such as `SLACK_APP_TOKEN` or `${SLACK_APP_TOKEN}` stay env-backed in config",
+    commandName === "start" ? "  - literal token values without `--persist` stay runtime-only for this start invocation" : "  - literal token values on `init` require `--persist` because no runtime exists yet",
+    "  - `--persist` writes canonical credential files so later plain `clisbot start` can reuse them",
+    "",
+    "Examples:",
+    `  clisbot ${commandName} --cli codex --bot-type personal --telegram-bot-token TELEGRAM_BOT_TOKEN`,
+    `  clisbot ${commandName} --cli codex --bot-type team --slack-app-token SLACK_APP_TOKEN --slack-bot-token SLACK_BOT_TOKEN`,
+    `  clisbot ${commandName} --cli gemini --bot-type personal --telegram-bot-token "$TELEGRAM_BOT_TOKEN" --persist`,
+    "",
+    "Related help:",
+    "  - `clisbot agents --help` for lower-level agent bootstrap and binding control",
+    "  - `clisbot accounts --help` for account persistence after first run",
+    "  - `clisbot channels --help` for route setup after bootstrap"
+  ].join(`
+`);
+}
 function getPrimaryWorkspacePath(summary) {
   const preferredAgentId = summary.channelSummaries.find((channel) => channel.enabled)?.defaultAgentId ?? "default";
   return summary.agentSummaries.find((agent) => agent.id === preferredAgentId)?.workspacePath ?? summary.agentSummaries[0]?.workspacePath;
@@ -75016,6 +75704,10 @@ async function printStartedRuntimeSummary(pid, configPath, logPath) {
   }
 }
 async function initConfig(args = []) {
+  if (hasHelpFlag(args)) {
+    console.log(renderBootstrapCommandHelp("init"));
+    return;
+  }
   const state = await prepareBootstrapState(args, "init");
   if (!state) {
     return;
@@ -75034,6 +75726,10 @@ async function initConfig(args = []) {
   }
 }
 async function start(args = []) {
+  if (hasHelpFlag(args)) {
+    console.log(renderBootstrapCommandHelp("start"));
+    return;
+  }
   const runtimeStatus = await getRuntimeStatus();
   const bootstrapFlags = parseBootstrapFlags(args);
   const restartForLiteralBootstrap = runtimeStatus.running && hasLiteralMemCredentials(bootstrapFlags);
@@ -75086,7 +75782,7 @@ async function start(args = []) {
 }
 
 // src/control/runtime-supervisor.ts
-import { statSync as statSync4, watch } from "node:fs";
+import { statSync as statSync5, watch } from "node:fs";
 import { basename as basename4, dirname as dirname15 } from "node:path";
 
 // src/channels/processed-events-store.ts
@@ -75249,12 +75945,22 @@ class RuntimeSupervisor {
     let nextRuntime;
     try {
       const loadedConfig = await this.dependencies.loadConfig(this.configPath);
+      const configMtimeMs = statSync5(loadedConfig.configPath).mtimeMs;
+      if (reason === "watch" && consumeSuppressedConfigReload(loadedConfig.configPath, configMtimeMs)) {
+        await this.reconcileConfigWatcher(loadedConfig);
+        await this.dependencies.runtimeHealthStore.setReload({
+          status: "success",
+          reason,
+          configMtimeMs
+        });
+        return;
+      }
       nextRuntime = await this.createRuntime(loadedConfig);
       await this.reconcileConfigWatcher(loadedConfig);
       await this.dependencies.runtimeHealthStore.setReload({
         status: "success",
         reason,
-        configMtimeMs: statSync4(loadedConfig.configPath).mtimeMs
+        configMtimeMs
       });
       this.activeRuntime = nextRuntime;
       if (previousRuntime) {
@@ -75596,6 +76302,9 @@ async function printStatusSummary() {
   if (runtimeStatus.restartNumber) {
     console.log(`restart attempt: ${runtimeStatus.restartNumber}`);
   }
+  if (runtimeStatus.restartMode) {
+    console.log(`restart mode: ${runtimeStatus.restartMode}`);
+  }
   if (runtimeStatus.restartStageIndex != null && runtimeStatus.restartStageIndex >= 0) {
     console.log(`restart stage: ${runtimeStatus.restartStageIndex + 1}`);
   }