switchroom 0.21.7 → 0.21.8

package/telegram-plugin/tests/boot-resume-guard-wiring.test.ts

@@ -0,0 +1,203 @@
+/**
+ * switchroom#4641 — wiring pin for the boot-resume generation guard.
+ *
+ * `boot-resume-gateway-only-respawn.test.ts` proves the OUTCOME (a stamped
+ * generation token yields zero `resume_interrupted` spool entries, an unstamped
+ * one still resumes) over the real registry, builders and spool, but it
+ * supplies the ORDERING itself: gateway.ts is a 24k-line module whose boot
+ * block cannot be imported without booting a gateway. This file closes that gap
+ * by pinning gateway.ts's own wiring, so a refactor cannot move the guard below
+ * the reaper, drop it, or move the token stamp back inside the block while
+ * the outcome suite stays green against its own copy of the sequence.
+ *
+ * Pinned:
+ *   1. the label exists and is on the `isGatewayMain` boot-registry block,
+ *   2. the guard runs and `break`s out of that label,
+ *   3. it precedes the orphan-turn reaper, the bridge-dead marker consumption,
+ *      the interrupted-turn finder, the resume builders, the crash-redelivery
+ *      capture and `writePendingTurnEnv` — i.e. `break` skips ALL of them,
+ *   4. the break carries a comment naming those skipped effects (the reviewer
+ *      MEDIUM: the skip is wider than the resume path and was undocumented),
+ *   5. THE STAMP FOLLOWS THE DURABLE PUT. The `bootResumeInit` block only
+ *      builds `bootResumeInbound` in MEMORY; the resume becomes crash-
+ *      survivable ~8k lines later at `inboundSpool.put(...)`. Stamping at the
+ *      tail of the block (the shape this PR's first revision shipped) means a
+ *      crash in between leaves a token, no `agent-process.json`, and a
+ *      successor that suppresses a turn already stamped `ended_via='restart'`
+ *      — silent, permanent work loss. So: the stamp must NOT appear inside the
+ *      block at all, must come after the put and after `markTurnResumed`, and
+ *      must be UNCONDITIONAL (top-level, gated only on `isGatewayMain`) so a
+ *      boot with nothing to resume still writes a token. Same rule
+ *      `markTurnResumed` already obeys — see turns-schema.ts's "the caller
+ *      must stamp only AFTER the resume inbound is durably spooled".
+ */
+
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const SRC = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+  'utf8',
+)
+
+/** First index of `needle`, asserted present. */
+function idx(needle: string): number {
+  const i = SRC.indexOf(needle)
+  expect(i, `gateway.ts should contain ${JSON.stringify(needle)}`).toBeGreaterThan(-1)
+  return i
+}
+
+describe('#4641 boot-resume guard wiring in gateway.ts', () => {
+  it('labels the boot-registry block so the guard can exit it', () => {
+    expect(SRC).toContain('bootResumeInit: if (isGatewayMain) try {')
+  })
+
+  it('calls the guard and breaks out of the whole block', () => {
+    expect(SRC).toMatch(
+      /if \(shouldSkipBootResumeForGatewayOnlyRespawn\(STATE_DIR\)\) break bootResumeInit/,
+    )
+    expect(SRC).toContain(
+      "import { shouldSkipBootResumeForGatewayOnlyRespawn, markBootResumeComplete } from './agent-process-liveness.js'",
+    )
+  })
+
+  it('runs the guard BEFORE every side effect a gateway-only respawn must skip', () => {
+    const guard = idx('shouldSkipBootResumeForGatewayOnlyRespawn(STATE_DIR)')
+    // The orphan-turn reaper — what stamped the live turn `ended_via='restart'`.
+    expect(guard).toBeLessThan(idx('markOrphanedWithTimeoutClassification(turnsDb'))
+    // #3038 bridge-dead escalation marker consumption.
+    expect(guard).toBeLessThan(idx('consumeBridgeDeadEscalationMarker('))
+    // The interrupted-turn finder + the synthetic that lied to the session.
+    expect(guard).toBeLessThan(idx('findLatestTurnIfInterrupted(turnsDb)'))
+    expect(guard).toBeLessThan(idx('buildResumeInterruptedInbound({'))
+    // The sub-agent "killed by the restart" list.
+    expect(guard).toBeLessThan(idx('listNonTerminalSubagentsForTurn(turnsDb'))
+    // The crash-redelivery candidate capture.
+    expect(guard).toBeLessThan(idx('pendingRedelivery = { turn: pending'))
+    // The bridge-dead idle notice.
+    expect(guard).toBeLessThan(idx('buildBridgeDeadIdleNoticeInbound({'))
+    // The one-shot wake-audit env file.
+    expect(guard).toBeLessThan(idx('writePendingTurnEnv(agentDir, pending)'))
+  })
+
+  it('documents at the break every effect it skips beyond the resume path', () => {
+    // The reviewer MEDIUM: `break bootResumeInit` silently skipped the
+    // bridge-dead marker (whose own comment claims it is ALWAYS cleared), the
+    // idle notice and the redelivery capture. The break must name them, so the
+    // next reader of gateway.ts:1721 is not misled by that stale invariant.
+    const line = SRC.split('\n').find((l) => l.includes('break bootResumeInit'))
+    expect(line, 'gateway.ts should contain the guarded break').toBeDefined()
+    for (const named of [
+      'reaper',
+      'consumeBridgeDeadEscalationMarker',
+      'idle notice',
+      'pendingRedelivery',
+      'writePendingTurnEnv',
+    ]) {
+      expect(line!, `the break comment must name ${named}`).toContain(named)
+    }
+  })
+
+  it('stamps the generation token AFTER the durable spool put, never inside the block', () => {
+    // The invariant this pins, and why it is NOT "the stamp is last in the
+    // block": the block builds `bootResumeInbound` in memory only. Stamping at
+    // its tail marks the generation done while the resume is still nowhere on
+    // disk, so a crash before the put leaves a token + no `agent-process.json`
+    // + a turn stamped `ended_via='restart'` and `resumed_at` NULL — and the
+    // successor returns `gateway-only-respawn-no-record` and drops it forever.
+    const durablePut = idx('inboundSpool.put(bootResumeInbound.agent, bootResumeInbound.msg)')
+    const stamps = [...SRC.matchAll(/markBootResumeComplete\(STATE_DIR\)/g)].map((m) => m.index!)
+    expect(stamps.length, 'exactly one token stamp site in gateway.ts').toBe(1)
+    const stamp = stamps[0]!
+
+    // 1. It is OUTSIDE the bootResumeInit block: the block's `} catch (err) {`
+    //    closes long before the stamp.
+    const blockStart = idx('bootResumeInit: if (isGatewayMain) try {')
+    const blockEnd = SRC.indexOf('} catch (err) {', blockStart)
+    expect(blockEnd).toBeGreaterThan(blockStart)
+    expect(
+      stamp,
+      'the token stamp must NOT live inside the bootResumeInit block — the block only builds the resume in memory',
+    ).toBeGreaterThan(blockEnd)
+
+    // 2. It follows the durable put, and the at-most-once `markTurnResumed`
+    //    ledger that obeys the identical ordering rule.
+    expect(durablePut, 'the durable spool put must precede the token stamp').toBeLessThan(stamp)
+    expect(idx('markTurnResumed(turnsDb, resumeTurnKey)')).toBeLessThan(stamp)
+
+    // 3. It is top-level (zero indentation, so not nested inside
+    //    `if (isGatewayMain && bootResumeInbound != null)`) and independent of
+    //    whether there was anything to resume — a boot that found nothing must
+    //    still stamp, or a later gateway-only respawn reaps a
+    //    meanwhile-started live turn — but it IS gated on the block not having
+    //    thrown. gateway.ts's block-level `catch` swallows and lets init
+    //    continue, so an ungated stamp marks the generation done after the
+    //    reaper has already durably ended a turn that was never spooled.
+    const stampLine = SRC.split('\n').find((l) => l.includes('markBootResumeComplete(STATE_DIR)'))!
+    expect(stampLine).toMatch(
+      /^if \(isGatewayMain && !bootResumeThrew\) markBootResumeComplete\(STATE_DIR\)/,
+    )
+
+    // 4. Nothing durable-resume-related may sneak between the put and the
+    //    stamp except the resumed_at ledger — i.e. the stamp closes that
+    //    sequence rather than floating somewhere later in module init.
+    const between = SRC.slice(durablePut + 1, stamp)
+    expect(between, 'no second spool put may separate the durable put from the stamp')
+      .not.toContain('inboundSpool.put(bootResumeInbound')
+    expect(
+      between.split('\n').length,
+      'the stamp must sit immediately after the resume-commit block, not drift away from it',
+    ).toBeLessThan(40)
+  })
+
+  it('does not re-join the stamp onto writePendingTurnEnv inside the block', () => {
+    // The exact regression shape: `writePendingTurnEnv(agentDir, pending); markBootResumeComplete(STATE_DIR)`
+    // — joined onto one line to satisfy the gateway line ratchet. The ratchet
+    // is not a licence to stamp early.
+    const envLine = SRC.split('\n').find((l) => l.includes('writePendingTurnEnv(agentDir, pending)'))!
+    expect(
+      envLine,
+      'the generation token must not be stamped alongside writePendingTurnEnv (still in-memory-only territory)',
+    ).not.toContain('markBootResumeComplete')
+  })
+
+  it("sets bootResumeThrew in the block's own catch, and nowhere else", () => {
+    // The catch is a SWALLOW: it logs, nulls turnsDb and lets module init run
+    // on to the stamp. By then the reaper may already have durably written
+    // `ended_via='restart'` with nothing spooled, so the catch must record the
+    // failure and the stamp must honour it. Pinned by source text because the
+    // block is module-init code this suite cannot import.
+    const blockStart = idx('bootResumeInit: if (isGatewayMain) try {')
+    const catchAt = SRC.indexOf('} catch (err) {', blockStart)
+    const stamp = idx('markBootResumeComplete(STATE_DIR)')
+
+    const sets = [...SRC.matchAll(/bootResumeThrew = true/g)].map((m) => m.index!)
+    expect(sets.length, 'exactly one assignment site').toBe(1)
+    expect(sets[0]!, "the assignment must be in the block's catch").toBeGreaterThan(catchAt)
+    expect(sets[0]!, 'and before the stamp reads it').toBeLessThan(stamp)
+
+    // The catch must not early-return/exit instead: init continues, which is
+    // precisely why the flag is needed.
+    const catchBody = SRC.slice(catchAt, SRC.indexOf('\n}\n', catchAt) + 2)
+    expect(catchBody).toContain('turnsDb = null')
+    expect(catchBody).not.toContain('process.exit')
+
+    const decl = SRC.indexOf('let bootResumeThrew = false')
+    expect(decl, 'declared before the block so the stamp can read it').toBeGreaterThan(-1)
+    expect(decl).toBeLessThan(blockStart)
+  })
+
+  it('keeps the guard AFTER the registry is opened, so turn tracking still works', () => {
+    // A gateway-only respawn still needs a live turnsDb for the rest of the
+    // gateway; the guard skips the boot-resume side effects, not the DB.
+    expect(idx('turnsDb = openTurnsDb(agentDir)')).toBeLessThan(
+      idx('shouldSkipBootResumeForGatewayOnlyRespawn(STATE_DIR)'),
+    )
+    expect(idx('applySubagentsSchema(turnsDb)')).toBeLessThan(
+      idx('shouldSkipBootResumeForGatewayOnlyRespawn(STATE_DIR)'),
+    )
+  })
+})

