clisbot 0.1.32 → 0.1.36

package/config/clisbot.json.template

@@ -97,6 +97,8 @@
         ],
         "trustWorkspace": true,
         "startupDelayMs": 3000,
+        "startupRetryCount": 2,
+        "startupRetryDelayMs": 1000,
         "promptSubmitDelayMs": 150,
         "sessionId": {
           "create": {

package/dist/main.js

@@ -54713,8 +54713,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.",
@@ -55261,6 +55261,8 @@ var DEFAULT_AGENT_TOOL_TEMPLATES = {
     ],
     trustWorkspace: true,
     startupDelayMs: 3000,
+    startupRetryCount: 2,
+    startupRetryDelayMs: 1000,
     promptSubmitDelayMs: 150,
     sessionId: {
       create: {
@@ -55292,6 +55294,8 @@ var DEFAULT_AGENT_TOOL_TEMPLATES = {
     startupOptions: ["--dangerously-skip-permissions"],
     trustWorkspace: true,
     startupDelayMs: 3000,
+    startupRetryCount: 2,
+    startupRetryDelayMs: 1000,
     promptSubmitDelayMs: 150,
     sessionId: {
       create: {
@@ -55320,6 +55324,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 +55365,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 +55391,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 +60057,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 +60095,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 +60139,8 @@ var agentDefaultsSchema = exports_external.object({
     ],
     trustWorkspace: true,
     startupDelayMs: 3000,
+    startupRetryCount: 2,
+    startupRetryDelayMs: 1000,
     promptSubmitDelayMs: 150,
     sessionId: defaultRunnerSessionIdConfig
   }),
@@ -60789,6 +60805,8 @@ function renderDefaultConfigTemplate(options = {}) {
           ],
           trustWorkspace: true,
           startupDelayMs: 3000,
+          startupRetryCount: 2,
+          startupRetryDelayMs: 1000,
           startupReadyPattern: undefined,
           promptSubmitDelayMs: 150,
           sessionId: {
@@ -61148,6 +61166,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 +61363,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 +61541,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 +61555,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 +61580,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");
+  }
+  if (hasFlag(args, "--bootstrap")) {
+    throw new Error("agents bootstrap does not use --bootstrap; 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");
+  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);
@@ -64959,6 +65142,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 +65183,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 +65205,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 +65383,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 +65400,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 +65730,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 +65835,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 +65908,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 +65919,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 +65974,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(() => "") : "");
       }
@@ -66262,6 +66483,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()];
@@ -66706,7 +66950,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);
@@ -74523,7 +74767,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 +74778,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 +74823,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 +74838,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 +74875,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 +75032,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 +75533,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 +75545,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 +75558,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 +75582,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 +75635,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 +75777,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 +75811,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 +76103,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 +76116,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 +76145,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,162 +76277,6 @@ 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";
-}
-function parseBotType(rawValue) {
-  const value = rawValue.trim().toLowerCase();
-  if (value === "personal" || value === "personal-assistant") {
-    return "personal-assistant";
-  }
-  if (value === "team" || value === "team-assistant") {
-    return "team-assistant";
-  }
-  throw new Error(`Invalid bot type: ${rawValue}`);
-}
-function parseOptionValue4(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 = 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;
-    }
-    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 (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;
-    }
-    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 (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);
-  }
-  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/activity-store.ts
 import { dirname as dirname14 } from "node:path";
 class ActivityStore {
@@ -76413,10 +76517,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.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clisbot",
-  "version": "0.1.32",
+  "version": "0.1.36",
   "private": false,
   "description": "Chat surfaces for durable AI coding agents running in tmux",
   "license": "MIT",