clisbot 0.1.32 → 0.1.38

package/dist/main.js

@@ -54623,6 +54623,12 @@ function parseCliArgs(argv) {
       args: args.slice(1)
     };
   }
+  if (command === "runner") {
+    return {
+      name: "runner",
+      args: args.slice(1)
+    };
+  }
   if (command === "pairing") {
     return {
       name: "pairing",
@@ -54685,6 +54691,7 @@ function renderCliHelp() {
     "  clisbot message <subcommand>",
     "  clisbot agents <subcommand>",
     "  clisbot auth <subcommand>",
+    "  clisbot runner <subcommand>",
     "  clisbot pairing <subcommand>",
     "  clisbot init [--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>]...",
@@ -54713,8 +54720,8 @@ function renderCliHelp() {
     "                     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]",
+    "                     add telegram --account <id> (--token|--telegram-bot-token) <ENV_NAME|${ENV_NAME}|literal> [--persist]",
+    "                     add slack --account <id> (--app-token|--slack-app-token) <ENV_NAME|${ENV_NAME}|literal> (--bot-token|--slack-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.",
@@ -54728,6 +54735,8 @@ function renderCliHelp() {
     "  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`.",
+    "  runner             Validate and inspect runner-facing operator contracts such as `runner smoke`.",
+    "                     See `clisbot runner --help` for the current smoke surface.",
     "  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.",
@@ -55261,6 +55270,8 @@ var DEFAULT_AGENT_TOOL_TEMPLATES = {
     ],
     trustWorkspace: true,
     startupDelayMs: 3000,
+    startupRetryCount: 2,
+    startupRetryDelayMs: 1000,
     promptSubmitDelayMs: 150,
     sessionId: {
       create: {
@@ -55292,6 +55303,8 @@ var DEFAULT_AGENT_TOOL_TEMPLATES = {
     startupOptions: ["--dangerously-skip-permissions"],
     trustWorkspace: true,
     startupDelayMs: 3000,
+    startupRetryCount: 2,
+    startupRetryDelayMs: 1000,
     promptSubmitDelayMs: 150,
     sessionId: {
       create: {
@@ -55320,6 +55333,8 @@ var DEFAULT_AGENT_TOOL_TEMPLATES = {
     startupOptions: ["--approval-mode=yolo", "--sandbox=false"],
     trustWorkspace: true,
     startupDelayMs: 15000,
+    startupRetryCount: 2,
+    startupRetryDelayMs: 1000,
     startupReadyPattern: "Type your message or @path/to/file",
     startupBlockers: [
       {
@@ -55359,6 +55374,8 @@ function buildRunnerFromToolTemplate(toolId, template, startupOptions) {
       args: [...options, "-C", "{workspace}"],
       trustWorkspace: template.trustWorkspace,
       startupDelayMs: template.startupDelayMs,
+      startupRetryCount: template.startupRetryCount,
+      startupRetryDelayMs: template.startupRetryDelayMs,
       startupReadyPattern: template.startupReadyPattern,
       startupBlockers: template.startupBlockers?.map((entry) => ({ ...entry })),
       promptSubmitDelayMs: template.promptSubmitDelayMs,
@@ -55383,6 +55400,8 @@ function buildRunnerFromToolTemplate(toolId, template, startupOptions) {
     args: [...options],
     trustWorkspace: template.trustWorkspace,
     startupDelayMs: template.startupDelayMs,
+    startupRetryCount: template.startupRetryCount,
+    startupRetryDelayMs: template.startupRetryDelayMs,
     startupReadyPattern: template.startupReadyPattern,
     startupBlockers: template.startupBlockers?.map((entry) => ({ ...entry })),
     promptSubmitDelayMs: template.promptSubmitDelayMs,
@@ -60047,6 +60066,8 @@ var runnerSchema = exports_external.object({
   ]),
   trustWorkspace: exports_external.boolean().default(true),
   startupDelayMs: exports_external.number().int().positive().default(3000),
+  startupRetryCount: exports_external.number().int().min(0).default(2),
+  startupRetryDelayMs: exports_external.number().int().min(0).default(1000),
   startupReadyPattern: exports_external.string().min(1).optional(),
   startupBlockers: exports_external.array(runnerStartupBlockerSchema).optional(),
   promptSubmitDelayMs: exports_external.number().int().min(0).default(150),
@@ -60083,6 +60104,8 @@ var runnerOverrideSchema = exports_external.object({
   args: exports_external.array(exports_external.string()).optional(),
   trustWorkspace: exports_external.boolean().optional(),
   startupDelayMs: exports_external.number().int().positive().optional(),
+  startupRetryCount: exports_external.number().int().min(0).optional(),
+  startupRetryDelayMs: exports_external.number().int().min(0).optional(),
   startupReadyPattern: exports_external.string().min(1).optional(),
   startupBlockers: exports_external.array(runnerStartupBlockerSchema).optional(),
   promptSubmitDelayMs: exports_external.number().int().min(0).optional(),
@@ -60125,6 +60148,8 @@ var agentDefaultsSchema = exports_external.object({
     ],
     trustWorkspace: true,
     startupDelayMs: 3000,
+    startupRetryCount: 2,
+    startupRetryDelayMs: 1000,
     promptSubmitDelayMs: 150,
     sessionId: defaultRunnerSessionIdConfig
   }),
@@ -60789,6 +60814,8 @@ function renderDefaultConfigTemplate(options = {}) {
           ],
           trustWorkspace: true,
           startupDelayMs: 3000,
+          startupRetryCount: 2,
+          startupRetryDelayMs: 1000,
           startupReadyPattern: undefined,
           promptSubmitDelayMs: 150,
           sessionId: {
@@ -61148,6 +61175,157 @@ function resolveTopLevelBoundAgentId(config, match) {
   });
 }
 
+// src/control/channel-bootstrap-flags.ts
+function isLiteralToken(token) {
+  return token?.kind === "mem";
+}
+function parseBotType(rawValue) {
+  const value = rawValue.trim().toLowerCase();
+  if (value === "personal") {
+    return "personal-assistant";
+  }
+  if (value === "team") {
+    return "team-assistant";
+  }
+  throw new Error(`Invalid bot type: ${rawValue}. Expected personal or team.`);
+}
+function parseOptionValue(args, name, index) {
+  const value = args[index + 1]?.trim();
+  if (!value) {
+    throw new Error(`Missing value for ${name}`);
+  }
+  return value;
+}
+function getOrCreateSlackAccount(accounts, accountId) {
+  let account = accounts.find((entry) => entry.accountId === accountId);
+  if (!account) {
+    account = { accountId };
+    accounts.push(account);
+  }
+  return account;
+}
+function getOrCreateTelegramAccount(accounts, accountId) {
+  let account = accounts.find((entry) => entry.accountId === accountId);
+  if (!account) {
+    account = { accountId };
+    accounts.push(account);
+  }
+  return account;
+}
+function ensureUniqueAccount(accounts, accountId, flagName) {
+  if (accounts.some((entry) => entry.accountId === accountId)) {
+    throw new Error(`Duplicate ${flagName} ${accountId}`);
+  }
+}
+function validateSlackAccount(account) {
+  if (!account.appToken || !account.botToken) {
+    throw new Error(`Slack account ${account.accountId} requires both app token and bot token`);
+  }
+  if (account.appToken.kind !== account.botToken.kind) {
+    throw new Error(`Slack account ${account.accountId} must use one credential source kind for both app and bot tokens`);
+  }
+}
+function validateTelegramAccount(account) {
+  if (!account.botToken) {
+    throw new Error(`Telegram account ${account.accountId} requires a bot token`);
+  }
+}
+function parseBootstrapFlags(args) {
+  const slackAccounts = [];
+  const telegramAccounts = [];
+  let currentSlackAccountId;
+  let currentTelegramAccountId;
+  let cliTool;
+  let bootstrap;
+  let persist = false;
+  let sawCredentialFlags = false;
+  let sawSlackFlags = false;
+  let sawTelegramFlags = false;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--cli") {
+      cliTool = parseOptionValue(args, arg, index);
+      index += 1;
+      continue;
+    }
+    if (arg === "--bot-type") {
+      bootstrap = parseBotType(parseOptionValue(args, arg, index));
+      index += 1;
+      continue;
+    }
+    if (arg === "--persist") {
+      persist = true;
+      continue;
+    }
+    if (arg === "--slack-account") {
+      const accountId = parseOptionValue(args, arg, index);
+      ensureUniqueAccount(slackAccounts, accountId, "--slack-account");
+      currentSlackAccountId = accountId;
+      getOrCreateSlackAccount(slackAccounts, accountId);
+      sawSlackFlags = true;
+      index += 1;
+      continue;
+    }
+    if (arg === "--telegram-account") {
+      const accountId = parseOptionValue(args, arg, index);
+      ensureUniqueAccount(telegramAccounts, accountId, "--telegram-account");
+      currentTelegramAccountId = accountId;
+      getOrCreateTelegramAccount(telegramAccounts, accountId);
+      sawTelegramFlags = true;
+      index += 1;
+      continue;
+    }
+    if (arg === "--slack-app-token") {
+      const token = parseTokenInput(parseOptionValue(args, arg, index));
+      const account = getOrCreateSlackAccount(slackAccounts, currentSlackAccountId ?? "default");
+      account.appToken = token;
+      sawCredentialFlags = true;
+      sawSlackFlags = true;
+      index += 1;
+      continue;
+    }
+    if (arg === "--slack-bot-token") {
+      const token = parseTokenInput(parseOptionValue(args, arg, index));
+      const account = getOrCreateSlackAccount(slackAccounts, currentSlackAccountId ?? "default");
+      account.botToken = token;
+      sawCredentialFlags = true;
+      sawSlackFlags = true;
+      index += 1;
+      continue;
+    }
+    if (arg === "--telegram-bot-token") {
+      const token = parseTokenInput(parseOptionValue(args, arg, index));
+      const account = getOrCreateTelegramAccount(telegramAccounts, currentTelegramAccountId ?? "default");
+      account.botToken = token;
+      sawCredentialFlags = true;
+      sawTelegramFlags = true;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown option for start/init: ${arg}`);
+  }
+  for (const account of slackAccounts) {
+    validateSlackAccount(account);
+  }
+  for (const account of telegramAccounts) {
+    validateTelegramAccount(account);
+  }
+  return {
+    cliTool,
+    bootstrap,
+    persist,
+    slackAccounts,
+    telegramAccounts,
+    sawCredentialFlags,
+    sawSlackFlags,
+    sawTelegramFlags,
+    literalWarnings: []
+  };
+}
+function hasLiteralBootstrapCredentials(flags) {
+  return flags.slackAccounts.some((account) => isLiteralToken(account.appToken) || isLiteralToken(account.botToken)) || flags.telegramAccounts.some((account) => isLiteralToken(account.botToken));
+}
+
 // src/control/agents-cli.ts
 function getEditableConfigPath() {
   return process.env.CLISBOT_CONFIG_PATH;
@@ -61194,8 +61372,8 @@ function renderAgentsHelp() {
     "  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 add <id> --cli <codex|claude|gemini> [--workspace <path>] [--startup-option <arg>]... [--bot-type <personal|team>] [--bind <channel[:accountId]>]...",
+    "  clisbot agents bootstrap <id> --bot-type <personal|team> [--force]",
     "  clisbot agents bindings [--agent <id>] [--json]",
     "  clisbot agents bind --agent <id> --bind <channel[:accountId]>",
     "  clisbot agents unbind --agent <id> [--bind <channel[:accountId]> | --all]",
@@ -61372,7 +61550,13 @@ async function addAgentToEditableConfig(params) {
 async function addAgent(args) {
   const agentId = args[0]?.trim();
   if (!agentId) {
-    throw new Error("Usage: agents add <id> --cli <codex|claude|gemini> [--workspace <path>] [--startup-option <arg>]... [--bootstrap <personal-assistant|team-assistant>] [--bind <channel[:accountId]>]...");
+    throw new Error("Usage: agents add <id> --cli <codex|claude|gemini> [--workspace <path>] [--startup-option <arg>]... [--bot-type <personal|team>] [--bind <channel[:accountId]>]...");
+  }
+  if (hasFlag(args, "--bootstrap")) {
+    throw new Error("agents add no longer accepts --bootstrap; use --bot-type personal or --bot-type team");
+  }
+  if (hasFlag(args, "--mode")) {
+    throw new Error("agents add does not use --mode; use --bot-type personal or --bot-type team");
   }
   const cliTool = parseSingleOption(args, "--cli");
   if (!cliTool || !(cliTool in DEFAULT_AGENT_TOOL_TEMPLATES)) {
@@ -61380,9 +61564,10 @@ async function addAgent(args) {
   }
   const workspace = parseSingleOption(args, "--workspace");
   const startupOptions = parseRepeatedOption(args, "--startup-option");
-  const bootstrap = parseSingleOption(args, "--bootstrap");
-  if (hasFlag(args, "--bootstrap") && (!bootstrap || !SUPPORTED_BOOTSTRAP_MODES.includes(bootstrap))) {
-    throw new Error("--bootstrap requires personal-assistant or team-assistant");
+  let bootstrap;
+  const botType = parseSingleOption(args, "--bot-type");
+  if (botType) {
+    bootstrap = parseBotType(botType);
   }
   const bindings = parseRepeatedOption(args, "--bind").map(parseBinding);
   const result = await addAgentToEditableConfig({
@@ -61404,12 +61589,19 @@ async function addAgent(args) {
 async function bootstrapAgent(args) {
   const agentId = args[0]?.trim();
   if (!agentId) {
-    throw new Error("Usage: agents bootstrap <id> --mode <personal-assistant|team-assistant> [--force]");
+    throw new Error("Usage: agents bootstrap <id> --bot-type <personal|team> [--force]");
+  }
+  if (hasFlag(args, "--mode")) {
+    throw new Error("agents bootstrap no longer accepts --mode; use --bot-type personal or --bot-type team");
   }
-  const mode = parseSingleOption(args, "--mode");
-  if (!mode || !SUPPORTED_BOOTSTRAP_MODES.includes(mode)) {
-    throw new Error("agents bootstrap requires --mode personal-assistant or --mode team-assistant");
+  if (hasFlag(args, "--bootstrap")) {
+    throw new Error("agents bootstrap does not use --bootstrap; use --bot-type personal or --bot-type team");
   }
+  const botType = parseSingleOption(args, "--bot-type");
+  if (!botType) {
+    throw new Error("agents bootstrap requires --bot-type personal or --bot-type team");
+  }
+  const mode = parseBotType(botType);
   const force = hasFlag(args, "--force");
   const { config, configPath } = await readEditableConfig(getEditableConfigPath());
   const entry = ensureAgentExists(config, agentId);
@@ -64072,6 +64264,8 @@ function resolveAgentTargetInternal(loadedConfig, target) {
 }
 
 // src/agents/job-queue.ts
+var QUEUE_PENDING_POLL_INTERVAL_MS = 25;
+
 class ClearedQueuedTaskError extends Error {
   constructor() {
     super("Queued task was cleared before execution.");
@@ -64099,6 +64293,7 @@ class AgentJobQueue {
       text: options.text,
       createdAt: Date.now(),
       status: "pending",
+      canStart: options.canStart,
       task,
       resolve,
       reject,
@@ -64166,6 +64361,10 @@ class AgentJobQueue {
         if (!nextEntry) {
           break;
         }
+        if (nextEntry.canStart && !await nextEntry.canStart()) {
+          await sleep(QUEUE_PENDING_POLL_INTERVAL_MS);
+          continue;
+        }
         nextEntry.status = "running";
         try {
           nextEntry.resolve(await nextEntry.task());
@@ -64426,12 +64625,22 @@ function isInterruptStatusLine(line) {
   }
   return CODEX_WORKING_STATUS_PATTERN.test(trimmed) || CODEX_INTERRUPT_FOOTER_PATTERN.test(trimmed);
 }
+function isActiveTimerStatusLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return isInterruptStatusLine(trimmed) || GEMINI_THINKING_STATUS_PATTERN.test(trimmed) || CLAUDE_TIMER_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);
+  return isActiveTimerStatusLine(trimmed) || CLAUDE_WORKED_STATUS_PATTERN.test(trimmed);
+}
+function hasActiveTimerStatus(snapshot) {
+  return splitNormalizedLines(snapshot).some((line) => isActiveTimerStatusLine(line));
 }
 function shouldDropCodexChromeLine(line) {
   const trimmed = line.trim();
@@ -64959,6 +65168,8 @@ var PASTE_CAPTURE_REVALIDATE_POLL_INTERVAL_MS = 40;
 var PASTE_CAPTURE_REVALIDATE_MAX_WAIT_MS = 160;
 var SUBMIT_CONFIRM_POLL_INTERVAL_MS = 40;
 var SUBMIT_CONFIRM_MAX_WAIT_MS = 160;
+var SUBMIT_SNAPSHOT_CONFIRM_POLL_INTERVAL_MS = 40;
+var SUBMIT_SNAPSHOT_CONFIRM_MAX_WAIT_MS = 320;
 var TMUX_MISSING_TARGET_PATTERN = /(?:no current target|can't find pane|can't find window)/i;
 var TMUX_MISSING_SESSION_PATTERN = /(?:can't find session:|no server running on )/i;
 var TMUX_SERVER_UNAVAILABLE_PATTERN = /(?:No such file or directory|error connecting to|failed to connect to server)/i;
@@ -64998,15 +65209,18 @@ async function submitTmuxSessionInput(params) {
       logLatencyDebug("tmux-paste-unconfirmed", params.timingContext, {
         sessionName: params.sessionName
       });
-      throw new Error("tmux paste was not confirmed before Enter. The pane state did not change, so clisbot did not treat the prompt as visibly delivered.");
+      preSubmitState = prePasteState;
+    } else {
+      preSubmitState = await params.tmux.getPaneState(params.sessionName);
     }
-    preSubmitState = await params.tmux.getPaneState(params.sessionName);
   }
   await params.tmux.sendKey(params.sessionName, "Enter");
   if (await waitForPaneSubmitConfirmation({
     tmux: params.tmux,
     sessionName: params.sessionName,
-    baseline: preSubmitState
+    baseline: preSubmitState,
+    baselineSnapshot: prePasteSnapshot,
+    captureLines
   })) {
     return;
   }
@@ -65017,10 +65231,15 @@ async function submitTmuxSessionInput(params) {
   if (await waitForPaneSubmitConfirmation({
     tmux: params.tmux,
     sessionName: params.sessionName,
-    baseline: preSubmitState
+    baseline: preSubmitState,
+    baselineSnapshot: prePasteSnapshot,
+    captureLines
   })) {
     return;
   }
+  if (!pasteSettlement.visible) {
+    throw new Error("tmux paste was not confirmed before Enter, and submission still could not be confirmed after Enter. clisbot did not treat the prompt as truthfully delivered.");
+  }
   logLatencyDebug("tmux-submit-unconfirmed", params.timingContext, {
     sessionName: params.sessionName
   });
@@ -65190,6 +65409,16 @@ async function waitForPaneSubmitConfirmation(params) {
     if (hasPaneStateChanged(params.baseline, state)) {
       return true;
     }
+    const snapshotChanged = await waitForPaneSubmitSnapshotConfirmation({
+      tmux: params.tmux,
+      sessionName: params.sessionName,
+      baselineSnapshot: params.baselineSnapshot,
+      captureLines: params.captureLines,
+      maxWaitMs: Math.min(SUBMIT_SNAPSHOT_CONFIRM_MAX_WAIT_MS, Math.max(0, deadline - Date.now()))
+    });
+    if (snapshotChanged) {
+      return true;
+    }
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) {
       return false;
@@ -65197,6 +65426,20 @@ async function waitForPaneSubmitConfirmation(params) {
     await sleep(Math.min(SUBMIT_CONFIRM_POLL_INTERVAL_MS, remainingMs));
   }
 }
+async function waitForPaneSubmitSnapshotConfirmation(params) {
+  const deadline = Date.now() + params.maxWaitMs;
+  while (true) {
+    const snapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines));
+    if (snapshot !== params.baselineSnapshot) {
+      return true;
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return false;
+    }
+    await sleep(Math.min(SUBMIT_SNAPSHOT_CONFIRM_POLL_INTERVAL_MS, remainingMs));
+  }
+}
 async function waitForPanePasteSettlement(params) {
   await sleep(params.minDelayMs);
   let currentState = await params.tmux.getPaneState(params.sessionName);
@@ -65513,32 +65756,38 @@ class RunnerService {
       pollIntervalMs: capture.pollIntervalMs
     });
   }
-  async retryFreshStartWithClearedSessionId(target, resolved, options) {
-    if (options.allowRetry === false) {
+  async retryFreshStartWithClearedSessionId(target, resolved, remainingFreshRetries) {
+    if (remainingFreshRetries <= 0) {
       return null;
     }
     await this.tmux.killSession(resolved.sessionName);
     await this.sessionState.clearSessionIdEntry(resolved, {
       runnerCommand: resolved.runner.command
     });
+    if (resolved.runner.startupRetryDelayMs > 0) {
+      await sleep(resolved.runner.startupRetryDelayMs);
+    }
     return this.ensureSessionReady(target, {
-      allowFreshRetry: options.nextAllowFreshRetry
+      remainingFreshRetries: remainingFreshRetries - 1
     });
   }
-  async retryAfterStartupFault(target, resolved, error, allowFreshRetry) {
+  async retryAfterStartupFault(target, resolved, error, remainingFreshRetries) {
     if (!isRecoverableStartupSessionLoss(error)) {
       return null;
     }
-    return this.retryFreshStartWithClearedSessionId(target, resolved, {
-      allowRetry: allowFreshRetry,
-      nextAllowFreshRetry: false
-    });
+    return this.retryFreshStartWithClearedSessionId(target, resolved, remainingFreshRetries);
   }
-  async retryAfterStartupTimeout(target, resolved, allowFreshRetry) {
-    return this.retryFreshStartWithClearedSessionId(target, resolved, {
-      allowRetry: allowFreshRetry,
-      nextAllowFreshRetry: false
-    });
+  async retryAfterStartupTimeout(target, resolved, remainingFreshRetries) {
+    return this.retryFreshStartWithClearedSessionId(target, resolved, remainingFreshRetries);
+  }
+  resolveRemainingFreshRetries(resolved, options) {
+    if (typeof options.remainingFreshRetries === "number") {
+      return options.remainingFreshRetries;
+    }
+    if (options.allowFreshRetry === false) {
+      return 0;
+    }
+    return resolved.runner.startupRetryCount;
   }
   async abortUnreadySession(resolved, reason, snapshot) {
     await this.tmux.killSession(resolved.sessionName);
@@ -65612,6 +65861,7 @@ class RunnerService {
       sessionKey: resolved.sessionKey,
       sessionName: resolved.sessionName
     };
+    const remainingFreshRetries = this.resolveRemainingFreshRetries(resolved, options);
     logLatencyDebug("ensure-session-ready-start", timingContext);
     await ensureDir2(resolved.workspacePath);
     await ensureDir2(dirname11(this.loadedConfig.raw.tmux.socketPath));
@@ -65684,7 +65934,7 @@ class RunnerService {
         await this.abortUnreadySession(resolved, bootstrapResult.message, bootstrapResult.snapshot);
       }
       if (bootstrapResult.status === "timeout" && resolved.runner.startupReadyPattern) {
-        const retried = await this.retryAfterStartupTimeout(target, resolved, options.allowFreshRetry);
+        const retried = await this.retryAfterStartupTimeout(target, resolved, remainingFreshRetries);
         if (retried) {
           return retried;
         }
@@ -65695,7 +65945,7 @@ class RunnerService {
         runnerCommand: runnerLaunch.command
       });
     } catch (error) {
-      const retried = await this.retryAfterStartupFault(target, resolved, error, options.allowFreshRetry);
+      const retried = await this.retryAfterStartupFault(target, resolved, error, remainingFreshRetries);
       if (retried) {
         return retried;
       }
@@ -65750,10 +66000,7 @@ class RunnerService {
       if (options.allowFreshRetryBeforePrompt === false || !isRecoverableStartupSessionLoss(error)) {
         throw await this.mapSessionError(error, resolved.sessionName, "before prompt submission", resolved.sessionName ? await this.captureSessionSnapshot(resolved).catch(() => "") : "");
       }
-      const retried = await this.retryFreshStartWithClearedSessionId(target, resolved, {
-        allowRetry: true,
-        nextAllowFreshRetry: false
-      });
+      const retried = await this.retryFreshStartWithClearedSessionId(target, resolved, resolved.runner.startupRetryCount);
       if (!retried) {
         throw await this.mapSessionError(error, resolved.sessionName, "before prompt submission", resolved.sessionName ? await this.captureSessionSnapshot(resolved).catch(() => "") : "");
       }
@@ -65924,8 +66171,10 @@ var FIRST_OUTPUT_POLL_INTERVAL_MS = 250;
 async function monitorTmuxRun(params) {
   let previousSnapshot = params.initialSnapshot;
   let previousRunningSnapshot = "";
-  let lastActivityAt = params.startedAt;
+  let lastPaneChangeAt = params.startedAt;
   let sawActivity = false;
+  let sawPaneChange = false;
+  let sawPromptSubmission = Boolean(params.prompt);
   let detachedNotified = params.detachedAlready;
   let firstMeaningfulDeltaLogged = false;
   let noOutputThresholdLogged = false;
@@ -65941,6 +66190,8 @@ async function monitorTmuxRun(params) {
       promptSubmitDelayMs: params.promptSubmitDelayMs,
       timingContext: params.timingContext
     });
+    sawPromptSubmission = true;
+    lastPaneChangeAt = Date.now();
     await params.onPromptSubmitted?.();
     logLatencyDebug("tmux-submit-complete", params.timingContext, {
       sessionName: params.sessionName,
@@ -65952,11 +66203,16 @@ async function monitorTmuxRun(params) {
     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();
+    const paneChanged = snapshot !== previousSnapshot;
+    if (paneChanged) {
+      lastPaneChangeAt = now;
+      sawPaneChange = true;
+    }
+    const hasActiveTimer = hasActiveTimerStatus(snapshot);
     const runningSnapshot = params.initialSnapshot ? deriveRunningInteractionText(params.initialSnapshot, snapshot) : deriveRunningInteractionSnapshot(snapshot);
     previousSnapshot = snapshot;
     if (runningSnapshot && runningSnapshot !== previousRunningSnapshot) {
       previousRunningSnapshot = runningSnapshot;
-      lastActivityAt = now;
       sawActivity = true;
       if (!firstMeaningfulDeltaLogged) {
         firstMeaningfulDeltaLogged = true;
@@ -65979,7 +66235,7 @@ async function monitorTmuxRun(params) {
         initialSnapshot: params.initialSnapshot
       });
     }
-    if (sawActivity && now - lastActivityAt >= params.idleTimeoutMs) {
+    if (!hasActiveTimer && (sawActivity || sawPaneChange || sawPromptSubmission) && now - lastPaneChangeAt >= params.idleTimeoutMs) {
       await params.onCompleted({
         snapshot: deriveInteractionText(params.initialSnapshot, previousSnapshot),
         fullSnapshot: previousSnapshot,
@@ -66000,9 +66256,20 @@ async function monitorTmuxRun(params) {
 // src/agents/session-service.ts
 var OBSERVER_RETRYABLE_FAILURE_LIMIT = 3;
 var DETACHED_OBSERVER_INTERVAL_MS = 5 * 60000;
+var TMUX_MISSING_SESSION_PATTERN3 = /(?:can't find session:|no server running on )/i;
+var TMUX_SERVER_UNAVAILABLE_PATTERN3 = /(?:No such file or directory|error connecting to|failed to connect to server)/i;
 function formatObserverError(error) {
   return error instanceof Error ? error.stack ?? error.message : String(error);
 }
+function isMissingTmuxSessionError2(error) {
+  return error instanceof Error && TMUX_MISSING_SESSION_PATTERN3.test(error.message);
+}
+function isTmuxServerUnavailableError2(error) {
+  return error instanceof Error && TMUX_SERVER_UNAVAILABLE_PATTERN3.test(error.message);
+}
+function isBootstrapSessionLostError2(error) {
+  return error instanceof Error && /tmux session disappeared before startup finished|tmux server became unavailable before startup finished/i.test(error.message);
+}
 function listObserverErrorCodes(error) {
   const codes = new Set;
   const visit = (value) => {
@@ -66074,6 +66341,7 @@ class SessionService {
   runnerSessions;
   resolveTarget;
   activeRuns = new Map;
+  nextRunId = 1;
   stopping = false;
   constructor(tmux, sessionState, runnerSessions, resolveTarget) {
     this.tmux = tmux;
@@ -66087,42 +66355,10 @@ class SessionService {
       if (!entry.runtime || entry.runtime.state === "idle") {
         continue;
       }
-      const resolved = this.resolveTarget({
+      await this.reconcilePersistedActiveRun({
         agentId: entry.agentId,
         sessionKey: entry.sessionKey
       });
-      if (!await this.tmux.hasSession(resolved.sessionName)) {
-        await this.sessionState.setSessionRuntime(resolved, {
-          state: "idle"
-        });
-        continue;
-      }
-      const fullSnapshot = normalizePaneText(await this.tmux.capturePane(resolved.sessionName, resolved.stream.captureLines));
-      const initialResult = createDeferred();
-      const update = this.createRunUpdate({
-        resolved,
-        status: entry.runtime.state === "detached" ? "detached" : "running",
-        snapshot: deriveInteractionText("", fullSnapshot),
-        fullSnapshot,
-        initialSnapshot: "",
-        note: entry.runtime.state === "detached" ? this.buildDetachedNote(resolved) : undefined
-      });
-      this.activeRuns.set(resolved.sessionKey, {
-        resolved,
-        observers: new Map,
-        observerFailures: new Map,
-        initialResult,
-        latestUpdate: update,
-        steeringReady: true,
-        startedAt: entry.runtime.startedAt ?? Date.now()
-      });
-      this.startRunMonitor(resolved.sessionKey, {
-        prompt: undefined,
-        initialSnapshot: fullSnapshot,
-        startedAt: entry.runtime.startedAt ?? Date.now(),
-        detachedAlready: entry.runtime.state === "detached",
-        timingContext: undefined
-      });
     }
   }
   async executePrompt(target, prompt, observer, options = {}) {
@@ -66133,21 +66369,15 @@ class SessionService {
     if (existingActiveRun) {
       throw new ActiveRunInProgressError(existingActiveRun.latestUpdate);
     }
-    const existingEntry = await this.sessionState.getEntry(target.sessionKey);
-    if (existingEntry?.runtime?.state && existingEntry.runtime.state !== "idle") {
-      const resolvedExisting = this.resolveTarget(target);
-      throw new ActiveRunInProgressError(this.createRunUpdate({
-        resolved: resolvedExisting,
-        status: existingEntry.runtime.state === "detached" ? "detached" : "running",
-        snapshot: "",
-        fullSnapshot: "",
-        initialSnapshot: "",
-        note: existingEntry.runtime.state === "detached" ? this.buildDetachedNote(resolvedExisting) : "This session already has an active run. Use `/attach`, `/watch every 30s`, or `/stop` before sending a new prompt."
-      }));
+    const reconciledRun = await this.reconcilePersistedActiveRun(target);
+    if (reconciledRun) {
+      throw new ActiveRunInProgressError(reconciledRun.latestUpdate);
     }
     const initialResult = createDeferred();
     const provisionalResolved = this.resolveTarget(target);
+    const runId = this.allocateRunId();
     this.activeRuns.set(provisionalResolved.sessionKey, {
+      runId,
       resolved: provisionalResolved,
       observers: new Map([[observer.id, { ...observer }]]),
       observerFailures: new Map,
@@ -66195,6 +66425,7 @@ class SessionService {
         startedAt
       });
       this.startRunMonitor(resolved.sessionKey, {
+        runId,
         prompt,
         initialSnapshot,
         startedAt,
@@ -66203,12 +66434,12 @@ class SessionService {
       });
       return initialResult.promise;
     } catch (error) {
-      await this.failActiveRun(provisionalResolved.sessionKey, error);
+      await this.failActiveRun(provisionalResolved.sessionKey, runId, error);
       throw error;
     }
   }
   async observeRun(target, observer) {
-    const existingRun = this.activeRuns.get(target.sessionKey);
+    const existingRun = this.activeRuns.get(target.sessionKey) ?? await this.reconcilePersistedActiveRun(target);
     if (existingRun) {
       existingRun.observers.set(observer.id, {
         ...observer
@@ -66262,6 +66493,29 @@ class SessionService {
   canSteerActiveRun(target) {
     return this.activeRuns.get(target.sessionKey)?.steeringReady ?? false;
   }
+  async submitSessionInput(target, text) {
+    const result = await this.runnerSessions.submitSessionInput(target, text);
+    const run = this.activeRuns.get(target.sessionKey);
+    if (!run) {
+      return result;
+    }
+    const startedAt = Date.now();
+    run.startedAt = startedAt;
+    if (run.latestUpdate.status === "detached") {
+      run.latestUpdate = this.createRunUpdate({
+        resolved: run.resolved,
+        status: "running",
+        snapshot: run.latestUpdate.snapshot,
+        fullSnapshot: run.latestUpdate.fullSnapshot,
+        initialSnapshot: run.latestUpdate.initialSnapshot
+      });
+    }
+    await this.sessionState.setSessionRuntime(run.resolved, {
+      state: "running",
+      startedAt
+    });
+    return result;
+  }
   async stop() {
     this.stopping = true;
     const activeRuns = [...this.activeRuns.values()];
@@ -66348,8 +66602,8 @@ class SessionService {
       }
     }
   }
-  async finishActiveRun(sessionKey, update) {
-    const run = this.activeRuns.get(sessionKey);
+  async finishActiveRun(sessionKey, runId, update) {
+    const run = this.getRun(sessionKey, runId);
     if (!run) {
       return;
     }
@@ -66360,8 +66614,8 @@ class SessionService {
     run.initialResult.resolve(update);
     this.activeRuns.delete(run.resolved.sessionKey);
   }
-  async failActiveRun(sessionKey, error) {
-    const run = this.activeRuns.get(sessionKey);
+  async failActiveRun(sessionKey, runId, error) {
+    const run = this.getRun(sessionKey, runId);
     if (!run) {
       return;
     }
@@ -66387,7 +66641,7 @@ class SessionService {
     if (!this.runnerSessions.canRecoverMidRun(error)) {
       return false;
     }
-    const run = this.activeRuns.get(sessionKey);
+    const run = this.getRun(sessionKey, params.runId);
     if (!run) {
       return true;
     }
@@ -66404,7 +66658,7 @@ class SessionService {
     }));
     try {
       const recovered = await this.runnerSessions.reopenRunContext(target, params.timingContext);
-      const currentRun = this.activeRuns.get(sessionKey);
+      const currentRun = this.getRun(sessionKey, params.runId);
       if (!currentRun) {
         return true;
       }
@@ -66420,6 +66674,7 @@ class SessionService {
       });
       await this.notifyRunObservers(currentRun, currentRun.latestUpdate);
       this.startRunMonitor(sessionKey, {
+        runId: currentRun.runId,
         prompt: MID_RUN_RECOVERY_CONTINUE_PROMPT,
         initialSnapshot: recovered.initialSnapshot,
         startedAt: currentRun.startedAt,
@@ -66432,11 +66687,12 @@ class SessionService {
     } catch (reopenError) {
       if (recoveryAttempt < MID_RUN_RECOVERY_MAX_ATTEMPTS && this.runnerSessions.canRecoverMidRun(reopenError)) {
         return await this.recoverLostMidRun(sessionKey, {
+          runId: params.runId,
           timingContext: params.timingContext,
           recoveryAttempt: recoveryAttempt + 1
         }, reopenError);
       }
-      const currentRun = this.activeRuns.get(sessionKey);
+      const currentRun = this.getRun(sessionKey, params.runId);
       if (!currentRun) {
         return true;
       }
@@ -66444,15 +66700,15 @@ class SessionService {
       try {
         await this.runnerSessions.startFreshSession(target, params.timingContext);
       } catch (freshError) {
-        await this.failActiveRun(sessionKey, await this.runnerSessions.mapRunError(freshError, currentRun.resolved.sessionName, currentRun.latestUpdate.fullSnapshot));
+        await this.failActiveRun(sessionKey, currentRun.runId, await this.runnerSessions.mapRunError(freshError, currentRun.resolved.sessionName, currentRun.latestUpdate.fullSnapshot));
         return true;
       }
-      await this.failActiveRun(sessionKey, new Error(buildRunRecoveryNote("fresh-required")));
+      await this.failActiveRun(sessionKey, currentRun.runId, new Error(buildRunRecoveryNote("fresh-required")));
       return true;
     }
   }
   startRunMonitor(sessionKey, params) {
-    const run = this.activeRuns.get(sessionKey);
+    const run = this.getRun(sessionKey, params.runId);
     if (!run) {
       return;
     }
@@ -66476,14 +66732,14 @@ class SessionService {
           detachedAlready: params.detachedAlready,
           timingContext: params.timingContext,
           onPromptSubmitted: async () => {
-            const currentRun = this.activeRuns.get(sessionKey);
+            const currentRun = this.getRun(sessionKey, params.runId);
             if (!currentRun) {
               return;
             }
             currentRun.steeringReady = true;
           },
           onRunning: async (update) => {
-            const currentRun = this.activeRuns.get(sessionKey);
+            const currentRun = this.getRun(sessionKey, params.runId);
             if (!currentRun) {
               return;
             }
@@ -66499,7 +66755,7 @@ class SessionService {
             }));
           },
           onDetached: async (update) => {
-            const currentRun = this.activeRuns.get(sessionKey);
+            const currentRun = this.getRun(sessionKey, params.runId);
             if (!currentRun) {
               return;
             }
@@ -66521,27 +66777,111 @@ class SessionService {
             currentRun.initialResult.resolve(detachedUpdate);
           },
           onCompleted: async (update) => {
+            const currentRun = this.getRun(sessionKey, params.runId);
+            if (!currentRun) {
+              return;
+            }
             const runUpdate = this.createRunUpdate({
-              resolved: run.resolved,
+              resolved: currentRun.resolved,
               status: "completed",
               snapshot: mergeRunSnapshot(params.snapshotPrefix ?? "", update.snapshot),
               fullSnapshot: update.fullSnapshot,
               initialSnapshot: update.initialSnapshot
             });
-            await this.finishActiveRun(sessionKey, runUpdate);
+            await this.finishActiveRun(sessionKey, params.runId, runUpdate);
           }
         });
       } catch (error) {
         if (await this.recoverLostMidRun(sessionKey, {
+          runId: params.runId,
           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));
+        await this.failActiveRun(sessionKey, params.runId, await this.runnerSessions.mapRunError(error, run.resolved.sessionName, run.latestUpdate.fullSnapshot));
       }
     })();
   }
+  allocateRunId() {
+    return String(this.nextRunId++);
+  }
+  async reconcilePersistedActiveRun(target) {
+    const activeRun = this.activeRuns.get(target.sessionKey);
+    if (activeRun) {
+      return activeRun;
+    }
+    const entry = await this.sessionState.getEntry(target.sessionKey);
+    if (!entry?.runtime || entry.runtime.state === "idle") {
+      return null;
+    }
+    const resolved = this.resolveTarget(target);
+    if (!await this.tmux.hasSession(resolved.sessionName)) {
+      await this.sessionState.setSessionRuntime(resolved, {
+        state: "idle"
+      });
+      return null;
+    }
+    try {
+      return await this.rehydratePersistedActiveRun(resolved, {
+        runtimeState: entry.runtime.state,
+        startedAt: entry.runtime.startedAt
+      });
+    } catch (error) {
+      if (isMissingTmuxSessionError2(error) || isTmuxServerUnavailableError2(error) || isBootstrapSessionLostError2(error)) {
+        await this.sessionState.setSessionRuntime(resolved, {
+          state: "idle"
+        });
+        return null;
+      }
+      throw error;
+    }
+  }
+  async rehydratePersistedActiveRun(resolved, params) {
+    const existingRun = this.activeRuns.get(resolved.sessionKey);
+    if (existingRun) {
+      return existingRun;
+    }
+    const fullSnapshot = normalizePaneText(await this.tmux.capturePane(resolved.sessionName, resolved.stream.captureLines));
+    const startedAt = params.startedAt ?? Date.now();
+    const runId = this.allocateRunId();
+    const initialResult = createDeferred();
+    const update = this.createRunUpdate({
+      resolved,
+      status: params.runtimeState === "detached" ? "detached" : "running",
+      snapshot: deriveInteractionText("", fullSnapshot),
+      fullSnapshot,
+      initialSnapshot: "",
+      note: params.runtimeState === "detached" ? this.buildDetachedNote(resolved) : undefined
+    });
+    const run = {
+      runId,
+      resolved,
+      observers: new Map,
+      observerFailures: new Map,
+      initialResult,
+      latestUpdate: update,
+      steeringReady: true,
+      startedAt
+    };
+    this.activeRuns.set(resolved.sessionKey, run);
+    this.startRunMonitor(resolved.sessionKey, {
+      runId,
+      prompt: undefined,
+      initialSnapshot: fullSnapshot,
+      startedAt,
+      detachedAlready: params.runtimeState === "detached",
+      timingContext: undefined
+    });
+    return run;
+  }
+  getRun(sessionKey, runId) {
+    const run = this.activeRuns.get(sessionKey);
+    if (!run || run.runId !== runId) {
+      return null;
+    }
+    return run;
+  }
 }
 
 // src/agents/agent-service.ts
@@ -66706,7 +67046,7 @@ class AgentService {
     return this.activeRuns.canSteerActiveRun(target);
   }
   async submitSessionInput(target, text) {
-    return this.runnerSessions.submitSessionInput(target, text);
+    return this.activeRuns.submitSessionInput(target, text);
   }
   isSessionBusy(target) {
     return this.activeRuns.hasActiveRun(target) || this.queue.isBusy(target.sessionKey);
@@ -66889,7 +67229,8 @@ class AgentService {
       timingContext: callbacks.timingContext,
       onUpdate: callbacks.onUpdate
     }), {
-      text: prompt
+      text: prompt,
+      canStart: async () => !this.activeRuns.hasActiveRun(target)
     });
   }
   getMaxMessageChars(agentId) {
@@ -69221,6 +69562,7 @@ async function clearSlackAssistantThreadStatus(client, target) {
 }
 
 // src/channels/processing-indicator.ts
+var ACTIVE_RUN_WAIT_POLL_INTERVAL_MS = 250;
 function shouldResolveIndicatorWait(update) {
   return isTerminalRunStatus(update.status);
 }
@@ -69247,6 +69589,18 @@ async function waitForProcessingIndicatorLifecycle(params) {
         settled = true;
         resolve();
       };
+      (async () => {
+        while (!settled) {
+          await sleep(ACTIVE_RUN_WAIT_POLL_INTERVAL_MS);
+          if (settled) {
+            return;
+          }
+          if (!params.agentService.hasActiveRun(params.sessionTarget)) {
+            resolveOnce();
+            return;
+          }
+        }
+      })();
       try {
         const observation = await params.agentService.observeRun(params.sessionTarget, {
           id: params.observerId,
@@ -74523,7 +74877,7 @@ function extractLinuxProcState(raw) {
 function getEditableConfigPath5() {
   return process.env.CLISBOT_CONFIG_PATH;
 }
-function parseOptionValue(args, name) {
+function parseOptionValue2(args, name) {
   const index = args.findIndex((arg) => arg === name);
   if (index === -1) {
     return;
@@ -74534,6 +74888,21 @@ function parseOptionValue(args, name) {
   }
   return value;
 }
+function parseAliasedOptionValue(args, names, label) {
+  const values = names.flatMap((name) => {
+    const value = parseOptionValue2(args, name);
+    return value === undefined ? [] : [{ name, value }];
+  });
+  if (values.length === 0) {
+    return;
+  }
+  const distinctValues = Array.from(new Set(values.map((entry) => entry.value)));
+  if (distinctValues.length > 1) {
+    const seen = values.map((entry) => `${entry.name}=${entry.value}`).join(", ");
+    throw new Error(`Conflicting values for ${label}: ${seen}`);
+  }
+  return values[values.length - 1]?.value;
+}
 function hasFlag2(args, name) {
   return args.includes(name);
 }
@@ -74564,13 +74933,14 @@ 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 add telegram --account <id> (--token | --telegram-bot-token) <ENV_NAME|${ENV_NAME}|literal> [--persist]",
+    "  clisbot accounts add slack --account <id> (--app-token | --slack-app-token) <ENV_NAME|${ENV_NAME}|literal> (--bot-token | --slack-bot-token) <ENV_NAME|${ENV_NAME}|literal> [--persist]",
     "  clisbot accounts persist --channel <slack|telegram> --account <id>",
     "  clisbot accounts persist --all",
     "",
     "Notes:",
     "  - env-style input such as `TELEGRAM_BOT_TOKEN` or `${TELEGRAM_BOT_TOKEN}` keeps the account env-backed in config",
+    "  - `accounts add` accepts both the short account-local flags and the bootstrap-style channel flags",
     "  - 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"
@@ -74578,8 +74948,8 @@ function renderAccountsHelp() {
 `);
 }
 async function addTelegramAccount(args, deps) {
-  const accountId = parseOptionValue(args, "--account") ?? "default";
-  const token = parseTokenInput(parseOptionValue(args, "--token") ?? "");
+  const accountId = parseOptionValue2(args, "--account") ?? "default";
+  const token = parseTokenInput(parseAliasedOptionValue(args, ["--token", "--telegram-bot-token"], "telegram bot token") ?? "");
   const persist = hasFlag2(args, "--persist");
   const runtimeStatus = await deps.getRuntimeStatus();
   if (token.kind === "mem" && !persist && !runtimeStatus.running) {
@@ -74615,9 +74985,9 @@ async function addTelegramAccount(args, deps) {
   console.log(`config: ${configPath}`);
 }
 async function addSlackAccount(args, deps) {
-  const accountId = parseOptionValue(args, "--account") ?? "default";
-  const appToken = parseTokenInput(parseOptionValue(args, "--app-token") ?? "");
-  const botToken = parseTokenInput(parseOptionValue(args, "--bot-token") ?? "");
+  const accountId = parseOptionValue2(args, "--account") ?? "default";
+  const appToken = parseTokenInput(parseAliasedOptionValue(args, ["--app-token", "--slack-app-token"], "slack app token") ?? "");
+  const botToken = parseTokenInput(parseAliasedOptionValue(args, ["--bot-token", "--slack-bot-token"], "slack bot token") ?? "");
   const persist = hasFlag2(args, "--persist");
   const runtimeStatus = await deps.getRuntimeStatus();
   if (appToken.kind !== botToken.kind) {
@@ -74772,8 +75142,8 @@ async function runAccountsCli(args, deps = {}) {
       await persistAllConfiguredAccounts(resolvedDeps);
       return;
     }
-    const provider = parseOptionValue(args, "--channel");
-    const accountId = parseOptionValue(args, "--account") ?? "default";
+    const provider = parseOptionValue2(args, "--channel");
+    const accountId = parseOptionValue2(args, "--account") ?? "default";
     if (provider !== "slack" && provider !== "telegram") {
       throw new Error(renderAccountsHelp());
     }
@@ -75273,7 +75643,7 @@ function parseResponseModeTarget(channel, raw) {
   }
   return target;
 }
-function parseOptionValue2(args, name) {
+function parseOptionValue3(args, name) {
   const index = args.findIndex((arg) => arg === name);
   if (index === -1) {
     return;
@@ -75285,7 +75655,7 @@ function parseOptionValue2(args, name) {
   return value;
 }
 function parseBooleanOption(args, name, fallback) {
-  const raw = parseOptionValue2(args, name);
+  const raw = parseOptionValue3(args, name);
   if (!raw) {
     return fallback;
   }
@@ -75298,7 +75668,7 @@ function parseBooleanOption(args, name, fallback) {
   throw new Error(`${name} requires true or false`);
 }
 function getAgentId(args) {
-  return parseOptionValue2(args, "--agent") ?? "default";
+  return parseOptionValue3(args, "--agent") ?? "default";
 }
 async function setChannelEnabled(action, channel) {
   const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
@@ -75322,7 +75692,7 @@ async function addTelegramGroup(args) {
     throw new Error("Usage: clisbot channels add telegram-group <chatId> [--topic <topicId>] [--agent <id>] [--require-mention true|false]");
   }
   const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
-  const topicId = parseOptionValue2(args, "--topic");
+  const topicId = parseOptionValue3(args, "--topic");
   const agentId = getAgentId(args);
   const requireMention = parseBooleanOption(args, "--require-mention", true);
   const groupRoute = config.channels.telegram.groups[chatId] ?? {
@@ -75375,7 +75745,7 @@ async function removeTelegramGroup(args) {
     throw new Error("Usage: clisbot channels remove telegram-group <chatId> [--topic <topicId>]");
   }
   const { config, configPath } = await readEditableConfig(getEditableConfigPath7());
-  const topicId = parseOptionValue2(args, "--topic");
+  const topicId = parseOptionValue3(args, "--topic");
   const groupRoute = config.channels.telegram.groups[chatId];
   if (!groupRoute) {
     console.log(`telegram group route ${chatId} is not configured`);
@@ -75517,9 +75887,9 @@ async function runResponseModeCli(args) {
   }
   const responseMode = action === "set" ? parseResponseMode2(args[1]) : undefined;
   const optionArgs = action === "set" ? args.slice(2) : args.slice(1);
-  const channel = parseResponseModeChannel(parseOptionValue2(optionArgs, "--channel"));
-  const target = parseResponseModeTarget(channel, parseOptionValue2(optionArgs, "--target"));
-  const topic = parseOptionValue2(optionArgs, "--topic");
+  const channel = parseResponseModeChannel(parseOptionValue3(optionArgs, "--channel"));
+  const target = parseResponseModeTarget(channel, parseOptionValue3(optionArgs, "--target"));
+  const topic = parseOptionValue3(optionArgs, "--topic");
   if (channel === "slack" && topic) {
     throw new Error("Slack response-mode commands do not support --topic");
   }
@@ -75551,9 +75921,9 @@ async function runAdditionalMessageModeCli(args) {
   }
   const additionalMessageMode = action === "set" ? parseAdditionalMessageMode2(args[1]) : undefined;
   const optionArgs = action === "set" ? args.slice(2) : args.slice(1);
-  const channel = parseResponseModeChannel(parseOptionValue2(optionArgs, "--channel"));
-  const target = parseResponseModeTarget(channel, parseOptionValue2(optionArgs, "--target"));
-  const topic = parseOptionValue2(optionArgs, "--topic");
+  const channel = parseResponseModeChannel(parseOptionValue3(optionArgs, "--channel"));
+  const target = parseResponseModeTarget(channel, parseOptionValue3(optionArgs, "--target"));
+  const topic = parseOptionValue3(optionArgs, "--topic");
   if (channel === "slack" && topic) {
     throw new Error("Slack additional-message-mode commands do not support --topic");
   }
@@ -75843,7 +76213,7 @@ function parseRepeatedOption3(args, name) {
   }
   return values;
 }
-function parseOptionValue3(args, name) {
+function parseOptionValue4(args, name) {
   const values = parseRepeatedOption3(args, name);
   return values.length > 0 ? values.at(-1) : undefined;
 }
@@ -75856,7 +76226,7 @@ function parseMessageBodyFileOption(args) {
   return bodyFileValues.at(-1) ?? messageFileValues.at(-1);
 }
 function parseIntegerOption(args, name) {
-  const raw = parseOptionValue3(args, name);
+  const raw = parseOptionValue4(args, name);
   if (!raw) {
     return;
   }
@@ -75885,34 +76255,34 @@ function parseMessageCommand(args) {
   }
   const action = rawAction;
   const rest = args.slice(1);
-  const channel = parseOptionValue3(rest, "--channel");
+  const channel = parseOptionValue4(rest, "--channel");
   if (channel !== "slack" && channel !== "telegram") {
     throw new Error("--channel <slack|telegram> is required");
   }
   return {
     action,
     channel,
-    account: parseOptionValue3(rest, "--account"),
-    target: parseOptionValue3(rest, "--target"),
-    message: parseOptionValue3(rest, "--message") ?? parseOptionValue3(rest, "-m"),
+    account: parseOptionValue4(rest, "--account"),
+    target: parseOptionValue4(rest, "--target"),
+    message: parseOptionValue4(rest, "--message") ?? parseOptionValue4(rest, "-m"),
     messageFile: parseMessageBodyFileOption(rest),
-    media: parseOptionValue3(rest, "--media"),
-    messageId: parseOptionValue3(rest, "--message-id"),
-    emoji: parseOptionValue3(rest, "--emoji"),
+    media: parseOptionValue4(rest, "--media"),
+    messageId: parseOptionValue4(rest, "--message-id"),
+    emoji: parseOptionValue4(rest, "--emoji"),
     remove: hasFlag4(rest, "--remove"),
-    threadId: parseOptionValue3(rest, "--thread-id"),
-    replyTo: parseOptionValue3(rest, "--reply-to"),
+    threadId: parseOptionValue4(rest, "--thread-id"),
+    replyTo: parseOptionValue4(rest, "--reply-to"),
     limit: parseIntegerOption(rest, "--limit"),
-    query: parseOptionValue3(rest, "--query"),
-    pollQuestion: parseOptionValue3(rest, "--poll-question"),
+    query: parseOptionValue4(rest, "--query"),
+    pollQuestion: parseOptionValue4(rest, "--poll-question"),
     pollOptions: parseRepeatedOption3(rest, "--poll-option"),
     forceDocument: hasFlag4(rest, "--force-document"),
     silent: hasFlag4(rest, "--silent"),
     progress: hasFlag4(rest, "--progress"),
     final: hasFlag4(rest, "--final"),
     json: hasFlag4(rest, "--json"),
-    inputFormat: parseMessageInputFormat(parseOptionValue3(rest, "--input")),
-    renderMode: parseMessageRenderMode(parseOptionValue3(rest, "--render"))
+    inputFormat: parseMessageInputFormat(parseOptionValue4(rest, "--input")),
+    renderMode: parseMessageRenderMode(parseOptionValue4(rest, "--render"))
   };
 }
 function renderMessageHelp() {
@@ -76017,160 +76387,214 @@ async function runMessageCli(args, dependencies = defaultMessageCliDependencies)
   dependencies.print(JSON.stringify(execution.result, null, 2));
 }
 
-// src/control/channel-bootstrap-flags.ts
-function isLiteralToken(token) {
-  return token?.kind === "mem";
+// src/control/runtime-cli-shared.ts
+class CliCommandError extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+  }
 }
-function parseBotType(rawValue) {
-  const value = rawValue.trim().toLowerCase();
-  if (value === "personal" || value === "personal-assistant") {
-    return "personal-assistant";
+function printCommandOutcomeBanner(outcome) {
+  console.log("");
+  console.log("+---------+");
+  console.log(outcome === "success" ? "| SUCCESS |" : "| FAILED  |");
+  console.log("+---------+");
+  console.log("");
+}
+function printCommandOutcomeFooter(outcome) {
+  printCommandOutcomeBanner(outcome);
+}
+function assertSupportedPlatform(command) {
+  if (process.platform !== "win32") {
+    return;
   }
-  if (value === "team" || value === "team-assistant") {
-    return "team-assistant";
+  if (command.name === "help" || command.name === "version") {
+    return;
   }
-  throw new Error(`Invalid bot type: ${rawValue}`);
+  throw new Error("Native Windows is not supported yet. Run clisbot from WSL2 or use Linux/macOS instead.");
 }
-function parseOptionValue4(args, name, index) {
-  const value = args[index + 1]?.trim();
-  if (!value) {
-    throw new Error(`Missing value for ${name}`);
-  }
-  return value;
+function getCliErrorExitCode(error) {
+  return error instanceof CliCommandError ? error.exitCode : 1;
 }
-function getOrCreateSlackAccount(accounts, accountId) {
-  let account = accounts.find((entry) => entry.accountId === accountId);
-  if (!account) {
-    account = { accountId };
-    accounts.push(account);
+
+// src/control/runner-cli.ts
+var SMOKE_BACKENDS = ["codex", "claude", "gemini", "all"];
+var SMOKE_SCENARIOS = [
+  "startup_ready",
+  "first_prompt_roundtrip",
+  "session_id_roundtrip",
+  "interrupt_during_run",
+  "recover_after_runner_loss"
+];
+var SMOKE_SUITES = ["launch-trio"];
+function parseRepeatedOption4(args, name) {
+  const values = [];
+  for (let index = 0;index < args.length; index += 1) {
+    if (args[index] !== name) {
+      continue;
+    }
+    const value = args[index + 1]?.trim();
+    if (!value) {
+      throw new CliCommandError(`Missing value for ${name}`, 2);
+    }
+    values.push(value);
   }
-  return account;
+  return values;
 }
-function getOrCreateTelegramAccount(accounts, accountId) {
-  let account = accounts.find((entry) => entry.accountId === accountId);
-  if (!account) {
-    account = { accountId };
-    accounts.push(account);
+function parseSingleOption3(args, name) {
+  const values = parseRepeatedOption4(args, name);
+  if (values.length === 0) {
+    return;
   }
-  return account;
+  return values[values.length - 1];
 }
-function ensureUniqueAccount(accounts, accountId, flagName) {
-  if (accounts.some((entry) => entry.accountId === accountId)) {
-    throw new Error(`Duplicate ${flagName} ${accountId}`);
-  }
+function hasFlag5(args, name) {
+  return args.includes(name);
 }
-function validateSlackAccount(account) {
-  if (!account.appToken || !account.botToken) {
-    throw new Error(`Slack account ${account.accountId} requires both app token and bot token`);
+function isOneOf(value, allowed) {
+  return allowed.includes(value);
+}
+function parseTimeoutMs(raw) {
+  if (!raw) {
+    return;
   }
-  if (account.appToken.kind !== account.botToken.kind) {
-    throw new Error(`Slack account ${account.accountId} must use one credential source kind for both app and bot tokens`);
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliCommandError("Invalid value for --timeout-ms", 2);
   }
+  return parsed;
 }
-function validateTelegramAccount(account) {
-  if (!account.botToken) {
-    throw new Error(`Telegram account ${account.accountId} requires a bot token`);
-  }
+function renderRunnerHelp() {
+  return [
+    "clisbot runner",
+    "",
+    "Usage:",
+    "  clisbot runner",
+    "  clisbot runner --help",
+    "  clisbot runner smoke --backend <codex|claude|gemini> --scenario <name> [--workspace <path>] [--agent <id>] [--artifact-dir <path>] [--timeout-ms <n>] [--keep-session] [--json]",
+    "  clisbot runner smoke --backend all --suite launch-trio [--workspace <path>] [--agent <id>] [--artifact-dir <path>] [--timeout-ms <n>] [--keep-session] [--json]",
+    "",
+    "Smoke scenarios:",
+    "  - startup_ready",
+    "  - first_prompt_roundtrip",
+    "  - session_id_roundtrip",
+    "  - interrupt_during_run",
+    "  - recover_after_runner_loss",
+    "",
+    "Smoke suites:",
+    "  - launch-trio",
+    "",
+    "Current status:",
+    "  - the `runner` CLI surface now validates the smoke command contract",
+    "  - real smoke execution is the next implementation batch"
+  ].join(`
+`);
 }
-function parseBootstrapFlags(args) {
-  const slackAccounts = [];
-  const telegramAccounts = [];
-  let currentSlackAccountId;
-  let currentTelegramAccountId;
-  let cliTool;
-  let bootstrap;
-  let persist = false;
-  let sawCredentialFlags = false;
-  let sawSlackFlags = false;
-  let sawTelegramFlags = false;
-  for (let index = 0;index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--cli") {
-      cliTool = parseOptionValue4(args, arg, index);
-      index += 1;
-      continue;
-    }
-    if (arg === "--bootstrap") {
-      bootstrap = parseBotType(parseOptionValue4(args, arg, index));
-      index += 1;
-      continue;
-    }
-    if (arg === "--bot-type") {
-      bootstrap = parseBotType(parseOptionValue4(args, arg, index));
-      index += 1;
-      continue;
-    }
-    if (arg === "--persist") {
-      persist = true;
-      continue;
-    }
-    if (arg === "--slack-account") {
-      const accountId = parseOptionValue4(args, arg, index);
-      ensureUniqueAccount(slackAccounts, accountId, "--slack-account");
-      currentSlackAccountId = accountId;
-      getOrCreateSlackAccount(slackAccounts, accountId);
-      sawSlackFlags = true;
-      index += 1;
-      continue;
+function parseSmokeCommand(args) {
+  const backend = parseSingleOption3(args, "--backend");
+  if (!backend) {
+    throw new CliCommandError(`Usage: clisbot runner smoke --backend <codex|claude|gemini> --scenario <name> [--json]
+       clisbot runner smoke --backend all --suite launch-trio [--json]`, 2);
+  }
+  if (!isOneOf(backend, SMOKE_BACKENDS)) {
+    throw new CliCommandError(`Unsupported --backend value: ${backend}`, 2);
+  }
+  const rawScenario = parseSingleOption3(args, "--scenario");
+  const rawSuite = parseSingleOption3(args, "--suite");
+  if (rawScenario && rawSuite) {
+    throw new CliCommandError("--scenario and --suite are mutually exclusive", 2);
+  }
+  if (rawScenario && !isOneOf(rawScenario, SMOKE_SCENARIOS)) {
+    throw new CliCommandError(`Unsupported --scenario value: ${rawScenario}`, 2);
+  }
+  if (rawSuite && !isOneOf(rawSuite, SMOKE_SUITES)) {
+    throw new CliCommandError(`Unsupported --suite value: ${rawSuite}`, 2);
+  }
+  const scenario = rawScenario;
+  const suite = rawSuite;
+  if (backend === "all") {
+    if (scenario) {
+      throw new CliCommandError("--backend all is only valid with --suite", 2);
     }
-    if (arg === "--telegram-account") {
-      const accountId = parseOptionValue4(args, arg, index);
-      ensureUniqueAccount(telegramAccounts, accountId, "--telegram-account");
-      currentTelegramAccountId = accountId;
-      getOrCreateTelegramAccount(telegramAccounts, accountId);
-      sawTelegramFlags = true;
-      index += 1;
-      continue;
+    if (!suite) {
+      throw new CliCommandError("--backend all requires --suite launch-trio", 2);
     }
-    if (arg === "--slack-app-token") {
-      const token = parseTokenInput(parseOptionValue4(args, arg, index));
-      const account = getOrCreateSlackAccount(slackAccounts, currentSlackAccountId ?? "default");
-      account.appToken = token;
-      sawCredentialFlags = true;
-      sawSlackFlags = true;
-      index += 1;
-      continue;
+  } else {
+    if (suite) {
+      throw new CliCommandError(`--suite is only valid with --backend all`, 2);
     }
-    if (arg === "--slack-bot-token") {
-      const token = parseTokenInput(parseOptionValue4(args, arg, index));
-      const account = getOrCreateSlackAccount(slackAccounts, currentSlackAccountId ?? "default");
-      account.botToken = token;
-      sawCredentialFlags = true;
-      sawSlackFlags = true;
-      index += 1;
-      continue;
+    if (!scenario) {
+      throw new CliCommandError(`--backend ${backend} requires --scenario`, 2);
     }
-    if (arg === "--telegram-bot-token") {
-      const token = parseTokenInput(parseOptionValue4(args, arg, index));
-      const account = getOrCreateTelegramAccount(telegramAccounts, currentTelegramAccountId ?? "default");
-      account.botToken = token;
-      sawCredentialFlags = true;
-      sawTelegramFlags = true;
-      index += 1;
-      continue;
-    }
-    throw new Error(`Unknown option for start/init: ${arg}`);
   }
-  for (const account of slackAccounts) {
-    validateSlackAccount(account);
+  return {
+    backend,
+    scenario,
+    suite,
+    workspace: parseSingleOption3(args, "--workspace"),
+    agent: parseSingleOption3(args, "--agent"),
+    artifactDir: parseSingleOption3(args, "--artifact-dir"),
+    timeoutMs: parseTimeoutMs(parseSingleOption3(args, "--timeout-ms")),
+    keepSession: hasFlag5(args, "--keep-session"),
+    json: hasFlag5(args, "--json")
+  };
+}
+function renderSmokeNotImplementedResult(options) {
+  return {
+    kind: "runner-smoke-framework-error",
+    version: "v0",
+    ok: false,
+    backendId: options.backend,
+    scenario: options.scenario ?? null,
+    suite: options.suite ?? null,
+    error: {
+      code: "NOT_IMPLEMENTED",
+      message: "clisbot runner smoke is not implemented yet. The command surface and contract validation are ready; the real execution batch is next."
+    },
+    options: {
+      workspace: options.workspace ?? null,
+      agent: options.agent ?? null,
+      artifactDir: options.artifactDir ?? null,
+      timeoutMs: options.timeoutMs ?? null,
+      keepSession: options.keepSession,
+      json: options.json
+    }
+  };
+}
+async function runSmokeCli(args) {
+  if (args.length === 0 || hasFlag5(args, "--help") || hasFlag5(args, "-h")) {
+    console.log(renderRunnerHelp());
+    return;
   }
-  for (const account of telegramAccounts) {
-    validateTelegramAccount(account);
+  const options = parseSmokeCommand(args);
+  const result = renderSmokeNotImplementedResult(options);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log([
+      "clisbot runner smoke",
+      "",
+      `backend: ${options.backend}`,
+      options.scenario ? `scenario: ${options.scenario}` : `suite: ${options.suite}`,
+      "status: not implemented yet",
+      "note: the smoke contract is validated, but real CLI execution is the next batch"
+    ].join(`
+`));
   }
-  return {
-    cliTool,
-    bootstrap,
-    persist,
-    slackAccounts,
-    telegramAccounts,
-    sawCredentialFlags,
-    sawSlackFlags,
-    sawTelegramFlags,
-    literalWarnings: []
-  };
+  process.exitCode = 3;
 }
-function hasLiteralBootstrapCredentials(flags) {
-  return flags.slackAccounts.some((account) => isLiteralToken(account.appToken) || isLiteralToken(account.botToken)) || flags.telegramAccounts.some((account) => isLiteralToken(account.botToken));
+async function runRunnerCli(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+    console.log(renderRunnerHelp());
+    return;
+  }
+  if (subcommand === "smoke") {
+    await runSmokeCli(args.slice(1));
+    return;
+  }
+  throw new CliCommandError(renderRunnerHelp(), 2);
 }
 
 // src/control/activity-store.ts
@@ -76413,10 +76837,11 @@ function appendBootstrapGuidance(lines, summary) {
   lines.push("");
   lines.push("Guidance:");
   for (const agent of pendingBootstrap) {
+    const botType = agent.bootstrapMode === "team-assistant" ? "team" : "personal";
     if (agent.bootstrapState === "missing") {
       lines.push(`  Agent ${agent.id} is missing bootstrap files.`);
       lines.push(`    workspace: ${agent.workspacePath}`);
-      lines.push(`    run: clisbot agents bootstrap ${agent.id} --mode ${agent.bootstrapMode}`);
+      lines.push(`    run: clisbot agents bootstrap ${agent.id} --bot-type ${botType}`);
       continue;
     }
     lines.push(`  Agent ${agent.id} still needs bootstrap completion.`);
@@ -76707,27 +77132,6 @@ function renderOperatorErrorWithHelpLines(error) {
   ];
 }
 
-// src/control/runtime-cli-shared.ts
-function printCommandOutcomeBanner(outcome) {
-  console.log("");
-  console.log("+---------+");
-  console.log(outcome === "success" ? "| SUCCESS |" : "| FAILED  |");
-  console.log("+---------+");
-  console.log("");
-}
-function printCommandOutcomeFooter(outcome) {
-  printCommandOutcomeBanner(outcome);
-}
-function assertSupportedPlatform(command) {
-  if (process.platform !== "win32") {
-    return;
-  }
-  if (command.name === "help" || command.name === "version") {
-    return;
-  }
-  throw new Error("Native Windows is not supported yet. Run clisbot from WSL2 or use Linux/macOS instead.");
-}
-
 // src/control/runtime-bootstrap-cli.ts
 function hasHelpFlag(args) {
   return args.includes("--help") || args.includes("-h") || args.includes("help");
@@ -77817,6 +78221,10 @@ async function runControlCommand(command) {
     await runAuthCli(command.args);
     return true;
   }
+  if (command.name === "runner") {
+    await runRunnerCli(command.args);
+    return true;
+  }
   if (command.name === "pairing") {
     await runPairingCli(command.args);
     return true;
@@ -77838,5 +78246,5 @@ try {
     printCommandOutcomeBanner("failure");
   }
   await printCliError(error);
-  process.exit(1);
+  process.exit(getCliErrorExitCode(error));
 }