package/telegram-plugin/tests/callback-query-handlers.test.ts

@@ -25,7 +25,7 @@
  * broker call, which is exactly the behavior the extraction must not change.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import type { Context } from 'grammy'
 import {
   createCallbackQueryHandlers,
@@ -42,6 +42,10 @@ import { createSweepableCardStore } from '../gateway/approval-card-stores.js'
 import { createSweepableStore } from '../gateway/pending-state-stores.js'
 import { StagingMap } from '../secret-detect/staging.js'
 import { InlineKeyboard } from 'grammy'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { enqueueEvalCaseProposal } from '../../src/self-improve/eval-case-proposals.js'
 
 // Mock the auth-broker client so the `auth:use:` swap path is observable
 // (spy on setActive) without a live UDS broker. Only handleAuthDashboardCallback
@@ -625,6 +629,144 @@ describe('handleSkillProposalCallback', () => {
   })
 })
 
+// ── evcase:* — eval-case proposal ───────────────────────────────────────
+//
+// The defect these pin: this handler was a copy of the skill handler that
+// dropped the `deliverResumeSyntheticOrBuffer` call, so BOTH exits — dismiss
+// and approve — edited the card and returned without telling the proposing
+// agent anything. The agent had been steered to end its turn and wait for a
+// wake-up that no code path sent. On unmodified code every assertion below on
+// `deliverResumeSyntheticOrBuffer` fails with 0 calls.
+//
+// `handleEvalCaseProposalCallback` reads the proposal store off disk (not from
+// an injected store), so these drive a REAL tmp state dir via the real
+// `enqueueEvalCaseProposal`. `TELEGRAM_STATE_DIR` is NOT one of
+// `agent-state-dir-guard`'s GUARDED_STATE_DIR_VARS, so the guard neither
+// redirects nor blocks it — setting it here is the whole isolation.
+
+describe('handleEvalCaseProposalCallback', () => {
+  let stateDir: string
+  let prevStateDir: string | undefined
+  let prevAgent: string | undefined
+
+  beforeEach(() => {
+    stateDir = mkdtempSync(join(tmpdir(), 'evcase-cb-'))
+    prevStateDir = process.env.TELEGRAM_STATE_DIR
+    prevAgent = process.env.SWITCHROOM_AGENT_NAME
+    process.env.TELEGRAM_STATE_DIR = stateDir
+    process.env.SWITCHROOM_AGENT_NAME = 'test-agent'
+  })
+
+  afterEach(() => {
+    if (prevStateDir == null) delete process.env.TELEGRAM_STATE_DIR
+    else process.env.TELEGRAM_STATE_DIR = prevStateDir
+    if (prevAgent == null) delete process.env.SWITCHROOM_AGENT_NAME
+    else process.env.SWITCHROOM_AGENT_NAME = prevAgent
+    rmSync(stateDir, { recursive: true, force: true })
+  })
+
+  function seedProposal(over: { heldOut?: boolean } = {}) {
+    return enqueueEvalCaseProposal(stateDir, {
+      skill_slug: 'deploy-checklist',
+      skill_dir: join(stateDir, 'skills', 'deploy-checklist'),
+      case: { prompt: 'the correction, as an input' },
+      fingerprint: 'fp-1',
+      held_out: over.heldOut === true,
+    })
+  }
+
+  it('dismiss wakes the agent with an eval_case_rejected inbound', async () => {
+    const { deps } = makeDeps()
+    const h = createCallbackQueryHandlers(deps)
+    const p = seedProposal()
+    const { ctx } = makeCtx()
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:deny:${p.id}`)
+    expect(deps.deliverResumeSyntheticOrBuffer).toHaveBeenCalledWith(
+      'test-agent',
+      expect.objectContaining({
+        meta: expect.objectContaining({
+          source: 'eval_case_rejected',
+          proposal_id: p.id,
+          skill_slug: 'deploy-checklist',
+        }),
+      }),
+    )
+  })
+
+  it('approve with a successful applier wakes the agent with eval_case_applied', async () => {
+    const runEvalCaseApply = vi.fn(() => ({ ok: true, out: 'added 1 case' }))
+    const { deps } = makeDeps({ runEvalCaseApply })
+    const h = createCallbackQueryHandlers(deps)
+    const p = seedProposal()
+    const { ctx } = makeCtx()
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:approve:${p.id}`)
+    expect(runEvalCaseApply).toHaveBeenCalledWith(p.id)
+    expect(deps.deliverResumeSyntheticOrBuffer).toHaveBeenCalledWith(
+      'test-agent',
+      expect.objectContaining({
+        meta: expect.objectContaining({ source: 'eval_case_applied', proposal_id: p.id }),
+      }),
+    )
+  })
+
+  it('approve with a failing applier wakes the agent with eval_case_apply_failed + the output', async () => {
+    const runEvalCaseApply = vi.fn(() => ({ ok: false, out: 'ENOENT: skill dir missing' }))
+    const { deps, injected } = makeDeps({ runEvalCaseApply })
+    const h = createCallbackQueryHandlers(deps)
+    const p = seedProposal()
+    const { ctx } = makeCtx()
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:approve:${p.id}`)
+    expect(deps.deliverResumeSyntheticOrBuffer).toHaveBeenCalledWith(
+      'test-agent',
+      expect.objectContaining({
+        meta: expect.objectContaining({ source: 'eval_case_apply_failed', proposal_id: p.id }),
+      }),
+    )
+    // The applier's own diagnosis reaches the agent, not just "it failed".
+    expect(injected[0]?.text).toContain('ENOENT: skill dir missing')
+  })
+
+  it('carries the card’s forum topic into the outcome inbound', async () => {
+    const { deps } = makeDeps()
+    const h = createCallbackQueryHandlers(deps)
+    const p = seedProposal()
+    const { ctx } = makeCtx({ threadId: 7 })
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:deny:${p.id}`)
+    expect(deps.deliverResumeSyntheticOrBuffer).toHaveBeenCalledWith(
+      'test-agent',
+      expect.objectContaining({
+        threadId: 7,
+        meta: expect.objectContaining({ message_thread_id: '7' }),
+      }),
+    )
+  })
+
+  it('a second tap injects nothing — the non-pending guard runs before every injection', async () => {
+    const runEvalCaseApply = vi.fn(() => ({ ok: true, out: '' }))
+    const { deps } = makeDeps({ runEvalCaseApply })
+    const h = createCallbackQueryHandlers(deps)
+    const p = seedProposal()
+    const { ctx } = makeCtx()
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:approve:${p.id}`)
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:approve:${p.id}`)
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:deny:${p.id}`)
+    expect(deps.deliverResumeSyntheticOrBuffer).toHaveBeenCalledTimes(1)
+    expect(runEvalCaseApply).toHaveBeenCalledTimes(1)
+  })
+
+  it('a non-allowlisted tapper neither applies nor wakes the agent', async () => {
+    const runEvalCaseApply = vi.fn(() => ({ ok: true, out: '' }))
+    const { deps } = makeDeps({ runEvalCaseApply })
+    const h = createCallbackQueryHandlers(deps)
+    const p = seedProposal()
+    const { ctx, raw } = makeCtx({ senderId: '999' })
+    await h.handleEvalCaseProposalCallback(ctx, `evcase:approve:${p.id}`)
+    expect(raw.answerCallbackQuery).toHaveBeenCalledWith({ text: 'Not authorized.' })
+    expect(runEvalCaseApply).not.toHaveBeenCalled()
+    expect(deps.deliverResumeSyntheticOrBuffer).not.toHaveBeenCalled()
+  })
+})
+
 // ── op:* — operator-event card actions ──────────────────────────────────
 
 describe('handleOperatorEventCallback', () => {

package/telegram-plugin/tests/eval-case-proposal-inbound-builders.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Fixture pins for the eval-case outcome inbounds.
+ *
+ * `meta.source` is what the bridge keys on to render the `<channel source=…>`
+ * block that wakes the proposing agent, and the `meta.*` fields are the
+ * forensic anchor back to the proposal + the deciding operator. A silent change
+ * to either would put the agent back where this fix found it — steered to end
+ * its turn and wait for a wake-up nothing recognises. Mirrors
+ * `skill-proposal-card.test.ts`'s `buildSkillProposalApplyInbound` block.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  buildEvalCaseAppliedInbound,
+  buildEvalCaseRejectedInbound,
+  buildEvalCaseApplyFailedInbound,
+} from '../gateway/eval-case-proposal-inbound-builders.js'
+
+const CTX = { agent: 'klanker', chat_id: '12345' }
+
+describe('buildEvalCaseAppliedInbound', () => {
+  it('pins source and meta for an applied case', () => {
+    const inb = buildEvalCaseAppliedInbound({
+      ctx: CTX,
+      proposalId: 'p1',
+      skillSlug: 'deploy-checklist',
+      heldOut: false,
+      operatorId: '999',
+      nowMs: 1000,
+    })
+    expect(inb.meta.source).toBe('eval_case_applied')
+    expect(inb.meta.agent).toBe('klanker')
+    expect(inb.meta.proposal_id).toBe('p1')
+    expect(inb.meta.skill_slug).toBe('deploy-checklist')
+    expect(inb.meta.held_out).toBe('false')
+    expect(inb.meta.operator_id).toBe('999')
+    expect(inb.chatId).toBe('12345')
+    expect(inb.user).toBe('self-improve')
+    expect(inb.messageId).toBe(1000)
+    expect(inb.ts).toBe(1000)
+    // The agent must NOT re-write a case the gateway already applied.
+    expect(inb.text).toContain('do NOT write it yourself')
+    expect(inb.text).toContain('evals.json')
+  })
+
+  it('names the held-out sink instead of evals.json when held_out', () => {
+    const inb = buildEvalCaseAppliedInbound({
+      ctx: CTX,
+      proposalId: 'p1',
+      skillSlug: 'deploy-checklist',
+      heldOut: true,
+      operatorId: '999',
+    })
+    expect(inb.meta.held_out).toBe('true')
+    expect(inb.text).toContain('held-out sink')
+    expect(inb.text).not.toContain('evals.json')
+  })
+
+  it('carries the forum topic through to threadId and meta', () => {
+    const inb = buildEvalCaseAppliedInbound({
+      ctx: { ...CTX, threadId: 7 },
+      proposalId: 'p1',
+      skillSlug: 's',
+      heldOut: false,
+      operatorId: '999',
+    })
+    expect(inb.threadId).toBe(7)
+    expect(inb.meta.message_thread_id).toBe('7')
+  })
+
+  it('omits threadId/message_thread_id entirely for a DM proposal', () => {
+    const inb = buildEvalCaseAppliedInbound({
+      ctx: CTX,
+      proposalId: 'p1',
+      skillSlug: 's',
+      heldOut: false,
+      operatorId: '999',
+    })
+    expect('threadId' in inb).toBe(false)
+    expect('message_thread_id' in inb.meta).toBe(false)
+  })
+})
+
+describe('buildEvalCaseRejectedInbound', () => {
+  it('pins source and tells the agent nothing was written', () => {
+    const inb = buildEvalCaseRejectedInbound({
+      ctx: CTX,
+      proposalId: 'p2',
+      skillSlug: 'deploy-checklist',
+      heldOut: false,
+      operatorId: '999',
+      nowMs: 2000,
+    })
+    expect(inb.meta.source).toBe('eval_case_rejected')
+    expect(inb.meta.proposal_id).toBe('p2')
+    expect(inb.user).toBe('self-improve')
+    expect(inb.text).toContain('NOTHING was written')
+    expect(inb.text).toContain('Do NOT re-propose')
+  })
+})
+
+describe('buildEvalCaseApplyFailedInbound', () => {
+  it('pins source and refuses to let the agent assume the case landed', () => {
+    const inb = buildEvalCaseApplyFailedInbound({
+      ctx: CTX,
+      proposalId: 'p3',
+      skillSlug: 'deploy-checklist',
+      heldOut: false,
+      operatorId: '999',
+      applyOut: 'ENOENT: skill dir missing',
+      nowMs: 3000,
+    })
+    expect(inb.meta.source).toBe('eval_case_apply_failed')
+    expect(inb.meta.proposal_id).toBe('p3')
+    expect(inb.text).toContain('was NOT')
+    expect(inb.text).toContain('do NOT assume')
+    expect(inb.text).toContain('ENOENT: skill dir missing')
+  })
+
+  it('truncates a runaway applier dump so it cannot dominate the woken turn', () => {
+    const inb = buildEvalCaseApplyFailedInbound({
+      ctx: CTX,
+      proposalId: 'p3',
+      skillSlug: 's',
+      heldOut: false,
+      operatorId: '999',
+      applyOut: 'x'.repeat(5000),
+    })
+    expect(inb.text).toContain('x'.repeat(500))
+    expect(inb.text).not.toContain('x'.repeat(501))
+  })
+
+  it('says "(no output)" rather than emitting an empty line', () => {
+    const inb = buildEvalCaseApplyFailedInbound({
+      ctx: CTX,
+      proposalId: 'p3',
+      skillSlug: 's',
+      heldOut: false,
+      operatorId: '999',
+      applyOut: '   \n  ',
+    })
+    expect(inb.text).toContain('(no output)')
+  })
+})

package/telegram-plugin/tests/hermes-messages-paging.test.ts

@@ -0,0 +1,149 @@
+/**
+ * `GET /api/sessions/:id/messages` — ordering and pagination, against a REAL
+ * turns DB.
+ *
+ * Separate from `hermes-rest-parity.test.ts` for one reason: that fixture
+ * points `SWITCHROOM_AGENTS_DIR` at an empty tmpdir, so every session has zero
+ * messages and an assertion about ORDER or about which slice came back passes
+ * vacuously there. Ordering and offset windowing are exactly the properties
+ * that need real rows, and the turns DB is `bun:sqlite` — hence a bun test
+ * (vitest excludes it; see vitest.config.ts). It lives under
+ * telegram-plugin/tests/ rather than beside the adapter because that is the only
+ * tree the bun CI job walks — `bun test` runs with cwd telegram-plugin/, so a
+ * root-level src/ bun test is executed by NEITHER runner
+ * (scripts/check-test-runner-coverage.mjs, and the debt list it guards).
+ *
+ * Upstream contract being asserted (`hermes_cli/web_routers/sessions.py:601-651`
+ * at 9da6d455c9e1f2bf74bb9f47766ee9fc52e17bfb):
+ *   - messages come back CHRONOLOGICAL within the page;
+ *   - `order=oldest` windows from the start, `order=latest` from the end;
+ *   - `pagination.returned` is the real row count of that window.
+ *
+ * The bug each case guards, stated so a future edit cannot weaken it into a
+ * code-path check: the adapter read `listTurnsForAgent` (newest-first) and
+ * projected it without reversing, so the transcript arrived backwards; and it
+ * emitted no `pagination`, which `getAllSessionMessages` (hermes.ts:713-750)
+ * reads as "legacy backend, that was everything" and stops paging on.
+ */
+
+import { test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { openTurnsDb } from "../registry/turns-schema.js";
+import { handleHermesRest, type HermesRestResult } from "../../src/web/hermes-adapter.js";
+import type { SwitchroomConfig } from "../../src/config/schema.js";
+
+const AGENT = "alpha";
+let agentsDir = "";
+
+const CONFIG = { agents: { [AGENT]: {} } } as unknown as SwitchroomConfig;
+
+/** Seed `n` completed turns with explicit, strictly-increasing start times. */
+function seedTurns(n: number) {
+  const dir = join(agentsDir, AGENT);
+  mkdirSync(dir, { recursive: true });
+  const db = openTurnsDb(dir);
+  try {
+    for (let i = 0; i < n; i++) {
+      const ts = 1_700_000_000_000 + i * 1000;
+      db.prepare(
+        `INSERT INTO turns
+           (turn_key, chat_id, thread_id, started_at, ended_at, ended_via,
+            user_prompt_preview, assistant_reply_preview, created_at, updated_at)
+         VALUES (?, ?, NULL, ?, ?, 'stop', ?, ?, ?, ?)`,
+      ).run(`t${i}`, "chat", ts, ts + 500, `u${i}`, `a${i}`, ts, ts);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+async function messages(search: string): Promise<Record<string, unknown>> {
+  const res = (await handleHermesRest(
+    "GET",
+    `/api/sessions/${AGENT}/messages`,
+    CONFIG,
+    search,
+  )) as HermesRestResult;
+  expect(res).not.toBeNull();
+  expect(res.status).toBe(200);
+  return res.body as Record<string, unknown>;
+}
+
+function contents(body: Record<string, unknown>): string[] {
+  return (body.messages as { content: string }[]).map((m) => m.content);
+}
+
+beforeEach(() => {
+  agentsDir = mkdtempSync(join(tmpdir(), "sr-hermes-msgs-"));
+  process.env.SWITCHROOM_AGENTS_DIR = agentsDir;
+});
+
+afterEach(() => {
+  rmSync(agentsDir, { recursive: true, force: true });
+});
+
+test("messages are chronological, not the newest-first order the turns DB reads in", async () => {
+  seedTurns(3);
+  const body = await messages("?limit=500&offset=0&order=oldest");
+  // u0/a0 is the OLDEST turn. Before the fix this list started at u2.
+  expect(contents(body)).toEqual(["u0", "a0", "u1", "a1", "u2", "a2"]);
+});
+
+test("order=oldest windows from the start and reports what it returned", async () => {
+  seedTurns(3);
+  const body = await messages("?limit=2&offset=2&order=oldest");
+  expect(contents(body)).toEqual(["u1", "a1"]);
+  expect(body.pagination).toEqual({ limit: 2, offset: 2, order: "oldest", returned: 2 });
+});
+
+test("order=latest windows from the END, still chronological inside the page", async () => {
+  seedTurns(3);
+  const body = await messages("?limit=3&order=latest");
+  expect(contents(body)).toEqual(["a1", "u2", "a2"]);
+  expect(body.pagination).toEqual({ limit: 3, offset: 0, order: "latest", returned: 3 });
+});
+
+test("paging with the desktop's own loop terminates having read every message once", async () => {
+  seedTurns(5); // 10 messages
+  // getAllSessionMessages (hermes.ts:713-750): limit=500, order=oldest, advance
+  // offset by the page length, stop when the page is short of `limit`.
+  const seen: string[] = [];
+  let offset = 0;
+  for (let guard = 0; guard < 10; guard++) {
+    const page = await messages(`?limit=4&offset=${offset}&order=oldest`);
+    const pagination = page.pagination as { limit: number };
+    seen.push(...contents(page));
+    if (contents(page).length === 0 || contents(page).length < pagination.limit) break;
+    offset += contents(page).length;
+  }
+  expect(seen).toEqual(["u0", "a0", "u1", "a1", "u2", "a2", "u3", "a3", "u4", "a4"]);
+});
+
+test("an omitted limit defaults to the latest 500, an explicit one defaults to oldest", async () => {
+  seedTurns(1);
+  expect((await messages("")).pagination).toEqual({
+    limit: 500,
+    offset: 0,
+    order: "latest",
+    returned: 2,
+  });
+  expect((await messages("?limit=10")).pagination).toEqual({
+    limit: 10,
+    offset: 0,
+    order: "oldest",
+    returned: 2,
+  });
+});
+
+test("an unrecognised order is a 400, not a silently-reinterpreted page", async () => {
+  seedTurns(1);
+  const res = await handleHermesRest(
+    "GET",
+    `/api/sessions/${AGENT}/messages`,
+    CONFIG,
+    "?order=sideways",
+  );
+  expect(res?.status).toBe(400);
+});