switchroom 0.13.22 → 0.13.24

package/telegram-plugin/gateway/gateway.ts

@@ -251,6 +251,7 @@ import {
   tryHostdDispatch,
   hostdRequestId,
   hostdWillBeUsed,
+  isHostdEnabled,
   pollHostdStatus,
   hostdGetStatusOnce,
   warnLegacySpawnIfHostdDisabled,
@@ -3303,12 +3304,19 @@ silencePoke.startTimer({
 // `SWITCHROOM_DISABLE_PENDING_PROGRESS=1`.
 pendingProgress.startTimer({
   editMessage: async (ctx) => {
+    // #1698: preserve the anchor's original parse_mode. Without this
+    // the edit goes out as plain text, and any <b>/<code>/<a> tag in
+    // anchorOriginalText (the model authored HTML via the reply tool,
+    // which defaults to format='html') re-renders as literal text the
+    // moment the first "still working (Nm)" tick fires.
+    const editOpts = ctx.parseMode != null ? { parse_mode: ctx.parseMode } : undefined
     await swallowingApiCall(
       () =>
         lockedBot.api.editMessageText(
           ctx.chatId,
           ctx.messageId,
           ctx.newText,
+          editOpts,
         ),
       {
         chat_id: ctx.chatId,
@@ -4567,6 +4575,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
           pendingProgress.noteOutbound(statusKey(chat_id, threadId), {
             messageId: decision.messageId,
             text: decision.mergedText,
+            parseMode,
           })
           if (HISTORY_ENABLED) {
             try {
@@ -4759,6 +4768,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
       pendingProgress.noteOutbound(statusKey(chat_id, threadId), {
         messageId: anchorMsgId,
         text: chunks[chunks.length - 1],
+        parseMode,
       })
     }
   }
@@ -5138,9 +5148,21 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
     // that follows. Capture it so if this turn ends with a pending
     // async dispatch, the framework edits THIS message in place at
     // intervals.
+    //
+    // #1698 — capture the parse_mode the stream-reply-handler used so
+    // the cross-turn edit tick reuses it. Mirrors the format→parseMode
+    // logic at stream-reply-handler.ts:355-368. Without this, the first
+    // "still working (Nm)" tick edits HTML content as plain text and
+    // <b>/<code>/<a> render as literal tags.
+    const streamFormat = (args.format as string | undefined) ?? (access.parseMode ?? 'html')
+    const streamParseMode: 'HTML' | 'MarkdownV2' | undefined =
+      streamFormat === 'html' ? 'HTML'
+      : streamFormat === 'markdownv2' ? 'MarkdownV2'
+      : undefined
     pendingProgress.noteOutbound(statusKey(sChatId, sThreadId), {
       messageId: result.messageId,
       text: args.text as string,
+      parseMode: streamParseMode,
     })
   }
   // #1664 — mark the turn's final answer as delivered. For stream_reply a
@@ -10081,29 +10103,64 @@ bot.command('update', async ctx => {
       return
     }
   }
-  // Docker reachability guard (#926). The gateway runs INSIDE the agent
-  // container, which has the switchroom CLI baked in but no docker
-  // binary and no /var/run/docker.sock mount. So `switchroom update`'s
-  // pull-images and recreate-containers steps would fail with
-  // "docker: command not found".
+  // Pre-dispatch availability gate (#926 / #1469 / #1470). The gateway
+  // runs INSIDE the agent container, which has the switchroom CLI baked
+  // in but no docker binary and no /var/run/docker.sock mount. So
+  // `switchroom update`'s pull-images and recreate-containers steps
+  // would fail with "docker: command not found" — UNLESS hostd is in
+  // play (#1175 Phase 2 RFC C), in which case hostd runs on the host
+  // with the docker socket mounted and the in-container docker
+  // dependency goes away.
   //
-  // BYPASSED when hostd is on (#1175 Phase 2 RFC C): hostd runs on the
-  // host with the docker socket mounted, so the in-container docker
-  // dependency goes away. Skip the guard so /update apply can dispatch
-  // through hostd. When hostd is NOT in play, keep the guard so the
-  // operator gets a clean explanation instead of an opaque exit-127.
-  if (!hostdWillBeUsed(getMyAgentName()) && !isDockerReachable()) {
-    await switchroomReply(
-      ctx,
-      `❌ <b>/update apply</b> needs docker access from inside the agent ` +
-      `container, but it's not available (no <code>docker</code> binary on ` +
-      `PATH, no <code>/var/run/docker.sock</code> mount).\n\n` +
-      `On docker installs, either run <code>switchroom update</code> from ` +
-      `the host shell, or enable <code>host_control.enabled</code> in ` +
-      `<code>switchroom.yaml</code> and <code>switchroom hostd install</code> ` +
-      `so this verb dispatches through the host-side daemon.`,
-      { html: true },
-    )
+  // Three states to distinguish here, so the operator gets a message
+  // pointing at the right remediation:
+  //
+  //   - hostd ready (socket bound): proceed — no gate.
+  //   - hostd configured-on but socket missing (#1470): tell the
+  //     operator to run `switchroom hostd install`. Don't conflate
+  //     with "enable host_control" — it's already on.
+  //   - hostd off AND no in-container docker (#1469): fall through
+  //     to spawn-detached would fail late; explain the choice between
+  //     host CLI and enabling hostd.
+  const myAgentName = getMyAgentName()
+  const hostdReady = hostdWillBeUsed(myAgentName)
+  if (!hostdReady && !isDockerReachable()) {
+    if (isHostdEnabled()) {
+      // hostd is configured on, but the per-agent socket isn't bound —
+      // hostd hasn't been installed yet, or its daemon is down.
+      await switchroomReply(
+        ctx,
+        `❌ <b>/update apply</b> needs <code>hostd</code>, but its socket ` +
+        `for agent <code>${escapeHtmlForTg(myAgentName)}</code> isn't ` +
+        `bound and in-container docker access isn't available either.\n\n` +
+        `<code>host_control.enabled</code> is on in <code>switchroom.yaml</code>, ` +
+        `so hostd is the expected dispatch path — but no socket at ` +
+        `<code>/run/switchroom/hostd/${escapeHtmlForTg(myAgentName)}/sock</code>. ` +
+        `On a fresh docker install this usually means hostd hasn't been ` +
+        `installed yet.\n\n` +
+        `Run <code>switchroom hostd install</code> on the host to install + ` +
+        `start the daemon, then retry. Send <code>/upgradestatus</code> to ` +
+        `re-check the daemon state from here.`,
+        { html: true },
+      )
+    } else {
+      // host_control explicitly off + no in-container docker: nothing
+      // can drive the apply from inside the container. Operator has to
+      // pick one of: host CLI, or enable hostd.
+      await switchroomReply(
+        ctx,
+        `❌ <b>/update apply</b> needs docker access from inside the agent ` +
+        `container, but it's not available (no <code>docker</code> binary on ` +
+        `PATH, no <code>/var/run/docker.sock</code> mount) and ` +
+        `<code>host_control.enabled</code> is off.\n\n` +
+        `Either run <code>switchroom update</code> from the host shell, or ` +
+        `set <code>host_control.enabled: true</code> in ` +
+        `<code>switchroom.yaml</code> and run ` +
+        `<code>switchroom hostd install</code> on the host so this verb ` +
+        `can dispatch through the host-side daemon.`,
+        { html: true },
+      )
+    }
     return
   }
   // Debounce vs concurrent self-restart commands (/restart, /new, /reset

package/telegram-plugin/pending-work-progress.ts

@@ -45,10 +45,14 @@
  * interval is short (5s) but edits are spaced at EDIT_INTERVAL_MS so
  * the Telegram bot.api editMessageText rate stays well under limits.
  *
- * Edits are plain text (no parseMode). The suffix is appended to the
- * model's authored text; on subsequent edits the prior suffix is
- * stripped before re-appending so the message never accumulates
- * duplicate suffixes.
+ * Edits preserve the anchor's original `parse_mode` (issue #1698). The
+ * anchor was sent through the reply tool, which defaults to HTML; an
+ * earlier version of this module dropped parse_mode on edit, which made
+ * the next "still working (Nm)" tick re-render `<b>` / `<code>` tags as
+ * literal text. The suffix itself is plain text (no `<`/`>`/`&`) so it
+ * is safe under any parse_mode. On subsequent edits the prior suffix is
+ * stripped before re-appending so the message never accumulates duplicate
+ * suffixes.
  *
  * Kill switch: `SWITCHROOM_DISABLE_PENDING_PROGRESS=1` disables the
  * whole subsystem. The conversational-pacing prompt is unaffected.
@@ -76,6 +80,10 @@ export interface PendingProgressEditCtx {
   threadId: number | null
   messageId: number
   newText: string
+  /** Telegram parse_mode the original anchor was sent with (#1698).
+   *  The edit must use the same mode or pre-rendered HTML / MarkdownV2
+   *  tags in `anchorOriginalText` re-render as literal text. */
+  parseMode: 'HTML' | 'MarkdownV2' | undefined
 }
 
 /**
@@ -116,6 +124,11 @@ interface State {
   /** The captured anchor text — what the model wrote, *minus* any
    *  prior pending-progress suffix. Used as the base for every edit. */
   anchorOriginalText: string
+  /** parse_mode the anchor was originally sent with. Edits must
+   *  reuse this or the rendered HTML / MarkdownV2 tags in
+   *  anchorOriginalText render as literal text on the next tick
+   *  (issue #1698). */
+  anchorParseMode: 'HTML' | 'MarkdownV2' | undefined
   /** Wall-clock ms when the cross-turn ambient state was *activated*
    *  (at turn_end with pending+anchor). null before activation. */
   activatedAt: number | null
@@ -144,6 +157,7 @@ function ensure(key: string): State {
       pending: false,
       anchorMessageId: null,
       anchorOriginalText: '',
+      anchorParseMode: undefined,
       activatedAt: null,
       lastEditAt: null,
     }
@@ -181,6 +195,7 @@ export function startTurn(key: string): void {
   s.pending = false
   s.anchorMessageId = null
   s.anchorOriginalText = ''
+  s.anchorParseMode = undefined
 }
 
 /**
@@ -202,12 +217,24 @@ export function noteAsyncDispatch(key: string): void {
  */
 export function noteOutbound(
   key: string,
-  opts: { messageId: number; text: string },
+  opts: {
+    messageId: number
+    text: string
+    /** parse_mode the anchor was sent with. Captured so the
+     *  cross-turn edit tick can reuse it (#1698). Undefined or
+     *  omitted means the original send had no parse_mode (plain
+     *  text). Production callers MUST pass this — every reply path
+     *  knows its own parse_mode. Defaulted to undefined only so test
+     *  fixtures don't have to thread it through where they're
+     *  asserting other behaviour. */
+    parseMode?: 'HTML' | 'MarkdownV2' | undefined
+  },
 ): void {
   if (!enabled()) return
   const s = ensure(key)
   s.anchorMessageId = opts.messageId
   s.anchorOriginalText = opts.text.replace(SUFFIX_RE, '')
+  s.anchorParseMode = opts.parseMode
 }
 
 /**
@@ -331,6 +358,7 @@ function tick(now: number): void {
       threadId,
       messageId: s.anchorMessageId,
       newText,
+      parseMode: s.anchorParseMode,
     }
     // Fire-and-forget so a slow edit doesn't block the tick loop.
     // Errors are logged but never bubble (a 429 / "message not modified"

package/telegram-plugin/tests/answer-stream.test.ts

@@ -417,6 +417,116 @@ describe('answer-stream — stop() cancels pending throttled edits', () => {
   })
 })
 
+// ─── #1704 regression — clear the sendMessageDraft on every terminal path ──
+//
+// In DMs the answer-stream uses sendMessageDraft, which renders inside the
+// user's compose box. Telegram Desktop blocks the user from typing while
+// the bot's draft is live — so stop() / retract() / materialize() must
+// all clear the draft. Without these tests the bug class slips back in
+// the next time someone tweaks the lifecycle.
+
+describe('answer-stream — clears sendMessageDraft on terminal paths (#1704)', () => {
+  it('stop() clears the draft when draft transport was in use', async () => {
+    const sendMessage = makeSendMessage()
+    const editMessageText = makeEditMessageText()
+    const sendMessageDraft = makeSendMessageDraft()
+    const stream = createAnswerStream({
+      chatId: 'chat1',
+      isPrivateChat: true,
+      throttleMs: 250,
+      sendMessage,
+      editMessageText,
+      sendMessageDraft,
+    })
+
+    stream.update('mid-turn thought')
+    await flushMicrotasks()
+    expect(sendMessageDraft).toHaveBeenCalledTimes(1)
+
+    stream.stop()
+    // stop() is sync but the clear fires fire-and-forget — drain microtasks.
+    await flushMicrotasks()
+
+    // A second draft call must have landed with empty text, clearing the
+    // compose-box preview. The draft id matches the in-flight stream's.
+    const draftId = (sendMessageDraft.mock.calls[0] as unknown as [string, number, string, unknown])[1]
+    expect(sendMessageDraft).toHaveBeenCalledWith('chat1', draftId, '', undefined)
+  })
+
+  it('retract() clears the draft when draft transport was in use', async () => {
+    const sendMessage = makeSendMessage()
+    const editMessageText = makeEditMessageText()
+    const sendMessageDraft = makeSendMessageDraft()
+    const stream = createAnswerStream({
+      chatId: 'chat1',
+      isPrivateChat: true,
+      throttleMs: 250,
+      sendMessage,
+      editMessageText,
+      sendMessageDraft,
+    })
+
+    stream.update('mid-turn thought')
+    await flushMicrotasks()
+    expect(sendMessageDraft).toHaveBeenCalledTimes(1)
+
+    await stream.retract()
+
+    const draftId = (sendMessageDraft.mock.calls[0] as unknown as [string, number, string, unknown])[1]
+    expect(sendMessageDraft).toHaveBeenCalledWith('chat1', draftId, '', undefined)
+  })
+
+  it('stop() is a no-op on the draft API when message transport was in use', async () => {
+    const sendMessage = makeSendMessage()
+    const editMessageText = makeEditMessageText()
+    const sendMessageDraft = makeSendMessageDraft()
+    const stream = createAnswerStream({
+      chatId: 'chat1',
+      isPrivateChat: false, // forces message transport
+      minInitialChars: 0,
+      throttleMs: 250,
+      sendMessage,
+      editMessageText,
+      sendMessageDraft,
+    })
+
+    stream.update('mid-turn thought')
+    await flushMicrotasks()
+    expect(sendMessage).toHaveBeenCalledTimes(1)
+    expect(sendMessageDraft).not.toHaveBeenCalled()
+
+    stream.stop()
+    await flushMicrotasks()
+
+    // Never touched the draft API at all.
+    expect(sendMessageDraft).not.toHaveBeenCalled()
+  })
+
+  it('forwards message_thread_id to the draft-clear call', async () => {
+    const sendMessage = makeSendMessage()
+    const editMessageText = makeEditMessageText()
+    const sendMessageDraft = makeSendMessageDraft()
+    const stream = createAnswerStream({
+      chatId: 'chat1',
+      isPrivateChat: true,
+      threadId: 42,
+      throttleMs: 250,
+      sendMessage,
+      editMessageText,
+      sendMessageDraft,
+    })
+
+    stream.update('mid-turn thought')
+    await flushMicrotasks()
+
+    await stream.retract()
+
+    const lastCall = sendMessageDraft.mock.calls[sendMessageDraft.mock.calls.length - 1] as unknown as [string, number, string, { message_thread_id?: number } | undefined]
+    expect(lastCall[2]).toBe('')
+    expect(lastCall[3]).toEqual({ message_thread_id: 42 })
+  })
+})
+
 describe('answer-stream — empty / whitespace-only text is a no-op', () => {
   it('update("") does not trigger any transport call', async () => {
     const sendMessage = makeSendMessage()

package/telegram-plugin/tests/pending-work-progress.test.ts

@@ -318,6 +318,62 @@ describe('pending-work-progress', () => {
     expect(cap.edits).toHaveLength(0)
   })
 
+  // ─── #1698 regression — preserve parse_mode on the cross-turn edit ───
+  it("preserves the anchor's parse_mode on every edit (#1698)", async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    // Anchor was sent through the reply tool with format='html', so
+    // the captured text is already rendered Telegram HTML.
+    noteOutbound(KEY, {
+      messageId: 100,
+      text: '<b>Worker back.</b> Both blockers fixed.',
+      parseMode: 'HTML',
+    })
+    cap.now = 0
+    noteTurnEnd(KEY)
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits).toHaveLength(1)
+    expect(cap.edits[0].parseMode).toBe('HTML')
+    expect(cap.edits[0].newText).toBe(
+      '<b>Worker back.</b> Both blockers fixed.\n\n— still working (1m)',
+    )
+  })
+
+  it('passes undefined parseMode through when the anchor was plain text', async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    // format: 'text' path — anchor was sent without parse_mode.
+    noteOutbound(KEY, {
+      messageId: 100,
+      text: 'plain text reply',
+      parseMode: undefined,
+    })
+    noteTurnEnd(KEY)
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits[0].parseMode).toBeUndefined()
+  })
+
+  it('defaults parseMode to undefined when caller omits it (test ergonomics)', async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    // Callsite that hasn't been updated for the new field — must not
+    // typecheck-fail nor crash. The edit goes out parse_mode-less,
+    // matching the pre-#1698 behaviour for legacy callers.
+    noteOutbound(KEY, { messageId: 100, text: 'wd' })
+    noteTurnEnd(KEY)
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits[0].parseMode).toBeUndefined()
+  })
+
   it('multiple chats — independent state', async () => {
     const cap = setup()
     const KEY_A = 'A:_'

package/telegram-plugin/uat/scenarios/jtbd-interrupt-marker-dm.test.ts

@@ -31,7 +31,7 @@ const INTERRUPT = "! actually just reply with the single word 'hello'";
 // a JTBD-floor invariant and shouldn't gate every PR that touches
 // telegram-plugin/. Unskip once the underlying behaviour has been
 // audited end-to-end via `bun run test:uat`.
-describe.skip("uat: ! interrupt marker", () => {
+describe("uat: ! interrupt marker", () => {
   it(
     "user fires !-interrupt mid-turn → agent picks up new task, drops old",
     async () => {