switchroom 0.15.8 → 0.15.10

package/dist/agent-scheduler/index.js

@@ -12276,7 +12276,7 @@ function isKnownCheapModel(model) {
 }
 function isCheapCronEnabled(env = process.env) {
   const v = (env.SWITCHROOM_CHEAP_CRON ?? "").toLowerCase();
-  return v === "1" || v === "true" || v === "on";
+  return !(v === "0" || v === "false" || v === "off");
 }
 function resolveCronModel(model) {
   return isKnownCheapModel(model) ? model : DEFAULT_CRON_MODEL;
@@ -12313,6 +12313,90 @@ function resolveEscalationRouting(input, opts) {
   return resolveCronRouting({ ...input, kind: "prompt" }, opts);
 }
 
+// src/scheduler/cron-cadence.ts
+function csvSmallestGap(field) {
+  if (!field.includes(","))
+    return null;
+  const parts = field.split(",").map((s) => Number(s)).filter((n) => Number.isInteger(n) && n >= 0);
+  if (parts.length < 2)
+    return null;
+  const sorted = [...parts].sort((a, b) => a - b);
+  let smallest = Infinity;
+  for (let i = 1;i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1];
+    if (gap > 0 && gap < smallest)
+      smallest = gap;
+  }
+  return Number.isFinite(smallest) ? smallest : null;
+}
+function estimateCronGapMin(expr) {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length < 5)
+    return Infinity;
+  const [min, hour] = fields;
+  if (min === "*")
+    return 1;
+  const minStep = min.match(/^\*\/(\d+)$/);
+  if (minStep) {
+    const n = Number(minStep[1]);
+    return n > 0 ? n : Infinity;
+  }
+  const minCsv = csvSmallestGap(min);
+  if (minCsv !== null)
+    return minCsv;
+  if (!/^\d+$/.test(min))
+    return Infinity;
+  if (hour === "*")
+    return 60;
+  const hourStep = hour.match(/^\*\/(\d+)$/);
+  if (hourStep) {
+    const n = Number(hourStep[1]);
+    return n > 0 ? n * 60 : Infinity;
+  }
+  const hourCsv = csvSmallestGap(hour);
+  if (hourCsv !== null)
+    return hourCsv * 60;
+  if (/^\d+$/.test(hour))
+    return 1440;
+  return Infinity;
+}
+
+// src/scheduler/tier-selector.ts
+var DEFAULT_FREQUENT_GAP_MIN = 60;
+function recommendCronTier(input, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
+  if (input.kind === "poll") {
+    return { tier: "poll", source: "explicit", reason: "declared kind: poll (model-free check)" };
+  }
+  if (input.context === "fresh") {
+    return { tier: "cheap", source: "explicit", reason: "declared context: fresh (cheap cron session)" };
+  }
+  if (input.context === "agent") {
+    return { tier: "main", source: "explicit", reason: "declared context: agent (full live session)" };
+  }
+  if (input.model !== undefined) {
+    return isKnownCheapModel(input.model) ? { tier: "cheap", source: "explicit", reason: `cheap model '${input.model}' → cheap cron session` } : { tier: "main", source: "explicit", reason: `model '${input.model}' is not a known-cheap id → full live session` };
+  }
+  if (input.smallestGapMin <= frequentGapMin) {
+    return {
+      tier: "cheap",
+      source: "cadence-default",
+      reason: `fires every ~${input.smallestGapMin}min (≤ ${frequentGapMin}min) — defaulting to a cheap ` + `session; set context: agent (or an Opus/custom model) if this needs the agent's full context`
+    };
+  }
+  return {
+    tier: "main",
+    source: "cadence-default",
+    reason: `fires every ~${input.smallestGapMin}min (> ${frequentGapMin}min) — defaulting to the agent's ` + `full session; set model: sonnet (or context: fresh) to run it cheaply`
+  };
+}
+function applyDefaultTier(entry, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
+  if (entry.kind === "poll" || entry.context !== undefined || entry.model !== undefined) {
+    return entry;
+  }
+  const rec = recommendCronTier({ smallestGapMin: estimateCronGapMin(entry.cron) }, frequentGapMin);
+  return rec.tier === "cheap" ? { ...entry, context: "fresh" } : entry;
+}
+
 // src/agent-scheduler/cheap-cron-wiring.ts
 import { lookup as dnsLookup } from "node:dns/promises";
 
