switchroom 0.14.31 → 0.14.33

package/dist/cli/autoaccept-poll.js

@@ -110,6 +110,138 @@ async function runAutoaccept(opts) {
   return { fired, reason: "manual-stop" };
 }
 
+// src/agents/autoaccept.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+var PROMPTS2 = [
+  {
+    name: "dev-channels-loading",
+    match: /Loading.{1,30}development.{1,30}channels/,
+    keys: ["Enter"]
+  },
+  {
+    name: "dev-channels-local",
+    match: /using this for local development/,
+    keys: ["Enter"]
+  },
+  {
+    name: "dev-channels",
+    match: /I.{0,5}accept.{0,80}development.{0,10}channels/,
+    keys: ["Down", "Enter"]
+  },
+  {
+    name: "mcp-trust",
+    match: /Use this and all future MCP servers/,
+    keys: ["Enter"]
+  },
+  {
+    name: "theme",
+    match: /Choose.{1,30}text.{1,30}style/,
+    keys: ["Enter"]
+  },
+  {
+    name: "provider",
+    match: /Anthropic.{1,80}Bedrock/,
+    keys: ["Enter"]
+  },
+  {
+    name: "enter-to-confirm",
+    match: /Enter.{1,30}confirm/,
+    keys: ["Enter"]
+  }
+];
+function capturePane2(agentName) {
+  const socket = `switchroom-${agentName}`;
+  try {
+    const out = execFileSync2("tmux", ["-L", socket, "capture-pane", "-p", "-t", agentName], {
+      timeout: 3000,
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 4 * 1024 * 1024
+    });
+    return out.toString("utf8");
+  } catch (err) {
+    console.error(`[autoaccept] ${agentName}: capture-pane failed: ${err.message}`);
+    return "";
+  }
+}
+function sendKeys2(agentName, keys) {
+  const socket = `switchroom-${agentName}`;
+  try {
+    execFileSync2("tmux", ["-L", socket, "send-keys", "-t", agentName, ...keys], { timeout: 3000, stdio: ["ignore", "pipe", "pipe"] });
+    return true;
+  } catch (err) {
+    console.error(`[autoaccept] ${agentName}: send-keys ${keys.join(" ")} failed: ${err.message}`);
+    return false;
+  }
+}
+
+// src/agents/wedge-watchdog.ts
+var WEDGE_FOOTER_SIGNATURE = /(?=[\s\S]*[Ee]sc(?:ape)?[^\n]*cancel)(?=[\s\S]*(?:to select|to navigate|\u2191\/\u2193))/;
+var DEFAULT_POLL_MS2 = 5000;
+var DEFAULT_STABILITY_THRESHOLD = 3;
+var DEFAULT_COOLDOWN_MS = 60000;
+function defaultSleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function stabilityKey(text) {
+  return text.split(`
+`).map((l) => l.replace(/\s+$/, "")).join(`
+`);
+}
+async function runWedgeWatchdog(opts) {
+  const pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS2;
+  const stabilityThreshold = opts.stabilityThreshold ?? DEFAULT_STABILITY_THRESHOLD;
+  const cooldownMs = opts.cooldownMs ?? DEFAULT_COOLDOWN_MS;
+  const deferToPrompts = opts.deferToPrompts ?? PROMPTS2;
+  const signature = opts.wedgeSignature ?? WEDGE_FOOTER_SIGNATURE;
+  const maxPolls = opts.maxPolls ?? Number.POSITIVE_INFINITY;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? defaultSleep2;
+  const capture = opts.capture ?? capturePane2;
+  const send = opts.send ?? sendKeys2;
+  let stableCount = 0;
+  let lastKey = null;
+  let cooldownUntil = 0;
+  let fires = 0;
+  let polls = 0;
+  while (polls < maxPolls) {
+    polls++;
+    let text = "";
+    try {
+      text = capture(opts.agentName);
+    } catch (err) {
+      console.error(`[wedge-watchdog] ${opts.agentName}: capture threw: ${err.message}`);
+      text = "";
+    }
+    const isBlockingModal = !!text && signature.test(text) && !deferToPrompts.some((p) => p.match.test(text));
+    if (isBlockingModal) {
+      const key = stabilityKey(text);
+      if (key === lastKey) {
+        stableCount++;
+      } else {
+        stableCount = 1;
+        lastKey = key;
+      }
+      if (stableCount >= stabilityThreshold && now() >= cooldownUntil) {
+        console.error(`[wedge-watchdog] ${opts.agentName}: dismissing stuck blocking prompt ` + `(Esc) after ${stableCount} stable polls (~${stableCount * pollIntervalMs / 1000}s) \u2014 no human to answer it`);
+        try {
+          send(opts.agentName, ["Escape"]);
+        } catch (err) {
+          console.error(`[wedge-watchdog] ${opts.agentName}: send threw: ${err.message}`);
+        }
+        fires++;
+        cooldownUntil = now() + cooldownMs;
+        stableCount = 0;
+        lastKey = null;
+      }
+    } else {
+      stableCount = 0;
+      lastKey = null;
+    }
+    await sleep(pollIntervalMs);
+  }
+  return { fires, polls, reason: "max-polls" };
+}
+
 // src/cli/autoaccept-poll.ts
 async function main() {
   const agentName = process.argv[2];
@@ -119,9 +251,20 @@ async function main() {
   }
   try {
     const res = await runAutoaccept({ agentName });
-    console.error(`[autoaccept-poll] ${agentName}: done reason=${res.reason} fired=${res.fired.length ? res.fired.join(",") : "(none)"}`);
+    console.error(`[autoaccept-poll] ${agentName}: boot done reason=${res.reason} fired=${res.fired.length ? res.fired.join(",") : "(none)"}`);
+  } catch (err) {
+    console.error(`[autoaccept-poll] ${agentName}: boot unexpected throw: ${err.message}`);
+  }
+  if (process.env.SWITCHROOM_WEDGE_WATCHDOG === "0") {
+    console.error(`[autoaccept-poll] ${agentName}: wedge-watchdog disabled (SWITCHROOM_WEDGE_WATCHDOG=0) \u2014 exiting after boot phase`);
+    process.exit(0);
+  }
+  try {
+    console.error(`[autoaccept-poll] ${agentName}: entering wedge-watchdog (continuous)`);
+    const res = await runWedgeWatchdog({ agentName });
+    console.error(`[autoaccept-poll] ${agentName}: wedge-watchdog returned reason=${res.reason} fires=${res.fires}`);
   } catch (err) {
-    console.error(`[autoaccept-poll] ${agentName}: unexpected throw: ${err.message}`);
+    console.error(`[autoaccept-poll] ${agentName}: wedge-watchdog unexpected throw: ${err.message}`);
   }
   process.exit(0);
 }

