mixdog 0.9.3 → 0.9.5

package/src/runtime/channels/lib/interaction-workflows.mjs

@@ -22,28 +22,15 @@ class PendingInteractionStore {
     this.patch(userId, channelId, { _msgId: messageId });
   }
 }
-function getPendingSelectUpdate(customId, values) {
-  const value = values?.[0];
-  if (!value) return null;
-  const scheduleMatch = customId.match(/^sched_(add|edit)_(period|exec|mode)$/);
-  if (scheduleMatch) {
-    return { [scheduleMatch[2]]: value };
-  }
-  if (customId === "quiet_holidays_select") {
-    return { holidays: value };
-  }
-  if (customId === "activity_mode_select") {
-    return { activityMode: value };
-  }
-  return null;
-}
 function buildModalRequestSpec(customId, pending, profile) {
   switch (customId) {
     case "sched_add_next": {
       const fields = [
         { id: "name", label: "Name", required: true },
         { id: "time", label: "Cron expression (e.g. 0 9 * * 1-5)", required: true },
-        { id: "channel", label: "Channel", required: false, value: "general" }
+        // Single main channel: `channel` is a boolean-ish flag (true → post
+        // to the main channel, empty/false → inject into the Lead session).
+        { id: "channel", label: "Post to channel? (true / false)", required: false, value: "true" }
       ];
       if (pending.exec?.includes("script")) {
         fields.push({ id: "script", label: "Script filename", required: true });
@@ -54,19 +41,10 @@ function buildModalRequestSpec(customId, pending, profile) {
         fields
       };
     }
-    case "quiet_set_next":
-      return {
-        customId: "modal_quiet",
-        title: "Quiet Hours",
-        fields: [
-          { id: "schedule", label: "Schedule quiet hours (e.g. 23:00-07:00)", required: false }
-        ]
-      };
     case "sched_edit_next": {
       const fields = [
         { id: "time", label: "Cron expression (e.g. 0 9 * * 1-5)", required: false },
-        { id: "channel", label: "Channel", required: false },
-        { id: "dnd", label: "Quiet hours (e.g. 23:00-07:00, leave empty to disable)", required: false }
+        { id: "channel", label: "Post to channel? (true / false)", required: false }
       ];
       if (pending.exec?.includes("script")) {
         fields.push({ id: "script", label: "Script filename", required: false });
@@ -77,15 +55,6 @@ function buildModalRequestSpec(customId, pending, profile) {
         fields
       };
     }
-    case "activity_add_next":
-      return {
-        customId: "modal_activity_add",
-        title: "Add Activity Channel",
-        fields: [
-          { id: "name", label: "Channel Name", required: true },
-          { id: "id", label: "Channel ID", required: true }
-        ]
-      };
     case "profile_edit":
       return {
         customId: "modal_profile_edit",
@@ -101,84 +70,7 @@ function buildModalRequestSpec(customId, pending, profile) {
       return null;
   }
 }
-function buildModalExecutionPlan(customId, pending, fields) {
-  switch (customId) {
-    case "modal_sched_add": {
-      const params = {
-        time: fields.time,
-        channel: fields.channel || "general",
-        mode: pending.mode || "non-interactive",
-        period: pending.period || "daily",
-        exec: pending.exec || "prompt"
-      };
-      if (fields.script) params.script = fields.script;
-      return {
-        commands: [{ target: "bot", args: ["schedule", "add", fields.name], params }],
-        followup: { target: "bot", args: ["schedule", "list"], params: {} }
-      };
-    }
-    case "modal_quiet": {
-      const commands = [];
-      if (fields.schedule) commands.push({ target: "bot", args: ["quiet", "schedule", fields.schedule], params: {} });
-      if (pending.holidays && pending.holidays !== "none") {
-        commands.push({ target: "bot", args: ["quiet", "holidays", pending.holidays], params: {} });
-      }
-      return {
-        commands,
-        followup: { target: "bot", args: ["quiet", "list"], params: {} }
-      };
-    }
-    case "modal_sched_edit": {
-      const name = pending.editName;
-      if (!name) return null;
-      const params = {};
-      if (fields.time) params.time = fields.time;
-      if (fields.channel) params.channel = fields.channel;
-      if (pending.period) params.period = pending.period;
-      if (pending.exec) params.exec = pending.exec;
-      if (pending.mode) params.mode = pending.mode;
-      if (fields.script) params.script = fields.script;
-      const commands = [
-        { target: "bot", args: ["schedule", "edit", name], params }
-      ];
-      if (fields.dnd) {
-        commands.push({ target: "bot", args: ["quiet", "schedule", fields.dnd], params: {} });
-      }
-      return {
-        commands,
-        followup: { target: "bot", args: ["schedule", "detail", name], params: {} }
-      };
-    }
-    case "modal_activity_add":
-      return {
-        commands: [{
-          target: "bot",
-          args: ["activity", "add", fields.name],
-          params: {
-            id: fields.id,
-            mode: pending.activityMode || "interactive"
-          }
-        }],
-        followup: { target: "bot", args: ["activity", "list"], params: {} }
-      };
-    case "modal_profile_edit": {
-      const params = {};
-      if (fields.name) params.name = fields.name;
-      if (fields.role) params.role = fields.role;
-      if (fields.lang) params.lang = fields.lang;
-      if (fields.tone) params.tone = fields.tone;
-      return {
-        commands: Object.keys(params).length > 0 ? [{ target: "profile", args: ["set"], params }] : [],
-        followup: { target: "bot", args: ["profile", "list"], params: {} }
-      };
-    }
-    default:
-      return null;
-  }
-}
 export {
   PendingInteractionStore,
-  buildModalExecutionPlan,
-  buildModalRequestSpec,
-  getPendingSelectUpdate
+  buildModalRequestSpec
 };

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

@@ -588,7 +588,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 === "reply" || name === "react" || name === "edit_message" || name === "fetch" || name === "download_attachment") return true;
+    if (name === "reply" || name === "fetch") return true;
     return false;
   };
   /** Concatenate text blocks from a transcript entry (user or assistant). */

package/src/runtime/channels/lib/owner-heartbeat.mjs

@@ -0,0 +1,75 @@
+// Bridge ownership snapshot + owner heartbeat cluster. Extracted verbatim from
+// channels/index.mjs (behavior-preserving). Self-contained: owns its own
+// heartbeat timer + last-note dedup state, and depends only on the
+// active-instance read/refresh primitives + identity, threaded as injected
+// deps so the module reads live file-level references at call time.
+function createOwnerHeartbeat({
+  getInstanceId,
+  readActiveInstance,
+  refreshActiveInstance,
+  OWNER_HEARTBEAT_INTERVAL_MS = 5e3,
+}) {
+  let lastOwnershipNote = "";
+  let ownerHeartbeatTimer = null;
+
+  function logOwnership(note) {
+    if (lastOwnershipNote === note) return;
+    lastOwnershipNote = note;
+    process.stderr.write(`[ownership] ${note}
+`);
+  }
+  function currentOwnerState() {
+    const active = readActiveInstance();
+    return {
+      active,
+      // Strict last-wins: this process owns the bridge ONLY when active-instance
+      // names exactly this INSTANCE_ID. A newer remote session that claims the
+      // seat overwrites instanceId, so the old owner immediately reads owned=false
+      // and disconnects on its next refresh tick. No PID/terminal fallback —
+      // that used to let a co-terminal worker wrongly self-claim.
+      owned: active?.instanceId === getInstanceId()
+    };
+  }
+  function getBridgeOwnershipSnapshot() {
+    return currentOwnerState();
+  }
+  function claimBridgeOwnership(reason) {
+    refreshActiveInstance(getInstanceId());
+    logOwnership(`claimed owner (${reason})`);
+  }
+  function startOwnerHeartbeat() {
+    if (ownerHeartbeatTimer) return;
+    ownerHeartbeatTimer = setInterval(() => {
+      try {
+        // Last-wins guard: only refresh the seat if we STILL own it. If a newer
+        // remote session claimed active-instance.json since our last tick, do
+        // NOT overwrite it back — that would re-steal ownership and cause
+        // ping-pong / double backend connections. The bridgeOwnershipTimer's
+        // refreshBridgeOwnership() will observe owned=false and disconnect us.
+        // onlyIfOwned: re-checks ownership INSIDE the file lock so a newer
+        // owner claiming the seat between currentOwnerState() and the locked
+        // write is never overwritten (see refreshActiveInstance CAS guard).
+        if (currentOwnerState().owned) refreshActiveInstance(getInstanceId(), undefined, { onlyIfOwned: true });
+      } catch (e) {
+        process.stderr.write(`[ownership] heartbeat refresh failed: ${e instanceof Error ? e.message : String(e)}\n`);
+      }
+    }, OWNER_HEARTBEAT_INTERVAL_MS);
+    ownerHeartbeatTimer.unref?.();
+  }
+  function stopOwnerHeartbeat() {
+    if (!ownerHeartbeatTimer) return;
+    clearInterval(ownerHeartbeatTimer);
+    ownerHeartbeatTimer = null;
+  }
+
+  return {
+    logOwnership,
+    currentOwnerState,
+    getBridgeOwnershipSnapshot,
+    claimBridgeOwnership,
+    startOwnerHeartbeat,
+    stopOwnerHeartbeat,
+  };
+}
+
+export { createOwnerHeartbeat };

package/src/runtime/channels/lib/parent-bridge.mjs

@@ -0,0 +1,88 @@
+// Worker → parent IPC bridge. Extracted verbatim from channels/index.mjs
+// (behavior-preserving). Groups the notify-to-parent path and the
+// worker → parent → memory call bridge. Bound to live getters
+// (getInstanceId) so runtime identity stays consistent.
+function normalizeChannelNotifyParams(method, params) {
+  if (method === 'notifications/claude/channel' && params && params.meta) {
+    const m = {};
+    for (const [k, v] of Object.entries(params.meta)) {
+      if (v === undefined || v === null) continue;
+      m[k] = k === 'silent_to_agent' ? (v === true || v === 'true') : String(v);
+    }
+    return { ...params, meta: m };
+  }
+  return params;
+}
+
+function createParentBridge({ getInstanceId }) {
+  function sendNotifyToParent(method, params) {
+    // CC channel schema requires meta: Record<string,string> (channelNotification.ts).
+    // Coerce every meta value to string so a non-string (e.g. a Discord
+    // interaction.type number) can't fail zod and silently drop the notify.
+    // silent_to_agent stays boolean — an internal routing flag the daemon
+    // router / agentNotify consume (=== true) before the CC zod boundary.
+    const outParams = normalizeChannelNotifyParams(method, params);
+    if (!process.send) {
+      try { process.stderr.write(`mixdog channels: notify dropped (no IPC channel): ${method}\n`); } catch {}
+      return;
+    }
+    try {
+      process.send({ type: 'notify', method, params: outParams });
+    } catch (err) {
+      try { process.stderr.write(`mixdog channels: notify IPC send failed: ${err && err.message || err}\n`); } catch {}
+    }
+  }
+
+  // ── Memory worker bridge (worker → parent → memory) ─────────────────
+  // The channels worker does not own the memory worker handle. To trigger
+  // memory tool actions (e.g. cycle1) we send `memory_call_request` to the
+  // parent, which routes through callWorker('memory', ...) and ships the
+  // result back as `memory_call_response`. The response listener is
+  // integrated into the main IPC handler below (not a second listener).
+  const _memoryCallPending = new Map();
+  let _memoryCallSeq = 0;
+
+  function callMemoryAction(action, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      if (!process.send) return reject(new Error('not a worker process'));
+      const callId = `mc_${getInstanceId()}_${++_memoryCallSeq}_${Math.random().toString(36).slice(2, 8)}`;
+      const timer = setTimeout(() => {
+        _memoryCallPending.delete(callId);
+        reject(new Error(`memory_call ${action} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      _memoryCallPending.set(callId, {
+        resolve: (v) => { clearTimeout(timer); resolve(v); },
+        reject: (e) => { clearTimeout(timer); reject(e); },
+      });
+      try {
+        process.send({ type: 'memory_call_request', callId, action, args: args || {} });
+      } catch (e) {
+        _memoryCallPending.delete(callId);
+        clearTimeout(timer);
+        reject(e);
+      }
+    });
+  }
+
+  // Response side of the worker → parent → memory bridge. The caller routes
+  // `memory_call_response` messages here from its single process IPC handler
+  // (keeping IPC dispatch in one place). Returns true when the message was a
+  // recognised memory_call_response (handled), false otherwise.
+  function handleMemoryCallResponse(msg) {
+    if (!(msg && msg.type === 'memory_call_response' && msg.callId)) return false;
+    const pending = _memoryCallPending.get(msg.callId);
+    if (!pending) return true;
+    _memoryCallPending.delete(msg.callId);
+    if (msg.ok) pending.resolve(msg.result);
+    else pending.reject(new Error(msg.error || 'memory_call failed'));
+    return true;
+  }
+
+  return {
+    sendNotifyToParent,
+    callMemoryAction,
+    handleMemoryCallResponse,
+  };
+}
+
+export { createParentBridge, normalizeChannelNotifyParams };

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

@@ -104,7 +104,7 @@ function touchUiHeartbeat(instanceId) {
       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 });
+    }, { compact: true, fsync: false, fsyncDir: false, renameFallback: 'truncate' });
   } catch { /* best-effort; a missed tick just relies on the next one */ }
 }
 function buildRuntimeIdentity() {
@@ -209,7 +209,7 @@ function readActiveInstance() {
             && _staleSup2 === undefined;
           if (ownerEmpty) return undefined;
           return { ...stableRestLocked, updatedAt: Date.now() };
-        }, { compact: true, fsync: false, fsyncDir: false });
+        }, { compact: true, fsync: false, fsyncDir: false, renameFallback: 'truncate' });
       } catch {}
     }
     return null;
@@ -240,11 +240,21 @@ function buildActiveInstanceState(instanceId, meta) {
       ...typeof meta?.backendReady === "boolean" ? { backendReady: meta.backendReady } : {}
   };
 }
-function refreshActiveInstance(instanceId, meta) {
+function refreshActiveInstance(instanceId, meta, options) {
   ensureRuntimeDirs();
   return updateJsonAtomicSync(ACTIVE_INSTANCE_FILE, (curRaw) => {
     const prevForPreserve = curRaw;
     const prev = activeInstanceStaleReason(curRaw) ? null : curRaw;
+    // CAS guard (opt-in via options.onlyIfOwned): heartbeat/refresh ticks
+    // check ownership OUTSIDE this lock, so a newer session can claim the
+    // seat between that check and this locked update. Without this re-read,
+    // the tick would overwrite the newer owner's instanceId (TOCTOU
+    // re-steal -> ownership ping-pong / double backend connections).
+    // Returning undefined aborts the update with no write. Explicit claims
+    // (boot, claimBridgeOwnership) omit the option and stay last-wins.
+    if (options?.onlyIfOwned && (!prev?.instanceId || prev.instanceId !== instanceId)) {
+      return undefined;
+    }
     // Drop stale fields (pid/startedAt) written by older server versions.
     const { pid: _legacyPid, startedAt: _legacyStartedAt, ...prevRest } = prev ?? {};
     const identity = buildRuntimeIdentity();
@@ -362,7 +372,7 @@ function refreshActiveInstance(instanceId, meta) {
       }
     }
     return { ...preservedExtra, ...next };
-  }, { compact: true, fsync: false, fsyncDir: false });
+  }, { compact: true, fsync: false, fsyncDir: false, renameFallback: 'truncate' });
 }
 const SERVER_PID_FILE = join(
   RUNTIME_ROOT,

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

@@ -3,7 +3,7 @@ import { appendFile as _appendFile } from "fs";
 import { join, isAbsolute } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
-import { DATA_DIR, DEFAULT_HOLIDAY_COUNTRY, isInQuietWindow } from "./config.mjs";
+import { DATA_DIR } from "./config.mjs";
 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';
@@ -39,7 +39,6 @@ function logSchedule(msg) {
   if (!_schedLogTimer) _schedLogTimer = setTimeout(_flushScheduleLog, 2000);
 }
 
-import { isHoliday } from "./holidays.mjs";
 import { tryRead } from "./settings.mjs";
 // node-cron is an optional runtime dep. If the module isn't installed
 // (e.g. a fresh v0.6.190 where node_modules predates the package.json
@@ -104,7 +103,7 @@ function tzSnapshot(now, tz) {
 class Scheduler {
   nonInteractive;
   interactive;
-  channelsConfig;
+  channelId;
   promptsDir;
   tickTimer = null;
   lastFired = /* @__PURE__ */ new Map();
@@ -122,53 +121,16 @@ class Scheduler {
   // names skipped for today
   skippedTodayDate = "";
   // "YYYY-MM-DD" local date the skippedToday set belongs to
-  holidayCountry = null;
-  // ISO country code for holiday check
-  holidayChecked = "";
-  // "YYYY-MM-DD" last checked date
-  todayIsHoliday = false;
-  // cached result for today
-  quietSchedule = null;
-  // global quiet hours "HH:MM-HH:MM"
   cronJobs = /* @__PURE__ */ new Map();
   // name -> node-cron ScheduledTask for cron-expression entries
   //
-  // 0.1.62 wiring:
-  //   `topConfig` is the normalized top-level channels config from
-  //   loadConfig()/applyDefaults() — it carries `quiet`, `schedules`
-  //   at the top level. `channelsConfig` is still accepted separately
-  //   (channel metadata only, not quiet config) because resolveChannel()
-  //   needs the channel-label → platform-id map.
-  constructor(nonInteractive, interactive, channelsConfig, topConfig) {
+  // `channelId` is the single resolved main-channel id used when a schedule's
+  // `channel` flag is set (post-to-channel); absent flag → inject into session.
+  constructor(nonInteractive, interactive, channelId) {
     this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
     this.interactive = interactive.filter((s) => s.enabled !== false);
-    this.channelsConfig = channelsConfig ?? null;
+    this.channelId = channelId ?? "";
     this.promptsDir = join(DATA_DIR, "prompts");
-    this._applyQuietConfig(topConfig);
-  }
-  /** Resolve quiet/schedules flags from the top-level config
-   *  (0.1.62 shape: `topConfig.quiet`, `topConfig.schedules`). Falls
-   *  through silently to defaults (empty schedule, holidays off,
-   *  respect flag default true) when topConfig is missing or malformed
-   *  — defensive, not legacy. */
-  _applyQuietConfig(topConfig) {
-    const cfg = (topConfig && typeof topConfig === "object") ? topConfig : null;
-    const quietSrc = cfg?.quiet ?? null;
-    const schedulesSrc = cfg?.schedules ?? null;
-    // Holidays: prefer an explicit ISO country code. Legacy boolean `true`
-    // from older setup UI builds is normalized to the local default country.
-    const hol = quietSrc?.holidays;
-    if (hol === true) {
-      this.holidayCountry = DEFAULT_HOLIDAY_COUNTRY;
-    } else if (typeof hol === "string" && hol) {
-      this.holidayCountry = hol.trim().toUpperCase();
-    } else {
-      this.holidayCountry = null;
-    }
-    // Quiet window string "HH:MM-HH:MM" from topConfig.quiet.schedule.
-    this.quietSchedule = quietSrc?.schedule ?? null;
-    // Opt-in flag: default true when unspecified, matching applyDefaults.
-    this.respectQuietSchedules = schedulesSrc?.respectQuiet !== false;
   }
   setInjectHandler(fn) {
     this.injectFn = fn;
@@ -372,8 +334,8 @@ ${Scheduler.INSTANCE_UUID}`;
       }
     }
   }
-  /** Fire path for a cron-triggered entry. Applies day/quiet/holiday
-   *  guards against the schedule's TZ (or local when absent). */
+  /** Fire path for a cron-triggered entry. Applies day guards against
+   *  the schedule's TZ (or local when absent). */
   async onCronFire(schedule, type) {
     const now = /* @__PURE__ */ new Date();
     const tz = schedule.timezone || null;
@@ -381,16 +343,6 @@ ${Scheduler.INSTANCE_UUID}`;
     const isWeekend = snap.dow === 0 || snap.dow === 6;
     const days = schedule.days ?? "daily";
     if (!this.matchesDays(days, snap.dow, isWeekend)) return;
-    if (this.holidayCountry) {
-      try {
-        const holiday = await isHoliday(this.tzDate(now, tz), this.holidayCountry);
-        if (holiday && (schedule.skipHolidays || days === "weekday")) {
-          logSchedule(`skipping "${schedule.name}" \u2014 public holiday\n`);
-          return;
-        }
-      } catch {}
-    }
-    if ((schedule.dnd || this.respectQuietSchedules) && this.isQuietHours(now, tz)) return;
     if (this.shouldSkip(schedule.name)) return;
     // Record lastFired only when the fire actually proceeds past
     // fireTimed's running/precondition guards (it resolves truthy on a
@@ -401,13 +353,6 @@ ${Scheduler.INSTANCE_UUID}`;
       (err) => process.stderr.write(`mixdog scheduler: ${schedule.name} failed: ${err}\n`)
     );
   }
-  /** Produce a Date whose calendar day matches the TZ-adjusted dateStr,
-   *  so holiday lookups by country work against the right day. */
-  tzDate(now, tz) {
-    if (!tz) return now;
-    const snap = tzSnapshot(now, tz);
-    return new Date(`${snap.dateStr}T12:00:00Z`);
-  }
   stop() {
     if (this.tickTimer) {
       clearInterval(this.tickTimer);
@@ -447,14 +392,11 @@ ${Scheduler.INSTANCE_UUID}`;
     } catch {}
     this.start();
   }
-  reloadConfig(nonInteractive, interactive, channelsConfig, topConfig, options = {}) {
+  reloadConfig(nonInteractive, interactive, channelId, options = {}) {
     this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
     this.interactive = interactive.filter((s) => s.enabled !== false);
-    this.channelsConfig = channelsConfig ?? null;
+    this.channelId = channelId ?? "";
     this.promptsDir = join(DATA_DIR, "prompts");
-    this._applyQuietConfig(topConfig);
-    this.holidayChecked = "";
-    this.todayIsHoliday = false;
     if (this.deferred.size > 0 || this.skippedToday.size > 0) {
       process.stderr.write(`mixdog scheduler: reload clearing ${this.deferred.size} deferred, ${this.skippedToday.size} skipped
 `);
@@ -520,24 +462,9 @@ ${Scheduler.INSTANCE_UUID}`;
     );
   }
   async tickAsync() {
-    const now = /* @__PURE__ */ new Date();
-    const dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
-    // All timed schedules are now handled exclusively by node-cron (registerCronJobs).
-    // tick() only drives the holiday cache refresh.
-    if (this.holidayCountry && this.holidayChecked !== dateStr) {
-      this.holidayChecked = dateStr;
-      try {
-        this.todayIsHoliday = await isHoliday(now, this.holidayCountry);
-        if (this.todayIsHoliday) {
-          process.stderr.write(`mixdog scheduler: today (${dateStr}) is a holiday \u2014 weekday schedules will be skipped
-`);
-        }
-      } catch (err) {
-        process.stderr.write(`mixdog scheduler: holiday check failed: ${err}
-`);
-        this.todayIsHoliday = false;
-      }
-    }
+    // All timed schedules are handled exclusively by node-cron
+    // (registerCronJobs). tick() no longer does any per-day work; the
+    // interval is kept for future cadence-driven work and lifecycle parity.
   }
   /** Day abbreviation → JS day number (0=Sun...6=Sat) */
   static DAY_ABBRS = {
@@ -557,18 +484,6 @@ ${Scheduler.INSTANCE_UUID}`;
     const dayList = days.split(",").map((d) => d.trim().toLowerCase());
     return dayList.some((d) => Scheduler.DAY_ABBRS[d] === dow);
   }
-  /** Check if current time is within global quiet hours (quiet.schedule).
-   *  tz optional — when set, HH:MM is evaluated in the given IANA zone.
-   *
-   *  Delegates to the shared, now TZ-aware isInQuietWindow(cfg, now, tz)
-   *  helper in lib/config.mjs. Holidays are passed as `false` here on
-   *  purpose: public-holiday skips for the scheduler are handled by the
-   *  separate holidayCountry / skipHolidays / days==="weekday" path in
-   *  onCronFire, so this quiet-window check stays schedule-window only —
-   *  identical to the prior local implementation. */
-  isQuietHours(now, tz) {
-    return isInQuietWindow({ schedule: this.quietSchedule, holidays: false }, now, tz);
-  }
   // ── Fire timed schedule ─────────────────────────────────────────────
   async fireTimed(schedule, type) {
     const execMode = schedule.exec ?? "prompt";
@@ -680,21 +595,20 @@ ${scriptResult}
     });
   }
   // ── Helpers ─────────────────────────────────────────────────────────
-  /** Resolve a channel label to its platform ID via channelsConfig, fallback to raw value */
-  resolveChannel(label) {
-    const entry = this.channelsConfig?.[label];
-    if (entry?.channelId) return entry.channelId;
-    // Misconfigured label: no channelsConfig entry, so we fall back to
-    // using the raw label as the channel id. Warn once per label so the
-    // misconfiguration is diagnosable without spamming stderr.
-    if (label != null) {
-      this._channelFallbackWarned ??= new Set();
-      if (!this._channelFallbackWarned.has(label)) {
-        this._channelFallbackWarned.add(label);
-        process.stderr.write(`mixdog scheduler: channel label "${label}" not found in channelsConfig — using it as a raw channel id\n`);
-      }
-    }
-    return label;
+  /**
+   * Map a schedule's `channel` flag to a target channel id. The flag is
+   * boolean-ish: any non-empty value except "false" (including legacy labels
+   * like "main") means "post to the main channel"; absent/false → "" (inject
+   * into the Lead session). No label resolution. A pure-digit / snowflake
+   * value is honored verbatim as an explicit id override (matches
+   * resolveWebhookChannelId in index.mjs).
+   */
+  resolveChannel(flag) {
+    if (flag == null) return "";
+    const v = String(flag).trim();
+    if (v === "" || v.toLowerCase() === "false") return "";
+    if (/^-?\d+$/.test(v)) return v;
+    return this.channelId ?? "";
   }
   /** Resolve prompt: try file first, fall back to inline text */
   resolvePrompt(schedule) {