switchroom 0.15.10 → 0.15.12

package/telegram-plugin/dist/server.js

@@ -24631,6 +24631,29 @@ var init_bridge = __esm(async () => {
         },
         required: ["chat_id", "key"]
       }
+    },
+    {
+      name: "linear_agent_activity",
+      description: 'Emit a structured Linear AgentActivity against an agent session (#2298). Use this ONLY inside a turn that was woken by a Linear agent session (the inbound carries meta.source="linear" and meta.agent_session_id) \u2014 pass that agent_session_id back here. Linear renders activities as status chips + a timeline on the issue, so the human sees acknowledge \u2192 work \u2192 result. Emit a `thought` within ~10s of being woken so the session does not look dead, then `message`(s) as you make progress, and finally exactly one terminal `complete` (work done) or `error` (you could not proceed). body is required for thought/message/error and optional for complete. Resolves the agent\'s Linear app token from the vault; on VAULT-BROKER-DENIED it returns an error instructing you to vault_request_access for `linear/<agent>/token`.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          agent_session_id: {
+            type: "string",
+            description: "The Linear AgentSession id \u2014 copy it verbatim from the woken turn's meta.agent_session_id."
+          },
+          type: {
+            type: "string",
+            enum: ["thought", "message", "complete", "error"],
+            description: "Activity kind. thought = visible reasoning ack (emit within ~10s); message = progress update; complete = terminal success; error = terminal failure."
+          },
+          body: {
+            type: "string",
+            description: "Activity text (Markdown). Required for thought/message/error; optional for complete (a closing summary)."
+          }
+        },
+        required: ["agent_session_id", "type"]
+      }
     }
   ];
   mcp.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_SCHEMAS }));

package/telegram-plugin/gateway/gateway.ts

