grok-telegram-bot 2.4.0 → 2.6.0

package/src/bot/session-runtime.ts

@@ -23,7 +23,7 @@ import { type PromptInput, type ReasoningEffort, textPrompt } from "../app/types
 import { createLogger } from "../logger.js";
 import { buildTranscript, readHistory } from "../sessions/history.js";
 import { sessionHashtags } from "../render/hashtags.js";
-import { PROGRESS_DIRECTIVE } from "../render/progress.js";
+import { extractProgress, PROGRESS_DIRECTIVE } from "../render/progress.js";
 import { buildPriming, recentTranscript } from "./session-fork.js";
 import { TailWatcher } from "../sessions/tail.js";
 import type { HistoryEntry } from "../sessions/types.js";
@@ -62,6 +62,33 @@ import {
   type Suggestion,
   suggestionsKeyboard,
 } from "./suggestions.js";
+import type { ForumManager } from "../forum/manager.js";
+import { isGeneralThread, outboundThreadExtra } from "../forum/thread.js";
+import type { SessionStore } from "../sessions/store.js";
+import type { TelegramBotService } from "./telegram-bots.js";
+import { executeTelegramActions } from "./telegram-actions.js";
+import {
+  buildManagerContextBlock,
+  injectManagerContext,
+} from "./manager-context.js";
+import {
+  bindJobSession,
+  updateManagerJob,
+  type ReportBackMeta,
+} from "./manager-jobs.js";
+import {
+  buildManagerWorkReportPrompt,
+  isManagerWorkReportPrompt,
+  wrapManagerDirective,
+} from "../render/manager-directive.js";
+import {
+  buildTelegramBridgeDirective,
+  buildTelegramBridgeResultsPrompt,
+  extractTelegramActions,
+  isTelegramBridgeResultsPrompt,
+  stripTelegramActionFences,
+  wrapTelegramBridgePrompt,
+} from "../render/telegram-bridge.js";
 import {
   parsePlanUpdate,
   renderPlanMarkdown,
@@ -69,9 +96,11 @@ import {
   type PlanEntry,
 } from "../render/plan.js";
 import {
-  buildLastTurnSummary,
+  buildSessionCardComment,
+  clampThinking,
   cleanCommentLine,
   cleanUserPreview,
+  COMMENT_MAX,
   stepFromThought,
   stepFromToolUpdate,
   stripDirectiveWrappers,
@@ -144,6 +173,8 @@ export class SessionRuntime {
   private turnCount = 0;
   /** Telegram message id of the current turn's prompt, so replies thread to it. */
   private turnReplyTo: number | undefined;
+  /** Short id for `#prompt_<id>` on all AI messages of this turn. */
+  private turnPromptId: string | undefined;
   private imageScanText = "";
   private sentImagesThisTurn = new Set<string>();
   /** Monotonic count used to reject ACP "success" responses with no turn updates. */
@@ -172,19 +203,77 @@ export class SessionRuntime {
   accountRotator: AccountRotator | undefined;
   /** Session ids that already received the first-prompt auto-complexity directive. */
   private complexitySteered = new Set<string>();
+  /** Session ids that already received the first-prompt Telegram bridge directive. */
+  private telegramBridgeSteered = new Set<string>();
+  /**
+   * How many TELEGRAM BRIDGE RESULTS follow-ups are chained after the current
+   * user turn. Caps infinite list_bots/bot_command loops; reset on real user work.
+   */
+  private bridgeResultDepth = 0;
+  /** Max sequential bridge result turns per user request. */
+  private static readonly BRIDGE_CHAIN_MAX = 4;
+  /**
+   * Optional Telegram bridge services (forum / session store / sibling bots).
+   * Injected by the registry after construct.
+   */
+  bridge?: {
+    store: SessionStore;
+    forum?: ForumManager;
+    bots: TelegramBotService;
+    /** Cross-topic prompt dispatch (create_topic → send_prompt orchestration). */
+    submitTopicPrompt?: import("./telegram-actions.js").SubmitTopicPromptFn;
+    /** Wake General manager with a work-report prompt. */
+    wakeManager?: (opts: {
+      originChatId: number;
+      originThreadId: number;
+      prompt: string;
+    }) => Promise<void>;
+  };
+  /**
+   * Report-back for the *current* turn chain (dispatch + recheck/suggestions).
+   * Set from PromptInput.reportBack at turn start; kept until queue drains.
+   */
+  private pendingReportBack: ReportBackMeta | undefined;
+  /**
+   * Staged by {@link setReportBack} and attached to the next {@link submit}
+   * so concurrent dispatches carry their own job through the queue.
+   */
+  private stagedReportBack: ReportBackMeta | undefined;
   /** Last credits total reported for this session (for per-turn delta accounting). */
   private lastReportedCredits = 0;
-  /** Live "what is happening now" line while a turn is in flight. */
+  /** Live "what is happening now" line while a turn is in flight (tools/plan). */
   private liveStep: string | undefined;
-  /** Idle card comment (AI/local summary of the chat after the last turn). */
+  /**
+   * Card comment on disk / idle: last user prompt (≤ COMMENT_MAX).
+   * While busy, {@link cardComment} also appends last agent thinking.
+   */
   private sessionComment: string | undefined;
+  /** Cleaned last user prompt for cards (not overwritten by self-recheck meta). */
+  private cardUserPrompt: string | undefined;
+  /** Accumulated agent_thought_chunk text for the current turn (card display). */
+  private cardThinking = "";
   /** User text of the turn currently running (for local card-comment fallback). */
   private turnUserText = "";
-  /** Assistant prose streamed this turn — used to build the idle card summary. */
+  /** Assistant prose streamed this turn — used for suggestions / completion. */
   private turnAssistantText = "";
   /** Quiet meta capture (suggestions) — never stream to Telegram. */
   private capturingQuiet = false;
   private quietCaptureBuf = "";
+  /**
+   * General manager: Thinking… / Starting… bubble for this turn (deleted when
+   * silent, or replaced by a single fallback reply).
+   */
+  private managerStatusMsgId: number | undefined;
+  /** Count of successful notify actions this turn (user-facing messages). */
+  private managerNotifyCount = 0;
+  /** True when this turn already delivered at least one user-visible message. */
+  private managerUserVisible = false;
+  /**
+   * Done delivery bookkeeping for this turn: expect a loud Done ping, and whether
+   * one was successfully sent (finally forces a short Done if expected but missing).
+   */
+  private turnExpectDone = false;
+  private turnDonePinged = false;
   /** Batches of post-turn suggestions for inline-button callbacks. */
   private suggestionBatches = new Map<number, Suggestion[]>();
   private suggestionBatchSeq = 0;
@@ -214,20 +303,48 @@ export class SessionRuntime {
    */
   private skipSelfRecheck = false;
 
+  /**
+   * Forum topic thread id (message_thread_id). When set, all outbound messages
+   * for this runtime are posted into that topic.
+   */
+  readonly messageThreadId: number | undefined;
+  /** Settings storage key (`chatId` or `chatId:t{threadId}`). */
+  readonly settingsKey: string;
+  /**
+   * General topic only: OpenClaw-style manager chat (orchestrate, no coding UX).
+   */
+  readonly managerMode: boolean;
+  /**
+   * Optional: register Telegram message id → session for General reply-routing
+   * (user message, Done, stream bubbles). Wired by ChatController.
+   */
+  onTelegramMessageBound: ((messageId: number, sessionId: string) => void) | undefined;
+
   constructor(
     private readonly api: Api,
     private readonly chatId: number,
     private readonly acp: GrokClient,
     private readonly cfg: AppConfig,
     private readonly settings: SettingsStore,
-    init?: { cwd: string; projectName?: string; sessionId?: string },
+    init?: {
+      cwd: string;
+      projectName?: string;
+      sessionId?: string;
+      messageThreadId?: number;
+      settingsKey?: string;
+    },
   ) {
+    this.messageThreadId = init?.messageThreadId;
+    this.settingsKey = init?.settingsKey ?? String(chatId);
+    // Only the forum General topic is the manager — not AI Chat / private DMs.
+    this.managerMode =
+      this.messageThreadId !== undefined && isGeneralThread(this.messageThreadId);
     if (init) {
       this.cwd = init.cwd;
       this.projectName = init.projectName;
       this.sessionId = init.sessionId;
     } else {
-      const s = settings.get(chatId);
+      const s = settings.getKey(this.settingsKey);
       this.cwd = s.projectPath ?? cfg.workspace;
       this.projectName = s.projectName;
       this.sessionId = s.sessionId;
@@ -264,9 +381,27 @@ export class SessionRuntime {
 
   /** Latest task-completion % (0–100) parsed this turn, or undefined if none. */
   get taskProgress(): number | undefined {
+    // Manager chat never shows a progress bar.
+    if (this.managerMode) return undefined;
     return this.progress;
   }
 
+  /**
+   * Stage report-back for the next {@link submit} (General → project dispatch).
+   * Attached to that prompt so a second dispatch cannot steal the first job's
+   * completion report when the child session is busy/queued.
+   */
+  setReportBack(meta: ReportBackMeta): void {
+    if (this.stagedReportBack && this.stagedReportBack.jobId !== meta.jobId) {
+      updateManagerJob(this.stagedReportBack.jobId, {
+        status: "cancelled",
+        resultSummary: "superseded by a newer manager dispatch before start",
+      });
+    }
+    this.stagedReportBack = meta;
+    if (this.sessionId) bindJobSession(meta.jobId, this.sessionId);
+  }
+
   /**
    * Full plan board for the live stream / status panel (above the progress bar).
    * Empty when no plan is active this turn.
@@ -299,14 +434,23 @@ export class SessionRuntime {
   }
 
   /**
-   * One-line status for Running/Sessions cards:
-   * live step while busy, otherwise the last chat summary / comment.
+   * Session card comment:
+   *   always — last user prompt (≤250)
+   *   busy   — plus last AI agent thinking on the next line (≤250)
    */
   get cardComment(): string | undefined {
-    if (this.busy && this.liveStep) return this.liveStep;
-    if (this.sessionComment) return this.sessionComment;
-    if (this.sessionId) return this.acp.sessionComment(this.sessionId);
-    return undefined;
+    const user =
+      this.cardUserPrompt ||
+      this.sessionComment ||
+      (this.sessionId ? this.acp.sessionComment(this.sessionId) : undefined) ||
+      cleanUserPreview(this.suggestionUserText || this.turnUserText || "", COMMENT_MAX) ||
+      undefined;
+    const built = buildSessionCardComment({
+      userPrompt: user,
+      thinking: this.busy && this.cardThinking ? this.cardThinking : undefined,
+      busy: this.busy,
+    });
+    return built || undefined;
   }
 
   /** Record a new progress value and refresh the status panel / cards. The bar
@@ -319,7 +463,7 @@ export class SessionRuntime {
     this.changed();
   }
 
-  /** Update the live step shown on session cards (throttled by equality). */
+  /** Update the live step (tools/plan) — kept for diagnostics; cards use user+thinking. */
   private setLiveStep(step: string | undefined): void {
     const next = step?.trim() ? cleanCommentLine(step) : undefined;
     if (next === this.liveStep) return;
@@ -327,9 +471,21 @@ export class SessionRuntime {
     this.changed();
   }
 
-  /** Persist idle card comment (disk + memory) so /running and /sessions see it. */
+  /** Append thought text and refresh cards when the display line changes. */
+  private appendCardThinking(chunk: string): void {
+    const piece = chunk.replace(/\s+/g, " ").trim();
+    if (!piece) return;
+    const prevShown = this.cardThinking ? clampThinking(this.cardThinking, COMMENT_MAX) : "";
+    this.cardThinking = this.cardThinking ? `${this.cardThinking} ${piece}` : piece;
+    const nextShown = clampThinking(this.cardThinking, COMMENT_MAX);
+    if (nextShown !== prevShown) this.changed();
+  }
+
+  /** Persist last user prompt (disk + memory) so /running and /sessions see it. */
   private setSessionComment(comment: string | undefined): void {
-    const next = comment?.trim() ? cleanCommentLine(comment) : undefined;
+    const next = comment?.trim()
+      ? cleanUserPreview(comment, COMMENT_MAX) || cleanCommentLine(comment, COMMENT_MAX)
+      : undefined;
     if (next === this.sessionComment) return;
     this.sessionComment = next;
     if (next && this.sessionId) {
@@ -342,11 +498,25 @@ export class SessionRuntime {
     this.changed();
   }
 
-  /** Hydrate comment from disk after bind/resume. */
+  /** Keep disk/memory comment = last real user prompt after a turn ends. */
+  private persistCardUserPrompt(): void {
+    const prompt =
+      this.cardUserPrompt ||
+      cleanUserPreview(this.suggestionUserText || this.turnUserText || "", COMMENT_MAX);
+    if (prompt) {
+      this.cardUserPrompt = prompt;
+      this.setSessionComment(prompt);
+    }
+  }
+
+  /** Hydrate last user prompt from disk after bind/resume. */
   private loadPersistedComment(): void {
     if (!this.sessionId) return;
     const c = this.acp.sessionComment(this.sessionId);
-    if (c) this.sessionComment = c;
+    if (c) {
+      this.sessionComment = c;
+      if (!this.cardUserPrompt) this.cardUserPrompt = cleanUserPreview(c, COMMENT_MAX) || c;
+    }
   }
 
   /** Searchable hashtag footer for this session (project В· session В· model В·
@@ -364,12 +534,23 @@ export class SessionRuntime {
     if (value) {
       // A turn was started here and is still in flight, but its streamer was
       // finalized when we went background. Recreate it and let onUpdate feed
-      // the remaining chunks/thoughts/tools just like a normal live turn — we
-      // own the agent's session/update events, so no tail-watch is needed.
+      // the remaining chunks/thoughts/tools just like a normal live turn.
+      // Recreate the streamer for the live turn (manager: prose-only).
       if (this.busy && !this.streamer) {
         // Any transient follow-watch of this session is now superseded.
         if (this.watchIsFollow) this.stopWatch();
-        this.streamer = new ResponseStreamer(this.api, this.chatId, this.cfg.streamThrottleMs, this.turnReplyTo, this.hashtags(), (pct) => this.setProgress(pct), this.cfg.progressFallback, this.turnStartedAt);
+        this.streamer = new ResponseStreamer(
+          this.api,
+          this.chatId,
+          this.cfg.streamThrottleMs,
+          this.turnReplyTo,
+          this.hashtags(),
+          this.managerMode ? undefined : (pct) => this.setProgress(pct),
+          this.managerMode ? false : this.cfg.progressFallback,
+          this.turnStartedAt,
+          this.messageThreadId,
+          this.managerMode ? { proseOnly: true, showProgressBar: false } : undefined,
+        );
         // Restore the live plan board so steps stay visible above the progress bar.
         if (this.planEntries?.length) {
           this.streamer.setPlan(renderPlanMarkdown(this.planEntries));
@@ -379,6 +560,7 @@ export class SessionRuntime {
     } else {
       this.typing.stop();
       this.stopWatch();
+      // Seal live bubble when demoted (manager has no streamer).
       if (this.streamer) {
         // Finalize off the critical path so project/session switches never wait
         // on Telegram edits of the previous live stream.
@@ -390,13 +572,16 @@ export class SessionRuntime {
     this.changed();
   }
   get reasoning(): ReasoningEffort {
-    return this.settings.get(this.chatId).reasoning;
+    return this.settings.getKey(this.settingsKey).reasoning;
   }
   get agent(): string | undefined {
-    return this.settings.get(this.chatId).agent;
+    return this.settings.getKey(this.settingsKey).agent;
   }
   get model(): string | undefined {
-    return this.settings.get(this.chatId).model;
+    return this.settings.getKey(this.settingsKey).model;
+  }
+  get preferredAccountId(): string | undefined {
+    return this.settings.getKey(this.settingsKey).preferredAccountId;
   }
 
   /** Latest context-usage % / effort / credits for the current session. */
@@ -440,6 +625,8 @@ export class SessionRuntime {
     this.lastReportedCredits = 0;
     this.liveStep = undefined;
     this.sessionComment = undefined;
+    this.cardUserPrompt = undefined;
+    this.cardThinking = "";
     await this.applySessionPrefs();
     this.persist();
     this.sessionChanged();
@@ -495,8 +682,8 @@ export class SessionRuntime {
   async startImportedSession(cwd: string, projectName: string | undefined, priming: string): Promise<void> {
     await this.startNewSession(cwd, projectName);
     if (priming.trim()) this.primingContext = priming;
-    // Imported transcripts already have context — skip first-prompt complexity steering.
-    this.markComplexitySteered();
+    // Imported transcripts already have context — skip first-prompt directives.
+    this.markFirstPromptSteered();
   }
 
   startWatch(jsonlPath: string, follow = false): void {
@@ -519,7 +706,7 @@ export class SessionRuntime {
   async setModelPref(modelId: string): Promise<{ ok: boolean; error?: string }> {
     // Persist the choice always; only talk to Grok when a session is live in
     // the current process (set_model on an unloaded session crashes the agent).
-    this.settings.update(this.chatId, { model: modelId });
+    this.settings.updateKey(this.settingsKey, { model: modelId });
     if (modelId && this.sessionLive && this.sessionId) {
       if (!this.acp.hasModel(modelId)) return { ok: false, error: `unknown model: ${modelId}` };
       try {
@@ -534,7 +721,7 @@ export class SessionRuntime {
   }
 
   async setAgentPref(agent: string): Promise<void> {
-    this.settings.update(this.chatId, { agent });
+    this.settings.updateKey(this.settingsKey, { agent });
     if (agent && this.sessionLive && this.sessionId && this.acp.hasMode(agent)) {
       try {
         await this.acp.setMode(this.sessionId, agent);
@@ -546,22 +733,29 @@ export class SessionRuntime {
   }
 
   setReasoningPref(effort: ReasoningEffort): void {
-    this.settings.update(this.chatId, { reasoning: effort });
+    this.settings.updateKey(this.settingsKey, { reasoning: effort });
+    this.changed();
+  }
+
+  setPreferredAccountId(id: string | undefined): void {
+    this.settings.updateKey(this.settingsKey, { preferredAccountId: id || undefined });
+    // Force re-apply on next ensureSession when user changes preference.
+    this.preferredAccountApplied = undefined;
     this.changed();
   }
 
   private async applySessionPrefs(): Promise<void> {
-    const s = this.settings.get(this.chatId);
+    const s = this.settings.getKey(this.settingsKey);
     // Drop any persisted model the agent doesn't actually offer (an unknown id
     // is silently accepted by set_model but then breaks the next prompt).
     if (s.model && !this.acp.hasModel(s.model)) {
-      log.warn(`clearing invalid persisted model "${s.model}" for chat ${this.chatId}`);
-      this.settings.update(this.chatId, { model: "" });
+      log.warn(`clearing invalid persisted model "${s.model}" for scope ${this.settingsKey}`);
+      this.settings.updateKey(this.settingsKey, { model: "" });
     }
-    const cur = this.settings.get(this.chatId);
+    const cur = this.settings.getKey(this.settingsKey);
     // Adopt the session's current agent (mode) when the user hasn't chosen one.
     if (!cur.agent && this.acp.currentModeId) {
-      this.settings.update(this.chatId, { agent: this.acp.currentModeId });
+      this.settings.updateKey(this.settingsKey, { agent: this.acp.currentModeId });
     } else if (this.sessionId && cur.agent && this.acp.hasMode(cur.agent) && cur.agent !== this.acp.currentModeId) {
       try {
         await this.acp.setMode(this.sessionId, cur.agent);
@@ -582,40 +776,88 @@ export class SessionRuntime {
 
   async submit(input: PromptInput): Promise<"ran" | "queued"> {
     await this.ensureSession();
+    // Attach staged manager report-back to this prompt (FIFO through the queue).
+    let toSubmit = input;
+    if (this.stagedReportBack) {
+      const rb = this.stagedReportBack;
+      this.stagedReportBack = undefined;
+      toSubmit = input.reportBack ? input : { ...input, reportBack: rb };
+      if (this.sessionId) bindJobSession(rb.jobId, this.sessionId);
+    }
     if (this.busy) {
-      this.queue.push(input);
+      this.queue.push(toSubmit);
       this.changed();
       return "queued";
     }
-    // First prompt of a fresh session: steer the agent to decide complexity
-    // itself (plan if complex, implement if simple) — never ask the user.
-    let toRun = input;
-    if (this.shouldSteerComplexity()) {
-      toRun = wrapAutoComplexityPrompt(input);
-      this.markComplexitySteered();
-      log.info(`chat ${this.chatId}: first-prompt auto-complexity steering applied`);
-    }
-    void this.runTurn(toRun);
+    // First-prompt steering is applied inside runTurn so queued first messages
+    // (and flushQueue) get the same complexity + telegram bridge directives.
+    void this.runTurn(toSubmit);
     return "ran";
   }
 
-  private markComplexitySteered(): void {
-    if (this.sessionId) this.complexitySteered.add(this.sessionId);
+  private markFirstPromptSteered(): void {
+    if (!this.sessionId) return;
+    this.complexitySteered.add(this.sessionId);
+    this.telegramBridgeSteered.add(this.sessionId);
+  }
+
+  private telegramBridgeDirective(): string {
+    return buildTelegramBridgeDirective({
+      forumReady: !!this.bridge?.forum?.isReady,
+      topicGroupId: this.cfg.topicGroupId,
+      allowedBots: this.cfg.allowedTelegramBots,
+      botCommands: this.cfg.telegramBotCommands,
+      managerMode: this.managerMode,
+    });
   }
 
   /**
-   * Apply auto-complexity directive only on the first prompt of a brand-new
-   * conversation (no prior user turns in this process / session jsonl).
+   * Complexity + telegram bridge teaching on the first prompt of a brand-new
+   * conversation only (no prior user turns in this process / session jsonl).
+   * Manager mode uses MANAGER_DIRECTIVE instead of complexity/progress coding UX.
    */
-  private shouldSteerComplexity(): boolean {
+  private applyFirstPromptSteering(input: PromptInput): PromptInput {
+    if (!this.shouldSteerFirstPrompt(input)) return input;
+    let toRun: PromptInput;
+    if (this.managerMode) {
+      toRun = wrapManagerDirective(input);
+      toRun = wrapTelegramBridgePrompt(toRun, this.telegramBridgeDirective());
+      this.markFirstPromptSteered();
+      log.info(`chat ${this.chatId}: first-prompt manager + telegram bridge applied`);
+      return toRun;
+    }
+    toRun = wrapAutoComplexityPrompt(input);
+    toRun = wrapTelegramBridgePrompt(toRun, this.telegramBridgeDirective());
+    this.markFirstPromptSteered();
+    log.info(`chat ${this.chatId}: first-prompt complexity + telegram bridge applied`);
+    return toRun;
+  }
+
+  /**
+   * Apply first-prompt directives only on a brand-new conversation (no prior
+   * user turns in this process / session jsonl).
+   */
+  private shouldSteerFirstPrompt(input: PromptInput): boolean {
     if (!this.sessionId) return false;
-    if (this.complexitySteered.has(this.sessionId)) return false;
+    if (this.complexitySteered.has(this.sessionId) && this.telegramBridgeSteered.has(this.sessionId)) {
+      return false;
+    }
     if (this.turnCount > 0) return false;
+    // Never wrap meta follow-ups even if somehow first.
+    if (
+      input.skipSelfRecheck ||
+      isSelfRecheckPrompt(input.text) ||
+      isTelegramBridgeResultsPrompt(input.text) ||
+      isManagerWorkReportPrompt(input.text)
+    ) {
+      return false;
+    }
     try {
       const path = join(this.cfg.sessionsDir, `${this.sessionId}.jsonl`);
       const hist = readHistory(path, 8);
       if (hist.some((e) => e.role === "user" && e.text.trim().length > 0)) {
         this.complexitySteered.add(this.sessionId);
+        this.telegramBridgeSteered.add(this.sessionId);
         return false;
       }
     } catch {
@@ -624,9 +866,40 @@ export class SessionRuntime {
     return true;
   }
 
+  /** Memory + topic catalog inject for every real manager user turn. */
+  private applyManagerContext(input: PromptInput): PromptInput {
+    if (!this.managerMode) return input;
+    if (
+      isTelegramBridgeResultsPrompt(input.text) ||
+      isManagerWorkReportPrompt(input.text) ||
+      isSelfRecheckPrompt(input.text)
+    ) {
+      return input;
+    }
+    if (!this.bridge) return input;
+    const userText = stripDirectiveWrappers(input.text) || input.text;
+    const block = buildManagerContextBlock({
+      userText,
+      sessionsDir: this.cfg.sessionsDir,
+      store: this.bridge.store,
+      forum: this.bridge.forum,
+    });
+    return {
+      ...input,
+      text: injectManagerContext(input.text, block),
+    };
+  }
+
+  /**
+   * Stop the current turn for this runtime only.
+   * Soft ACP cancel + session-scoped force-complete; never kills the shared
+   * agent (that would stop every multiplexed chat and take the bot offline).
+   */
   async cancel(): Promise<boolean> {
     if (!this.busy || !this.sessionId) return false;
     this.cancelled = true;
+    // Clear queue of follow-ups for this turn? No — only stop the active turn;
+    // queued user messages remain so the user can flush later if they want.
     await this.acp.cancel(this.sessionId);
     return true;
   }
@@ -647,6 +920,7 @@ export class SessionRuntime {
     // Account rotation restarts the process globally. Do not bind a new chat
     // to a candidate account until the owner has finished probing it.
     await this.accountRotator?.waitForIdle();
+    await this.applyPreferredAccount();
     if (this.rebindPending && this.sessionId) {
       // The ACP process is frequently mid-restart the first time we re-bind
       // (auto-restart after a crash, or a fresh bot boot), so a single attempt
@@ -671,6 +945,38 @@ export class SessionRuntime {
     if (!this.sessionId) await this.startNewSession(this.cwd, this.projectName);
   }
 
+  /** Last preferred account we successfully aligned to (avoids activate thrash). */
+  private preferredAccountApplied?: string;
+
+  /**
+   * If this scope prefers a saved account and the process is on another login,
+   * switch before binding the session. Skips when another turn is in flight
+   * (account switch restarts the agent) or we already applied this preference.
+   */
+  private async applyPreferredAccount(): Promise<void> {
+    const preferred = this.preferredAccountId;
+    const rotator = this.accountRotator;
+    if (!preferred || !rotator) return;
+    const st = rotator.state();
+    if (st.activeId === preferred) {
+      this.preferredAccountApplied = preferred;
+      return;
+    }
+    // User cleared or changed preference — allow one more activate.
+    if (this.preferredAccountApplied === preferred) return;
+    if (this.acp.hasInflightPrompt()) {
+      log.debug(`scope ${this.settingsKey}: skip preferred account (turn in flight)`);
+      return;
+    }
+    try {
+      await rotator.activate(preferred);
+      this.preferredAccountApplied = preferred;
+      log.info(`scope ${this.settingsKey}: activated preferred account ${preferred.slice(0, 8)}`);
+    } catch (e) {
+      log.debug(`preferred account activate failed: ${(e as Error).message}`);
+    }
+  }
+
   /** Reload a persisted session, retrying flaky failures with a short backoff.
    *  Returns true once loaded, false after the attempts are exhausted. */
   private async rebindWithRetries(sessionId: string, attempts = 4): Promise<boolean> {
@@ -711,20 +1017,70 @@ export class SessionRuntime {
   }
 
   private async runTurn(input: PromptInput): Promise<void> {
+    // Apply before any turn bookkeeping so card previews / logs see the wrapped
+    // text the same way the agent does (also covers flushQueue first messages).
+    try {
+      input = this.applyFirstPromptSteering(input);
+      input = this.applyManagerContext(input);
+    } catch (e) {
+      log.warn(`prompt steering/context failed: ${(e as Error).message}`);
+    }
+
     this.busy = true;
     this.cancelled = false;
     this.turnReplyTo = input.replyTo;
+    this.turnPromptId = input.promptId;
     this.turnUserText = input.text;
     this.turnAssistantText = "";
+    this.cardThinking = "";
+    this.turnExpectDone = false;
+    this.turnDonePinged = false;
     this.isSelfRecheckTurn = isSelfRecheckPrompt(input.text);
-    // Meta turns (recheck, auto-suggestion batches) never arm another recheck.
-    this.skipSelfRecheck = !!input.skipSelfRecheck || this.isSelfRecheckTurn;
-    // Fresh user work resets suggestion anchors; recheck keeps the original ask.
+    // Meta turns (recheck, bridge results, work reports) never arm another recheck.
+    const isBridgeResults = isTelegramBridgeResultsPrompt(input.text);
+    const isWorkReport = isManagerWorkReportPrompt(input.text);
+    // Keep the Thinking… bubble across search_memory → results follow-ups so
+    // the user is not left with a deleted placeholder and no reply.
+    if (this.managerStatusMsgId !== undefined && !isBridgeResults) {
+      const orphan = this.managerStatusMsgId;
+      this.managerStatusMsgId = undefined;
+      void this.deleteManagerStatus(orphan);
+    }
+    this.skipSelfRecheck =
+      !!input.skipSelfRecheck ||
+      this.isSelfRecheckTurn ||
+      isBridgeResults ||
+      isWorkReport ||
+      this.managerMode;
+    // Fresh user work resets bridge-chain depth + suggestion anchors.
+    if (!this.isSelfRecheckTurn && !isBridgeResults && !isWorkReport) {
+      this.bridgeResultDepth = 0;
+    }
+    // Fresh user work resets suggestion anchors; recheck / bridge results keep the original ask.
     // Strip complexity/reply wrappers so suggestions + recheck see the real ask.
-    if (!this.isSelfRecheckTurn) {
+    if (!this.isSelfRecheckTurn && !isBridgeResults && !isWorkReport) {
       this.suggestionUserText = stripDirectiveWrappers(input.text) || input.text;
       this.preRecheckAssistantText = "";
       this.preRecheckFileOps = new Map();
+      // Card comment: last real user prompt (not self-recheck / empty meta).
+      const preview = input.text.trim()
+        ? cleanUserPreview(input.text, COMMENT_MAX)
+        : input.images.length
+          ? "Attached image(s)"
+          : "";
+      if (preview) {
+        this.cardUserPrompt = preview;
+        this.setSessionComment(preview);
+      }
+    }
+    // Bind THIS prompt's report-back (manager dispatch). Meta follow-ups
+    // (recheck / bridge results) omit reportBack and keep the prior job until
+    // the queue drains and we report once.
+    if (input.reportBack) {
+      this.pendingReportBack = input.reportBack as ReportBackMeta;
+    }
+    if (this.pendingReportBack && this.sessionId) {
+      bindJobSession(this.pendingReportBack.jobId, this.sessionId);
     }
     this.shownToolIds = new Set();
     this.toolCallCache = new Map();
@@ -745,13 +1101,64 @@ export class SessionRuntime {
     // A new streamed turn supersedes any transient "follow" watch of this same
     // session's previous in-flight turn (avoids duplicated output).
     if (this.watchIsFollow) this.stopWatch();
-    const live = this.foreground;
+    // Manager (General): stream short chat prose (no tools/progress). Work
+    // reports stay quiet. Bridge-result follow-ups ARE user-facing — that is
+    // usually when the manager answers after search_memory.
+    const managerSilent =
+      this.managerMode && (isWorkReport || this.isSelfRecheckTurn);
+    const live = this.foreground && !managerSilent;
     const startedAt = Date.now();
     this.turnStartedAt = startedAt;
+    this.managerNotifyCount = 0;
+    this.managerUserVisible = false;
+    // General: Starting… (from message handler) → Thinking… then stream into it.
+    // Work-report wakes stay fully silent (no bubble).
+    const managerMeta = managerSilent;
+    let thinkingMsgId: number | undefined = input.seedMessageId ?? this.managerStatusMsgId;
+    if (this.managerMode && !managerSilent && this.turnReplyTo !== undefined) {
+      if (thinkingMsgId !== undefined) {
+        await this.editManagerStatus(thinkingMsgId, "Thinking\u2026");
+      } else {
+        thinkingMsgId = await this.postManagerStatus(this.turnReplyTo, "Thinking\u2026");
+      }
+      this.managerStatusMsgId = thinkingMsgId;
+    } else if (this.managerMode && managerSilent && thinkingMsgId !== undefined && !isBridgeResults) {
+      // Drop Starting… leftover on silent work-report / recheck turns.
+      await this.deleteManagerStatus(thinkingMsgId);
+      thinkingMsgId = undefined;
+      this.managerStatusMsgId = undefined;
+    }
     this.streamer = live
-      ? new ResponseStreamer(this.api, this.chatId, this.cfg.streamThrottleMs, this.turnReplyTo, this.hashtags(), (pct) => this.setProgress(pct), this.cfg.progressFallback, startedAt)
+      ? new ResponseStreamer(
+          this.api,
+          this.chatId,
+          this.cfg.streamThrottleMs,
+          this.turnReplyTo,
+          this.hashtags(),
+          this.managerMode ? undefined : (pct) => this.setProgress(pct),
+          this.managerMode ? false : this.cfg.progressFallback,
+          startedAt,
+          this.messageThreadId,
+          this.managerMode
+            ? {
+                proseOnly: true,
+                showProgressBar: false,
+                seedMessageId: thinkingMsgId,
+              }
+            : undefined,
+        )
       : undefined;
-    if (live) this.typing.start();
+    // Bind user message (+ status bubble) → session for reply routing.
+    if (this.managerMode && this.sessionId) {
+      if (this.turnReplyTo !== undefined) {
+        this.onTelegramMessageBound?.(this.turnReplyTo, this.sessionId);
+      }
+      if (thinkingMsgId !== undefined) {
+        this.onTelegramMessageBound?.(thinkingMsgId, this.sessionId);
+      }
+    }
+    // Typing indicator for user-facing manager turns and live project streams.
+    if (live || (this.managerMode && !managerMeta)) this.typing.start();
     this.activity(true);
     this.changed();
     this.imageScanText = "";
@@ -760,8 +1167,13 @@ export class SessionRuntime {
     const content = buildContentBlocks(input, {
       reasoning: reasoningDirective(this.reasoning),
       priming: this.primingContext,
-      imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
-      progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+      imageOutput:
+        !this.managerMode && this.cfg.sendAgentImages
+          ? IMAGE_OUTPUT_DIRECTIVE
+          : undefined,
+      // Manager chat: no progress spam; project topics keep the usual directive.
+      progress:
+        !this.managerMode && this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
     });
     this.primingContext = undefined;
 
@@ -786,6 +1198,15 @@ export class SessionRuntime {
       if (final.result && !this.cancelled) this.streamer?.completeFallback();
       if (this.streamer) await this.streamer.finalize();
       if (this.foreground) await this.sendTurnImages();
+
+      // Telegram bridge actions (JSON fences in the agent reply). Process on
+      // normal turns AND bridge-results follow-ups so multi-step bot_command /
+      // search chains work; depth cap prevents infinite loops.
+      let queuedBridgeResults = false;
+      if (final.result && !this.cancelled) {
+        queuedBridgeResults = await this.processTelegramBridgeActions();
+      }
+
       // Always build the completion (records `lastCompletion` so switching back
       // to this session can replay its Done + summary). Only PING the chat for
       // the foreground turn, or a background turn when NOTIFY_OTHER_SESSIONS is on.
@@ -798,49 +1219,40 @@ export class SessionRuntime {
         this.turnCount++;
         // Persist real per-account usage (turns + reported credits) for /accounts and /usage.
         this.recordAccountUsage();
-        // Card comment: what this turn solved (assistant result + files) — no extra agent call.
-        this.setSessionComment(
-          buildLastTurnSummary({
-            userText: this.turnUserText,
-            assistantText: this.turnAssistantText,
-            fileOps: this.fileOps,
-            stopReason: final.result.stopReason,
-          }),
-        );
-        this.setLiveStep(undefined);
+        // Card comment: last user prompt (thinking cleared when idle).
+        this.persistCardUserPrompt();
+        this.cardThinking = "";
+        // Keep live step while bridge/sibling-bot results are still queued —
+        // clearing here made "Waiting for bot" vanish before the interim notify.
+        if (!queuedBridgeResults) this.setLiveStep(undefined);
       } else if (this.cancelled) {
-        this.setSessionComment(
-          buildLastTurnSummary({
-            userText: this.turnUserText,
-            assistantText: this.turnAssistantText,
-            fileOps: this.fileOps,
-            cancelled: true,
-          }),
-        );
+        this.persistCardUserPrompt();
+        this.cardThinking = "";
         this.setLiveStep(undefined);
       } else if (final.error) {
-        this.setSessionComment(
-          buildLastTurnSummary({
-            userText: this.turnUserText,
-            assistantText: this.turnAssistantText,
-            fileOps: this.fileOps,
-            error: final.error.message,
-          }),
-        );
+        this.persistCardUserPrompt();
+        this.cardThinking = "";
         this.setLiveStep(undefined);
       }
       if (final.result || this.cancelled) {
-        const liveMsg = this.completionMessage(final.result?.stopReason, startedAt, streamedOutput);
-        const pingDone = canPing && (this.foreground || !hasQueued);
+        // Bridge results in the queue mean "not Done yet" — never treat as a
+        // completion ping even in the foreground. Do not post bridge status
+        // spam to the chat (live step / status panel only).
+        const pingDone =
+          canPing && (this.foreground || !hasQueued) && !queuedBridgeResults;
+        // Manager uses notify/finishManagerUserFacing — never arm Done safety-net spam.
+        this.turnExpectDone = pingDone && !this.managerMode;
 
         // One-shot self-recheck: only after a real *user* turn (not meta/auto),
         // with idle queue. skipSelfRecheck blocks loops after recheck / auto-batch.
         // Also skipped when no files were modified, or when a quiet AI decision
         // refuses (simple tasks, pure build, nothing worth re-verifying).
+        // Delay recheck/Done when bridge results are queued (like self-recheck).
         const wantSelfRecheck =
           !!final.result &&
           !this.cancelled &&
           !hasQueued &&
+          !queuedBridgeResults &&
           this.cfg.selfRecheckEnabled &&
           !this.skipSelfRecheck &&
           !this.isSelfRecheckTurn;
@@ -853,6 +1265,13 @@ export class SessionRuntime {
           this.preRecheckFileOps = cloneFileOps(this.fileOps);
           this.setLiveStep("Deciding if self-recheck is needed\u2026");
           this.changed();
+          // Visible chat status so stream-complete is not mistaken for a silent exit.
+          if (pingDone) {
+            await this.notify(
+              "\u{1F50D} Checking if a quality pass is needed\u2026",
+              { loud: true, replyTo: this.turnReplyTo },
+            );
+          }
           const recheck = await this.maybePlanSelfRecheck();
           this.setLiveStep(undefined);
           // User may cancel during the quiet decision call — first turn still
@@ -862,9 +1281,13 @@ export class SessionRuntime {
             this.preRecheckAssistantText = "";
           } else if (recheck) {
             queuedRecheck = true;
+            this.turnExpectDone = false; // final Done comes after the recheck turn
             // Front of queue; mark skip so the recheck turn never re-arms itself.
             this.queue.unshift(
-              textPrompt(recheck, this.turnReplyTo, undefined, { skipSelfRecheck: true }),
+              textPrompt(recheck, this.turnReplyTo, undefined, {
+                skipSelfRecheck: true,
+                promptId: this.turnPromptId,
+              }),
             );
             this.changed();
             if (pingDone) {
@@ -883,123 +1306,254 @@ export class SessionRuntime {
           }
         }
 
-        if (!queuedRecheck) {
-          // Post-turn suggestions on successful, non-cancelled Done with idle queue —
-          // both foreground and background (so switch-to-session can re-show them).
-          let doneMarkup = switchKb;
-          // After a recheck pass, rebuild Done with split first-turn / recheck files.
+        // Manager: keep Thinking… while bridge results are chaining so the
+        // follow-up turn can stream the real answer into the same bubble.
+        if (this.managerMode && queuedBridgeResults && this.managerStatusMsgId !== undefined) {
+          void this.editManagerStatus(this.managerStatusMsgId, "Thinking\u2026");
+        }
+
+        if (!queuedRecheck && !queuedBridgeResults) {
+          // Manager (General): quiet-by-default completion — no Done spam.
+          // User-facing only via notify (already sent) or one fallback reply.
+          if (this.managerMode) {
+            await this.finishManagerUserFacing(managerMeta, final.result?.stopReason, startedAt);
+            this.turnDonePinged = true;
+            // Suggestions only when something was actually shown to the user.
+            if (
+              final.result &&
+              !this.cancelled &&
+              !hasQueued &&
+              this.managerUserVisible &&
+              !managerMeta
+            ) {
+              try {
+                const baseForSug =
+                  cleanManagerVisibleText(this.turnAssistantText).slice(0, 500) || "Done";
+                await this.collectAndApplySuggestions(baseForSug, undefined, {
+                  autoQueue: true,
+                });
+              } catch (e) {
+                log.debug(`manager suggestions failed: ${(e as Error).message}`);
+              }
+            }
+          } else {
+          // Build Done text *now* (after quiet decision) so a cancel during the
+          // recheck-decision wait shows ⏹ Stopped, not a stale ✅ Done head.
           let doneText = this.isSelfRecheckTurn
-            ? this.completionMessageSplit(final.result?.stopReason, startedAt, streamedOutput)
-            : liveMsg;
-          if (final.result && !this.cancelled && !hasQueued) {
-            const sug = await this.collectAndApplySuggestions(doneText, switchKb, {
-              // Only auto-queue high-need follow-ups when the user is watching;
-              // background sessions store buttons for the Done ping / switch replay.
-              autoQueue: this.foreground,
+              ? this.completionMessageSplit(final.result?.stopReason, startedAt, streamedOutput)
+              : this.completionMessage(final.result?.stopReason, startedAt, streamedOutput);
+          // 1) Always send Done FIRST — never block the completion ping on the
+          // quiet suggestions prompt (which can hang and look like "no Done").
+          let doneMsgId: number | undefined;
+          const shouldPingDone = pingDone;
+          if (shouldPingDone && doneText.trim()) {
+            doneMsgId = await this.notify(doneText, {
+              loud: true,
+              replyTo: this.turnReplyTo,
+              replyMarkup: switchKb,
             });
-            doneText = sug.text;
-            doneMarkup = sug.markup;
+            if (doneMsgId !== undefined) this.turnDonePinged = true;
+          }
+          // 2) Suggestions: project topics keep Done-edit UX.
+          if (final.result && !this.cancelled && !hasQueued) {
+            try {
+              const baseForSug = doneText;
+              const sug = await this.collectAndApplySuggestions(
+                baseForSug,
+                switchKb,
+                {
+                  autoQueue: this.foreground,
+                },
+              );
+              if (shouldPingDone && sug.text !== doneText) {
+                await this.enhanceDoneMessage(doneMsgId, sug.text, sug.markup ?? switchKb);
+              }
+            } catch (e) {
+              log.debug(`suggestions after Done failed: ${(e as Error).message}`);
+            }
+          }
           }
-          if (pingDone) await this.notify(doneText, { loud: true, replyTo: this.turnReplyTo, replyMarkup: doneMarkup });
           // Clear frozen first-turn ops after final Done (recheck path done).
           if (this.isSelfRecheckTurn) this.preRecheckFileOps = new Map();
+
+          // Child work dispatched from General → wake manager with a report.
+          // (Waits only for same-job meta follow-ups; see maybeReportBackToManager.)
+          await this.maybeReportBackToManager({
+            ok: !!final.result && !this.cancelled,
+            cancelled: this.cancelled,
+            stopReason: final.result?.stopReason,
+            error: undefined,
+          });
         }
+        // queuedBridgeResults: stay quiet in chat — agent gets results via queue.
       } else if (final.error) {
-        // If the self-recheck pass itself failed, still surface Done for the
-        // original work (split files + suggestions) so the user is not stuck.
-        if (this.isSelfRecheckTurn && !hasQueued) {
+        // Manager: one short important message (or edit Thinking…); never Done spam.
+        if (this.managerMode) {
+          await this.finishManagerError(final.error.message, startedAt);
+          this.turnDonePinged = true;
+          await this.maybeReportBackToManager({
+            ok: false,
+            cancelled: false,
+            error: final.error.message,
+          });
+        } else if (this.isSelfRecheckTurn && !hasQueued) {
+          // If the self-recheck pass itself failed, still surface Done for the
+          // original work (split files + suggestions) so the user is not stuck.
           const switchKb = this.switchKeyboard();
           const pingDone = canPing && (this.foreground || !hasQueued);
+          this.turnExpectDone = pingDone;
           let doneText =
             this.completionMessageSplit(undefined, startedAt, streamedOutput) +
             `\n\n\u26A0\uFE0F Self-recheck failed: ${final.error.message}`;
-          if (!this.cancelled) {
-            const sug = await this.collectAndApplySuggestions(doneText, switchKb, {
-              autoQueue: this.foreground,
+          let doneMsgId: number | undefined;
+          if (pingDone) {
+            doneMsgId = await this.notify(doneText, {
+              loud: true,
+              replyTo: this.turnReplyTo,
+              replyMarkup: switchKb,
             });
-            doneText = sug.text;
-            if (pingDone) {
-              await this.notify(doneText, {
-                loud: true,
-                replyTo: this.turnReplyTo,
-                replyMarkup: sug.markup,
+            if (doneMsgId !== undefined) this.turnDonePinged = true;
+          }
+          if (!this.cancelled) {
+            try {
+              const sug = await this.collectAndApplySuggestions(doneText, switchKb, {
+                autoQueue: this.foreground,
               });
+              if (pingDone && sug.text !== doneText) {
+                await this.enhanceDoneMessage(doneMsgId, sug.text, sug.markup ?? switchKb);
+              }
+            } catch (e) {
+              log.debug(`suggestions after recheck-fail Done failed: ${(e as Error).message}`);
             }
-          } else if (pingDone) {
-            await this.notify(doneText, { loud: true, replyTo: this.turnReplyTo, replyMarkup: switchKb });
           }
           this.preRecheckFileOps = new Map();
+          // Self-recheck failed after real work — still report manager job if any.
+          await this.maybeReportBackToManager({
+            ok: true,
+            cancelled: this.cancelled,
+            stopReason: "self_recheck_failed",
+            error: final.error.message,
+          });
         } else {
           const transient = isTransientError(final.error);
           const liveMsg = this.errorMessage(final.error, startedAt, final.attempts, transient);
-          if (canPing) await this.notify(liveMsg, { loud: true, replyTo: this.turnReplyTo, replyMarkup: switchKb });
+          this.turnExpectDone = canPing;
+          if (canPing) {
+            const id = await this.notify(liveMsg, {
+              loud: true,
+              replyTo: this.turnReplyTo,
+              replyMarkup: switchKb,
+            });
+            if (id !== undefined) this.turnDonePinged = true;
+          }
+          await this.maybeReportBackToManager({
+            ok: false,
+            cancelled: false,
+            error: final.error.message,
+          });
         }
       }
     } catch (err) {
       // Unexpected failure outside the prompt path (e.g. while finalizing).
       await this.streamer?.finalize().catch(() => {});
       const errMsg = (err as Error).message;
-      this.setSessionComment(
-        buildLastTurnSummary({
-          userText: this.turnUserText,
-          assistantText: this.turnAssistantText,
-          fileOps: this.fileOps,
-          error: errMsg,
-        }),
-      );
+      this.persistCardUserPrompt();
+      this.cardThinking = "";
       this.setLiveStep(undefined);
       // If the self-recheck pass itself blew up, still surface Done for the
       // original work (split files + suggestions) so the user is not stuck.
       if (this.isSelfRecheckTurn && this.queue.length === 0) {
         const switchKb = this.switchKeyboard();
         const canPing = this.foreground || this.cfg.notifyOtherSessions;
+        this.turnExpectDone = canPing;
         let doneText =
           this.completionMessageSplit(undefined, startedAt, this.streamer?.hasOutput ?? false) +
           `\n\n\u26A0\uFE0F Self-recheck failed: ${errMsg}`;
         try {
-          if (!this.cancelled) {
-            const sug = await this.collectAndApplySuggestions(doneText, switchKb, {
-              autoQueue: this.foreground,
-            });
-            doneText = sug.text;
-            if (canPing) {
-              await this.notify(doneText, {
-                loud: true,
-                replyTo: this.turnReplyTo,
-                replyMarkup: sug.markup,
-              });
-            }
-          } else if (canPing) {
-            await this.notify(doneText, {
+          let doneMsgId: number | undefined;
+          if (canPing) {
+            doneMsgId = await this.notify(doneText, {
               loud: true,
               replyTo: this.turnReplyTo,
               replyMarkup: switchKb,
             });
+            if (doneMsgId !== undefined) this.turnDonePinged = true;
+          }
+          if (!this.cancelled) {
+            try {
+              const sug = await this.collectAndApplySuggestions(doneText, switchKb, {
+                autoQueue: this.foreground,
+              });
+              if (canPing && sug.text !== doneText) {
+                await this.enhanceDoneMessage(doneMsgId, sug.text, sug.markup ?? switchKb);
+              }
+            } catch (e2) {
+              log.debug(`suggestions after recheck catch failed: ${(e2 as Error).message}`);
+            }
           }
         } catch (e2) {
           log.debug(`recheck catch recovery failed: ${(e2 as Error).message}`);
-          if (canPing) {
-            await this.notify(doneText, {
+          if (canPing && !this.turnDonePinged) {
+            const id = await this.notify(doneText, {
               loud: true,
               replyTo: this.turnReplyTo,
               replyMarkup: switchKb,
-            }).catch(() => {});
+            });
+            if (id !== undefined) this.turnDonePinged = true;
           }
         }
         this.preRecheckFileOps = new Map();
+      } else if (this.managerMode) {
+        await this.finishManagerError(errMsg, startedAt);
+        this.turnDonePinged = true;
+        await this.maybeReportBackToManager({
+          ok: false,
+          cancelled: this.cancelled,
+          error: errMsg,
+        });
       } else {
         const msg = `\u274C Error after ${fmtDuration(Date.now() - startedAt)}: ${errMsg}`;
         this.lastCompletion = msg;
-        if (this.foreground || this.cfg.notifyOtherSessions) {
+        const canPing = this.foreground || this.cfg.notifyOtherSessions;
+        this.turnExpectDone = canPing;
+        if (canPing) {
           const from = this.foreground ? "" : `\u{1F4E8} From other session ${this.sessionTag()}\n`;
-          await this.notify(`${from}${msg}`, {
+          const id = await this.notify(`${from}${msg}`, {
             loud: true,
             replyTo: this.turnReplyTo,
             replyMarkup: this.switchKeyboard(),
           });
+          if (id !== undefined) this.turnDonePinged = true;
         }
+        await this.maybeReportBackToManager({
+          ok: false,
+          cancelled: this.cancelled,
+          error: errMsg,
+        });
       }
     } finally {
+      // Safety net: turn completed with an expected Done ping that never landed
+      // (notify failed, hung path, etc.). Never block queue flush on this.
+      // Manager never uses this path (turnExpectDone is false in manager mode).
+      if (this.turnExpectDone && !this.turnDonePinged && !this.managerMode) {
+        const fallback =
+          this.lastCompletion?.trim() ||
+          `\u2705 Done \u00B7 ${fmtDuration(Date.now() - startedAt)}`;
+        const short =
+          fallback.length > 3500 ? fallback.slice(0, 3499) + "\u2026" : fallback;
+        try {
+          const id = await this.notify(short, {
+            loud: true,
+            replyTo: this.turnReplyTo,
+            replyMarkup: this.switchKeyboard(),
+          });
+          if (id !== undefined) this.turnDonePinged = true;
+          else log.warn(`chat ${this.chatId}: Done safety-net notify failed`);
+        } catch (e) {
+          log.warn(`chat ${this.chatId}: Done safety-net error: ${(e as Error).message}`);
+        }
+      }
+      this.turnExpectDone = false;
       this.typing.stop();
       this.streamer = undefined;
       this.capturingQuiet = false;
@@ -1013,7 +1567,8 @@ export class SessionRuntime {
       // messages. The finished streamed bubble keeps its own (frozen) bar.
       this.progress = undefined;
       this.planEntries = undefined;
-      // Prefer stored summary on cards once idle (clear live step if still set).
+      // Idle cards show last user prompt only (clear live step / thinking).
+      this.cardThinking = "";
       if (!this.liveStep || this.sessionComment) this.liveStep = undefined;
       this.changed();
     }
@@ -1029,6 +1584,122 @@ export class SessionRuntime {
     }
   }
 
+  /**
+   * Parse telegram JSON actions from the assistant reply, execute them, notify
+   * the user, and queue a results follow-up for the agent when useful.
+   * Returns true when a results prompt was queued (delay Done/recheck).
+   */
+  private async processTelegramBridgeActions(): Promise<boolean> {
+    const { actions, cleaned } = extractTelegramActions(this.turnAssistantText);
+    if (cleaned !== this.turnAssistantText) {
+      this.turnAssistantText = cleaned;
+    }
+    if (actions.length === 0) return false;
+    if (!this.bridge) {
+      log.warn(`chat ${this.chatId}: telegram actions present but bridge not wired`);
+      return false;
+    }
+
+    const botCmds = actions.filter((a) => a.action === "bot_command");
+    // bot_command means Grok ended its turn early to wait on a sibling bot —
+    // this is NOT a Done. Keep busy; status panel live-step only (no chat spam).
+    if (botCmds.length > 0) {
+      const labels = botCmds
+        .map((a) =>
+          a.action === "bot_command" ? `@${a.bot} /${a.command}` : "",
+        )
+        .filter(Boolean)
+        .join(", ");
+      this.setLiveStep(`Waiting for sibling bot: ${labels}`);
+    } else {
+      this.setLiveStep("Running Telegram bridge actions\u2026");
+    }
+    this.changed();
+    log.info(`chat ${this.chatId}: executing ${actions.length} telegram bridge action(s)`);
+
+    const results = await executeTelegramActions(actions, {
+      api: this.api,
+      cfg: this.cfg,
+      chatId: this.chatId,
+      messageThreadId: this.messageThreadId,
+      replyToMessageId: this.turnReplyTo,
+      forum: this.bridge.forum,
+      store: this.bridge.store,
+      bots: this.bridge.bots,
+      submitTopicPrompt: this.bridge.submitTopicPrompt,
+      managerMode: this.managerMode,
+      managerUserAskPreview: this.suggestionUserText || cleanUserPreview(this.turnUserText, 400),
+    });
+
+    // Count successful notify actions. Do not delete the live stream bubble
+    // (same id as Thinking…) — that would wipe the user's visible reply.
+    for (const r of results) {
+      if (r.action === "notify" && r.ok) {
+        this.managerNotifyCount++;
+        this.managerUserVisible = true;
+        const streamLive = this.streamer?.liveMessageId;
+        if (
+          this.managerStatusMsgId !== undefined &&
+          this.managerStatusMsgId !== streamLive &&
+          !this.streamer?.hasOutput
+        ) {
+          const sid = this.managerStatusMsgId;
+          this.managerStatusMsgId = undefined;
+          void this.deleteManagerStatus(sid);
+        }
+        const mid = (r.data as { messageId?: number } | undefined)?.messageId;
+        if (mid !== undefined && this.sessionId) {
+          this.onTelegramMessageBound?.(mid, this.sessionId);
+        }
+      }
+    }
+
+    // Only announce durable side-effects in chat (topic create/bind/cross-prompt).
+    // Manager mode stays quiet — use notify for user text; no auto notes.
+    // search_memory / list_* / bot wait status stay silent — results go to the agent.
+    const durableActions = new Set(["create_topic", "set_path", "send_prompt"]);
+    const notes = results
+      .filter((r) => durableActions.has(r.action) && r.userNote?.trim())
+      .map((r) => r.userNote!)
+      .filter(Boolean);
+    if (notes.length > 0 && this.foreground && !this.managerMode) {
+      await this.notify(notes.join("\n"), {
+        loud: true,
+        replyTo: this.turnReplyTo,
+      });
+    }
+
+    // Cap chained result turns so a model that re-emits list_bots forever cannot
+    // block Done. Side-effects already ran; user notes were sent above.
+    // Still queue once when we have bot_command errors so the agent can recover.
+    if (this.bridgeResultDepth >= SessionRuntime.BRIDGE_CHAIN_MAX) {
+      log.warn(
+        `chat ${this.chatId}: telegram bridge chain depth ${this.bridgeResultDepth} — not re-queuing results`,
+      );
+      return false;
+    }
+
+    // Feed results back so the agent can use search hits / bot replies / errors.
+    const prompt = buildTelegramBridgeResultsPrompt(
+      results.map((r) => ({
+        action: r.action,
+        ok: r.ok,
+        data: r.data,
+        error: r.error,
+      })),
+    );
+    this.bridgeResultDepth++;
+    this.queue.unshift(
+      textPrompt(prompt, this.turnReplyTo, undefined, {
+        skipSelfRecheck: true,
+        promptId: this.turnPromptId,
+      }),
+    );
+    this.setLiveStep("Feeding sibling-bot / bridge results to the agent\u2026");
+    this.changed();
+    return true;
+  }
+
   /**
    * Quietly ask for 1–3 follow-ups, attach buttons to the Done text, store them
    * for switch-replay, and optionally queue auto-approved items as **one**
@@ -1038,7 +1709,7 @@ export class SessionRuntime {
     doneText: string,
     switchKb: InlineKeyboard | undefined,
     opts?: { autoQueue?: boolean },
-  ): Promise<{ text: string; markup?: InlineKeyboard }> {
+  ): Promise<{ text: string; markup?: InlineKeyboard; suggestions?: Suggestion[] }> {
     if (!this.cfg.suggestionsEnabled || !this.sessionId) {
       return { text: doneText, markup: switchKb };
     }
@@ -1048,6 +1719,8 @@ export class SessionRuntime {
     } catch (e) {
       log.debug(`suggestions fetch failed: ${(e as Error).message}`);
     }
+    // Manager: keep 1–4 short follow-ups only.
+    if (this.managerMode) suggestions = suggestions.slice(0, 4);
     if (suggestions.length === 0) return { text: doneText, markup: switchKb };
 
     const batchId = ++this.suggestionBatchSeq;
@@ -1065,18 +1738,26 @@ export class SessionRuntime {
     let banner: string;
     if (auto.length > 0) {
       const batched = formatBatchedSuggestionsPrompt(auto);
-      const lines = auto.map((s, i) => `  ${i + 1}) ${s.need}% \u2014 ${s.text}`);
+      // Hard, visible auto-approve block (especially for General chat).
+      const lines = auto.map((s) => `\u2022 ${s.text}`);
       const autoBlock =
-        `\n\n\u{1F4A1} Auto-running ${auto.length} suggestion${auto.length === 1 ? "" : "s"}` +
-        ` as one prompt (\u2265 ${thr}% need):\n${lines.join("\n")}`;
+        `\n\n\u2705 Auto Approved:\n${lines.join("\n")}` +
+        (this.managerMode ? "" : `\n(need \u2265 ${thr}%)`);
       text += autoBlock;
-      banner = `\u{1F4A1} Suggestions (auto-running ${auto.length} as one prompt):\n${lines.join("\n")}`;
+      banner = `\u2705 Auto Approved:\n${lines.join("\n")}`;
       // Single queue entry — agent executes 1) 2) 3) in one turn.
       // skipSelfRecheck: auto-follow-ups must not arm another recheck cycle.
-      this.queue.push(textPrompt(batched, this.turnReplyTo, undefined, { skipSelfRecheck: true }));
+      this.queue.push(
+        textPrompt(batched, this.turnReplyTo, undefined, {
+          skipSelfRecheck: true,
+          promptId: this.turnPromptId,
+        }),
+      );
       this.changed();
     } else {
-      text += "\n\n\u{1F4A1} Suggestions \u2014 tap one to continue:";
+      text += this.managerMode
+        ? "\n\nTap a suggestion to continue:"
+        : "\n\n\u{1F4A1} Suggestions \u2014 tap one to continue:";
       banner = "\u{1F4A1} Suggestions \u2014 tap one to continue:";
     }
 
@@ -1084,8 +1765,168 @@ export class SessionRuntime {
     // the same keyboard). Cleared when a new turn starts.
     this.pendingSuggestions = { batchId, suggestions, banner };
 
-    const markup = suggestionsKeyboard(batchId, suggestions, switchKb);
-    return { text, markup };
+    // Keyboard: show remaining (non-auto) suggestions; if all auto, no buttons.
+    const remaining = suggestions.filter((s) => !auto.some((a) => a.text === s.text));
+    const markup =
+      remaining.length > 0
+        ? suggestionsKeyboard(batchId, remaining, switchKb)
+        : switchKb;
+    return { text, markup, suggestions };
+  }
+
+  /** Post General status bubble (Starting… / Thinking…) — streamer edits it later. */
+  private async postManagerStatus(
+    replyTo: number,
+    text: string,
+  ): Promise<number | undefined> {
+    try {
+      const extra: Record<string, unknown> = {
+        disable_notification: true,
+        ...outboundThreadExtra(this.messageThreadId),
+        reply_parameters: {
+          message_id: replyTo,
+          allow_sending_without_reply: true,
+        },
+      };
+      const msg = await this.api.sendMessage(this.chatId, text, extra);
+      return msg.message_id;
+    } catch (e) {
+      log.debug(`manager status "${text}" failed: ${(e as Error).message}`);
+      return undefined;
+    }
+  }
+
+  private async editManagerStatus(messageId: number, text: string): Promise<void> {
+    try {
+      await this.api.editMessageText(this.chatId, messageId, text);
+    } catch (e) {
+      log.debug(`manager status edit failed: ${(e as Error).message}`);
+    }
+  }
+
+  private async deleteManagerStatus(messageId: number): Promise<void> {
+    try {
+      await this.api.deleteMessage(this.chatId, messageId);
+    } catch (e) {
+      log.debug(`manager status delete failed: ${(e as Error).message}`);
+    }
+  }
+
+  /** Surface a short important error in General; clear Thinking… bubble. */
+  private async finishManagerError(errorMessage: string, startedAt: number): Promise<void> {
+    const elapsed = fmtDuration(Date.now() - startedAt);
+    const short =
+      errorMessage.length > 280 ? errorMessage.slice(0, 277) + "\u2026" : errorMessage;
+    const text = `\u274C ${short} \u00B7 ${elapsed}`;
+    this.lastCompletion = text;
+    if (this.managerStatusMsgId !== undefined) {
+      await this.editManagerStatus(this.managerStatusMsgId, text);
+      this.managerUserVisible = true;
+      if (this.sessionId) this.onTelegramMessageBound?.(this.managerStatusMsgId, this.sessionId);
+      this.managerStatusMsgId = undefined;
+      return;
+    }
+    if (this.turnReplyTo !== undefined) {
+      const id = await this.notify(text, { loud: true, replyTo: this.turnReplyTo });
+      if (id !== undefined) this.managerUserVisible = true;
+    }
+  }
+
+  /**
+   * General quiet completion:
+   * - if notify already sent → drop Thinking… bubble
+   * - else if direct user ask and clean prose → one short fallback message
+   * - else → delete Thinking… and stay silent
+   */
+  private async finishManagerUserFacing(
+    metaTurn: boolean,
+    stopReason: string | undefined,
+    startedAt: number,
+  ): Promise<void> {
+    const elapsed = fmtDuration(Date.now() - startedAt);
+    if (this.cancelled || stopReason === "cancelled") {
+      this.lastCompletion = `\u23F9 Stopped \u00B7 ${elapsed}`;
+      // Only surface cancel if user was waiting on a visible bubble.
+      if (this.managerStatusMsgId !== undefined && !metaTurn) {
+        await this.editManagerStatus(this.managerStatusMsgId, this.lastCompletion);
+        this.managerUserVisible = true;
+      } else if (this.managerStatusMsgId !== undefined) {
+        await this.deleteManagerStatus(this.managerStatusMsgId);
+      }
+      this.managerStatusMsgId = undefined;
+      return;
+    }
+
+    // Prose already landed in the Thinking… bubble via the streamer — keep it.
+    if (this.streamer?.hasOutput) {
+      this.managerUserVisible = true;
+      this.lastCompletion =
+        cleanManagerVisibleText(this.turnAssistantText).slice(0, 500) ||
+        `\u2705 Done \u00B7 ${elapsed}`;
+      this.managerStatusMsgId = undefined;
+      return;
+    }
+
+    if (this.managerNotifyCount > 0) {
+      this.lastCompletion =
+        cleanManagerVisibleText(this.turnAssistantText).slice(0, 500) ||
+        `\u2705 Done \u00B7 ${elapsed}`;
+      if (this.managerStatusMsgId !== undefined) {
+        await this.deleteManagerStatus(this.managerStatusMsgId);
+        this.managerStatusMsgId = undefined;
+      }
+      return;
+    }
+
+    // Work-report / recheck: silent unless cancelled (handled above).
+    if (metaTurn) {
+      this.lastCompletion = `\u2705 Done \u00B7 ${elapsed}`;
+      if (this.managerStatusMsgId !== undefined) {
+        await this.deleteManagerStatus(this.managerStatusMsgId);
+        this.managerStatusMsgId = undefined;
+      }
+      return;
+    }
+
+    // Direct user ask: single fallback if the model emitted no visible prose.
+    const cleaned = cleanManagerVisibleText(this.turnAssistantText);
+    const fallback = pickManagerFallbackText(cleaned);
+    if (fallback && this.managerStatusMsgId !== undefined) {
+      await this.editManagerStatus(this.managerStatusMsgId, fallback);
+      this.managerUserVisible = true;
+      this.lastCompletion = fallback.slice(0, 500);
+      if (this.sessionId) this.onTelegramMessageBound?.(this.managerStatusMsgId, this.sessionId);
+      this.managerStatusMsgId = undefined;
+      return;
+    }
+    if (fallback && this.turnReplyTo !== undefined) {
+      const id = await this.notify(fallback, {
+        loud: false,
+        replyTo: this.turnReplyTo,
+      });
+      if (id !== undefined) {
+        this.managerUserVisible = true;
+        this.lastCompletion = fallback.slice(0, 500);
+        if (this.sessionId) this.onTelegramMessageBound?.(id, this.sessionId);
+      }
+    } else if (this.managerStatusMsgId !== undefined) {
+      // Never delete the placeholder leaving the user with no reply.
+      await this.editManagerStatus(
+        this.managerStatusMsgId,
+        "Working on it \u2014 I\u2019ll report back here.",
+      );
+      this.managerUserVisible = true;
+      this.lastCompletion = "Working on it";
+      if (this.sessionId) this.onTelegramMessageBound?.(this.managerStatusMsgId, this.sessionId);
+      this.managerStatusMsgId = undefined;
+      return;
+    } else {
+      this.lastCompletion = `\u2705 Done \u00B7 ${elapsed}`;
+    }
+    if (this.managerStatusMsgId !== undefined) {
+      await this.deleteManagerStatus(this.managerStatusMsgId);
+      this.managerStatusMsgId = undefined;
+    }
   }
 
   /**
@@ -1142,14 +1983,12 @@ export class SessionRuntime {
   ): Promise<ReturnType<typeof parseSelfRecheckDecision>> {
     if (!this.sessionId) return { needed: false, reason: "no session" };
     const prompt = buildSelfRecheckDecisionPrompt(user, did, filesSummary);
-    this.capturingQuiet = true;
-    this.quietCaptureBuf = "";
     try {
-      await this.acp.prompt(this.sessionId, [{ type: "text", text: prompt }]);
-      return parseSelfRecheckDecision(this.quietCaptureBuf);
-    } finally {
-      this.capturingQuiet = false;
-      this.quietCaptureBuf = "";
+      const raw = await this.runQuietPrompt(prompt);
+      return parseSelfRecheckDecision(raw);
+    } catch (e) {
+      log.debug(`self-recheck decision quiet prompt failed: ${(e as Error).message}`);
+      return { needed: false, reason: "decision prompt failed" };
     }
   }
 
@@ -1164,15 +2003,60 @@ export class SessionRuntime {
     const didParts = [this.preRecheckAssistantText, this.turnAssistantText].filter((s) => s?.trim());
     const did = didParts.join("\n") || this.turnAssistantText;
     const prompt = buildSuggestionsPrompt(user, did);
+    try {
+      const raw = await this.runQuietPrompt(prompt);
+      return parseSuggestions(raw);
+    } catch (e) {
+      log.debug(`suggestions quiet prompt failed: ${(e as Error).message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Run a quiet meta ACP prompt (JSON only) with a hard timeout.
+   * On timeout: session/cancel so the shared agent is not stuck holding the
+   * session (which would block Done forever). Does NOT set this.cancelled
+   * (user /stop is separate). Timed-out / partial capture is discarded.
+   */
+  private async runQuietPrompt(text: string): Promise<string> {
+    if (!this.sessionId) return "";
+    const ms = Math.max(5_000, this.cfg.quietPromptTimeoutMs || 90_000);
     this.capturingQuiet = true;
     this.quietCaptureBuf = "";
+    let timedOut = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      // Ignore timer if the prompt already settled (avoids discarding a good JSON
+      // reply that finished in the same tick as the timeout).
+      if (settled) return;
+      timedOut = true;
+      log.warn(
+        `chat ${this.chatId}: quiet meta prompt timed out after ${ms}ms — cancelling session prompt`,
+      );
+      // Session-scoped cancel only — never kill the shared agent process.
+      void this.acp.cancel(this.sessionId!);
+    }, ms);
+    let buf = "";
     try {
-      await this.acp.prompt(this.sessionId, [{ type: "text", text: prompt }]);
-      return parseSuggestions(this.quietCaptureBuf);
+      await this.acp.prompt(this.sessionId, [{ type: "text", text }]);
+      settled = true;
+      clearTimeout(timer);
+      buf = this.quietCaptureBuf;
+    } catch (e) {
+      settled = true;
+      clearTimeout(timer);
+      buf = this.quietCaptureBuf;
+      if (!timedOut) throw e;
+      log.debug(`quiet prompt ended after timeout: ${(e as Error).message}`);
     } finally {
+      clearTimeout(timer);
       this.capturingQuiet = false;
       this.quietCaptureBuf = "";
     }
+    // Timed-out meta replies are often half-JSON — skip rather than act on garbage.
+    // If we settled successfully before the timer fired, timedOut stays false.
+    if (timedOut) return "";
+    return buf;
   }
 
   /** Resolve a tapped suggestion button; returns the prompt text or undefined. */
@@ -1270,7 +2154,8 @@ export class SessionRuntime {
         reasoning: reasoningDirective(this.reasoning),
         priming: this.primingContext,
         imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
-        progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+        progress:
+          !this.managerMode && this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
       });
       this.primingContext = undefined;
       log.info(
@@ -1333,7 +2218,8 @@ export class SessionRuntime {
       reasoning: reasoningDirective(this.reasoning),
       priming: transcript ? buildPriming(transcript) : undefined,
       imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
-      progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+      progress:
+          !this.managerMode && this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
     });
     return this.runPromptWithRetries(forkContent);
   }
@@ -1385,7 +2271,8 @@ export class SessionRuntime {
           reasoning: reasoningDirective(this.reasoning),
           priming: transcript ? buildPriming(transcript) : undefined,
           imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
-          progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+          progress:
+          !this.managerMode && this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
         });
         return this.runPromptWithRetries(content);
       }
@@ -1432,7 +2319,8 @@ export class SessionRuntime {
         reasoning: reasoningDirective(this.reasoning),
         priming: transcript ? buildPriming(transcript) : undefined,
         imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
-      progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+      progress:
+          !this.managerMode && this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
       });
       log.info(
         `chat ${this.chatId} auto-rotating to account ${t.label}` +
@@ -1479,6 +2367,11 @@ export class SessionRuntime {
       try {
         const updatesBeforePrompt = this.sessionUpdateCount;
         const result = await this.acp.prompt(this.sessionId!, content);
+        // User /stop force-complete or agent honouring session/cancel often
+        // returns cancelled with zero session/update chunks — that is success.
+        if (this.cancelled || result?.stopReason === "cancelled") {
+          return { result: result ?? { stopReason: "cancelled" }, attempts: attempt };
+        }
         // A healthy ACP turn emits at least one session/update (text, thought,
         // or tool event) before resolving session/prompt. Grok can otherwise
         // report a successful end-turn after an upstream model failure; never
@@ -1557,7 +2450,8 @@ export class SessionRuntime {
     const resumeContent = buildContentBlocks(textPrompt(RESUME_INSTRUCTION), {
       reasoning: reasoningDirective(this.reasoning),
       imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
-      progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+      progress:
+          !this.managerMode && this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
     });
 
     let last = final;
@@ -1604,6 +2498,7 @@ export class SessionRuntime {
         already: this.sentImagesThisTurn,
         max: this.cfg.agentImagesMax,
         replyTo: this.turnReplyTo,
+        messageThreadId: this.messageThreadId,
       });
       if (n > 0) log.info(`chat ${this.chatId}: sent ${n} agent image file(s)`);
     } catch {
@@ -1627,6 +2522,111 @@ export class SessionRuntime {
     return `\u{1F4E8} From other session ${this.sessionTag()}\n${head}\n${summarizeFileOpsShort(this.fileOps)}\n\n${tags}`;
   }
 
+  /** Soft completion for General manager (no file-ops / progress spam). */
+  private managerCompletionMessage(
+    stopReason: string | undefined,
+    startedAt: number,
+    streamedOutput: boolean,
+  ): string {
+    const elapsed = fmtDuration(Date.now() - startedAt);
+    if (this.cancelled || stopReason === "cancelled") {
+      const msg = `\u23F9 Stopped \u00B7 ${elapsed}`;
+      this.lastCompletion = msg;
+      return streamedOutput ? "" : msg;
+    }
+    // When prose already streamed, no extra Done line (chat-like).
+    if (streamedOutput) {
+      this.lastCompletion = this.turnAssistantText.slice(0, 800) || `\u2705 Done \u00B7 ${elapsed}`;
+      return "";
+    }
+    const msg = `\u2705 Done \u00B7 ${elapsed}`;
+    this.lastCompletion = msg;
+    return msg;
+  }
+
+  /**
+   * True when the next queued prompt is a continuation of the *same* manager
+   * job (self-recheck / bridge results / suggestion batch), not a new user
+   * ask or a different send_prompt dispatch.
+   */
+  private queueIsSameJobContinuation(jobId: string): boolean {
+    if (this.queue.length === 0) return false;
+    const next = this.queue[0]!;
+    if (next.reportBack && next.reportBack.jobId !== jobId) return false;
+    if (next.reportBack && next.reportBack.jobId === jobId) return true;
+    // Meta continuations omit reportBack but keep the open job.
+    return (
+      !!next.skipSelfRecheck ||
+      isSelfRecheckPrompt(next.text) ||
+      isTelegramBridgeResultsPrompt(next.text) ||
+      isManagerWorkReportPrompt(next.text)
+    );
+  }
+
+  /**
+   * If this runtime was dispatched from General, wake the manager with a
+   * structured WORK REPORT once for this job. Waits only for same-job meta
+   * follow-ups; reports immediately when a different dispatch/user turn is next.
+   */
+  private async maybeReportBackToManager(opts: {
+    ok: boolean;
+    cancelled: boolean;
+    stopReason?: string;
+    error?: string;
+  }): Promise<void> {
+    const meta = this.pendingReportBack;
+    if (!meta || !this.bridge?.wakeManager) return;
+    // Same-job recheck / bridge results / suggestions still pending — wait.
+    if (this.queueIsSameJobContinuation(meta.jobId)) return;
+
+    const status = opts.cancelled ? "cancelled" : opts.ok ? "done" : "failed";
+    const assistantSummary = (
+      this.turnAssistantText.trim() ||
+      this.lastCompletion ||
+      "(no assistant text)"
+    ).replace(/\s+/g, " ").trim();
+    const filesSummary =
+      this.fileOps.size > 0 ? summarizeFileOpsShort(this.fileOps) : undefined;
+
+    updateManagerJob(meta.jobId, {
+      status: status === "done" ? "done" : status === "cancelled" ? "cancelled" : "failed",
+      resultSummary: assistantSummary.slice(0, 400),
+      childSessionId: this.sessionId,
+    });
+
+    const prompt = buildManagerWorkReportPrompt({
+      jobId: meta.jobId,
+      targetName: meta.targetName || this.projectName || basename(this.cwd),
+      targetThreadId: this.messageThreadId ?? 0,
+      targetPath: meta.targetPath || this.cwd,
+      userAskPreview: meta.userAskPreview,
+      dispatchPromptPreview: meta.dispatchPrompt,
+      status,
+      stopReason: opts.stopReason,
+      error: opts.error,
+      assistantSummary,
+      filesSummary,
+      childSessionId: this.sessionId,
+    });
+
+    // Clear before await so a re-entry cannot double-report this job.
+    this.pendingReportBack = undefined;
+    try {
+      await this.bridge.wakeManager({
+        originChatId: meta.originChatId,
+        originThreadId: meta.originThreadId,
+        prompt,
+      });
+      log.info(
+        `report-back job ${meta.jobId} → general (#${meta.originThreadId}) status=${status}`,
+      );
+    } catch (e) {
+      log.warn(`report-back failed for job ${meta.jobId}: ${(e as Error).message}`);
+      // Restore so a later turn might retry once if still attached.
+      this.pendingReportBack = meta;
+    }
+  }
+
   /**
    * Final Done after a self-recheck: head + split file lists (first turn vs recheck).
    */
@@ -1693,12 +2693,16 @@ export class SessionRuntime {
   }
 
   /** Searchable Telegram hashtags so you can pull up every message of a session
-   *  or project by tapping the tag. */
+   *  or project (and this turn's prompt) by tapping the tag. */
   private hashtags(): string {
+    // General manager: no tags (user requested clean chat). Reply routing uses
+    // Telegram message-id → session map, not #sess_ footers.
+    if (this.managerMode) return "";
     return sessionHashtags({
       projectName: this.projectName,
       cwd: this.cwd,
       sessionId: this.sessionId,
+      promptId: this.turnPromptId,
     });
   }
 
@@ -1710,11 +2714,17 @@ export class SessionRuntime {
     const head = this.queue[0]!;
     const isMeta =
       !!head.skipSelfRecheck ||
-      isSelfRecheckPrompt(head.text);
+      isSelfRecheckPrompt(head.text) ||
+      isTelegramBridgeResultsPrompt(head.text);
     const batch = isMeta
       ? this.queue.shift()!
       : mergeInputs(this.queue.splice(0, this.queue.length));
-    if (this.foreground) await this.notify("\u25B6\uFE0F Processing queued message\u2026");
+    // Real user follow-ups only — never spam chat for bridge/recheck meta turns.
+    if (this.foreground && !isMeta) {
+      await this.notify("\u25B6\uFE0F Processing queued message\u2026", {
+        replyTo: batch.replyTo,
+      });
+    }
     void this.runTurn(batch);
   }
 
@@ -1761,7 +2771,10 @@ export class SessionRuntime {
       }
     } else if (kind === "agent_thought_chunk") {
       const text = contentText(update.content);
-      if (text?.trim()) this.setLiveStep(stepFromThought(text));
+      if (text?.trim()) {
+        this.appendCardThinking(text);
+        this.setLiveStep(stepFromThought(text));
+      }
     } else if (kind === "plan") {
       // Always track plan entries (background too) so switch-to-live restores the board.
       const entries = parsePlanUpdate(update);
@@ -1836,7 +2849,7 @@ export class SessionRuntime {
 
   private persist(): void {
     if (!this.foreground) return; // only the foreground session is the chat's restored default
-    this.settings.update(this.chatId, {
+    this.settings.updateKey(this.settingsKey, {
       projectPath: this.cwd,
       projectName: this.projectName,
       sessionId: this.sessionId,
@@ -1859,20 +2872,65 @@ export class SessionRuntime {
     }
   }
 
+  /**
+   * Send a chat message. Returns Telegram message_id on success.
+   * On failure, retries once truncated (~3500) without reply_markup so a long
+   * Done / markup error cannot silently drop the completion ping.
+   */
   private async notify(
     text: string,
     opts?: { loud?: boolean; replyTo?: number; replyMarkup?: InlineKeyboard },
+  ): Promise<number | undefined> {
+    const send = async (body: string, withMarkup: boolean): Promise<number | undefined> => {
+      try {
+        const extra: Record<string, unknown> = {
+          ...(opts?.loud ? { disable_notification: false } : {}),
+          // Never pass message_thread_id=1 (General) — Telegram rejects it.
+          ...outboundThreadExtra(this.messageThreadId),
+        };
+        if (opts?.replyTo !== undefined) {
+          extra.reply_parameters = { message_id: opts.replyTo, allow_sending_without_reply: true };
+        }
+        if (withMarkup && opts?.replyMarkup) extra.reply_markup = opts.replyMarkup;
+        const msg = await this.api.sendMessage(this.chatId, body, extra);
+        if (this.sessionId) this.onTelegramMessageBound?.(msg.message_id, this.sessionId);
+        return msg.message_id;
+      } catch (e) {
+        log.debug("notify failed:", (e as Error).message);
+        return undefined;
+      }
+    };
+    const id = await send(text, true);
+    if (id !== undefined) return id;
+    const short = text.length > 3500 ? text.slice(0, 3499) + "\u2026" : text;
+    return send(short, false);
+  }
+
+  /**
+   * After Done was already sent, attach suggestion text + buttons by editing
+   * that message (or sending a follow-up if edit fails / no message id).
+   */
+  private async enhanceDoneMessage(
+    messageId: number | undefined,
+    text: string,
+    markup: InlineKeyboard | undefined,
   ): Promise<void> {
-    try {
-      const extra: Record<string, unknown> = opts?.loud ? { disable_notification: false } : {};
-      if (opts?.replyTo !== undefined) {
-        extra.reply_parameters = { message_id: opts.replyTo, allow_sending_without_reply: true };
+    if (messageId !== undefined) {
+      try {
+        // editMessageText does not need message_thread_id; keep markup only.
+        const extra: Record<string, unknown> = {};
+        if (markup) extra.reply_markup = markup;
+        await this.api.editMessageText(this.chatId, messageId, text, extra);
+        return;
+      } catch (e) {
+        log.debug("enhanceDoneMessage edit failed:", (e as Error).message);
       }
-      if (opts?.replyMarkup) extra.reply_markup = opts.replyMarkup;
-      await this.api.sendMessage(this.chatId, text, extra);
-    } catch (e) {
-      log.debug("notify failed:", (e as Error).message);
     }
+    await this.notify(text, {
+      loud: false,
+      replyTo: this.turnReplyTo,
+      replyMarkup: markup,
+    });
   }
 
   private async onWatchEntries(entries: HistoryEntry[]): Promise<void> {
@@ -1885,8 +2943,47 @@ export class SessionRuntime {
       })
       .filter(Boolean)
       .join("\n\n");
-    if (body.trim()) await sendMarkdownDoc(this.api, this.chatId, `${body}\n\n${this.tags}`);
+    if (body.trim()) {
+      await sendMarkdownDoc(this.api, this.chatId, `${body}\n\n${this.tags}`, {
+        messageThreadId: this.messageThreadId,
+      });
+    }
+  }
+}
+
+/** Visible manager reply body (no progress markers / telegram action fences). */
+function cleanManagerVisibleText(raw: string): string {
+  if (!raw?.trim()) return "";
+  const withoutTg = stripTelegramActionFences(raw);
+  return extractProgress(withoutTg).cleaned.trim();
+}
+
+/**
+ * One short user-facing fallback when General forgot `notify`.
+ * Drops empty, table-spam, and pure status narration.
+ */
+export function pickManagerFallbackText(cleaned: string): string | undefined {
+  let t = cleaned.replace(/\r\n/g, "\n").trim();
+  if (!t) return undefined;
+  // Drop markdown tables and multi-line job dumps.
+  if (/^\s*\|.+\|/m.test(t) && (t.match(/\|/g) || []).length >= 6) return undefined;
+  // Collapse whitespace.
+  t = t.replace(/\n{3,}/g, "\n\n").trim();
+  // Prefer first 1–2 short paragraphs.
+  const paras = t.split(/\n\n+/).map((p) => p.trim()).filter(Boolean);
+  let out = paras.slice(0, 2).join("\n\n");
+  if (out.length > 600) out = out.slice(0, 597) + "\u2026";
+  // Ignore pure meta / empty placeholders.
+  if (/^(thinking|starting|ok|done|\.+|\u2026)+$/i.test(out.trim())) return undefined;
+  if (out.length < 2) return undefined;
+  // Skip "Dispatching… / Sending to…" spam patterns if that is all we got.
+  if (
+    /^(dispatching|sending to|queued|cancelling|already running)\b/i.test(out) &&
+    out.length < 280
+  ) {
+    return undefined;
   }
+  return out;
 }
 
 /** Format an elapsed duration compactly (e.g. "8s", "2m 13s", "1h 4m"). */