switchroom 0.16.29 → 0.16.46

package/telegram-plugin/tests/ipc-server-validate-rollout-status.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Validation contract for the #2726 rollout status IPC verbs — hostd asks the
+ * caller agent's gateway to POST (terminal ping / first narration message) or
+ * EDIT (later phases) an ORDINARY operator-DM message. A rogue process on the
+ * same UDS must not inject a malformed payload: requestId + agentName required
+ * and shaped, text required non-empty and bounded, messageId (edit) an integer.
+ *
+ * No Bun-native API → vitest per the mixed-runner gotcha.
+ */
+import { describe, it, expect } from "vitest";
+import { validateClientMessage } from "../gateway/ipc-server.js";
+import { RICH_MESSAGE_MAX_CHARS } from "../format.js";
+
+const post = {
+  type: "rollout_status_post",
+  requestId: "ro-1",
+  agentName: "overlord",
+  text: "⏳ Rollout → v1.2.3 — applying",
+};
+const edit = {
+  type: "rollout_status_edit",
+  requestId: "ro-1",
+  agentName: "overlord",
+  messageId: 42,
+  text: "✅ Rollout → v1.2.3 — done",
+};
+
+describe("validateClientMessage — rollout_status_post", () => {
+  it("accepts a well-formed message", () => {
+    expect(validateClientMessage(post)).toBe(true);
+  });
+
+  it("rejects a missing / empty / over-long requestId", () => {
+    expect(validateClientMessage({ ...post, requestId: undefined })).toBe(false);
+    expect(validateClientMessage({ ...post, requestId: "" })).toBe(false);
+    expect(validateClientMessage({ ...post, requestId: "x".repeat(65) })).toBe(false);
+  });
+
+  it("rejects a missing / malformed agentName", () => {
+    expect(validateClientMessage({ ...post, agentName: undefined })).toBe(false);
+    expect(validateClientMessage({ ...post, agentName: "Bad Name" })).toBe(false);
+  });
+
+  it("rejects empty or over-long text", () => {
+    expect(validateClientMessage({ ...post, text: "" })).toBe(false);
+    expect(
+      validateClientMessage({ ...post, text: "x".repeat(RICH_MESSAGE_MAX_CHARS + 1) }),
+    ).toBe(false);
+  });
+});
+
+describe("validateClientMessage — rollout_status_edit", () => {
+  it("accepts a well-formed message", () => {
+    expect(validateClientMessage(edit)).toBe(true);
+  });
+
+  it("rejects a non-integer messageId", () => {
+    expect(validateClientMessage({ ...edit, messageId: 1.5 })).toBe(false);
+    expect(validateClientMessage({ ...edit, messageId: "42" })).toBe(false);
+    expect(validateClientMessage({ ...edit, messageId: undefined })).toBe(false);
+  });
+
+  it("rejects empty text", () => {
+    expect(validateClientMessage({ ...edit, text: "" })).toBe(false);
+  });
+});

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

@@ -175,6 +175,30 @@ describe("renderIssuesCard", () => {
     expect(out).toContain("`<x>::<y>`");
     expect(out).toContain("<dangerous & stuff>");
   });
+
+  it("stacks issue rows with GFM hard breaks so they don't collapse onto one line (#2669)", () => {
+    // Card-body regression: the rich-message renderer collapses lone-`\n`
+    // separated rows into a run-on blob. The issues card now routes its rows
+    // through stackCardLines, so each issue row is separated by a hard break.
+    const events = [
+      makeEvent({ fingerprint: "a::1", code: "1", severity: "critical", summary: "alpha down", detail: "Fix: restart alpha" }),
+      makeEvent({ fingerprint: "a::2", code: "2", severity: "error", summary: "beta slow" }),
+    ];
+    const out = renderIssuesCard({ agentName: "klanker", events, now: 1_700_000_000_000 })!;
+    // Header → rows is a genuine paragraph gap (blank line preserved).
+    expect(out).toContain("\n\n");
+    // Each adjacent issue row (and its remediation line) is hard-broken, not
+    // soft — so no two non-blank body lines are glued by a LONE `\n`.
+    const softBreaks = out.split("\n\n").flatMap((block) => {
+      // Within a block, every internal `\n` must be a hard break (` \n`).
+      return [...block.matchAll(/(?<! {2})\n/g)];
+    });
+    expect(softBreaks.length).toBe(0);
+    // Both rows + the remediation line all rendered, stacked.
+    expect(out).toContain("alpha down");
+    expect(out).toContain("→ _restart alpha_");
+    expect(out).toContain("beta slow");
+  });
 });
 
 // ─── createIssuesCardHandle (lifecycle) ──────────────────────────────────────