@@ -14296,7 +14380,8 @@ function registerAgentSchedule(opts) {
         }
       }
       const cheapEnabled = opts.cheapCron?.enabled ?? false;
-      const routing = resolveCronRouting(entry, { cheapCronEnabled: cheapEnabled });
+      const routed = cheapEnabled ? applyDefaultTier(entry) : entry;
+      const routing = resolveCronRouting(routed, { cheapCronEnabled: cheapEnabled });
       const threadId = resolveEntryThreadId(entry, opts.channel);
       const record = (fields) => opts.sink.recordFire({
         agent: entry.agent,

package/dist/cli/switchroom.js

@@ -15435,6 +15435,93 @@ var init_cron_routing = __esm(() => {
   OPUS_MODEL_RE = /opus/i;
 });
 
+// src/scheduler/cron-cadence.ts
+function csvSmallestGap(field) {
+  if (!field.includes(","))
+    return null;
+  const parts = field.split(",").map((s) => Number(s)).filter((n) => Number.isInteger(n) && n >= 0);
+  if (parts.length < 2)
+    return null;
+  const sorted = [...parts].sort((a, b) => a - b);
+  let smallest = Infinity;
+  for (let i = 1;i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1];
+    if (gap > 0 && gap < smallest)
+      smallest = gap;
+  }
+  return Number.isFinite(smallest) ? smallest : null;
+}
+function estimateCronGapMin(expr) {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length < 5)
+    return Infinity;
+  const [min, hour] = fields;
+  if (min === "*")
+    return 1;
+  const minStep = min.match(/^\*\/(\d+)$/);
+  if (minStep) {
+    const n = Number(minStep[1]);
+    return n > 0 ? n : Infinity;
+  }
+  const minCsv = csvSmallestGap(min);
+  if (minCsv !== null)
+    return minCsv;
+  if (!/^\d+$/.test(min))
+    return Infinity;
+  if (hour === "*")
+    return 60;
+  const hourStep = hour.match(/^\*\/(\d+)$/);
+  if (hourStep) {
+    const n = Number(hourStep[1]);
+    return n > 0 ? n * 60 : Infinity;
+  }
+  const hourCsv = csvSmallestGap(hour);
+  if (hourCsv !== null)
+    return hourCsv * 60;
+  if (/^\d+$/.test(hour))
+    return 1440;
+  return Infinity;
+}
+
+// src/scheduler/tier-selector.ts
+function recommendCronTier(input, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
+  if (input.kind === "poll") {
+    return { tier: "poll", source: "explicit", reason: "declared kind: poll (model-free check)" };
+  }
+  if (input.context === "fresh") {
+    return { tier: "cheap", source: "explicit", reason: "declared context: fresh (cheap cron session)" };
+  }
+  if (input.context === "agent") {
+    return { tier: "main", source: "explicit", reason: "declared context: agent (full live session)" };
+  }
+  if (input.model !== undefined) {
+    return isKnownCheapModel(input.model) ? { tier: "cheap", source: "explicit", reason: `cheap model '${input.model}' \u2192 cheap cron session` } : { tier: "main", source: "explicit", reason: `model '${input.model}' is not a known-cheap id \u2192 full live session` };
+  }
+  if (input.smallestGapMin <= frequentGapMin) {
+    return {
+      tier: "cheap",
+      source: "cadence-default",
+      reason: `fires every ~${input.smallestGapMin}min (\u2264 ${frequentGapMin}min) \u2014 defaulting to a cheap ` + `session; set context: agent (or an Opus/custom model) if this needs the agent's full context`
+    };
+  }
+  return {
+    tier: "main",
+    source: "cadence-default",
+    reason: `fires every ~${input.smallestGapMin}min (> ${frequentGapMin}min) \u2014 defaulting to the agent's ` + `full session; set model: sonnet (or context: fresh) to run it cheaply`
+  };
+}
+function applyDefaultTier(entry, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
+  if (entry.kind === "poll" || entry.context !== undefined || entry.model !== undefined) {
+    return entry;
+  }
+  const rec = recommendCronTier({ smallestGapMin: estimateCronGapMin(entry.cron) }, frequentGapMin);
+  return rec.tier === "cheap" ? { ...entry, context: "fresh" } : entry;
+}
+var DEFAULT_FREQUENT_GAP_MIN = 60;
+var init_tier_selector = __esm(() => {
+  init_cron_routing();
+});
+
 // src/config/timezone.ts
 import { readFileSync as readFileSync3, readlinkSync } from "node:fs";
 function defaultReadEtcTimezone() {
@@ -23262,7 +23349,7 @@ function describeAgents(config) {
     const resolved = resolveAgentConfig(config.defaults, config.profiles, agent);
     const profile = agent.extends ?? "default";
     const uid = allocateAgentUid(name);
-    const cronSession = scheduleNeedsCronSession((resolved.schedule ?? []).map((e) => ({ kind: e.kind, model: e.model, context: e.context })), { cheapCronEnabled: true });
+    const cronSession = scheduleNeedsCronSession((resolved.schedule ?? []).map((e) => applyDefaultTier({ cron: e.cron, kind: e.kind, model: e.model, context: e.context })), { cheapCronEnabled: true });
     const resources = resolveResourceDefaults(name, profile, resolved.resources, { cronSession });
     const strippedCaps = readStrippedCaps(agent);
     out.push({
@@ -23760,6 +23847,7 @@ function emitAgentService(lines, a, imageTag, buildMode, buildContext, homePrefi
 var AGENT_UID_MIN = 10001, AGENT_UID_MAX = 10999, RESOURCE_BY_PROFILE, CRON_SESSION_MEM_BUMP_MIB = 512, CRON_SESSION_PIDS_BUMP = 128, BIND_MOUNT_SOURCE_DENYLIST, BIND_MOUNT_TARGET_DENYLIST, BIND_MOUNT_EXACT_SOURCE_DENY, CONTAINER_CONFIG_PATH = "/state/config/switchroom.yaml";
 var init_compose = __esm(() => {
   init_cron_routing();
+  init_tier_selector();
   init_merge();
   init_timezone();
   init_peercred();
@@ -24438,6 +24526,8 @@ function getAgentLogs(name, follow) {
 function classifyChangeKind(path) {
   if (/\/telegram\/cron-(?:\d+|[0-9a-f]{12})\.sh$/.test(path))
     return "cron";
+  if (path.includes("/.claude-cron/"))
+    return "cron";
   if (path.includes("/.claude/skills/"))
     return "skill";
   if (path.endsWith("/.claude/settings.json"))
@@ -50235,8 +50325,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.15.8";
-var COMMIT_SHA = "318cb85f";
+var VERSION = "0.15.10";
+var COMMIT_SHA = "bb9182e1";
 
 // src/cli/agent.ts
 init_source();
@@ -50347,6 +50437,7 @@ var LEGACY_CRON_SCRIPT_BASENAME_RE = /^cron-(\d+)\.sh$/;
 // src/agents/scaffold.ts
 init_schema();
 init_cron_routing();
+init_tier_selector();
 init_merge();
 init_timezone();
 
@@ -51489,11 +51580,7 @@ function renderFleetInvariants() {
 `);
 }
 function buildCronSessionContext(agentConfig) {
-  const entries = (agentConfig.schedule ?? []).map((e) => ({
-    kind: e.kind,
-    model: e.model,
-    context: e.context
-  }));
+  const entries = (agentConfig.schedule ?? []).map((e) => applyDefaultTier({ cron: e.cron, kind: e.kind, model: e.model, context: e.context }));
   return {
     cronSessionEnabled: scheduleNeedsCronSession(entries, { cheapCronEnabled: true }),
     cronModelQ: shellSingleQuote(DEFAULT_CRON_MODEL)

package/dist/cli/ui/index.html

@@ -119,6 +119,40 @@
 
     .meta-item span { color: var(--text); }
 
+    .scope-toggle {
+      cursor: pointer;
+      color: var(--text);
+      border-bottom: 1px dotted var(--text-dim);
+      user-select: none;
+    }
+    .scope-toggle:hover { color: var(--blue); }
+    .scope-toggle:focus-visible { outline: 2px solid var(--blue); outline-offset: 2px; }
+    .scope-caret {
+      display: inline-block;
+      width: 0.9em;
+      margin-right: 0.15rem;
+      color: var(--text-dim);
+      font-size: 0.75em;
+    }
+    .scope-list {
+      list-style: none;
+      margin: 0.35rem 0 0;
+      padding: 0.5rem 0.75rem;
+      width: 100%;
+      background: var(--surface-hover);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      font-size: 0.78rem;
+      line-height: 1.5;
+    }
+    .scope-list li {
+      color: var(--text);
+      word-break: break-all;
+      padding: 0.1rem 0;
+      border-bottom: 1px solid var(--border);
+    }
+    .scope-list li:last-child { border-bottom: none; }
+
     .card-actions {
       padding: 0.75rem 1.25rem;
       border-top: 1px solid var(--border);
@@ -1225,6 +1259,7 @@
     const _dimC = (s) => `<span style="color:var(--text-dim)">${escapeHtml(s)}</span>`;
 
     let _accessBtnSeq = 0;
+    let _scopeSeq = 0;
 
     // One OAuth-account card (Google or Microsoft — same shape; Microsoft
     // adds an account-type pill). When agentNames is supplied, renders a
@@ -1255,6 +1290,24 @@
              }).join('')}
            </div>`
         : '';
+      // Scope: clickable "N scope(s)" that expands a full-width list of the
+      // individual scopes below the meta row (the old version hid them in a
+      // title tooltip only). The list is a sibling block after .card-meta so
+      // it isn't squished inside the flex-wrapped meta-items.
+      const scopeList = a.scope ? a.scope.split(/\s+/).filter(Boolean) : [];
+      let scopeCount, scopeBlock = '';
+      if (scopeList.length) {
+        const sid = `scopes-${++_scopeSeq}`;
+        scopeCount = `<span class="scope-toggle" id="${sid}-t" role="button" tabindex="0" aria-expanded="false" aria-controls="${sid}"
+            onclick="toggleScopes('${sid}')"
+            onkeydown="if(event.key==='Enter'||event.key===' '){event.preventDefault();toggleScopes('${sid}');}"
+          ><span class="scope-caret">▸</span>${escapeHtml(scopeList.length + ' scope' + (scopeList.length === 1 ? '' : 's'))}</span>`;
+        scopeBlock = `<ul class="scope-list" id="${sid}" hidden>${
+          scopeList.map(s => `<li title="${escapeHtml(s)}">${escapeHtml(s)}</li>`).join('')
+        }</ul>`;
+      } else {
+        scopeCount = _dimC('—');
+      }
       return `
       <div class="account-card">
         <div class="account-card-header">
@@ -1264,9 +1317,10 @@
         <div class="account-usage"><label style="color:var(--text-dim);opacity:.7">Enabled for: </label>${acl}</div>
         <div class="card-meta" style="padding:0">
           <div class="meta-item"><label>Expires </label><span>${expires}</span></div>
-          <div class="meta-item" title="${a.scope ? escapeHtml(a.scope) : ''}"><label>Scope </label><span>${a.scope ? escapeHtml(a.scope.split(' ').length + ' scope(s)') : _dimC('—')}</span></div>
+          <div class="meta-item"><label>Scope </label><span>${scopeCount}</span></div>
           <div class="meta-item"><label>Client </label><span>${a.clientId ? escapeHtml(a.clientId.slice(0, 16) + '…') : _dimC('—')}</span></div>
         </div>
+        ${scopeBlock}
         ${manage}
       </div>`;
     }
@@ -1531,6 +1585,22 @@
       }
     }
 
+    // Expand/collapse a connection card's scope list in place. Self-contained
+    // (no global state / re-render) — just flips the list's [hidden] and the
+    // toggle's caret + aria-expanded.
+    function toggleScopes(id) {
+      const list = document.getElementById(id);
+      const toggle = document.getElementById(id + '-t');
+      if (!list) return;
+      const open = list.hidden;
+      list.hidden = !open;
+      if (toggle) {
+        toggle.setAttribute('aria-expanded', String(open));
+        const caret = toggle.querySelector('.scope-caret');
+        if (caret) caret.textContent = open ? '▾' : '▸';
+      }
+    }
+
     async function toggleLogs(name) {
       if (openLogs.has(name)) {
         openLogs.delete(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.15.8",
+  "version": "0.15.10",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

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

@@ -48238,6 +48238,16 @@ function isCronIdentity(name) {
 function resolveInjectTarget(agentName3, meta) {
   return meta?.session === "cron" ? cronIdentity(agentName3) : agentName3;
 }
+function deliverInjectWithFallback(agentName3, meta, send) {
+  const target = resolveInjectTarget(agentName3, meta);
+  const wantedCron = target !== agentName3;
+  if (send(target))
+    return { target, delivered: true, fellBackToMain: false };
+  if (wantedCron && send(agentName3)) {
+    return { target: agentName3, delivered: true, fellBackToMain: true };
+  }
+  return { target, delivered: false, fellBackToMain: false };
+}
 
 // gateway/obligation-ledger.ts
 class ObligationLedger {
@@ -53757,11 +53767,11 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.15.8";
-var COMMIT_SHA = "318cb85f";
-var COMMIT_DATE = "2026-06-12T23:50:50Z";
-var LATEST_PR = 2296;
-var COMMITS_AHEAD_OF_TAG = 1;
+var VERSION = "0.15.10";
+var COMMIT_SHA = "bb9182e1";
+var COMMIT_DATE = "2026-06-13T01:33:32Z";
+var LATEST_PR = 2302;
+var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -57116,12 +57126,14 @@ var ipcServer = createIpcServer({
   onInjectInbound(_client, msg) {
     const promptKey = typeof msg.inbound.meta?.prompt_key === "string" ? msg.inbound.meta.prompt_key : "unknown";
     const source = typeof msg.inbound.meta?.source === "string" ? msg.inbound.meta.source : "unknown";
-    const target = resolveInjectTarget(msg.agentName, msg.inbound.meta);
-    const toCron = target !== msg.agentName;
-    const delivered = ipcServer.sendToAgent(target, msg.inbound);
-    if (delivered && !toCron)
+    const { target, delivered, fellBackToMain } = deliverInjectWithFallback(msg.agentName, msg.inbound.meta, (t) => ipcServer.sendToAgent(t, msg.inbound));
+    if (fellBackToMain) {
+      process.stderr.write(`telegram gateway: cron fire fell back to main session (no cron bridge) agent=${msg.agentName} prompt_key=${promptKey}
+`);
+    }
+    if (delivered && target === msg.agentName)
       markClaudeBusyForInbound(msg.inbound);
-    process.stderr.write(`telegram gateway: inject_inbound agent=${msg.agentName} target=${target} source=${source} prompt_key=${promptKey} delivered=${delivered}
+    process.stderr.write(`telegram gateway: inject_inbound agent=${msg.agentName} target=${target}${fellBackToMain ? " (fellback)" : ""} source=${source} prompt_key=${promptKey} delivered=${delivered}
 `);
     if (!delivered) {
       pendingInboundBuffer.push(target, msg.inbound);

package/telegram-plugin/gateway/cron-session.ts

@@ -43,3 +43,37 @@ export function baseAgent(name: string): string {
 export function resolveInjectTarget(agentName: string, meta: Record<string, string> | undefined): string {
   return meta?.session === "cron" ? cronIdentity(agentName) : agentName;
 }
+
+export interface InjectDelivery {
+  /** The bridge identity the fire was actually delivered to (or last tried). */
+  target: string;
+  delivered: boolean;
+  /** True iff a Tier-1 (cron) fire fell back to the main agent bridge. */
+  fellBackToMain: boolean;
+}
+
+/**
+ * Deliver an inject with graceful Tier-1 fallback (cheap-crons JTBD: a cron
+ * must NEVER be dropped because of tier routing).
+ *
+ * Tries the routed target via `send` (returns true iff delivered). The
+ * cron-session bridge is boot-forked, so a frequent cron added by hot-reload
+ * or agent self-authoring has no live `<agent>-cron` bridge until the next
+ * restart — and a crashed cron session has none either. When a cron-routed
+ * fire isn't delivered, fall back to the MAIN agent bridge so the fire lands
+ * now (full session); it routes cheap again once the cron session is up.
+ * Cheap when available, never broken. Pure: `send` is injected.
+ */
+export function deliverInjectWithFallback(
+  agentName: string,
+  meta: Record<string, string> | undefined,
+  send: (target: string) => boolean,
+): InjectDelivery {
+  const target = resolveInjectTarget(agentName, meta);
+  const wantedCron = target !== agentName;
+  if (send(target)) return { target, delivered: true, fellBackToMain: false };
+  if (wantedCron && send(agentName)) {
+    return { target: agentName, delivered: true, fellBackToMain: true };
+  }
+  return { target, delivered: false, fellBackToMain: false };
+}

package/telegram-plugin/gateway/gateway.ts

@@ -299,7 +299,7 @@ import { handleRequestDriveApproval } from './drive-write-approval.js'
 import { handleRequestMs365Approval } from './ms365-write-approval.js'
 import { buildDiffPreviewCard } from './diff-preview-card.js'
 import { createPendingInboundBuffer, redeliverBufferedInbound, idleDrainTick } from './pending-inbound-buffer.js'
-import { isCronIdentity, resolveInjectTarget } from './cron-session.js'
+import { isCronIdentity, deliverInjectWithFallback } from './cron-session.js'
 import {
   ObligationLedger,
   buildObligationRepresentInbound,
@@ -6425,19 +6425,34 @@ const ipcServer: IpcServer = createIpcServer({
     // unchanged. Route+buffer share the same target so a fire that lands
     // mid cron-session-spawn buffers under the cron identity and drains to
     // it on register.
-    const target = resolveInjectTarget(msg.agentName, msg.inbound.meta)
-    const toCron = target !== msg.agentName
-    const delivered = ipcServer.sendToAgent(target, msg.inbound)
-    // Status-silent (§2.4): a cron fire must NOT set the MAIN agent's
-    // currentTurn (progress card / silence-poke). The cron session is
-    // fire-and-forget; its reply is its only Telegram surface.
-    if (delivered && !toCron) markClaudeBusyForInbound(msg.inbound)
+    // Graceful Tier-1 fallback (cheap-crons JTBD: a cron must NEVER be
+    // dropped because of tier routing). A cron-routed fire whose `<agent>-cron`
+    // bridge isn't connected (boot-forked session not up yet for a hot-added
+    // frequent cron, or a crashed cron session) falls back to the MAIN agent
+    // bridge so the fire lands now; it routes cheap again once the session is
+    // up. See deliverInjectWithFallback.
+    const { target, delivered, fellBackToMain } = deliverInjectWithFallback(
+      msg.agentName,
+      msg.inbound.meta,
+      (t) => ipcServer.sendToAgent(t, msg.inbound),
+    )
+    if (fellBackToMain) {
+      process.stderr.write(
+        `telegram gateway: cron fire fell back to main session (no cron bridge) agent=${msg.agentName} prompt_key=${promptKey}\n`,
+      )
+    }
+    // Status-silent (§2.4): a cron fire delivered to the CRON session must NOT
+    // set the MAIN agent's currentTurn. But a fire that LANDED on the main
+    // bridge (a non-cron fire, or one that fell back) IS a main-session turn —
+    // surface it on the progress card, or the session looks dark.
+    if (delivered && target === msg.agentName) markClaudeBusyForInbound(msg.inbound)
     process.stderr.write(
-      `telegram gateway: inject_inbound agent=${msg.agentName} target=${target} source=${source} prompt_key=${promptKey} delivered=${delivered}\n`,
+      `telegram gateway: inject_inbound agent=${msg.agentName} target=${target}${fellBackToMain ? " (fellback)" : ""} source=${source} prompt_key=${promptKey} delivered=${delivered}\n`,
     )
     // #1150: same buffer-on-failure pattern as vault_grant_approved.
-    // Cron fires use this path too — if a cron-driven wake-up lands
-    // mid bridge-reconnect, buffer it for the next register.
+    // Only reached if BOTH the cron bridge and the main bridge are down
+    // (e.g. mid-restart) — buffer under the bridge we tried last so it
+    // drains on the next register.
     if (!delivered) {
       pendingInboundBuffer.push(target, msg.inbound)
     }

package/telegram-plugin/tests/cron-session.test.ts

@@ -5,6 +5,7 @@ import {
   cronIdentity,
   isCronIdentity,
   resolveInjectTarget,
+  deliverInjectWithFallback,
 } from '../gateway/cron-session.js'
 
 describe('cron-session identity helpers', () => {
@@ -30,3 +31,38 @@ describe('cron-session identity helpers', () => {
     expect(resolveInjectTarget('clerk', { source: 'telegram' })).toBe('clerk')
   })
 })
+
+describe('deliverInjectWithFallback — a cron fire is never dropped by tier routing', () => {
+  it('delivers to the cron bridge when it is connected', () => {
+    const sent: string[] = []
+    const r = deliverInjectWithFallback('clerk', { session: 'cron' }, (t) => (sent.push(t), true))
+    expect(r).toEqual({ target: 'clerk-cron', delivered: true, fellBackToMain: false })
+    expect(sent).toEqual(['clerk-cron']) // tried cron only; it delivered
+  })
+
+  it('falls back to the MAIN bridge when the cron bridge is not connected', () => {
+    // The exact gap: a hot-added / agent-authored frequent cron whose
+    // boot-forked cron session isn't up. Must land on main, not vanish.
+    const sent: string[] = []
+    const r = deliverInjectWithFallback('clerk', { session: 'cron' }, (t) => {
+      sent.push(t)
+      return t === 'clerk' // cron bridge down, main up
+    })
+    expect(r).toEqual({ target: 'clerk', delivered: true, fellBackToMain: true })
+    expect(sent).toEqual(['clerk-cron', 'clerk']) // tried cron, then fell back to main
+  })
+
+  it('reports not-delivered only when BOTH cron and main are down (then it buffers)', () => {
+    const sent: string[] = []
+    const r = deliverInjectWithFallback('clerk', { session: 'cron' }, (t) => (sent.push(t), false))
+    expect(r).toEqual({ target: 'clerk-cron', delivered: false, fellBackToMain: false })
+    expect(sent).toEqual(['clerk-cron', 'clerk']) // tried both, both down
+  })
+
+  it('a non-cron (main) fire never tries a fallback', () => {
+    const sent: string[] = []
+    const r = deliverInjectWithFallback('clerk', { session: 'main' }, (t) => (sent.push(t), false))
+    expect(r).toEqual({ target: 'clerk', delivered: false, fellBackToMain: false })
+    expect(sent).toEqual(['clerk']) // only the main bridge, no cron fallback attempted
+  })
+})