@@ -139,6 +139,7 @@ import {
   recordReaction, lookupMessageRoleAndText,
   checkpointWal as checkpointHistoryWal,
   pruneMessagesOlderThanDays,
+  hasOutboundDeliveredSince,
 } from '../history.js'
 import {
   runRegistryReaper,
@@ -466,6 +467,7 @@ import {
   listGrantsViaBroker,
   revokeGrantViaBroker,
 } from '../../src/vault/broker/client.js'
+import { emitLinearAgentActivity } from './linear-activity.js'
 import {
   approvalRequest,
   approvalConsume,
@@ -1506,6 +1508,20 @@ const OBLIGATION_BACKGROUND_WORK_GRACE_MS = (() => {
   const n = Number(raw)
   return Number.isFinite(n) && n >= 0 ? n : 20 * 60_000
 })()
+// Per-represent grace window. After a re-present fires, the obligation is
+// ineligible for the next represent/escalate until at least this many ms have
+// elapsed since markRepresented. Without this the 5s sweep can fire again
+// before the re-presented turn even reaches the agent, burning the represent
+// budget and producing back-to-back re-presents or a premature escalation.
+// Default 120s — generous enough for a turn to start + deliver an answer;
+// small enough not to delay genuine unanswered re-presents.
+// Kill switch: SWITCHROOM_OBLIGATION_REPRESENT_GRACE_MS=0 → no per-represent grace.
+const OBLIGATION_REPRESENT_GRACE_MS = (() => {
+  const raw = process.env.SWITCHROOM_OBLIGATION_REPRESENT_GRACE_MS
+  if (raw == null || raw === '') return 120_000
+  const n = Number(raw)
+  return Number.isFinite(n) && n >= 0 ? n : 120_000
+})()
 // Marker-freshness window for the orphaned-foreground signal. The turn-active
 // marker is touched on every foreground tool_use and on foreground sub-agent
 // JSONL growth, so an mtime younger than this means a sub-agent is touching it
@@ -2175,23 +2191,38 @@ function hasDifferentThreadedRecentTurn(
  * PR2 obligation-ledger CLOSE. Called when a SUBSTANTIVE final answer lands
  * (not a bare interim ack — using finalAnswerSubstantive, the #2141 signal): the
  * obligation discharged is the one for the SAME origin the answer routes to
- * (origin_turn_id the model echoed, else the live turn). So 713's reply closes
- * 713's obligation even after currentTurn flipped to 715, and 715 stays open
- * until ITS own substantive answer. An ack does NOT close (so ack-then-ghost is
- * re-presented, not re-dropped). turn.turnId === the obligation's origin id
- * (both deriveTurnId(chat,thread,messageId) of the same inbound). No-op unless
- * the flag is on. NOTE residual: a genuinely SHORT answer (<200 chars, not a
- * stream-done) reads as non-substantive and won't close → a bounded re-ask
- * (≤2) then one operator-visible nudge — the accepted double-ask tradeoff,
- * measured in the canary.
+ * (origin_turn_id the model echoed, else the routed origin the gateway resolved,
+ * else the live turn). So 713's reply closes 713's obligation even after
+ * currentTurn flipped to 715, and 715 stays open until ITS own substantive
+ * answer. Answers to re-presented obligations (via=quoted, no model echo) close
+ * via the gateway-resolved routedOriginTurn. An ack does NOT close (so
+ * ack-then-ghost is re-presented, not re-dropped). The live-turn fallback fires
+ * only for the live turn's OWN obligation (it was the turn delivering this
+ * reply), preserving the 713/715 invariant. No-op unless the flag is on.
+ *
+ * @param routedOriginTurn — the origin the reply router already resolved
+ *   (echoedTurn ?? quotedTurn); pass whenever the TURN_ORIGIN_ROUTING path ran.
+ *   Skipped when null/undefined (pre-routing paths, or DM with no quote).
  */
 function closeObligationOnSubstantiveReply(
   args: Record<string, unknown>,
   liveTurn: CurrentTurn | null | undefined,
+  routedOriginTurn?: CurrentTurn | null,
 ): void {
   if (!OBLIGATION_LEDGER_ENABLED) return
   const echoed = findTurnByOriginId(args.origin_turn_id as string | undefined)
-  const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId)
+  // routedOriginTurn is the gateway-resolved origin (echoedTurn ?? quotedTurn).
+  // Only pass it as routedOriginId when it DIFFERS from the echoed turn (if
+  // echoed is present, resolveCloseTarget's first branch already handles it),
+  // and only when it is NOT the live turn (live-turn is the fallback, not the
+  // routed origin — passing live turn here would bypass the live-turn fallback
+  // logic and still close correctly, but naming matters for the 713/715 case:
+  // the routed origin on a via=quoted reply IS the origin, not "live fallback").
+  const routedOriginId =
+    routedOriginTurn != null && echoed == null
+      ? routedOriginTurn.turnId
+      : null
+  const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId, routedOriginId)
   if (target != null) obligationLedger.close(target)
 }
 
@@ -5414,13 +5445,16 @@ function obligationSweep(): void {
     OBLIGATION_BACKGROUND_WORK_GRACE_MS > 0 && agentHasInFlightBackgroundWork(now)
   // Grace window: skip an obligation whose handling turn ended < grace ago — its
   // trailing slow/worker answer may still be landing (over-escalation fix).
+  // Per-represent grace: skip an obligation re-presented < grace ago — prevents
+  // the 5s sweep from immediately firing again before the re-present even lands.
   const decision = obligationLedger.decideAtIdle(
-    OBLIGATION_ESCALATE_GRACE_MS > 0 || backgroundWorkActive
+    OBLIGATION_ESCALATE_GRACE_MS > 0 || backgroundWorkActive || OBLIGATION_REPRESENT_GRACE_MS > 0
       ? {
           now,
           graceMs: OBLIGATION_ESCALATE_GRACE_MS,
           backgroundWorkActive,
           backgroundGraceMs: OBLIGATION_BACKGROUND_WORK_GRACE_MS,
+          representGraceMs: OBLIGATION_REPRESENT_GRACE_MS,
         }
       : undefined,
   )
@@ -5449,8 +5483,22 @@ function obligationSweep(): void {
     )
     return
   }
-  // escalate — re-present ladder exhausted. Send ONE operator-visible nudge and
-  // close the obligation ONLY AFTER it actually lands. This inverts the old
+  // escalate — re-present ladder exhausted. Before sending the user-visible
+  // apology, check whether the agent has ALREADY delivered an outbound reply
+  // to this chat since the obligation was opened. If yes, the obligation is
+  // stale (the agent did answer, just without closing the obligation via the
+  // normal close path) — close silently instead of alarming the user with a
+  // false "I may have missed this". This is Fix 4: escalate only on knowledge,
+  // not doubt. Fall back to false (safe: never suppresses) if history unavailable.
+  if (HISTORY_ENABLED && hasOutboundDeliveredSince(o.chatId, o.openedAt, o.threadId)) {
+    process.stderr.write(
+      `telegram gateway: obligation closed silently — outbound delivered since open origin=${o.originTurnId}\n`,
+    )
+    obligationLedger.close(o.originTurnId)
+    return
+  }
+  // Proceed with escalation: send ONE operator-visible nudge and close the
+  // obligation ONLY AFTER it actually lands. This inverts the old
   // close-before-send (which silently dropped the terminal whenever the send
   // failed): the close is now itself an observable terminal. A transient send
   // failure leaves the obligation OPEN → retried next sweep; a PERMANENT one
@@ -6671,6 +6719,7 @@ const ALLOWED_TOOLS = new Set([
   'vault_request_save',
   'vault_request_access',
   'request_secret',
+  'linear_agent_activity',
 ])
 
 async function executeToolCall(tool: string, args: Record<string, unknown>): Promise<unknown> {
@@ -6716,6 +6765,8 @@ async function executeToolCall(tool: string, args: Record<string, unknown>): Pro
       return executeVaultRequestAccess(args)
     case 'request_secret':
       return executeRequestSecret(args)
+    case 'linear_agent_activity':
+      return executeLinearAgentActivity(args)
     default:
       throw new Error(`unknown tool: ${tool}`)
   }
@@ -6747,6 +6798,10 @@ async function executeSendChecklist(args: Record<string, unknown>): Promise<{ co
   return { content: [{ type: 'text', text: `checklist sent (id: ${sent.message_id})` }] }
 }
 
+async function executeLinearAgentActivity(args: Record<string, unknown>): Promise<{ content: Array<{ type: string; text: string }> }> {
+  return emitLinearAgentActivity(args)
+}
+
 async function executeUpdateChecklist(args: Record<string, unknown>): Promise<{ content: Array<{ type: string; text: string }> }> {
   const chat_id = args.chat_id as string
   if (!chat_id) throw new Error('update_checklist: chat_id is required')
@@ -6970,6 +7025,10 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // heuristic is what mis-routed a late reply to whichever topic most
   // recently received a message. DM: every tier is undefined → unchanged.
   // Kill switch off → exact legacy resolveThreadId precedence.
+  // Hoist the resolved origin turn so the obligation-close path (below) can
+  // pass it into resolveCloseTarget as routedOriginId, closing re-presented
+  // obligations even when the model omitted origin_turn_id (Fix 1/2).
+  let replyRoutedOriginTurn: CurrentTurn | null = null
   let threadId: number | undefined
   if (TURN_ORIGIN_ROUTING_ENABLED) {
     const explicit = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
@@ -6979,6 +7038,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
     const echoedTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
     const quotedTurn = echoedTurn == null ? findTurnByQuotedMessageId(chat_id, args.reply_to) : null
     const originTurn = echoedTurn ?? quotedTurn
+    replyRoutedOriginTurn = originTurn ?? null
     threadId = resolveAnswerThreadWithLog(
       chat_id,
       Number.isFinite(explicit as number) ? (explicit as number) : undefined,
@@ -7220,7 +7280,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
               text: decision.mergedText,
               disableNotification,
             })
-            if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn)
+            if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn, replyRoutedOriginTurn)
           }
           outboundDedup.record(
             chat_id,
@@ -7573,7 +7633,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
       finalizeStatusReaction(chat_id, threadId, 'done')
       // PR2: close this origin's obligation on a SUBSTANTIVE final answer
       // (after finalize so the reaction guard test's anchor window is stable).
-      if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn)
+      if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn, replyRoutedOriginTurn)
     }
     // v0.13.30 follow-up — release the buffer gate on EVERY reply
     // finalize, not just on `isFinalAnswerReply`. The narrow
