mixdog 0.9.135 → 0.9.136

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

@@ -1,16 +1,9 @@
 import { readFileSync, mkdirSync } from "fs";
 import { join } from "path";
-import { DiscordProvider } from "../providers/discord.mjs";
-import { TelegramProvider } from "../providers/telegram.mjs";
 import {
   readSection,
   updateSection,
   CONFIG_PATH as MIXDOG_CONFIG_PATH,
-  SECRET_ACCOUNTS,
-  getDiscordToken,
-  getTelegramToken,
-  diagnoseDiscordTokenValue,
-  invalidateSecretReadCache,
 } from "../../shared/config.mjs";
 import { listSchedules } from "../../shared/schedules-db.mjs";
 import { resolvePluginData } from "../../shared/plugin-paths.mjs";
@@ -22,9 +15,6 @@ const DEFAULT_ACCESS = {
   channels: {}
 };
 const DEFAULT_CONFIG = {
-  provider: "discord",
-  discord: { token: "" },
-  telegram: { token: "" },
   access: DEFAULT_ACCESS,
   channel: {}
 };
@@ -40,27 +30,8 @@ function applyDefaults(config) {
   return out;
 }
 
-function channelIdForProvider(entry = {}, provider = "discord") {
-  if (provider === "telegram") {
-    return String(entry?.telegramChatId || "");
-  }
-  return String(entry?.discordChannelId || "");
-}
-
-// Resolve the single active-provider channel id from the config's `channel`
-// section. Disk config carries a single `channel` object only.
-function resolveChannelId(raw = {}, provider = "discord") {
-  const channel = raw.channel && typeof raw.channel === "object" ? raw.channel : null;
-  if (channel) return channelIdForProvider(channel, provider);
-  return "";
-}
-
-async function loadConfig({ freshSecrets = false } = {}) {
+async function loadConfig() {
   try {
-    if (freshSecrets) {
-      invalidateSecretReadCache(SECRET_ACCOUNTS.discordToken);
-      invalidateSecretReadCache(SECRET_ACCOUNTS.telegramToken);
-    }
     let raw = readSection("channels");
     raw = raw && typeof raw === "object" ? raw : {};
     // Schedules are the PG `scheduler.schedules` table (single source of
@@ -83,27 +54,11 @@ async function loadConfig({ freshSecrets = false } = {}) {
       const v = readSection("voice");
       if (v && typeof v === "object") voice = v;
     } catch { /* missing section is fine */ }
-    const discordToken = getDiscordToken();
-    const discordTokenProblem = diagnoseDiscordTokenValue(discordToken, raw);
-    if (discordTokenProblem) {
-      process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
-    }
-    // Single-provider select: config.provider picks ONE of discord|telegram.
-    // Anything else falls back to the discord default.
-    const provider = raw.provider === "telegram" ? "telegram" : "discord";
-    const telegramToken = getTelegramToken();
-    const channelId = resolveChannelId(raw, provider);
-    // The runtime reads only the resolved `channelId`; disk carries a single
-    // `channel` object, so spread `raw` directly.
+    // Messaging is retired: no provider select, no tokens, no channel id.
     return applyDefaults({
       ...DEFAULT_CONFIG,
       ...raw,
-      provider,
-      channelId,
-      discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
-      // Merge the keychain-resolved telegram token (harmless when provider 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 } : {}) },
+      channelId: "",
       access: {
         ...DEFAULT_ACCESS,
         ...(raw.access || {}),
@@ -116,9 +71,7 @@ async function loadConfig({ freshSecrets = false } = {}) {
       mkdirSync(DATA_DIR, { recursive: true });
       updateSection("channels", () => DEFAULT_CONFIG);
       process.stderr.write(
-        `mixdog: default channels config created in ${MIXDOG_CONFIG_PATH}
-  edit the active provider channel id to connect.
-`
+        `mixdog: default channels config created in ${MIXDOG_CONFIG_PATH}\n`
       );
       return applyDefaults(DEFAULT_CONFIG);
     }
@@ -154,56 +107,18 @@ const HEADLESS_PROVIDER = {
     return Buffer.alloc(0);
   },
   on() {
+  },
+  startTyping() {
+  },
+  stopTyping() {
   }
 };
-function createProvider(config) {
-  // Channels-module toggle is MESSAGING-ONLY: automation (scheduler/webhooks)
-  // keeps the worker alive, so a disabled module runs the headless provider
-  // instead of blocking the whole runtime.
-  if (config.enabled === false) {
-    process.stderr.write("mixdog: channels messaging disabled; channel runtime running in headless mode\n");
-    return HEADLESS_PROVIDER;
-  }
-  // Single-provider select: exactly one provider is constructed based on
-  // config.provider (discord|telegram). The two are mutually exclusive.
-  if (config.provider === "telegram") {
-    const telegramToken = getTelegramToken();
-    if (!telegramToken) {
-      process.stderr.write("mixdog: telegram bot not configured; channel runtime running in headless mode\n");
-      return HEADLESS_PROVIDER;
-    }
-    const tgStateDir = config.telegram?.stateDir ?? join(DATA_DIR, "telegram");
-    mkdirSync(tgStateDir, { recursive: true });
-    return new TelegramProvider({
-      ...config.telegram,
-      configPath: CONFIG_FILE,
-      access: config.access,
-      // Single-source channel setup: the main chat is auto-allowed inside
-      // TelegramProvider.loadAccess() so the configured Telegram target is
-      // enough for both inbound gating and outbound.
-      mainChannelId: config.channelId
-    }, tgStateDir);
-  }
-  const discordToken = getDiscordToken();
-  const discordTokenProblem = diagnoseDiscordTokenValue(discordToken, config);
-  if (discordTokenProblem) {
-    process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
-  }
-  if (config.provider !== "discord" || !discordToken || discordTokenProblem) {
-    process.stderr.write("mixdog: discord bot not configured; channel runtime running in headless mode\n");
-    return HEADLESS_PROVIDER;
-  }
-  const stateDir = config.discord.stateDir ?? join(DATA_DIR, "discord");
-  mkdirSync(stateDir, { recursive: true });
-  return new DiscordProvider({
-    ...config.discord,
-    configPath: CONFIG_FILE,
-    access: config.access,
-    // Single-source channel setup: the main channel is auto-allowed inside
-    // DiscordProvider.loadAccess() so the configured Discord target is enough
-    // for both inbound and outbound — no separate access.channels entry.
-    mainChannelId: config.channelId
-  }, stateDir);
+function createProvider() {
+  // Discord/Telegram messaging is retired (user decision: the PWA replaces
+  // it). The channel runtime always runs headless: automation
+  // (scheduler/webhooks) and voice transcription keep the worker alive while
+  // every messaging call is a no-op.
+  return HEADLESS_PROVIDER;
 }
 const PROFILE_FILE = join(DATA_DIR, "profile.json");
 function loadProfileConfig() {
@@ -216,8 +131,6 @@ function loadProfileConfig() {
 export {
   DATA_DIR,
   createProvider,
-  getDiscordToken,
-  getTelegramToken,
   loadConfig,
   loadProfileConfig
 };

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

@@ -2,11 +2,8 @@ import * as fs from "fs";
 import * as path from "path";
 import { DATA_DIR } from "./config.mjs";
 
-// Drop-trace instrumentation for channels/index.mjs.
-// Extracted verbatim (behavior-preserving). Distinct from lib/drop-trace.mjs
-// (which the output-forwarder uses): this instance is owned by index.mjs and
-// keeps its own buffered writer + `preview` helper so the two trace streams
-// stay byte-identical to the pre-split behavior.
+// Drop-trace instrumentation for channels/index.mjs: buffered writer +
+// `preview` helper owned by index.mjs.
 const _dropTraceLog = path.join(DATA_DIR, "drop-trace.log");
 const DROP_TRACE_ENABLED =
   process.env.MIXDOG_DROP_TRACE === "1" ||

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

@@ -31,24 +31,17 @@ export function createOwnedRuntime({
   getChannelBridgeActive,
   instanceId,
   TERMINAL_LEAD_PID,
-  forwarder,
   sendNotifyToParent,
   scheduler,
   statusState,
   logOwnership,
   currentOwnerState,
-  bindPersistedTranscriptIfAny,
-  cancelPendingTranscriptRearm,
-  schedulePendingTranscriptRearm,
-  stopServerTyping,
   wireWebhookHandlers,
   wireEventQueueHandlers,
-  memoryDrainBuffer,
 }) {
   let bridgeRuntimeStarting = false;
   let _ownedRuntimeStopRequested = false;
   let bridgeOwnershipRefreshInFlight = null;
-  let _memoryDrainTimer = null;
   // Automation (scheduler + webhook server + relay tunnel) can outlive a
   // failed/absent messaging provider: it is tracked separately so teardown and
   // reload know it is running even while bridgeRuntimeConnected stays false.
@@ -174,27 +167,16 @@ let _ownedRuntimeSelfHealing = false;
 // reconnect window can reset a healthy reconnect loop. Keep this for explicit
 // activation/reload recovery only.
 async function selfHealOwnedRuntime(options = {}) {
-  const shouldRestoreBinding = options.restoreBinding === true;
   const shouldResetProvider = options.resetProvider === true;
-  if (!shouldRestoreBinding && !shouldResetProvider) return;
+  if (!shouldResetProvider) return;
   if (_ownedRuntimeSelfHealing) return;
   _ownedRuntimeSelfHealing = true;
   try {
-    if (shouldRestoreBinding) {
-      await bindPersistedTranscriptIfAny().catch((e) => {
-        process.stderr.write(`mixdog: self-heal bindPersistedTranscriptIfAny failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
-      });
-    }
-    if (shouldResetProvider && typeof getProvider()?._resetClient === "function") {
+    if (typeof getProvider()?._resetClient === "function") {
       await getProvider()._resetClient().catch((e) => {
         process.stderr.write(`mixdog: self-heal getProvider() reset failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
       });
     }
-    // Do NOT nudge forwardNewText() here. bindPersistedTranscriptIfAny() above
-    // already forwards the same-session catch-up from the persisted cursor; an
-    // extra drain risks surfacing the old tail of a freshly (re)bound transcript
-    // on connect/change/rebind. Only outputs created after the new binding
-    // should be forwarded, and the normal watch/poll path handles those.
   } finally {
     _ownedRuntimeSelfHealing = false;
   }
@@ -237,13 +219,6 @@ async function startOwnedRuntime(options = {}) {
     process.stderr.write(`mixdog: pre-connect metadata advert aborted (${e instanceof Error ? e.message : String(e)})\n`);
     return;
   }
-  // Periodic buffer drain: replays memory-buffer/entry-*/ingest-*.json once the
-  // daemon-hosted memory runtime is ready. Idempotent + reentrancy-guarded inside
-  // drainBuffer(); unref'd so it never holds the worker open.
-  if (!_memoryDrainTimer) {
-    _memoryDrainTimer = setInterval(() => { void memoryDrainBuffer().catch(() => {}); }, 5e3);
-    _memoryDrainTimer.unref?.();
-  }
   // Re-check after each post-connect await so a stopOwnedRuntime() landing
   // mid-start cannot be overridden by the resuming start (scheduler/snapshot/
   // webhook/binding launches below would revive owner state after stop).
@@ -260,12 +235,6 @@ async function startOwnedRuntime(options = {}) {
     _ownedRuntimeStopRequested = false;
     return true;
   };
-  const restoreBinding = options.restoreBinding !== false;
-  const bindPersistedTranscriptTask = restoreBinding
-    ? bindPersistedTranscriptIfAny().catch((e) => {
-      process.stderr.write(`mixdog: bindPersistedTranscriptIfAny failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
-    })
-    : null;
   // Await getProvider().connect() so callers (and bindingReady) only resolve after
   // the Discord binding is real. Previously this was fire-and-forget and
   // refreshBridgeOwnership returned immediately, letting bindingReady fire
@@ -273,9 +242,6 @@ async function startOwnedRuntime(options = {}) {
   try {
     await startingProvider.connect();
     if (await bailIfStopRequested()) {
-      cancelPendingTranscriptRearm();
-      try { forwarder.stopWatch(); } catch {}
-      if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
       return;
     }
     // Advertise provider readiness (metadata advert).
@@ -301,9 +267,6 @@ async function startOwnedRuntime(options = {}) {
       process.stderr.write(`mixdog: initProviders failed (non-fatal): ${e instanceof Error ? e.message : String(e)}\n`);
     }
     if (await bailIfStopRequested()) {
-      cancelPendingTranscriptRearm();
-      try { forwarder.stopWatch(); } catch {}
-      if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
       return;
     }
     // Reconnect after a degraded (automation-only) start must not double-arm
@@ -314,26 +277,10 @@ async function startOwnedRuntime(options = {}) {
     }
     syncOwnedWebhookAndEventRuntime();
     automationRunning = true;
-    if (restoreBinding) {
-      if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
-      const pendingTranscriptPath = forwarder.transcriptPath;
-      if (pendingTranscriptPath && !fs.existsSync(pendingTranscriptPath)) {
-        // Pre-connect bind may have armed rearm while !getBridgeRuntimeConnected();
-        // the first tick then exits without rescheduling. Re-arm now that we own.
-        schedulePendingTranscriptRearm(statusState.read().channelId, pendingTranscriptPath);
-      } else {
-        void forwarder.forwardNewText().catch((err) => {
-          process.stderr.write(`mixdog: post-connect forwardNewText failed (non-fatal): ${err instanceof Error ? err.message : String(err)}\n`);
-        });
-      }
-    }
     process.stderr.write(`mixdog: running with ${getProvider().name} getProvider()\n`);
     logOwnership(`active owner lead=${TERMINAL_LEAD_PID} pid=${process.pid}`);
   } catch (e) {
     process.stderr.write(`mixdog: getProvider() connect failed (non-fatal, cycle1/MCP still up): ${e instanceof Error ? e.message : String(e)}\n`);
-    cancelPendingTranscriptRearm();
-    try { forwarder.stopWatch(); } catch {}
-    if (bindPersistedTranscriptTask) await bindPersistedTranscriptTask;
     // Roll back partial owner-side state advertised before connect() ran:
     // disconnect the provider WE started (a post-connect startup step may have
     // thrown while the gateway is live), then release the channel locks + clear
@@ -341,7 +288,6 @@ async function startOwnedRuntime(options = {}) {
     try { await startingProvider.disconnect(); } catch {}
     try { releaseOwnedChannelLocks(instanceId); } catch {}
     try { clearActiveInstance(instanceId); } catch {}
-    if (_memoryDrainTimer) { clearInterval(_memoryDrainTimer); _memoryDrainTimer = null; }
     // DEGRADED MODE (automation decoupling): a messaging connect failure —
     // packaged runtime without discord.js, bad token, gateway outage — must
     // not take schedules/webhooks down with it. Start the automation runtime
@@ -364,11 +310,6 @@ async function startOwnedRuntime(options = {}) {
   }
 }
 async function stopOwnedRuntime(reason) {
-  // Cancel any pending transcript re-arm poll BEFORE the connected/starting
-  // early-return below. Otherwise a poll armed against a not-yet-existing
-  // transcript could fire after teardown and reinstall the fs.watch handle
-  // (startWatch is not owner-gated), leaking a live watcher past shutdown.
-  cancelPendingTranscriptRearm();
   // startOwnedRuntime() advertises owner HTTP/heartbeat/active-instance and
   // claims channel locks BEFORE awaiting getProvider().connect(). If shutdown lands
   // during that window (bridgeRuntimeStarting=true, getBridgeRuntimeConnected()
@@ -384,13 +325,6 @@ async function stopOwnedRuntime(reason) {
     try { await automationStartPromise; } catch {}
   }
   const wasConnected = getBridgeRuntimeConnected();
-  stopServerTyping();
-  // Release the transcript fs.watch handle plus the forwarder's debounce/retry
-  // timers on standby. Without this the watcher keeps firing scheduleWatchFlush
-  // and the drain/retry timers stay live after ownership is dropped, leaking a
-  // file handle + timers for the rest of the process lifetime.
-  try { forwarder.stopWatch(); } catch {}
-  if (_memoryDrainTimer) { clearInterval(_memoryDrainTimer); _memoryDrainTimer = null; }
   scheduler.stop();
   stopSnapshotWriter();
   await stopWebhookAndEventRuntime();
@@ -499,19 +433,9 @@ async function reloadRuntimeConfig() {
     // the restart and the NEW provider would never connect (lost-restart race).
     if (_inFlightStart) { try { await _inFlightStart; } catch {} }
     setProvider(nextProvider);
-    // The persisted routing channelId belongs to the OLD getProvider() (e.g. a
-    // Discord snowflake) and is meaningless for the new one — sending to it
-    // would 400 "chat not found". There is no id mapping between platforms, so
-    // CLEAR the stale binding: drop the forwarder's context + watcher and wipe
-    // status.channelId/transcriptPath. The next inbound from the new getProvider()
-    // rebinds the correct chat via applyTranscriptBinding(). Only done on
-    // providerChanged — same-getProvider() reloads keep their binding untouched.
-    // (active-instance is cleared by stopOwnedRuntime on the restart path; we
-    // don't re-advertise here to avoid resurrecting a just-cleared entry.)
+    // Provider-type change wipes the persisted routing ids; messaging is
+    // retired, so only the status snapshot needs clearing.
     if (providerTypeChanged) {
-      try { forwarder.stopWatch(); } catch {}
-      forwarder.channelId = "";
-      forwarder.transcriptPath = "";
       try {
         statusState.update((state) => {
           state.channelId = "";

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

@@ -6,7 +6,17 @@ import { DATA_DIR } from "./config.mjs";
 import { ensureNopluginDir } from "./executor.mjs";
 import { withFileLockSync } from "../../shared/atomic-file.mjs";
 import { resolveRuntimeRoot } from "../../shared/runtime-root.mjs";
-import { markFired, markDone, setDeferred, setSkippedUntil } from "../../shared/schedules-db.mjs";
+import {
+  advanceScheduleCursor,
+  claimScheduleRun,
+  markFired,
+  markDone,
+  markScheduleFailure,
+  markScheduleSuccess,
+  setDeferred,
+  setNextFire,
+  setSkippedUntil,
+} from "../../shared/schedules-db.mjs";
 import { runScheduleSession } from "../../shared/schedule-session-run.mjs";
 
 const SCHEDULE_LOG = join(DATA_DIR, "schedule.log");
@@ -107,6 +117,9 @@ class Scheduler {
     this.interactive = interactive.filter((s) => s.enabled !== false);
     this.channelId = channelId ?? "";
     this.promptsDir = join(DATA_DIR, "prompts");
+    for (const s of [...this.nonInteractive, ...this.interactive]) {
+      if (s.lastFiredAt) this.lastFired.set(s.name, new Date(s.lastFiredAt).toISOString());
+    }
     this.refreshSkipCache();
   }
   setInjectHandler(fn) {
@@ -341,11 +354,18 @@ ${Scheduler.INSTANCE_UUID}`;
           continue;
         }
         try {
-          const task = cron.schedule(s.whenCron, () => this.onCronFire(s, type), {
+          const task = cron.schedule(s.whenCron, (ctx) => this.onCronFire(s, type, ctx?.date), {
             timezone: s.timezone || undefined,
             name: s.name,
           });
           this.cronJobs.set(s.name, task);
+          const next = typeof task.getNextRun === "function" ? task.getNextRun() : null;
+          if (next) {
+            s.nextFireAt = next.toISOString();
+            void setNextFire(s.name, next).catch((err) => {
+              process.stderr.write(`mixdog scheduler: ${s.name} setNextFire failed: ${err}\n`);
+            });
+          }
           logSchedule(`registered cron "${s.name}" = "${s.whenCron}"${s.timezone ? ` tz=${s.timezone}` : ""}\n`);
         } catch (err) {
           process.stderr.write(`mixdog scheduler: failed to register cron "${s.name}" (${s.whenCron}): ${err}\n`);
@@ -357,20 +377,44 @@ ${Scheduler.INSTANCE_UUID}`;
   }
   /** Fire path for a cron-triggered entry. node-cron's dow field covers the
    *  day guard, so there is no separate days filter. Persists last_fired_at. */
-  async onCronFire(schedule, type) {
-    const now = /* @__PURE__ */ new Date();
-    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
-    // real fire), so failed/skipped fires no longer display as fired.
-    this.fireTimed(schedule, type).then(async (fired) => {
-      if (!fired) return;
-      this.lastFired.set(schedule.name, now.toISOString());
-      try { await markFired(schedule.name, now); }
-      catch (err) { process.stderr.write(`mixdog scheduler: ${schedule.name} markFired failed: ${err}\n`); }
-    }).catch(
-      (err) => process.stderr.write(`mixdog scheduler: ${schedule.name} failed: ${err}\n`)
-    );
+  async onCronFire(schedule, type, scheduledDate = null) {
+    const startedAt = /* @__PURE__ */ new Date();
+    const scheduledAt = scheduledDate instanceof Date && Number.isFinite(scheduledDate.getTime())
+      ? scheduledDate
+      : startedAt;
+    const task = this.cronJobs.get(schedule.name);
+    const nextFireAt = typeof task?.getNextRun === "function" ? task.getNextRun() : null;
+    schedule.nextFireAt = nextFireAt?.toISOString?.() ?? null;
+    if (this.shouldSkip(schedule.name)) {
+      try { await advanceScheduleCursor(schedule.name, scheduledAt, nextFireAt); }
+      catch (err) { process.stderr.write(`mixdog scheduler: ${schedule.name} cursor advance failed: ${err}\n`); }
+      return;
+    }
+    try {
+      const claimed = await claimScheduleRun(schedule.name, scheduledAt, startedAt, nextFireAt);
+      if (!claimed) {
+        logSchedule(`${schedule.name}: duplicate/stale cron slot skipped\n`);
+        return;
+      }
+      schedule.lastScheduledAt = scheduledAt.toISOString();
+      schedule.lastStartedAt = startedAt.toISOString();
+      schedule.lastFiredAt = startedAt.toISOString();
+      this.lastFired.set(schedule.name, startedAt.toISOString());
+      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true });
+      if (!fired) {
+        schedule.lastFailedAt = new Date().toISOString();
+        await markScheduleFailure(schedule.name, new Date());
+        return;
+      }
+      const completedAt = new Date();
+      schedule.lastSuccessAt = completedAt.toISOString();
+      await markScheduleSuccess(schedule.name, completedAt);
+    } catch (err) {
+      schedule.lastFailedAt = new Date().toISOString();
+      try { await markScheduleFailure(schedule.name, new Date()); } catch {}
+      process.stderr.write(`mixdog scheduler: ${schedule.name} failed: ${err}\n`);
+      this.notifyFailure(schedule, `run failed: ${err?.message || err}`);
+    }
   }
   stop() {
     if (this.tickTimer) {
@@ -419,6 +463,8 @@ ${Scheduler.INSTANCE_UUID}`;
     }
     const timer = setTimeout(() => this.fireOneShot(schedule, type), Math.max(0, delay));
     this.oneShotTimers.set(schedule.name, timer);
+    schedule.nextFireAt = new Date(fireAt).toISOString();
+    void setNextFire(schedule.name, new Date(fireAt)).catch(() => {});
     logSchedule(`armed one-shot "${schedule.name}" at ${new Date(fireAt).toISOString()}${delay <= 0 ? " (misfire → immediate)" : ""}\n`);
   }
   /** markDone with bounded retry. A one-shot that fired but failed to persist
@@ -462,6 +508,8 @@ ${Scheduler.INSTANCE_UUID}`;
       logSchedule(`one-shot "${schedule.name}" deferred/skipped — re-arming for ${new Date(target).toISOString()}\n`);
       const timer = setTimeout(() => this.fireOneShot(schedule, type), delay);
       this.oneShotTimers.set(schedule.name, timer);
+      schedule.nextFireAt = new Date(target).toISOString();
+      void setNextFire(schedule.name, new Date(target)).catch(() => {});
       return;
     }
     // Mark done ONLY after a successful fire. A false/throwing fireTimed
@@ -474,6 +522,8 @@ ${Scheduler.INSTANCE_UUID}`;
       // rejects. Only a resolved dispatch counts as a real fire here.
       const fired = await this.fireTimed(schedule, type, { awaitDispatch: true });
       if (!fired) {
+        schedule.lastFailedAt = new Date().toISOString();
+        try { await markScheduleFailure(schedule.name, new Date()); } catch {}
         logSchedule(`one-shot "${schedule.name}" did not fire (skipped/guarded) — leaving pending for retry\n`);
         return;
       }
@@ -481,8 +531,12 @@ ${Scheduler.INSTANCE_UUID}`;
       schedule.lastFiredAt = now.toISOString();
       try { await markFired(schedule.name, now); }
       catch (err) { process.stderr.write(`mixdog scheduler: ${schedule.name} markFired failed: ${err}\n`); }
+      schedule.lastSuccessAt = new Date().toISOString();
+      try { await markScheduleSuccess(schedule.name, new Date()); } catch {}
       await this.markDoneWithRetry(schedule.name);
     } catch (err) {
+      schedule.lastFailedAt = new Date().toISOString();
+      try { await markScheduleFailure(schedule.name, new Date()); } catch {}
       process.stderr.write(`mixdog scheduler: ${schedule.name} one-shot failed: ${err} — leaving pending for retry\n`);
       this.notifyFailure(schedule, `one-shot failed: ${err?.message || err} — left pending for retry`);
     }
@@ -526,8 +580,11 @@ ${Scheduler.INSTANCE_UUID}`;
       name: s.name,
       time: s.whenCron ?? s.whenAt ?? null,
       type,
-      running: false,
-      lastFired: this.lastFired.get(s.name) ?? null,
+      running: this.running.has(s.name),
+      lastFired: this.lastFired.get(s.name) ?? s.lastFiredAt ?? null,
+      lastSuccess: s.lastSuccessAt ?? null,
+      lastFailed: s.lastFailedAt ?? null,
+      nextFire: s.nextFireAt ?? null,
     }));
   }
   async triggerManual(name) {

package/src/runtime/channels/lib/status-snapshot.mjs

@@ -3,7 +3,7 @@
  *
  * Writes <DATA_DIR>/channels/status-snapshot.json every 10 seconds so that
  * setup-server can read cross-process state (cron next-fire, deferred count,
- * Discord unread, relay hook URL) without IPC.
+ * relay hook URL) without IPC.
  *
  * Atomic write: tmp → rename so readers never see a partial file.
  *
@@ -31,60 +31,12 @@ function stableSnapshotJson(snapshot) {
   return JSON.stringify(stable, null, 2);
 }
 
-// ── In-memory Discord unread tracking ────────────────────────────────────────
-// Key: channelId  Value: { label, latestSeenId, unseenCount }
-// No persistence across restarts — clean start is fine for v1.
-const _discordUnread = new Map();
-const DISCORD_UNREAD_MAX_CHANNELS = 500;
-
-/**
- * Called whenever the provider observes messages for a channelId.
- * `messages` is the array returned by provider.fetchMessages().
- * We record the most-recently-seen message id and count messages
- * received since the last call as "unread since last fetch".
- * Pass { markRead: true } for live gateway messages that were already
- * delivered into the bridge.
- */
-export function recordFetchedMessages(channelId, channelLabel, messages, options = {}) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  const prev = _discordUnread.get(channelId);
-  const prevLatestId = prev?.latestSeenId ?? null;
-  const newLatestId  = messages[messages.length - 1]?.id ?? null;
-
-  // Count messages newer than the last seen id (BigInt-compare Discord snowflakes).
-  let unseenCount = 0;
-  if (options.markRead === true) {
-    unseenCount = 0;
-  } else if (prevLatestId) {
-    for (const m of messages) {
-      try {
-        if (BigInt(m.id) > BigInt(prevLatestId)) unseenCount++;
-      } catch { unseenCount++; }
-    }
-  }
-  // First call: zero unread (baseline, not retroactive).
-
-  // Retain the most recently observed channels only. Channel ids originate from
-  // inbound traffic and ad-hoc fetches, so an unbounded process-wide registry
-  // would otherwise grow for the worker lifetime.
-  if (_discordUnread.has(channelId)) {
-    _discordUnread.delete(channelId);
-  } else if (_discordUnread.size >= DISCORD_UNREAD_MAX_CHANNELS) {
-    _discordUnread.delete(_discordUnread.keys().next().value);
-  }
-  _discordUnread.set(channelId, {
-    label: channelLabel ?? channelId,
-    latestSeenId: newLatestId,
-    unseenCount,
-  });
-}
-
 // ── Snapshot computation ─────────────────────────────────────────────────────
 // The legacy HH:MM / everyNm / hourly next-fire fallback was removed: the
 // scheduler accepts cron expressions exclusively (scheduler.mjs:68), so the
 // fallback could only produce stale next-fire timestamps for entries that
 // never actually fire under the cron-only scheduler.
-async function computeSnapshot(scheduler) {
+export async function computeSnapshot(scheduler) {
   const now = Date.now();
 
   // ── Schedules ──────────────────────────────────────────────────────────────
@@ -97,9 +49,10 @@ async function computeSnapshot(scheduler) {
       for (const [name, task] of scheduler.cronJobs) {
         if (scheduler.shouldSkip && scheduler.shouldSkip(name)) continue;
         try {
-          // node-cron ScheduledTask exposes nextDate() / getNextDate()
-          // depending on the installed version; try both.
+          // node-cron v4 exposes getNextRun(); retain older aliases for
+          // compatibility with persisted installations on an earlier runtime.
           const nd =
+            (typeof task.getNextRun === 'function' ? task.getNextRun() : null) ??
             (typeof task.nextDate  === 'function' ? task.nextDate()  : null) ??
             (typeof task.getNextDate === 'function' ? task.getNextDate() : null);
           if (!nd) continue;
@@ -136,18 +89,6 @@ async function computeSnapshot(scheduler) {
     }
   }
 
-  // ── Discord unread ─────────────────────────────────────────────────────────
-  const unreadList = [];
-  let totalUnread  = 0;
-  for (const [channelId, entry] of _discordUnread) {
-    unreadList.push({
-      channelId,
-      channelLabel: entry.label,
-      count: entry.unseenCount,
-    });
-    totalUnread += entry.unseenCount;
-  }
-
   // ── Relay hook URL (identity file read; assigned on first tunnel start) ────
   const hookPublicUrl = readHookPublicBase();
 
@@ -160,10 +101,6 @@ async function computeSnapshot(scheduler) {
       deferred,
       deferredCount: deferred.length,
     },
-    discord: {
-      unread: unreadList,
-      totalUnread,
-    },
     hook: {
       publicUrl: hookPublicUrl,
     },