switchroom 0.16.38 → 0.16.47

package/telegram-plugin/gateway/model-command.ts

@@ -308,6 +308,32 @@ export const MODEL_CALLBACK_REFRESH = 'mdl:r'
 export const MODEL_CALLBACK_SR = 'mdl:sr:'
 /** Callback for section-header rows — shows an informational toast, no action. */
 export const MODEL_CALLBACK_HEADER = 'mdl:h'
+/**
+ * Callback prefix for Claude aliases that the CLI picker doesn't render but
+ * the CLI resolves natively (e.g. `fable`). Carries the alias verbatim; its
+ * handler INJECTS `/model <alias>` — the same mechanism MODEL_CALLBACK_SR
+ * uses — because the cursor-nav select path can only pick rows claude's own
+ * picker actually renders.
+ */
+export const MODEL_CALLBACK_ALIAS = 'mdl:alias:'
+/** Callback: open the nested "External models" keyboard page. */
+export const MODEL_CALLBACK_PAGE_EXTERNAL = 'mdl:page:ext'
+/** Callback: return from the External page to the main keyboard page. */
+export const MODEL_CALLBACK_PAGE_MAIN = 'mdl:page:main'
+
+/** Which keyboard page the model menu is currently rendering. */
+export type ModelMenuPage = 'main' | 'external'
+
+/**
+ * Static Claude aliases appended to the scraped Claude group. The claude CLI's
+ * own `/model` picker (deps.discover) does NOT list `fable`, but the CLI
+ * resolves the alias natively, so we render it as an extra button that selects
+ * by injecting `/model fable` (MODEL_CALLBACK_ALIAS). Extend this list to
+ * surface further CLI-resolvable aliases the picker omits.
+ */
+export const EXTRA_CLAUDE_ALIASES: ReadonlyArray<{ alias: string; label: string }> = [
+  { alias: 'fable', label: 'Fable' },
+]
 
 /**
  * Friendly display names for sr-* synthetic model names. An sr-* model in
@@ -394,14 +420,42 @@ function headerRow(label: string): ModelMenuKeyboardButton[] {
   return [{ text: label, callback_data: MODEL_CALLBACK_HEADER }]
 }
 
-function menuKeyboard(
+/**
+ * The external (🌐 non-Anthropic) model list, sourced from the static
+ * SR_MODEL_ALIASES values UNION-ed with any live discoverSrModels() results,
+ * deduped and sorted.
+ *
+ * Why the static union: discoverSrModels() reads LiteLLM's /model/info, which
+ * requires ANTHROPIC_CUSTOM_HEADERS (a litellm key) to be set on the gateway
+ * process. switchroom never sets that env on the gateway, so in production
+ * discoverSrModels() always returns [] and the external group was silently
+ * empty. The six SR_MODEL_ALIASES targets are the sr-* names the litellm
+ * config actually exposes, so seeding from them makes the group reliable
+ * without the missing env — while still merging any live results on hosts
+ * that do configure discovery.
+ *
+ * Subscription-honest: ONLY the curated sr-* aliases surface as buttons. Raw
+ * gpt-4o / openrouter/* dupes / voyage-* embeddings never do.
+ */
+export function externalModelNames(discovered: string[]): string[] {
+  const set = new Set<string>(Object.values(SR_MODEL_ALIASES))
+  for (const n of discovered) {
+    if (isSrModel(n)) set.add(n)
+  }
+  return [...set].sort()
+}
+
+/**
+ * Main keyboard page: scraped Claude buttons + static Fable alias, then (only
+ * when the external list is non-empty) a single "🌐 External models ▸" row that
+ * opens the nested page, then Refresh.
+ */
+function mainPageKeyboard(
   claudeOptions: ModelPickerOption[],
-  srOptions: ModelPickerOption[],
+  hasExternal: boolean,
 ): ModelMenuKeyboardButton[][] {
-  const hasBothGroups = claudeOptions.length > 0 && srOptions.length > 0
   const rows: ModelMenuKeyboardButton[][] = []
 
-  if (hasBothGroups) rows.push(headerRow('── Claude (Max / Pro subscription) ──'))
   for (const o of claudeOptions) {
     rows.push([{
       text: o.current ? `✅ ${o.label}` : o.label,
@@ -409,23 +463,44 @@ function menuKeyboard(
     }])
   }
 
-  // sr-* models are non-Anthropic (routed via LiteLLM → OpenRouter).
-  // Selection uses text-inject rather than cursor-nav — more reliable
-  // when the picker has many models (GATEWAY_MODEL_DISCOVERY=1).
-  if (srOptions.length > 0) {
-    rows.push(headerRow('── OpenRouter / external ──'))
-    for (const o of srOptions) {
-      rows.push([{
-        text: `🌐 ${srFriendlyLabel(o.label)}`,
-        callback_data: `${MODEL_CALLBACK_SR}${o.label}`,
-      }])
-    }
+  // Static Claude aliases the CLI picker omits (e.g. Fable). Deduped: if the
+  // scraped Claude options already include a matching row, don't render the
+  // static one too.
+  for (const { alias, label } of EXTRA_CLAUDE_ALIASES) {
+    const already = claudeOptions.some(
+      (o) => o.label.toLowerCase() === label.toLowerCase() ||
+        o.label.toLowerCase() === alias.toLowerCase(),
+    )
+    if (already) continue
+    rows.push([{ text: label, callback_data: `${MODEL_CALLBACK_ALIAS}${alias}` }])
+  }
+
+  if (hasExternal) {
+    rows.push([{ text: '🌐 External models ▸', callback_data: MODEL_CALLBACK_PAGE_EXTERNAL }])
   }
 
   rows.push([{ text: '🔄 Refresh', callback_data: MODEL_CALLBACK_REFRESH }])
   return rows
 }
 
+/**
+ * External keyboard page: a labelled header, one 🌐 button per external model
+ * (reusing the existing MODEL_CALLBACK_SR select handler), then Back + Refresh.
+ */
+function externalPageKeyboard(externalNames: string[]): ModelMenuKeyboardButton[][] {
+  const rows: ModelMenuKeyboardButton[][] = []
+  rows.push(headerRow('── External (billed separately) ──'))
+  for (const name of externalNames) {
+    rows.push([{
+      text: `🌐 ${srFriendlyLabel(name)}`,
+      callback_data: `${MODEL_CALLBACK_SR}${name}`,
+    }])
+  }
+  rows.push([{ text: '◂ Back', callback_data: MODEL_CALLBACK_PAGE_MAIN }])
+  rows.push([{ text: '🔄 Refresh', callback_data: MODEL_CALLBACK_REFRESH }])
+  return rows
+}
+
 /**
  * Build the `/model` dashboard: live model + quota brief + tap menu.
  * Returns a keyboard-less fallback (v1-shaped static text) when the
@@ -433,6 +508,7 @@ function menuKeyboard(
  */
 export async function buildModelMenu(
   deps: ModelMenuDeps & ModelCommandDeps,
+  page: ModelMenuPage = 'main',
 ): Promise<ModelMenuReply> {
   if (deps.isBusy()) return busyReply(deps)
 
@@ -460,7 +536,26 @@ export async function buildModelMenu(
   // sr-* models come from LiteLLM (/model/info via discoverSrModels), not the
   // claude picker — the CLI only knows Anthropic models.
   const { claude: claudeOptions } = classifyDiscoveredOptions(discovered.options)
-  const srOptions: ModelPickerOption[] = srNames.map((name, i) => ({ index: i, label: name, detail: '', current: false }))
+  const externalNames = externalModelNames(srNames)
+
+  // External page: a focused list of the 🌐 (billed-separately) models with a
+  // Back button. It never switches the model itself — the page callbacks just
+  // re-render with the other page's keyboard.
+  if (page === 'external') {
+    const lines: string[] = [`**Model — ${deps.escapeHtml(deps.getAgentName())}** · 🌐 External`]
+    lines.push(
+      '',
+      'These models are **billed separately** via OpenRouter — they do NOT use your Claude Max/Pro subscription. Tap one to switch the **live session**:',
+      PERSIST_NOTE,
+    )
+    return { text: lines.join('\n'), html: true, keyboard: externalPageKeyboard(externalNames) }
+  }
+
+  // claude's ✔ marks the DEFAULT FOR NEW SESSIONS, which is a different axis
+  // from the model the agent is running right now (set via --model at launch
+  // or a prior session switch). Labelling the ✔ row "Now:" was misleading —
+  // it could read "Opus 4.8" while the live session is on Fable. Call it what
+  // it is, and tell the operator a switch applies to the live session.
   const current = claudeOptions.find((o) => o.current)
   const lines: string[] = [`**Model — ${deps.escapeHtml(deps.getAgentName())}**`]
   if (discovered.dismissFailed) {
@@ -474,12 +569,16 @@ export async function buildModelMenu(
   }
   if (quota) lines.push(`Quota: ${deps.escapeHtml(quota)}`)
   lines.push('', 'Tap a model to switch the **live session**:')
-  if (srOptions.length > 0) {
-    lines.push('Claude models use your Max/Pro subscription. 🌐 models are billed separately via OpenRouter.')
+  if (externalNames.length > 0) {
+    lines.push('Claude models use your Max/Pro subscription. Tap 🌐 External models for models billed separately via OpenRouter.')
   }
   lines.push(PERSIST_NOTE)
 
-  return { text: lines.join('\n'), html: true, keyboard: menuKeyboard(claudeOptions, srOptions) }
+  return {
+    text: lines.join('\n'),
+    html: true,
+    keyboard: mainPageKeyboard(claudeOptions, externalNames.length > 0),
+  }
 }
 
 export interface ModelCallbackOutcome {
@@ -519,6 +618,61 @@ export async function handleModelMenuCallback(
     return { answer: 'Refreshed', reply: await buildModelMenu(deps) }
   }
 
+  // Page navigation — these DO NOT switch the model. They just re-render the
+  // menu with the other page's keyboard + body text (mirrors the REFRESH shape).
+  if (data === MODEL_CALLBACK_PAGE_EXTERNAL) {
+    return { answer: 'External models', reply: await buildModelMenu(deps, 'external') }
+  }
+  if (data === MODEL_CALLBACK_PAGE_MAIN) {
+    return { answer: 'Back', reply: await buildModelMenu(deps, 'main') }
+  }
+
+  // Claude-alias tap (e.g. Fable): the CLI resolves the alias but its picker
+  // doesn't render it, so select by injecting `/model <alias>` — same path as
+  // the sr-* handler below, no cursor-nav.
+  if (data.startsWith(MODEL_CALLBACK_ALIAS)) {
+    const alias = data.slice(MODEL_CALLBACK_ALIAS.length)
+    if (!isValidModelArg(alias)) {
+      return { answer: 'Invalid model name', reply: await buildModelMenu(deps) }
+    }
+    if (deps.isBusy()) {
+      return {
+        answer: '⏳ Agent is mid-turn — tap again when it’s idle',
+        reply: busyReply(deps),
+        toastOnly: true,
+      }
+    }
+    let aliasResult: InjectResult
+    try {
+      aliasResult = await deps.inject(deps.getAgentName(), `/model ${alias}`)
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      return {
+        answer: 'Switch failed',
+        reply: await menuWithBanner(deps, `❌ Switch to **${deps.escapeHtml(alias)}** failed: ${deps.escapeHtml(msg)}`),
+      }
+    }
+    if (aliasResult.outcome === 'ok') {
+      const confirmation =
+        aliasResult.output
+          .split('\n')
+          .map((l) => l.trim())
+          .find((l) => /set model|switched/i.test(l)) ?? `Switched to ${alias} (session)`
+      return {
+        answer: confirmation,
+        reply: await menuWithBannerStatic(deps, `✅ ${deps.escapeHtml(confirmation)}`),
+        selectedModel: sessionModelFromConfirmation(confirmation) ?? alias,
+      }
+    }
+    return {
+      answer: 'Switch failed',
+      reply: await menuWithBanner(
+        deps,
+        `❌ Switch to **${deps.escapeHtml(alias)}** failed — agent may be mid-turn`,
+      ),
+    }
+  }
+
   if (data === MODEL_CALLBACK_HEADER) {
     // Section-header row — the gateway handles this with a direct answerCallbackQuery
     // before calling this function, so this branch is dead in practice. Guard

package/telegram-plugin/hooks/tool-label-pretool.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Type declarations for the PreToolUse hook module so TypeScript surfaces
+ * (tool-activity-summary.ts's `describeToolUse`) can delegate to
+ * `computeLabel` — the ONE status-vocabulary composer — without tsc
+ * resolution errors. The runtime module is plain ESM (hooks are executed
+ * directly by Claude Code, so they cannot be TS); main() is guarded behind
+ * an is-main check, making the import side-effect-free.
+ */
+export function computeLabel(
+  toolName: string,
+  input: Record<string, unknown> | undefined | null,
+): string | null

package/telegram-plugin/hooks/tool-label-pretool.mjs

@@ -76,6 +76,16 @@ function safeBasename(p) {
   }
 }
 
+/** Hostname only, `www.` stripped — the WebFetch label form ("Reading example.com"). */
+function urlHost(u) {
+  if (!u || typeof u !== 'string') return ''
+  try {
+    return new URL(u).hostname.replace(/^www\./, '')
+  } catch {
+    return u
+  }
+}
+
 function urlHostPath(u) {
   if (!u || typeof u !== 'string') return ''
   try {
@@ -115,26 +125,53 @@ export function computeLabel(toolName, input) {
   }
 
   // Built-in rule table.
+  //
+  // THE single status vocabulary. This function is the ONE composer for the
+  // per-tool activity wording on EVERY surface: the real-time sidecar drives
+  // the live feed from here, and the gateway/watcher flush paths delegate via
+  // `describeToolUse` (tool-activity-summary.ts). Do NOT fork a second
+  // wording table — status-vocabulary-unification.test.ts pins the
+  // delegation, so drift fails CI.
   switch (toolName) {
-    case 'Read':
-      return `Reading ${clip(safeBasename(i.file_path))}`.trim()
+    case 'Read': {
+      const f = clip(safeBasename(i.file_path))
+      return f ? `Reading ${f}` : 'Reading a file'
+    }
     case 'Edit':
-      return `Editing ${clip(safeBasename(i.file_path))}`.trim()
-    case 'Write':
-      return `Writing ${clip(safeBasename(i.file_path))}`.trim()
+    case 'MultiEdit': {
+      const f = clip(safeBasename(i.file_path))
+      return f ? `Editing ${f}` : 'Editing a file'
+    }
+    case 'Write': {
+      const f = clip(safeBasename(i.file_path))
+      return f ? `Writing ${f}` : 'Writing a file'
+    }
     case 'Grep': {
-      const path = i.path ? clip(asText(i.path), 40) : '.'
       const pat = clip(asText(i.pattern), 40)
-      return `Searching ${path} for ${pat}`
+      if (!pat) return 'Searching files'
+      const path = i.path ? clip(asText(i.path), 40) : ''
+      return path ? `Searching ${path} for ${pat}` : `Searching for ${pat}`
+    }
+    case 'Glob': {
+      const pat = clip(asText(i.pattern), 60)
+      return pat ? `Finding files matching ${pat}` : 'Searching files'
+    }
+    case 'WebFetch': {
+      const h = clip(urlHost(i.url), 60)
+      return h ? `Reading ${h}` : 'Reading a web page'
     }
-    case 'Glob':
-      return `Finding files matching ${clip(asText(i.pattern), 60)}`
-    case 'WebFetch':
-      return `Fetching ${clip(urlHostPath(i.url), 60)}`
-    case 'WebSearch':
-      return `Searching the web for ${clip(asText(i.query), 60)}`
-    case 'NotebookEdit':
-      return `Editing notebook ${clip(safeBasename(i.notebook_path))}`
+    case 'WebSearch': {
+      const q = clip(asText(i.query), 60)
+      return q ? `Searching the web for ${q}` : 'Searching the web'
+    }
+    case 'NotebookEdit': {
+      const f = clip(safeBasename(i.notebook_path))
+      return f ? `Editing ${f}` : 'Editing a notebook'
+    }
+    case 'TaskCreate':
+    case 'TaskUpdate':
+    case 'TaskList':
+      return 'Updating the plan'
     case 'BashOutput':
       return 'Reading background output'
     case 'KillBash':
@@ -183,7 +220,8 @@ export function computeLabel(toolName, input) {
       case 'mcp__hindsight__reflect':
         return 'Searching memory'
       case 'mcp__hindsight__retain':
-        return 'Saving memory'
+      case 'mcp__hindsight__update_memory':
+        return 'Saving to memory'
       // Explicit suppressions — return null so we don't emit a sidecar line.
       case 'mcp__hindsight__sync_retain':
         return null

package/telegram-plugin/package.json

@@ -27,7 +27,7 @@
   "dependencies": {
     "@grammyjs/runner": "^2.0.3",
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@mtcute/node": "^0.27.0",
+    "@mtcute/node": "^0.30.1",
     "@secretlint/core": "^12.2.0",
     "@secretlint/secretlint-rule-preset-recommend": "^12.2.0",
     "@secretlint/types": "^12.2.0",

package/telegram-plugin/session-tail.ts

@@ -239,6 +239,34 @@ export function projectAssistantTextBlocks(
   return out
 }
 
+/**
+ * True iff this assistant message's `content` carries the "answer surface"
+ * — a `text` block, or a real (non-`Agent`/`Task`) `tool_use`. Used to gate
+ * the `stop_reason === 'end_turn'` sub-agent terminal so it never fires on a
+ * split-off thinking-only line (see the terminal comment in
+ * projectSubagentLine). A thinking-only or empty line returns false; the real
+ * terminal rides the following content line, which also carries `end_turn`.
+ */
+export function assistantLineCarriesAnswerSurface(
+  content: Array<Record<string, unknown>> | undefined,
+): boolean {
+  if (!Array.isArray(content)) return false
+  for (const c of content) {
+    const ct = (c?.type as string | undefined) ?? ''
+    if (ct === 'text') {
+      // A non-empty text block is the answer surface.
+      const t = c.text as string | undefined
+      if (typeof t === 'string' && t.trim().length > 0) return true
+    } else if (ct === 'tool_use') {
+      // A real tool_use is content too. (An end_turn message rarely contains a
+      // tool_use, but if it does it is content-final, not a bare thinking split.)
+      const name = (c.name as string | undefined) ?? ''
+      if (name !== 'Agent' && name !== 'Task') return true
+    }
+  }
+  return false
+}
+
 /**
  * Project a single transcript line into a SessionEvent (or null if it's
  * uninteresting noise). Caller is responsible for the JSON parse — if a
@@ -486,8 +514,26 @@ export function projectSubagentLine(
     // events so the final text/preamble still renders; the watcher's turn_end
     // handler is guarded on `state === 'running'`, so a later real
     // turn_duration line is a no-op.
+    //
+    // UPSTREAM-SHAPE HARDENING (Claude Code ≥2.1.x): one logical assistant
+    // message is now persisted as MULTIPLE JSONL lines sharing one
+    // `message.id`, one content-block per line, and the terminal `stop_reason`
+    // (`end_turn`) is stamped on EVERY split line — including the leading
+    // `[thinking]` line that precedes the `[text: final answer]` line. Firing
+    // the terminal on the thinking-only line marks the sub-agent `done` and
+    // hands back stale/empty text BEFORE the real handback `[text]` line is
+    // projected (the watcher's onProgress is `state==='running'`-gated, so the
+    // late text is dropped). Guard: only treat `end_turn` as terminal on a line
+    // that actually carries the message's answer surface (a `text` block, or a
+    // non-`Agent`/`Task` tool_use). A thinking-only `end_turn` line is a split
+    // preamble; its terminal + handback ride the following content line, which
+    // still carries `end_turn` and fires correctly AFTER the text event. The
+    // old single-line `[thinking, text](end_turn)` shape has a `text` block, so
+    // it fires exactly as before — graceful degradation on both shapes. A
+    // genuine thinking-only end with no answer still terminates via the
+    // `turn_duration` / capped-reaper / watcher stall nets.
     const stopReason = message?.stop_reason as string | undefined
-    if (stopReason === 'end_turn') {
+    if (stopReason === 'end_turn' && assistantLineCarriesAnswerSurface(content)) {
       events.push({ kind: 'sub_agent_turn_end', agentId })
     }
     return events

package/telegram-plugin/stream-reply-handler.ts

@@ -158,6 +158,19 @@ export interface StreamReplyDeps {
    * the raw (repaired) text is sent unchanged.
    */
   normalizeParagraphBreaks?: (text: string) => string
+  /**
+   * Punctuation/bullet normalization (fleet-wide consistent formatting):
+   * em/en dashes → comma/hyphen, leading unicode bullets → `- `. Applied on
+   * code-masked text right after normalizeParagraphBreaks. Optional for
+   * backward compat; omitted → no normalization.
+   */
+  normalizePunctuation?: (text: string) => string
+  /**
+   * Over-bold tripwire: strips `**bold**` markers when a message is clearly
+   * over-bolded (>30% bold, or whole paragraphs/lists fully bolded). Applied
+   * after normalizePunctuation. Optional for backward compat.
+   */
+  stripExcessBold?: (text: string) => string
   /**
    * Insert a visible blank-line spacer into each prose `\n\n` gap so the rich
    * GFM renderer shows a real empty line between paragraphs (the rich engine
@@ -316,9 +329,14 @@ export async function handleStreamReply(
   deps: StreamReplyDeps,
 ): Promise<StreamReplyResult> {
   const chat_id = args.chat_id
-  const rawText = deps.normalizeParagraphBreaks
+  let rawText = deps.normalizeParagraphBreaks
     ? deps.normalizeParagraphBreaks(deps.repairEscapedWhitespace(args.text))
     : deps.repairEscapedWhitespace(args.text)
+  // Fleet-wide consistent formatting: dash/bullet normalization + over-bold
+  // tripwire, same order as the reply/edit paths (after paragraph
+  // normalization, before spacers). Both run on code-masked text internally.
+  if (deps.normalizePunctuation) rawText = deps.normalizePunctuation(rawText)
+  if (deps.stripExcessBold) rawText = deps.stripExcessBold(rawText)
   const done = Boolean(args.done)
   const format = args.format ?? deps.defaultFormat
   if (done) {

package/telegram-plugin/tests/always-allow-grant.test.ts

@@ -121,8 +121,40 @@ describe('scope-commit — durable hostd persistence', () => {
     expect(commitBlock).toContain('readFileSync(')
   })
 
-  it('passes a long timeout to tryHostdDispatch (apply+reconcile blocks)', () => {
-    expect(commitBlock).toContain('await tryHostdDispatch(agentName, req, 60_000)')
+  it('passes a 12-min timeout to tryHostdDispatch (apply+reconcile can take 5-10 min)', () => {
+    expect(commitBlock).toContain('await tryHostdDispatch(agentName, req, 720_000)')
+  })
+
+  it('acks the tap BEFORE the hostd await (interim status, background persist)', () => {
+    const interimAckIdx = commitBlock.indexOf('saving durably in background')
+    const bgIdx = commitBlock.indexOf('void (async () => {')
+    const hostdAwaitIdx = commitBlock.indexOf('await tryHostdDispatch(')
+    expect(interimAckIdx).toBeGreaterThan(-1)
+    expect(bgIdx).toBeGreaterThan(-1)
+    expect(hostdAwaitIdx).toBeGreaterThan(-1)
+    // interim ack fires before the background continuation opens, and the
+    // slow hostd await lives INSIDE the background continuation.
+    expect(interimAckIdx).toBeLessThan(bgIdx)
+    expect(bgIdx).toBeLessThan(hostdAwaitIdx)
+  })
+
+  it('background continuation body is wrapped in try/catch (a throw must not become an unhandledRejection → shutdown)', () => {
+    const bgIdx = commitBlock.indexOf('void (async () => {')
+    const tryIdx = commitBlock.indexOf('try {', bgIdx)
+    const hostdAwaitIdx = commitBlock.indexOf('await tryHostdDispatch(')
+    expect(tryIdx).toBeGreaterThan(bgIdx)
+    // The top-level try opens before any work (including the hostd await
+    // and scheduleGrantRestart's sync fs writes) runs inside the IIFE.
+    expect(tryIdx).toBeLessThan(hostdAwaitIdx)
+    expect(commitBlock).toContain('always-allow background persist threw')
+  })
+
+  it('edits the card with the real outcome after the background persist', () => {
+    const bgIdx = commitBlock.indexOf('void (async () => {')
+    const outcomeEditIdx = commitBlock.indexOf('await ctx.editMessageText(', bgIdx)
+    expect(outcomeEditIdx).toBeGreaterThan(bgIdx)
+    // Outcome edit failure is logged, never thrown into the void continuation.
+    expect(commitBlock).toContain('always-allow outcome card edit failed')
   })
 
   it('registers + cleans up the single-tap correlation entry', () => {

package/telegram-plugin/tests/card-format.test.ts

@@ -56,6 +56,21 @@ describe('stripMarkdown', () => {
   it('does not touch HTML-significant characters (escaping stays separate)', () => {
     expect(stripMarkdown('a < b & c > d')).toBe('a < b & c > d')
   })
+
+  it('F1: normalizes an em-dash on this card/narration prose surface', () => {
+    // The reply path scrubs em-dashes but cards/narration/PTY previews did not,
+    // so em-dashes leaked there. stripMarkdown now runs the same dash logic.
+    // A clause-joining dash becomes a full stop (never a comma — that produces
+    // a comma splice), with the following word recapitalized into a sentence.
+    expect(stripMarkdown('build done — shipping now')).toBe('build done. Shipping now')
+    expect(stripMarkdown('build done — Shipping now')).toBe('build done. Shipping now')
+  })
+
+  it('F1: preserves an em-dash inside an inline code span', () => {
+    // The dash normalizer masks code spans, and it runs BEFORE the backticks
+    // are stripped, so a dash inside `` `…` `` survives verbatim.
+    expect(stripMarkdown('see `a — b` token')).toBe('see a — b token')
+  })
 })
 
 describe('cleanWorkerResultParagraph', () => {
@@ -76,6 +91,19 @@ describe('cleanWorkerResultParagraph', () => {
   it('returns empty for whitespace/markup-only input', () => {
     expect(cleanWorkerResultParagraph('   \n---\n')).toBe('')
   })
+
+  it('F1: normalizes em-dashes in worker narration prose', () => {
+    const input = '## Result\n\nTests pass — ready to merge'
+    expect(cleanWorkerResultParagraph(input)).toBe('Result Tests pass. Ready to merge')
+  })
+
+  it('F1: an em-dash inside a fenced block is preserved (the block is dropped, never normalized)', () => {
+    // Fenced blocks are excised whole, so a dash inside one is preserved by
+    // removal — it never reaches (nor is mutated by) the dash normalizer, and
+    // the surrounding prose dash IS normalized.
+    const input = 'before — after\n```\nlet a = b — c\n```\ntail'
+    expect(cleanWorkerResultParagraph(input)).toBe('before. After tail')
+  })
 })
 
 describe('formatDuration', () => {