@@ -7633,20 +7693,36 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
   // topic and a late stream-reply can't be stolen by a successor turn. DM:
   // every tier undefined → unchanged. Kill switch off → legacy live-turn
   // injection only.
+  // Origin resolution is hoisted UNCONDITIONALLY (outside the
+  // message_thread_id==null guard below) so the obligation-close path has
+  // the correct routedOriginTurn even when the model explicitly passes
+  // message_thread_id (forum-topic streams). Without this hoist, Fix 1
+  // is a no-op for forum-topic streams — the origin is never resolved and
+  // closeObligationOnSubstantiveReply falls through to the live-turn
+  // fallback. Matches executeReply's unconditional resolution. Thread
+  // injection still stays scoped to the message_thread_id==null branch —
+  // only the obligation-close input changes.
+  let streamRoutedOriginTurn: CurrentTurn | null = null
+  // Track whether the origin was found via echo (for the routing log below).
+  let streamOriginVia: 'echo' | 'quoted' | null = null
+  if (TURN_ORIGIN_ROUTING_ENABLED) {
+    // Origin precedence: model echo first, then the framework-owned quoted
+    // message_id as a deterministic fallback (mirrors executeReply).
+    const echoedTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
+    const quotedTurn =
+      echoedTurn == null ? findTurnByQuotedMessageId(String(args.chat_id), args.reply_to) : null
+    const originTurn = echoedTurn ?? quotedTurn
+    streamRoutedOriginTurn = originTurn ?? null
+    streamOriginVia = originTurn == null ? null : echoedTurn != null ? 'echo' : 'quoted'
+  }
   if (args.message_thread_id == null) {
     let injected: number | undefined
     if (TURN_ORIGIN_ROUTING_ENABLED) {
-      // Origin precedence: model echo first, then the framework-owned quoted
-      // message_id as a deterministic fallback (mirrors executeReply).
-      const echoedTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
-      const quotedTurn =
-        echoedTurn == null ? findTurnByQuotedMessageId(String(args.chat_id), args.reply_to) : null
-      const originTurn = echoedTurn ?? quotedTurn
       injected = resolveAnswerThreadWithLog(
         String(args.chat_id),
         undefined,
-        originTurn,
-        originTurn == null ? null : echoedTurn != null ? 'echo' : 'quoted',
+        streamRoutedOriginTurn,
+        streamOriginVia,
         turn,
         'stream_reply',
       )
@@ -7925,7 +8001,7 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
       disableNotification: args.disable_notification === true,
       done: args.done === true,
     })
