mixdog 0.9.4 → 0.9.5

package/src/runtime/agent/orchestrator/session/loop.mjs

@@ -245,6 +245,9 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     let _softCapActive = false;      // tools disabled + wrap-up injected
     let _softCapGraceTurns = 0;      // text-only grace turns consumed (max 2)
     let _terminatedBySoftCap = false;
+    // Hard-cap final-answer turn: one tool-less wrap-up turn granted when the
+    // hard iteration cap fires, so the session ends with text, not empty.
+    let _capFinalTurnUsed = false;
     // Completion-first steering ladder controller. Owns the (cumulative) level-1
     // fire count, the all-read-only / serial-single / same-file-grep streaks,
     // and the level-2 latch. Threaded via live getters so it reads the loop's
@@ -280,9 +283,28 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     while (true) {
         throwIfAborted();
         if (iterations >= maxLoopIterations) {
-            process.stderr.write(`[loop] hard iteration cap ${maxLoopIterations} reached (sess=${sessionId || 'unknown'}); stopping loop.\n`);
-            terminatedByCap = true;
-            break;
+            // Final-answer turn: instead of breaking mid-transcript (which
+            // yields an empty final for locator-style agents that never got to
+            // answer), give the model ONE tool-less text turn to wrap up, then
+            // stop. Same mechanism as the worker soft cap (empty sendTools).
+            if (_capFinalTurnUsed) {
+                process.stderr.write(`[loop] hard iteration cap ${maxLoopIterations} reached (sess=${sessionId || 'unknown'}); stopping loop.\n`);
+                terminatedByCap = true;
+                // The granted final turn produced no text (model kept emitting
+                // tool calls into refusal stubs, or thinking-only). Synthesize a
+                // non-empty final so callers never see an empty response.
+                if (response && !String(response.content || '').trim()) {
+                    response.content = sessionAgent === 'explorer'
+                        ? 'EXPLORATION_FAILED'
+                        : '[iteration cap reached before final text]';
+                    if (Array.isArray(response.toolCalls)) response.toolCalls = [];
+                }
+                break;
+            }
+            _capFinalTurnUsed = true;
+            _softCapActive = true; // reuse soft-cap plumbing: no tool defs, refusal stubs
+            messages.push({ role: 'user', content: '<system-reminder>\nIteration cap reached. Tools are disabled. Answer NOW with your best result from what you already found.\n</system-reminder>', meta: 'hook' });
+            process.stderr.write(`[loop] hard iteration cap ${maxLoopIterations} reached (sess=${sessionId || 'unknown'}); forcing final text turn.\n`);
         }
         if (_iterWarnStage < _iterWarnAt.length && iterations >= _iterWarnAt[_iterWarnStage]) {
             _iterWarnStage += 1;
@@ -370,7 +392,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                     pressureTokens,
                 });
             } else {
-                try { opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
+                try { await opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
                 const compactStartedAt = Date.now();
                 // Clear the one-shot reactive-overflow flag now that this
                 // compact pass is consuming it (compactTrigger already
@@ -626,7 +648,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                     }, compactErr);
                     }
                 }
