clisbot 0.1.46-beta.0 → 0.1.46-beta.1

package/dist/main.js

@@ -58902,10 +58902,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 +58936,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 +58950,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 +58963,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 +58973,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 +58997,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 +59007,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 +59033,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 +59044,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 +59065,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 +59109,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 +59136,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 +59153,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 +59187,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 +59294,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) {
@@ -65882,12 +66016,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 +66037,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",
@@ -66011,7 +66158,7 @@ function renderAgentControlSlashHelp() {
     "- `/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 store 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",
@@ -67176,6 +67323,7 @@ function createStoredLoopBase(params) {
     protectedControlMutationRule: params.protectedControlMutationRule,
     promptSummary: params.promptSummary,
     promptSource: params.promptSource,
+    loopStart: params.loopStart,
     createdBy: params.createdBy,
     sender: params.sender ?? deriveLegacyLoopSender({
       createdBy: params.createdBy,
@@ -67206,6 +67354,7 @@ function createStoredIntervalLoop(params) {
       protectedControlMutationRule: params.protectedControlMutationRule,
       promptSummary: params.promptSummary,
       promptSource: params.promptSource,
+      loopStart: params.loopStart,
       createdBy: params.createdBy,
       sender: params.sender,
       surfaceBinding: params.surfaceBinding,
@@ -67236,6 +67385,7 @@ function createStoredCalendarLoop(params) {
       protectedControlMutationRule: params.protectedControlMutationRule,
       promptSummary: params.promptSummary,
       promptSource: params.promptSource,
+      loopStart: params.loopStart,
       createdBy: params.createdBy,
       sender: params.sender,
       surfaceBinding: params.surfaceBinding,
@@ -67624,6 +67774,8 @@ class ManagedLoopController {
 }
 
 // src/agents/managed-queue-controller.ts
+var QUEUE_MESSAGE_TOOL_FINAL_POLL_MS = 250;
+
 class ManagedQueueController {
   deps;
   queuedItems = new Map;
@@ -67709,12 +67861,29 @@ class ManagedQueueController {
       }
     }
     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(persisted.id)) {
         continue;
       }
       this.enqueuePersistedQueueItem(persisted);
     }
   }
+  async clearStaleRunningQueueItem(item) {
+    if (this.queuedItems.has(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
@@ -67759,6 +67928,7 @@ class ManagedQueueController {
       item: next
     });
     await this.deps.sessionState.replaceQueuedItemIfPresent(this.deps.resolveTarget(target), next);
+    return next;
   }
   async removeManagedQueueItem(target, item) {
     if (!item) {
@@ -67777,23 +67947,38 @@ class ManagedQueueController {
       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),
       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) => {
@@ -67809,6 +67994,37 @@ class ManagedQueueController {
       console.error("queued prompt execution failed", error);
     });
   }
+  async waitForMessageToolFinal(target, item, shouldStop) {
+    while (!shouldStop()) {
+      if (await this.hasMessageToolFinalForQueueItem(target, item)) {
+        return true;
+      }
+      await sleep(QUEUE_MESSAGE_TOOL_FINAL_POLL_MS);
+    }
+    return false;
+  }
+  async hasMessageToolFinalForQueueItem(target, item) {
+    const startedAt = this.queuedItems.get(item.id)?.item.startedAt ?? item.startedAt;
+    if (typeof startedAt !== "number" || !Number.isFinite(startedAt)) {
+      return false;
+    }
+    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
+    };
+  }
 }
 
 // src/agents/runner-service.ts
@@ -68089,18 +68305,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 +68552,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();
@@ -68864,7 +69104,7 @@ async function captureTmuxSessionIdentity(params) {
       });
       continue;
     }
-    const sessionId = extractSessionId(deriveSessionIdentityText(statusSubmission.submittedSnapshot, snapshot), params.pattern);
+    const sessionId = extractSessionIdFromCandidates(deriveSessionIdentityTexts(statusSubmission.submittedSnapshot, snapshot), params.pattern);
     if (sessionId) {
       await waitForTmuxPaneSettle({
         tmux: params.tmux,
@@ -68879,10 +69119,23 @@ async function captureTmuxSessionIdentity(params) {
   }
   return null;
 }
-function deriveSessionIdentityText(submittedSnapshot, snapshot) {
+function deriveSessionIdentityTexts(submittedSnapshot, snapshot) {
   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)
+  ].filter((candidate, index, candidates) => candidate && candidates.indexOf(candidate) === index);
+}
+function extractSessionIdFromCandidates(candidates, pattern) {
+  for (const candidate of candidates) {
+    const sessionId = extractSessionId(candidate, pattern);
+    if (sessionId) {
+      return sessionId;
+    }
+  }
+  return null;
 }
 async function dismissTmuxTrustPromptIfPresent(params) {
   const deadline = Date.now() + Math.max(TRUST_PROMPT_MAX_WAIT_MS, params.startupDelayMs);
@@ -68956,7 +69209,7 @@ async function waitForTmuxSessionBootstrap(params) {
           };
         }
       }
-      if (readyRegex && !readyRegex.test(snapshot)) {
+      if (readyRegex && !snapshotHasActiveReadyPattern(snapshot, readyRegex)) {
         await sleep(SESSION_BOOTSTRAP_POLL_INTERVAL_MS);
         continue;
       }
@@ -69190,6 +69443,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");
 }
@@ -69396,6 +69672,9 @@ 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;
@@ -69618,10 +69897,7 @@ class RunnerService {
       });
       try {
         await clearRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
-        await this.sessionState.touchSessionEntry(resolved, {
-          sessionId: existing?.sessionId,
-          runnerCommand: resolved.runner.command
-        });
+        await this.syncSessionIdentity(resolved);
       } catch (error) {
         throw await this.mapSessionError(error, resolved.sessionName, "during startup");
       }