-    if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn)
+    if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn, streamRoutedOriginTurn)
     // #1744 follow-up — stream_reply edge case. The first-emit gate at
     // L5178 only clears silent-end state on the FIRST emit of a stream.
     // If a stream's first emit was ack-shaped (disable_notification:true,

package/telegram-plugin/gateway/linear-activity.ts

@@ -0,0 +1,160 @@
+/**
+ * Linear AgentActivity emission (#2298).
+ *
+ * The `linear_agent_activity` MCP tool lets an agent that was woken by a
+ * Linear agent session respond with structured activities (thought /
+ * message / complete / error) that Linear renders as status chips + a
+ * timeline on the issue. This module owns the pure logic — token
+ * resolution + the `agentActivityCreate` GraphQL POST — behind injectable
+ * deps so it is testable without a vault broker or the network. The
+ * gateway wires it into `executeToolCall`.
+ *
+ * The agent's Linear app token is resolved from the vault under
+ * `linear/<agent>/token` via the broker (never an inline literal, never an
+ * env file). On a vault denial the tool returns actionable text telling the
+ * agent to `vault_request_access` for that key rather than failing opaquely.
+ */
+
+import {
+  getViaBrokerStructured,
+  readVaultTokenFile,
+} from '../../src/vault/broker/client.js'
+
+export const LINEAR_GRAPHQL_ENDPOINT = 'https://api.linear.app/graphql'
+
+export type LinearTokenResult =
+  | { ok: true; token: string }
+  | { ok: false; reason: 'denied' | 'unreachable' | 'not_found' | 'unknown' }
+
+export interface LinearActivityDeps {
+  /** Resolve the Linear app token for `agent` from the vault. */
+  resolveToken?: (agent: string) => Promise<LinearTokenResult>
+  /** Injectable fetch (tests). */
+  fetchImpl?: typeof fetch
+  /** Agent slug (defaults to SWITCHROOM_AGENT_NAME). */
+  agent?: string
+  /** Log sink — stderr in production. */
+  log?: (line: string) => void
+}
+
+export type ToolTextResult = { content: Array<{ type: string; text: string }> }
+
+/** Default token resolver: vault broker get on `linear/<agent>/token`. */
+export async function defaultResolveLinearToken(agent: string): Promise<LinearTokenResult> {
+  const key = `linear/${agent}/token`
+  const token = readVaultTokenFile(agent) ?? undefined
+  const result = await getViaBrokerStructured(key, token ? { token } : {})
+  if (result.kind === 'ok' && result.entry.kind === 'string') {
+    return { ok: true, token: result.entry.value }
+  }
+  if (result.kind === 'unreachable') return { ok: false, reason: 'unreachable' }
+  if (result.kind === 'not_found') return { ok: false, reason: 'not_found' }
+  if (result.kind === 'denied') return { ok: false, reason: 'denied' }
+  return { ok: false, reason: 'unknown' }
+}
+
+/**
+ * Emit a Linear AgentActivity. Validates args, resolves the token, POSTs
+ * the `agentActivityCreate` mutation, and returns an MCP text result. Never
+ * throws on a vault/network failure — returns actionable error text so the
+ * agent can recover (e.g. via vault_request_access).
+ */
+export async function emitLinearAgentActivity(
+  args: Record<string, unknown>,
+  deps: LinearActivityDeps = {},
+): Promise<ToolTextResult> {
+  const log = deps.log ?? ((s) => process.stderr.write(s))
+
+  const sessionId = args.agent_session_id as string | undefined
+  if (!sessionId) throw new Error('linear_agent_activity: agent_session_id is required')
+  const type = args.type as string | undefined
+  if (!type || !['thought', 'message', 'complete', 'error'].includes(type)) {
+    throw new Error('linear_agent_activity: type must be one of thought|message|complete|error')
+  }
+  const body = args.body as string | undefined
+  if (type !== 'complete' && (body == null || body === '')) {
+    throw new Error(`linear_agent_activity: body is required for type='${type}'`)
+  }
+
+  const agent = deps.agent ?? process.env.SWITCHROOM_AGENT_NAME ?? '-'
+  const resolveToken = deps.resolveToken ?? defaultResolveLinearToken
+  const tokenResult = await resolveToken(agent)
+  if (!tokenResult.ok) {
+    if (tokenResult.reason === 'denied' || tokenResult.reason === 'not_found') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text:
+              `linear_agent_activity failed: no Linear token (vault ${tokenResult.reason}). ` +
+              `Call vault_request_access for key 'linear/${agent}/token' (scope read), then retry.`,
+          },
+        ],
+      }
+    }
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `linear_agent_activity failed: vault broker ${tokenResult.reason} resolving 'linear/${agent}/token'.`,
+        },
+      ],
+    }
+  }
+
+  // AgentActivity content discriminated by type. thought/message/error carry
+  // a body; complete is terminal with an optional summary body.
+  const content: Record<string, unknown> = { type }
+  if (body != null && body !== '') content.body = body
+
+  const mutation =
+    'mutation AgentActivityCreate($input: AgentActivityCreateInput!) { ' +
+    'agentActivityCreate(input: $input) { success agentActivity { id } } }'
+  const variables = { input: { agentSessionId: sessionId, content } }
+
+  const fetchImpl = deps.fetchImpl ?? fetch
+  let resp: Response
+  try {
+    resp = await fetchImpl(LINEAR_GRAPHQL_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: tokenResult.token,
+      },
+      body: JSON.stringify({ query: mutation, variables }),
+    })
+  } catch (err) {
+    return {
+      content: [{ type: 'text', text: `linear_agent_activity failed: request error: ${(err as Error).message}` }],
+    }
+  }
+
+  if (!resp.ok) {
+    const txt = await resp.text().catch(() => '')
+    return {
+      content: [
+        { type: 'text', text: `linear_agent_activity failed: Linear API ${resp.status}${txt ? ` — ${txt.slice(0, 200)}` : ''}` },
+      ],
+    }
+  }
+
+  let json: { data?: { agentActivityCreate?: { success?: boolean } }; errors?: Array<{ message?: string }> }
+  try {
+    json = (await resp.json()) as typeof json
+  } catch {
+    return { content: [{ type: 'text', text: 'linear_agent_activity failed: malformed Linear API response' }] }
+  }
+  if (json.errors && json.errors.length > 0) {
+    return {
+      content: [
+        { type: 'text', text: `linear_agent_activity failed: ${json.errors.map((e) => e.message ?? 'error').join('; ').slice(0, 300)}` },
+      ],
+    }
+  }
+  if (json.data?.agentActivityCreate?.success === false) {
+    return { content: [{ type: 'text', text: 'linear_agent_activity failed: Linear reported success=false' }] }
+  }
+
+  log(`telegram gateway: linear_agent_activity: emitted type=${type} session=${sessionId} agent=${agent}\n`)
+  return { content: [{ type: 'text', text: `Linear ${type} emitted on session ${sessionId}` }] }
+}

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

