switchroom 0.19.46 → 0.19.47

package/telegram-plugin/dist/gateway/gateway.js

@@ -21547,7 +21547,7 @@ var init_observation_scopes = __esm(() => {
 });
 
 // ../src/config/schema.ts
-var CodeRepoEntrySchema, AgentBindMountSchema, HttpDiffPollSchema, PollSpecSchema, TelegramMessageActionSchema, WebhookActionSchema, ActionSpecSchema, ScheduleEntrySchema, AgentSoulSchema, AgentToolsSchema, ObservationScopesSchema, ObservationScopeStrategySchema, AntiConfabulationDirectiveSchema, AgentMemorySchema, HookEntrySchema, AgentHooksSchema, SubagentSchema, SessionSchema, SessionContinuitySchema, webhookDispatchRule, TelegramChannelSchema, ChannelsSchema, TIMEZONE_REGEX, ApproverIdSchema, GoogleWorkspaceTierSchema, GoogleWorkspaceConfigSchema, LiteLLMConfigSchema, HindsightPerOpLlmSchema, HindsightConfigSchema, MicrosoftWorkspaceConfigSchema, NotionWorkspaceConfigSchema, AgentGoogleWorkspaceConfigSchema, MicrosoftAccountEmailSchema, MicrosoftToolTokenSchema, MicrosoftAccountBindingSchema, AgentMicrosoftWorkspaceConfigSchema, AgentNotionWorkspaceConfigSchema, ReactionsSchema, ReactionDispatchSchema, releaseBlockFields, ReleaseBlock, RootReleaseBlock, NetworkIsolationSchema, servesField, knowsField, profileFields, ProfileSchema, _omitExtends, defaultsFields, AgentDefaultsSchema, AgentSchema, TelegramConfigSchema, MemoryBackendConfigSchema, VaultConfigSchema, QuotaConfigSchema, AutoReleaseCheckSchema, HostControlConfigSchema, WebServiceConfigSchema, FleetHealthConfigSchema, HostdConfigSchema, CronEgressSchema, CronConfigSchema, UserSchema, SwitchroomConfigSchema;
+var CodeRepoEntrySchema, AgentBindMountSchema, HttpDiffPollSchema, PollSpecSchema, TelegramMessageActionSchema, WebhookActionSchema, ActionSpecSchema, ScheduleEntrySchema, AgentSoulSchema, AgentToolsSchema, ObservationScopesSchema, ObservationScopeStrategySchema, AntiConfabulationDirectiveSchema, AgentMemorySchema, HookEntrySchema, AgentHooksSchema, SubagentSchema, SessionSchema, SessionContinuitySchema, webhookDispatchRule, TelegramChannelSchema, ChannelsSchema, TIMEZONE_REGEX, ApproverIdSchema, GoogleWorkspaceTierSchema, GoogleServiceTokenSchema, GoogleWorkspaceConfigSchema, LiteLLMConfigSchema, HindsightPerOpLlmSchema, HindsightConfigSchema, MicrosoftWorkspaceConfigSchema, NotionWorkspaceConfigSchema, AgentGoogleWorkspaceConfigSchema, MicrosoftAccountEmailSchema, MicrosoftToolTokenSchema, MicrosoftAccountBindingSchema, AgentMicrosoftWorkspaceConfigSchema, AgentNotionWorkspaceConfigSchema, ReactionsSchema, ReactionDispatchSchema, releaseBlockFields, ReleaseBlock, RootReleaseBlock, NetworkIsolationSchema, servesField, knowsField, profileFields, ProfileSchema, _omitExtends, defaultsFields, AgentDefaultsSchema, AgentSchema, TelegramConfigSchema, MemoryBackendConfigSchema, VaultConfigSchema, QuotaConfigSchema, AutoReleaseCheckSchema, HostControlConfigSchema, WebServiceConfigSchema, FleetHealthConfigSchema, HostdConfigSchema, CronEgressSchema, CronConfigSchema, UserSchema, SwitchroomConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_observation_scopes();
@@ -21934,11 +21934,18 @@ var init_schema = __esm(() => {
     "extended",
     "complete"
   ]);