@@ -69766,7 +70042,7 @@ 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") {
+    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 });
@@ -69925,7 +70201,6 @@ class RunnerService {
       });
       try {
         await this.tmux.sendKey(resolved.sessionName, "Escape");
-        await sleep(150);
       } catch {}
     }
     return {
@@ -70048,7 +70323,7 @@ async function monitorTmuxRun(params) {
   let previousRenderedRunningSnapshot = "";
   let lastPaneChangeAt = params.startedAt;
   let sawActivity = false;
-  let sawPaneChange = false;
+  let sawPaneChange = !params.prompt;
   let sawPromptSubmission = Boolean(params.prompt);
   let detachedNotified = params.detachedAlready;
   let firstMeaningfulDeltaLogged = false;
@@ -70258,6 +70533,26 @@ class SessionService {
       });
     }
   }
+  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 = {}) {
     if (this.stopping) {
       throw new Error("Runtime is stopping and cannot accept a new prompt.");
@@ -70392,6 +70687,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);
   }
@@ -70691,7 +71014,7 @@ class SessionService {
     }
   }
   async hasStoredResumableSessionId(resolved) {
-    if (resolved.runner.sessionId.resume.mode !== "command") {
+    if (resolved.runner.sessionId.resume.mode !== "command" && resolved.runner.sessionId.create.mode !== "explicit") {
       return false;
     }
     const entry = await this.sessionState.getEntry(resolved.sessionKey);
@@ -71067,18 +71390,11 @@ var REPLY_RULES = `When replying to the user:
 - put the user-facing message inside the --message body of that command
 {{progress_rules_block}}- {{final_rule_line}}`;
 var PROGRESS_PHRASE = "progress update or ";
-var EMPTY_PROGRESS_PHRASE = "";
 var PROGRESS_FLAG_SUFFIX = "|progress";
-var EMPTY_PROGRESS_FLAG_SUFFIX = "";
 var PROGRESS_RULES_BLOCK = `- use that command to send progress updates and the final reply back to the conversation
-- send at most {{max_progress_messages}} progress updates
-- keep progress updates short and meaningful
-- do not send progress updates for trivial internal steps
-`;
-var FINAL_ONLY_RULES_BLOCK = `- use that command only for the final user-facing reply
-- do not send user-facing progress updates for this conversation
+- 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 = "";
@@ -71183,10 +71499,9 @@ 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 progressPhrase = PROGRESS_PHRASE;
+  const progressFlagSuffix = PROGRESS_FLAG_SUFFIX;
+  const progressRulesBlock = PROGRESS_RULES_BLOCK;
   const finalRuleLine = params.config.requireFinalResponse ? FINAL_RULE_REQUIRED : FINAL_RULE_OPTIONAL;
   return {
     deliveryIntro: renderTemplate(DELIVERY_INTRO, {
@@ -71216,7 +71531,7 @@ function renderConfigurationGuidance() {
   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 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(`
 `);
 }
@@ -71722,8 +72037,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 +72052,7 @@ class SurfaceRuntime {
       maxRuns: loop.maxRuns,
       kind: "calendar"
     }) : renderLoopStartNotification({
-      mode: notifications.loopStart,
+      mode,
       agentId: target.agentId,
       loopId: loop.id,
       promptSummary: loop.promptSummary,
@@ -72150,7 +72466,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);
@@ -72167,13 +72488,16 @@ class AgentService {
   async getSessionDiagnostics(target) {
     const resolved = this.resolveTarget(target);
     const entry = await this.sessionState.getEntry(target.sessionKey);
-    const sessionId = entry?.sessionId?.trim() || undefined;
+    const storedSessionId = entry?.sessionId?.trim() || undefined;
     return {
-      sessionId,
-      resumeCommand: buildResumeCommandPreview(resolved, sessionId)
+      sessionName: resolved.sessionName,
+      sessionId: storedSessionId,
+      storedSessionId,
+      resumeCommand: buildResumeCommandPreview(resolved, storedSessionId)
     };
   }
   async listActiveSessionRuntimes() {
+    await this.activeRuns.clearLostPersistedActiveRuns();
     return this.sessionState.listActiveSessionRuntimes();
   }
   async setConversationFollowUpMode(target, mode) {
@@ -72593,30 +72917,16 @@ 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 renderWhoAmIMessage(params) {
+  const storedSessionId = params.sessionDiagnostics.storedSessionId ?? params.sessionDiagnostics.sessionId;
   const lines = [
     "Who am I",
     "",
     `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)"}\``,
+    `storedSessionId: \`${storedSessionId ?? "(not captured yet)"}\``
   ];
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
@@ -72633,19 +72943,20 @@ 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(`
 `);
 }
 function renderRouteStatusMessage(params) {
+  const storedSessionId = params.sessionDiagnostics.storedSessionId ?? params.sessionDiagnostics.sessionId;
   const lines = [
     "Status",
     "",
     `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)"}\``,
+    `storedSessionId: \`${storedSessionId ?? "(not captured yet)"}\``
   ];
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
@@ -72662,7 +72973,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()}\``);
   }