@@ -33,12 +33,20 @@ import {
 } from '../../src/agents/model-picker.js'
 
 /**
- * Aliases the claude CLI resolves natively. Listed in help text only —
- * the handler does NOT restrict to these (a full model id like
- * `claude-opus-4-8` passes through and claude itself validates it, so
- * new aliases/models work without a switchroom release).
+ * Aliases the claude CLI resolves natively (`claude --help`: "an alias for
+ * the latest model (e.g. 'fable', 'opus', or 'sonnet')"). Listed in help
+ * text only — the handler does NOT restrict to these (a full model id like
+ * `claude-opus-4-8` passes through and claude itself validates it, so new
+ * aliases/models work without a switchroom release).
+ *
+ * `fable` is the latest flagship (Fable 5) — kept selectable here on
+ * purpose. NB the alias is NOT the full codename: `claude-fable-5` (a
+ * pinned pre-launch id) was retired server-side and 4xx'd the whole fleet
+ * on 2026-06-13, while the `fable` alias keeps resolving to the current
+ * model. Aliases are the durable way to pick a model — see the model
+ * regression tests.
  */
-export const MODEL_ALIASES = ['opus', 'sonnet', 'haiku', 'default'] as const
+export const MODEL_ALIASES = ['opus', 'sonnet', 'haiku', 'fable', 'default'] as const
 
 /**
  * Shape gate for the model argument. This string is typed literally

package/telegram-plugin/gateway/obligation-ledger.ts

@@ -55,6 +55,12 @@ export interface Obligation {
    *  that re-stamps this once, and representCount is capped, so the ladder still
    *  terminates. Durable (part of the snapshot) so the grace survives restart. */
   lastTurnEndedAt?: number