+  GoogleServiceTokenSchema = exports_external.enum([
+    "cal",
+    "drive",
+    "docs",
+    "sheets",
+    "slides"
+  ]);
   GoogleWorkspaceConfigSchema = exports_external.object({
     google_client_id: exports_external.string().min(1).describe("Google OAuth client ID (literal string or vault reference e.g. 'vault:google-oauth-client-id')"),
     google_client_secret: exports_external.string().min(1).describe("Google OAuth client secret (literal string or vault reference e.g. 'vault:google-oauth-client-secret')"),
     approvers: exports_external.array(ApproverIdSchema).min(1).describe("Array of numeric Telegram user IDs authorized to approve drive onboarding. " + "At least one must be specified."),
-    tier: GoogleWorkspaceTierSchema.optional().describe("RFC G Phase 1: which upstream MCP tier to expose. " + "core (default) = ~16 tools (Drive+Docs+Sheets+Calendar). " + "extended = ~40 tools (+Slides, Forms, Tasks, Chat). " + "complete = ~60+ tools (+Gmail; not recommended yet \u2014 see RFC G \u00a75).")
+    tier: GoogleWorkspaceTierSchema.optional().describe("RFC G Phase 1: which upstream MCP tier to expose. " + "core (default) = ~16 tools (Drive+Docs+Sheets+Calendar tools; the " + "Calendar tools only authenticate when the account holds the opt-in " + "calendar scope \u2014 no tier mints it). " + "extended = ~40 tools (+Slides, Forms, Tasks, Chat). " + "complete = ~60+ tools (+Gmail; not recommended yet \u2014 see RFC G \u00a75).")
   }).optional();
   LiteLLMConfigSchema = exports_external.object({
     enabled: exports_external.boolean().optional().describe("Opt-in toggle. When true, `switchroom apply` provisions a per-agent " + "LiteLLM virtual key and injects routing env into the container. " + "Default OFF."),
@@ -21971,7 +21978,7 @@ var init_schema = __esm(() => {
       reflect: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `reflect` LLM op (synthesis / mental-model " + "refresh). Emits `HINDSIGHT_API_REFLECT_LLM_*`. Absent \u2192 uses global."),
       consolidation: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `consolidation` LLM op (background memory " + "merge). Emits `HINDSIGHT_API_CONSOLIDATION_LLM_*`. Absent \u2192 global.")
     }).optional().describe("LLM knob for the hindsight container. The flat `provider`/`model` set " + "the global default (backward-compatible); optional `retain`/`reflect`/" + "`consolidation` blocks override individual ops. All fields optional; " + "unset fields fall back to the hard-coded defaults."),
-    env: exports_external.record(exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()])).optional().describe("Operator overrides for switchroom's capability-gated Hindsight " + "performance defaults. Only the keys switchroom actually manages are " + "honoured (`HINDSIGHT_PERF_ENV_KEYS` in " + "src/setup/hindsight-perf-defaults.ts: RERANKER_LOCAL_FP16, " + "RERANKER_LOCAL_BATCH_SIZE, LLM_MAX_CONCURRENT, " + "RETAIN/CONSOLIDATION_LLM_MAX_CONCURRENT, LLM_STRICT_SCHEMA, " + "LLM_MAX_RETRIES, CONSOLIDATION_LLM_PARALLELISM, " + "MAX_OBSERVATIONS_PER_SCOPE, " + "RECALL_MAX_CANDIDATES_PER_SOURCE, LINK_EXPANSION_PER_ENTITY_LIMIT, " + "LINK_EXPANSION_TIMEOUT, LLM_REASONING_EFFORT, " + "RERANKER_LOCAL_BUCKET_BATCHING, RERANKER_MAX_CANDIDATES, " + "RERANKER_LOCAL_MAX_CONCURRENT, RECALL_MAX_CONCURRENT, " + "REFLECT_WALL_TIMEOUT, WORKER_CONSOLIDATION_RESERVED_SLOTS, " + "WORKER_CONSOLIDATION_SLOT_LIMIT, " + "CONSOLIDATION_MAX_MEMORIES_PER_ROUND, GRAPH_SEED_MIN_SIMILARITY, " + "LLM_SUPPORTS_MAX_ITEMS, RECENCY_DECAY_FUNCTION, " + "RECENCY_DECAY_HALFLIFE_DAYS \u2014 switchroom defaults recall's recency " + "curve to `exponential` with a 30-day half-life so a fact retained " + "today outranks a stale one, instead of upstream's near-flat " + "linear/365-day window), the override-only keys " + "switchroom manages but ships NO default for " + "(`HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS`: " + "HINDSIGHT_API_WORKER_CONSOLIDATION_BANK_PRIORITY \u2014 a per-deployment " + "`bank-pattern:priority,...` map; unset means upstream's flat " + "created_at FIFO across banks; and " + "HINDSIGHT_CE_DECISIVE_RELATIVE_GAP \u2014 the rollback knob for " + "switchroom's CE-saturation damping patch, a float; >= ~0.65 backs the " + "damping out entirely, unset means the patch's own derived gap; and " + "HINDSIGHT_API_RECENCY_DECAY_LINEAR_WINDOW_DAYS \u2014 only read when the " + "decay function is `linear`, so switchroom ships no default for it but " + "still honours an operator who flips the function back; and " + "HINDSIGHT_API_WORKER_MAX_SLOTS \u2014 the worker poller's TOTAL in-flight " + "task budget, the pool WORKER_CONSOLIDATION_RESERVED_SLOTS reserves out of; " + "unset means upstream's own default; and " + "HINDSIGHT_API_WORKER_RETAIN_RESERVED_SLOTS \u2014 the reserved slot FLOOR for the " + "retain (memory write) lane, carved from that same total; unset means " + "upstream's own 0, i.e. no floor and retain competes for the shared " + "pool; and " + "the pre-0.8.6 name HINDSIGHT_API_WORKER_<TYPE>_MAX_SLOTS is still " + "accepted for every operation type and normalised to " + "..._RESERVED_SLOTS on the way in, because setting both names for " + "one type is a hard boot failure in the engine and switchroom " + "therefore emits only the canonical name; and " + "HINDSIGHT_API_SEMANTIC_MIN_SIMILARITY \u2014 the cosine-similarity floor a " + "candidate must reach to be returned by the semantic retrieval arm at " + "all (0..1); unset means upstream's own 0.3, and where it should sit " + "depends on the bank's embedding model and phrasing diversity, so " + "switchroom ships no opinion; and " + "HINDSIGHT_MCP_RECALL_BUDGET_MODE \u2014 the rollback knob for switchroom's " + "mcp-recall-token-budget image patch; `legacy` restores upstream's " + "exact pre-patch recall returns, anything else or unset is the " + "honest-envelope mode; and " + "HINDSIGHT_API_LLM_TEMPERATURE_REFLECT \u2014 upstream's own per-op reflect " + "temperature knob, made live by switchroom's reflect-temperature image " + "patch; a float, or `none` to omit the kwarg (provider default, " + "upstream's accidental pre-patch behaviour); unset means the image's " + "baked default 0.1; and " + "HINDSIGHT_API_CONSOLIDATION_RECALL_MAX_CONCURRENT \u2014 the background " + "half of switchroom's recall-admission split (#3660): of the " + "RECALL_MAX_CONCURRENT admission slots, at most this many may be held " + "by background consolidation recalls at once, so foreground per-turn " + "recall always keeps the remainder; must be >= 1 and strictly less " + "than RECALL_MAX_CONCURRENT or the engine refuses to boot; unset " + "means the image's derived default min(2, RECALL_MAX_CONCURRENT - 1); " + "1 biases hard toward the interactive lane while a consolidation " + "backlog drains), plus the " + "embedded-PostgreSQL (pg0) sizing keys switchroom manages in " + "src/setup/hindsight-pg-defaults.ts (`HINDSIGHT_PG_ENV_KEYS`: " + "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE, " + "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS \u2014 a postgres size string such " + "as `4GB`, or the sentinel `off` to leave pg0's own default for that " + "one knob). A value set here " + "REPLACES switchroom's default and is emitted even when the gating " + "capability is absent, so an operator can always force a knob. Other " + "`HINDSIGHT_API_*` keys are deliberately IGNORED \u2014 a blanket " + "passthrough would collide with the vars startHindsight() derives " + "itself (HINDSIGHT_API_PORT, the retain token/deadline budget).")
+    env: exports_external.record(exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()])).optional().describe("Operator overrides for switchroom's capability-gated Hindsight " + "performance defaults. Only the keys switchroom actually manages are " + "honoured (`HINDSIGHT_PERF_ENV_KEYS` in " + "src/setup/hindsight-perf-defaults.ts: RERANKER_LOCAL_FP16, " + "RERANKER_LOCAL_BATCH_SIZE, LLM_MAX_CONCURRENT, " + "RETAIN/CONSOLIDATION_LLM_MAX_CONCURRENT, LLM_STRICT_SCHEMA, " + "LLM_MAX_RETRIES, CONSOLIDATION_LLM_PARALLELISM, " + "MAX_OBSERVATIONS_PER_SCOPE, " + "RECALL_MAX_CANDIDATES_PER_SOURCE, LINK_EXPANSION_PER_ENTITY_LIMIT, " + "LINK_EXPANSION_TIMEOUT, LLM_REASONING_EFFORT, " + "RERANKER_LOCAL_BUCKET_BATCHING, RERANKER_MAX_CANDIDATES, " + "RERANKER_LOCAL_MAX_CONCURRENT, RECALL_MAX_CONCURRENT, " + "REFLECT_WALL_TIMEOUT, WORKER_CONSOLIDATION_RESERVED_SLOTS, " + "WORKER_CONSOLIDATION_SLOT_LIMIT, " + "CONSOLIDATION_MAX_MEMORIES_PER_ROUND, GRAPH_SEED_MIN_SIMILARITY, " + "LLM_SUPPORTS_MAX_ITEMS, RECENCY_DECAY_FUNCTION, " + "RECENCY_DECAY_HALFLIFE_DAYS \u2014 switchroom defaults recall's recency " + "curve to `exponential` with a 30-day half-life so a fact retained " + "today outranks a stale one, instead of upstream's near-flat " + "linear/365-day window), the override-only keys " + "switchroom manages but ships NO default for " + "(`HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS`: " + "HINDSIGHT_API_WORKER_CONSOLIDATION_BANK_PRIORITY \u2014 a per-deployment " + "`bank-pattern:priority,...` map; unset means upstream's flat " + "created_at FIFO across banks; and " + "HINDSIGHT_CE_DECISIVE_RELATIVE_GAP \u2014 the rollback knob for " + "switchroom's CE-saturation damping patch, a float; >= ~0.65 backs the " + "damping out entirely, unset means the patch's own derived gap; and " + "HINDSIGHT_API_RECENCY_DECAY_LINEAR_WINDOW_DAYS \u2014 only read when the " + "decay function is `linear`, so switchroom ships no default for it but " + "still honours an operator who flips the function back; and " + "HINDSIGHT_API_WORKER_MAX_SLOTS \u2014 the worker poller's TOTAL in-flight " + "task budget, the pool WORKER_CONSOLIDATION_RESERVED_SLOTS reserves out of; " + "unset means upstream's own default; and " + "HINDSIGHT_API_WORKER_RETAIN_RESERVED_SLOTS \u2014 the reserved slot FLOOR for the " + "retain (memory write) lane, carved from that same total; unset means " + "upstream's own 0, i.e. no floor and retain competes for the shared " + "pool; and " + "the pre-0.8.6 name HINDSIGHT_API_WORKER_<TYPE>_MAX_SLOTS is still " + "accepted for every operation type and normalised to " + "..._RESERVED_SLOTS on the way in, because setting both names for " + "one type is a hard boot failure in the engine and switchroom " + "therefore emits only the canonical name; and " + "HINDSIGHT_API_SEMANTIC_MIN_SIMILARITY \u2014 the cosine-similarity floor a " + "candidate must reach to be returned by the semantic retrieval arm at " + "all (0..1); unset means upstream's own 0.3, and where it should sit " + "depends on the bank's embedding model and phrasing diversity, so " + "switchroom ships no opinion; and " + "HINDSIGHT_MCP_RECALL_BUDGET_MODE \u2014 the rollback knob for switchroom's " + "mcp-recall-token-budget image patch; `legacy` restores upstream's " + "exact pre-patch recall returns, anything else or unset is the " + "honest-envelope mode; and " + "HINDSIGHT_API_LLM_TEMPERATURE_REFLECT \u2014 upstream's own per-op reflect " + "temperature knob, made live by switchroom's reflect-temperature image " + "patch; a float, or `none` to omit the kwarg (provider default, " + "upstream's accidental pre-patch behaviour); unset means the image's " + "baked default 0.1; and " + "HINDSIGHT_API_CONSOLIDATION_RECALL_MAX_CONCURRENT \u2014 the background " + "half of switchroom's recall-admission split (#3660): of the " + "RECALL_MAX_CONCURRENT admission slots, at most this many may be held " + "by background consolidation recalls at once, so foreground per-turn " + "recall always keeps the remainder; must be >= 1 and strictly less " + "than RECALL_MAX_CONCURRENT or the engine refuses to boot; unset " + "means the image's derived default min(2, RECALL_MAX_CONCURRENT - 1); " + "1 biases hard toward the interactive lane while a consolidation " + "backlog drains; and " + "HINDSIGHT_MM_REFRESH_MIN_INTERVAL_S \u2014 the rollback/tuning knob for " + "switchroom's MM-refresh-debounce image patch: the minimum seconds " + "between consolidation-triggered refreshes of one mental model; unset " + "means the image's baked 3600, 0 restores upstream's " + "refresh-every-round behaviour; explicit and cron-scheduled refreshes " + "are never debounced), plus the " + "embedded-PostgreSQL (pg0) sizing keys switchroom manages in " + "src/setup/hindsight-pg-defaults.ts (`HINDSIGHT_PG_ENV_KEYS`: " + "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE, " + "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS \u2014 a postgres size string such " + "as `4GB`, or the sentinel `off` to leave pg0's own default for that " + "one knob). A value set here " + "REPLACES switchroom's default and is emitted even when the gating " + "capability is absent, so an operator can always force a knob. Other " + "`HINDSIGHT_API_*` keys are deliberately IGNORED \u2014 a blanket " + "passthrough would collide with the vars startHindsight() derives " + "itself (HINDSIGHT_API_PORT, the retain token/deadline budget).")
   });
   MicrosoftWorkspaceConfigSchema = exports_external.object({
     microsoft_client_id: exports_external.string().min(1).optional().describe("Microsoft OAuth application (client) ID from Entra portal " + "(literal string or vault reference e.g. " + "'vault:microsoft-oauth-client-id'). OPTIONAL \u2014 omit it to use " + "switchroom's shipped default Microsoft app (zero-config). " + "Set it only to bring your own Entra app (BYO)."),
@@ -22445,7 +22452,9 @@ var init_schema = __esm(() => {
     }).transform((v) => v.trim().toLowerCase()), exports_external.object({
       enabled_for: exports_external.array(exports_external.string().regex(/^[a-z0-9][a-z0-9_-]{0,50}$/, {
         message: "Agent name must match the standard agent-name pattern"
-      })).describe("Agent slugs that may read this account's vault slots " + "(`google:<account>:refresh_token` etc). Per-agent ACL is " + "enforced at the broker, not at the agent identity layer \u2014 " + "the agent still authenticates via socket-path-as-identity " + "per RFC D \u00a74.1, broker just gates the cross-agent token share.")
+      })).describe("Agent slugs that may read this account's vault slots " + "(`google:<account>:refresh_token` etc). Per-agent ACL is " + "enforced at the broker, not at the agent identity layer \u2014 " + "the agent still authenticates via socket-path-as-identity " + "per RFC D \u00a74.1, broker just gates the cross-agent token share."),
+      readonly: exports_external.boolean().optional().describe("Per-account read-only selection (v1 scope model). true \u2192 the " + "token minted by `auth google account add` carries ONLY " + ".readonly scope variants (zero write scopes), and the gdrive " + "MCP launcher passes upstream `--read-only` so write tools are " + "not exposed. Written by `account add --readonly`; re-read on " + "`--replace` so a re-consent cannot silently re-widen. Omitted " + "= legacy behaviour (tier-tied read-write document scopes)."),
+      services: exports_external.array(GoogleServiceTokenSchema).min(1).optional().describe("Per-account service selection (v1 scope model). Which Google " + "services the minted token covers AND the gdrive MCP exposes " + "(upstream `--tools`): cal, drive, docs, sheets, slides. " + "Written by `account add --services`; re-read on `--replace`. " + "Omitted = the tier's default services (drive,docs,sheets; " + "+slides at extended/complete).")
     })).optional().describe("RFC G Phase 2: per-Google-account ACL for vault slots holding " + "OAuth refresh tokens. Maps account email \u2192 list of agents " + "permitted to read that account's slots. Written by `switchroom " + "auth google enable|disable` (Phase 3); read by the broker on " + "every Google slot access. Replaces RFC D's per-agent vault slot " + "scope (which can't express 'two agents share one Google account')."),
     microsoft_accounts: exports_external.record(exports_external.string().regex(/^[^@\s:]+@[^@\s:]+\.[^@\s:]+$/, {
       message: "Account key must be a Microsoft account email like 'alice@outlook.com' or 'alice@contoso.com' (colons not allowed)"
@@ -54129,8 +54138,9 @@ function createHandbackPreturnSignal(deps) {
       entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs);
       return;
     }
+    const consumedElsewhere = deps.sessionActivitySince?.(entry.deliveredAt) === true;
     entry.consumed = true;
-    stopTypingUnlessTurnLive(entry, "orphan reap");
+    stopTypingUnlessTurnLive(entry, consumedElsewhere ? "consumed reap" : "orphan reap");
     if (entry.activityMessageId != null) {
       const record = {
         turnKey: entry.syntheticTurnKey,
@@ -54147,6 +54157,11 @@ function createHandbackPreturnSignal(deps) {
       });
     }
     dropEntry(entry);
+    if (consumedElsewhere) {
+      log(`handback-preturn-signal: reap resolved key=${entry.statusKey} ` + `turnId=${entry.adoptTurnId} \u2014 session consumed input after delivery ` + `(no adopting turn observed); cleaned up without re-injection
+`);
+      return;
+    }
     if (entry.reinjectCount < maxReinjects) {
       const nextCount = entry.reinjectCount + 1;
       entry.inbound.meta[HANDBACK_REINJECT_COUNT_META_KEY] = String(nextCount);
@@ -54296,6 +54311,28 @@ function createHandbackPreturnSignal(deps) {
   };
 }
 
+// gateway/session-consume-signal.ts
+class SessionConsumeSignal {
+  lastTurnMintAt = 0;
+  lastMainToolCallAt = 0;
+  noteTurnMint(now = Date.now()) {
+    if (now > this.lastTurnMintAt)
+      this.lastTurnMintAt = now;
+  }
+  noteMainToolCall(now = Date.now()) {
+    if (now > this.lastMainToolCallAt)
+      this.lastMainToolCallAt = now;
+  }
+  activitySince(sinceTs) {
+    return this.lastTurnMintAt > sinceTs || this.lastMainToolCallAt > sinceTs;
+  }
+  reset() {
+    this.lastTurnMintAt = 0;
+    this.lastMainToolCallAt = 0;
+  }
+}
+var sessionConsumeSignal = new SessionConsumeSignal;
+
 // gateway/handback-orphan-recovery.ts
 function formatOrphanEscalation(esc) {
   return `telegram gateway: handback orphan escalation key=${esc.statusKey} ` + `turnId=${esc.adoptTurnId} reinjects=${esc.reinjectCount} ageMs=${esc.ageMs} ` + `\u2014 deterministic recovery exhausted, no operator nudge issued
@@ -80374,6 +80411,28 @@ class SubagentReplyAuthority2 {
 }
 var subagentReplyAuthority2 = new SubagentReplyAuthority2;
 
+// gateway/session-consume-signal.ts
+class SessionConsumeSignal2 {
+  lastTurnMintAt = 0;
+  lastMainToolCallAt = 0;
+  noteTurnMint(now = Date.now()) {
+    if (now > this.lastTurnMintAt)
+      this.lastTurnMintAt = now;
+  }
+  noteMainToolCall(now = Date.now()) {
+    if (now > this.lastMainToolCallAt)
+      this.lastMainToolCallAt = now;
+  }
+  activitySince(sinceTs) {
+    return this.lastTurnMintAt > sinceTs || this.lastMainToolCallAt > sinceTs;
+  }
+  reset() {
+    this.lastTurnMintAt = 0;
+    this.lastMainToolCallAt = 0;
+  }
+}
+var sessionConsumeSignal2 = new SessionConsumeSignal2;
+
 // gateway/feed-open-gate.ts
 function shouldEarlyOpenLiveness(input) {
   if (!input.enabled)
@@ -81301,6 +81360,7 @@ function beginTurn(deps, ev) {
     scheduleEarlyLivenessOpen(next);
     process.stderr.write(`telegram gateway: ${formatTurnLifecycle("set", "enqueue", next, startedAt)}
 `);
+    sessionConsumeSignal2.noteTurnMint(startedAt);
     rememberRecentTurn(next);
     promoteQueuedStatus(ev.chatId, enqThreadIdNum);
     shadowEmit({
@@ -83013,6 +83073,18 @@ class SubagentHandbackMarker2 {
 
 // answer-ready-flush.ts
 var ANSWER_READY_FLUSH_MS = 1000;
+var ANSWER_STAGE_MS = 30000;
+function resolveAnswerStageMs(env) {
+  const raw = env.SWITCHROOM_ANSWER_STAGE_MS;
+  if (raw == null || raw.trim() === "")
+    return ANSWER_STAGE_MS;
+  const n = Number(raw);
+  if (!Number.isFinite(n))
+    return ANSWER_STAGE_MS;
+  if (n <= 0)
+    return 0;
+  return Math.floor(n);
+}
 function resolveAnswerReadyFlushMs(env) {
   const raw = env.SWITCHROOM_ANSWER_READY_FLUSH_MS;
   if (raw == null || raw.trim() === "")
@@ -83039,6 +83111,7 @@ class AnswerReadyFlushController {
   constructor(deps) {
     this.deps = deps;
   }
+  staged = new WeakSet;
   get setTimeoutFn() {
     return this.deps.setTimeoutFn ?? ((fn, ms) => setTimeout(fn, ms));
   }
@@ -83048,12 +83121,16 @@ class AnswerReadyFlushController {
   clear(turn) {
     if (turn == null)
       return;
+    this.staged.delete(turn);
     const handle = this.deps.getTimerHandle(turn);
     if (handle != null) {
       this.clearTimeoutFn(handle);
       this.deps.setTimerHandle(turn, null);
     }
   }
+  isStaged(turn) {
+    return this.staged.has(turn);
+  }
   reset() {
     const turn = this.deps.getCurrentTurn();
     this.clear(turn);
@@ -83070,9 +83147,25 @@ class AnswerReadyFlushController {
     if (live == null || live !== armedTurn)
       return;
     this.deps.setTimerHandle(live, null);
-    if (!shouldArmAnswerReadyFlush(this.deps.getArmInput(live)))
+    if (!shouldArmAnswerReadyFlush(this.deps.getArmInput(live))) {
+      if (this.staged.delete(live)) {
+        this.deps.log?.("answer-ready stage discarded \u2014 reply/tool activity landed inside the completion window");
+      }
+      return;
+    }
+    const stageMs = this.deps.stageWindowMs ?? 0;
+    if (stageMs > 0 && !this.staged.has(live)) {
+      this.staged.add(live);
+      this.deps.log?.(`answer-ready quiescence \u2014 staging composed terminal answer ` + `(promotes in ${stageMs}ms unless the reply lands or the turn completes)`);
+      const handle = this.setTimeoutFn(() => this.onExpiry(live), stageMs);
+      this.deps.setTimerHandle(live, handle);
       return;
-    this.deps.log?.("answer-ready quiescence flush \u2014 delivering composed terminal answer");
+    }
+    if (this.staged.delete(live)) {
+      this.deps.log?.("answer-ready stage promoted \u2014 completion window closed with no reply; delivering composed terminal answer");
+    } else {
+      this.deps.log?.("answer-ready quiescence flush \u2014 delivering composed terminal answer");
+    }
     this.deps.onFlush(live);
   }
 }
@@ -86171,7 +86264,8 @@ var HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS = new Set([
   "HINDSIGHT_MCP_RECALL_BUDGET_MODE",
   "HINDSIGHT_API_LLM_TEMPERATURE_REFLECT",
   "HINDSIGHT_API_RETAIN_WALL_TIMEOUT",
-  "HINDSIGHT_API_CONSOLIDATION_RECALL_MAX_CONCURRENT"
+  "HINDSIGHT_API_CONSOLIDATION_RECALL_MAX_CONCURRENT",
+  "HINDSIGHT_MM_REFRESH_MIN_INTERVAL_S"
 ]);
 var HINDSIGHT_WORKER_SLOT_TYPES = [
   "consolidation",
@@ -101046,10 +101140,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.19.46";
-var COMMIT_SHA = "306c3ed1";
-var COMMIT_DATE = "2026-08-02T00:29:39Z";
-var LATEST_PR = 4194;
+var VERSION2 = "0.19.47";
+var COMMIT_SHA = "9693493e";
+var COMMIT_DATE = "2026-08-02T01:20:29Z";
+var LATEST_PR = 4201;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -107081,6 +107175,8 @@ if (isGatewayMain)
     async onToolCall(client3, msg) {
       process.stderr.write(`telegram gateway: ipc: tool_call tool=${msg.tool} agent=${client3.agentName ?? "-"} clientId=${client3.id ?? "-"} callId=${msg.id}
 `);
+      if (!isCronIdentity(client3.agentName))
+        sessionConsumeSignal.noteMainToolCall();
       try {
         const result = await executeToolCall(msg.tool, msg.args, client3.agentName);
         return { type: "tool_call_result", id: msg.id, success: true, result };
@@ -108769,6 +108865,7 @@ var answerReadyFlush = new AnswerReadyFlushController({
     turn.answerReadyFlushTimeoutId = handle;
   },
   onFlush: () => handleSessionEvent2({ kind: "turn_end", durationMs: -1, reason: "answer-ready-quiescence" }),
+  stageWindowMs: resolveAnswerStageMs(process.env),
   log: (msg) => process.stderr.write(`telegram gateway: ${msg}
 `)
 });
@@ -108907,7 +109004,8 @@ var handbackPreturnSignal = createHandbackPreturnSignal({
       return false;
     return statusKey(live.sessionChatId, live.sessionThreadId) === key;
   },
-  isClaudeBusy: () => isMachineInTurn()
+  isClaudeBusy: () => isMachineInTurn(),
+  sessionActivitySince: (sinceTs) => sessionConsumeSignal.activitySince(sinceTs)
 });
 var memoryLegibilityStager = new MemoryLegibilityStager;
 function sendMemoryLegibilityLine(event, chatId, threadId) {

package/telegram-plugin/gateway/gateway.ts

@@ -283,6 +283,7 @@ import { NarrativeFlushController, PENDING_NARRATIVE_FLUSH_MS } from '../narrati
 import { createTypingWrapper } from '../typing-wrap.js'
 import { createTurnTypingLoop } from './turn-typing-loop.js'
 import { createHandbackPreturnSignal } from './handback-preturn-signal.js'
+import { sessionConsumeSignal } from './session-consume-signal.js'
 import { createHandbackOrphanRecovery } from './handback-orphan-recovery.js'
 import { deriveTurnId } from './derive-turn-id.js'
 import { createTypingEmitter, TYPING_REFRESH_MS } from '../typing-emitter.js'
@@ -495,10 +496,7 @@ import {
 } from '../reply-owner-resolve.js'
 import { SubagentHandbackMarker } from './subagent-handback-marker.js'
 // PR A — deterministic answer-ready quiescence flush (late-delivery fix).
-import {
-  AnswerReadyFlushController,
-  resolveAnswerReadyFlushMs,
-} from '../answer-ready-flush.js'
+import { AnswerReadyFlushController, resolveAnswerReadyFlushMs, resolveAnswerStageMs } from '../answer-ready-flush.js'
 // #1667 — pure decision core for the turn_end answer-delivery gate (#1664).
 import { decideTurnEndGate } from './turn-end-gate.js'
 // #1122 PR3: turn-flush-prose-recovery removed with the progress card.
@@ -10748,6 +10746,7 @@ if (isGatewayMain) ipcServer = createIpcServer({
 
   async onToolCall(client: IpcClient, msg: ToolCallMessage): Promise<ToolCallResult> {
     process.stderr.write(`telegram gateway: ipc: tool_call tool=${msg.tool} agent=${client.agentName ?? '-'} clientId=${client.id ?? '-'} callId=${msg.id}\n`)
+    if (!isCronIdentity(client.agentName)) sessionConsumeSignal.noteMainToolCall() // consumption proxy (session-consume-signal.ts)
     try {
       // #4172 — the calling client's identity gates reply supersede authority
       // (see replyCallerIsForeignSession, cron-session.ts).
@@ -13547,29 +13546,29 @@ function resetOrphanedReplyTimeout(): void {
  * PR A — DETERMINISTIC answer-ready quiescence flush controller.
  *
  * The orchestration (arm / debounce / rollover-guard / fire-time re-verify /
- * disarm) lives in the extracted, unit-tested `AnswerReadyFlushController`
- * (answer-ready-flush.ts) — the gateway only supplies the thin deps below and
- * calls `.reset()` / `.clear(turn)`. Behaviour:
+ * stage-don't-send / disarm) lives in the extracted, unit-tested
+ * `AnswerReadyFlushController` (answer-ready-flush.ts) — the gateway only
+ * supplies the thin deps below and calls `.reset()` / `.clear(turn)`.
  *
  * - `reset()` (from `case 'text'`): (re)arm iff the turn has a genuine composed
  *   terminal answer (the SAME `decideTurnFlush` classifier the turn-flush branch
  *   uses) AND is quiescent. Each text chunk re-arms → the debounce.
  * - `clear(turn)` (from tool activity + `endCurrentTurnAtomic`): the DISARM.
- * - on fire: re-pin `currentTurn === turn`, re-verify quiescence, then dispatch
- *   a positive `answer-ready-quiescence` synthetic turn_end that routes through
- *   the IDENTICAL turn-flush send path (endCurrentTurnAtomic → send-gated IIFE →
- *   honest PR-B record). Replaces the ~150 s dead wait with ~1 s, in code.
+ * - on fire: re-pin `currentTurn === turn`, re-verify quiescence, then STAGE the
+ *   answer on the still-live turn (`stageWindowMs` — see ANSWER_STAGE_MS) and
+ *   promote only when the completion window closes with no reply, dispatching
+ *   the positive `answer-ready-quiescence` synthetic turn_end through the
+ *   IDENTICAL turn-flush send path. A reply landing in the window discards the
+ *   stage (msgs 25843/25844); a real turn_end delivers via the turn-flush branch.
  *
  * Exactly-once: the synthetic turn_end's `endCurrentTurnAtomic` nulls the atom,
  * so a later REAL turn_end (or the orphaned backstop) short-circuits at its
  * `turn != null` guard; `endCurrentTurnAtomic` also calls `.clear(turn)` so a
- * real turn_end that lands FIRST cancels a pending flush. `outboundDedup` is the
- * second layer.
+ * real turn_end that lands FIRST cancels a pending flush/stage.
  *
  * The `answer-ready-quiescence` reason bypasses the `durationMs===-1`
- * recently-streaming SUPPRESSION guard (the terminal answer text itself stamps
- * recentlyStreaming): quiescence IS the positive "streaming has settled" signal,
- * the opposite of the hung-turn backstop that guard protects.
+ * recently-streaming SUPPRESSION guard: quiescence IS the positive "streaming
+ * has settled" signal, the opposite of the hung-turn backstop that guard covers.
  */
 const answerReadyFlush = new AnswerReadyFlushController<CurrentTurn>({
   getCurrentTurn: () => currentTurn,
@@ -13593,6 +13592,7 @@ const answerReadyFlush = new AnswerReadyFlushController<CurrentTurn>({
   },
   onFlush: () =>
     handleSessionEvent({ kind: 'turn_end', durationMs: -1, reason: 'answer-ready-quiescence' }),
+  stageWindowMs: resolveAnswerStageMs(process.env), // stage-don't-send — see ANSWER_STAGE_MS
   log: (msg) => process.stderr.write(`telegram gateway: ${msg}\n`),
 })
 
@@ -13831,9 +13831,10 @@ const handbackPreturnSignal = createHandbackPreturnSignal({
     return statusKey(live.sessionChatId, live.sessionThreadId) === key
   },
   // Queue-state gate for the orphan reap (see the signal's `isClaudeBusy` doc):
-  // while a turn is in flight the handback is enqueued behind it, not orphaned.
-  // False for both `bridge_alive_idle` and `bridge_dead` → genuine orphan reaps.
+  // a handback queued behind an in-flight turn is not orphaned.
   isClaudeBusy: () => isMachineInTurn(),
+  // 2026-08-02 invisible-consumption gate — see session-consume-signal.ts.
+  sessionActivitySince: (sinceTs) => sessionConsumeSignal.activitySince(sinceTs),
 })
 
 /**

package/telegram-plugin/gateway/handback-preturn-signal.ts

@@ -238,6 +238,18 @@ export interface HandbackPreturnSignalDeps {
    *  is the GLOBAL busy signal because the handback queues behind whatever turn
    *  is running, regardless of topic. Optional; defaults to "not busy". */
   isClaudeBusy?: () => boolean
+  /** True IFF the gateway observed the SESSION consume input after `sinceTs` —
+   *  a turn minting at the enqueue seam, or a main-session MCP tool call over
+   *  the IPC bridge (`session-consume-signal.ts`). Consulted at the moment the
+   *  reap would otherwise declare a genuine orphan: claude holds ONE FIFO input
+   *  queue, so post-delivery consumption evidence means the delivered handback
+   *  entered the model's context even though no adopting turn was ever minted
+   *  (the 2026-08-02 invisible-consumption incident — the session answered the
+   *  handback via a `reply` from idle with zero session-tail events, then the
+   *  reap re-injected the already-answered report twice). When true the reap
+   *  CLEANS UP (card + typing + entry) without re-injecting and without
+   *  escalating. Optional; defaults to "no evidence" (legacy re-inject). */
+  sessionActivitySince?: (sinceTs: number) => boolean
   now?: () => number
   /** Debounce before painting the pre-turn card (kills sub-second flicker). */
   debounceMs?: number
@@ -487,13 +499,27 @@ export function createHandbackPreturnSignal(
       entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs)
       return
     }
+    // INVISIBLE-CONSUMPTION GATE (2026-08-02 klanker incident). We are at the
+    // point the reap would declare a genuine orphan: claude is idle, the
+    // delivered TTL elapsed, and no adopting turn ever minted. But "no adopting
+    // turn" is NOT proof the handback went un-consumed — the session can
+    // consume injected input WITHOUT the gateway minting a turn (zero
+    // session-tail events; the only trace was a `reply` tool call from idle).
+    // If the gateway observed the session consume input after this handback
+    // was delivered (a later turn minting, or a main-session tool call —
+    // claude's single FIFO queue means either proves the earlier delivery
+    // entered the model's context), the handback was already processed:
+    // re-injecting it re-runs an answered report (observed: the same worker
+    // report processed three times). Clean up WITHOUT re-injection.
+    const consumedElsewhere = deps.sessionActivitySince?.(entry.deliveredAt) === true
     entry.consumed = true
-    // GENUINE ORPHAN. Recover DETERMINISTICALLY — never ask the operator to
-    // nudge. Stop the forever-running typing loop, DELETE the frozen card (do
-    // not leave a stale "needs a nudge" message), then re-inject the handback so
-    // the machine re-processes it itself. Cap the re-injections; past the cap
-    // escalate to fleet-health telemetry (NOT a chat card).
-    stopTypingUnlessTurnLive(entry, 'orphan reap')
+    // GENUINE ORPHAN (or consumed-elsewhere cleanup). Recover DETERMINISTICALLY
+    // — never ask the operator to nudge. Stop the forever-running typing loop,
+    // DELETE the frozen card (do not leave a stale "needs a nudge" message),
+    // then — for a genuine orphan only — re-inject the handback so the machine
+    // re-processes it itself. Cap the re-injections; past the cap escalate to
+    // fleet-health telemetry (NOT a chat card).
+    stopTypingUnlessTurnLive(entry, consumedElsewhere ? 'consumed reap' : 'orphan reap')
     if (entry.activityMessageId != null) {
       const record: PreTurnCardRecord = {
         turnKey: entry.syntheticTurnKey,
@@ -518,6 +544,18 @@ export function createHandbackPreturnSignal(
     // synchronously) is not swallowed by the per-topic dedupe guard. The entry
     // object stays valid for the captured re-inject below.
     dropEntry(entry)
+    if (consumedElsewhere) {
+      // Distinct structured line so fleet-health can track how often the
+      // session consumes a handback without a gateway-visible adopting turn
+      // (the underlying session-tail anomaly stays observable even though the
+      // false re-injection is gone).
+      log(
+        `handback-preturn-signal: reap resolved key=${entry.statusKey} ` +
+          `turnId=${entry.adoptTurnId} — session consumed input after delivery ` +
+          `(no adopting turn observed); cleaned up without re-injection\n`,
+      )
+      return
+    }
     if (entry.reinjectCount < maxReinjects) {
       const nextCount = entry.reinjectCount + 1
       // Stamp the counter on the inbound so it survives the buffer round trip

package/telegram-plugin/gateway/session-consume-signal.ts

@@ -0,0 +1,72 @@
+/**
+ * session-consume-signal.ts — "did the claude session consume input after T?"
+ *
+ * Built for the 2026-08-02 klanker false-orphan incident (handback turnId
+ * `#1785628912223`). A background worker's `subagent_handback` was released and
+ * DELIVERED to the bridge at 00:01:53Z; the session consumed it and answered it
+ * (a `reply` tool call at 00:02:58Z, IPC-observed, while the gateway's shadow
+ * state was `bridge_alive_idle`) — but NO gateway turn ever minted for it: the
+ * session-tail produced no `enqueue`/stream events for that consumption, so
+ * `handback-preturn-signal`'s entry was never adopted. After the delivered TTL
+ * the reap declared a genuine orphan and RE-INJECTED the already-answered
+ * handback — twice — re-processing the same worker report three times.
+ *
+ * The orphan reap's existing gates (`isClaudeBusy`, the delivered TTL) key off
+ * gateway-minted TURN state, which is exactly the signal that was absent. This
+ * module tracks the two consumption proxies the gateway CAN always observe,
+ * independent of the session-tail:
+ *
+ *   - a TURN MINT (the `enqueue` seam in stream-render): claude holds a single
+ *     FIFO input queue, so a turn minting for an inbound delivered AFTER the
+ *     handback proves everything delivered before it entered the model's
+ *     context (2026-08-02: real turn `#25821` minted 00:04:13Z and completed,
+ *     while the reap still declared the 00:01:53Z handback orphaned);
+ *   - a MAIN-SESSION MCP TOOL CALL over the IPC bridge (reply, progress_update,
+ *     …): the session can only produce a tool call by processing input, so a
+ *     tool call arriving after the delivery is direct evidence the session is
+ *     alive and consuming — the 00:02:58Z reply was the ONLY observable trace
+ *     of the invisible consumption. Cron/foreign sessions are excluded at the
+ *     call site (their activity says nothing about the main session's queue).
+ *
+ * Consumers ask `activitySince(deliveredAt)`. The deliberate trade: when this
+ * returns true for a handback that was in fact DROPPED before reaching claude
+ * (bridge death in the release→write window) while unrelated session activity
+ * happened to occur, the reap now cleans up instead of re-injecting — a lost
+ * recovery for a rare double-fault, logged distinctly for fleet-health. The
+ * previous behaviour re-injected an already-answered handback on every
+ * invisible consumption, which is the incident that actually occurs.
+ *
+ * Pure state, no I/O; module singleton mirrors `subagentReplyAuthority`.
+ */
+
+export class SessionConsumeSignal {
+  private lastTurnMintAt = 0
+  private lastMainToolCallAt = 0
+
+  /** A gateway turn minted at the `enqueue` seam (stream-render). */
+  noteTurnMint(now: number = Date.now()): void {
+    if (now > this.lastTurnMintAt) this.lastTurnMintAt = now
+  }
+
+  /** A NON-CRON client's MCP tool call arrived over the IPC bridge. The call
+   *  site excludes cron identities — a Tier-1 cheap-cron session consuming its
+   *  own input proves nothing about the main session's queue. */
+  noteMainToolCall(now: number = Date.now()): void {
+    if (now > this.lastMainToolCallAt) this.lastMainToolCallAt = now
+  }
+
+  /** True IFF either consumption proxy was observed strictly after `sinceTs`. */
+  activitySince(sinceTs: number): boolean {
+    return this.lastTurnMintAt > sinceTs || this.lastMainToolCallAt > sinceTs
+  }
+
+  /** Test-only: forget all observations. */
+  reset(): void {
+    this.lastTurnMintAt = 0
+    this.lastMainToolCallAt = 0
+  }
+}
+
+/** The ONE live instance (one CLI session per gateway process — the same
+ *  module-singleton shape as `subagentReplyAuthority`). */
+export const sessionConsumeSignal = new SessionConsumeSignal()

package/telegram-plugin/gateway/stream-render.ts

@@ -75,6 +75,7 @@ import { isTelegramReplyTool, isTelegramSurfaceTool } from '../tool-names.js'
 import { decideTurnFlush } from '../turn-flush-safety.js'
 import { FlushCompletionTracker } from '../flushed-turn-supersede.js'
 import { subagentReplyAuthority } from './subagent-reply-authority.js'
+import { sessionConsumeSignal } from './session-consume-signal.js'
 import { decideTerminalReason, deriveTurnRole } from '../turn-liveness-floor.js'
 import { chatKey, chatKeyWithSuffix } from './chat-key.js'
 import { deriveTurnId } from './derive-turn-id.js'
@@ -747,6 +748,10 @@ function beginTurn(deps: StreamRenderDeps, ev: TurnStartEnvelope): void {
     process.stderr.write(
       `telegram gateway: ${formatTurnLifecycle('set', 'enqueue', next, startedAt)}\n`,
     )
+    // Consumption proxy for the handback orphan reap (session-consume-signal):
+    // claude holds ONE FIFO input queue, so this turn minting proves every
+    // inbound delivered before its own entered the model's context.
+    sessionConsumeSignal.noteTurnMint(startedAt)
     // Component 3 — retain in the bounded recently-ended registry so a
     // LATE reply (landing after currentTurn flips to a successor) can
     // still resolve THIS turn's origin thread by its turnId.