switchroom 0.20.9 → 0.20.11

package/telegram-plugin/tests/narrative-lane-golden.test.ts

@@ -368,6 +368,103 @@ describe('narrative-lane golden — silent-sentinel card suppression (#4348)', (
   })
 })
 
+// ── #45 — HOLLOW activity card is SUPPRESSED (deleted, not finalized) ──────────
+// A turn injected into the session (typically a duplicate sub-agent handback
+// beat) adopts a per-turn activity card at turn START, then ends having done
+// ZERO surfaced tool work, never calling reply, delivering no final answer, and
+// emitting no captured/reply text. The card was posted but never got content —
+// the contentless `🤖 Agent · done · 0 tools · Ns` record. The #4348 sentinel
+// gate can't catch it (no NO_REPLY/HEARTBEAT_OK text to match), so the hollow
+// gate must DELETE it. A turn with ANY real content keeps its card.
+describe('narrative-lane golden — hollow-ghost card suppression (#45)', () => {
+  // Same open-then-stamp shape as the #4348 suite: open the feed card on a
+  // fresh (working) turn, then set the turn's terminal outcome and clear.
+  async function openThenClear(over: Partial<CurrentTurn>) {
+    const { lane, calls } = makeLane()
+    const turn = makeLaneTurn(lane)
+    lane.showNarrativeStep(turn, 'Doing the work now')
+    await turn.activityInFlight
+    const cardId = turn.activityMessageId
+    expect(cardId).not.toBeNull()
+    Object.assign(turn, over)
+    lane.clearActivitySummary(turn)
+    await settle()
+    return { calls, cardId, turn }
+  }
+
+  it('genuinely hollow turn (0 tools, no reply, no text, no narration): DELETES the card, no done edit', async () => {
+    // The exact #45 ghost-reply signature Ken reported: a card opened by the
+    // liveness timer that stayed contentless — `mirrorLines` EMPTY. FAILS
+    // pre-fix: clearActivitySummary finalizes a contentless `done · 0 tools`
+    // card with an editMessageText instead of deleting it.
+    //
+    // `mirrorLines: []` is set explicitly: `openThenClear` opens the card via
+    // `showNarrativeStep`, which pushes a line into `mirrorLines`; resetting it
+    // to empty here isolates Ken's real signature (card open via the timer, no
+    // surfaced narration) from the narration-only case pinned below.
+    const { calls, cardId, turn } = await openThenClear({
+      replyCalled: false,
+      labeledToolCount: 0,
+      mirrorLines: [],
+      capturedText: [],
+      lastReplyText: '',
+      finalAnswerEverDelivered: false,
+    })
+    expect(calls.filter((c) => c.method === 'deleteMessage' && c.message_id === cardId)).toHaveLength(1)
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId)).toHaveLength(0)
+    // Tracking released so a late render / superseded-prior finalize can't
+    // resurrect the card.
+    expect(turn.activityMessageId).toBeNull()
+  })
+
+  it('a narration-only turn (a rendered mirror line, 0 tools/reply/text) KEEPS its card (edit, no delete)', async () => {
+    // The regression the edit-flood-fuse pin
+    // (activity-drain-fuse-drop-not-failure.test.ts "a terminal card render is
+    // never shed") protects, pinned here in the fix's own suite: a turn that
+    // surfaced a `showNarrativeStep` line the user SAW is legitimate content —
+    // NOT Ken's empty ghost card — so the card must FINALIZE, never be deleted.
+    // `openThenClear` already surfaced "Doing the work now" into `mirrorLines`;
+    // we deliberately do NOT reset it, so the hollow gate must keep the card.
+    const { calls, cardId } = await openThenClear({
+      replyCalled: false,
+      labeledToolCount: 0,
+      capturedText: [],
+      lastReplyText: '',
+      finalAnswerEverDelivered: false,
+    })
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId).length)
+      .toBeGreaterThanOrEqual(1)
+    expect(calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+  })
+
+  it('a turn that did surfaced tool work is NOT hollow — its card FINALIZES (edit, no delete)', async () => {
+    // The guarantee the fix must not break: a card carrying a real `✓ N steps`
+    // body stays as a record even when the turn never replied.
+    const { calls, cardId } = await openThenClear({
+      replyCalled: false,
+      labeledToolCount: 3,
+      capturedText: [],
+      lastReplyText: '',
+      finalAnswerEverDelivered: false,
+    })
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId).length)
+      .toBeGreaterThanOrEqual(1)
+    expect(calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+  })
+
+  it('a turn that delivered a final answer keeps its card (edit, no delete)', async () => {
+    const { calls, cardId } = await openThenClear({
+      replyCalled: true,
+      labeledToolCount: 0,
+      lastReplyText: 'The three services are all green.',
+      finalAnswerEverDelivered: true,
+    })
+    expect(calls.filter((c) => c.method === 'editMessageText' && c.message_id === cardId).length)
+      .toBeGreaterThanOrEqual(1)
+    expect(calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+  })
+})
+
 // ── THREE-MODULE cross-surface dedup (Amendment 1) ────────────────────────
 // The REAL P4-A handleSessionEvent turn-flush, with the REAL P4-B lane wired
 // into its deps, records the delivered answer into ONE OutboundDedupCache;

