clisbot 0.1.46-beta.0 → 0.1.50

package/dist/main.js

@@ -32451,7 +32451,7 @@ var require_websocket = __commonJS((exports, module) => {
   var http = __require("http");
   var net = __require("net");
   var tls = __require("tls");
-  var { randomBytes, createHash } = __require("crypto");
+  var { randomBytes, createHash: createHash2 } = __require("crypto");
   var { Duplex, Readable } = __require("stream");
   var { URL: URL2 } = __require("url");
   var PerMessageDeflate = require_permessage_deflate();
@@ -32990,7 +32990,7 @@ var require_websocket = __commonJS((exports, module) => {
         abortHandshake(websocket, socket, "Invalid Upgrade header");
         return;
       }
-      const digest = createHash("sha1").update(key + GUID).digest("base64");
+      const digest = createHash2("sha1").update(key + GUID).digest("base64");
       if (res.headers["sec-websocket-accept"] !== digest) {
         abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
         return;
@@ -33363,7 +33363,7 @@ var require_websocket_server = __commonJS((exports, module) => {
   var EventEmitter = __require("events");
   var http = __require("http");
   var { Duplex } = __require("stream");
-  var { createHash } = __require("crypto");
+  var { createHash: createHash2 } = __require("crypto");
   var extension = require_extension();
   var PerMessageDeflate = require_permessage_deflate();
   var subprotocol = require_subprotocol();
@@ -33576,7 +33576,7 @@ var require_websocket_server = __commonJS((exports, module) => {
       }
       if (this._state > RUNNING)
         return abortHandshake(socket, 503);
-      const digest = createHash("sha1").update(key + GUID).digest("base64");
+      const digest = createHash2("sha1").update(key + GUID).digest("base64");
       const headers = [
         "HTTP/1.1 101 Switching Protocols",
         "Upgrade: websocket",
@@ -54755,6 +54755,11 @@ function renderCliHelp() {
     "  personal  One human gets one dedicated long-lived assistant workspace and session path.",
     "  team      One shared channel or group routes into one shared assistant workspace and session path.",
     "",
+    "Bootstrap files:",
+    "  `--bot-type` seeds workspace guidance files for a fresh agent. It is optional when you already have a workspace.",
+    "  Canonical workspace instructions live in `AGENTS.md`.",
+    "  Claude and Gemini bootstraps also add `CLAUDE.md` or `GEMINI.md` as symlinks to `AGENTS.md` for CLI discovery.",
+    "",
     "Credential input rules:",
     "  Pass ENV_NAME or ${ENV_NAME} to keep the selected bot env-backed.",
     "  Pass a raw or shell-expanded token value to use credentialType=mem for the current runtime only.",
@@ -54803,7 +54808,7 @@ function renderCliHelp() {
     "  status             Show runtime process, config, log, tmux socket status, and recent runner sessions.",
     "  version            Show the installed clisbot version.",
     "  logs               Print the most recent clisbot log lines.",
-    "  update             Print the AI-readable package update guide and release/migration doc links.",
+    "  update             Print the update guide and release/migration doc links.",
     `                     See ${renderCliCommand("update --help", { inline: true })} before asking an agent to update clisbot.`,
     "  timezone           Manage the app-wide wall-clock timezone used by schedules and loops.",
     `                     See ${renderCliCommand("timezone --help", { inline: true })} for override guidance.`,
@@ -58902,10 +58907,12 @@ function parseCommandDurationMs(raw) {
 // src/agents/loop-command.ts
 var DEFAULT_LOOP_MAX_TIMES = 50;
 var LOOP_FORCE_FLAG = "--force";
+var LOOP_START_FLAG = "--loop-start";
 var LOOP_ALL_FLAG = "--all";
 var LOOP_APP_FLAG = "--app";
 var MIN_LOOP_INTERVAL_MS = 60000;
 var FORCE_LOOP_INTERVAL_MS = 5 * 60000;
+var LOOP_START_MODES = ["none", "brief", "full"];
 var LOOP_WEEKDAY_LABELS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
 var LOOP_WEEKDAY_ALIASES = {
   sun: 0,
@@ -58934,7 +58941,12 @@ function parseLoopSlashCommand(raw) {
       error: "Loop requires an interval, count, or schedule. Try `/loop 5m check CI`, `/loop 3 check CI`, `/loop every day at 07:00 check CI`, or `/loop 3` for maintenance mode."
     };
   }
-  const tokens = trimmed.split(/\s+/).filter(Boolean);
+  const modifier = extractLoopStartModifier(trimmed);
+  if ("error" in modifier) {
+    return modifier;
+  }
+  const normalizedText = modifier.normalizedText;
+  const tokens = modifier.normalizedText.split(/\s+/).filter(Boolean);
   const forceTokenIndexes = tokens.map((token, index) => token.toLowerCase() === LOOP_FORCE_FLAG ? index : -1).filter((index) => index >= 0);
   if (forceTokenIndexes.length > 1) {
     return {
@@ -58943,7 +58955,7 @@ function parseLoopSlashCommand(raw) {
   }
   const forceTokenIndex = forceTokenIndexes[0];
   const leadingToken = tokens[0] ?? "";
-  const everyDayMatch = trimmed.match(/^every\s+day\s+at\s+(\S+)(?:\s+(.*))?$/i);
+  const everyDayMatch = normalizedText.match(/^every\s+day\s+at\s+(\S+)(?:\s+(.*))?$/i);
   if (everyDayMatch) {
     if (forceTokenIndex !== undefined) {
       return {
@@ -58956,7 +58968,7 @@ function parseLoopSlashCommand(raw) {
         error: "Loop wall-clock time must use `HH:MM` in 24-hour format."
       };
     }
-    return {
+    const parsed = {
       mode: "calendar",
       cadence: "daily",
       localTime: parsedTime.localTime,
@@ -58966,8 +58978,18 @@ function parseLoopSlashCommand(raw) {
       force: false,
       syntax: "calendar-at"
     };
+    const validationError = validateLoopStartModifierPlacement(parsed, modifier, modifier.tokens.length);
+    if (validationError) {
+      return {
+        error: validationError
+      };
+    }
+    return {
+      ...parsed,
+      ...modifier.loopStart ? { loopStart: modifier.loopStart } : {}
+    };
   }
-  const everyWeekdayMatch = trimmed.match(/^every\s+weekday\s+at\s+(\S+)(?:\s+(.*))?$/i);
+  const everyWeekdayMatch = normalizedText.match(/^every\s+weekday\s+at\s+(\S+)(?:\s+(.*))?$/i);
   if (everyWeekdayMatch) {
     if (forceTokenIndex !== undefined) {
       return {
@@ -58980,7 +59002,7 @@ function parseLoopSlashCommand(raw) {
         error: "Loop wall-clock time must use `HH:MM` in 24-hour format."
       };
     }
-    return {
+    const parsed = {
       mode: "calendar",
       cadence: "weekday",
       localTime: parsedTime.localTime,
@@ -58990,8 +59012,18 @@ function parseLoopSlashCommand(raw) {
       force: false,
       syntax: "calendar-at"
     };
+    const validationError = validateLoopStartModifierPlacement(parsed, modifier, modifier.tokens.length);
+    if (validationError) {
+      return {
+        error: validationError
+      };
+    }
+    return {
+      ...parsed,
+      ...modifier.loopStart ? { loopStart: modifier.loopStart } : {}
+    };
   }
-  const everyDayOfWeekMatch = trimmed.match(/^every\s+([a-z]+)\s+at\s+(\S+)(?:\s+(.*))?$/i);
+  const everyDayOfWeekMatch = normalizedText.match(/^every\s+([a-z]+)\s+at\s+(\S+)(?:\s+(.*))?$/i);
   if (everyDayOfWeekMatch) {
     const dayOfWeek = resolveLoopDayOfWeek(everyDayOfWeekMatch[1] ?? "");
     if (dayOfWeek != null) {
@@ -59006,7 +59038,7 @@ function parseLoopSlashCommand(raw) {
           error: "Loop wall-clock time must use `HH:MM` in 24-hour format."
         };
       }
-      return {
+      const parsed = {
         mode: "calendar",
         cadence: "day-of-week",
         dayOfWeek,
@@ -59017,6 +59049,16 @@ function parseLoopSlashCommand(raw) {
         force: false,
         syntax: "calendar-at"
       };
+      const validationError = validateLoopStartModifierPlacement(parsed, modifier, modifier.tokens.length);
+      if (validationError) {
+        return {
+          error: validationError
+        };
+      }
+      return {
+        ...parsed,
+        ...modifier.loopStart ? { loopStart: modifier.loopStart } : {}
+      };
     }
   }
   const leadingIntervalMs = parseCommandDurationMs(leadingToken);
@@ -59028,15 +59070,30 @@ function parseLoopSlashCommand(raw) {
     }
     const promptTokens = tokens.slice(forceTokenIndex === 1 ? 2 : 1);
     const promptText = promptTokens.join(" ").trim() || undefined;
-    return {
+    const parsed = {
       mode: "interval",
       intervalMs: leadingIntervalMs,
       promptText,
       force: forceTokenIndex === 1,
       syntax: "leading-interval"
     };
+    const validationError = validateLoopStartModifierPlacement(parsed, modifier, modifier.tokens.length);
+    if (validationError) {
+      return {
+        error: validationError
+      };
+    }
+    return {
+      ...parsed,
+      ...modifier.loopStart ? { loopStart: modifier.loopStart } : {}
+    };
   }
   if (/^-?\d+$/.test(leadingToken)) {
+    if (modifier.loopStart) {
+      return {
+        error: `\`${LOOP_START_FLAG}\` is only supported for recurring interval and wall-clock loops.`
+      };
+    }
     if (forceTokenIndex !== undefined) {
       return {
         error: `\`${LOOP_FORCE_FLAG}\` is only supported for interval loops.`
@@ -59057,8 +59114,13 @@ function parseLoopSlashCommand(raw) {
       syntax: "leading-count"
     };
   }
-  const trailingTimes = trimmed.match(/^(.*?)(?:\s+)?(-?\d+)\s+times$/i);
+  const trailingTimes = normalizedText.match(/^(.*?)(?:\s+)?(-?\d+)\s+times$/i);
   if (trailingTimes) {
+    if (modifier.loopStart) {
+      return {
+        error: `\`${LOOP_START_FLAG}\` is only supported for recurring interval and wall-clock loops.`
+      };
+    }
     if (forceTokenIndex !== undefined) {
       return {
         error: `\`${LOOP_FORCE_FLAG}\` is only supported for interval loops.`
@@ -59079,7 +59141,7 @@ function parseLoopSlashCommand(raw) {
       syntax: "trailing-times"
     };
   }
-  const withoutTrailingForce = forceTokenIndex === tokens.length - 1 ? tokens.slice(0, -1).join(" ") : trimmed;
+  const withoutTrailingForce = forceTokenIndex === tokens.length - 1 ? tokens.slice(0, -1).join(" ") : normalizedText;
   const normalizedEveryInput = withoutTrailingForce.trim();
   const hasTrailingForce = forceTokenIndex === tokens.length - 1;
   if (forceTokenIndex !== undefined && !hasTrailingForce) {
@@ -59096,13 +59158,23 @@ function parseLoopSlashCommand(raw) {
       };
     }
     const promptText = everyCompactClause[1]?.trim() || undefined;
-    return {
+    const parsed = {
       mode: "interval",
       intervalMs,
       promptText,
       force: hasTrailingForce,
       syntax: "every-clause"
     };
+    const validationError = validateLoopStartModifierPlacement(parsed, modifier, modifier.tokens.length);
+    if (validationError) {
+      return {
+        error: validationError
+      };
+    }
+    return {
+      ...parsed,
+      ...modifier.loopStart ? { loopStart: modifier.loopStart } : {}
+    };
   }
   const everyClause = normalizedEveryInput.match(/^(.*?)(?:\s+)?every\s+(-?\d+)\s+([a-z]+)$/i);
   if (everyClause) {
@@ -59120,18 +59192,84 @@ function parseLoopSlashCommand(raw) {
       };
     }
     const promptText = everyClause[1]?.trim() || undefined;
-    return {
+    const parsed = {
       mode: "interval",
       intervalMs,
       promptText,
       force: hasTrailingForce,
       syntax: "every-clause"
     };
+    const validationError = validateLoopStartModifierPlacement(parsed, modifier, modifier.tokens.length);
+    if (validationError) {
+      return {
+        error: validationError
+      };
+    }
+    return {
+      ...parsed,
+      ...modifier.loopStart ? { loopStart: modifier.loopStart } : {}
+    };
   }
   return {
     error: "Loop requires an interval, count, or schedule. Try `/loop 5m check CI`, `/loop 3 check CI`, `/loop every day at 07:00 check CI`, or `/loop 3` for maintenance mode."
   };
 }
+function extractLoopStartModifier(raw) {
+  const tokens = raw.split(/\s+/).filter(Boolean);
+  const indexes = tokens.map((token, index) => token.trim().toLowerCase() === LOOP_START_FLAG ? index : -1).filter((index) => index >= 0);
+  if (indexes.length > 1) {
+    return {
+      error: `Loop accepts at most one \`${LOOP_START_FLAG}\` flag.`
+    };
+  }
+  const flagIndex = indexes[0];
+  if (flagIndex == null) {
+    return {
+      normalizedText: raw,
+      tokens
+    };
+  }
+  const rawMode = tokens[flagIndex + 1]?.trim().toLowerCase();
+  if (!rawMode) {
+    return {
+      error: `Loop requires \`${LOOP_START_FLAG} <none|brief|full>\`.`
+    };
+  }
+  if (!LOOP_START_MODES.includes(rawMode)) {
+    return {
+      error: `\`${LOOP_START_FLAG}\` must be one of \`none\`, \`brief\`, or \`full\`.`
+    };
+  }
+  const strippedTokens = tokens.filter((_, index) => index !== flagIndex && index !== flagIndex + 1);
+  return {
+    normalizedText: strippedTokens.join(" "),
+    tokens,
+    flagIndex,
+    loopStart: rawMode
+  };
+}
+function validateLoopStartModifierPlacement(parsed, modifier, tokenCount) {
+  if (!modifier.loopStart || modifier.flagIndex == null) {
+    return;
+  }
+  if (parsed.mode === "calendar") {
+    if (modifier.flagIndex === 4) {
+      return;
+    }
+    return `For wall-clock loops, \`${LOOP_START_FLAG}\` must appear immediately after the \`at HH:MM\` clause, for example \`/loop every day at 07:00 --loop-start none morning brief\`.`;
+  }
+  if (parsed.syntax === "leading-interval") {
+    const expectedIndex = parsed.force ? 2 : 1;
+    if (modifier.flagIndex === expectedIndex) {
+      return;
+    }
+    return `For leading interval loops, \`${LOOP_START_FLAG}\` must appear after the interval and optional \`${LOOP_FORCE_FLAG}\`, before the prompt, for example \`/loop 5m --loop-start none check CI\`.`;
+  }
+  if (modifier.flagIndex === tokenCount - 2) {
+    return;
+  }
+  return `For \`every ...\` interval loops, \`${LOOP_START_FLAG}\` must appear at the end of the loop schedule, for example \`/loop check deploy every 2h --loop-start none\`.`;
+}
 function formatLoopIntervalShort(intervalMs) {
   if (intervalMs % (60 * 60000) === 0) {
     return `${intervalMs / (60 * 60000)}h`;
@@ -59161,7 +59299,8 @@ function renderLoopHelpLines() {
     "- `/loop /codereview 3 times`: run the slash command 3 times",
     "- `/loop status`: show active loops for this session",
     `- \`/loop cancel\`, \`/loop cancel <id>\`, \`/loop cancel --all\`, \`/loop cancel --all ${LOOP_APP_FLAG}\`: cancel active loops`,
-    `- intervals must be at least \`1m\`; intervals below \`5m\` require \`${LOOP_FORCE_FLAG}\` right after the interval clause; wall-clock schedules use \`every ... at HH:MM\`; the first wall-clock loop created with \`clisbot loops create\` requires \`--confirm\`; timezone resolves from route/topic, agent, bot, app timezone, then legacy defaults and host; bare numbers mean times, compact durations such as \`5m\` mean intervals, and the historical default loop cap was \`${DEFAULT_LOOP_MAX_TIMES}\``
+    `- intervals must be at least \`1m\`; intervals below \`5m\` require \`${LOOP_FORCE_FLAG}\` right after the interval clause; wall-clock schedules use \`every ... at HH:MM\`; the first wall-clock loop created with \`clisbot loops create\` requires \`--confirm\`; timezone resolves from route/topic, agent, bot, app timezone, then legacy defaults and host; bare numbers mean times, compact durations such as \`5m\` mean intervals, and the historical default loop cap was \`${DEFAULT_LOOP_MAX_TIMES}\``,
+    `- Advanced: loop creation also accepts \`${LOOP_START_FLAG} <none|brief|full>\` to override the default start notification behavior for that loop. Example: \`/loop every day at 07:00 --loop-start none morning brief\``
   ];
 }
 function hasLoopFlag(raw, flag) {
@@ -60287,8 +60426,8 @@ function migrateLegacyConfigShape(config) {
 }
 
 // src/config/config-migration.ts
-var CURRENT_SCHEMA_VERSION = "0.1.45";
-var CONFIG_UPGRADE_MAX_SCHEMA_VERSION = "0.1.44";
+var CURRENT_SCHEMA_VERSION = "0.1.50";
+var LEGACY_CONFIG_UPGRADE_MAX_SCHEMA_VERSION = "0.1.44";
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -60322,6 +60461,22 @@ function isAtMostVersion(schemaVersion, maxVersion) {
   }
   return true;
 }
+function isBeforeVersion(schemaVersion, targetVersion) {
+  const current = parseVersionParts(schemaVersion);
+  const target = parseVersionParts(targetVersion);
+  if (!current || !target) {
+    return !schemaVersion;
+  }
+  for (let index = 0;index < current.length; index += 1) {
+    if (current[index] < target[index]) {
+      return true;
+    }
+    if (current[index] > target[index]) {
+      return false;
+    }
+  }
+  return false;
+}
 function readTimezone(value) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -60572,7 +60727,10 @@ function updateSchemaVersion(config) {
   };
 }
 function shouldUpgradeConfigSchema(schemaVersion) {
-  return isAtMostVersion(schemaVersion, CONFIG_UPGRADE_MAX_SCHEMA_VERSION);
+  return isBeforeVersion(schemaVersion, CURRENT_SCHEMA_VERSION);
+}
+function shouldApplyLegacyConfigMigration(schemaVersion) {
+  return isAtMostVersion(schemaVersion, LEGACY_CONFIG_UPGRADE_MAX_SCHEMA_VERSION);
 }
 function normalizeConfigDocumentShape(input) {
   if (!isRecord3(input)) {
@@ -60581,7 +60739,7 @@ function normalizeConfigDocumentShape(input) {
   const config = { ...input };
   migrateLegacyConfigShape(config);
   const schemaVersion = isRecord3(config.meta) && typeof config.meta.schemaVersion === "string" ? config.meta.schemaVersion : undefined;
-  const legacyExactAdmission = shouldUpgradeConfigSchema(schemaVersion);
+  const legacyExactAdmission = shouldApplyLegacyConfigMigration(schemaVersion);
   const bots = cloneRecord2(config.bots);
   const slack = cloneRecord2(bots.slack);
   const telegram = cloneRecord2(bots.telegram);
@@ -62066,7 +62224,7 @@ import { basename, dirname as dirname4, join as join5 } from "node:path";
 
 // src/config/persisted-config.ts
 var defaultOwnedRunnerFields = {
-  codex: ["startupReadyPattern"],
+  codex: ["startupDelayMs", "startupReadyPattern"],
   gemini: [
     "startupDelayMs",
     "startupRetryCount",
@@ -62228,8 +62386,17 @@ function pruneCurrentSchemaStartupDefaults(config) {
   const defaults = isRecord6(agents?.defaults) ? agents.defaults : undefined;
   const runner = isRecord6(defaults?.runner) ? defaults.runner : undefined;
   const runnerDefaults = isRecord6(runner?.defaults) ? runner.defaults : undefined;
+  const codexRunner = isRecord6(runner?.codex) ? runner.codex : undefined;
+  let pruned = false;
   if (runnerDefaults?.startupDelayMs === 3000) {
     delete runnerDefaults.startupDelayMs;
+    pruned = true;
+  }
+  if (codexRunner?.startupDelayMs === 3000) {
+    delete codexRunner.startupDelayMs;
+    pruned = true;
+  }
+  if (pruned) {
     nextConfig.meta = {
       ...meta,
       schemaVersion: CURRENT_SCHEMA_VERSION,
@@ -63254,7 +63421,7 @@ async function runPairingCli(args, writer = console) {
 
 // src/agents/bootstrap.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { cpSync, existsSync as existsSync4, readdirSync, statSync as statSync2 } from "node:fs";
+import { cpSync, existsSync as existsSync4, lstatSync, readdirSync, rmSync as rmSync2, statSync as statSync2, symlinkSync } from "node:fs";
 import { dirname as dirname6, join as join6 } from "node:path";
 function resolveTemplateRoot(moduleDir) {
   const candidates = [
@@ -63272,35 +63439,40 @@ var TEMPLATE_ROOT = resolveTemplateRoot(dirname6(fileURLToPath2(import.meta.url)
 var DEFAULT_TEMPLATE_DIR = join6(TEMPLATE_ROOT, "default");
 var CUSTOMIZED_TEMPLATE_DIR = join6(TEMPLATE_ROOT, "customized");
 var CUSTOMIZED_DEFAULT_TEMPLATE_DIR = join6(CUSTOMIZED_TEMPLATE_DIR, "default");
-var TOOL_BOOTSTRAP_FILE = {
-  codex: "AGENTS.md",
+var CANONICAL_BOOTSTRAP_FILE = "AGENTS.md";
+var TOOL_DISCOVERY_FILE = {
   claude: "CLAUDE.md",
   gemini: "GEMINI.md"
 };
-function shouldIncludeTemplateFile(toolId, relativePath) {
-  const normalized = relativePath.replaceAll("\\", "/");
-  if (normalized.endsWith("AGENTS.md")) {
-    return toolId === "codex";
+function pathExists(path2) {
+  try {
+    lstatSync(path2);
+    return true;
+  } catch {
+    return false;
   }
+}
+function shouldIncludeTemplateFile(relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/");
   if (normalized.endsWith("CLAUDE.md")) {
-    return toolId === "claude";
+    return false;
   }
   if (normalized.endsWith("GEMINI.md")) {
-    return toolId === "gemini";
+    return false;
   }
   return true;
 }
-function collectTemplateFiles(rootDir, toolId, prefix = "") {
+function collectTemplateFiles(rootDir, prefix = "") {
   const files = [];
   for (const entry of readdirSync(rootDir)) {
     const sourcePath = join6(rootDir, entry);
     const relativePath = prefix ? join6(prefix, entry) : entry;
     const sourceStat = statSync2(sourcePath);
     if (sourceStat.isDirectory()) {
-      files.push(...collectTemplateFiles(sourcePath, toolId, relativePath));
+      files.push(...collectTemplateFiles(sourcePath, relativePath));
       continue;
     }
-    if (!shouldIncludeTemplateFile(toolId, relativePath)) {
+    if (!shouldIncludeTemplateFile(relativePath)) {
       continue;
     }
     files.push({
@@ -63313,22 +63485,44 @@ function collectTemplateFiles(rootDir, toolId, prefix = "") {
 }
 function getTemplateFiles(toolId, mode) {
   return [
-    ...collectTemplateFiles(DEFAULT_TEMPLATE_DIR, toolId),
-    ...collectTemplateFiles(CUSTOMIZED_DEFAULT_TEMPLATE_DIR, toolId).map((file) => ({
+    ...collectTemplateFiles(DEFAULT_TEMPLATE_DIR),
+    ...collectTemplateFiles(CUSTOMIZED_DEFAULT_TEMPLATE_DIR).map((file) => ({
       ...file,
       customized: true
     })),
-    ...collectTemplateFiles(join6(CUSTOMIZED_TEMPLATE_DIR, mode), toolId).map((file) => ({
+    ...collectTemplateFiles(join6(CUSTOMIZED_TEMPLATE_DIR, mode)).map((file) => ({
       ...file,
       customized: true
     }))
   ];
 }
+function getBootstrapManagedPaths(toolId, mode) {
+  const paths = new Set(getTemplateFiles(toolId, mode).map((file) => file.relativePath));
+  const discoveryFile = TOOL_DISCOVERY_FILE[toolId];
+  if (discoveryFile) {
+    paths.add(discoveryFile);
+  }
+  return [...paths];
+}
 function getBootstrapTemplateConflicts(workspacePath, toolId, mode) {
   if (!existsSync4(workspacePath)) {
     return [];
   }
-  return getTemplateFiles(toolId, mode).map((file) => file.relativePath).filter((relativePath) => existsSync4(join6(workspacePath, relativePath)));
+  return getBootstrapManagedPaths(toolId, mode).filter((relativePath) => pathExists(join6(workspacePath, relativePath)));
+}
+function writeToolDiscoverySymlink(workspacePath, toolId, options) {
+  const discoveryFile = TOOL_DISCOVERY_FILE[toolId];
+  if (!discoveryFile) {
+    return;
+  }
+  const destinationPath = join6(workspacePath, discoveryFile);
+  if (options?.force) {
+    rmSync2(destinationPath, {
+      force: true,
+      recursive: false
+    });
+  }
+  symlinkSync(CANONICAL_BOOTSTRAP_FILE, destinationPath);
 }
 async function applyBootstrapTemplate(workspacePath, mode, toolId, options) {
   const force = options?.force === true;
@@ -63344,6 +63538,9 @@ async function applyBootstrapTemplate(workspacePath, mode, toolId, options) {
       force: force || file.customized
     });
   }
+  writeToolDiscoverySymlink(workspacePath, toolId, {
+    force
+  });
 }
 function getBootstrapWorkspaceState(workspacePath, mode, toolId) {
   if (!mode) {
@@ -63352,7 +63549,11 @@ function getBootstrapWorkspaceState(workspacePath, mode, toolId) {
   if (!toolId || !existsSync4(workspacePath)) {
     return "missing";
   }
-  if (!existsSync4(join6(workspacePath, TOOL_BOOTSTRAP_FILE[toolId])) || !existsSync4(join6(workspacePath, "IDENTITY.md"))) {
+  if (!existsSync4(join6(workspacePath, CANONICAL_BOOTSTRAP_FILE)) || !existsSync4(join6(workspacePath, "IDENTITY.md"))) {
+    return "missing";
+  }
+  const discoveryFile = TOOL_DISCOVERY_FILE[toolId];
+  if (discoveryFile && !existsSync4(join6(workspacePath, discoveryFile))) {
     return "missing";
   }
   if (existsSync4(join6(workspacePath, "BOOTSTRAP.md"))) {
@@ -63559,6 +63760,9 @@ function renderAgentsHelp() {
     "Notes:",
     `  - \`agents add\` is the lower-level manual surface; first-run ${renderCliCommand("start", { inline: true })} and ${renderCliCommand("init", { inline: true })} can bootstrap the first \`default\` agent for you`,
     "  - `--cli` is required on `agents add`; supported tools are `codex`, `claude`, and `gemini`",
+    "  - `agents add` without `--bot-type` is valid and does not seed any bootstrap files",
+    "  - `--bot-type` on `agents add` or `agents bootstrap` seeds a fresh workspace template; use it when you want clisbot to create guidance files for you",
+    "  - canonical workspace instructions live in `AGENTS.md`; Claude and Gemini add `CLAUDE.md` or `GEMINI.md` as symlinks to that same file",
     "  - omit `--startup-option` to inherit the built-in startup args for the selected CLI tool",
     "  - `response-mode` and `additional-message-mode` mutate per-agent overrides under `agents.list[]`",
     "  - use agent timezone only when one workspace/assistant should run wall-clock loops in a different timezone than app default"
@@ -64527,7 +64731,7 @@ class RuntimeHealthStore {
 
 // src/control/runtime-process.ts
 import { execFileSync, spawn as spawn3 } from "node:child_process";
-import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
+import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync3, rmSync as rmSync4, statSync as statSync4 } from "node:fs";
 import { dirname as dirname15, join as join13 } from "node:path";
 import { kill as kill2 } from "node:process";
 
@@ -65133,14 +65337,20 @@ class TmuxClient {
     }
     return result.stdout;
   }
+  sessionTarget(sessionName) {
+    return `=${sessionName}`;
+  }
   target(sessionName) {
-    return `${sessionName}:${MAIN_WINDOW_NAME}`;
+    return `${this.sessionTarget(sessionName)}:${MAIN_WINDOW_NAME}`;
+  }
+  windowTarget(sessionName, windowName) {
+    return `${this.sessionTarget(sessionName)}:${windowName}`;
   }
   rawTarget(target) {
     return target;
   }
   async hasSession(sessionName) {
-    const result = await this.exec(["has-session", "-t", sessionName]);
+    const result = await this.exec(["has-session", "-t", this.sessionTarget(sessionName)]);
     return result.exitCode === 0;
   }
   async listSessions() {
@@ -65236,14 +65446,14 @@ ${result.stdout}`.trim();
       "-F",
       "#{pane_id}",
       "-t",
-      params.sessionName,
+      this.sessionTarget(params.sessionName),
       "-n",
       params.name,
       "-c",
       params.cwd,
       params.command
     ]);
-    await this.freezeWindowName(`${params.sessionName}:${params.name}`);
+    await this.freezeWindowName(this.windowTarget(params.sessionName, params.name));
     return paneId.trim();
   }
   async freezeWindowName(target) {
@@ -65254,7 +65464,7 @@ ${result.stdout}`.trim();
     const output = await this.execOrThrow([
       "list-windows",
       "-t",
-      sessionName,
+      this.sessionTarget(sessionName),
       "-F",
       "#{window_name}\t#{pane_id}"
     ]);
@@ -65330,7 +65540,7 @@ ${result.stdout}`.trim();
     };
   }
   async killSession(sessionName) {
-    await this.exec(["kill-session", "-t", sessionName]);
+    await this.exec(["kill-session", "-t", this.sessionTarget(sessionName)]);
   }
   async killPane(target) {
     await this.exec(["kill-pane", "-t", this.rawTarget(target)]);
@@ -65360,7 +65570,7 @@ ${result.stdout}`.trim();
 
 // src/control/runtime-monitor.ts
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync6, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync6, rmSync as rmSync3 } from "node:fs";
 import { dirname as dirname14 } from "node:path";
 import { kill } from "node:process";
 import { once } from "node:events";
@@ -65882,12 +66092,19 @@ function parseAgentCommand(text, options = {}) {
   if (lowered === "loop") {
     const loopText = withoutSlash.slice(command.length).trim();
     const loweredLoopText = loopText.toLowerCase();
+    const hasLoopStartOverride = hasLoopFlag(loopText, LOOP_START_FLAG);
     if (!loweredLoopText || loweredLoopText === "help") {
       return {
         type: "control",
         name: "loop-help"
       };
     }
+    if (hasLoopStartOverride && (loweredLoopText.startsWith("help ") || loweredLoopText === "status" || loweredLoopText.startsWith("status "))) {
+      return {
+        type: "loop-error",
+        message: `\`${LOOP_START_FLAG}\` is only supported when creating recurring interval and wall-clock loops.`
+      };
+    }
     if (loweredLoopText === "status") {
       return {
         type: "loop-control",
@@ -65896,6 +66113,12 @@ function parseAgentCommand(text, options = {}) {
     }
     if (loweredLoopText === "cancel" || loweredLoopText.startsWith("cancel ")) {
       const cancelArgs = loopText.slice("cancel".length).trim();
+      if (hasLoopStartOverride) {
+        return {
+          type: "loop-error",
+          message: `\`${LOOP_START_FLAG}\` is only supported when creating recurring interval and wall-clock loops.`
+        };
+      }
       if (hasLoopFlag(cancelArgs, LOOP_FORCE_FLAG)) {
         return {
           type: "loop-error",
@@ -66004,14 +66227,14 @@ function renderAgentControlSlashHelp() {
     "- `/start`: show onboarding help for the current surface",
     "- `/status`: show the current route status and operator setup commands",
     "- `/help`: show available control slash commands",
-    "- `/whoami`: show the current platform, route, and sender identity details",
+    "- `/whoami`: show the current platform, route, sender identity, and saved session id",
     "- `/transcript`: show a short recent session snapshot when the route verbose policy allows it",
     "- `/transcript full`: show a longer session snapshot when you need the full pane context",
     "- `/attach`: attach this thread to the active run and resume live updates when it is still processing",
     "- `/detach`: stop live updates for this thread while still posting the final result here",
     "- `/watch every 30s [for 10m]`: post the latest state on an interval until the run settles or the watch window ends",
     "- `/stop`: send Escape to interrupt the current conversation session",
-    "- `/new`: trigger a new runner conversation for this routed session and store the new session id",
+    "- `/new`: start a new session for this routed conversation and save the new session id",
     "- `/nudge`: send one extra Enter to the current tmux session without resending the prompt text",
     "- `/followup status`: show the current conversation follow-up policy",
     "- `/followup auto`: allow natural follow-up after the bot has replied in-thread",
@@ -66171,27 +66394,6 @@ class SessionStore {
       return next;
     });
   }
-  async touch(params) {
-    const existing = await this.get(params.sessionKey);
-    const sessionId = params.sessionId?.trim() || existing?.sessionId;
-    if (!sessionId) {
-      return null;
-    }
-    return this.put({
-      agentId: params.agentId,
-      sessionKey: params.sessionKey,
-      sessionId,
-      workspacePath: params.workspacePath,
-      runnerCommand: params.runnerCommand,
-      lastAdmittedPromptAt: existing?.lastAdmittedPromptAt,
-      followUp: existing?.followUp,
-      runtime: existing?.runtime,
-      loops: existing?.loops ?? existing?.intervalLoops,
-      queues: existing?.queues,
-      recentConversation: existing?.recentConversation,
-      updatedAt: Date.now()
-    });
-  }
   async withPathLock(work) {
     const previous = SessionStore.pathLocks.get(this.storePath) ?? Promise.resolve();
     let release;
@@ -66348,9 +66550,7 @@ class AgentSessionState {
       lastAdmittedPromptAt: existing?.lastAdmittedPromptAt,
       followUp: existing?.followUp,
       runnerCommand: params.runnerCommand ?? existing?.runnerCommand ?? resolved.runner.command,
-      runtime: {
-        state: "idle"
-      },
+      runtime: params.preserveRuntime ? existing?.runtime : { state: "idle" },
       loops: getStoredLoops(existing),
       recentConversation: existing?.recentConversation
     }));
@@ -66394,19 +66594,6 @@ class AgentSessionState {
       agentId: target.agentId
     };
   }
-  async listActiveSessionRuntimes() {
-    const entries = await this.sessionStore.list();
-    return entries.filter(hasActiveRuntime).map((entry) => ({
-      state: entry.runtime.state,
-      startedAt: entry.runtime.startedAt,
-      detachedAt: entry.runtime.detachedAt,
-      finalReplyAt: entry.runtime.finalReplyAt,
-      lastMessageToolReplyAt: entry.runtime.lastMessageToolReplyAt,
-      messageToolFinalReplyAt: entry.runtime.messageToolFinalReplyAt,
-      sessionKey: entry.sessionKey,
-      agentId: entry.agentId
-    }));
-  }
   async listIntervalLoops(params) {
     const entries = await this.sessionStore.list();
     return entries.flatMap((entry) => getStoredLoops(entry).filter((loop) => !params?.sessionKey || entry.sessionKey === params.sessionKey).map((loop) => ({
@@ -66664,6 +66851,10 @@ class AgentSessionState {
     const entry = await this.sessionStore.get(sessionKey);
     return getStoredQueues(entry).some((item) => item.status === "pending" || item.status === "running");
   }
+  async hasQueuedItem(sessionKey, queueId) {
+    const entry = await this.sessionStore.get(sessionKey);
+    return getStoredQueues(entry).some((item) => item.id === queueId);
+  }
   async resetStaleRunningQueuedItems(activeSessionKeys) {
     const entries = await this.sessionStore.list();
     let reset = 0;
@@ -66744,11 +66935,74 @@ function getStoredLoops(entry) {
 function getStoredQueues(entry) {
   return entry?.queues ?? [];
 }
-function hasActiveRuntime(entry) {
-  return entry.runtime?.state === "running" || entry.runtime?.state === "detached";
+
+// src/agents/session-identity.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+function createSessionId() {
+  return randomUUID3();
+}
+function parseRunnerSessionId(snapshot, pattern) {
+  const regex = new RegExp(pattern, "ig");
+  let lastMatch = null;
+  for (;; ) {
+    const match = regex.exec(snapshot);
+    if (!match) {
+      break;
+    }
+    if (!match[0]) {
+      break;
+    }
+    lastMatch = match;
+  }
+  return (lastMatch?.[1] ?? lastMatch?.[0] ?? "").trim() || null;
+}
+
+// src/agents/session-mapping.ts
+class SessionMapping {
+  sessionState;
+  constructor(sessionState) {
+    this.sessionState = sessionState;
+  }
+  async get(sessionKey) {
+    return this.sessionState.getEntry(sessionKey);
+  }
+  async prepareStartup(resolved) {
+    const entry = await this.sessionState.getEntry(resolved.sessionKey);
+    const storedSessionId = entry?.sessionId?.trim() || undefined;
+    if (storedSessionId) {
+      return {
+        storedSessionId,
+        sessionId: storedSessionId,
+        resume: true
+      };
+    }
+    if (resolved.runner.sessionId.create.mode !== "explicit") {
+      return {
+        resume: false
+      };
+    }
+    return {
+      sessionId: createSessionId(),
+      resume: false
+    };
+  }
+  async setActive(resolved, params) {
+    return this.sessionState.touchSessionEntry(resolved, {
+      sessionId: params.sessionId,
+      runnerCommand: params.runnerCommand,
+      runtime: params.runtime
+    });
+  }
+  async clearActive(resolved, params = {}) {
+    return this.sessionState.clearSessionIdEntry(resolved, params);
+  }
+  async touch(resolved, params = {}) {
+    return this.sessionState.touchSessionEntry(resolved, params);
+  }
 }
 
 // src/agents/session-key.ts
+import { createHash } from "node:crypto";
 var DEFAULT_MAIN_KEY = "main";
 var DEFAULT_BOT_ID = "default";
 var DEFAULT_ACCOUNT_ID = DEFAULT_BOT_ID;
@@ -66839,7 +67093,8 @@ function buildTmuxSessionName(params) {
     mainKey: normalizeMainKey(params.mainKey)
   });
   const baseName = sanitizeSessionName(rendered);
-  return baseName;
+  const sessionHash = createHash("sha1").update(params.sessionKey).digest("hex").slice(0, 8);
+  return `${baseName}-${sessionHash}`;
 }
 
 // src/agents/resolved-target.ts
@@ -66999,39 +67254,15 @@ class AgentJobQueue {
     if (!state) {
       return 0;
     }
-    const keptEntries = state.entries.filter((entry) => entry.status === "running");
-    const removedEntries = state.entries.filter((entry) => entry.status === "pending");
-    state.entries = keptEntries;
-    for (const entry of removedEntries) {
-      Promise.resolve(entry.lifecycle?.onClear?.()).catch(() => {
-        return;
-      });
-      entry.reject(new ClearedQueuedTaskError);
-    }
-    if (state.entries.length === 0 && !state.running) {
-      this.states.delete(key);
-    }
-    return removedEntries.length;
+    return this.clearPendingEntriesForState(key, state, () => true);
   }
-  clearPendingByIds(ids) {
-    const idSet = new Set(ids);
-    let cleared = 0;
-    for (const [key, state] of this.states.entries()) {
-      const keptEntries = state.entries.filter((entry) => entry.status === "running" || !idSet.has(entry.id));
-      const removedEntries = state.entries.filter((entry) => entry.status === "pending" && idSet.has(entry.id));
-      state.entries = keptEntries;
-      cleared += removedEntries.length;
-      for (const entry of removedEntries) {
-        Promise.resolve(entry.lifecycle?.onClear?.()).catch(() => {
-          return;
-        });
-        entry.reject(new ClearedQueuedTaskError);
-      }
-      if (state.entries.length === 0 && !state.running) {
-        this.states.delete(key);
-      }
+  clearPendingByIdsForKey(key, ids) {
+    const state = this.states.get(key);
+    if (!state) {
+      return 0;
     }
-    return cleared;
+    const idSet = new Set(ids);
+    return this.clearPendingEntriesForState(key, state, (entry) => idSet.has(entry.id));
   }
   getOrCreateState(key) {
     const existing = this.states.get(key);
@@ -67056,6 +67287,21 @@ class AgentJobQueue {
       return left.sequence - right.sequence;
     });
   }
+  clearPendingEntriesForState(key, state, shouldClear) {
+    const keptEntries = state.entries.filter((entry) => entry.status === "running" || !shouldClear(entry));
+    const removedEntries = state.entries.filter((entry) => entry.status === "pending" && shouldClear(entry));
+    state.entries = keptEntries;
+    for (const entry of removedEntries) {
+      Promise.resolve(entry.lifecycle?.onClear?.()).catch(() => {
+        return;
+      });
+      entry.reject(new ClearedQueuedTaskError);
+    }
+    if (state.entries.length === 0 && !state.running) {
+      this.states.delete(key);
+    }
+    return removedEntries.length;
+  }
   async drain(key, state) {
     if (state.running) {
       return;
@@ -67142,10 +67388,10 @@ function buildResumeCommandPreview(resolved, sessionId) {
 }
 
 // src/agents/loop-control-shared.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { join as join10 } from "node:path";
 function createLoopId() {
-  return randomUUID3().split("-")[0] ?? randomUUID3();
+  return randomUUID4().split("-")[0] ?? randomUUID4();
 }
 function buildStoredLoopSender(params) {
   const providerId = params.providerId.trim();
@@ -67172,10 +67418,11 @@ function createStoredLoopBase(params) {
     updatedAt: now,
     nextRunAt: params.nextRunAt,
     promptText: params.promptText,
-    canonicalPromptText: params.canonicalPromptText,
     protectedControlMutationRule: params.protectedControlMutationRule,
     promptSummary: params.promptSummary,
     promptSource: params.promptSource,
+    progressMessages: params.progressMessages,
+    loopStart: params.loopStart,
     createdBy: params.createdBy,
     sender: params.sender ?? deriveLegacyLoopSender({
       createdBy: params.createdBy,
@@ -67202,10 +67449,11 @@ function createStoredIntervalLoop(params) {
     ...createStoredLoopBase({
       nextRunAt: Date.now(),
       promptText: params.promptText,
-      canonicalPromptText: params.canonicalPromptText,
       protectedControlMutationRule: params.protectedControlMutationRule,
       promptSummary: params.promptSummary,
       promptSource: params.promptSource,
+      progressMessages: params.progressMessages,
+      loopStart: params.loopStart,
       createdBy: params.createdBy,
       sender: params.sender,
       surfaceBinding: params.surfaceBinding,
@@ -67232,10 +67480,11 @@ function createStoredCalendarLoop(params) {
     ...createStoredLoopBase({
       nextRunAt,
       promptText: params.promptText,
-      canonicalPromptText: params.canonicalPromptText,
       protectedControlMutationRule: params.protectedControlMutationRule,
       promptSummary: params.promptSummary,
       promptSource: params.promptSource,
+      progressMessages: params.progressMessages,
+      loopStart: params.loopStart,
       createdBy: params.createdBy,
       sender: params.sender,
       surfaceBinding: params.surfaceBinding,
@@ -67392,87 +67641,86 @@ class ManagedLoopController {
   }
   async reconcilePersistedIntervalLoops() {
     const persistedLoops = await this.deps.sessionState.listIntervalLoops();
-    const persistedIds = new Set;
+    const persistedKeys = new Set;
     for (const persisted of persistedLoops) {
-      persistedIds.add(persisted.id);
+      const managedKey = this.buildManagedLoopKey(persisted.sessionKey, persisted.id);
+      persistedKeys.add(managedKey);
       if (persisted.attemptedRuns >= persisted.maxRuns) {
-        this.dropManagedIntervalLoop(persisted.id);
+        this.dropManagedIntervalLoop(managedKey);
         continue;
       }
-      if (this.intervalLoops.has(persisted.id)) {
+      if (this.intervalLoops.has(managedKey)) {
         continue;
       }
-      this.intervalLoops.set(persisted.id, {
+      this.intervalLoops.set(managedKey, {
         target: {
           agentId: persisted.agentId,
           sessionKey: persisted.sessionKey
         },
         loop: persisted
       });
-      this.scheduleIntervalLoopTimer(persisted.id, Math.max(0, persisted.nextRunAt - Date.now()));
+      this.scheduleIntervalLoopTimer(managedKey, Math.max(0, persisted.nextRunAt - Date.now()));
     }
-    for (const loopId of this.intervalLoops.keys()) {
-      if (!persistedIds.has(loopId)) {
-        this.dropManagedIntervalLoop(loopId);
+    for (const managedKey of this.intervalLoops.keys()) {
+      if (!persistedKeys.has(managedKey)) {
+        this.dropManagedIntervalLoop(managedKey);
       }
     }
   }
   async createIntervalLoop(params) {
     this.assertActiveLoopCapacity();
     const loop = createStoredIntervalLoop(params);
+    const managedKey = this.buildManagedLoopKey(params.target.sessionKey, loop.id);
     await this.deps.sessionState.setIntervalLoop(this.deps.resolveTarget(params.target), loop);
-    this.intervalLoops.set(loop.id, {
+    this.intervalLoops.set(managedKey, {
       target: params.target,
       loop
     });
-    await this.runIntervalLoopIteration(loop.id, {
+    await this.runIntervalLoopIteration(managedKey, {
       notifyStart: false
     });
-    return this.getIntervalLoop(loop.id);
+    return this.getIntervalLoop(params.target.sessionKey, loop.id);
   }
   async createCalendarLoop(params) {
     this.assertActiveLoopCapacity();
     const loop = createStoredCalendarLoop(params);
+    const managedKey = this.buildManagedLoopKey(params.target.sessionKey, loop.id);
     await this.deps.sessionState.setIntervalLoop(this.deps.resolveTarget(params.target), loop);
-    this.intervalLoops.set(loop.id, {
+    this.intervalLoops.set(managedKey, {
       target: params.target,
       loop
     });
-    this.scheduleIntervalLoopTimer(loop.id, Math.max(0, loop.nextRunAt - Date.now()));
-    return this.getIntervalLoop(loop.id);
+    this.scheduleIntervalLoopTimer(managedKey, Math.max(0, loop.nextRunAt - Date.now()));
+    return this.getIntervalLoop(params.target.sessionKey, loop.id);
   }
-  async cancelIntervalLoop(loopId) {
-    const managed = this.intervalLoops.get(loopId);
+  async cancelIntervalLoop(target, loopId) {
+    const managedKey = this.buildManagedLoopKey(target.sessionKey, loopId);
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return false;
     }
-    if (managed.timer) {
-      clearTimeout(managed.timer);
-      this.loopTimers.delete(managed.timer);
-    }
-    this.intervalLoops.delete(loopId);
-    await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(managed.target), loopId);
+    await this.cancelManagedIntervalLoop(managedKey, managed);
     return true;
   }
   async cancelIntervalLoopsForSession(target) {
-    const matching = [...this.intervalLoops.values()].filter((managed) => managed.target.sessionKey === target.sessionKey).map((managed) => managed.loop.id);
-    for (const loopId of matching) {
-      await this.cancelIntervalLoop(loopId);
+    const matching = [...this.intervalLoops.entries()].filter(([, managed]) => managed.target.sessionKey === target.sessionKey);
+    for (const [managedKey, managed] of matching) {
+      await this.cancelManagedIntervalLoop(managedKey, managed);
     }
     return matching.length;
   }
   async cancelAllIntervalLoops() {
-    const ids = [...this.intervalLoops.keys()];
-    for (const loopId of ids) {
-      await this.cancelIntervalLoop(loopId);
+    const matching = [...this.intervalLoops.entries()];
+    for (const [managedKey, managed] of matching) {
+      await this.cancelManagedIntervalLoop(managedKey, managed);
     }
-    return ids.length;
+    return matching.length;
   }
   listIntervalLoops(params) {
     return [...this.intervalLoops.values()].filter((managed) => !params?.sessionKey || managed.target.sessionKey === params.sessionKey).map((managed) => this.toLoopStatus(managed)).sort((left, right) => left.nextRunAt - right.nextRunAt);
   }
-  getIntervalLoop(loopId) {
-    const managed = this.intervalLoops.get(loopId);
+  getIntervalLoop(sessionKey, loopId) {
+    const managed = this.intervalLoops.get(this.buildManagedLoopKey(sessionKey, loopId));
     return managed ? this.toLoopStatus(managed) : null;
   }
   getActiveIntervalLoopCount() {
@@ -67496,8 +67744,8 @@ class ManagedLoopController {
     const entry = await this.deps.sessionState.getEntry(managed.target.sessionKey);
     return (entry?.loops ?? entry?.intervalLoops ?? []).some((loop) => loop.id === managed.loop.id);
   }
-  dropManagedIntervalLoop(loopId) {
-    const managed = this.intervalLoops.get(loopId);
+  dropManagedIntervalLoop(managedKey) {
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return;
     }
@@ -67505,30 +67753,34 @@ class ManagedLoopController {
       clearTimeout(managed.timer);
       this.loopTimers.delete(managed.timer);
     }
-    this.intervalLoops.delete(loopId);
+    this.intervalLoops.delete(managedKey);
+  }
+  async cancelManagedIntervalLoop(managedKey, managed) {
+    this.dropManagedIntervalLoop(managedKey);
+    await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(managed.target), managed.loop.id);
   }
-  async runIntervalLoopIteration(loopId, options = {}) {
-    const managed = this.intervalLoops.get(loopId);
+  async runIntervalLoopIteration(managedKey, options = {}) {
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return;
     }
     if (!await this.isManagedLoopPersisted(managed)) {
-      this.dropManagedIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
       return;
     }
     const attemptedRuns = managed.loop.attemptedRuns + 1;
     const now = Date.now();
     const nextLoopState = this.buildNextLoopState(managed.loop, attemptedRuns, now);
     if (await this.deps.isSessionBusy(managed.target)) {
-      await this.skipLoopIteration(loopId, managed, nextLoopState, attemptedRuns, now);
+      await this.skipLoopIteration(managedKey, managed, nextLoopState, attemptedRuns, now);
       return;
     }
     nextLoopState.executedRuns += 1;
     if (!await this.updateManagedIntervalLoop(managed, nextLoopState)) {
-      this.dropManagedIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
       return;
     }
-    await this.executeLoopIteration(loopId, managed.target, nextLoopState, attemptedRuns, now, options.notifyStart !== false);
+    await this.executeLoopIteration(managedKey, managed.target, nextLoopState, attemptedRuns, now, options.notifyStart !== false);
   }
   buildNextLoopState(loop, attemptedRuns, now) {
     return {
@@ -67538,33 +67790,35 @@ class ManagedLoopController {
       nextRunAt: this.computeNextManagedLoopRunAtMs(loop, now)
     };
   }
-  async skipLoopIteration(loopId, managed, nextLoopState, attemptedRuns, now) {
+  async skipLoopIteration(managedKey, managed, nextLoopState, attemptedRuns, now) {
     nextLoopState.skippedRuns += 1;
     if (!await this.updateManagedIntervalLoop(managed, nextLoopState)) {
-      this.dropManagedIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
       return;
     }
     if (attemptedRuns >= managed.loop.maxRuns) {
-      await this.cancelIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
+      await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(managed.target), managed.loop.id);
       return;
     }
-    this.scheduleIntervalLoopTimer(loopId, Math.max(0, nextLoopState.nextRunAt - now));
+    this.scheduleIntervalLoopTimer(managedKey, Math.max(0, nextLoopState.nextRunAt - now));
   }
-  async executeLoopIteration(loopId, target, nextLoopState, attemptedRuns, now, notifyStart) {
-    await this.notifyAndEnqueueLoop(loopId, target, nextLoopState, attemptedRuns, notifyStart);
+  async executeLoopIteration(managedKey, target, nextLoopState, attemptedRuns, now, notifyStart) {
+    await this.notifyAndEnqueueLoop(managedKey, target, nextLoopState, attemptedRuns, notifyStart);
     if (attemptedRuns >= nextLoopState.maxRuns) {
-      await this.cancelIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
+      await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(target), nextLoopState.id);
       return;
     }
-    this.scheduleIntervalLoopTimer(loopId, Math.max(0, nextLoopState.nextRunAt - now));
+    this.scheduleIntervalLoopTimer(managedKey, Math.max(0, nextLoopState.nextRunAt - now));
   }
-  async notifyAndEnqueueLoop(loopId, target, nextLoopState, attemptedRuns, notifyStart) {
+  async notifyAndEnqueueLoop(managedKey, target, nextLoopState, attemptedRuns, notifyStart) {
     if (notifyStart) {
       await this.deps.surfaceRuntime.notifyManagedLoopStart(target, nextLoopState);
     }
     const promptText = await this.deps.surfaceRuntime.buildManagedLoopPrompt(target.agentId, nextLoopState);
     const { result } = this.deps.enqueuePrompt(target, promptText, {
-      observerId: `loop:${loopId}:${attemptedRuns}`,
+      observerId: `loop:${managedKey}:${attemptedRuns}`,
       onUpdate: async () => {
         return;
       }
@@ -67575,8 +67829,8 @@ class ManagedLoopController {
       }
     });
   }
-  scheduleIntervalLoopTimer(loopId, delayMs) {
-    const managed = this.intervalLoops.get(loopId);
+  scheduleIntervalLoopTimer(managedKey, delayMs) {
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return;
     }
@@ -67586,12 +67840,12 @@ class ManagedLoopController {
     }
     const timer = setTimeout(() => {
       this.loopTimers.delete(timer);
-      const current = this.intervalLoops.get(loopId);
+      const current = this.intervalLoops.get(managedKey);
       if (!current) {
         return;
       }
       current.timer = undefined;
-      this.runIntervalLoopIteration(loopId, { notifyStart: true }).catch((error) => {
+      this.runIntervalLoopIteration(managedKey, { notifyStart: true }).catch((error) => {
         if (!this.deps.shouldSuppressShutdownError(error)) {
           console.error("loop execution failed", error);
         }
@@ -67608,6 +67862,9 @@ class ManagedLoopController {
     managed.loop = nextLoopState;
     return true;
   }
+  buildManagedLoopKey(sessionKey, loopId) {
+    return `${sessionKey}::${loopId}`;
+  }
   computeNextManagedLoopRunAtMs(loop, nowMs) {
     if (loop.kind === "calendar") {
       return computeNextCalendarLoopRunAtMs({
@@ -67624,6 +67881,8 @@ class ManagedLoopController {
 }
 
 // src/agents/managed-queue-controller.ts
+var QUEUE_MESSAGE_TOOL_FINAL_POLL_MS = 250;
+
 class ManagedQueueController {
   deps;
   queuedItems = new Map;
@@ -67646,7 +67905,7 @@ class ManagedQueueController {
   }
   async clearQueuedPrompts(target) {
     const clearedStored = await this.deps.sessionState.clearPendingQueuedItemsForSessionKey(target.sessionKey);
-    this.deps.queue.clearPendingByIds(clearedStored.map((item) => item.id));
+    this.deps.queue.clearPendingByIdsForKey(target.sessionKey, clearedStored.map((item) => item.id));
     return clearedStored.length;
   }
   enqueuePrompt(target, prompt, callbacks) {
@@ -67684,8 +67943,8 @@ class ManagedQueueController {
       return;
     }
     this.setManagedQueueItem(target, item, true);
-    return this.persistQueueItem(this.deps.resolveTarget(target), item).then(() => this.markPersisted(item)).catch((error) => {
-      this.clearPendingById(item);
+    return this.persistQueueItem(this.deps.resolveTarget(target), item).then(() => this.markPersisted(target, item)).catch((error) => {
+      this.clearPendingById(target, item);
       throw error;
     });
   }
@@ -67696,25 +67955,58 @@ class ManagedQueueController {
     await reconciledBeforeStart;
     return !await this.deps.hasBlockingActiveRun(target);
   }
+  async canStartPersistedQueueItem(target, item) {
+    if (await this.deps.hasBlockingActiveRun(target)) {
+      return false;
+    }
+    if (!await this.deps.sessionState.hasQueuedItem(target.sessionKey, item.id)) {
+      this.clearPendingById(target, item);
+      return false;
+    }
+    return true;
+  }
   async reconcilePersistedQueueItems() {
     const persistedItems = await this.deps.sessionState.listQueuedItems({
       statuses: ["pending", "running"]
     });
-    const persistedIds = new Set(persistedItems.map((item) => item.id));
-    const removedIds = [...this.queuedItems.entries()].filter(([id, managed]) => !managed.persisting && !persistedIds.has(id)).map(([id]) => id);
-    if (removedIds.length > 0) {
-      this.deps.queue.clearPendingByIds(removedIds);
-      for (const id of removedIds) {
-        this.queuedItems.delete(id);
+    const persistedKeys = new Set(persistedItems.map((item) => this.buildManagedQueueKey(item.sessionKey, item.id)));
+    const removedManagedItems = [...this.queuedItems.entries()].filter(([key, managed]) => !managed.persisting && !persistedKeys.has(key));
+    if (removedManagedItems.length > 0) {
+      const removedBySession = new Map;
+      for (const [key, managed] of removedManagedItems) {
+        const ids = removedBySession.get(managed.target.sessionKey) ?? [];
+        ids.push(managed.item.id);
+        removedBySession.set(managed.target.sessionKey, ids);
+        this.queuedItems.delete(key);
+      }
+      for (const [sessionKey, itemIds] of removedBySession.entries()) {
+        this.deps.queue.clearPendingByIdsForKey(sessionKey, itemIds);
       }
     }
     for (const persisted of persistedItems) {
-      if (persisted.status !== "pending" || this.queuedItems.has(persisted.id)) {
+      if (persisted.status === "running") {
+        await this.clearStaleRunningQueueItem(persisted);
+        continue;
+      }
+      if (this.queuedItems.has(this.buildManagedQueueKey(persisted.sessionKey, persisted.id))) {
         continue;
       }
       this.enqueuePersistedQueueItem(persisted);
     }
   }
+  async clearStaleRunningQueueItem(item) {
+    if (this.queuedItems.has(this.buildManagedQueueKey(item.sessionKey, item.id))) {
+      return;
+    }
+    const target = {
+      agentId: item.agentId,
+      sessionKey: item.sessionKey
+    };
+    if (await this.deps.hasBlockingActiveRun(target)) {
+      return;
+    }
+    await this.removeManagedQueueItem(target, item);
+  }
   persistQueueItem(resolved, item) {
     return this.deps.sessionState.countPendingQueuedItemsForSessionKey(resolved.sessionKey, {
       excludeId: item.id
@@ -67727,21 +68019,22 @@ class ManagedQueueController {
     });
   }
   setManagedQueueItem(target, item, persisting) {
-    this.queuedItems.set(item.id, {
+    this.queuedItems.set(this.buildManagedQueueKey(target.sessionKey, item.id), {
       target,
       item,
       persisting
     });
   }
-  markPersisted(item) {
-    const managed = this.queuedItems.get(item.id);
+  markPersisted(target, item) {
+    const key = this.buildManagedQueueKey(target.sessionKey, item.id);
+    const managed = this.queuedItems.get(key);
     if (managed) {
-      this.queuedItems.set(item.id, { ...managed, persisting: false });
+      this.queuedItems.set(key, { ...managed, persisting: false });
     }
   }
-  clearPendingById(item) {
-    this.deps.queue.clearPendingByIds([item.id]);
-    this.queuedItems.delete(item.id);
+  clearPendingById(target, item) {
+    this.deps.queue.clearPendingByIdsForKey(target.sessionKey, [item.id]);
+    this.queuedItems.delete(this.buildManagedQueueKey(target.sessionKey, item.id));
   }
   async markQueueItemRunning(target, item) {
     if (!item) {
@@ -67754,17 +68047,18 @@ class ManagedQueueController {
       startedAt: now,
       updatedAt: now
     };
-    this.queuedItems.set(item.id, {
+    this.queuedItems.set(this.buildManagedQueueKey(target.sessionKey, item.id), {
       target,
       item: next
     });
     await this.deps.sessionState.replaceQueuedItemIfPresent(this.deps.resolveTarget(target), next);
+    return next;
   }
   async removeManagedQueueItem(target, item) {
     if (!item) {
       return;
     }
-    this.queuedItems.delete(item.id);
+    this.queuedItems.delete(this.buildManagedQueueKey(target.sessionKey, item.id));
     await this.deps.sessionState.removeQueuedItem(this.deps.resolveTarget(target), item.id);
   }
   enqueuePersistedQueueItem(item) {
@@ -67772,28 +68066,43 @@ class ManagedQueueController {
       agentId: item.agentId,
       sessionKey: item.sessionKey
     };
-    this.queuedItems.set(item.id, {
+    this.queuedItems.set(this.buildManagedQueueKey(target.sessionKey, item.id), {
       target,
       item
     });
     const queued = this.deps.queue.enqueue(item.sessionKey, async () => {
-      await this.markQueueItemRunning(target, item);
+      const runningItem = await this.markQueueItemRunning(target, item);
       await this.deps.surfaceRuntime.notifyManagedQueueStart(target, item);
       const promptText = await this.deps.surfaceRuntime.buildManagedQueuePrompt(item.agentId, item);
-      return this.deps.activeRuns.executePrompt(target, promptText, {
+      const result = this.deps.activeRuns.executePrompt(target, promptText, {
         id: `queue:${item.id}`,
         mode: "live",
         onUpdate: async () => {
           return;
         }
       });
+      let stopWaitingForToolFinal = false;
+      try {
+        const outcome = await Promise.race([
+          result.then((update) => ({ kind: "result", update })),
+          this.waitForMessageToolFinal(target, runningItem ?? item, () => stopWaitingForToolFinal).then((seen) => ({ kind: seen ? "message-tool-final" : "result" }))
+        ]);
+        if (outcome.kind === "message-tool-final") {
+          return this.createMessageToolFinalQueueUpdate(target, item);
+        }
+        return await result;
+      } finally {
+        stopWaitingForToolFinal = true;
+      }
     }, {
       id: item.id,
       createdAt: item.createdAt,
       text: item.promptSummary,
-      canStart: async () => !await this.deps.hasBlockingActiveRun(target),
+      canStart: async () => this.canStartPersistedQueueItem(target, item),
       onComplete: async (value) => {
-        await this.deps.surfaceRuntime.notifyManagedQueueSettlement(target, item, value);
+        if (!value.messageToolFinalAlreadySent && !await this.hasMessageToolFinalForQueueItem(target, item)) {
+          await this.deps.surfaceRuntime.notifyManagedQueueSettlement(target, item, value);
+        }
         await this.removeManagedQueueItem(target, item);
       },
       onFailure: async (error) => {
@@ -67803,38 +68112,54 @@ class ManagedQueueController {
       onClear: () => this.removeManagedQueueItem(target, item)
     });
     queued.result.catch((error) => {
+      if (error instanceof ClearedQueuedTaskError) {
+        return;
+      }
       if (this.deps.shouldSuppressShutdownError(error)) {
         return;
       }
       console.error("queued prompt execution failed", error);
     });
   }
-}
-
-// src/agents/runner-service.ts
-import { dirname as dirname12 } from "node:path";
-
-// src/agents/session-identity.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-function createSessionId() {
-  return randomUUID4();
-}
-function extractSessionId(snapshot, pattern) {
-  const regex = new RegExp(pattern, "ig");
-  let lastMatch = null;
-  for (;; ) {
-    const match = regex.exec(snapshot);
-    if (!match) {
-      break;
+  async waitForMessageToolFinal(target, item, shouldStop) {
+    while (!shouldStop()) {
+      if (await this.hasMessageToolFinalForQueueItem(target, item)) {
+        return true;
+      }
+      await sleep(QUEUE_MESSAGE_TOOL_FINAL_POLL_MS);
     }
-    if (!match[0]) {
-      break;
+    return false;
+  }
+  async hasMessageToolFinalForQueueItem(target, item) {
+    const startedAt = this.queuedItems.get(this.buildManagedQueueKey(target.sessionKey, item.id))?.item.startedAt ?? item.startedAt;
+    if (typeof startedAt !== "number" || !Number.isFinite(startedAt)) {
+      return false;
     }
-    lastMatch = match;
+    const runtime = await this.deps.sessionState.getSessionRuntime(target);
+    return typeof runtime.messageToolFinalReplyAt === "number" && Number.isFinite(runtime.messageToolFinalReplyAt) && runtime.messageToolFinalReplyAt >= startedAt;
+  }
+  createMessageToolFinalQueueUpdate(target, item) {
+    const resolved = this.deps.resolveTarget(target);
+    return {
+      status: "completed",
+      agentId: target.agentId,
+      sessionKey: target.sessionKey,
+      sessionName: resolved.sessionName,
+      workspacePath: resolved.workspacePath,
+      snapshot: "",
+      fullSnapshot: "",
+      initialSnapshot: "",
+      messageToolFinalAlreadySent: true
+    };
+  }
+  buildManagedQueueKey(sessionKey, itemId) {
+    return `${sessionKey}::${itemId}`;
   }
-  return (lastMatch?.[1] ?? lastMatch?.[0] ?? "").trim() || null;
 }
 
+// src/agents/runner-service.ts
+import { dirname as dirname12 } from "node:path";
+
 // src/shared/transcript-normalization.ts
 import { stripVTControlCharacters } from "node:util";
 function normalizePaneText(raw) {
@@ -68089,18 +68414,37 @@ function isTimerDrivenStatusLine(line) {
   return isActiveTimerStatusLine(trimmed) || CLAUDE_WORKED_STATUS_PATTERN.test(trimmed);
 }
 function hasActiveTimerStatus(snapshot) {
-  return splitNormalizedLines(snapshot).some((line) => isActiveTimerStatusLine(line));
+  return Boolean(extractLatestActiveTimerStatusLine(snapshot));
 }
 function extractLatestActiveTimerStatusLine(snapshot) {
   const lines = splitNormalizedLines(snapshot);
   for (let index = lines.length - 1;index >= 0; index -= 1) {
     const line = lines[index]?.trim() ?? "";
-    if (isActiveTimerStatusLine(line)) {
+    if (isActiveTimerStatusLine(line) && isLiveTimerStatusLine(lines, index)) {
       return line;
     }
   }
   return "";
 }
+function isLiveTimerStatusLine(lines, timerIndex) {
+  for (let index = timerIndex + 1;index < lines.length; index += 1) {
+    const trimmed = lines[index]?.trim() ?? "";
+    if (!trimmed) {
+      continue;
+    }
+    if (isRunnerIdlePromptLine(trimmed) || isRunnerPromptMetadataLine(trimmed)) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isRunnerIdlePromptLine(trimmed) {
+  return trimmed.startsWith("› ") || trimmed === "›" || trimmed.startsWith("> ");
+}
+function isRunnerPromptMetadataLine(trimmed) {
+  return /^gpt-[\w.-]+ .*·/.test(trimmed) || trimmed.startsWith("model:") || trimmed.startsWith("directory:") || trimmed.startsWith("ctx:") || trimmed.startsWith("tokens:") || trimmed.startsWith("? for shortcuts");
+}
 function shouldDropCodexChromeLine(line) {
   const trimmed = line.trim();
   if (!trimmed) {
@@ -68317,6 +68661,11 @@ function deriveInteractionText(initialSnapshot, currentSnapshot) {
   const current = cleanInteractionSnapshot(currentSnapshot);
   return extractScrolledAppend(previous, current) || diffText(previous, current);
 }
+function deriveInteractionDiffText(initialSnapshot, currentSnapshot) {
+  const previous = cleanInteractionSnapshot(initialSnapshot);
+  const current = cleanInteractionSnapshot(currentSnapshot);
+  return diffText(previous, current);
+}
 function appendInteractionText(currentBody, nextDelta) {
   const trimmedCurrent = currentBody.trim();
   const trimmedDelta = nextDelta.trim();
@@ -68773,6 +69122,14 @@ class TmuxSubmitUnconfirmedError extends Error {
   }
 }
 async function submitTmuxSessionInput(params) {
+  if (params.trustPrompt) {
+    await acceptTmuxTrustPromptIfPresent({
+      tmux: params.tmux,
+      sessionName: params.sessionName,
+      captureLines: params.trustPrompt.captureLines,
+      startupDelayMs: params.trustPrompt.startupDelayMs
+    });
+  }
   const prePasteState = await params.tmux.getPaneState(params.sessionName);
   const captureLines = estimatePasteCaptureLines(params.text);
   const prePasteSnapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, captureLines));
@@ -68826,6 +69183,12 @@ async function submitTmuxSessionInput(params) {
   throw new TmuxSubmitUnconfirmedError;
 }
 async function captureTmuxSessionIdentity(params) {
+  await acceptTmuxTrustPromptIfPresent({
+    tmux: params.tmux,
+    sessionName: params.sessionName,
+    captureLines: params.captureLines,
+    startupDelayMs: params.timeoutMs
+  });
   let statusSubmission = await submitTmuxSessionInput({
     tmux: params.tmux,
     sessionName: params.sessionName,
@@ -68849,7 +69212,7 @@ async function captureTmuxSessionIdentity(params) {
       throw error;
     }
     if (tmuxPaneHasTrustPrompt(snapshot)) {
-      await dismissTrustPrompt({
+      await acceptTrustPrompt({
         tmux: params.tmux,
         sessionName: params.sessionName,
         captureLines: params.captureLines
@@ -68864,7 +69227,7 @@ async function captureTmuxSessionIdentity(params) {
       });
       continue;
     }
-    const sessionId = extractSessionId(deriveSessionIdentityText(statusSubmission.submittedSnapshot, snapshot), params.pattern);
+    const sessionId = extractSessionIdFromCaptureCandidates(deriveSessionIdCaptureCandidates(statusSubmission.submittedSnapshot, snapshot, params.statusCommand), params.pattern);
     if (sessionId) {
       await waitForTmuxPaneSettle({
         tmux: params.tmux,
@@ -68879,12 +69242,34 @@ async function captureTmuxSessionIdentity(params) {
   }
   return null;
 }
-function deriveSessionIdentityText(submittedSnapshot, snapshot) {
+function deriveSessionIdCaptureCandidates(submittedSnapshot, snapshot, statusCommand) {
   const rawSubmitted = normalizePaneText(submittedSnapshot);
   const rawSnapshot = normalizePaneText(snapshot);
-  return extractScrolledAppend(rawSubmitted, rawSnapshot) || deriveInteractionText(submittedSnapshot, snapshot);
+  return [
+    extractScrolledAppend(rawSubmitted, rawSnapshot),
+    deriveInteractionText(submittedSnapshot, snapshot),
+    deriveInteractionDiffText(submittedSnapshot, snapshot),
+    rawSnapshot,
+    extractStatusCommandTail(rawSnapshot, statusCommand)
+  ].filter((candidate, index, candidates) => candidate && candidates.indexOf(candidate) === index);
+}
+function extractStatusCommandTail(snapshot, statusCommand) {
+  const lastStatusIndex = snapshot.lastIndexOf(statusCommand);
+  if (lastStatusIndex < 0) {
+    return "";
+  }
+  return snapshot.slice(lastStatusIndex);
+}
+function extractSessionIdFromCaptureCandidates(candidates, pattern) {
+  for (const candidate of candidates) {
+    const sessionId = parseRunnerSessionId(candidate, pattern);
+    if (sessionId) {
+      return sessionId;
+    }
+  }
+  return null;
 }
-async function dismissTmuxTrustPromptIfPresent(params) {
+async function acceptTmuxTrustPromptIfPresent(params) {
   const deadline = Date.now() + Math.max(TRUST_PROMPT_MAX_WAIT_MS, params.startupDelayMs);
   while (Date.now() <= deadline) {
     let snapshot = "";
@@ -68907,7 +69292,7 @@ async function dismissTmuxTrustPromptIfPresent(params) {
     if (!tmuxPaneHasTrustPrompt(snapshot)) {
       return;
     }
-    await dismissTrustPrompt({
+    await acceptTrustPrompt({
       tmux: params.tmux,
       sessionName: params.sessionName,
       captureLines: params.captureLines
@@ -68939,7 +69324,7 @@ async function waitForTmuxSessionBootstrap(params) {
     if (snapshot) {
       lastSnapshot = snapshot;
       if (params.trustWorkspace && tmuxPaneHasTrustPrompt(snapshot)) {
-        await dismissTrustPrompt({
+        await acceptTrustPrompt({
           tmux: params.tmux,
           sessionName: params.sessionName,
           captureLines: params.captureLines
@@ -68956,7 +69341,7 @@ async function waitForTmuxSessionBootstrap(params) {
           };
         }
       }
-      if (readyRegex && !readyRegex.test(snapshot)) {
+      if (readyRegex && !snapshotHasActiveReadyPattern(snapshot, readyRegex)) {
         await sleep(SESSION_BOOTSTRAP_POLL_INTERVAL_MS);
         continue;
       }
@@ -68972,7 +69357,7 @@ async function waitForTmuxSessionBootstrap(params) {
     snapshot: lastSnapshot
   };
 }
-async function dismissTrustPrompt(params) {
+async function acceptTrustPrompt(params) {
   await params.tmux.sendKey(params.sessionName, "Enter");
   const deadline = Date.now() + TRUST_PROMPT_MAX_WAIT_MS;
   while (Date.now() <= deadline) {
@@ -69190,6 +69575,29 @@ function buildBootstrapSessionLostError(sessionName, error) {
 function arePaneStatesEqual(left, right) {
   return left.cursorX === right.cursorX && left.cursorY === right.cursorY && left.historySize === right.historySize;
 }
+function snapshotHasActiveReadyPattern(snapshot, readyRegex) {
+  const lines = splitNormalizedLines(snapshot);
+  let readyLineIndex = -1;
+  for (let index = 0;index < lines.length; index += 1) {
+    if (readyRegex.test(lines[index] ?? "")) {
+      readyLineIndex = index;
+    }
+  }
+  if (readyLineIndex < 0) {
+    return readyRegex.test(snapshot);
+  }
+  for (const rawLine of lines.slice(readyLineIndex + 1)) {
+    const line = rawLine.trim();
+    if (!line || isPromptMetadataLine(line)) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isPromptMetadataLine(line) {
+  return /^gpt-[\w.-]+\b/i.test(line) || /^model:\s*/i.test(line) || /^session:\s*/i.test(line);
+}
 function looksLikeClaudeTrustPrompt(snapshot) {
   return snapshot.includes("Quick safety check:") && snapshot.includes("Yes, I trust this folder") || snapshot.includes("Enter to confirm · Esc to cancel");
 }
@@ -69364,8 +69772,10 @@ var TMUX_DUPLICATE_SESSION_PATTERN = /duplicate session:/i;
 var TMUX_TRANSIENT_TARGET_PATTERN = /(?:no current target|can't find pane|can't find window|no such pane|no such window|tmux pane state unavailable)/i;
 var SESSION_READY_CAPTURE_RETRY_COUNT = 5;
 var SESSION_READY_CAPTURE_RETRY_DELAY_MS = 100;
-var TRIGGER_NEW_SESSION_CAPTURE_RETRY_COUNT = 3;
+var STARTUP_SESSION_ID_CAPTURE_RETRY_COUNT = 2;
+var STARTUP_SESSION_ID_CAPTURE_RETRY_DELAY_MS = 500;
 var SESSION_ID_CAPTURE_FAILURE_COOLDOWN_MS = 15000;
+var PRESERVED_SESSION_ID_RETRY_MESSAGE = "The previous runner session could not be resumed. clisbot preserved the stored session id instead of opening a new conversation automatically. Use `/new` if you want to trigger a new runner conversation, then resend the prompt.";
 function summarizeSnapshot(snapshot) {
   const compact = snapshot.split(`
 `).map((line) => line.trim()).filter(Boolean).join(" ").slice(0, 220);
@@ -69396,19 +69806,24 @@ function isFreshStartRetryablePromptDeliveryError(error) {
 function isRetryableFreshStartFault(error) {
   return isRecoverableStartupSessionLoss(error) || isTransientTmuxTargetError(error) || isFreshStartRetryablePromptDeliveryError(error);
 }
+function canRestartWithStoredSessionId(resolved) {
+  return resolved.runner.sessionId.resume.mode === "command" || resolved.runner.sessionId.create.mode === "explicit";
+}
 
 class RunnerService {
   loadedConfig;
   tmux;
   sessionState;
   resolveTarget;
+  sessionMapping;
   cleanupInFlight = false;
   sessionIdentityCaptureRetryAt = new Map;
-  constructor(loadedConfig, tmux, sessionState, resolveTarget) {
+  constructor(loadedConfig, tmux, sessionState, resolveTarget, sessionMapping = new SessionMapping(sessionState)) {
     this.loadedConfig = loadedConfig;
     this.tmux = tmux;
     this.sessionState = sessionState;
     this.resolveTarget = resolveTarget;
+    this.sessionMapping = sessionMapping;
   }
   async mapSessionError(error, sessionName, action, lastSnapshot = "") {
     if (isRecoverableStartupSessionLoss(error)) {
@@ -69452,24 +69867,21 @@ class RunnerService {
       args: args.map((value) => applyTemplate(value, values))
     };
   }
-  async syncSessionIdentity(resolved) {
-    const existing = await this.sessionState.getEntry(resolved.sessionKey);
+  async syncStoredSessionIdForResolvedTarget(resolved) {
+    const existing = await this.sessionMapping.get(resolved.sessionKey);
     if (existing?.sessionId) {
-      this.sessionIdentityCaptureRetryAt.delete(resolved.sessionKey);
-      return this.sessionState.touchSessionEntry(resolved, {
-        sessionId: existing.sessionId,
-        runnerCommand: resolved.runner.command
-      });
+      await this.persistStoredSessionIdBestEffort(resolved, existing.sessionId, resolved.runner.command);
+      return existing;
     }
     const retryAt = this.sessionIdentityCaptureRetryAt.get(resolved.sessionKey) ?? 0;
     if (retryAt > Date.now()) {
-      return this.sessionState.touchSessionEntry(resolved, {
+      return this.sessionMapping.touch(resolved, {
         runnerCommand: resolved.runner.command
       });
     }
     let sessionId;
     try {
-      sessionId = await this.captureSessionIdentity(resolved);
+      sessionId = await this.captureSessionIdFromRunner(resolved);
     } catch (error) {
       if (isFreshStartRetryablePromptDeliveryError(error)) {
         this.sessionIdentityCaptureRetryAt.set(resolved.sessionKey, Date.now() + SESSION_ID_CAPTURE_FAILURE_COOLDOWN_MS);
@@ -69477,16 +69889,36 @@ class RunnerService {
       throw error;
     }
     if (sessionId) {
-      this.sessionIdentityCaptureRetryAt.delete(resolved.sessionKey);
-    } else {
-      this.sessionIdentityCaptureRetryAt.set(resolved.sessionKey, Date.now() + SESSION_ID_CAPTURE_FAILURE_COOLDOWN_MS);
+      await this.persistStoredSessionIdBestEffort(resolved, sessionId, resolved.runner.command);
+      return {
+        sessionId
+      };
     }
-    return this.sessionState.touchSessionEntry(resolved, {
-      sessionId,
+    this.deferStoredSessionIdCapture(resolved.sessionKey);
+    return this.sessionMapping.touch(resolved, {
       runnerCommand: resolved.runner.command
     });
   }
-  async captureSessionIdentity(resolved, options = {}) {
+  persistStoredSessionId(resolved, sessionId, runnerCommand = resolved.runner.command) {
+    this.sessionIdentityCaptureRetryAt.delete(resolved.sessionKey);
+    return this.sessionMapping.setActive(resolved, {
+      sessionId,
+      runnerCommand
+    });
+  }
+  async persistStoredSessionIdBestEffort(resolved, sessionId, runnerCommand = resolved.runner.command) {
+    try {
+      await this.persistStoredSessionId(resolved, sessionId, runnerCommand);
+      return true;
+    } catch (error) {
+      this.warnStartupSessionIdentityDegraded(resolved, error);
+      return false;
+    }
+  }
+  deferStoredSessionIdCapture(sessionKey) {
+    this.sessionIdentityCaptureRetryAt.set(sessionKey, Date.now() + SESSION_ID_CAPTURE_FAILURE_COOLDOWN_MS);
+  }
+  async captureSessionIdFromRunner(resolved, options = {}) {
     const capture = resolved.runner.sessionId.capture;
     if (capture.mode !== "status-command" && !options.forceStatusCommand) {
       return null;
@@ -69514,12 +69946,39 @@ class RunnerService {
       remainingFreshRetries: remainingFreshRetries - 1
     });
   }
-  async retryAfterStartupFault(target, resolved, error, remainingFreshRetries) {
+  async retryAfterStartupFault(target, resolved, error, remainingFreshRetries, allowFreshResumeFallback) {
+    if (allowFreshResumeFallback) {
+      const resumedFresh = await this.retryFreshStartAfterStoredResumeFailure(target, resolved, error, remainingFreshRetries);
+      if (resumedFresh) {
+        return resumedFresh;
+      }
+    }
     if (!isRetryableFreshStartFault(error)) {
       return null;
     }
     return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries);
   }
+  async retryFreshStartAfterStoredResumeFailure(target, resolved, error, remainingFreshRetries) {
+    if (!isRecoverableStartupSessionLoss(error)) {
+      return null;
+    }
+    if (resolved.runner.sessionId.resume.mode !== "command" || resolved.runner.sessionId.create.mode !== "runner") {
+      return null;
+    }
+    const existing = await this.sessionMapping.get(resolved.sessionKey);
+    if (!existing?.sessionId) {
+      return null;
+    }
+    const exitRecord = await readRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
+    if (!exitRecord || exitRecord.exitCode === 0) {
+      return null;
+    }
+    console.log(`clisbot preserved stored sessionId after failed runner resume startup ${resolved.sessionName}`);
+    await this.sessionMapping.touch(resolved, {
+      runnerCommand: resolved.runner.command
+    });
+    throw new Error(PRESERVED_SESSION_ID_RETRY_MESSAGE);
+  }
   async retryAfterStartupTimeout(target, resolved, remainingFreshRetries) {
     return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries);
   }
@@ -69547,7 +70006,7 @@ class RunnerService {
       try {
         const snapshot = await this.captureSessionSnapshot(resolved);
         if (tmuxPaneHasTrustPrompt(snapshot)) {
-          await this.dismissVisibleTrustPrompt(resolved);
+          await this.acceptVisibleWorkspaceTrustPrompt(resolved);
           continue;
         }
         return;
@@ -69610,18 +70069,16 @@ class RunnerService {
     await ensureDir2(resolved.workspacePath);
     await ensureDir2(dirname12(this.loadedConfig.raw.tmux.socketPath));
     await ensureRunnerExitRecordDir(this.loadedConfig.stateDir, resolved.sessionName);
-    const existing = await this.sessionState.getEntry(resolved.sessionKey);
+    const preparedMapping = await this.sessionMapping.prepareStartup(resolved);
     const serverRunning = await this.tmux.isServerRunning();
     if (serverRunning && await this.tmux.hasSession(resolved.sessionName)) {
       logLatencyDebug("ensure-session-ready-existing-session", timingContext, {
-        hasStoredSessionId: Boolean(existing?.sessionId)
+        hasStoredSessionId: Boolean(preparedMapping.storedSessionId)
       });
       try {
         await clearRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
-        await this.sessionState.touchSessionEntry(resolved, {
-          sessionId: existing?.sessionId,
-          runnerCommand: resolved.runner.command
-        });
+        await this.acceptWorkspaceTrustPromptIfPresent(resolved);
+        await this.syncStoredSessionIdForResolvedTarget(resolved);
       } catch (error) {
         throw await this.mapSessionError(error, resolved.sessionName, "during startup");
       }
@@ -69634,10 +70091,10 @@ class RunnerService {
     if (!resolved.session.createIfMissing) {
       throw new Error(`tmux session "${resolved.sessionName}" does not exist`);
     }
-    const startupSessionId = existing?.sessionId || (resolved.runner.sessionId.create.mode === "explicit" ? createSessionId() : "");
-    const resumingExistingSession = Boolean(existing?.sessionId);
+    const storedOrExplicitSessionId = preparedMapping.sessionId ?? "";
+    const resumingExistingSession = preparedMapping.resume;
     const runnerLaunch = this.buildRunnerArgs(resolved, {
-      sessionId: startupSessionId || undefined,
+      sessionId: storedOrExplicitSessionId || undefined,
       resume: resumingExistingSession
     });
     await clearRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
@@ -69665,7 +70122,7 @@ class RunnerService {
       logLatencyDebug("ensure-session-ready-new-session", timingContext, {
         startupDelayMs: resolved.runner.startupDelayMs,
         resumingExistingSession,
-        hasStoredSessionId: Boolean(existing?.sessionId)
+        hasStoredSessionId: Boolean(preparedMapping.storedSessionId)
       });
       const bootstrapResult = await waitForTmuxSessionBootstrap({
         tmux: this.tmux,
@@ -69687,11 +70144,11 @@ class RunnerService {
         await this.abortUnreadySession(resolved, `Runner session "${resolved.sessionName}" did not reach the configured ready state within ${resolved.runner.startupDelayMs}ms.`, bootstrapResult.snapshot);
       }
       await this.finalizeSessionStartup(resolved, {
-        startupSessionId,
+        storedOrExplicitSessionId,
         runnerCommand: runnerLaunch.command
       });
     } catch (error) {
-      const retried = await this.retryAfterStartupFault(target, resolved, error, remainingFreshRetries);
+      const retried = await this.retryAfterStartupFault(target, resolved, error, remainingFreshRetries, options.allowFreshRetry !== false);
       if (retried) {
         return retried;
       }
@@ -69704,25 +70161,48 @@ class RunnerService {
     return resolved;
   }
   async finalizeSessionStartup(resolved, params) {
-    await this.dismissTrustPrompt(resolved);
+    await this.acceptWorkspaceTrustPromptIfPresent(resolved);
     await this.verifySessionReady(resolved);
-    if (params.startupSessionId) {
-      await this.sessionState.touchSessionEntry(resolved, {
-        sessionId: params.startupSessionId,
-        runnerCommand: params.runnerCommand
-      });
+    if (params.storedOrExplicitSessionId) {
+      await this.persistStoredSessionIdBestEffort(resolved, params.storedOrExplicitSessionId, params.runnerCommand);
       return;
     }
-    await this.syncSessionIdentity(resolved);
+    const entry = await this.syncStoredSessionIdForResolvedTarget(resolved);
+    if (entry?.sessionId) {
+      return;
+    }
+    await this.retryMissingStoredSessionIdAfterStartup(resolved);
   }
-  async dismissTrustPrompt(resolved) {
+  warnStartupSessionIdentityDegraded(resolved, error) {
+    console.warn(`clisbot could not persist or confirm a durable sessionId after startup for ${resolved.sessionName}; continuing without resumable state`, error);
+  }
+  async retryMissingStoredSessionIdAfterStartup(resolved) {
+    for (let attempt = 0;attempt < STARTUP_SESSION_ID_CAPTURE_RETRY_COUNT; attempt += 1) {
+      await sleep(STARTUP_SESSION_ID_CAPTURE_RETRY_DELAY_MS);
+      let sessionId = null;
+      try {
+        sessionId = await this.captureSessionIdFromRunner(resolved);
+      } catch (error) {
+        if (isRecoverableStartupSessionLoss(error) || isTransientTmuxTargetError(error) || isFreshStartRetryablePromptDeliveryError(error)) {
+          continue;
+        }
+        return;
+      }
+      if (!sessionId) {
+        continue;
+      }
+      await this.persistStoredSessionIdBestEffort(resolved, sessionId);
+      return;
+    }
+  }
+  async acceptWorkspaceTrustPromptIfPresent(resolved) {
     if (!resolved.runner.trustWorkspace) {
       return;
     }
-    await this.dismissVisibleTrustPrompt(resolved);
+    await this.acceptVisibleWorkspaceTrustPrompt(resolved);
   }
-  async dismissVisibleTrustPrompt(resolved) {
-    await dismissTmuxTrustPromptIfPresent({
+  async acceptVisibleWorkspaceTrustPrompt(resolved) {
+    await acceptTmuxTrustPromptIfPresent({
       tmux: this.tmux,
       sessionName: resolved.sessionName,
       captureLines: resolved.stream.captureLines,
@@ -69765,8 +70245,8 @@ class RunnerService {
   }
   async reopenRunContext(target, timingContext) {
     const resolved = this.resolveTarget(target);
-    const existing = await this.sessionState.getEntry(resolved.sessionKey);
-    if (!existing?.sessionId || resolved.runner.sessionId.resume.mode !== "command") {
+    const existing = await this.sessionMapping.get(resolved.sessionKey);
+    if (!existing?.sessionId || !canRestartWithStoredSessionId(resolved)) {
       throw new Error(`Runner session "${resolved.sessionName}" cannot reopen the same conversation context.`);
     }
     return this.ensureRunnerReady(target, { allowFreshRetryBeforePrompt: false, timingContext });
@@ -69777,7 +70257,9 @@ class RunnerService {
       return;
     });
     console.log(`clisbot clearing stored sessionId for explicit fresh session ${resolved.sessionName}`);
-    await this.sessionState.clearSessionIdEntry(resolved, { runnerCommand: resolved.runner.command });
+    await this.sessionMapping.clearActive(resolved, {
+      runnerCommand: resolved.runner.command
+    });
     return this.ensureRunnerReady(target, {
       allowFreshRetryBeforePrompt: false,
       timingContext
@@ -69799,26 +70281,37 @@ class RunnerService {
     });
   }
   async triggerNewSessionInLiveRunner(resolved) {
-    const oldSessionId = (await this.sessionState.getEntry(resolved.sessionKey))?.sessionId;
+    const oldSessionId = (await this.sessionMapping.get(resolved.sessionKey))?.sessionId;
     const command = this.resolveNewSessionCommand(resolved);
-    let sessionId = null;
-    for (let attempt = 0;attempt < 2; attempt += 1) {
+    await this.acceptWorkspaceTrustPromptIfPresent(resolved);
+    let submitUnconfirmedError = null;
+    try {
       await this.submitNewSessionCommand(resolved, command);
-      sessionId = await this.captureNewSessionIdentityAfterTrigger(resolved, oldSessionId);
-      if (sessionId) {
-        break;
+    } catch (error) {
+      if (error instanceof TmuxSubmitUnconfirmedError) {
+        submitUnconfirmedError = error;
+      } else {
+        throw error;
       }
     }
+    const sessionId = await this.captureNewSessionIdentityAfterTrigger(resolved, oldSessionId);
     if (!sessionId) {
-      await this.clearSessionIdAfterNewSessionFailure(resolved, command);
-    }
-    await this.sessionState.touchSessionEntry(resolved, {
-      sessionId,
-      runnerCommand: resolved.runner.command,
-      runtime: {
-        state: "idle"
+      if (submitUnconfirmedError) {
+        throw submitUnconfirmedError;
       }
-    });
+      this.throwNewSessionCaptureFailure(command, oldSessionId);
+    }
+    try {
+      await this.sessionMapping.setActive(resolved, {
+        sessionId,
+        runnerCommand: resolved.runner.command,
+        runtime: {
+          state: "idle"
+        }
+      });
+    } catch (error) {
+      this.throwNewSessionPersistFailure(command, sessionId, error);
+    }
     return {
       agentId: resolved.agentId,
       sessionKey: resolved.sessionKey,
@@ -69831,7 +70324,7 @@ class RunnerService {
   }
   async restartRunnerWithFreshSessionIdForNewCommand(target) {
     const { resolved } = await this.restartRunnerWithFreshSessionId(target);
-    const entry = await this.sessionState.getEntry(resolved.sessionKey);
+    const entry = await this.sessionMapping.get(resolved.sessionKey);
     return {
       agentId: resolved.agentId,
       sessionKey: resolved.sessionKey,
@@ -69852,29 +70345,34 @@ class RunnerService {
     });
   }
   async captureNewSessionIdentityAfterTrigger(resolved, oldSessionId) {
-    for (let attempt = 0;attempt < TRIGGER_NEW_SESSION_CAPTURE_RETRY_COUNT; attempt += 1) {
-      const sessionId = await this.captureSessionIdentity(resolved, {
+    for (let attempt = 0;attempt < SESSION_READY_CAPTURE_RETRY_COUNT; attempt += 1) {
+      const sessionId = await this.captureSessionIdFromRunner(resolved, {
         forceStatusCommand: true
       });
       if (sessionId && sessionId !== oldSessionId) {
         return sessionId;
       }
-      if (attempt < TRIGGER_NEW_SESSION_CAPTURE_RETRY_COUNT - 1) {
+      if (attempt < SESSION_READY_CAPTURE_RETRY_COUNT - 1) {
         await sleep(SESSION_READY_CAPTURE_RETRY_DELAY_MS);
       }
     }
     return null;
   }
-  async clearSessionIdAfterNewSessionFailure(resolved, command) {
-    console.log(`clisbot clearing stored sessionId after ${command} because status capture returned no id for ${resolved.sessionName}`);
-    await this.sessionState.clearSessionIdEntry(resolved, {
-      runnerCommand: resolved.runner.command
+  throwNewSessionCaptureFailure(command, oldSessionId) {
+    console.log(`clisbot preserved the previous stored sessionId after ${command} because status capture returned no id`);
+    throw new Error(oldSessionId ? `${command} completed, but clisbot could not confirm the rotated session id. The previous stored session id was preserved instead of being cleared automatically.` : `${command} completed, but clisbot could not capture a new session id from the runner status command.`);
+  }
+  throwNewSessionPersistFailure(command, sessionId, error) {
+    console.error(`clisbot failed to persist rotated sessionId after ${command}`, {
+      sessionId,
+      error
     });
-    throw new Error(`${command} completed, but clisbot could not capture a new session id from the runner status command.`);
+    const details = error instanceof Error && error.message.trim() ? ` Persist error: ${error.message.trim()}` : "";
+    throw new Error(`${command} completed and clisbot captured session id ${sessionId}, but could not persist it. The durable session mapping was left unchanged.${details}`);
   }
   async killRunnerAndPreserveSessionId(resolved) {
     await this.tmux.killSession(resolved.sessionName);
-    await this.sessionState.touchSessionEntry(resolved, {
+    await this.sessionMapping.touch(resolved, {
       runnerCommand: resolved.runner.command
     });
   }
@@ -69892,7 +70390,6 @@ class RunnerService {
         snapshot: ""
       };
     }
-    await this.sessionState.touchSessionEntry(resolved);
     try {
       return {
         agentId: resolved.agentId,
@@ -69918,14 +70415,13 @@ class RunnerService {
     const resolved = this.resolveTarget(target);
     const existed = await this.tmux.hasSession(resolved.sessionName);
     if (existed) {
-      await this.sessionState.touchSessionEntry(resolved, {
+      await this.sessionMapping.touch(resolved, {
         runtime: {
           state: "idle"
         }
       });
       try {
         await this.tmux.sendKey(resolved.sessionName, "Escape");
-        await sleep(150);
       } catch {}
     }
     return {
@@ -69941,7 +70437,7 @@ class RunnerService {
     const existed = await this.tmux.hasSession(resolved.sessionName);
     if (existed) {
       await this.tmux.sendKey(resolved.sessionName, "Enter");
-      await this.sessionState.touchSessionEntry(resolved);
+      await this.sessionMapping.touch(resolved);
     }
     return {
       agentId: resolved.agentId,
@@ -69976,6 +70472,7 @@ class RunnerService {
     if (!await this.tmux.hasSession(resolved.sessionName)) {
       throw new Error(`tmux session "${resolved.sessionName}" does not exist`);
     }
+    await this.acceptWorkspaceTrustPromptIfPresent(resolved);
     await submitTmuxSessionInput({
       tmux: this.tmux,
       sessionName: resolved.sessionName,
@@ -69983,7 +70480,7 @@ class RunnerService {
       promptSubmitDelayMs: resolved.runner.promptSubmitDelayMs,
       timingContext: undefined
     });
-    await this.sessionState.touchSessionEntry(resolved);
+    await this.sessionMapping.touch(resolved);
     return {
       agentId: resolved.agentId,
       sessionKey: resolved.sessionKey,
@@ -70048,12 +70545,20 @@ async function monitorTmuxRun(params) {
   let previousRenderedRunningSnapshot = "";
   let lastPaneChangeAt = params.startedAt;
   let sawActivity = false;
-  let sawPaneChange = false;
+  let sawPaneChange = Boolean(normalizePaneText(params.initialSnapshot));
   let sawPromptSubmission = Boolean(params.prompt);
   let detachedNotified = params.detachedAlready;
   let firstMeaningfulDeltaLogged = false;
   let noOutputThresholdLogged = false;
   if (params.prompt) {
+    if (params.trustWorkspace) {
+      await acceptTmuxTrustPromptIfPresent({
+        tmux: params.tmux,
+        sessionName: params.sessionName,
+        captureLines: params.captureLines,
+        startupDelayMs: params.startupDelayMs ?? 0
+      });
+    }
     logLatencyDebug("tmux-submit-start", params.timingContext, {
       sessionName: params.sessionName,
       promptSubmitDelayMs: params.promptSubmitDelayMs
@@ -70193,6 +70698,12 @@ function isRetryableObserverDeliveryError(error) {
   const message = error instanceof Error ? `${error.name} ${error.message}` : String(error);
   return /fetch failed|request timed out|network|socket hang up/i.test(message);
 }
+function buildMissingSessionIdStartupWarning() {
+  return [
+    "Runner session started, but clisbot could not capture a durable session id yet.",
+    "This session is running, but it is not resumable until a session id is captured and persisted."
+  ].join(" ");
+}
 
 class ActiveRunInProgressError extends Error {
   update;
@@ -70247,15 +70758,40 @@ class SessionService {
     this.resolveTarget = resolveTarget;
   }
   async recoverPersistedRuns() {
+    const activeSessionKeys = new Set;
     const entries = await this.sessionState.listEntries();
     for (const entry of entries) {
       if (!entry.runtime || entry.runtime.state === "idle") {
         continue;
       }
-      await this.reconcilePersistedActiveRun({
+      const run = await this.reconcilePersistedActiveRun({
         agentId: entry.agentId,
         sessionKey: entry.sessionKey
       });
+      if (run) {
+        activeSessionKeys.add(run.resolved.sessionKey);
+      }
+    }
+    return activeSessionKeys;
+  }
+  async clearLostPersistedActiveRuns() {
+    const entries = await this.sessionState.listEntries();
+    for (const entry of entries) {
+      if (!entry.runtime || entry.runtime.state === "idle") {
+        continue;
+      }
+      if (this.activeRuns.has(entry.sessionKey)) {
+        continue;
+      }
+      const resolved = this.resolveTarget({
+        agentId: entry.agentId,
+        sessionKey: entry.sessionKey
+      });
+      if (!await this.tmux.hasSession(resolved.sessionName)) {
+        await this.sessionState.setSessionRuntime(resolved, {
+          state: "idle"
+        });
+      }
     }
   }
   async executePrompt(target, prompt, observer, options = {}) {
@@ -70310,6 +70846,7 @@ class SessionService {
         throw new Error(`Active run disappeared during startup for ${provisionalResolved.sessionKey}.`);
       }
       run.resolved = resolved;
+      run.sessionId = (await this.sessionState.getEntry(resolved.sessionKey))?.sessionId?.trim() || undefined;
       run.startedAt = startedAt;
       run.latestUpdate = this.createRunUpdate({
         resolved,
@@ -70322,6 +70859,17 @@ class SessionService {
         state: "running",
         startedAt
       });
+      if (!run.sessionId) {
+        await this.notifyRunObservers(run, this.createRunUpdate({
+          resolved,
+          status: "running",
+          snapshot: "",
+          fullSnapshot: initialSnapshot,
+          initialSnapshot,
+          note: buildMissingSessionIdStartupWarning(),
+          forceVisible: true
+        }));
+      }
       this.startRunMonitor(resolved.sessionKey, {
         runId,
         prompt,
@@ -70392,6 +70940,34 @@ class SessionService {
       detached: true
     };
   }
+  async interruptActiveRun(target) {
+    const run = this.activeRuns.get(target.sessionKey) ?? await this.reconcilePersistedActiveRun(target);
+    if (!run) {
+      return {
+        interrupted: false
+      };
+    }
+    const error = new Error("Run interrupted by /stop.");
+    const update = this.createRunUpdate({
+      resolved: run.resolved,
+      status: "error",
+      snapshot: error.message,
+      fullSnapshot: run.latestUpdate.fullSnapshot,
+      initialSnapshot: run.latestUpdate.initialSnapshot,
+      note: "Run interrupted."
+    });
+    await this.sessionState.setSessionRuntime(run.resolved, {
+      state: "idle"
+    });
+    await this.notifyRunObservers(run, update);
+    if (!run.initialResult.settled) {
+      run.initialResult.reject(error);
+    }
+    this.activeRuns.delete(run.resolved.sessionKey);
+    return {
+      interrupted: true
+    };
+  }
   hasActiveRun(target) {
     return this.activeRuns.has(target.sessionKey);
   }
@@ -70439,6 +71015,17 @@ class SessionService {
     }
     this.activeRuns.clear();
   }
+  listLiveSessionRuntimes() {
+    return [...this.activeRuns.values()].map((run) => ({
+      state: run.latestUpdate.status === "detached" ? "detached" : "running",
+      startedAt: run.startedAt,
+      sessionKey: run.resolved.sessionKey,
+      agentId: run.resolved.agentId
+    }));
+  }
+  getLiveSessionId(target) {
+    return this.activeRuns.get(target.sessionKey)?.sessionId;
+  }
   buildDetachedNote(resolved) {
     return `This session has been running for over ${resolved.stream.maxRuntimeLabel}. clisbot left it running and will post the final result here when it completes. Use \`/attach\` for live updates, \`/watch every <duration>\` for periodic updates, or \`/stop\` to interrupt it.`;
   }
@@ -70641,6 +71228,7 @@ class SessionService {
         return true;
       }
       currentRun.resolved = recovered.resolved;
+      currentRun.sessionId = (await this.sessionState.getEntry(recovered.resolved.sessionKey))?.sessionId?.trim() || currentRun.sessionId;
       currentRun.latestUpdate = this.createRunUpdate({
         resolved: currentRun.resolved,
         status: currentRun.latestUpdate.status === "detached" ? "detached" : "running",
@@ -70674,7 +71262,7 @@ class SessionService {
       if (!currentRun) {
         return true;
       }
-      if (await this.hasStoredResumableSessionId(currentRun.resolved)) {
+      if (await this.requiresManualNewAfterFailedResume(currentRun)) {
         await this.notifyRecoveryStep(currentRun, buildRunRecoveryNote("resume-failed"));
         await this.failActiveRun(sessionKey, currentRun.runId, new Error(buildRunRecoveryNote("manual-new-required")));
         return true;
@@ -70690,12 +71278,13 @@ class SessionService {
       return true;
     }
   }
-  async hasStoredResumableSessionId(resolved) {
-    if (resolved.runner.sessionId.resume.mode !== "command") {
+  async requiresManualNewAfterFailedResume(run) {
+    const storedSessionId = (await this.sessionState.getEntry(run.resolved.sessionKey))?.sessionId?.trim() || "";
+    if (!storedSessionId) {
       return false;
     }
-    const entry = await this.sessionState.getEntry(resolved.sessionKey);
-    return Boolean(entry?.sessionId);
+    run.sessionId = storedSessionId;
+    return true;
   }
   startRunMonitor(sessionKey, params) {
     const run = this.getRun(sessionKey, params.runId);
@@ -70712,6 +71301,8 @@ class SessionService {
           sessionName: run.resolved.sessionName,
           prompt: params.prompt,
           promptSubmitDelayMs: run.resolved.runner.promptSubmitDelayMs,
+          trustWorkspace: run.resolved.runner.trustWorkspace,
+          startupDelayMs: run.resolved.runner.startupDelayMs,
           captureLines: run.resolved.stream.captureLines,
           updateIntervalMs: run.resolved.stream.updateIntervalMs,
           idleTimeoutMs: run.resolved.stream.idleTimeoutMs,
@@ -70857,6 +71448,7 @@ class SessionService {
     const run = {
       runId,
       resolved,
+      sessionId: (await this.sessionState.getEntry(resolved.sessionKey))?.sessionId?.trim() || undefined,
       observers: new Map,
       observerFailures: new Map,
       initialResult,
@@ -71071,14 +71663,9 @@ var EMPTY_PROGRESS_PHRASE = "";
 var PROGRESS_FLAG_SUFFIX = "|progress";
 var EMPTY_PROGRESS_FLAG_SUFFIX = "";
 var PROGRESS_RULES_BLOCK = `- use that command to send progress updates and the final reply back to the conversation
-- send at most {{max_progress_messages}} progress updates
-- keep progress updates short and meaningful
-- do not send progress updates for trivial internal steps
-`;
-var FINAL_ONLY_RULES_BLOCK = `- use that command only for the final user-facing reply
-- do not send user-facing progress updates for this conversation
+- send at most {{max_progress_messages}} short, meaningful progress updates; skip trivial internal steps
 `;
-var FINAL_RULE_REQUIRED = "send exactly 1 final user-facing response";
+var FINAL_RULE_REQUIRED = "send a single final user-facing message by default; split only when channel limits require it or clarity would otherwise suffer";
 var FINAL_RULE_OPTIONAL = "final response is optional";
 var EMPTY_REPLY_COMMAND = "";
 var EMPTY_REPLY_RULES = "";
@@ -71096,8 +71683,10 @@ var TELEGRAM_REPLY_COMMAND_BASE = `{{command}} message send \\
   --render native \\
 `;
 var SLACK_REPLY_STYLE_HINT = `Put readable hierarchical Markdown in the --message body.
+For clickable links, use canonical URLs and do not wrap them in backticks.
 Keep each paragraph, list, or code block under 2500 chars.`;
 var TELEGRAM_REPLY_STYLE_HINT = `Put readable hierarchical Markdown in the --message body.
+For clickable links, use canonical URLs and do not wrap them in backticks.
 Keep the Markdown body under 3000 chars.`;
 var ACCOUNT_CLAUSE = "  --account {{account_id}} \\\n";
 var EMPTY_ACCOUNT_CLAUSE = "";
@@ -71138,7 +71727,8 @@ function buildChannelPromptText(params) {
     identity: params.identity,
     config: params.config,
     responseMode: params.responseMode,
-    streaming: params.streaming
+    streaming: params.streaming,
+    maxProgressMessagesOverride: params.maxProgressMessagesOverride
   });
   const context = resolvePromptContext(params);
   return renderTemplate(BASE_TEMPLATE, {
@@ -71183,10 +71773,11 @@ function renderMessagePromptParts(params) {
       replyStyleHint: EMPTY_REPLY_STYLE_HINT
     };
   }
-  const allowProgress = (params.streaming ?? "off") === "off";
-  const progressPhrase = allowProgress ? PROGRESS_PHRASE : EMPTY_PROGRESS_PHRASE;
-  const progressFlagSuffix = allowProgress ? PROGRESS_FLAG_SUFFIX : EMPTY_PROGRESS_FLAG_SUFFIX;
-  const progressRulesBlock = allowProgress ? PROGRESS_RULES_BLOCK : FINAL_ONLY_RULES_BLOCK;
+  const maxProgressMessages = Math.max(0, params.maxProgressMessagesOverride ?? params.config.maxProgressMessages);
+  const progressEnabled = maxProgressMessages > 0;
+  const progressPhrase = progressEnabled ? PROGRESS_PHRASE : EMPTY_PROGRESS_PHRASE;
+  const progressFlagSuffix = progressEnabled ? PROGRESS_FLAG_SUFFIX : EMPTY_PROGRESS_FLAG_SUFFIX;
+  const progressRulesBlock = progressEnabled ? PROGRESS_RULES_BLOCK : "";
   const finalRuleLine = params.config.requireFinalResponse ? FINAL_RULE_REQUIRED : FINAL_RULE_OPTIONAL;
   return {
     deliveryIntro: renderTemplate(DELIVERY_INTRO, {
@@ -71201,7 +71792,7 @@ function renderMessagePromptParts(params) {
     }),
     replyRules: renderTemplate(REPLY_RULES, {
       progress_rules_block: renderTemplate(progressRulesBlock, {
-        max_progress_messages: String(params.config.maxProgressMessages)
+        max_progress_messages: String(maxProgressMessages)
       }),
       final_rule_line: finalRuleLine
     }),
@@ -71215,8 +71806,9 @@ function renderConfigurationGuidance() {
   const cliName = getRenderedCliName();
   return [
     `When the user asks to change ${cliName} configuration, use ${cliName} CLI commands; see ${renderCliCommand("--help", { inline: true })}, ${renderCliCommand("bots --help", { inline: true })}, ${renderCliCommand("routes --help", { inline: true })}, ${renderCliCommand("auth --help", { inline: true })}, or ${renderCliCommand("update --help", { inline: true })} for details.`,
+    `For ${cliName} install or update requests, check ${renderCliCommand("update --help", { inline: true })} first and follow it.`,
     `For schedule/loop/reminder requests, inspect ${renderCliCommand("loops --help", { inline: true })} and use the loops CLI.`,
-    `For durable queue inspection or one-shot queued prompts, inspect ${renderCliCommand("queues --help", { inline: true })} and use ${renderCliCommand("queues create --channel <slack|telegram> --target <route> --sender <principal> <prompt>", { inline: true })}.`
+    `For durable queue requests, inspect ${renderCliCommand("queues --help", { inline: true })} and use the queues CLI.`
   ].join(`
 `);
 }
@@ -71266,9 +71858,11 @@ function buildReplyCommandBase(params) {
 }
 
 // src/channels/mode-config-shared.ts
-function createTelegramRouteOverride() {
+function createTelegramRouteOverride(base) {
   return {
-    enabled: true,
+    enabled: base?.enabled ?? true,
+    requireMention: base?.requireMention ?? true,
+    allowBots: base?.allowBots ?? false,
     allowUsers: [],
     blockUsers: []
   };
@@ -71291,7 +71885,7 @@ function getOrCreateTelegramTopicRoute(bot, chatId, topicId) {
   if (existingTopic) {
     return existingTopic;
   }
-  const createdTopic = createTelegramRouteOverride();
+  const createdTopic = createTelegramRouteOverride(group);
   group.topics[topicId] = createdTopic;
   return createdTopic;
 }
@@ -71722,8 +72316,9 @@ class SurfaceRuntime {
     }
     const identity = this.buildLoopChannelIdentity(loop);
     const notifications = this.resolveSurfaceNotifications(identity);
+    const mode = loop.loopStart ?? notifications.loopStart;
     const text = loop.kind === "calendar" ? renderLoopStartNotification({
-      mode: notifications.loopStart,
+      mode,
       agentId: target.agentId,
       loopId: loop.id,
       promptSummary: loop.promptSummary,
@@ -71736,7 +72331,7 @@ class SurfaceRuntime {
       maxRuns: loop.maxRuns,
       kind: "calendar"
     }) : renderLoopStartNotification({
-      mode: notifications.loopStart,
+      mode,
       agentId: target.agentId,
       loopId: loop.id,
       promptSummary: loop.promptSummary,
@@ -71824,7 +72419,7 @@ class SurfaceRuntime {
     }
   }
   async buildManagedLoopPrompt(agentId, loop) {
-    if (!loop.canonicalPromptText || !loop.surfaceBinding) {
+    if (!loop.surfaceBinding) {
       return loop.promptText;
     }
     const identity = this.buildLoopChannelIdentity(loop);
@@ -71839,7 +72434,7 @@ class SurfaceRuntime {
       scheduledLoopId: loop.id
     });
     return buildAgentPromptText({
-      text: loop.canonicalPromptText,
+      text: loop.promptText,
       identity,
       config: channelConfig.agentPrompt,
       cliTool: getAgentEntry2(this.loadedConfig, agentId)?.cli,
@@ -71849,11 +72444,12 @@ class SurfaceRuntime {
       agentId,
       time: promptTime,
       promptContext,
-      scheduledLoopId: loop.id
+      scheduledLoopId: loop.id,
+      maxProgressMessagesOverride: loop.progressMessages
     });
   }
   async buildManagedQueuePrompt(agentId, item) {
-    if (!item.canonicalPromptText || !item.surfaceBinding) {
+    if (!item.surfaceBinding) {
       return item.promptText;
     }
     const identity = this.buildQueueChannelIdentity(item);
@@ -71867,7 +72463,7 @@ class SurfaceRuntime {
       time: promptTime
     });
     return buildAgentPromptText({
-      text: item.canonicalPromptText,
+      text: item.promptText,
       identity,
       config: channelConfig.agentPrompt,
       cliTool: getAgentEntry2(this.loadedConfig, agentId)?.cli,
@@ -72034,6 +72630,7 @@ class AgentService {
   tmuxClient;
   queue = new AgentJobQueue;
   sessionState;
+  sessionMapping;
   runnerSessions;
   activeRuns;
   managedLoops;
@@ -72048,7 +72645,8 @@ class AgentService {
     this.tmuxClient = deps.tmux ?? new TmuxClient(this.loadedConfig.raw.tmux.socketPath);
     const sessionStore = deps.sessionStore ?? new SessionStore(resolveSessionStorePath(this.loadedConfig));
     this.sessionState = new AgentSessionState(sessionStore);
-    this.runnerSessions = new RunnerService(this.loadedConfig, this.tmuxClient, this.sessionState, (target) => this.resolveTarget(target));
+    this.sessionMapping = new SessionMapping(this.sessionState);
+    this.runnerSessions = new RunnerService(this.loadedConfig, this.tmuxClient, this.sessionState, (target) => this.resolveTarget(target), this.sessionMapping);
     this.activeRuns = this.createSessionService();
     this.surfaceRuntime = new SurfaceRuntime(this.loadedConfig);
     this.managedQueues = this.createManagedQueueController();
@@ -72059,7 +72657,7 @@ class AgentService {
   }
   set tmux(value) {
     this.tmuxClient = value;
-    this.runnerSessions = new RunnerService(this.loadedConfig, this.tmuxClient, this.sessionState, (target) => this.resolveTarget(target));
+    this.runnerSessions = new RunnerService(this.loadedConfig, this.tmuxClient, this.sessionState, (target) => this.resolveTarget(target), this.sessionMapping);
     this.activeRuns = this.createSessionService();
     this.managedQueues = this.createManagedQueueController();
   }
@@ -72090,9 +72688,8 @@ class AgentService {
     });
   }
   async start() {
-    await this.activeRuns.recoverPersistedRuns();
-    const activeSessions = new Set((await this.sessionState.listActiveSessionRuntimes()).map((runtime) => runtime.sessionKey));
-    await this.sessionState.resetStaleRunningQueuedItems(activeSessions);
+    const activeSessionKeys = await this.activeRuns.recoverPersistedRuns();
+    await this.sessionState.resetStaleRunningQueuedItems(activeSessionKeys);
     await this.managedQueues.reconcilePersistedQueueItems();
     this.queueReconcileTimer = setInterval(() => {
       this.managedQueues.reconcilePersistedQueueItems().catch((error) => {
@@ -72150,7 +72747,12 @@ class AgentService {
     return this.runnerSessions.captureTranscript(target);
   }
   async interruptSession(target) {
-    return this.runnerSessions.interruptSession(target);
+    const runner = await this.runnerSessions.interruptSession(target);
+    const activeRun = await this.activeRuns.interruptActiveRun(target);
+    return {
+      ...runner,
+      interrupted: runner.interrupted || activeRun.interrupted
+    };
   }
   async nudgeSession(target) {
     return this.runnerSessions.nudgeSession(target);
@@ -72164,17 +72766,29 @@ class AgentService {
   async getSessionRuntime(target) {
     return this.sessionState.getSessionRuntime(target);
   }
+  async getSessionEntry(target) {
+    return this.sessionState.getEntry(target.sessionKey);
+  }
+  async listSessionEntries() {
+    return this.sessionState.listEntries();
+  }
   async getSessionDiagnostics(target) {
     const resolved = this.resolveTarget(target);
     const entry = await this.sessionState.getEntry(target.sessionKey);
-    const sessionId = entry?.sessionId?.trim() || undefined;
+    const liveSessionId = this.activeRuns.getLiveSessionId(target);
+    const storedSessionId = entry?.sessionId?.trim() || undefined;
+    const sessionId = liveSessionId ?? storedSessionId;
     return {
+      sessionName: resolved.sessionName,
       sessionId,
+      sessionIdPersistence: sessionId && sessionId === storedSessionId ? "persisted" : sessionId ? "not-persisted-yet" : undefined,
+      storedSessionId,
       resumeCommand: buildResumeCommandPreview(resolved, sessionId)
     };
   }
-  async listActiveSessionRuntimes() {
-    return this.sessionState.listActiveSessionRuntimes();
+  async listLiveSessionRuntimes() {
+    await this.activeRuns.clearLostPersistedActiveRuns();
+    return this.activeRuns.listLiveSessionRuntimes();
   }
   async setConversationFollowUpMode(target, mode) {
     return this.sessionState.setConversationFollowUpMode(this.resolveTarget(target), mode);
@@ -72275,8 +72889,8 @@ class AgentService {
   async createCalendarLoop(params) {
     return this.managedLoops.createCalendarLoop(params);
   }
-  async cancelIntervalLoop(loopId) {
-    return this.managedLoops.cancelIntervalLoop(loopId);
+  async cancelIntervalLoop(target, loopId) {
+    return this.managedLoops.cancelIntervalLoop(target, loopId);
   }
   async cancelIntervalLoopsForSession(target) {
     return this.managedLoops.cancelIntervalLoopsForSession(target);
@@ -72287,8 +72901,8 @@ class AgentService {
   listIntervalLoops(params) {
     return this.managedLoops.listIntervalLoops(params);
   }
-  getIntervalLoop(loopId) {
-    return this.managedLoops.getIntervalLoop(loopId);
+  getIntervalLoop(target, loopId) {
+    return this.managedLoops.getIntervalLoop(target.sessionKey, loopId);
   }
   getActiveIntervalLoopCount() {
     return this.managedLoops.getActiveIntervalLoopCount();
@@ -72340,9 +72954,8 @@ function createStoredQueueItem(params) {
     createdAt: now,
     updatedAt: now,
     promptText: params.promptText,
-    canonicalPromptText: params.canonicalPromptText,
     protectedControlMutationRule: params.protectedControlMutationRule,
-    promptSummary: params.promptSummary ?? summarizeQueuePrompt(params.canonicalPromptText ?? params.promptText),
+    promptSummary: params.promptSummary ?? summarizeQueuePrompt(params.promptText),
     promptSource: "custom",
     createdBy: params.createdBy,
     sender: params.sender,
@@ -72593,20 +73206,13 @@ function renderStartupSteeringUnavailableMessage() {
   ].join(`
 `);
 }
-function renderPrincipalFormat(identity) {
-  if (identity.platform === "slack") {
-    return "slack:<nativeUserId>";
-  }
-  return "telegram:<nativeUserId>";
-}
-function renderPrincipalExample(identity) {
-  if (identity.senderId) {
-    return `${identity.platform}:${identity.senderId}`;
-  }
-  if (identity.platform === "slack") {
-    return "slack:U123ABC456";
-  }
-  return "telegram:1276408333";
+function renderNewSessionFailureMessage(error) {
+  const details = error instanceof Error && error.message.trim() ? error.message.trim() : "Unknown error.";
+  return [
+    "Could not finish opening a new runner conversation.",
+    details
+  ].join(`
+`);
 }
 function renderWhoAmIMessage(params) {
   const lines = [
@@ -72615,9 +73221,13 @@ function renderWhoAmIMessage(params) {
     `platform: \`${params.identity.platform}\``,
     `conversationKind: \`${params.identity.conversationKind}\``,
     `agentId: \`${params.route.agentId}\``,
-    `sessionKey: \`${params.sessionTarget.sessionKey}\``,
-    `storedSessionId: \`${params.sessionDiagnostics.sessionId ?? "(not captured yet)"}\``
+    `sessionName: \`${params.sessionDiagnostics.sessionName ?? "(not available)"}\``,
+    `sessionId: \`${params.sessionDiagnostics.sessionId ?? "(not available yet)"}\``,
+    `sessionIdPersistence: \`${params.sessionDiagnostics.sessionIdPersistence ?? "not stored yet"}\``
   ];
+  if (params.sessionDiagnostics.storedSessionId && params.sessionDiagnostics.storedSessionId !== params.sessionDiagnostics.sessionId) {
+    lines.push(`storedSessionId: \`${params.sessionDiagnostics.storedSessionId}\``);
+  }
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
   }
@@ -72633,7 +73243,7 @@ function renderWhoAmIMessage(params) {
   if (params.identity.topicId) {
     lines.push(`topicId: \`${params.identity.topicId}\``);
   }
-  lines.push(`resumeCommand: \`${params.sessionDiagnostics.resumeCommand ?? "(not available yet)"}\``, `principal: \`${params.auth.principal ?? "(none)"}\``, `principalFormat: \`${renderPrincipalFormat(params.identity)}\``, `principalExample: \`${renderPrincipalExample(params.identity)}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayBypassPairing: \`${params.auth.mayBypassPairing}\``, `mayBypassSharedSenderPolicy: \`${params.auth.mayBypassSharedSenderPolicy}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `verbose: \`${params.route.verbose}\``);
+  lines.push(`resumeCommand: \`${params.sessionDiagnostics.resumeCommand ?? "(not available yet)"}\``, `principal: \`${params.auth.principal ?? "(none)"}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayBypassPairing: \`${params.auth.mayBypassPairing}\``, `mayBypassSharedSenderPolicy: \`${params.auth.mayBypassSharedSenderPolicy}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `verbose: \`${params.route.verbose}\``);
   return lines.join(`
 `);
 }
@@ -72644,9 +73254,13 @@ function renderRouteStatusMessage(params) {
     `platform: \`${params.identity.platform}\``,
     `conversationKind: \`${params.identity.conversationKind}\``,
     `agentId: \`${params.route.agentId}\``,
-    `sessionKey: \`${params.sessionTarget.sessionKey}\``,
-    `storedSessionId: \`${params.sessionDiagnostics.sessionId ?? "(not captured yet)"}\``
+    `sessionName: \`${params.sessionDiagnostics.sessionName ?? "(not available)"}\``,
+    `sessionId: \`${params.sessionDiagnostics.sessionId ?? "(not available yet)"}\``,
+    `sessionIdPersistence: \`${params.sessionDiagnostics.sessionIdPersistence ?? "not stored yet"}\``
   ];
+  if (params.sessionDiagnostics.storedSessionId && params.sessionDiagnostics.storedSessionId !== params.sessionDiagnostics.sessionId) {
+    lines.push(`storedSessionId: \`${params.sessionDiagnostics.storedSessionId}\``);
+  }
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
   }
@@ -72662,7 +73276,7 @@ function renderRouteStatusMessage(params) {
   if (params.identity.topicId) {
     lines.push(`topicId: \`${params.identity.topicId}\``);
   }
-  lines.push(`resumeCommand: \`${params.sessionDiagnostics.resumeCommand ?? "(not available yet)"}\``, `principal: \`${params.auth.principal ?? "(none)"}\``, `principalFormat: \`${renderPrincipalFormat(params.identity)}\``, `principalExample: \`${renderPrincipalExample(params.identity)}\``, `streaming: \`${params.route.streaming}\``, `response: \`${params.route.response}\``, `responseMode: \`${params.route.responseMode}\``, `additionalMessageMode: \`${params.route.additionalMessageMode}\``, `surfaceNotifications.queueStart: \`${params.route.surfaceNotifications.queueStart}\``, `surfaceNotifications.loopStart: \`${params.route.surfaceNotifications.loopStart}\``, `verbose: \`${params.route.verbose}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayBypassSharedSenderPolicy: \`${params.auth.mayBypassSharedSenderPolicy}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `timezone.effective: \`${params.timezone.effective}\``, `timezone.route: \`${params.timezone.route ?? "(inherit)"}\``, `timezone.bot: \`${params.timezone.bot ?? "(inherit)"}\``, `followUp.mode: \`${params.followUpState.overrideMode ?? params.route.followUp.mode}\``, `followUp.windowMinutes: \`${formatFollowUpTtlMinutes(params.route.followUp.participationTtlMs)}\``, `run.state: \`${params.runtimeState.state}\``);
+  lines.push(`resumeCommand: \`${params.sessionDiagnostics.resumeCommand ?? "(not available yet)"}\``, `principal: \`${params.auth.principal ?? "(none)"}\``, `streaming: \`${params.route.streaming}\``, `response: \`${params.route.response}\``, `additionalMessageMode: \`${params.route.additionalMessageMode}\``, `surfaceNotifications.queueStart: \`${params.route.surfaceNotifications.queueStart}\``, `surfaceNotifications.loopStart: \`${params.route.surfaceNotifications.loopStart}\``, `verbose: \`${params.route.verbose}\``, `appRole: \`${params.auth.appRole}\``, `agentRole: \`${params.auth.agentRole}\``, `mayBypassSharedSenderPolicy: \`${params.auth.mayBypassSharedSenderPolicy}\``, `mayManageProtectedResources: \`${params.auth.mayManageProtectedResources}\``, `canUseShell: \`${params.auth.canUseShell}\``, `timezone.effective: \`${params.timezone.effective}\``, `timezone.route: \`${params.timezone.route ?? "(inherit)"}\``, `timezone.bot: \`${params.timezone.bot ?? "(inherit)"}\``, `followUp.mode: \`${params.followUpState.overrideMode ?? params.route.followUp.mode}\``, `followUp.windowMinutes: \`${formatFollowUpTtlMinutes(params.route.followUp.participationTtlMs)}\``, `run.state: \`${params.runtimeState.state}\``);
   if (params.runtimeState.startedAt) {
     lines.push(`run.startedAt: \`${new Date(params.runtimeState.startedAt).toISOString()}\``);
   }
@@ -73422,7 +74036,6 @@ async function processChannelInteraction(params) {
   };
   const queueItem = forceQueuedDelivery ? createStoredQueueItem({
     promptText: delayedPromptQueueText,
-    canonicalPromptText: delayedPromptQueueText,
     promptSummary: explicitQueueMessage ?? summarizeQueuePrompt(delayedPromptQueueText),
     createdBy: params.senderId,
     sender: buildLoopSender(params.identity),
@@ -73552,14 +74165,18 @@ async function processChannelInteraction(params) {
         await params.agentService.recordConversationReply(params.sessionTarget);
         return interactionResult;
       }
-      const rotated = await params.agentService.triggerNewSession(params.sessionTarget);
-      await params.postText([
-        `Triggered a new runner conversation for agent \`${rotated.agentId}\`.`,
-        `sessionName: \`${rotated.sessionName}\``,
-        `storedSessionId: \`${rotated.sessionId ?? "none"}\``,
-        rotated.restartedRunner ? "No live runner existed, so clisbot opened a fresh runner session." : `triggerCommand: \`${rotated.command}\``
-      ].join(`
+      try {
+        const rotated = await params.agentService.triggerNewSession(params.sessionTarget);
+        await params.postText([
+          `Triggered a new runner conversation for agent \`${rotated.agentId}\`.`,
+          `sessionName: \`${rotated.sessionName}\``,
+          `sessionId: \`${rotated.sessionId ?? "none"}\``,
+          rotated.restartedRunner ? "No live runner existed, so clisbot opened a fresh runner session." : `triggerCommand: \`${rotated.command}\``
+        ].join(`
 `));
+      } catch (error) {
+        await params.postText(renderNewSessionFailureMessage(error));
+      }
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
     }
@@ -73735,7 +74352,7 @@ async function processChannelInteraction(params) {
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
     }
-    const cancelled = await params.agentService.cancelIntervalLoop(targetLoopId);
+    const cancelled = await params.agentService.cancelIntervalLoop(params.sessionTarget, targetLoopId);
     await params.postText(cancelled ? `Cancelled loop \`${targetLoopId}\`.` : `No active loop found with id \`${targetLoopId}\`.`);
     await params.agentService.recordConversationReply(params.sessionTarget);
     return interactionResult;
@@ -73820,9 +74437,9 @@ ${renderLoopUsage()}`);
       const createdLoop2 = await params.agentService.createCalendarLoop({
         target: params.sessionTarget,
         promptText: resolvedLoopPrompt.text,
-        canonicalPromptText: resolvedLoopPrompt.text,
         promptSummary: summarizeLoopPrompt(resolvedLoopPrompt.text, resolvedLoopPrompt.maintenancePrompt),
         promptSource: resolvedLoopPrompt.maintenancePrompt ? "LOOP.md" : "custom",
+        loopStart: slashCommand.params.loopStart,
         surfaceBinding: buildLoopSurfaceBinding(params.identity),
         cadence: slashCommand.params.cadence,
         dayOfWeek: slashCommand.params.dayOfWeek,
@@ -73859,9 +74476,9 @@ ${renderLoopUsage()}`);
     const createdLoop = await params.agentService.createIntervalLoop({
       target: params.sessionTarget,
       promptText: resolvedLoopPrompt.text,
-      canonicalPromptText: resolvedLoopPrompt.text,
       promptSummary: summarizeLoopPrompt(resolvedLoopPrompt.text, resolvedLoopPrompt.maintenancePrompt),
       promptSource: resolvedLoopPrompt.maintenancePrompt ? "LOOP.md" : "custom",
+      loopStart: slashCommand.params.loopStart,
       surfaceBinding: buildLoopSurfaceBinding(params.identity),
       intervalMs: effectiveIntervalMs,
       maxRuns: maxRunsPerLoop,
@@ -75347,9 +75964,9 @@ function getSlackMaxChars(maxMessageChars) {
 }
 
 // src/channels/runtime-identity.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function buildTokenHint(token) {
-  return createHash("sha256").update(token.trim()).digest("hex").slice(0, 8);
+  return createHash2("sha256").update(token.trim()).digest("hex").slice(0, 8);
 }
 
 // src/channels/slack/service.ts
@@ -75609,6 +76226,12 @@ class SlackSocketService {
         allowFrom: params.route.allowUsers ?? [],
         userId: senderId
       })) {
+        const explicitlyAddressed = params.wasMentioned || hasBotMention(event.text ?? "", this.botUserId);
+        if (params.route.requireMention && !explicitlyAddressed) {
+          debugSlackEvent("drop-shared-not-addressed", { eventId, senderId });
+          await this.processedEventsStore.markCompleted(eventId);
+          return;
+        }
         try {
           await postSlackText(this.app.client, {
             channel: channelId,
@@ -75949,7 +76572,7 @@ class SlackSocketService {
         senderId: slackSenderId,
         text,
         agentPromptText,
-        agentPromptBuilder: (nextText) => buildAgentPromptText({
+        agentPromptBuilder: (nextText, options) => buildAgentPromptText({
           text: enrichPromptText(nextText),
           identity,
           config: this.getBotConfig().agentPrompt,
@@ -75967,7 +76590,8 @@ class SlackSocketService {
             agentId: params.route.agentId,
             routeTimezone: params.route.timezone,
             botTimezone: params.route.botTimezone
-          }).timezone
+          }).timezone,
+          maxProgressMessagesOverride: options?.maxProgressMessagesOverride
         }),
         promptContext,
         protectedControlMutationRule,
@@ -76538,10 +77162,11 @@ function resolveSlackMessageContent(params) {
       throw new Error("Slack blocks input supports only --render none or --render blocks");
     }
     const blocks = parseSlackBlocksInput(text);
+    const fallbackText = buildSlackBlocksFallbackText(blocks);
     return {
-      text: buildSlackBlocksFallbackText(blocks),
+      text: fallbackText,
       blocks,
-      apiText: "​"
+      apiText: fallbackText
     };
   }
   if (inputFormat === "html") {
@@ -76549,10 +77174,11 @@ function resolveSlackMessageContent(params) {
   }
   if (renderMode === "blocks") {
     const blocks = renderMarkdownToSlackBlocks(text);
+    const fallbackText = buildSlackBlocksFallbackText(blocks);
     return {
-      text: buildSlackBlocksFallbackText(blocks),
+      text: fallbackText,
       blocks,
-      apiText: "​"
+      apiText: fallbackText
     };
   }
   if (renderMode === "html") {
@@ -77538,6 +78164,33 @@ function sanitizeTelegramHref(rawHref) {
   }
   return null;
 }
+function splitTrailingUrlPunctuation(rawUrl) {
+  let core = rawUrl;
+  let trailing = "";
+  while (/[.,!?;:]$/.test(core)) {
+    trailing = core.slice(-1) + trailing;
+    core = core.slice(0, -1);
+  }
+  while (core.endsWith(")")) {
+    const openCount = (core.match(/\(/g) ?? []).length;
+    const closeCount = (core.match(/\)/g) ?? []).length;
+    if (closeCount <= openCount) {
+      break;
+    }
+    trailing = ")" + trailing;
+    core = core.slice(0, -1);
+  }
+  while (core.endsWith("]")) {
+    const openCount = (core.match(/\[/g) ?? []).length;
+    const closeCount = (core.match(/]/g) ?? []).length;
+    if (closeCount <= openCount) {
+      break;
+    }
+    trailing = "]" + trailing;
+    core = core.slice(0, -1);
+  }
+  return { core, trailing };
+}
 function storeToken(tokens, value) {
   const token = `${TOKEN_PREFIX}${tokens.length};\x00`;
   tokens.push(value);
@@ -77564,6 +78217,14 @@ function renderInlineMarkdownToTelegramHtml(text) {
     }
     return storeToken(tokens, `<a href="${safeHref}">${escapeHtml(label)}</a>`);
   });
+  working = working.replaceAll(/\b(?:https?:\/\/|tg:\/\/|mailto:)[^\s<>"`]+/g, (rawUrl) => {
+    const { core, trailing } = splitTrailingUrlPunctuation(rawUrl);
+    const safeHref = sanitizeTelegramHref(core);
+    if (!safeHref) {
+      return rawUrl;
+    }
+    return storeToken(tokens, `<a href="${safeHref}">${escapeHtml(core)}</a>`) + trailing;
+  });
   working = escapeHtml(working);
   working = applyInlineFormatting(working);
   return restoreTokens(working, tokens);
@@ -77955,6 +78616,7 @@ var TELEGRAM_FULL_COMMANDS = [
   { command: "detach", description: "Stop live updates for this thread" },
   { command: "watch", description: "Watch the active run on an interval" },
   { command: "stop", description: "Interrupt current run" },
+  { command: "new", description: "Start new session" },
   { command: "nudge", description: "Send one extra Enter to the session" },
   { command: "followup", description: "Show or change follow-up mode" },
   { command: "mention", description: "Require explicit mention for later turns" },
@@ -78580,7 +79242,7 @@ class TelegramPollingService {
           senderId: message.from?.id != null ? String(message.from.id).trim() : undefined,
           text,
           agentPromptText,
-          agentPromptBuilder: (nextText) => buildAgentPromptText({
+          agentPromptBuilder: (nextText, options) => buildAgentPromptText({
             text: enrichPromptText(nextText),
             identity,
             config: this.getBotConfig().agentPrompt,
@@ -78598,7 +79260,8 @@ class TelegramPollingService {
               agentId: route.agentId,
               routeTimezone: route.timezone,
               botTimezone: route.botTimezone
-            }).timezone
+            }).timezone,
+            maxProgressMessagesOverride: options?.maxProgressMessagesOverride
           }),
           promptContext,
           protectedControlMutationRule,
@@ -79286,8 +79949,8 @@ var defaultRuntimeMonitorDependencies = {
   },
   readState: readRuntimeMonitorState,
   writeState: writeRuntimeMonitorState,
-  removePid: (pidPath) => rmSync2(pidPath, { force: true }),
-  removeRuntimeCredentials: (runtimeCredentialsPath) => rmSync2(runtimeCredentialsPath, { force: true }),
+  removePid: (pidPath) => rmSync3(pidPath, { force: true }),
+  removeRuntimeCredentials: (runtimeCredentialsPath) => rmSync3(runtimeCredentialsPath, { force: true }),
   sleep,
   now: () => Date.now(),
   spawnChild: (command, args, options) => spawn2(command, args, {
@@ -79837,7 +80500,7 @@ async function startDetachedRuntime(params) {
     };
   }
   if (existingPid) {
-    rmSync3(pidPath, { force: true });
+    rmSync4(pidPath, { force: true });
   }
   if (existingMonitorState?.runtimePid && isProcessRunning(existingMonitorState.runtimePid)) {
     kill2(existingMonitorState.runtimePid, "SIGTERM");
@@ -79946,7 +80609,7 @@ async function stopDetachedRuntime(params, dependencies = {}) {
       }
     }
   }
-  rmSync3(pidPath, { force: true });
+  rmSync4(pidPath, { force: true });
   removeRuntimeCredentials(runtimeCredentialsPath);
   await disableExpiredMemAccountsInConfig(configPath);
   if (monitorState) {
@@ -79988,7 +80651,7 @@ async function writeRuntimePid(pidPath, pid = process.pid) {
 `);
 }
 function removeRuntimePid(pidPath) {
-  rmSync3(resolvePidPath(pidPath), { force: true });
+  rmSync4(resolvePidPath(pidPath), { force: true });
 }
 async function getRuntimeStatus(params = {}) {
   const configPath = resolveConfigPath2(params.configPath);
@@ -80849,7 +81512,7 @@ function resolveSlackLoopCliContext(params) {
     sessionTarget,
     identity,
     route,
-    buildLoopPromptText: (text) => buildAgentPromptText({
+    buildLoopPromptText: (text, options) => buildAgentPromptText({
       text,
       identity,
       config: botConfig.agentPrompt,
@@ -80863,7 +81526,8 @@ function resolveSlackLoopCliContext(params) {
         agentId: sessionTarget.agentId,
         routeTimezone: route.timezone,
         botTimezone: route.botTimezone
-      }).timezone
+      }).timezone,
+      maxProgressMessagesOverride: options?.maxProgressMessagesOverride
     })
   };
 }
@@ -80919,7 +81583,7 @@ function resolveTelegramLoopCliContext(params) {
     sessionTarget,
     identity,
     route,
-    buildLoopPromptText: (text) => buildAgentPromptText({
+    buildLoopPromptText: (text, options) => buildAgentPromptText({
       text,
       identity,
       config: botConfig.agentPrompt,
@@ -80933,7 +81597,8 @@ function resolveTelegramLoopCliContext(params) {
         agentId: sessionTarget.agentId,
         routeTimezone: route.timezone,
         botTimezone: route.botTimezone
-      }).timezone
+      }).timezone,
+      maxProgressMessagesOverride: options?.maxProgressMessagesOverride
     })
   };
 }
@@ -81093,6 +81758,8 @@ function renderLoopsHelp() {
     "  - `--sender <principal>` is required when creating loops, using `slack:<user-id>` or `telegram:<user-id>`",
     "  - optional creator display fields: `--sender-name <name>` and `--sender-handle <handle>`",
     "  - `--timezone <iana>` is a one-off wall-clock loop override and is frozen on the created loop record",
+    `  - \`${LOOP_START_FLAG} <none|brief|full>\` controls scheduled loop-start notifications only; it does not control injected agent progress messages`,
+    "  - `--progress <count>` overrides loop progress-message injection for agent replies; `0` disables progress messages, and omitting the flag inherits the normal clisbot prompt config",
     "  - in Telegram forum groups, omitting `--topic-id` targets the parent chat surface; sends then follow Telegram's normal no-`message_thread_id` behavior, which is the General topic when that forum has one",
     "",
     "Expressions:",
@@ -81114,6 +81781,7 @@ function renderLoopsHelp() {
     "  - CLI loop creation fails without `--sender` so scheduled prompts can preserve creator identity",
     "  - the first wall-clock loop returns `confirmation_required` and does not persist until rerun with `--confirm`",
     "  - recurring interval loops and confirmed wall-clock loops are persisted immediately and picked up by the runtime when it is running",
+    "  - loop-created agent prompts inherit the normal clisbot prompt config unless `--progress <count>` overrides that loop",
     "  - if runtime is stopped, recurring loops activate on the next `clisbot start`",
     "  - global `cancel --all` clears the whole app; scoped `cancel --all` clears one routed session",
     "  - `cancel --all --app` is accepted only with a scoped session target, matching `/loop cancel --all --app`",
@@ -81143,6 +81811,8 @@ function renderLoopsCreateHelp() {
     "  - `--new-thread` creates a Slack thread anchor before persisting the loop",
     "  - `--timezone <iana>` freezes a one-off wall-clock timezone on the loop record",
     "  - `--confirm` persists the first wall-clock loop after reviewing the confirmation output",
+    `  - advanced: \`${LOOP_START_FLAG} <none|brief|full>\` overrides the default scheduled loop-start notification behavior for that recurring loop`,
+    "  - advanced: `--progress <count>` overrides loop agent progress-message injection; `0` disables progress messages, and omitting the flag inherits the normal clisbot prompt config",
     "",
     "Examples:",
     `  ${renderCliCommand("loops create --channel slack --target group:C1234567890 --thread-id 1712345678.123456 --sender slack:U1234567890 every day at 07:00 check CI")}`,
@@ -81152,7 +81822,8 @@ function renderLoopsCreateHelp() {
     "Behavior:",
     "  - create without `--sender` fails by design",
     "  - the `--sender` platform must match `--channel`",
-    "  - recurring CLI-created loops persist creator metadata into the session store"
+    "  - recurring CLI-created loops persist creator metadata into the session store",
+    "  - CLI-created loop prompts inherit the normal clisbot prompt config unless `--progress <count>` is provided"
   ].join(`
 `);
 }
@@ -81363,6 +82034,7 @@ async function getScopedLoopCounts(params) {
 // src/control/loops-cli.ts
 var LOOP_BUSY_RETRY_MS = 250;
 var LOOP_CONFIRM_FLAG = "--confirm";
+var LOOP_PROGRESS_FLAG = "--progress";
 var LOOP_SENDER_FLAG = "--sender";
 var LOOP_SENDER_NAME_FLAG = "--sender-name";
 var LOOP_SENDER_HANDLE_FLAG = "--sender-handle";
@@ -81522,7 +82194,9 @@ async function waitForSessionIdle(agentService, target) {
 }
 async function executeCountLoop(params) {
   const agentService = new AgentService(params.state.loadedConfig);
-  const builtPrompt = params.context.buildLoopPromptText(params.promptText);
+  const builtPrompt = params.context.buildLoopPromptText(params.promptText, params.progressMessages == null ? undefined : {
+    maxProgressMessagesOverride: params.progressMessages
+  });
   console.log(renderLoopStartedMessage({
     mode: "times",
     count: params.count,
@@ -81576,8 +82250,35 @@ function stripLoopCreatorArgs(args) {
   }
   return remaining;
 }
+function parseLoopProgress(args) {
+  const raw = parseOptionValue3(args, LOOP_PROGRESS_FLAG);
+  if (raw == null) {
+    return;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || String(parsed) !== raw.trim() || parsed < 0) {
+    throw new Error(`${LOOP_PROGRESS_FLAG} must be a non-negative integer.`);
+  }
+  return parsed;
+}
+function stripLoopProgressArgs(args) {
+  const remaining = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === "--") {
+      remaining.push(...args.slice(index));
+      break;
+    }
+    if (current === LOOP_PROGRESS_FLAG) {
+      index += 1;
+      continue;
+    }
+    remaining.push(current);
+  }
+  return remaining;
+}
 function parseCreateExpression(rawArgs, explicitCreateSubcommand) {
-  const expressionArgs = stripLoopContextArgs(stripLoopCreatorArgs(stripConfirmFlag(explicitCreateSubcommand ? rawArgs.slice(1) : rawArgs)));
+  const expressionArgs = stripLoopContextArgs(stripLoopCreatorArgs(stripLoopProgressArgs(stripConfirmFlag(explicitCreateSubcommand ? rawArgs.slice(1) : rawArgs))));
   const expression = expressionArgs.join(" ").trim();
   if (!expression) {
     throw new Error("Loop creation requires an interval, count, or schedule expression.");
@@ -81657,6 +82358,7 @@ function requireValidIntervalLoop(parsed) {
 async function resolveLoopCreateRequest(state, rawArgs, explicitCreateSubcommand) {
   const confirm = hasFlag4(rawArgs, LOOP_CONFIRM_FLAG);
   const loopTimezone = parseLoopTimezone(rawArgs);
+  const progressMessages = parseLoopProgress(rawArgs);
   const expression = parseCreateExpression(rawArgs, explicitCreateSubcommand);
   const parsed = parseCreateCommand(expression);
   let addressing = parseAddressing(rawArgs);
@@ -81686,7 +82388,8 @@ async function resolveLoopCreateRequest(state, rawArgs, explicitCreateSubcommand
       maxActiveLoops,
       expression,
       confirm,
-      loopTimezone
+      loopTimezone,
+      progressMessages
     };
   }
   addressing = await prepareLoopCreateAddressing({
@@ -81717,7 +82420,8 @@ async function resolveLoopCreateRequest(state, rawArgs, explicitCreateSubcommand
     maxActiveLoops,
     expression,
     confirm,
-    loopTimezone
+    loopTimezone,
+    progressMessages
   };
 }
 function buildLoopSurfaceBinding2(request) {
@@ -81746,9 +82450,10 @@ function buildRecurringLoopCreateBase(state, request) {
 function buildRecurringLoopPromptMetadata(request) {
   return {
     promptText: request.resolvedPrompt.text,
-    canonicalPromptText: request.resolvedPrompt.text,
     promptSummary: summarizeLoopPrompt(request.resolvedPrompt.text, request.resolvedPrompt.maintenancePrompt),
     promptSource: request.resolvedPrompt.maintenancePrompt ? "LOOP.md" : "custom",
+    progressMessages: request.progressMessages,
+    loopStart: request.parsed.mode === "times" ? undefined : request.parsed.loopStart,
     maintenancePrompt: request.resolvedPrompt.maintenancePrompt,
     createdBy: request.creator.providerId,
     sender: request.creator,
@@ -81888,7 +82593,8 @@ async function createLoop(state, rawArgs, options = {}) {
       context: request.deliveryContext ?? request.context,
       promptText: request.resolvedPrompt.text,
       count: request.parsed.count,
-      maintenancePrompt: request.resolvedPrompt.maintenancePrompt
+      maintenancePrompt: request.resolvedPrompt.maintenancePrompt,
+      progressMessages: request.progressMessages
     });
     return;
   }
@@ -82254,6 +82960,11 @@ async function runMessageCli(args, dependencies = defaultMessageCliDependencies)
 var QUEUE_SENDER_FLAG = "--sender";
 var QUEUE_SENDER_NAME_FLAG = "--sender-name";
 var QUEUE_SENDER_HANDLE_FLAG = "--sender-handle";
+var defaultQueueCliDependencies = {
+  print: (text) => console.log(text),
+  warn: (text) => console.warn(text),
+  sendQueueCreatedNotification: sendQueueCreatedNotificationToSurface
+};
 function getEditableConfigPath9() {
   return process.env.CLISBOT_CONFIG_PATH;
 }
@@ -82411,7 +83122,6 @@ function resolveProtectedControlMutationRule(state, agentId, sender) {
 function createQueueItemForContext(params) {
   return createStoredQueueItem({
     promptText: params.promptText,
-    canonicalPromptText: params.promptText,
     protectedControlMutationRule: resolveProtectedControlMutationRule(params.state, params.context.sessionTarget.agentId, params.sender),
     promptSummary: params.promptText,
     createdBy: params.sender.providerId,
@@ -82419,6 +83129,56 @@ function createQueueItemForContext(params) {
     surfaceBinding: buildQueueSurfaceBinding(params.context)
   });
 }
+function renderQueueCreatedNotification(params) {
+  const queueLine = params.positionAhead > 0 ? `Queued \`${params.queueId}\`: ${params.positionAhead} ahead.` : `Queued \`${params.queueId}\`.`;
+  return `${queueLine}
+
+${params.promptText.trim()}`;
+}
+async function getQueuePositionAhead(state, sessionKey, itemId) {
+  const queues = await state.sessionState.listQueuedItems({
+    sessionKey,
+    statuses: ["pending", "running"]
+  });
+  const index = queues.findIndex((item) => item.id === itemId);
+  return index >= 0 ? index : 0;
+}
+function buildQueueCreatedMessageCommand(params) {
+  return {
+    action: "send",
+    channel: params.context.channel,
+    account: params.context.botId,
+    target: params.context.target,
+    message: params.text,
+    threadId: params.context.threadId,
+    remove: false,
+    pollOptions: [],
+    forceDocument: false,
+    silent: false,
+    progress: false,
+    final: false,
+    json: false,
+    inputFormat: "plain",
+    renderMode: "none"
+  };
+}
+async function sendQueueCreatedNotificationToSurface(params) {
+  if (!params.item.surfaceBinding) {
+    return;
+  }
+  const loadedConfig = await loadConfig(params.state.configPath, {
+    materializeChannels: [params.context.channel]
+  });
+  const plugin = listChannelPlugins().find((entry) => entry.id === params.context.channel);
+  if (!plugin) {
+    throw new Error(`Unsupported queue notification channel: ${params.context.channel}`);
+  }
+  await plugin.runMessageCommand(loadedConfig, buildQueueCreatedMessageCommand({
+    context: params.context,
+    text: params.text
+  }));
+  await params.state.sessionState.recordConversationReply(params.resolved);
+}
 function renderQueueInventory(params) {
   const lines = [
     `Queue ${params.commandLabel}`,
@@ -82433,20 +83193,20 @@ function renderQueueInventory(params) {
   return lines.join(`
 `);
 }
-async function listQueues(state, addressing, commandLabel) {
+async function listQueues(state, addressing, commandLabel, deps) {
   const context = addressing.channel || addressing.target ? resolveScopedContext(state, addressing) : undefined;
   const sessionKey = context?.sessionTarget.sessionKey;
   const queues = await state.sessionState.listQueuedItems({
     sessionKey,
     statuses: commandLabel === "list" ? ["pending"] : ["pending", "running"]
   });
-  console.log(renderQueueInventory({
+  deps.print(renderQueueInventory({
     commandLabel,
     sessionStorePath: state.sessionStorePath,
     queues
   }));
 }
-async function createQueue(state, args) {
+async function createQueue(state, args, deps) {
   const addressing = parseQueueCliAddressing(args);
   const promptText = stripQueueArgs(args.slice(1)).join(" ").trim();
   if (!promptText) {
@@ -82467,18 +83227,30 @@ async function createQueue(state, args) {
     sender
   });
   await state.sessionState.setQueuedItem(resolved, item);
-  console.log(`Queued prompt \`${item.id}\` for \`${context.sessionTarget.sessionKey}\`.`);
+  const positionAhead = await getQueuePositionAhead(state, context.sessionTarget.sessionKey, item.id);
+  const text = renderQueueCreatedNotification({ queueId: item.id, positionAhead, promptText });
+  await deps.sendQueueCreatedNotification({
+    state,
+    context,
+    resolved,
+    item,
+    positionAhead,
+    text
+  }).catch((error) => {
+    deps.warn(`Queued prompt ${item.id}, but surface acknowledgement failed: ${String(error)}`);
+  });
+  deps.print(`Queued prompt \`${item.id}\` for \`${context.sessionTarget.sessionKey}\`.`);
 }
-async function clearQueues(state, addressing) {
+async function clearQueues(state, addressing, deps) {
   if (addressing.all) {
     const cleared2 = await state.sessionState.clearAllPendingQueuedItems();
-    console.log(`Cleared ${cleared2.length} pending queued prompt${cleared2.length === 1 ? "" : "s"} across the whole app.`);
+    deps.print(`Cleared ${cleared2.length} pending queued prompt${cleared2.length === 1 ? "" : "s"} across the whole app.`);
     return;
   }
   const context = resolveScopedContext(state, addressing);
   const sessionKey = context.sessionTarget.sessionKey;
   const cleared = await state.sessionState.clearPendingQueuedItemsForSessionKey(sessionKey);
-  console.log(`Cleared ${cleared.length} pending queued prompt${cleared.length === 1 ? "" : "s"} for \`${sessionKey}\`.`);
+  deps.print(`Cleared ${cleared.length} pending queued prompt${cleared.length === 1 ? "" : "s"} for \`${sessionKey}\`.`);
 }
 function renderQueuesHelp() {
   return [
@@ -82499,23 +83271,24 @@ function renderQueuesHelp() {
   ].join(`
 `);
 }
-async function runQueuesCli(args) {
+async function runQueuesCli(args, dependencies = {}) {
+  const deps = { ...defaultQueueCliDependencies, ...dependencies };
   if (args[0] === "--help" || args[0] === "help" || args.length === 0) {
-    console.log(renderQueuesHelp());
+    deps.print(renderQueuesHelp());
     return;
   }
   const command = args[0];
   const state = await loadQueueControlState();
   if (command === "list" || command === "status") {
-    await listQueues(state, parseQueueCliAddressing(args.slice(1)), command);
+    await listQueues(state, parseQueueCliAddressing(args.slice(1)), command, deps);
     return;
   }
   if (command === "create") {
-    await createQueue(state, args);
+    await createQueue(state, args, deps);
     return;
   }
   if (command === "clear") {
-    await clearQueues(state, parseQueueCliAddressing(args.slice(1)));
+    await clearQueues(state, parseQueueCliAddressing(args.slice(1)), deps);
     return;
   }
   throw new Error(`Unknown queues subcommand: ${command}`);
@@ -83280,13 +84053,37 @@ function sortRunnerSessionMetadataNewestFirst(entries) {
     return left.sessionName.localeCompare(right.sessionName);
   });
 }
+function deriveRunnerSessionIdentity(params) {
+  const storedSessionId = params.entry?.sessionId?.trim() || undefined;
+  const liveSessionId = params.liveSessionId?.trim() || undefined;
+  const sessionId = liveSessionId ?? storedSessionId;
+  return {
+    sessionId,
+    sessionIdPersistence: sessionId && sessionId === storedSessionId ? "persisted" : sessionId ? "not-persisted-yet" : undefined,
+    storedSessionId
+  };
+}
+function parseRunnerSessionIdFromSnapshot(loadedConfig, entry, snapshot) {
+  if (!entry) {
+    return;
+  }
+  const resolved = resolveAgentTarget(loadedConfig, {
+    agentId: entry.agentId,
+    sessionKey: entry.sessionKey
+  });
+  const pattern = resolved.runner.sessionId.capture.pattern?.trim();
+  if (!pattern) {
+    return;
+  }
+  return parseRunnerSessionId(snapshot, pattern) ?? undefined;
+}
 async function listRunnerSessions(loadedConfig) {
   const sessionStore = new SessionStore(resolveSessionStorePath(loadedConfig));
   const metadata = buildRunnerSessionMetadata(loadedConfig, await sessionStore.list());
   const sessionByName = new Map(metadata.map((item) => [item.sessionName, item.entry]));
   const tmux = new TmuxClient(loadedConfig.raw.tmux.socketPath);
   const liveSessionNames = new Set(await tmux.listSessions());
-  return [...liveSessionNames].sort((left, right) => {
+  const orderedSessionNames = [...liveSessionNames].sort((left, right) => {
     const leftEntry = sessionByName.get(left);
     const rightEntry = sessionByName.get(right);
     const leftPromptAt = leftEntry?.lastAdmittedPromptAt ?? 0;
@@ -83300,12 +84097,19 @@ async function listRunnerSessions(loadedConfig) {
       return rightUpdatedAt - leftUpdatedAt;
     }
     return left.localeCompare(right);
-  }).map((sessionName, index) => ({
-    index: index + 1,
-    sessionName,
-    live: true,
-    entry: sessionByName.get(sessionName)
-  }));
+  });
+  return orderedSessionNames.map((sessionName, index) => {
+    const entry = sessionByName.get(sessionName);
+    return {
+      index: index + 1,
+      sessionName,
+      live: true,
+      entry,
+      identity: deriveRunnerSessionIdentity({
+        entry
+      })
+    };
+  });
 }
 
 // src/control/runner-cli.ts
@@ -83318,6 +84122,7 @@ var SMOKE_SCENARIOS = [
   "recover_after_runner_loss"
 ];
 var SMOKE_SUITES = ["launch-trio"];
+var MISSING_STORED_SESSION_ID_TEXT = "not stored";
 function parseRepeatedOption4(args, name) {
   const values = [];
   for (let index = 0;index < args.length; index += 1) {
@@ -83428,7 +84233,7 @@ function renderRunnerHelp() {
     `  ${renderCliCommand("runner smoke --backend all --suite launch-trio [--workspace <path>] [--agent <id>] [--artifact-dir <path>] [--timeout-ms <n>] [--keep-session] [--json]")}`,
     "",
     "Operator session debugging:",
-    "  - `list` shows current tmux runner sessions, newest admitted turn first when known, plus stored sessionId/state when available",
+    "  - `list` shows current tmux runner sessions, newest admitted turn first when known, plus sessionId and persistence state when available",
     "  - `inspect` captures one snapshot; default tail is 100 lines",
     "  - `--index <n>` selects the 1-based order printed by `runner list`",
     "  - `watch --latest` follows the session that most recently admitted a new prompt",
@@ -83604,10 +84409,11 @@ function renderWatchFrame(params) {
     "",
     `session: ${params.sessionName}`,
     params.agentId ? `agent: ${params.agentId}` : null,
-    params.sessionKey ? `sessionKey: ${params.sessionKey}` : null,
+    `sessionId: ${params.sessionId?.trim() || MISSING_STORED_SESSION_ID_TEXT}`,
+    `sessionIdPersistence: ${params.sessionIdPersistence ?? "not stored yet"}`,
+    params.storedSessionId && params.storedSessionId !== params.sessionId ? `storedSessionId: ${params.storedSessionId}` : null,
     `lines: ${params.lines}`,
-    `intervalMs: ${params.intervalMs}`,
-    `status: ${params.status}`,
+    `state: ${params.state}`,
     "",
     params.snapshot.trimEnd() || "(empty pane)"
   ].filter((line) => Boolean(line)).join(`
@@ -83644,21 +84450,20 @@ function renderRunnerListSession(session) {
   if (!session.entry) {
     return [
       prefix,
-      "  sessionId: none",
-      "  state: unmanaged",
-      "  live: yes"
+      `  sessionId: ${MISSING_STORED_SESSION_ID_TEXT}`,
+      "  state: unmanaged"
     ].join(`
 `);
   }
   return [
     prefix,
     `  agent: ${session.entry.agentId}`,
-    `  sessionKey: ${session.entry.sessionKey}`,
-    `  sessionId: ${session.entry.sessionId?.trim() || "none"}`,
+    `  sessionId: ${session.identity?.sessionId?.trim() || MISSING_STORED_SESSION_ID_TEXT}`,
+    `  sessionIdPersistence: ${session.identity?.sessionIdPersistence ?? "not stored yet"}`,
+    session.identity?.storedSessionId && session.identity.storedSessionId !== session.identity.sessionId ? `  storedSessionId: ${session.identity.storedSessionId}` : null,
     `  state: ${session.entry.runtime?.state ?? "no-runtime"}`,
-    `  live: ${session.live ? "yes" : "no"}`,
     `  lastAdmittedPromptAt: ${formatTimestamp(session.entry.lastAdmittedPromptAt)}`
-  ].join(`
+  ].filter((line) => Boolean(line)).join(`
 `);
 }
 function resolveIndexedSession(sessions, index) {
@@ -83697,6 +84502,7 @@ async function resolveWatchSelection(options) {
   const sessionMetadata = buildRunnerSessionMetadata(context.loadedConfig, context.entries);
   if (options.sessionName) {
     return {
+      loadedConfig: context.loadedConfig,
       sessionName: options.sessionName,
       metadata: sessionMetadata.find((item) => item.sessionName === options.sessionName) ?? null,
       tmux: context.tmux
@@ -83705,6 +84511,7 @@ async function resolveWatchSelection(options) {
   if (options.index != null) {
     const selected = resolveIndexedSession(await listRunnerSessions(context.loadedConfig), options.index);
     return {
+      loadedConfig: context.loadedConfig,
       sessionName: selected.sessionName,
       metadata: sessionMetadata.find((item) => item.sessionName === selected.sessionName) ?? null,
       tmux: context.tmux
@@ -83716,6 +84523,7 @@ async function resolveWatchSelection(options) {
       throw new CliCommandError(`No admitted prompt is recorded yet. Use ${renderCliCommand("runner watch --next", { inline: true })} or watch a named session.`, 1);
     }
     return {
+      loadedConfig: context.loadedConfig,
       sessionName: latest.sessionName,
       metadata: latest,
       tmux: context.tmux
@@ -83735,6 +84543,7 @@ async function resolveWatchSelection(options) {
     });
     if (admittedAfterBaseline[0]) {
       return {
+        loadedConfig: context.loadedConfig,
         sessionName: admittedAfterBaseline[0].sessionName,
         metadata: admittedAfterBaseline[0],
         tmux: context.tmux
@@ -83765,13 +84574,18 @@ async function runWatchCli(args) {
         throw error;
       }
     }
+    const identity = deriveRunnerSessionIdentity({
+      entry: selection.metadata?.entry,
+      liveSessionId: parseRunnerSessionIdFromSnapshot(selection.loadedConfig, selection.metadata?.entry, snapshot)
+    });
     const frame = renderWatchFrame({
       sessionName: selection.sessionName,
-      sessionKey: selection.metadata?.entry.sessionKey,
+      sessionId: identity.sessionId,
+      sessionIdPersistence: identity.sessionIdPersistence,
+      storedSessionId: identity.storedSessionId,
       agentId: selection.metadata?.entry.agentId,
       lines: options.lines,
-      intervalMs: options.intervalMs,
-      status,
+      state: status,
       snapshot
     });
     if (process.stdout.isTTY) {
@@ -83887,6 +84701,7 @@ var GITHUB_RAW_BASE = "https://raw.githubusercontent.com/longbkit/clisbot/main";
 function renderUpdateHelp() {
   return [
     `${renderCliCommand("update")} / ${renderCliCommand("update --help")}`,
+    "Start here for any clisbot install or update request.",
     "Prints this guide only. Direct update is not supported yet.",
     "A bot can use this guide to update itself.",
     "",
@@ -83897,21 +84712,30 @@ function renderUpdateHelp() {
     "",
     "Flow:",
     `  1. ${renderCliCommand("status")}`,
-    "  2. Read docs in priority order.",
+    "  2. Read docs in priority order and follow them before installing.",
     "  3. npm install -g clisbot@<target> && clisbot restart",
     `  4. ${renderCliCommand("status")}`,
-    "  5. Report version, health, manual action, and useful release-note highlights.",
+    "  5. Report version, health, manual action, and useful release highlights.",
     "",
     "Docs, read in order:",
     `  1. Migration index: ${GITHUB_RAW_BASE}/docs/migrations/index.md`,
     "     If Manual action: required, follow its runbook. If none, continue.",
-    `  2. Release quick info: ${GITHUB_RAW_BASE}/docs/releases/README.md`,
-    "     Use for release-note map and current release highlights.",
-    `  3. Update guide: ${GITHUB_RAW_BASE}/docs/update/README.md`,
-    "     Use for release notes, useful new features, things to try, and user-guide links.",
-    "  4. Full docs: https://github.com/longbkit/clisbot/tree/main/docs",
+    `  2. Update guide: ${GITHUB_RAW_BASE}/docs/updates/update-guide.md`,
+    "     Use for target choice, install flow, verification, and wrong-publish recovery.",
+    `  3. Release notes: ${GITHUB_RAW_BASE}/docs/releases/README.md`,
+    "     Use for the canonical version map and full version notes.",
+    `  4. Release guides: ${GITHUB_RAW_BASE}/docs/updates/README.md`,
+    "     Use for shorter catch-up notes: what changed, what to try, and what to watch.",
+    "  5. Full docs: https://github.com/longbkit/clisbot/tree/main/docs",
     "     Use for deep questions. If needed, fetch or clone docs and inspect relevant files.",
     "",
+    "Recovery:",
+    "  - If a version was published by mistake, publish the corrected target or tag first.",
+    "  - Then deprecate the wrong version.",
+    "  - Start with `npm login` in an attached session.",
+    "  - If npm returns a browser approval URL, keep that same session open and continue it after approval.",
+    "  - If the write command still returns EOTP, ask the operator for a current OTP and rerun the exact command with --otp=<code>.",
+    "",
     "Rules:",
     "  - Use npm dist-tags, not highest semver.",
     "  - Stable/latest is default; beta only when the user asks.",
@@ -84220,7 +85044,7 @@ function appendBootstrapGuidance(lines, summary) {
     lines.push(`  Agent ${agent.id} still needs bootstrap completion.`);
     lines.push(`    workspace: ${agent.workspacePath}`);
     lines.push("    next: chat with the bot or open the workspace");
-    lines.push(`    follow: BOOTSTRAP.md and the ${agent.bootstrapMode} personality files`);
+    lines.push("    follow: BOOTSTRAP.md, AGENTS.md, and the rest of the seeded workspace files");
   }
   lines.push("");
   lines.push("  Next steps after bootstrap:");
@@ -84269,7 +85093,7 @@ function renderStartSummary(summary) {
     lines.push(`  Example: ${renderCliCommand("start --cli codex --bot-type team")}`);
     lines.push(`  Manual setup is still available with ${renderCliCommand("agents add ...", { inline: true })}.`);
     lines.push(...renderOperatorHelpLines("  "));
-    lines.push("  Bootstrap files will be seeded in the agent workspace. Review BOOTSTRAP.md, SOUL.md, USER.md, IDENTITY.md, and MEMORY.md.");
+    lines.push("  Bootstrap files are optional. If you use `--bot-type`, clisbot seeds BOOTSTRAP.md, AGENTS.md, SOUL.md, USER.md, IDENTITY.md, and related files into the agent workspace.");
     return lines.join(`
 `);
   }
@@ -84465,7 +85289,7 @@ async function getRuntimeOperatorSummary(params) {
     },
     agentSummaries,
     channelSummaries,
-    activeRuns: await agentService.listActiveSessionRuntimes(),
+    activeRuns: await agentService.listLiveSessionRuntimes(),
     configuredAgents: agentSummaries.length,
     bootstrapPendingAgents: agentSummaries.filter((item) => item.bootstrapState === "missing" || item.bootstrapState === "not-bootstrapped").length,
     bootstrappedAgents: agentSummaries.filter((item) => item.bootstrapState === "bootstrapped").length,
@@ -84547,7 +85371,10 @@ function renderBootstrapCommandHelp(commandName) {
     "Behavior:",
     `  - ${behavior}`,
     "  - first-run agent bootstrap needs both `--cli` and `--bot-type`",
+    "  - `--bot-type` is a workspace-template choice, not a general runtime requirement for later agents",
     "  - `--bot-type personal` maps to `personal-assistant`; `--bot-type team` maps to `team-assistant`",
+    "  - bootstrap seeds `AGENTS.md`, `BOOTSTRAP.md`, `IDENTITY.md`, and the rest of the workspace guidance files",
+    "  - Claude and Gemini bootstraps also create `CLAUDE.md` or `GEMINI.md` as symlinks to `AGENTS.md`",
     "  - explicit credential flags only enable the channels and bots you named in this command",
     "  - env-style values such as `SLACK_APP_TOKEN` or `${SLACK_APP_TOKEN}` stay env-backed in config",
     commandName === "start" ? "  - literal token values without `--persist` stay runtime-only for this start invocation" : "  - literal token values on `init` require `--persist` because no runtime exists yet",
@@ -85491,6 +86318,8 @@ async function withStartupTimeout(name, start2) {
 }
 
 // src/control/runtime-management-cli.ts
+var RESTART_STOP_STATUS_RECHECK_TIMEOUT_MS = 2000;
+var RESTART_STOP_STATUS_RECHECK_INTERVAL_MS = 100;
 function getOperatorConfigPath() {
   return expandHomePath(process.env.CLISBOT_CONFIG_PATH || DEFAULT_CONFIG_PATH);
 }
@@ -85727,11 +86556,36 @@ async function stop(hard = false) {
   console.log("clisbot stopped");
   printCommandOutcomeFooter("success");
 }
-async function restart() {
-  await stopDetachedRuntime({
-    configPath: getOperatorConfigPath(),
-    hard: false
-  });
+async function restart(dependencies = {
+  stopDetachedRuntime,
+  getRuntimeStatus,
+  sleep,
+  warn: (message) => console.error(message)
+}) {
+  const configPath = getOperatorConfigPath();
+  try {
+    await dependencies.stopDetachedRuntime({
+      configPath,
+      hard: false
+    });
+  } catch (error) {
+    const status = await waitForStoppedRuntimeAfterStopError(configPath, dependencies);
+    if (status.running) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    dependencies.warn(`warning: clisbot stop reported an error, but status now shows the service is stopped; continuing with start. Stop error: ${message}`);
+  }
+}
+async function waitForStoppedRuntimeAfterStopError(configPath, dependencies) {
+  const deadline = Date.now() + RESTART_STOP_STATUS_RECHECK_TIMEOUT_MS;
+  while (true) {
+    const status = await dependencies.getRuntimeStatus({ configPath });
+    if (!status.running || Date.now() >= deadline) {
+      return status;
+    }
+    await dependencies.sleep(RESTART_STOP_STATUS_RECHECK_INTERVAL_MS);
+  }
 }
 async function status() {
   await printStatusSummary();