package/dist/cli/switchroom.js

@@ -49420,8 +49420,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.31";
-var COMMIT_SHA = "1aa03b91";
+var VERSION = "0.14.33";
+var COMMIT_SHA = "0b73633c";
 
 // src/cli/agent.ts
 init_source();
@@ -50523,6 +50523,7 @@ var DEFAULT_READ_ONLY_PREAPPROVED_TOOLS = [
   "Skill"
 ];
 var WEBKITE_FLEET_DENY_TOOLS = ["WebFetch", "WebSearch"];
+var INTERACTIVE_TUI_FLEET_DENY_TOOLS = ["AskUserQuestion"];
 var WEBKITE_BINARY_CONTAINER_PATH = "/usr/local/bin/webkite";
 function webkiteBinaryAvailable() {
   const override = process.env.SWITCHROOM_WEBKITE_BINARY;
@@ -51107,7 +51108,8 @@ function buildWorkspaceContext(args) {
     tools,
     toolsDeny: dedupe2([
       ...tools.deny ?? [],
-      ...webkiteDenyForAgent(agentConfig)
+      ...webkiteDenyForAgent(agentConfig),
+      ...INTERACTIVE_TUI_FLEET_DENY_TOOLS
     ]),
     permissionAllow,
     defaultModeAcceptEdits: hasAllWildcard,
@@ -51392,6 +51394,12 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
           allow.push(t);
       }
       settings.permissions.allow = allow;
+      const deny = Array.isArray(settings.permissions.deny) ? settings.permissions.deny : [];
+      for (const t of INTERACTIVE_TUI_FLEET_DENY_TOOLS) {
+        if (!deny.includes(t))
+          deny.push(t);
+      }
+      settings.permissions.deny = deny;
       if (settings.mcpServers && "switchroom" in settings.mcpServers) {
         delete settings.mcpServers["switchroom"];
       }
@@ -52126,7 +52134,8 @@ function reconcileAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchr
   ]);
   const desiredDeny = dedupe2([
     ...tools.deny ?? [],
-    ...webkiteDenyForAgent(agentConfig)
+    ...webkiteDenyForAgent(agentConfig),
+    ...INTERACTIVE_TUI_FLEET_DENY_TOOLS
   ]);
   let topicId = agentConfig.topic_id;
   if (topicId === undefined) {

package/dist/host-control/main.js

@@ -14918,7 +14918,11 @@ import {
   writeFileSync as writeFileSync3,
   renameSync,
   mkdirSync as mkdirSync2,
-  unlinkSync
+  openSync as openSync2,
+  ftruncateSync,
+  writeSync,
+  fsyncSync,
+  closeSync as closeSync2
 } from "node:fs";
 import { join as join3, dirname as dirname4, resolve as resolve5 } from "node:path";
 import { randomUUID as randomUUID2, randomBytes } from "node:crypto";
@@ -20740,10 +20744,23 @@ function formatConfigApprovalDenyError(approval, approvalId) {
   const suffix = approval.reason ? `: ${approval.reason}` : "";
   return `E_DENIED: operator denied config_propose_edit${suffix} (approval_id=${approvalId})`;
 }
-function unlinkSyncBestEffort(path2) {
+function writeFileInPlacePreservingInode(targetPath, content) {
+  const buf = Buffer.from(content, "utf-8");
+  const fd = openSync2(targetPath, "r+");
   try {
-    unlinkSync(path2);
-  } catch {}
+    ftruncateSync(fd, 0);
+    let off = 0;
+    while (off < buf.length) {
+      off += writeSync(fd, buf, off, buf.length - off, off);
+    }
+    fsyncSync(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  const readBack = readFileSync5(targetPath);
+  if (readBack.length !== buf.length) {
+    throw new Error(`in-place write short: wrote ${buf.length} bytes but read back ${readBack.length}`);
+  }
 }
 var STATUS_RETENTION_MS = 10 * 60 * 1000;
 var STATUS_MAX_ENTRIES = 256;
@@ -21341,15 +21358,15 @@ class HostdServer {
         return this.reconcileFailedRolledBack(`snapshot read failed: ${e.message}`, req, caller, started);
       }
       const postApply = verdict.postApplyContent;
-      const tmp = configPath + ".tmp";
       try {
-        writeFileSync3(tmp, postApply);
-        renameSync(tmp, configPath);
+        writeFileInPlacePreservingInode(configPath, postApply);
       } catch (e) {
-        unlinkSyncBestEffort(tmp);
+        try {
+          writeFileInPlacePreservingInode(configPath, snapshot);
+        } catch {}
         await approval.finalize({
           outcome: "reconcile_failed_rolled_back",
-          detail: `atomic write failed: ${e.message}`
+          detail: `in-place write failed: ${e.message}`
         });
         return this.reconcileFailedRolledBack(`write failed: ${e.message}`, req, caller, started);
       }
@@ -21369,8 +21386,7 @@ class HostdServer {
       }
       let rollbackDetail = "";
       try {
-        writeFileSync3(tmp, snapshot);
-        renameSync(tmp, configPath);
+        writeFileInPlacePreservingInode(configPath, snapshot);
       } catch (e) {
         rollbackDetail = `snapshot restore failed: ${e.message}`;
         await approval.finalize({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.31",
+  "version": "0.14.33",
   "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/profiles/_base/start.sh.hbs

@@ -111,10 +111,15 @@ if [ "$SWITCHROOM_RUNTIME" = "docker" ] && [ -z "$SWITCHROOM_DOCKER_TMUX_INNER"
     echo "[start.sh] channels.telegram.enabled=false — skipping gateway sidecar" >&2
   fi
 
-  # 2) autoaccept-poll — first-run TUI prompt dispatcher. Single-shot
-  #    by design (exits cleanly after idle-timeout once prompts have
-  #    fired); the supervisor's exponential backoff keeps a flaky
-  #    autoaccept from busy-looping.
+  # 2) autoaccept-poll — first-run TUI prompt dispatcher, then continuous
+  #    wedge-watchdog. Two phases in one process: a one-shot boot phase
+  #    dispatches the first-run prompts and returns after idle-timeout,
+  #    then the process stays alive running the wedge-watchdog (dismisses a
+  #    stuck blocking modal selector mid-session — the AskUserQuestion /
+  #    ExitPlanMode class — with Esc). So it is NORMALLY long-lived; the
+  #    supervisor only respawns it if it crashes/exits, and its backoff
+  #    keeps a flaky run from busy-looping. Set SWITCHROOM_WEDGE_WATCHDOG=0
+  #    to restore the legacy boot-only single-shot behaviour.
   if [ -f /opt/switchroom/autoaccept-poll.js ] && command -v bun >/dev/null 2>&1; then
     _switchroom_supervise autoaccept /var/log/switchroom/autoaccept.log \
       bun /opt/switchroom/autoaccept-poll.js "{{name}}" &

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

@@ -51766,10 +51766,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.31";
-var COMMIT_SHA = "1aa03b91";
-var COMMIT_DATE = "2026-06-01T06:45:00Z";
-var LATEST_PR = 2060;
+var VERSION = "0.14.33";
+var COMMIT_SHA = "0b73633c";
+var COMMIT_DATE = "2026-06-01T12:35:17Z";
+var LATEST_PR = 2066;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52186,6 +52186,10 @@ function recordTurnEnd(db2, args) {
     WHERE turn_key = ?
   `).run(now, args.endedVia, args.lastAssistantMsgId ?? null, args.lastAssistantDone !== undefined ? args.lastAssistantDone ? 1 : 0 : null, args.assistantReplyPreview ?? null, args.toolCallCount !== undefined ? args.toolCallCount : null, now, args.turnKey);
 }
+function getTurnByKey(db2, turnKey) {
+  const row = db2.prepare(`SELECT * FROM turns WHERE turn_key = ?`).get(turnKey);
+  return row ? mapRow(row) : null;
+}
 function markOrphanedWithTimeoutClassification(db2, opts) {
   const now = opts.now ?? Date.now();
   const isHang = opts.markerAgeMs != null && opts.markerAgeMs >= opts.hangThresholdMs && opts.markerTurnKey != null && opts.markerTurnKey.length > 0;
@@ -52831,6 +52835,25 @@ try {
 `);
   turnsDb = null;
 }
+function resolveSubagentOriginChat(agentId) {
+  if (turnsDb == null)
+    return null;
+  try {
+    const sub = getSubagentByJsonlId(turnsDb, agentId);
+    if (sub?.parent_turn_key == null)
+      return null;
+    const turn = getTurnByKey(turnsDb, sub.parent_turn_key);
+    if (turn == null || turn.chat_id.length === 0)
+      return null;
+    const threadNum = turn.thread_id != null && turn.thread_id.length > 0 ? Number(turn.thread_id) : NaN;
+    return {
+      chatId: turn.chat_id,
+      threadId: Number.isFinite(threadNum) ? threadNum : undefined
+    };
+  } catch {
+    return null;
+  }
+}
 var REGISTRY_REAPER_INTERVAL_MS = 21600000;
 function runHistoryReaperNow(reason) {
   const retentionDays = resolveRetentionDays(HISTORY_ACCESS.historyRetentionDays);
@@ -62616,7 +62639,7 @@ var didOneTimeSetup = false;
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
                   outcome,
                   isBackground,
-                  fleetChatId,
+                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
                   ownerChatId: loadAccess().allowFrom[0] ?? "",
                   taskDescription: description,
                   resultText,
@@ -62695,20 +62718,21 @@ var didOneTimeSetup = false;
                   return;
                 }
                 if (workerFeedEnabled) {
-                  workerActivityFeed.update(agentId, fleetChatId || (loadAccess().allowFrom[0] ?? ""), {
+                  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;
                 }
                 const decision = decideSubagentProgress({
                   disableEnvValue: process.env.SWITCHROOM_DISABLE_SUBAGENT_PROGRESS,
                   isBackground,
-                  fleetChatId,
+                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
                   ownerChatId: loadAccess().allowFrom[0] ?? "",
                   subagentJsonlId: agentId,
                   taskDescription: description,

package/telegram-plugin/gateway/gateway.ts

@@ -427,6 +427,7 @@ import {
   recordTurnEnd,
   findLatestTurnIfInterrupted,
   findRecentTurnsForChat,
+  getTurnByKey,
 } from '../registry/turns-schema.js'
 import {
   buildResumeInterruptedInbound,
@@ -1117,6 +1118,41 @@ try {
   turnsDb = null
 }
 
+/**
+ * Resolve the chat/thread a background sub-agent was dispatched from, so
+ * its live worker card + handback route back to the originating
+ * conversation (group / forum topic) instead of the operator DM.
+ *
+ * Walks jsonl_agent_id → `subagents.parent_turn_key` →
+ * `turns.chat_id`/`thread_id`. Returns null on any miss so the caller
+ * keeps its existing `allowFrom[0]` DM fallback — best-effort, never
+ * throws out of the worker-card hot path. This restores the chat context
+ * the pinned-card fleet used to carry before it was removed in #1122
+ * (progressDriver is permanently null, so the old fleet lookup always
+ * yielded the DM for a Task dispatched from a group/topic).
+ */
+function resolveSubagentOriginChat(
+  agentId: string,
+): { chatId: string; threadId?: number } | null {
+  if (turnsDb == null) return null
+  try {
+    const sub = getSubagentByJsonlId(turnsDb, agentId)
+    if (sub?.parent_turn_key == null) return null
+    const turn = getTurnByKey(turnsDb, sub.parent_turn_key)
+    if (turn == null || turn.chat_id.length === 0) return null
+    const threadNum =
+      turn.thread_id != null && turn.thread_id.length > 0
+        ? Number(turn.thread_id)
+        : NaN
+    return {
+      chatId: turn.chat_id,
+      threadId: Number.isFinite(threadNum) ? threadNum : undefined,
+    }
+  } catch {
+    return null
+  }
+}
+
 // ─── Periodic history reaper (#1073) ──────────────────────────────────────
 // The init-time prune in history.ts only touched the `messages` table.
 // `subagents` and `turns` in registry.db grew unbounded — every Agent()
@@ -18371,11 +18407,15 @@ void (async () => {
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
                   outcome,
                   isBackground,
-                  fleetChatId,
-                  // Owner-chat fallback: if the progress-driver fleet
-                  // entry was already cleaned up, route to the owner
-                  // chat. Every switchroom fleet agent is DM-shaped, so
-                  // allowFrom[0] is the conversation that dispatched.
+                  // Route the handback (the worker's result → a synthesized
+                  // turn) back to the conversation the Task was dispatched
+                  // from, so the result lands where the user asked — not the
+                  // agent's DM. Falls back to fleetChatId/ownerChatId.
+                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
+                  // Owner-chat fallback: if the parent-turn chat can't be
+                  // resolved, route to the owner chat. Every switchroom fleet
+                  // agent is DM-shaped, so allowFrom[0] is the conversation
+                  // that dispatched.
                   ownerChatId: loadAccess().allowFrom[0] ?? '',
                   taskDescription: description,
                   resultText,
@@ -18505,12 +18545,16 @@ void (async () => {
                 // message owns the progress beat. Push a running cue and
                 // return BEFORE the legacy bucket relay so the same activity
                 // isn't double-surfaced (in-message edit + injected
-                // "still working" inbound turn). Chat = owner DM, since the
-                // pinned-card fleet is gone and every agent is DM-shaped.
+                // "still working" inbound turn). Route to the conversation
+                // the Task was dispatched from (group / forum topic) via the
+                // parent turn; fall back to the owner DM when that can't be
+                // resolved (the pinned-card fleet that used to carry the chat
+                // is gone — see resolveSubagentOriginChat).
                 if (workerFeedEnabled) {
+                  const origin = resolveSubagentOriginChat(agentId)
                   void workerActivityFeed.update(
                     agentId,
-                    fleetChatId || (loadAccess().allowFrom[0] ?? ''),
+                    origin?.chatId || fleetChatId || (loadAccess().allowFrom[0] ?? ''),
                     {
                       description: dispatch.feedDescription,
                       lastTool,
@@ -18519,6 +18563,7 @@ void (async () => {
                       elapsedMs,
                       state: 'running',
                     },
+                    origin?.threadId,
                   )
                   return
                 }
@@ -18526,7 +18571,9 @@ void (async () => {
                 const decision = decideSubagentProgress({
                   disableEnvValue: process.env.SWITCHROOM_DISABLE_SUBAGENT_PROGRESS,
                   isBackground,
-                  fleetChatId,
+                  // Prefer the conversation the Task was dispatched from over
+                  // the owner DM (see resolveSubagentOriginChat).
+                  fleetChatId: resolveSubagentOriginChat(agentId)?.chatId || fleetChatId,
                   ownerChatId: loadAccess().allowFrom[0] ?? '',
                   subagentJsonlId: agentId,
                   taskDescription: description,

package/telegram-plugin/registry/turns-schema.test.ts

@@ -20,6 +20,7 @@ import {
   recordTurnStart,
   recordTurnEnd,
   findRecentTurnsForChat,
+  getTurnByKey,
 } from './turns-schema.js'
 
 // ---------------------------------------------------------------------------
@@ -99,3 +100,36 @@ describe('findRecentTurnsForChat', () => {
     db.close()
   })
 })
+
+// ---------------------------------------------------------------------------
+// getTurnByKey — recover the dispatch chat/thread for a sub-agent's parent
+// turn (subagents.parent_turn_key -> turns.turn_key). Without this the
+// worker card / handback fall back to the operator DM (#worker-card-routing).
+// ---------------------------------------------------------------------------
+
+describe('getTurnByKey', () => {
+  it('returns null when the turn key does not exist', () => {
+    const db = openTurnsDbInMemory()
+    expect(getTurnByKey(db, 'nope')).toBeNull()
+    db.close()
+  })
+
+  it('recovers chat_id + thread_id for a group/topic turn', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'g:11', chatId: '-1001234567890', threadId: '42' })
+    const turn = getTurnByKey(db, 'g:11')
+    expect(turn?.turn_key).toBe('g:11')
+    expect(turn?.chat_id).toBe('-1001234567890')
+    expect(turn?.thread_id).toBe('42')
+    db.close()
+  })
+
+  it('recovers chat_id with null thread_id for a plain group/DM turn', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'dm:7', chatId: '12345' })
+    const turn = getTurnByKey(db, 'dm:7')
+    expect(turn?.chat_id).toBe('12345')
+    expect(turn?.thread_id).toBeNull()
+    db.close()
+  })
+})

package/telegram-plugin/registry/turns-schema.ts

@@ -348,6 +348,24 @@ export function findOrphanedTurns(db: SqliteDatabase, chatId: string): Turn[] {
   return rows.map(mapRow)
 }
 
+/**
+ * Fetch a single turn by its primary key, or null if absent.
+ *
+ * Used to recover the chat/thread a background sub-agent was dispatched
+ * from: `subagents.parent_turn_key` is an FK-by-convention to
+ * `turns.turn_key`, so this resolves the originating conversation
+ * (chat_id + thread_id) for a worker card / handback. Without it the
+ * worker feed falls back to the operator DM (the pinned-card fleet that
+ * used to carry the chat was removed in #1122), so a Task dispatched from
+ * a group/topic posted its progress to the agent's DM instead.
+ */
+export function getTurnByKey(db: SqliteDatabase, turnKey: string): Turn | null {
+  const row = db
+    .prepare(`SELECT * FROM turns WHERE turn_key = ?`)
+    .get(turnKey) as RawTurnRow | undefined
+  return row ? mapRow(row) : null
+}
+
 export interface OrphanClassifyOpts {
   /**
    * `turnKey` from the on-disk `turn-active.json` marker — the single