+  /** Wall-clock ms this obligation was most recently re-presented. Drives the
+   *  per-represent grace: a freshly re-presented obligation is skipped until
+   *  at least `representGraceMs` has elapsed, preventing immediate second
+   *  re-present/escalate when the sweep fires < 5s later. Durable (part of the
+   *  snapshot) so the grace window survives a restart. */
+  lastRepresentedAt?: number
 }
 
 /** What the gateway should do for the oldest open obligation at an idle boundary. */
@@ -202,20 +208,30 @@ export class ObligationLedger {
    * pathologically-stuck/leaked worker cannot suppress the escalation forever —
    * once openedAt+backgroundGraceMs passes, the obligation is acted on regardless
    * of work state, and the FSM still terminates.
+   *
+   * PER-REPRESENT GRACE (opts.representGraceMs > 0): an obligation that was just
+   * re-presented is ineligible until at least `representGraceMs` ms have elapsed
+   * since `lastRepresentedAt`. Without this, the 5s sweep can fire again before
+   * the re-presented turn even reaches the agent, burning the represent budget
+   * immediately and producing back-to-back escalations on the same message.
    */
   decideAtIdle(opts?: {
     now: number
     graceMs: number
     backgroundWorkActive?: boolean
     backgroundGraceMs?: number
+    representGraceMs?: number
   }): LedgerDecision {
-    const useEligible = opts != null && (opts.graceMs > 0 || opts.backgroundWorkActive === true)
+    const useEligible =
+      opts != null &&
+      (opts.graceMs > 0 || opts.backgroundWorkActive === true || (opts.representGraceMs ?? 0) > 0)
     const o = useEligible
       ? this.oldestEligible(
           opts!.now,
           opts!.graceMs,
           opts!.backgroundWorkActive === true,
           opts!.backgroundGraceMs ?? 0,
+          opts!.representGraceMs ?? 0,
         )
       : this.oldest()
     if (o === undefined) return { action: 'none' }
@@ -224,24 +240,30 @@ export class ObligationLedger {
   }
 
   /** The oldest open obligation that is currently ELIGIBLE to act on — i.e. NOT
-   *  within either grace window:
+   *  within any grace window:
    *   - trailing-answer grace: its handling turn ended < `graceMs` ago (a queued
    *     obligation with no lastTurnEndedAt can't have a trailing answer, so it is
-   *     always eligible on this axis); AND
+   *     always eligible on this axis);
    *   - background-work grace: when `backgroundWorkActive`, it was opened <
    *     `backgroundGraceMs` ago (genuine in-flight autonomous work — bounded by
-   *     the ceiling so a stale/leaked worker can't suppress escalation forever). */
+   *     the ceiling so a stale/leaked worker can't suppress escalation forever);
+   *   - per-represent grace: it was re-presented < `representGraceMs` ago (prevents
+   *     a 5s sweep tick from immediately firing again on the same obligation before
+   *     the re-presented turn even reaches the agent). */
   private oldestEligible(
     now: number,
     graceMs: number,
     backgroundWorkActive: boolean,
     backgroundGraceMs: number,
+    representGraceMs: number,
   ): Obligation | undefined {
     let best: Obligation | undefined
     for (const o of this.open.values()) {
       if (o.lastTurnEndedAt != null && now - o.lastTurnEndedAt < graceMs) continue // trailing-answer grace
       if (backgroundWorkActive && backgroundGraceMs > 0 && now - o.openedAt < backgroundGraceMs)
         continue // in-flight autonomous work, bounded by the ceiling
+      if (representGraceMs > 0 && o.lastRepresentedAt != null && now - o.lastRepresentedAt < representGraceMs)
+        continue // per-represent grace: sweep fired before re-presented turn landed
       if (best === undefined || o.openedAt < best.openedAt) best = o
     }
     return best
@@ -259,29 +281,48 @@ export class ObligationLedger {
   /**
    * Decide which obligation a substantive reply discharges — DETERMINISTICALLY,
    * holding for any model behavior:
-   *  - `echoedTurnId` (the model echoed origin_turn_id back) → authoritative;
-   *    close exactly that (a no-op via close() if it isn't actually open).
-   *  - else, close the live turn's obligation ONLY when UNAMBIGUOUS — exactly
-   *    one obligation open. With >1 open and no echo we cannot tell which one
-   *    the reply answered; closing the live turn's would silently drop the other
-   *    (713's un-echoed reply landing while currentTurn=715 must NOT close 715).
-   *    So we close nothing → the real target stays open and is re-presented (a
-   *    bounded double-ask), never wrong-closed. Returns the id to close, or null.
+   *
+   *  1. `echoedTurnId` (model echoed origin_turn_id back) → authoritative; close
+   *     exactly that (a no-op via close() if it isn't actually open).
+   *  2. `routedOriginId` (gateway-resolved origin from quote/via=quoted or
+   *     via=live routing) → treat as the definitive target when present; this
+   *     makes answers to re-presented messages close their obligation even when
+   *     no model echo was provided and even with >1 open obligation (the routed
+   *     origin IS the answer's origin — this is deterministic, not a guess).
+   *     The 713/715 invariant still holds: the gateway only passes a routedOriginId
+   *     that it has positively resolved as the reply's origin (quote resolution,
+   *     via=quoted); it never passes the LIVE turn id here when a different
+   *     obligation is the resolved origin.
+   *  3. else, close the live turn's own obligation when that turn itself is open —
+   *     this is unambiguous (the reply happened IN that turn, so the turn's own
+   *     obligation IS the right target). The 713/715 wrong-close protection is
+   *     preserved by ordering: routed/echoed origin (steps 1/2) wins first;
+   *     live-turn fallback (step 3) only fires when no routed origin resolved, AND
+   *     only for the live turn's OWN obligation (not another open obligation). A
+   *     reply answering message A landing while currentTurn=B must STILL not close B
+   *     — only steps 1/2 can close A in that case. With multiple open obligations
+   *     and no routed origin, the LIVE turn's own obligation is the safe default
+   *     (relaxed from size==1 which wrongly blocked it when a second message arrived
+   *     meanwhile). Returns the id to close, or null.
    */
   resolveCloseTarget(
     echoedTurnId: string | null | undefined,
     liveTurnId: string | null | undefined,
+    routedOriginId?: string | null,
   ): string | null {
     if (echoedTurnId != null) return echoedTurnId
-    if (liveTurnId != null && this.open.size === 1 && this.open.has(liveTurnId)) return liveTurnId
+    if (routedOriginId != null) return routedOriginId
+    if (liveTurnId != null && this.open.has(liveTurnId)) return liveTurnId
     return null
   }
 
-  /** Record that an obligation was just re-presented (bumps representCount). */
-  markRepresented(originTurnId: string): number {
+  /** Record that an obligation was just re-presented (bumps representCount, stamps
+   *  lastRepresentedAt for the per-represent grace window). */
+  markRepresented(originTurnId: string, now = Date.now()): number {
     const o = this.open.get(originTurnId)
     if (o === undefined) return 0
     o.representCount += 1
+    o.lastRepresentedAt = now
     this.persist()
     return o.representCount
   }