-                try { opts.onStageChange?.('requesting'); } catch { /* best-effort */ }
+                try { await opts.onStageChange?.('requesting'); } catch { /* best-effort */ }
                 const compactChanged = messagesArrayChanged(messages, compacted);
                 if (compactChanged) {
                     messages.length = 0;

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -196,7 +196,7 @@ export async function runSessionCompaction(session, opts = {}) {
     const budgetSourceTokens = force ? Math.max(pressureTokens, triggerTokens) : pressureTokens;
     const compactBudget = compactTargetBudget(boundary, reserveTokens, budgetSourceTokens);
     const budget = compactBudget || boundary;
-    try { opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
+    try { await opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
     const provider = opts.provider || getProvider(session.provider) || null;
     let compacted;
     let compactError = null;

package/src/runtime/agent/orchestrator/stall-policy.mjs

@@ -206,9 +206,28 @@ export const PROVIDER_RETRY_JITTER_RATIO = (() => {
     return 0.2;
 })();
 
+// Public workflow agents are not in agents.json (that file only defines hidden
+// roles), so they historically always fell back to the 600s default. A wedged
+// anthropic SSE stream (HTTP 200 then zero deltas — observed 2026-07-03 on a
+// sonnet-5 worker, twice in a row) then holds the owner for the full 10 min.
+// Scoped workers/reviewers should be reaped faster; lead keeps the generous
+// default because interactive xhigh turns legitimately think for minutes.
+const WORKFLOW_AGENT_STALL_ABORT_S = {
+    'worker': 300,
+    'reviewer': 300,
+    'debugger': 420,
+    'heavy-worker': 420,
+    'maintainer': 300,
+    'explore': 240,
+    'web-researcher': 300,
+};
+
 export function resolveAgentStallThresholds(agent, env = process.env) {
     const cfg = agent ? getHiddenAgent(agent) : null;
-    const cfgAbort = cfg?.stallCap?.idleSeconds > 0 ? cfg.stallCap.idleSeconds : STALL_ABORT_S;
+    const roleAbort = WORKFLOW_AGENT_STALL_ABORT_S[String(agent || '')] || null;
+    const cfgAbort = cfg?.stallCap?.idleSeconds > 0
+        ? cfg.stallCap.idleSeconds
+        : (roleAbort || STALL_ABORT_S);
     const envOverride = envThresholdSeconds(env);
     const abort = envOverride != null ? envOverride : cfgAbort;
     // Mid-stream "slow" warning disabled — an agent stall now notifies ONLY at

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -17,7 +17,7 @@ export const BUILTIN_TOOLS = [
         name: 'read',
         title: 'Mixdog Read',
         annotations: { title: 'Mixdog Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
-        description: 'Read known file path(s). Prefer grep content_with_context or code_graph anchors first. Window with numeric offset+limit only. Batch paths/regions as real arrays; adjacent spans in one file = one window, not repeated calls. Dirs use list.',
+        description: 'Read known file path(s). Prefer grep content_with_context or code_graph anchors first. Window with numeric offset+limit. Batch paths/regions as real arrays; adjacent spans in one file = one window, not repeated calls. Dirs use list.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -42,7 +42,7 @@ export const BUILTIN_TOOLS = [
                             minItems: 1,
                         },
                     ],
-                    description: 'File path. To batch spans: path[] or {path,offset,limit}[] region objects. Pass arrays directly; JSON strings are legacy recovery only.',
+                    description: 'File path. Batch spans via path[] or {path,offset,limit}[] regions. Pass arrays directly; JSON strings are legacy recovery only.',
                 },
                 offset: { type: 'number', minimum: 0, description: 'Numeric lines to skip before reading; 0 starts at line 1. Continue with offset:N.' },
                 limit: { type: 'number', minimum: 1, description: 'Numeric max lines to return after offset.' },
@@ -53,16 +53,16 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: `Run shell to CHANGE state or RUN programs (git/build/test/run). Never to inspect the filesystem — reading, listing, searching, or checking existence go through the dedicated tools, never a shell command. Set shell: powershell or bash. ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
+        description: `Run shell to CHANGE state or RUN programs (git/build/test/run). Never to inspect the filesystem — reading, listing, searching, existence checks use the dedicated tools, never shell. Set shell: powershell or bash. ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
             properties: {
                 command: { type: 'string', description: 'Command.' },
-                cwd: { type: 'string', description: 'Working directory. Persists across shell calls within a session — omit to reuse the previous command\'s directory (e.g. after cd); pass an absolute path to change it.' },
+                cwd: { type: 'string', description: 'Working directory. Persists across shell calls in a session — omit to reuse the previous command\'s directory (e.g. after cd); pass an absolute path to change it.' },
                 timeout: { type: 'number', description: 'Timeout ms.' },
                 merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
-                shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows default is PowerShell; bash means Git Bash/POSIX.' },
+                shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows defaults to PowerShell; bash = Git Bash/POSIX.' },
             },
             required: ['command'],
         },
@@ -87,7 +87,7 @@ export const BUILTIN_TOOLS = [
         name: 'grep',
         title: 'Mixdog Grep',
         annotations: { title: 'Mixdog Grep', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'Search file contents by text/regex in a known scope. Use files_with_matches/count for broad anchors, content_with_context for narrow code answers. One concept → one grep; multiple scopes = ONE call with path[].',
+        description: 'Search file contents by text/regex in a known scope. files_with_matches/count for broad anchors, content_with_context for narrow answers. One concept → one grep; multiple scopes = ONE call with path[].',
         inputSchema: {
             type: 'object',
             properties: {
@@ -163,7 +163,7 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Partial path/name words (not file contents), or query[] to batch several lookups in one call.',
+                    description: 'Partial path/name words (not file contents), or query[] to batch lookups in one call.',
                 },
                 path: { type: 'string', description: 'Base directory.' },
                 head_limit: { type: 'number', description: 'Max paths.' },

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -9,7 +9,7 @@ export const CODE_GRAPH_TOOL_DEFS = [
       properties: {
         mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers'], description: 'Repo-local operation; code flow before text search.' },
         files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Source file(s): string or array; one call fans out per file (imports/dependents/related/impact/symbols/overview). `file` singular alias also accepted.' },
-        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s): string or array; batch in one call. One anchor is enough — no repeated lookups. `symbol` singular alias also accepted.' },
+        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Identifier(s)/keyword(s): string or array; batch in one call. One anchor is enough. `symbol` singular alias also accepted.' },
         symbol: { type: 'string', description: 'Singular alias for symbols.' },
         file: { type: 'string', description: 'Singular alias for files.' },
         body: { type: 'boolean', description: 'Include body.' },

package/src/runtime/channels/backends/discord-gateway.mjs

@@ -31,7 +31,7 @@ async function connectInner(self) {
     self.client = null;
     throw err;
   }
-  self.persistAccessFromChannelsConfig();
+  self.persistAccessFromMainChannel();
 }
 
 async function buildClient(self) {
@@ -120,7 +120,7 @@ function registerEventListeners(self) {
         return;
       }
       if (interaction.isButton() || interaction.isStringSelectMenu() || interaction.isRoleSelectMenu() || interaction.isUserSelectMenu() || interaction.isChannelSelectMenu()) {
-        const needsModal = interaction.isButton() && (interaction.customId === "sched_add_next" || interaction.customId === "sched_edit_next" || interaction.customId === "quiet_set_next" || interaction.customId === "activity_add_next" || interaction.customId === "profile_edit");
+        const needsModal = interaction.isButton() && (interaction.customId === "sched_add_next" || interaction.customId === "sched_edit_next" || interaction.customId === "profile_edit");
         if (needsModal) {
           if (self.onModalRequest) {
             await Promise.resolve(self.onModalRequest(interaction)).catch((err) => {

package/src/runtime/channels/backends/discord.mjs

@@ -326,47 +326,37 @@ class DiscordBackend {
     try {
       const parsed = readSection("channels");
       const access = normalizeAccess(parsed.access ?? this.initialAccess);
-      if (parsed.channelsConfig) {
-        for (const entry of Object.values(parsed.channelsConfig)) {
-          if (typeof entry === "object" && entry !== null) {
-            const id = entry.channelId;
-            if (id && !(id in access.channels)) {
-              access.channels[id] = { requireMention: false, allowFrom: [] };
-            }
-          }
-        }
+      // Single main channel: auto-allow the configured channel id so channel
+      // adds apply without a restart (mirrors loadAccess()).
+      const id = this.mainChannelId;
+      if (id && !(id in access.channels)) {
+        access.channels[id] = { requireMention: false, allowFrom: [] };
       }
       return access;
     } catch {
       return this.initialAccess;
     }
   }
-  persistAccessFromChannelsConfig() {
+  persistAccessFromMainChannel() {
     if (this.isStatic || !this.configFile) return;
     try {
+      const id = this.mainChannelId;
+      if (!id) return;
       const parsed = readSection("channels");
-      if (!parsed.channelsConfig) return;
       const access = normalizeAccess(parsed.access);
-      let changed = false;
-      for (const entry of Object.values(parsed.channelsConfig)) {
-        if (typeof entry === "object" && entry !== null) {
-          const id = entry.channelId;
-          if (id && !(id in access.channels)) {
-            access.channels[id] = { requireMention: false, allowFrom: [] };
-            changed = true;
-          }
-        }
+      if (!(id in access.channels)) {
+        access.channels[id] = { requireMention: false, allowFrom: [] };
+        this.saveAccess(access);
       }
-      if (changed) this.saveAccess(access);
     } catch (err) {
-      process.stderr.write(`mixdog discord: persistAccessFromChannelsConfig failed: ${err}\n`);
+      process.stderr.write(`mixdog discord: persistAccessFromMainChannel failed: ${err}\n`);
     }
   }
   loadAccess() {
     const a = this.bootAccess ?? this.readConfigAccess();
     // Single-source channel setup: auto-allow the configured main channel so
     // both inbound (gate) and outbound (fetchAllowedChannel) accept it from a
-    // single channelsConfig.main.channelId — no separate access.channels entry.
+    // single channel.channelId — no separate access.channels entry.
     // An explicit entry for the same channel is preserved (not overwritten).
     if (this.mainChannelId && a && !(this.mainChannelId in (a.channels ?? {}))) {
       return { ...a, channels: { ...(a.channels ?? {}), [this.mainChannelId]: { allowFrom: [], requireMention: false } } };
@@ -516,9 +506,8 @@ class DiscordBackend {
     }
     if (this.onMessage) {
       // Thread messages were gated against the parent channel's policy (see
-      // gate() above), but routing also needs the parent id to find labels/
-      // modes in channelsConfig. Surface parentChatId so resolveInboundRoute
-      // can fall back to the parent when the thread id has no entry.
+      // gate() above). Surface parentChatId so downstream routing can fall
+      // back to the parent when the thread id needs it.
       const isThread = (() => { try { return !!msg.channel?.isThread?.(); } catch { return false; } })();
       const parentChatId = isThread ? (msg.channel.parentId ?? null) : null;
       this.onMessage({

package/src/runtime/channels/backends/telegram.mjs

@@ -112,22 +112,18 @@ class TelegramBackend {
   formatOutgoing(text) {
     return text;
   }
-  // Fold every channelsConfig entry's channelId into access.channels, mirroring
-  // DiscordBackend.readConfigAccess(). Read live so same-backend channel adds
-  // apply without a restart. Falls back to initialAccess if the read throws.
+  // Fold the single configured main channel id into access.channels, mirroring
+  // DiscordBackend.readConfigAccess(). Read live so a channel change applies
+  // without a restart. Falls back to initialAccess if the read throws.
   readConfigAccess() {
     try {
       const parsed = readSection("channels");
       const access = normalizeAccess(parsed.access ?? this.initialAccess);
-      if (parsed.channelsConfig) {
-        for (const entry of Object.values(parsed.channelsConfig)) {
-          if (typeof entry === "object" && entry !== null) {
-            const id = entry.channelId;
-            if (id && !(id in access.channels)) {
-              access.channels[id] = { requireMention: false, allowFrom: [] };
-            }
-          }
-        }
+      // Single main channel: auto-allow the configured channel id so a channel
+      // change applies without a restart (mirrors loadAccess()).
+      const id = this.mainChannelId;
+      if (id && !(id in access.channels)) {
+        access.channels[id] = { requireMention: false, allowFrom: [] };
       }
       return access;
     } catch {

package/src/runtime/channels/index.mjs

@@ -208,12 +208,6 @@ const {
   callMemoryAction,
   handleMemoryCallResponse,
 } = createParentBridge({ getInstanceId: () => INSTANCE_ID });
-function resolveChannelLabel(channelsConfig, label) {
-  if (!label || !channelsConfig) return label;
-  const entry = channelsConfig[label];
-  if (entry?.channelId) return entry.channelId;
-  return label;
-}
 let channelBridgeActive = false;
 function writeBridgeState(active) {
   try {
@@ -518,11 +512,8 @@ async function rebindTranscriptContext(channelId, options = {}) {
 const scheduler = new Scheduler(
   config.nonInteractive ?? [],
   config.interactive ?? [],
-  // channelsConfig kept for channel-label resolution (resolveChannel)
-  // only — quiet/schedules now come from the top-level config.
-  config.channelsConfig,
-  // 0.1.62: top-level normalized config carries quiet/schedules.
-  config
+  // Single resolved main-channel id used for the schedule `channel` flag.
+  config.channelId
 );
 // Register the pending-dispatch probe so the scheduler treats an in-flight
 // bridge dispatch as "active" regardless of user-inbound silence.
@@ -608,10 +599,7 @@ async function bindPersistedTranscriptIfAny() {
     }
   }
   if (!currentStatus.channelId && channelBridgeActive) {
-    const chCfg = config.channelsConfig;
-    const mainLabel = config.mainChannel ?? "main";
-    const mainEntry = chCfg?.[mainLabel];
-    const mainId = mainEntry?.channelId;
+    const mainId = config.channelId;
     if (mainId) {
       statusState.update((state) => {
         state.channelId = mainId;
@@ -637,17 +625,14 @@ function shouldStartEventPipelineRuntime() {
 }
 function ensureEventPipelineRuntime() {
   if (!eventPipeline) {
-    eventPipeline = new EventPipeline(config.events, config.channelsConfig);
+    eventPipeline = new EventPipeline(config.events, config.channelId);
     wireEventQueueHandlers(eventPipeline.getQueue());
   }
   return eventPipeline;
 }
 function ensureWebhookServerRuntime() {
   if (!webhookServer) {
-    // Pass top-level normalized config so the webhook gate reads the new
-    // top-level `quiet` subtree (and `webhook.respectQuiet`) introduced in
-    // 0.1.62. See applyDefaults() in lib/config.mjs.
-    webhookServer = new WebhookServer(config.webhook, { quiet: config.quiet ?? null });
+    webhookServer = new WebhookServer(config.webhook);
   }
   wireWebhookHandlers();
   return webhookServer;
@@ -666,7 +651,7 @@ function syncOwnedWebhookAndEventRuntime({ reload = false } = {}) {
   if (shouldStartEventPipelineRuntime()) {
     const pipeline = ensureEventPipelineRuntime();
     if (reload) {
-      pipeline.reloadConfig(config.events, config.channelsConfig);
+      pipeline.reloadConfig(config.events, config.channelId);
       wireEventQueueHandlers(pipeline.getQueue());
     }
     pipeline.start();
@@ -683,7 +668,7 @@ function syncOwnedWebhookAndEventRuntime({ reload = false } = {}) {
       // so we don't race the bound port — calling start() synchronously
       // here would re-listen before close() finishes and surface
       // EADDRINUSE on the same port.
-      server.reloadConfig(config.webhook, { quiet: config.quiet ?? null }, {
+      server.reloadConfig(config.webhook, {
         autoStart: false
       }).then(() => {
         // A stopWebhookAndEventRuntime() / deactivate landing during the async
@@ -940,10 +925,8 @@ async function reloadRuntimeConfig() {
   scheduler.reloadConfig(
     config.nonInteractive ?? [],
     config.interactive ?? [],
-    // channelsConfig: channel-label resolution only.
-    config.channelsConfig,
-    // 0.1.62: top-level normalized config (quiet/schedules).
-    config,
+    // Single resolved main-channel id used for the schedule `channel` flag.
+    config.channelId,
     { restart: bridgeRuntimeConnected }
   );
   const nextBackend = createBackend(config);
@@ -1128,15 +1111,17 @@ function wireWebhookHandlers() {
     );
   });
 }
-function resolveWebhookChannelId(channelLabel) {
-  // Fail closed: route only to channels explicitly present in config —
-  // the endpoint's owner-configured `channel`, else the `main` channel.
-  // Runtime / persisted-status fallbacks are never used (they could route
-  // a delivery to an arbitrary or stale channel). The endpoint channel is
-  // owner-authored config, not attacker payload, so honoring it is safe.
-  const channels = config?.channelsConfig || {};
-  if (channelLabel && channels[channelLabel]?.channelId) return channels[channelLabel].channelId;
-  return channels.main?.channelId || "";
+function resolveWebhookChannelId(channelFlag) {
+  // Single main channel: the endpoint's `channel` frontmatter is a boolean-ish
+  // flag (any non-empty value except "false" → post to the main channel). A raw
+  // channel id is still honored verbatim for owner-authored overrides.
+  const main = config?.channelId || "";
+  if (channelFlag == null) return main;
+  const v = String(channelFlag).trim();
+  if (v === "" || v.toLowerCase() === "false") return "";
+  // A pure-digit / snowflake-looking value is treated as an explicit id;
+  // anything else (legacy labels like "main") maps to the main channel.
+  return /^-?\d+$/.test(v) ? v : main;
 }
 function wireEventQueueHandlers(eventQueue) {
   if (!eventQueue) return;
@@ -1390,13 +1375,10 @@ import { TOOL_DEFS } from './tool-defs.mjs';
 const BACKEND_TOOLS = /* @__PURE__ */ new Set(["reply", "fetch"]);
 // ── Inbound routing / dedup / ownership helpers ─────────────────────────────
 // Extracted → lib/inbound-routing.mjs. Bound to live config/identity getters.
-// Created here (ahead of backend-dispatch) so labelForChannelId is initialised
-// before it is passed into createBackendDispatch below.
 const {
   writeChannelOwner,
   shouldDropDuplicateInbound,
   resolveInboundRoute,
-  labelForChannelId,
 } = createInboundRouting({
   getConfig: () => config,
   getInstanceId: () => INSTANCE_ID,
@@ -1414,8 +1396,6 @@ const {
   getConfig: () => config,
   getBackend: () => backend,
   scheduler,
-  resolveChannelLabel,
-  labelForChannelId,
 });
 // ── Worker/HTTP tool-call dispatch ──────────────────────────────────────────
 // handleToolCall switch + bridge auto-connect retry wrapper. Extracted →
@@ -1472,7 +1452,8 @@ backend.onMessage = (msg) => {
   }
   if (!channelBridgeActive) return;
   if (shouldDropDuplicateInbound(msg)) return;
-  recordFetchedMessages(msg.chatId, labelForChannelId(msg.chatId), [{ id: msg.messageId }], { markRead: true });
+  // No label concept anymore: the channel id IS the identifier.
+  recordFetchedMessages(msg.chatId, msg.chatId, [{ id: msg.messageId }], { markRead: true });
   if (!writeChannelOwner(msg.chatId)) return;
   const route = resolveInboundRoute(msg.chatId, msg.parentChatId);
   scheduler.noteActivity();
@@ -1877,9 +1858,8 @@ if (_isWorkerMode && process.send) {
           }
           refreshToolExecConsumerMarker();
         }
-        const mainLabel = config?.mainChannel || 'main';
         const target = (statusState?.read?.().channelId)
-          || resolveChannelLabel(config?.channelsConfig, mainLabel)
+          || config?.channelId
           || null;
         if (!target || !backend?.sendMessage) {
           process.stderr.write(`mixdog channels: permission_request dropped, no target channel (request_id=${request_id})\n`);

package/src/runtime/channels/lib/backend-dispatch.mjs

@@ -3,7 +3,7 @@ import { recordFetchedMessages } from "./status-snapshot.mjs";
 // Backend-tool dispatch helpers. Extracted verbatim from channels/index.mjs
 // (behavior-preserving). Bound to live getters so runtime config/backend
 // reloads keep the original file-level reference semantics.
-function createBackendDispatch({ getConfig, getBackend, scheduler, resolveChannelLabel, labelForChannelId }) {
+function createBackendDispatch({ getConfig, getBackend, scheduler }) {
   async function dispatchReply(args) {
     const sendOpts = {
       replyTo: args.reply_to,
@@ -22,12 +22,14 @@ function createBackendDispatch({ getConfig, getBackend, scheduler, resolveChanne
   }
 
   async function dispatchFetch(args) {
+    // `args.channel` is a raw channel id (no label resolution anymore); when
+    // omitted, fall back to the single configured main channel id.
     const config = getConfig();
-    const channelId = resolveChannelLabel(config.channelsConfig, args.channel);
+    const channelId = args.channel || config.channelId || "";
     const limit = args.limit ?? 20;
     let msgs;
     msgs = await getBackend().fetchMessages(channelId, limit);
-    recordFetchedMessages(channelId, args.channel !== channelId ? args.channel : labelForChannelId(channelId), msgs);
+    recordFetchedMessages(channelId, channelId, msgs);
     const text = msgs.length === 0 ? "(no messages)" : msgs.map((m) => {
       const atts = m.attachmentCount > 0 ? ` +${m.attachmentCount}att` : "";
       return `[${m.ts}] ${m.user}: ${m.text}  (id: ${m.id}${atts})`;