switchroom 0.14.90 → 0.14.91

package/dist/cli/switchroom.js

@@ -49815,8 +49815,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.90";
-var COMMIT_SHA = "6386ff19";
+var VERSION = "0.14.91";
+var COMMIT_SHA = "e938daab";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.90",
+  "version": "0.14.91",
   "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

@@ -52900,10 +52900,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.90";
-var COMMIT_SHA = "6386ff19";
-var COMMIT_DATE = "2026-06-08T00:05:33Z";
-var LATEST_PR = 2235;
+var VERSION = "0.14.91";
+var COMMIT_SHA = "e938daab";
+var COMMIT_DATE = "2026-06-09T03:14:21Z";
+var LATEST_PR = 2241;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -53545,6 +53545,21 @@ function resolveWorkerFeedDispatch(sub, watcherDescription) {
   };
 }
 
+// gateway/subagent-status-surface.ts
+function resolveSubagentStatusSurface(input) {
+  if (!input.isBackground) {
+    if (input.liveTurnPresent)
+      return "nest";
+    if (!input.orphanStatusEnabled)
+      return "skip";
+    return input.workerFeedEnabled ? "worker-feed" : "skip";
+  }
+  return input.workerFeedEnabled ? "worker-feed" : "legacy-relay";
+}
+function isOrphanSubagentStatusEnabled(envVal) {
+  return envVal !== "0";
+}
+
 // gateway/resolve-calling-subagent.ts
 function resolveCallingSubagent(opts) {
   if (opts.db == null)
@@ -64569,6 +64584,7 @@ var didOneTimeSetup = false;
           if (watcherAgentDir != null) {
             const workerFeedEnabled = isWorkerActivityFeedEnabled(process.env.SWITCHROOM_WORKER_ACTIVITY_FEED);
             const foregroundNestingEnabled = process.env.SWITCHROOM_FOREGROUND_SUBAGENT_NESTING !== "0";
+            const orphanStatusEnabled = isOrphanSubagentStatusEnabled(process.env.SWITCHROOM_ORPHAN_SUBAGENT_STATUS);
             const workerActivityFeed = createWorkerActivityFeed({
               bot: {
                 sendMessage: async (cid, text, sendOpts) => {
@@ -64650,6 +64666,22 @@ var didOneTimeSetup = false;
                         }
                       }
                     }
+                    return;
+                  }
+                  if (resolveSubagentStatusSurface({
+                    isBackground: false,
+                    liveTurnPresent: false,
+                    workerFeedEnabled,
+                    orphanStatusEnabled
+                  }) === "worker-feed") {
+                    workerActivityFeed.finish(agentId, {
+                      description: dispatch.feedDescription,
+                      lastTool: null,
+                      toolCount,
+                      latestSummary: resultText,
+                      elapsedMs: durationMs,
+                      state: outcome === "failed" ? "failed" : "done"
+                    });
                   }
                   return;
                 }
@@ -64716,6 +64748,26 @@ var didOneTimeSetup = false;
                 }
                 const isBackground = dispatch.isBackground;
                 if (!isBackground) {
+                  const surface = resolveSubagentStatusSurface({
+                    isBackground: false,
+                    liveTurnPresent: currentTurn != null,
+                    workerFeedEnabled,
+                    orphanStatusEnabled
+                  });
+                  if (surface === "worker-feed") {
+                    const origin = resolveSubagentOriginChat(agentId);
+                    workerActivityFeed.update(agentId, origin?.chatId || fleetChatId || (loadAccess().allowFrom[0] ?? ""), {
+                      description: dispatch.feedDescription,
+                      lastTool,
+                      toolCount,
+                      latestSummary,
+                      elapsedMs,
+                      state: "running"
+                    }, origin?.threadId);
+                    return;
+                  }
+                  if (surface !== "nest")
+                    return;
                   const turn = currentTurn;
                   if (turn == null)
                     return;

package/telegram-plugin/gateway/gateway.ts

@@ -471,6 +471,10 @@ import {
 } from './resume-inbound-builder.js'
 import { applySubagentsSchema, getSubagentByJsonlId } from '../registry/subagents-schema.js'
 import { resolveWorkerFeedDispatch, type WorkerFeedDispatch } from './worker-feed-dispatch.js'
+import {
+  resolveSubagentStatusSurface,
+  isOrphanSubagentStatusEnabled,
+} from './subagent-status-surface.js'
 import { formatIdleFooter } from '../idle-footer.js'
 import { resolveCallingSubagent } from './resolve-calling-subagent.js'
 
@@ -20410,6 +20414,11 @@ void (async () => {
             // compose draft, so no answer-stream contention). The kill-switch
             // disables only the nesting; the parent's own feed is unaffected.
             const foregroundNestingEnabled = process.env.SWITCHROOM_FOREGROUND_SUBAGENT_NESTING !== '0'
+            // Orphaned-foreground status (2026-06-09): a FOREGROUND sub-agent
+            // with no live parent turn to nest into (dispatched outside a turn,
+            // or the turn ended while it kept running — extended autonomous
+            // work) is surfaced via the worker feed instead of vanishing.
+            const orphanStatusEnabled = isOrphanSubagentStatusEnabled(process.env.SWITCHROOM_ORPHAN_SUBAGENT_STATUS)
             const workerActivityFeed = createWorkerActivityFeed({
               bot: {
                 sendMessage: async (cid, text, sendOpts) => {
@@ -20609,6 +20618,29 @@ void (async () => {
                         }
                       }
                     }
+                    return
+                  }
+                  // Not nested → an orphaned foreground sub-agent that was
+                  // surfaced via the worker feed (no live turn to nest into):
+                  // finalize its message (no-op if none was posted). A
+                  // foreground result returns inline as the Task tool result, so
+                  // there is no handback to deliver — return after.
+                  if (
+                    resolveSubagentStatusSurface({
+                      isBackground: false,
+                      liveTurnPresent: false,
+                      workerFeedEnabled,
+                      orphanStatusEnabled,
+                    }) === 'worker-feed'
+                  ) {
+                    void workerActivityFeed.finish(agentId, {
+                      description: dispatch.feedDescription,
+                      lastTool: null,
+                      toolCount,
+                      latestSummary: resultText,
+                      elapsedMs: durationMs,
+                      state: outcome === 'failed' ? 'failed' : 'done',
+                    })
                   }
                   return
                 }
@@ -20738,8 +20770,39 @@ void (async () => {
                   // activity draft rather than a separate worker message. Pure
                   // jsonl-tail → render (no model call), inside the
                   // subscription-honest boundary.
+                  //
+                  // But a foreground sub-agent with NO live turn to nest into
+                  // (dispatched outside a turn, or the turn ended while it kept
+                  // running — extended autonomous work) has nowhere to nest, and
+                  // pre-fix it silently returned here → invisible. Route through
+                  // the proven decision: an orphaned foreground sub-agent goes to
+                  // the worker feed (owner-DM fallback), not into the void.
+                  const surface = resolveSubagentStatusSurface({
+                    isBackground: false,
+                    liveTurnPresent: currentTurn != null,
+                    workerFeedEnabled,
+                    orphanStatusEnabled,
+                  })
+                  if (surface === 'worker-feed') {
+                    const origin = resolveSubagentOriginChat(agentId)
+                    void workerActivityFeed.update(
+                      agentId,
+                      origin?.chatId || fleetChatId || (loadAccess().allowFrom[0] ?? ''),
+                      {
+                        description: dispatch.feedDescription,
+                        lastTool,
+                        toolCount,
+                        latestSummary,
+                        elapsedMs,
+                        state: 'running',
+                      },
+                      origin?.threadId,
+                    )
+                    return
+                  }
+                  if (surface !== 'nest') return // 'skip' — orphan-status off
                   const turn = currentTurn
-                  if (turn == null) return
+                  if (turn == null) return // defensive: 'nest' implies a live turn
                   // Render regardless of `replyCalled` — a foreground Task
                   // blocks the parent, so any reply seen while it runs is an
                   // interim ack, never the final answer. Gating on replyCalled

package/telegram-plugin/gateway/subagent-status-surface.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest'
+import {
+  resolveSubagentStatusSurface,
+  isOrphanSubagentStatusEnabled,
+  type SubagentStatusSurface,
+  type SubagentStatusSurfaceInput,
+} from './subagent-status-surface.js'
+
+// ── Human-readable map ──────────────────────────────────────────────────────
+describe('resolveSubagentStatusSurface', () => {
+  const base: SubagentStatusSurfaceInput = {
+    isBackground: false,
+    liveTurnPresent: true,
+    workerFeedEnabled: true,
+    orphanStatusEnabled: true,
+  }
+  it('foreground + live turn → nest (unchanged default)', () => {
+    expect(resolveSubagentStatusSurface(base)).toBe('nest')
+  })
+  it('THE fix: orphaned foreground (no live turn) → worker-feed', () => {
+    expect(resolveSubagentStatusSurface({ ...base, liveTurnPresent: false })).toBe('worker-feed')
+  })
+  it('kill switch: orphaned foreground with orphanStatus OFF → skip (pre-fix invisible)', () => {
+    expect(
+      resolveSubagentStatusSurface({ ...base, liveTurnPresent: false, orphanStatusEnabled: false }),
+    ).toBe('skip')
+  })
+  it('orphaned foreground but feed OFF → skip (nothing to surface through)', () => {
+    expect(
+      resolveSubagentStatusSurface({ ...base, liveTurnPresent: false, workerFeedEnabled: false }),
+    ).toBe('skip')
+  })
+  it('background + feed on → worker-feed', () => {
+    expect(resolveSubagentStatusSurface({ ...base, isBackground: true, liveTurnPresent: false })).toBe('worker-feed')
+  })
+  it('background + feed off → legacy-relay', () => {
+    expect(
+      resolveSubagentStatusSurface({ ...base, isBackground: true, workerFeedEnabled: false }),
+    ).toBe('legacy-relay')
+  })
+})
+
+describe('isOrphanSubagentStatusEnabled — default ON, =0 kill switch', () => {
+  it('undefined / "1" / "" → on; "0" → off', () => {
+    expect(isOrphanSubagentStatusEnabled(undefined)).toBe(true)
+    expect(isOrphanSubagentStatusEnabled('1')).toBe(true)
+    expect(isOrphanSubagentStatusEnabled('')).toBe(true)
+    expect(isOrphanSubagentStatusEnabled('0')).toBe(false)
+  })
+})
+
+// ── TOTAL-ENUMERATION DETERMINISM PROOF ─────────────────────────────────────
+// 4 booleans = 16 reachable inputs. Enumerate all, assert totality, determinism,
+// the documented table (independent spec), and the load-bearing invariants.
+// (operator standard feedback_prove_finite_fsm_not_sample.)
+function allInputs(): SubagentStatusSurfaceInput[] {
+  const rows: SubagentStatusSurfaceInput[] = []
+  for (const isBackground of [false, true])
+    for (const liveTurnPresent of [false, true])
+      for (const workerFeedEnabled of [false, true])
+        for (const orphanStatusEnabled of [false, true])
+          rows.push({ isBackground, liveTurnPresent, workerFeedEnabled, orphanStatusEnabled })
+  return rows
+}
+
+// Independent spec encoding (kept separate from the impl).
+function spec(i: SubagentStatusSurfaceInput): SubagentStatusSurface {
+  if (i.isBackground) return i.workerFeedEnabled ? 'worker-feed' : 'legacy-relay'
+  if (i.liveTurnPresent) return 'nest'
+  if (!i.orphanStatusEnabled) return 'skip'
+  return i.workerFeedEnabled ? 'worker-feed' : 'skip'
+}
+
+describe('resolveSubagentStatusSurface — total enumeration (16 inputs)', () => {
+  const ROWS = allInputs()
+
+  it('exactly 16 reachable inputs (2^4)', () => {
+    expect(ROWS.length).toBe(16)
+  })
+  it('TOTAL + DETERMINISTIC: every input returns one of the four surfaces, idempotently', () => {
+    const surfaces = new Set<SubagentStatusSurface>(['nest', 'worker-feed', 'legacy-relay', 'skip'])
+    for (const i of ROWS) {
+      const a = resolveSubagentStatusSurface(i)
+      expect(surfaces.has(a)).toBe(true)
+      expect(resolveSubagentStatusSurface({ ...i })).toBe(a)
+    }
+  })
+  it('PRECEDENCE: matches the documented spec on all 16 inputs', () => {
+    for (const i of ROWS) expect(resolveSubagentStatusSurface(i)).toBe(spec(i))
+  })
+
+  it('INV-ORPHAN-VISIBLE: an orphaned foreground sub-agent is NEVER skip when orphanStatus + feed are on', () => {
+    for (const i of ROWS) {
+      if (!i.isBackground && !i.liveTurnPresent && i.orphanStatusEnabled && i.workerFeedEnabled) {
+        expect(resolveSubagentStatusSurface(i)).toBe('worker-feed')
+      }
+    }
+  })
+  it('INV-KILL-SWITCH: orphanStatus OFF ⇒ an orphaned foreground sub-agent is exactly the pre-fix behaviour (skip)', () => {
+    for (const i of ROWS) {
+      if (!i.isBackground && !i.liveTurnPresent && !i.orphanStatusEnabled) {
+        expect(resolveSubagentStatusSurface(i)).toBe('skip')
+      }
+    }
+  })
+  it('INV-NEST-UNCHANGED: a foreground sub-agent with a live turn is ALWAYS nest, independent of the other flags', () => {
+    for (const i of ROWS) {
+      if (!i.isBackground && i.liveTurnPresent) expect(resolveSubagentStatusSurface(i)).toBe('nest')
+    }
+  })
+  it('INV-BACKGROUND-UNCHANGED: background routing depends ONLY on the feed flag, never on liveTurn/orphanStatus', () => {
+    for (const i of ROWS) {
+      if (i.isBackground) {
+        expect(resolveSubagentStatusSurface(i)).toBe(i.workerFeedEnabled ? 'worker-feed' : 'legacy-relay')
+      }
+    }
+  })
+})

package/telegram-plugin/gateway/subagent-status-surface.ts

@@ -0,0 +1,69 @@
+/**
+ * Where does a sub-agent's live status go?
+ *
+ * A sub-agent's progress is surfaced on one of four "surfaces". This pure
+ * decision picks which, so the routing is provable by total enumeration rather
+ * than buried in the gateway's imperative branches.
+ *
+ *   - `nest`         — a FOREGROUND sub-agent running inside a LIVE parent turn:
+ *                      its narrative nests under the parent's activity draft
+ *                      (the progress card). The default, unchanged.
+ *   - `worker-feed`  — a BACKGROUND worker (the `🛠 Worker` edit-in-place
+ *                      message), OR a FOREGROUND sub-agent that has NO live
+ *                      parent turn to nest into (dispatched outside a turn, or
+ *                      the turn ended while it kept running). The latter is the
+ *                      2026-06-09 fix: extended autonomous work was invisible
+ *                      because foreground status was turn-scoped and a sub-agent
+ *                      with no turn silently returned. It now reuses the worker
+ *                      feed (with the same owner-DM fallback background workers
+ *                      already use), so post-turn work is always visible.
+ *   - `legacy-relay` — a BACKGROUND worker when the worker feed is OFF: fall
+ *                      back to the legacy "still working" injected-inbound relay.
+ *   - `skip`         — nothing to surface (kill-switch off for an orphaned
+ *                      foreground, or no feed to surface it through).
+ *
+ * Determinism: the input space is 4 booleans = 16 rows, enumerated and proven
+ * in subagent-status-surface.test.ts (operator standard
+ * feedback_prove_finite_fsm_not_sample). The load-bearing invariant: an
+ * orphaned foreground sub-agent (no live turn) is `worker-feed`, never `skip`,
+ * whenever the orphan-status flag and the feed are both on.
+ */
+
+export type SubagentStatusSurface = 'nest' | 'worker-feed' | 'legacy-relay' | 'skip'
+
+export interface SubagentStatusSurfaceInput {
+  /** run_in_background dispatch (registry `subagents.background`). */
+  isBackground: boolean
+  /**
+   * A LIVE parent turn exists to nest this (foreground) sub-agent into.
+   * onProgress: `currentTurn != null`. onFinish: `currentTurn != null && it was
+   * actually nested` (so a foreground sub-agent that was surfaced via the worker
+   * feed — never nested — finalizes through the feed, not a turn collapse).
+   * Ignored for background sub-agents.
+   */
+  liveTurnPresent: boolean
+  /** SWITCHROOM_WORKER_ACTIVITY_FEED on. */
+  workerFeedEnabled: boolean
+  /** SWITCHROOM_ORPHAN_SUBAGENT_STATUS on — surface no-parent-turn foreground
+   *  sub-agents via the worker feed. Off = pre-fix behaviour (invisible). */
+  orphanStatusEnabled: boolean
+}
+
+export function resolveSubagentStatusSurface(
+  input: SubagentStatusSurfaceInput,
+): SubagentStatusSurface {
+  if (!input.isBackground) {
+    // Foreground sub-agent.
+    if (input.liveTurnPresent) return 'nest'
+    // Orphaned foreground: no live turn to nest into — the invisible case.
+    if (!input.orphanStatusEnabled) return 'skip' // kill switch: pre-fix behaviour
+    return input.workerFeedEnabled ? 'worker-feed' : 'skip' // surfacing needs the feed
+  }
+  // Background worker.
+  return input.workerFeedEnabled ? 'worker-feed' : 'legacy-relay'
+}
+
+/** SWITCHROOM_ORPHAN_SUBAGENT_STATUS — default ON; `=0` restores pre-fix (invisible) behaviour. */
+export function isOrphanSubagentStatusEnabled(envVal: string | undefined): boolean {
+  return envVal !== '0'
+}