package/telegram-plugin/tests/model-command.test.ts

@@ -44,7 +44,7 @@ function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
       return okResult("⏺ Set model to sonnet");
     },
     getAgentName: () => "klanker",
-    getConfiguredModel: () => "claude-sonnet-4-6",
+    getConfiguredModel: () => "claude-sonnet-5",
     escapeHtml: (s) =>
       s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"),
     preBlock: (s) => `<pre>${s}</pre>`,
@@ -75,9 +75,9 @@ describe("parseModelCommand", () => {
       model: "claude-opus-4-8",
     });
     // 1m-context variant ids carry brackets
-    expect(parseModelCommand("/model claude-sonnet-4-6[1m]")).toEqual({
+    expect(parseModelCommand("/model claude-sonnet-5[1m]")).toEqual({
       kind: "set",
-      model: "claude-sonnet-4-6[1m]",
+      model: "claude-sonnet-5[1m]",
     });
   });
 
@@ -107,7 +107,7 @@ describe("parseModelCommand", () => {
 
 describe("isValidModelArg", () => {
   it("accepts aliases and full ids", () => {
-    for (const good of [...MODEL_ALIASES, "claude-opus-4-8", "claude-haiku-4-5-20251001", "claude-sonnet-4-6[1m]"]) {
+    for (const good of [...MODEL_ALIASES, "claude-opus-4-8", "claude-haiku-4-5-20251001", "claude-sonnet-5[1m]"]) {
       expect(isValidModelArg(good), good).toBe(true);
     }
   });
@@ -163,7 +163,7 @@ describe("handleModelCommand — show / help never inject (picker-wedge guard)",
     const { deps, calls } = makeDeps();
     const reply = await handleModelCommand({ kind: "show" }, deps);
     expect(calls.length).toBe(0);
-    expect(reply.text).toContain("claude-sonnet-4-6");
+    expect(reply.text).toContain("claude-sonnet-5");
     expect(reply.text).toContain("/model opus");
     expect(reply.text).toContain("switchroom.yaml");
   });
@@ -246,7 +246,7 @@ describe("isSrModel / isClaudeModel helpers", () => {
   it("isSrModel is true only for sr-* names", () => {
     expect(isSrModel("sr-gemini-2.5-pro")).toBe(true);
     expect(isSrModel("sr-deepseek-r1")).toBe(true);
-    expect(isSrModel("claude-sonnet-4-6")).toBe(false);
+    expect(isSrModel("claude-sonnet-5")).toBe(false);
     expect(isSrModel("sonnet")).toBe(false);
     expect(isSrModel("")).toBe(false);
   });
@@ -256,7 +256,7 @@ describe("isSrModel / isClaudeModel helpers", () => {
       expect(isClaudeModel(alias), alias).toBe(true);
     }
     expect(isClaudeModel("claude-opus-4-8")).toBe(true);
-    expect(isClaudeModel("claude-sonnet-4-6[1m]")).toBe(true);
+    expect(isClaudeModel("claude-sonnet-5[1m]")).toBe(true);
     expect(isClaudeModel("sr-gemini-2.5-pro")).toBe(false);
     expect(isClaudeModel("gpt-4")).toBe(false);
   });
@@ -407,7 +407,13 @@ import {
   MODEL_CALLBACK_REFRESH,
   MODEL_CALLBACK_HEADER,
   MODEL_CALLBACK_SR,
+  MODEL_CALLBACK_ALIAS,
+  MODEL_CALLBACK_PAGE_EXTERNAL,
+  MODEL_CALLBACK_PAGE_MAIN,
   SR_MODEL_LABELS,
+  SR_MODEL_ALIASES,
+  EXTRA_CLAUDE_ALIASES,
+  externalModelNames,
   isSrToClaudeTransition,
   type ModelMenuDeps,
 } from "../gateway/model-command.js";
@@ -415,7 +421,7 @@ import { labelTag } from "../../src/agents/model-picker.js";
 
 const OPTIONS = [
   { index: 1, label: "Default (recommended)", detail: "Opus 4.8 with 1M context", current: false },
-  { index: 2, label: "Sonnet", detail: "Sonnet 4.6 · Efficient", current: true },
+  { index: 2, label: "Sonnet", detail: "Sonnet 5 · Efficient", current: true },
   { index: 3, label: "Haiku", detail: "Haiku 4.5 · Fastest", current: false },
 ];
 
@@ -448,11 +454,16 @@ describe("buildModelMenu", () => {
     expect(menu.text).toContain("**Sonnet**");
     expect(menu.text).toContain("29% / 5h · 33% / 7d");
     expect(menu.keyboard).toBeDefined();
-    // 3 option rows + refresh row
-    expect(menu.keyboard!.length).toBe(4);
+    // 3 scraped option rows + static Fable row + refresh row
+    // (no external row here — discoverSrModels returns [] and the default
+    // makeMenuDeps has no SR seed override, but externalModelNames seeds from
+    // SR_MODEL_ALIASES, so the External row IS present — see dedicated tests).
     expect(menu.keyboard![1][0].text).toBe("✅ Sonnet");
     expect(menu.keyboard![0][0].text).toBe("Default (recommended)");
-    expect(menu.keyboard![3][0].callback_data).toBe(MODEL_CALLBACK_REFRESH);
+    // Refresh is always the last row.
+    expect(menu.keyboard![menu.keyboard!.length - 1][0].callback_data).toBe(
+      MODEL_CALLBACK_REFRESH,
+    );
   });
 
   it("every callback_data fits Telegram's 64-byte cap", async () => {
@@ -585,7 +596,7 @@ describe("sessionModelFromConfirmation", () => {
 
 const OPTIONS_WITH_SR = [
   { index: 1, label: "Default (recommended)", detail: "Opus 4.8 with 1M context", current: false },
-  { index: 2, label: "Sonnet", detail: "Sonnet 4.6", current: true },
+  { index: 2, label: "Sonnet", detail: "Sonnet 5", current: true },
   { index: 3, label: "sr-gemini-2.5-pro", detail: "", current: false },
   { index: 4, label: "sr-deepseek-r1", detail: "", current: false },
   // internal path — should be filtered out
@@ -635,42 +646,48 @@ describe("buildModelMenu — with sr-* models", () => {
     });
   }
 
-  it("shows 🌐 buttons for sr-* models, normal buttons for claude models", async () => {
-    const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
-    expect(menu.keyboard).toBeDefined();
-    const allButtons = menu.keyboard!.flat();
-    // 🌐 buttons for sr-*
-    expect(allButtons.find((b) => b.text === "🌐 Gemini 2.5 Pro")).toBeDefined();
-    expect(allButtons.find((b) => b.text === "🌐 DeepSeek R1")).toBeDefined();
-    // Regular buttons for Claude models
-    expect(allButtons.find((b) => b.text === "Default (recommended)")).toBeDefined();
-    // openrouter/* not shown at all
-    expect(allButtons.find((b) => b.text.includes("openrouter"))).toBeUndefined();
-  });
+  // Nested-page design (this PR): sr-* models no longer render inline on the
+  // main page — they live behind the "🌐 External models ▸" button on a second
+  // keyboard page. Live discoverSrModels() results are UNION-ed with the static
+  // SR_MODEL_ALIASES seed, so the external page always has at least the six
+  // curated aliases even when discovery returns [].
 
-  it("sr-* buttons use mdl:sr: callback prefix", async () => {
+  it("live-discovered sr-* models appear on the EXTERNAL page (not inline on main)", async () => {
     const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
+    const main = await buildModelMenu(deps, "main");
+    const mainButtons = main.keyboard!.flat();
+    // Not inline on the main page…
+    expect(mainButtons.find((b) => b.text === "🌐 Gemini 2.5 Pro")).toBeUndefined();
+    // …but the External-open button is present.
+    expect(mainButtons.find((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL)).toBeDefined();
+
+    const ext = await buildModelMenu(deps, "external");
+    const extButtons = ext.keyboard!.flat();
+    expect(extButtons.find((b) => b.text === "🌐 Gemini 2.5 Pro")).toBeDefined();
+    expect(extButtons.find((b) => b.text === "🌐 DeepSeek R1")).toBeDefined();
+    // openrouter/* / non-sr-* never shown at all.
+    expect(extButtons.find((b) => b.text.includes("openrouter"))).toBeUndefined();
+  });
+
+  it("external-page sr-* buttons use the mdl:sr: callback prefix", async () => {
+    const { deps } = makeMenuDepsWithSr();
+    const menu = await buildModelMenu(deps, "external");
     const srButton = menu.keyboard!.flat().find((b) => b.text === "🌐 Gemini 2.5 Pro");
     expect(srButton?.callback_data).toBe(`${MODEL_CALLBACK_SR}sr-gemini-2.5-pro`);
   });
 
-  it("shows section header rows when both claude and sr-* models present", async () => {
+  it("external page has exactly one header row (billed-separately)", async () => {
     const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
-    const allButtons = menu.keyboard!.flat();
-    const headers = allButtons.filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
-    expect(headers.length).toBe(2);
-    expect(headers[0].text).toContain("Claude");
-    expect(headers[1].text).toContain("OpenRouter");
+    const menu = await buildModelMenu(deps, "external");
+    const headers = menu.keyboard!.flat().filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
+    expect(headers.length).toBe(1);
+    expect(headers[0].text).toContain("External");
   });
 
-  it("no section headers when only claude models (no sr-*)", async () => {
+  it("main page carries NO header rows (headers live on the external page)", async () => {
     const { deps } = makeMenuDeps();
-    const menu = await buildModelMenu(deps);
-    const allButtons = (menu.keyboard ?? []).flat();
-    const headers = allButtons.filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
+    const menu = await buildModelMenu(deps, "main");
+    const headers = (menu.keyboard ?? []).flat().filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
     expect(headers.length).toBe(0);
   });
 
@@ -682,17 +699,11 @@ describe("buildModelMenu — with sr-* models", () => {
     expect(injectCalls).toHaveLength(0);
   });
 
-  it("shows subscription/OpenRouter legend when sr-* models are present", async () => {
+  it("main page points at the External page for OpenRouter-billed models", async () => {
     const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
+    const menu = await buildModelMenu(deps, "main");
     expect(menu.text).toContain("Max/Pro subscription");
-    expect(menu.text).toContain("OpenRouter");
-  });
-
-  it("no legend when no sr-* models in picker", async () => {
-    const { deps } = makeMenuDeps();
-    const menu = await buildModelMenu(deps);
-    expect(menu.text).not.toContain("OpenRouter");
+    expect(menu.text).toContain("External models");
   });
 });
 
@@ -761,3 +772,158 @@ describe("isSrToClaudeTransition", () => {
     expect(isSrToClaudeTransition("Sonnet", "sr-gemini-2.5-pro")).toBe(false);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Paginated picker — Fable in the Claude group + nested External page.
+// ---------------------------------------------------------------------------
+
+describe("externalModelNames", () => {
+  it("seeds from SR_MODEL_ALIASES values even when discovery is empty", () => {
+    const names = externalModelNames([]);
+    for (const target of Object.values(SR_MODEL_ALIASES)) {
+      expect(names).toContain(target);
+    }
+    // All six curated aliases, deduped.
+    expect(names.length).toBe(new Set(Object.values(SR_MODEL_ALIASES)).size);
+    expect(names).toEqual([...names].sort());
+  });
+
+  it("unions live discovery, dedupes, and drops non-sr-* names", () => {
+    const names = externalModelNames(["sr-brand-new", "sr-glm-5", "gpt-4o", "voyage-law-2"]);
+    expect(names).toContain("sr-brand-new");
+    expect(names).toContain("sr-glm-5");
+    // sr-glm-5 already came from aliases — deduped, not doubled.
+    expect(names.filter((n) => n === "sr-glm-5").length).toBe(1);
+    // Non-sr-* names never surface (subscription-honest).
+    expect(names).not.toContain("gpt-4o");
+    expect(names).not.toContain("voyage-law-2");
+  });
+});
+
+describe("paginated model menu — main page", () => {
+  it("main page includes a Fable button and an External-models-open button", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps);
+    const flat = menu.keyboard!.flat();
+    const fable = flat.find((b) => b.text === "Fable");
+    expect(fable).toBeDefined();
+    expect(fable!.callback_data).toBe(`${MODEL_CALLBACK_ALIAS}fable`);
+    const ext = flat.find((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL);
+    expect(ext).toBeDefined();
+    expect(ext!.text).toContain("External");
+    // Refresh is last.
+    expect(menu.keyboard![menu.keyboard!.length - 1][0].callback_data).toBe(
+      MODEL_CALLBACK_REFRESH,
+    );
+  });
+
+  it("no External-open button when there are no external models", async () => {
+    // Force externalModelNames to be empty by stubbing SR aliases away is not
+    // possible (static), but a build with an empty alias set is covered by the
+    // externalModelNames unit test. Here we assert the button is gated on the
+    // list being non-empty via the real (non-empty) path: it IS present.
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps);
+    const flat = menu.keyboard!.flat();
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL)).toBe(true);
+  });
+
+  it("dedupes the static Fable row if the scraped options already include Fable", async () => {
+    const { deps } = makeMenuDeps({
+      discover: async () => ({
+        ok: true as const,
+        options: [
+          { index: 1, label: "Sonnet", detail: "", current: true },
+          { index: 2, label: "Fable", detail: "Fable 5", current: false },
+        ],
+        currentLabel: "Sonnet",
+      }),
+    });
+    const menu = await buildModelMenu(deps);
+    const flat = menu.keyboard!.flat();
+    // Exactly one Fable button, and it's the scraped (select) one, not the alias.
+    const fables = flat.filter((b) => b.text === "Fable" || b.text === "✅ Fable");
+    expect(fables.length).toBe(1);
+    expect(fables[0].callback_data.startsWith(MODEL_CALLBACK_ALIAS)).toBe(false);
+  });
+
+  it("every callback_data still fits Telegram's 64-byte cap", async () => {
+    const { deps } = makeMenuDeps();
+    for (const page of ["main", "external"] as const) {
+      const menu = await buildModelMenu(deps, page);
+      for (const btn of menu.keyboard!.flat()) {
+        expect(Buffer.byteLength(btn.callback_data, "utf-8")).toBeLessThanOrEqual(64);
+      }
+    }
+  });
+});
+
+describe("paginated model menu — external page", () => {
+  it("lists all six SR_MODEL_ALIASES models plus a Back button", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps, "external");
+    const flat = menu.keyboard!.flat();
+    for (const target of Object.values(SR_MODEL_ALIASES)) {
+      const btn = flat.find((b) => b.callback_data === `${MODEL_CALLBACK_SR}${target}`);
+      expect(btn, `missing external button for ${target}`).toBeDefined();
+      expect(btn!.text.startsWith("🌐")).toBe(true);
+    }
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_MAIN)).toBe(true);
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_REFRESH)).toBe(true);
+  });
+
+  it("external page body text makes the billed-separately split explicit", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps, "external");
+    expect(menu.text).toContain("billed separately");
+    expect(menu.text).toContain("OpenRouter");
+    expect(menu.text).toContain("subscription");
+  });
+});
+
+describe("page callbacks swap the keyboard without switching model", () => {
+  it("PAGE_EXTERNAL renders the external page and does NOT select/inject", async () => {
+    const { deps, calls, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(MODEL_CALLBACK_PAGE_EXTERNAL, deps);
+    expect(calls.select).toEqual([]);
+    expect(injectCalls).toEqual([]);
+    expect(out.selectedModel).toBeUndefined();
+    const flat = out.reply.keyboard!.flat();
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_MAIN)).toBe(true);
+    expect(out.reply.text).toContain("billed separately");
+  });
+
+  it("PAGE_MAIN renders the main page and does NOT select/inject", async () => {
+    const { deps, calls, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(MODEL_CALLBACK_PAGE_MAIN, deps);
+    expect(calls.select).toEqual([]);
+    expect(injectCalls).toEqual([]);
+    expect(out.selectedModel).toBeUndefined();
+    const flat = out.reply.keyboard!.flat();
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL)).toBe(true);
+    expect(flat.some((b) => b.text === "Fable")).toBe(true);
+  });
+});
+
+describe("Fable alias callback injects /model fable", () => {
+  it("injects exactly '/model fable' and reports the session model", async () => {
+    const { deps, calls, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}fable`, deps);
+    // Alias path uses inject, never the cursor-nav select path.
+    expect(calls.select).toEqual([]);
+    expect(injectCalls).toHaveLength(1);
+    expect(injectCalls[0].command).toBe("/model fable");
+    expect(out.reply.text).toContain("✅");
+  });
+
+  it("EXTRA_CLAUDE_ALIASES contains fable", () => {
+    expect(EXTRA_CLAUDE_ALIASES.some((a) => a.alias === "fable" && a.label === "Fable")).toBe(true);
+  });
+
+  it("rejects an invalid alias without injecting", async () => {
+    const { deps, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}bad name`, deps);
+    expect(injectCalls).toEqual([]);
+    expect(out.answer).toContain("Invalid");
+  });
+});

package/telegram-plugin/tests/obligation-turn-end.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest'
+
+import { decideObligationTurnEnd } from '../gateway/obligation-turn-end.js'
+import { ObligationLedger } from '../gateway/obligation-ledger.js'
+
+/**
+ * #2624 — obligation close on replyCalled shipped test-free. Pin BOTH branches:
+ *
+ *   - Normal reply → close at turn_end (finalAnswerDelivered OR replyCalled).
+ *   - Ack-then-ghost / no-reply → NOT closed at turn_end; stays open so the
+ *     idle sweep ends it via silence_fallback.
+ */
+describe('decideObligationTurnEnd (#2624)', () => {
+  it('final answer delivered → close', () => {
+    expect(decideObligationTurnEnd(true, false)).toBe('close')
+  })
+
+  it('replyCalled (short sr-* reply demoted to non-final) → close', () => {
+    // The LiteLLM sr-* cascade: reply("OK", {disable_notification:true}) is
+    // below the 200-char backstop + notification-suppressed, so
+    // finalAnswerDelivered is false — but the model explicitly replied.
+    expect(decideObligationTurnEnd(false, true)).toBe('close')
+  })
+
+  it('final answer AND replyCalled → close', () => {
+    expect(decideObligationTurnEnd(true, true)).toBe('close')
+  })
+
+  it('no reply at all (ack-then-ghost / no-reply) → note-ended, NOT close', () => {
+    expect(decideObligationTurnEnd(false, false)).toBe('note-ended')
+  })
+})
+
+describe('#2624 obligation lifecycle — end-to-end over the ledger', () => {
+  const openObligation = (ledger: ObligationLedger, turnId: string) =>
+    ledger.openIfAbsent({
+      originTurnId: turnId,
+      chatId: '123',
+      messageId: 1,
+      text: 'do the thing',
+      openedAt: 1_000,
+    })
+
+  it('normal reply closes the obligation at turn_end', () => {
+    const ledger = new ObligationLedger()
+    openObligation(ledger, 'turn-A')
+    expect(ledger.isOpen('turn-A')).toBe(true)
+
+    // Simulate the gateway turn_end branch for a turn that called reply.
+    if (decideObligationTurnEnd(true, false) === 'close') {
+      ledger.close('turn-A')
+    } else {
+      ledger.noteTurnEnded('turn-A', 2_000)
+    }
+    expect(ledger.isOpen('turn-A')).toBe(false)
+  })
+
+  it('ack-then-ghost turn_end does NOT close — obligation survives for silence_fallback', () => {
+    const ledger = new ObligationLedger()
+    openObligation(ledger, 'turn-B')
+
+    // turn_end with no reply: the ack-then-ghost path.
+    if (decideObligationTurnEnd(false, false) === 'close') {
+      ledger.close('turn-B')
+    } else {
+      ledger.noteTurnEnded('turn-B', 2_000)
+    }
+    // Still open at turn_end — the whole point: it is ended later via
+    // silence_fallback, NOT turn_end.
+    expect(ledger.isOpen('turn-B')).toBe(true)
+
+    // The silence-fallback sweep is what finally closes it.
+    expect(ledger.close('turn-B')).toBe(true)
+    expect(ledger.isOpen('turn-B')).toBe(false)
+  })
+})