mixdog 0.9.0 → 0.9.2

package/src/runtime/channels/lib/cli-worker-host.mjs

@@ -1,12 +1,5 @@
-function hasCliWorker() {
-  return true;
-}
 function startCliWorker(_options) {
 }
-async function stopCliWorker() {
-}
 export {
-  hasCliWorker,
-  startCliWorker,
-  stopCliWorker
+  startCliWorker
 };

package/src/runtime/channels/lib/config.mjs

@@ -1,7 +1,8 @@
 import { readFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { DiscordBackend } from "../backends/discord.mjs";
-import { readSection, updateSection, CONFIG_PATH as MIXDOG_CONFIG_PATH, getDiscordToken, diagnoseDiscordTokenValue } from "../../shared/config.mjs";
+import { TelegramBackend } from "../backends/telegram.mjs";
+import { readSection, updateSection, CONFIG_PATH as MIXDOG_CONFIG_PATH, getDiscordToken, getTelegramToken, diagnoseDiscordTokenValue } from "../../shared/config.mjs";
 import { listSchedules } from "../../shared/schedules-store.mjs";
 import { resolvePluginData } from "../../shared/plugin-paths.mjs";
 import { isHolidaySync } from "./holidays.mjs";
@@ -15,6 +16,7 @@ const DEFAULT_ACCESS = {
 const DEFAULT_CONFIG = {
   backend: "discord",
   discord: { token: "" },
+  telegram: { token: "" },
   access: DEFAULT_ACCESS,
   mainChannel: "main",
   channelsConfig: {
@@ -47,6 +49,22 @@ function applyDefaults(config) {
   out.webhook = { ...CONFIG_DEFAULTS.webhook, ...(out.webhook || {}) };
   return out;
 }
+
+function channelIdForBackend(entry = {}, backend = "discord") {
+  if (backend === "telegram") {
+    return String(entry?.telegramChatId || (entry?.discordChannelId ? "" : entry?.channelId) || "");
+  }
+  return String(entry?.discordChannelId || (entry?.telegramChatId ? "" : entry?.channelId) || "");
+}
+
+function channelsConfigForBackend(rawChannelsConfig = {}, backend = "discord") {
+  return Object.fromEntries(Object.entries(rawChannelsConfig || {}).map(([name, entry]) => {
+    const value = entry && typeof entry === "object" ? entry : {};
+    const channelId = channelIdForBackend(value, backend);
+    return [name, { ...value, channelId }];
+  }));
+}
+
 /**
  * Shared DND / quiet-window helper used by scheduler + webhook.
  *
@@ -185,11 +203,20 @@ function loadConfig() {
     if (discordTokenProblem) {
       process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
     }
+    // Single-backend select: config.backend picks ONE of discord|telegram.
+    // Anything else falls back to the discord default.
+    const backend = raw.backend === "telegram" ? "telegram" : "discord";
+    const telegramToken = getTelegramToken();
+    const rawChannelsConfig = { ...DEFAULT_CONFIG.channelsConfig, ...(raw.channelsConfig || {}) };
     return applyDefaults({
       ...DEFAULT_CONFIG,
       ...raw,
-      backend: "discord",
+      backend,
+      channelsConfig: channelsConfigForBackend(rawChannelsConfig, backend),
       discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
+      // Merge the keychain-resolved telegram token (harmless when backend is
+      // discord; the secret never lands in the on-disk config either way).
+      telegram: { ...DEFAULT_CONFIG.telegram, ...(({ token: _t, ...rest }) => rest)(raw.telegram || {}), ...(telegramToken ? { token: telegramToken } : {}) },
       access: {
         ...DEFAULT_ACCESS,
         // Drop the retired pairing-era keys at the config layer too (the
@@ -218,6 +245,10 @@ function loadConfig() {
 }
 const HEADLESS_BACKEND = {
   name: "headless",
+  MAX_MESSAGE_LENGTH: 2000,
+  formatOutgoing(t) {
+    return t;
+  },
   async connect() {
   },
   async disconnect() {
@@ -244,6 +275,26 @@ const HEADLESS_BACKEND = {
   }
 };
 function createBackend(config) {
+  // Single-backend select: exactly one backend is constructed based on
+  // config.backend (discord|telegram). The two are mutually exclusive.
+  if (config.backend === "telegram") {
+    const telegramToken = getTelegramToken();
+    if (!telegramToken) {
+      process.stderr.write("mixdog: telegram bot not configured; channel runtime running in headless mode\n");
+      return HEADLESS_BACKEND;
+    }
+    const tgStateDir = config.telegram?.stateDir ?? join(DATA_DIR, "telegram");
+    mkdirSync(tgStateDir, { recursive: true });
+    return new TelegramBackend({
+      ...config.telegram,
+      configPath: CONFIG_FILE,
+      access: config.access,
+      // Single-source channel setup: the main chat is auto-allowed inside
+      // TelegramBackend.loadAccess() so a configured channelsConfig.main.channelId
+      // is enough for both inbound gating and outbound.
+      mainChannelId: config.channelsConfig?.main?.channelId
+    }, tgStateDir);
+  }
   const discordToken = getDiscordToken();
   const discordTokenProblem = diagnoseDiscordTokenValue(discordToken, config);
   if (discordTokenProblem) {
@@ -276,9 +327,9 @@ function loadProfileConfig() {
 export {
   DATA_DIR,
   DEFAULT_HOLIDAY_COUNTRY,
-  applyDefaults,
   createBackend,
   getDiscordToken,
+  getTelegramToken,
   isInQuietWindow,
   loadConfig,
   loadProfileConfig

package/src/runtime/channels/lib/drop-trace.mjs

@@ -68,4 +68,4 @@ function dropTrace(event, fields) {
   } catch {}
 }
 
-export { dropTrace, _dtPreview, DROP_TRACE_ENABLED };
+export { dropTrace, _dtPreview };

package/src/runtime/channels/lib/executor.mjs

@@ -196,8 +196,5 @@ export {
   ensureNopluginDir,
   evaluateFilter,
   logEvent,
-  parseGeneric,
-  parseGithub,
-  parseSentry,
   runScript
 };

package/src/runtime/channels/lib/format.mjs

@@ -140,7 +140,8 @@ function safeCodeBlock(content, lang = "") {
   const escaped = content.replace(/```/g, "`​``");
   return "```" + lang + "\n" + escaped + "\n```";
 }
-function chunk(text, limit = 2e3) {
+const MAX_DISCORD_MESSAGE = 2000;
+function chunk(text, limit = MAX_DISCORD_MESSAGE) {
   if (text.length <= limit) return [text];
   const out = [];
   let rest = text;
@@ -184,5 +185,6 @@ function chunk(text, limit = 2e3) {
 export {
   chunk,
   formatForDiscord,
-  safeCodeBlock
+  safeCodeBlock,
+  MAX_DISCORD_MESSAGE
 };

package/src/runtime/channels/lib/memory-client.mjs

@@ -109,41 +109,3 @@ export async function ingestTranscript(filePath, { cwd } = {}) {
   }
 }
 
-export async function listCoreMemories(args = {}) {
-  const rawProjectId = args && Object.prototype.hasOwnProperty.call(args, 'project_id')
-    ? args.project_id
-    : args?.projectScope
-  const projectId = rawProjectId == null || rawProjectId === 'all' ? '*' : rawProjectId
-  const result = await memoryFetch('POST', '/api/tool', {
-    name: 'memory',
-    arguments: {
-      action: 'core',
-      op: 'list',
-      project_id: projectId,
-    },
-  }, 30_000)
-  if (!result || result.error) {
-    throw new Error(result?.error || 'core memory list: empty response')
-  }
-  return result
-}
-
-export async function searchMemories(args = {}) {
-  const result = await memoryFetch('POST', '/api/tool', {
-    name: 'search_memories',
-    arguments: args && typeof args === 'object' ? args : {},
-  }, 30_000)
-  if (!result || result.error) {
-    throw new Error(result?.error || 'memory_search: empty response')
-  }
-  return result
-}
-
-export async function isHealthy() {
-  try {
-    const result = await memoryFetch('GET', '/health')
-    return result.status === 'ok'
-  } catch {
-    return false
-  }
-}

package/src/runtime/channels/lib/output-forwarder.mjs

@@ -1,6 +1,6 @@
 import { existsSync, statSync, watch, openSync, readSync, closeSync } from "fs";
 import { createHash } from "crypto";
-import { formatForDiscord, chunk, safeCodeBlock } from "./format.mjs";
+import { safeCodeBlock } from "./format.mjs";
 import { dropTrace, _dtPreview } from "./drop-trace.mjs";
 import {
   formatToolSurface,
@@ -282,7 +282,12 @@ class OutputForwarder {
       this.commitReadProgress(item.nextFileSize);
       return;
     }
-    const formatted = item.preformatted ? item.text : formatForDiscord(item.text);
+    // Formatting is routed through the active backend via the send-callback so
+    // the forwarder stays backend-agnostic (Discord/Telegram/etc). Preformatted
+    // items (tool logs) are sent as-is. Fallback to raw text when no hook.
+    const formatted = item.preformatted
+      ? item.text
+      : (this.cb.formatOutgoing ? this.cb.formatOutgoing(item.text) : item.text);
     const hash = item.skipHashDedup
       ? ""
       : item.dedupKey
@@ -292,48 +297,25 @@ class OutputForwarder {
       this.commitReadProgress(item.nextFileSize);
       return;
     }
-    const chunks = chunk(formatted, 2e3);
-    const _t0Send = Date.now();
-    // Resume from _nextChunkIdx if this item is being retried after a partial send.
-    // This avoids re-sending chunks that already landed successfully.
-    if (item._chunks === undefined) {
-      item._chunks = chunks;
-      item._nextChunkIdx = 0;
-      item._sendRetries = 0;
-    }
-    for (let _ci = item._nextChunkIdx; _ci < item._chunks.length; _ci++) {
-      const c = item._chunks[_ci];
-      try {
-        await this.cb.send(targetChannelId, c);
-        item._nextChunkIdx = _ci + 1;
-        dropTrace("discord.send.ok", null);
-      } catch (err) {
-        // Discord 429 or transient error — honour Retry-After then re-throw so
-        // drainQueue's retry loop calls deliverQueueItem again. Chunk progress
-        // is stored on item so we resume from the failed chunk, not chunk 0.
-        const status = err?.status ?? err?.code ?? err?.httpStatus;
-        const retryAfter = err?.retryAfter ?? err?.retry_after
-          ?? err?.headers?.["retry-after"] ?? err?.response?.headers?.["retry-after"];
-        dropTrace("discord.send.err", { channelId: this.channelId, chunkIndex: _ci, status, retryAfter: retryAfter ?? "(none)", err: String(err) });
-        item._sendRetries = (item._sendRetries || 0) + 1;
-        if (item._sendRetries >= 3) {
-          // Cap retries to avoid infinite duplicate loop — give up on this item
-          process.stderr.write(`[output-forwarder] chunk send exceeded 3 retries at chunk ${_ci}, dropping item\n`);
-          item._nextChunkIdx = item._chunks.length; // mark exhausted
-          return;
-        }
-        if (status === 429) {
-          if (retryAfter != null) {
-            const ms = Number(retryAfter) > 1000 ? Number(retryAfter) : Number(retryAfter) * 1000;
-            if (Number.isFinite(ms) && ms > 0) {
-              await new Promise((r) => setTimeout(r, Math.min(ms, 60_000)));
-            }
-          } else {
-            await new Promise((r) => setTimeout(r, 1000));
-          }
-        }
-        throw err;
-      }
+    // Backend owns chunking + send retry: pass the whole (unchunked) text once.
+    // On failure the backend has already exhausted its per-chunk retries and
+    // throws; we re-throw so drainQueue/scheduleRetry requeues the whole item.
+    try {
+      // Hand back any opaque resume token stored from a prior partial-send
+      // failure so the backend resumes at the failed chunk instead of
+      // re-sending chunks that already landed. The token is opaque here —
+      // the forwarder only stores/passes/clears it, never interprets it.
+      await this.cb.send(targetChannelId, formatted, item._resumeToken ? { resumeToken: item._resumeToken } : undefined);
+      // Full success — drop any stale token so a later reuse of this item
+      // object can't carry a dead token.
+      item._resumeToken = undefined;
+      dropTrace("discord.send.ok", null);
+    } catch (err) {
+      // Persist the opaque resume token (if any) on the item so the requeued
+      // retry resumes from the failed chunk.
+      if (err?.resumeToken) item._resumeToken = err.resumeToken;
+      dropTrace("discord.send.err", { channelId: this.channelId, err: String(err) });
+      throw err;
     }
     if (!item.skipHashDedup) {
       this.lastHash = hash;
@@ -344,7 +326,9 @@ class OutputForwarder {
 
 ${_bt.trim()}` : _bt.trim();
     }
-    this.sentCount += chunks.length;
+    // sentCount now tracks delivered items (the forwarder no longer knows the
+    // backend's chunk count). Increment by 1 per delivered item.
+    this.sentCount += 1;
     this.commitReadProgress(item.nextFileSize);
   }
   scheduleRetry() {
@@ -375,7 +359,13 @@ ${_bt.trim()}` : _bt.trim();
     // finalLane[0] is being drained when this.sending; coalesce into tail only
     // when tail is not index 0 (i.e. length >= 2) or drain is not in flight.
     const ftLen = this.finalLane.length;
-    const ftTail = (ftLen > 0 && !(this.sending && ftLen === 1))
+    // A partially-delivered item carries an opaque _resumeToken pinned (by
+    // hash) to its exact text. Mutating its text here would break that hash on
+    // the next retry, forcing the backend to full-resend from chunk 0 and
+    // duplicate the chunks already delivered. Treat any tokenized item as
+    // sealed: never coalesce/cap-merge into it; new text goes behind it as a
+    // separate item.
+    const ftTail = (ftLen > 0 && !(this.sending && ftLen === 1) && !this.finalLane[ftLen - 1]._resumeToken)
       ? this.finalLane[ftLen - 1] : null;
     if (ftTail) {
       ftTail.text = `${ftTail.text}\n\n${newText}`;
@@ -391,6 +381,8 @@ ${_bt.trim()}` : _bt.trim();
       const capEnd = this.sending ? 1 : 0;
       for (let i = this.finalLane.length - 1; i >= capEnd; i--) {
         const cap = this.finalLane[i];
+        // Never fold into a sealed (partially-delivered) item — see above.
+        if (cap._resumeToken) continue;
         cap.text = `${cap.text}\n\n${newText}`;
         cap.bufferText = `${cap.bufferText}\n\n${newText}`;
         cap.nextFileSize = nextFileSize;
@@ -446,8 +438,20 @@ ${_bt.trim()}` : _bt.trim();
           }
           lane.shift();
         } catch (err) {
-          process.stderr.write(`mixdog: send failed: ${err}
-`);
+          // Permanent (non-retryable) send failure — e.g. Telegram 400 "chat
+          // not found", Discord 403/404. Retrying would loop forever and wedge
+          // the queue, so DROP the item: advance the read cursor past its bytes
+          // (so it never reprocesses), clear any stale resume token, and keep
+          // draining the next item.
+          if (err?.permanent) {
+            process.stderr.write(`[output-forwarder] permanent send failure, dropping item: ${err?.message || err}\n`);
+            dropTrace("drain.send.permanent", { lane: fromFinal ? "final" : "stream", itemType: item?.type, err: String(err) });
+            item._resumeToken = undefined;
+            this.commitReadProgress(item.nextFileSize);
+            lane.shift();
+            continue;
+          }
+          process.stderr.write(`[output-forwarder] send failed: ${err}\n`);
           dropTrace("drain.send.err", { finalLen: this.finalLane.length, streamLen: this.streamLane.length, lane: fromFinal ? "final" : "stream", itemType: item?.type, err: String(err) });
           this.scheduleRetry();
           break;
@@ -467,8 +471,7 @@ ${_bt.trim()}` : _bt.trim();
         }
         await this.cb.react(this.channelId, this.userMessageId, newEmoji);
         this.emoji = newEmoji;
-      } catch {
-      }
+      } catch {} // best-effort: reaction is non-critical
     }
     await this.deliverQueueItem(item);
   }
@@ -487,7 +490,7 @@ ${_bt.trim()}` : _bt.trim();
       try {
         this.pendingFinalFlush = true;
         this.updateState((state) => { state.pendingFinalFlush = true; });
-      } catch {}
+      } catch {} // best-effort: durable flush marker is non-critical
       if (retries < 5) {
         setTimeout(() => void this.forwardFinalText(retries + 1, channelId), 300);
       } else {
@@ -511,8 +514,7 @@ ${_bt.trim()}` : _bt.trim();
       if (this.userMessageId && this.emoji) {
         try {
           await this.cb.removeReaction(channelId, this.userMessageId, this.emoji);
-        } catch {
-        }
+        } catch {} // best-effort: remove reaction is non-critical
       }
       const { text: newText, nextFileSize } = this.extractNewText();
       if (newText) {
@@ -520,14 +522,23 @@ ${_bt.trim()}` : _bt.trim();
         try {
           await this.deliverQueueItem(finalItem);
         } catch (err) {
-          // Transient send failure: extractNewText already advanced the read
-          // cursor past these bytes, so dropping the item here would lose the
-          // final text. Requeue it (it retains per-chunk send progress) and let
-          // drainQueue retry instead of silently discarding. pendingFinalFlush
-          // stays set so a process restart can also resume the flush.
-          this.finalLane.push(finalItem);
-          this.scheduleRetry();
-          return;
+          // Permanent (non-retryable) failure — drop instead of requeue so we
+          // don't loop forever on a dead channel. extractNewText already
+          // advanced the read cursor, so commit it and let the frame go.
+          if (err?.permanent) {
+            process.stderr.write(`[output-forwarder] permanent final-send failure, dropping: ${err?.message || err}\n`);
+            this.commitReadProgress(nextFileSize);
+          } else {
+            // Transient send failure: extractNewText already advanced the read
+            // cursor past these bytes, so dropping the item here would lose the
+            // final text. Requeue the WHOLE item and let drainQueue retry
+            // instead of silently discarding. The backend owns chunking+retry,
+            // so a requeued send restarts from chunk 0. pendingFinalFlush stays
+            // set so a process restart can also resume the flush.
+            this.finalLane.push(finalItem);
+            this.scheduleRetry();
+            return;
+          }
         }
       } else {
         this.commitReadProgress(nextFileSize);
@@ -546,7 +557,7 @@ ${_bt.trim()}` : _bt.trim();
       try {
         this.pendingFinalFlush = false;
         this.updateState((state) => { state.pendingFinalFlush = false; });
-      } catch {}
+      } catch {} // best-effort: clear flush marker is non-critical
       this.updateState((state) => {
         state.sessionIdle = true;
       });
@@ -569,7 +580,7 @@ ${_bt.trim()}` : _bt.trim();
     // isHidden, because that helper would re-consult the module-local
     // HIDDEN_TOOLS Set and ignore the OutputForwarder static.
     if (OutputForwarder.HIDDEN_TOOLS.has(name)) return true;
-    if ((name.includes("plugin_mixdog") && !name.endsWith("recall_memory")) || name === "reply" || name === "react" || name === "edit_message" || name === "fetch" || name === "download_attachment") return true;
+    if (name === "reply" || name === "react" || name === "edit_message" || name === "fetch" || name === "download_attachment") return true;
     return false;
   };
   /** Concatenate text blocks from a transcript entry (user or assistant). */
@@ -684,13 +695,12 @@ ${_bt.trim()}` : _bt.trim();
       this.watchDebounce = null;
       let _wfStat = null;
       if (this.transcriptPath) {
-        try { _wfStat = statSync(this.transcriptPath); } catch {}
+        try { _wfStat = statSync(this.transcriptPath); } catch {} // best-effort: stat during flush
       }
       if (this.transcriptPath && !_wfStat) {
         const relocated = detectCurrentSessionTranscript()?.transcriptPath ?? findLatestTranscriptByMtime();
         if (relocated && relocated !== this.transcriptPath) {
-          process.stderr.write(`mixdog: watched transcript gone during flush, relocated to ${relocated}
-`);
+          process.stderr.write(`[output-forwarder] watched transcript gone during flush, relocated to ${relocated}\n`);
           dropTrace("watch.flush.relocate", { from: this.transcriptPath, to: relocated });
           this.closeWatcher();
           this.transcriptPath = relocated;
@@ -755,11 +765,7 @@ ${_bt.trim()}` : _bt.trim();
 }
 export {
   OutputForwarder,
-  cwdToProjectSlug,
-  detectCurrentSessionTranscript,
-  discoverCurrentClaudeSession,
   discoverSessionBoundTranscript,
   findLatestTranscriptByMtime,
-  getLatestInteractiveClaudeSession,
-  listInteractiveClaudeSessions
+  sameResolvedPath
 };

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -68,6 +68,7 @@ function isPidAlive(pid) {
     return e?.code === "EPERM";
   }
 }
+const UI_HEARTBEAT_STALE_MS = 5 * 60 * 1e3;
 function activeInstanceStaleReason(state) {
   const ownerPid = getActiveOwnerPid(state);
   if (!isPidAlive(ownerPid)) return `owner PID ${ownerPid ?? "unknown"} is dead`;
@@ -77,8 +78,35 @@ function activeInstanceStaleReason(state) {
   if (workerPid && !isPidAlive(workerPid)) return `worker PID ${workerPid} is dead`;
   const serverPid = parsePositivePid(state?.server_pid);
   if (serverPid && !isPidAlive(serverPid)) return `server PID ${serverPid} is dead`;
+  // Zombie-Lead repro (2026-07-02): a Lead's owner/channels/worker/server
+  // PIDs can all still be alive (process not killed) while the TUI's render
+  // loop is dead in the water — no signal ever fires, so pid-only staleness
+  // never trips. If the TUI is heartbeating (field present), treat a stale
+  // heartbeat as stale ownership too. Backward-compat: state written by an
+  // older/non-TUI process (or before the first heartbeat tick) simply omits
+  // ui_heartbeat_at, so this branch is a no-op and pid-only judgment stands.
+  const uiHeartbeatAt = Number(state?.ui_heartbeat_at);
+  if (Number.isFinite(uiHeartbeatAt) && uiHeartbeatAt > 0) {
+    const age = Date.now() - uiHeartbeatAt;
+    if (age > UI_HEARTBEAT_STALE_MS) {
+      return `ui heartbeat stale (${Math.round(age / 1000)}s since last tick)`;
+    }
+  }
   return null;
 }
+// Called from src/tui on a 30s timer while the render loop is alive. Only
+// touches ui_heartbeat_at (and updatedAt) so it never races/clobbers the
+// channels worker's own refreshActiveInstance() writes.
+function touchUiHeartbeat(instanceId) {
+  ensureRuntimeDirs();
+  try {
+    updateJsonAtomicSync(ACTIVE_INSTANCE_FILE, (curRaw) => {
+      if (!curRaw) return undefined;
+      if (instanceId && curRaw.instanceId !== instanceId) return undefined;
+      return { ...curRaw, ui_heartbeat_at: Date.now(), updatedAt: Date.now() };
+    }, { compact: true, fsync: false, fsyncDir: false });
+  } catch { /* best-effort; a missed tick just relies on the next one */ }
+}
 function buildRuntimeIdentity() {
   const terminalLeadPid = getTerminalLeadPid();
   const serverPid = getServerPid();
@@ -468,11 +496,7 @@ function clearActiveInstance(instanceId) {
   });
 }
 export {
-  ACTIVE_INSTANCE_FILE,
-  OWNER_DIR,
   RUNTIME_ROOT,
-  RUNTIME_STALE_TTL,
-  buildActiveInstanceState,
   cleanupInstanceRuntimeFiles,
   cleanupStaleRuntimeFiles,
   clearActiveInstance,
@@ -485,13 +509,12 @@ export {
   getPermissionResultPath,
   getTerminalLeadPid,
   getStatusPath,
-  getStopFlagPath,
   getTurnEndPath,
   notePreviousServerIfAny,
   makeInstanceId,
   readActiveInstance,
   refreshActiveInstance,
   releaseOwnedChannelLocks,
-  writeActiveInstance,
+  touchUiHeartbeat,
   writeServerPid
 };

package/src/runtime/channels/lib/scheduler.mjs

@@ -8,7 +8,7 @@ import { runScript as execScript, ensureNopluginDir } from "./executor.mjs";
 import { withFileLockSync } from "../../shared/atomic-file.mjs";
 import { makeAgentDispatch } from '../../agent/orchestrator/agent-runtime/agent-dispatch.mjs';
 
-const schedulerLlm = makeAgentDispatch({ taskType: 'scheduler-task', role: 'scheduler-task', sourceType: 'scheduler' });
+const schedulerLlm = makeAgentDispatch({ taskType: 'scheduler-task', agent: 'scheduler-task', sourceType: 'scheduler' });
 const SCHEDULE_LOG = join(DATA_DIR, "schedule.log");
 // Buffered async logger — coalesces per-line appends into batched writes.
 let _schedLogBuf = [];

package/src/runtime/channels/lib/session-discovery.mjs

@@ -1,7 +1,6 @@
 import { readFileSync, readdirSync, statSync } from "fs";
 import { execFileSync } from "child_process";
 import { basename, join, resolve } from "path";
-import { homedir } from "os";
 import { mixdogHome } from "../../shared/plugin-paths.mjs";
 
 function cwdToProjectSlug(cwd) {
@@ -94,9 +93,6 @@ function getLatestInteractiveClaudeSession() {
 
 export {
   cwdToProjectSlug,
-  getParentPid,
-  readSessionRecord,
-  isInteractiveSession,
   discoverCurrentClaudeSession,
   listInteractiveClaudeSessions,
   getLatestInteractiveClaudeSession