@@ -73823,6 +74134,7 @@ ${renderLoopUsage()}`);
         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,
@@ -73862,6 +74174,7 @@ ${renderLoopUsage()}`);
       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,
@@ -77955,6 +78268,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" },
@@ -81143,6 +81457,7 @@ 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`,
     "",
     "Examples:",
     `  ${renderCliCommand("loops create --channel slack --target group:C1234567890 --thread-id 1712345678.123456 --sender slack:U1234567890 every day at 07:00 check CI")}`,
@@ -81749,6 +82064,7 @@ function buildRecurringLoopPromptMetadata(request) {
     canonicalPromptText: request.resolvedPrompt.text,
     promptSummary: summarizeLoopPrompt(request.resolvedPrompt.text, request.resolvedPrompt.maintenancePrompt),
     promptSource: request.resolvedPrompt.maintenancePrompt ? "LOOP.md" : "custom",
+    loopStart: request.parsed.mode === "times" ? undefined : request.parsed.loopStart,
     maintenancePrompt: request.resolvedPrompt.maintenancePrompt,
     createdBy: request.creator.providerId,
     sender: request.creator,
@@ -82254,6 +82570,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;
 }
@@ -82419,6 +82740,57 @@ function createQueueItemForContext(params) {
     surfaceBinding: buildQueueSurfaceBinding(params.context)
   });
 }
+function renderQueueCreatedNotification(params) {
+  const queueLine = params.positionAhead > 0 ? `Queued: ${params.positionAhead} ahead.` : "Queued.";
+  return `${queueLine}
+
+Prompt:
+${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 +82805,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 +82839,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({ 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 +82883,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}`);
@@ -83604,10 +83989,9 @@ function renderWatchFrame(params) {
     "",
     `session: ${params.sessionName}`,
     params.agentId ? `agent: ${params.agentId}` : null,
-    params.sessionKey ? `sessionKey: ${params.sessionKey}` : null,
+    `sessionId: ${params.sessionId?.trim() || "none"}`,
     `lines: ${params.lines}`,
-    `intervalMs: ${params.intervalMs}`,
-    `status: ${params.status}`,
+    `state: ${params.state}`,
     "",
     params.snapshot.trimEnd() || "(empty pane)"
   ].filter((line) => Boolean(line)).join(`
@@ -83645,18 +84029,15 @@ function renderRunnerListSession(session) {
     return [
       prefix,
       "  sessionId: none",
-      "  state: unmanaged",
-      "  live: yes"
+      "  state: unmanaged"
     ].join(`
 `);
   }
   return [
     prefix,
     `  agent: ${session.entry.agentId}`,
-    `  sessionKey: ${session.entry.sessionKey}`,
     `  sessionId: ${session.entry.sessionId?.trim() || "none"}`,
     `  state: ${session.entry.runtime?.state ?? "no-runtime"}`,
-    `  live: ${session.live ? "yes" : "no"}`,
     `  lastAdmittedPromptAt: ${formatTimestamp(session.entry.lastAdmittedPromptAt)}`
   ].join(`
 `);
@@ -83767,11 +84148,10 @@ async function runWatchCli(args) {
     }
     const frame = renderWatchFrame({
       sessionName: selection.sessionName,
-      sessionKey: selection.metadata?.entry.sessionKey,
+      sessionId: selection.metadata?.entry.sessionId,
       agentId: selection.metadata?.entry.agentId,
       lines: options.lines,
-      intervalMs: options.intervalMs,
-      status,
+      state: status,
       snapshot
     });
     if (process.stdout.isTTY) {
@@ -85727,11 +86107,25 @@ 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,
+  warn: (message) => console.error(message)
+}) {
+  const configPath = getOperatorConfigPath();
+  try {
+    await dependencies.stopDetachedRuntime({
+      configPath,
+      hard: false
+    });
+  } catch (error) {
+    const status = await dependencies.getRuntimeStatus({ configPath });
+    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 status() {
   await printStatusSummary();

package/package.json

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