package/telegram-plugin/tests/privacy-reset-call-sites.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Call-site pin for the gateway-owned session-start privacy reset (PR3).
+ *
+ * The whole point of PR3 (FIX 2 / FIX 3) is that the reset fires on GENUINE new
+ * sessions and is EXEMPT on paths that reattach to a persisting session. That
+ * is a wiring invariant, not a behavior a unit test on the module can observe —
+ * so this test parses gateway.ts and asserts WHERE `resetPrivacyForNewSession`
+ * is (and is not) called, the same source-parsing approach as
+ * `gateway-handler-registration-wiring.test.ts`.
+ *
+ * Instrumented (must call resetPrivacyForNewSession):
+ *   - the `'boot'` boot-card branch (cold start / crash / planned restart)
+ *   - the `bot.command('clear')` handler
+ *   - the idle-clear dispatch (`maybeIdleClear`)
+ *
+ * Exempt by construction (must NOT call it):
+ *   - `bridge-reconnect` (reattaches to a persisting session)
+ *   - `bot.command('compact')` and resume/continue
+ *
+ * Run: npx vitest run telegram-plugin/tests/privacy-reset-call-sites.test.ts
+ */
+
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+import ts from 'typescript'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const GATEWAY_PATH = resolve(__dirname, '..', 'gateway', 'gateway.ts')
+const GATEWAY_SRC = readFileSync(GATEWAY_PATH, 'utf8')
+const RESET = 'resetPrivacyForNewSession'
+
+const sourceFile = ts.createSourceFile(
+  GATEWAY_PATH,
+  GATEWAY_SRC,
+  ts.ScriptTarget.Latest,
+  true,
+  ts.ScriptKind.TS,
+)
+
+/** Line number (1-based) of every CALL to `resetPrivacyForNewSession(...)`. */
+function resetCallLines(): number[] {
+  const lines: number[] = []
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === RESET
+    ) {
+      lines.push(sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1)
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(sourceFile)
+  return lines.sort((a, b) => a - b)
+}
+
+/** The enclosing function/arrow name for a source line, best-effort. */
+function enclosingContext(line: number): string {
+  const idx = line - 1
+  // Walk upward for the nearest recognizable anchor.
+  const lines = GATEWAY_SRC.split('\n')
+  for (let i = idx; i >= 0 && i > idx - 200; i--) {
+    const t = lines[i]
+    if (/bot\.command\('clear'/.test(t)) return 'command:clear'
+    if (/function maybeIdleClear/.test(t)) return 'maybeIdleClear'
+    if (/resolveBootChatId\(marker, markerAgeMs\)/.test(t)) return 'boot'
+  }
+  return 'unknown'
+}
+
+describe('privacy reset call sites (PR3 FIX 2 / FIX 3)', () => {
+  it('calls resetPrivacyForNewSession exactly THREE times', () => {
+    expect(resetCallLines()).toHaveLength(3)
+  })
+
+  it('the three calls are the boot branch, the /clear handler, and idle-clear', () => {
+    const contexts = resetCallLines().map(enclosingContext).sort()
+    expect(contexts).toEqual(['boot', 'command:clear', 'maybeIdleClear'])
+  })
+
+  it('the boot reset is GUARDED against a --continue transcript-restore (MAJOR fix)', () => {
+    // The boot-branch call must be gated by !isContinueRestoreBoot(...) so a
+    // continue/auto restart that replays the SAME transcript does NOT flip
+    // privacy to public. The /clear + idle calls are always genuine new
+    // sessions and must NOT carry the guard.
+    const lines = GATEWAY_SRC.split('\n')
+    const bootLine = resetCallLines().find(l => enclosingContext(l) === 'boot')
+    expect(bootLine).toBeDefined()
+    expect(lines[bootLine! - 1]).toContain('isContinueRestoreBoot')
+    for (const l of resetCallLines()) {
+      if (enclosingContext(l) === 'boot') continue
+      expect(lines[l - 1]).not.toContain('isContinueRestoreBoot')
+    }
+  })
+
+  it('is NOT wired into the bridge-reconnect boot-card path', () => {
+    // Scope tightly to the bridge-reconnect block: from its dedupe tag to the
+    // `startBootCard(` it posts. The boot-path reset sits right before ITS
+    // startBootCard, so if the reconnect path were (wrongly) instrumented the
+    // reset would land in this same window. It must not.
+    const reconnectIdx = GATEWAY_SRC.indexOf("shouldSkipDuplicateBootCard({ activeBootCard, bootCardPending }, 'bridge-reconnect')")
+    expect(reconnectIdx).toBeGreaterThan(-1)
+    const reconnectBootCard = GATEWAY_SRC.indexOf('startBootCard(', reconnectIdx)
+    expect(reconnectBootCard).toBeGreaterThan(reconnectIdx)
+    const window = GATEWAY_SRC.slice(reconnectIdx, reconnectBootCard)
+    expect(window.includes(RESET)).toBe(false)
+  })
+
+  it("is NOT wired into the /compact handler", () => {
+    const compactIdx = GATEWAY_SRC.indexOf("bot.command('compact'")
+    const clearIdx = GATEWAY_SRC.indexOf("bot.command('clear'")
+    expect(compactIdx).toBeGreaterThan(-1)
+    expect(clearIdx).toBeGreaterThan(compactIdx)
+    // The compact handler body sits between the compact and clear registrations.
+    const compactBody = GATEWAY_SRC.slice(compactIdx, clearIdx)
+    expect(compactBody.includes(RESET)).toBe(false)
+  })
+})

package/telegram-plugin/tests/status-pin-store.test.ts

@@ -569,6 +569,31 @@ describe("status-pin-store — envelope version compat", () => {
     expect(loadStatusPins(PATH, fs)[0].threadId).toBe(77);
   });
 
+  it("D4: a forum-topic foreground pin threads its topic THROUGH the orchestrator into the persisted row", async () => {
+    // The narrative-lane fix passes `thread` as reconcileStatusPin's 4th arg;
+    // this locks the plumbing beneath it — runStatusPinReconcile → the durable
+    // row — so a forum-topic foreground card orphaned by a crash keeps a
+    // threadId the sweep can aim `unpinAllForumTopicMessages` at. Before the
+    // fix the producer dropped `thread`, landing a threadId-less row here.
+    const { fs } = memFs();
+    const claims = new Map<string, StatusPinClaim>();
+    await runStatusPinReconcile({
+      pinKey: "fg:-100123:9",
+      chatId: "-100123",
+      threadId: 9,
+      prev: null,
+      desired: { pinned: true, messageId: 715 },
+      persist: { path: PATH, fs },
+      runPin: async (action) =>
+        action.kind === "pin" ? { messageId: action.messageId } : null,
+      claims,
+    });
+
+    // The durable row AND the in-memory claim both carry the topic.
+    expect(loadStatusPins(PATH, fs)[0]?.threadId).toBe(9);
+    expect(claims.get("fg:-100123:9")?.threadId).toBe(9);
+  });
+
   it("drops a row with a non-numeric threadId", () => {
     const { fs } = memFs({
       [PATH]: JSON.stringify({

package/telegram-plugin/tests/throttle-tier.test.ts

@@ -427,6 +427,22 @@ describe('renderThrottleEscalationNotice — corroborated-wall announcement', ()
     expect(text).toContain('all blocked')
     expect(text).toContain('/auth add')
   })
+
+  it('strict-pinned caller: null rolledTo renders the riding-it-out variant, NOT all-blocked', () => {
+    // A strict pin (agents.<name>.auth.strict) deliberately does not roll —
+    // the broker reports caller_pinned_strict so this null is not misread as
+    // a fleet-wide exhaustion while the fleet is healthy.
+    const text = renderThrottleEscalationNotice({
+      account: 'work',
+      agent: 'workbot',
+      rolledTo: null,
+      callerPinnedStrict: true,
+    })
+    expect(text).toContain('strictly pinned')
+    expect(text).toContain('fleet is unaffected')
+    expect(text).not.toContain('all blocked')
+    expect(text).not.toContain('/auth add')
+  })
 })
 
 describe('rate_limited escalation card wording (model-unavailable integration)', () => {

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -21,6 +21,7 @@ import {
   isCompositeSilentNoise,
   endsWithSilentMarker,
   isSilentSentinelCardOutcome,
+  isHollowGhostCardOutcome,
   isTurnFlushSafetyEnabled,
   selectFlushDeliveryText,
   FLUSH_SUBSTANTIVE_MIN_CHARS,
@@ -976,3 +977,69 @@ describe('isSilentSentinelCardOutcome (#4348)', () => {
     expect(isSilentSentinelCardOutcome({ ...base })).toBe(false)
   })
 })
+
+describe('isHollowGhostCardOutcome (#45)', () => {
+  const base = {
+    replyCalled: false,
+    labeledToolCount: 0,
+    mirrorLines: [] as string[],
+    capturedText: [] as string[],
+    lastReplyText: '',
+    finalAnswerEverDelivered: false,
+  }
+
+  it('the ghost-reply signature — zero tools, no reply, no text, no narration — IS hollow', () => {
+    // The exact #45 condition the sentinel gate misses (no NO_REPLY text to
+    // match): the card adopted at turn start (liveness timer) never got any
+    // content — mirrorLines empty, no tool, no reply, no text.
+    expect(isHollowGhostCardOutcome({ ...base })).toBe(true)
+  })
+
+  it('a narration-only turn (a rendered mirror line, zero tools/reply/text) is NOT hollow', () => {
+    // The blocker this fix closes: a turn that surfaced a `showNarrativeStep`
+    // ("Doing the work now") but did no labeled tool work, never replied, and
+    // emitted no captured/reply text pushes a line into `mirrorLines`. That is
+    // real content the user saw in the card — the card must be KEPT, not deleted.
+    // This is the exact scenario the pre-existing edit-flood-fuse pin
+    // (activity-drain-fuse-drop-not-failure.test.ts "a terminal card render is
+    // never shed") protects.
+    expect(
+      isHollowGhostCardOutcome({ ...base, mirrorLines: ['Doing the work now'] }),
+    ).toBe(false)
+  })
+
+  it('whitespace-only mirror lines do NOT rescue the card — still hollow', () => {
+    // Symmetric with the capturedText/lastReplyText blank guards: a mirrorLines
+    // array of only blank strings surfaced nothing visible, so it stays hollow.
+    expect(isHollowGhostCardOutcome({ ...base, mirrorLines: ['   ', '\n'] })).toBe(true)
+  })
+
+  it('whitespace-only captured / reply text still counts as hollow', () => {
+    expect(isHollowGhostCardOutcome({ ...base, capturedText: ['   ', '\n'] })).toBe(true)
+    expect(isHollowGhostCardOutcome({ ...base, lastReplyText: '   ' })).toBe(true)
+  })
+
+  it('a delivered final answer keeps the card — never hollow', () => {
+    expect(isHollowGhostCardOutcome({ ...base, finalAnswerEverDelivered: true })).toBe(false)
+  })
+
+  it('any surfaced tool work keeps the card — the ✓ N steps body is real', () => {
+    expect(isHollowGhostCardOutcome({ ...base, labeledToolCount: 1 })).toBe(false)
+  })
+
+  it('a reply-called turn is never hollow (sentinel gate owns dropped sentinels)', () => {
+    expect(isHollowGhostCardOutcome({ ...base, replyCalled: true })).toBe(false)
+  })
+
+  it('captured terminal text keeps the card (not hollow)', () => {
+    expect(
+      isHollowGhostCardOutcome({ ...base, capturedText: ['Here is the answer.'] }),
+    ).toBe(false)
+  })
+
+  it('non-blank last reply text keeps the card (not hollow)', () => {
+    expect(
+      isHollowGhostCardOutcome({ ...base, lastReplyText: 'The three services are green.' }),
+    ).toBe(false)
+  })
+})

package/telegram-plugin/throttle-tier.ts

@@ -367,8 +367,13 @@ export function renderThrottleNotice(opts: {
 export function renderThrottleEscalationNotice(opts: {
   account: string | null
   agent: string
-  /** The account the fleet/agents rolled to; null = every fallback blocked. */
+  /** The account the fleet/agents rolled to; null = every fallback blocked —
+   *  UNLESS `callerPinnedStrict`, where null just means the caller stayed put. */
   rolledTo: string | null
+  /** True when the triggering agent has a strict pin (`auth.strict`): its
+   *  null `rolledTo` is "riding out the wall on its own account", not a
+   *  fleet-wide all-blocked. Absent from pre-flag brokers → false. */
+  callerPinnedStrict?: boolean
 }): string {
   const acct = opts.account ? `\`${escapeMarkdown(opts.account)}\`` : 'the active account'
   const head =
@@ -376,7 +381,11 @@ export function renderThrottleEscalationNotice(opts: {
     `(trigger: **${escapeMarkdown(opts.agent)}**) were corroborated by a live quota probe.`
   const tail = opts.rolledTo
     ? `Marked exhausted and rolled to \`${escapeMarkdown(opts.rolledTo)}\`.`
-    : `Marked exhausted — no fallback account had quota (all blocked). ` +
-      `Use \`/auth add <label>\` to attach another subscription.`
+    : opts.callerPinnedStrict
+      ? `Marked exhausted — **${escapeMarkdown(opts.agent)}** is strictly pinned to ${acct} ` +
+        `(\`auth.strict\`), so it rides out the wall on its own account. ` +
+        `The rest of the fleet is unaffected.`
+      : `Marked exhausted — no fallback account had quota (all blocked). ` +
+        `Use \`/auth add <label>\` to attach another subscription.`
   return `${head}\n${tail}`
 }

package/telegram-plugin/turn-flush-safety.ts

@@ -214,6 +214,103 @@ export function isSilentSentinelCardOutcome(input: SilentSentinelCardInput): boo
   return false
 }
 
+/**
+ * Inputs for {@link isHollowGhostCardOutcome} — the ending-turn fields the
+ * hollow-card gate reads. A strict superset of the silent-sentinel inputs plus
+ * `labeledToolCount` (the deterministic surfaced-tool total). All are already
+ * tracked on the gateway's `CurrentTurn`; passed as a plain struct so the
+ * decision stays a pure, unit-testable core.
+ */
+export interface HollowGhostCardInput {
+  /** True when the model called `reply` / `stream_reply` at least once. */
+  replyCalled: boolean
+  /**
+   * Count of surfaced (non-suppressed) tool steps this turn
+   * (`CurrentTurn.labeledToolCount`) — the same source that drives the card's
+   * `✓ N steps` total and the `tools=` lifecycle field. Zero means the turn did
+   * no surfaced tool work, so the card has no step body to record.
+   */
+  labeledToolCount: number
+  /**
+   * Rendered narrative/mirror lines surfaced into the activity card this turn
+   * (`CurrentTurn.mirrorLines`) — every `showNarrativeStep` appends one via
+   * `appendActivityLabel`. A NON-EMPTY array means the user saw real narration
+   * content in the card (e.g. "Doing the work now"), so the card is a legitimate
+   * record even with zero tool steps and no reply — it is NOT the empty ghost
+   * card. This is the axis that separates Ken's #45 bug (a card opened by the
+   * liveness timer that stayed contentless — `🤖 Agent · done · 0 tools · 40s`,
+   * `mirrorLines` empty) from a narration-only turn (a rendered step, no tool).
+   */
+  mirrorLines: string[]
+  /**
+   * Raw assistant text blocks accumulated across the turn
+   * (`CurrentTurn.capturedText`) — the turn-flush classifies the same source.
+   */
+  capturedText: string[]
+  /**
+   * The most-recent `reply` / `stream_reply` `input.text` this turn
+   * (`CurrentTurn.lastReplyText`); empty when the reply tool was never called.
+   */
+  lastReplyText: string
+  /**
+   * A SUBSTANTIVE final answer reached the user at some point this turn
+   * (`CurrentTurn.finalAnswerEverDelivered`). When true the card is a legitimate
+   * record beside a delivered answer and is NEVER suppressed.
+   */
+  finalAnswerEverDelivered: boolean
+}
+
+/**
+ * Decide whether an ending turn produced a genuinely HOLLOW activity card — the
+ * `#45` ghost-reply condition — so the gateway can DELETE the card instead of
+ * finalizing it to a contentless `🤖 Agent · done · 0 tools · Ns` record.
+ *
+ * The symptom (#45): a turn injected into the session (typically a duplicate
+ * sub-agent handback beat) adopts a per-turn activity card at turn START, then
+ * ends having done ZERO surfaced tool work, never calling reply, delivering no
+ * final answer, and emitting no captured terminal text. The card was already
+ * posted but never gets any content — the gateway already WARNs on this exact
+ * signature (`ghost-reply detected — turn ended with zero outbound messages …
+ * replyCalled=false capturedText=empty`) but does not suppress the empty card.
+ *
+ * This is the complement of {@link isSilentSentinelCardOutcome}: that gate
+ * handles a turn whose outcome was an INTENTIONAL silent sentinel (a NO_REPLY /
+ * HEARTBEAT_OK the model actually emitted, which reaches `lastReplyText` /
+ * `capturedText`). A hollow ghost turn emitted NOTHING at all — no sentinel text
+ * for the sentinel gate to match — so `decideTurnFlush` classifies it as
+ * `empty-text`, not `silent-marker`, and the sentinel gate returns false (see
+ * the `isSilentSentinelCardOutcome` test "a genuinely empty dark turn … is NOT a
+ * sentinel"). Both gates share the same conservative floor.
+ *
+ * Conservative by construction — every guarantee that keeps a real card is an
+ * early false:
+ *   - `finalAnswerEverDelivered` — a substantive answer reached the user; the
+ *     card is a legitimate record.
+ *   - `replyCalled` — the model called reply (even a dropped sentinel-only reply
+ *     is the SENTINEL gate's job, not this one); never treated as hollow here.
+ *   - `labeledToolCount > 0` — the turn did surfaced tool work, so the card
+ *     carries a real `✓ N steps` body worth keeping.
+ *   - any non-blank `mirrorLines` — the turn surfaced narrative content into the
+ *     card that the user saw (a `showNarrativeStep`), so the card is a real
+ *     record, NOT the contentless ghost card. This is the axis that keeps a
+ *     narration-only turn (rendered step, zero tools/reply/text) from being
+ *     mistaken for Ken's empty `done · 0 tools` card, whose `mirrorLines` is
+ *     empty because the card was opened by the liveness timer, not narration.
+ *   - any non-blank `capturedText` / `lastReplyText` — the turn produced terminal
+ *     text; not hollow (and, if it is silent-sentinel noise, the sentinel gate
+ *     already suppresses it).
+ * Only a turn that is empty on ALL of those axes is hollow.
+ */
+export function isHollowGhostCardOutcome(input: HollowGhostCardInput): boolean {
+  if (input.finalAnswerEverDelivered) return false
+  if (input.replyCalled) return false
+  if (input.labeledToolCount > 0) return false
+  if (Array.isArray(input.mirrorLines) && input.mirrorLines.join('').trim().length > 0) return false
+  if (Array.isArray(input.capturedText) && input.capturedText.join('').trim().length > 0) return false
+  if (typeof input.lastReplyText === 'string' && input.lastReplyText.trim().length > 0) return false
+  return true
+}
+
 /**
  * Substantive-answer floor (chars, trimmed). Mirrors
  * `final-answer-detect.ts` `FINAL_ANSWER_MIN_CHARS` and

package/vendor/hindsight-memory/CHANGELOG.md

@@ -54,6 +54,37 @@
 
 ### Changed (switchroom divergence)
 
+- **SessionStart hook runs async so its durability work stops being killed
+  mid-drain** (`hooks/hooks.json`, `scripts/session_start.py`). The hook does
+  the recovery a prior session's abrupt death skipped — drain the
+  SessionEnd-queued retains (#1071) and reconcile un-committed transcript turns
+  (#3244). Those two carry independent 4s wall-clock budgets
+  (`HINDSIGHT_DRAIN_BUDGET_S` / `HINDSIGHT_RECONCILE_BUDGET_S`), each sized in
+  isolation against the old synchronous 5s SessionStart timeout, plus a ~2s
+  Mode-1 external-server health probe. Summed, they routinely overran 5s, so
+  Claude Code SIGKILLed the hook part-way through — truncating exactly the
+  durability work it exists to do and letting the pending-retains backlog grow
+  (fleet transcripts carry 1000+ `hook_cancelled` attachments for
+  `session_start.py`, all `timedOut: true` with `durationMs > 5000`; a
+  successful firing injects no `additionalContext` and so leaves no record,
+  which made the failures look like ~100% of firings when the true rate is
+  unmeasurable from attachments). Setting `"async": true` on the hook (the same
+  non-blocking pattern the Stop-event `retain.py` already uses) detaches it from
+  the SessionStart critical path: it injects no context, so nothing depends on
+  it finishing first and async's dropped context costs nothing. The `timeout`
+  ceiling rises 5s → 30s purely as a background-lifetime bound above the ~10s
+  summed sub-budgets — it never re-introduces a startup block, because drain and
+  reconcile self-cap at their budgets regardless. The drain stays in the hook
+  (not deferred wholly to the `hindsight-drain` sidecar, which `start.sh` only
+  starts conditionally — when it is absent this hook is the sole backlog path)
+  and `reconcile_tail`, which has no sidecar equivalent, stays here and now runs
+  to completion; its over-budget remainder still resumes on the next boot.
+  Concurrent drain with the sidecar stays safe via `drain_pending`'s exclusive
+  `fcntl.flock`. Pinned by `scripts/tests/test_session_start_durability.py`
+  (drain + reconcile are still invoked, in order) and
+  `tests/hindsight-session-start-async.test.ts` (the async flag + budget-clearing
+  ceiling survive the scaffold's hooks-override round-trip).
+
 - **Recall/retain hygiene guard-rail batch** (`scripts/recall.py`,
   `scripts/subagent_retain.py`, `scripts/lib/content.py`, `scripts/tests/**`).
   Closes guard-rail debt in the fork's hook scripts before extending them:

package/vendor/hindsight-memory/hooks/hooks.json

@@ -6,7 +6,8 @@
           {
             "type": "command",
             "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/session_start.py\"",
-            "timeout": 5
+            "async": true,
+            "timeout": 30
           }
         ]
       }