mixdog 0.9.24 → 0.9.26

package/src/standalone/channel-admin.mjs

@@ -24,6 +24,20 @@ import {
 } from '../runtime/shared/config.mjs';
 import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
 import { readMarkdownDocument, serializeFrontmatterDoc } from '../runtime/shared/markdown-frontmatter.mjs';
+import {
+  listSchedules as dbListSchedules,
+  getSchedule as dbGetSchedule,
+  upsertSchedule,
+  deleteSchedule as dbDeleteSchedule,
+  setEnabled as dbSetEnabled,
+} from '../runtime/shared/schedules-db.mjs';
+import {
+  listEndpoints as dbListEndpoints,
+  loadEndpointConfig as dbLoadEndpoint,
+  upsertEndpoint as dbUpsertEndpoint,
+  deleteEndpoint as dbDeleteEndpoint,
+  setEndpointEnabled as dbSetEndpointEnabled,
+} from '../runtime/shared/webhooks-db.mjs';
 
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const DEFAULT_CHANNELS = Object.freeze({
@@ -38,10 +52,6 @@ function dataDir() {
   return resolvePluginData();
 }
 
-function schedulesDir() {
-  return join(dataDir(), 'schedules');
-}
-
 function webhooksDir() {
   return join(dataDir(), 'webhooks');
 }
@@ -279,34 +289,86 @@ function normalizeCron(time) {
   return value;
 }
 
-export function listSchedules() {
-  return listEntryDirs(schedulesDir()).map((name) => {
-    const dir = join(schedulesDir(), name);
-    const { frontmatter, body } = readMarkdownDocument(readText(join(dir, 'SCHEDULE.md'), ''));
-    const config = { ...frontmatter };
-    if (Object.prototype.hasOwnProperty.call(config, 'enabled')) {
-      config.enabled = config.enabled !== 'false' && config.enabled !== false;
+// Day-name / keyword -> cron day-of-week number (Sun=0 .. Sat=6).
+const DAY_TOKEN_TO_DOW = {
+  sun: 0, sunday: 0,
+  mon: 1, monday: 1,
+  tue: 2, tues: 2, tuesday: 2,
+  wed: 3, weds: 3, wednesday: 3,
+  thu: 4, thur: 4, thurs: 4, thursday: 4,
+  fri: 5, friday: 5,
+  sat: 6, saturday: 6,
+};
+
+// Fold a legacy `days` selector into the day-of-week (last) field of a cron
+// expression: daily -> '*', weekday -> '1-5', weekend -> '0,6', explicit day
+// lists ("mon,wed,fri" | "1,3,5") -> comma-joined numbers. Throws on an
+// unmappable token so bad combos surface instead of silently mis-scheduling.
+export function foldDaysIntoCron(cron, days) {
+  const parts = String(cron).trim().split(/\s+/);
+  const dowIndex = parts.length - 1;
+  const raw = String(days || '').trim().toLowerCase();
+  // days absent -> keep the cron's own day-of-week field ('0 9 * * 1' stays
+  // Monday-only). Only an explicit selector rewrites the dow field.
+  if (!raw) return parts.join(' ');
+  let dow;
+  if (raw === 'daily' || raw === 'everyday' || raw === 'every day') dow = '*';
+  else if (raw === 'weekday' || raw === 'weekdays') dow = '1-5';
+  else if (raw === 'weekend' || raw === 'weekends') dow = '0,6';
+  else {
+    const nums = raw.split(/[\s,]+/).filter(Boolean).map((tok) => (
+      /^[0-6]$/.test(tok) ? Number(tok) : DAY_TOKEN_TO_DOW[tok]
+    ));
+    if (nums.some((n) => n === undefined)) {
+      throw new Error(`days "${days}" is not a recognizable day selector`);
     }
-    // Dir name is canonical identity; frontmatter `name` is display-only and
-    // must never override the slug used for routing/deletion. `description`
-    // defaults to '' for old files with no such key (backward compat).
-    const description = String(config.description || '');
-    delete config.name;
-    delete config.description;
-    return {
-      name,
-      description,
-      ...config,
-      instructions: body,
-      route: config.channel ? `channel:${config.channel}` : 'session',
-    };
-  });
+    dow = nums.join(',');
+  }
+  parts[dowIndex] = dow;
+  return parts.join(' ');
+}
+
+function parseAtDatetime(at) {
+  const raw = String(at || '').trim();
+  if (!raw) throw new Error('at must be a datetime');
+  const d = new Date(raw);
+  if (Number.isNaN(d.getTime())) throw new Error(`at "${at}" is not a valid datetime`);
+  return d;
+}
+
+// Map the store's def shape onto the flat display shape every schedule reader
+// (channelSetup, renderChannelStatus, TUI pickers) consumes: `.time` renders
+// the cron or the one-shot datetime, `.route` the channel/session target.
+function scheduleToDisplay(s) {
+  return {
+    name: s.name,
+    description: s.description || '',
+    time: s.whenCron || (s.whenAt ? `at ${new Date(s.whenAt).toISOString()}` : ''),
+    whenAt: s.whenAt || undefined,
+    whenCron: s.whenCron || undefined,
+    timezone: s.timezone || undefined,
+    channel: s.channelId || undefined,
+    model: s.model || undefined,
+    enabled: s.enabled !== false,
+    instructions: s.prompt,
+    route: s.target === 'channel' ? `channel:${s.channelId}` : 'session',
+  };
+}
+
+export async function listSchedules() {
+  const rows = await dbListSchedules();
+  return rows.map(scheduleToDisplay);
 }
 
-export function saveSchedule({
+// Register or update a schedule in the PG store. Recurring input maps `time`
+// (+ optional `days`) to a cron; one-shot input maps an `at` datetime; the two
+// are mutually exclusive (also enforced by the store's when_at/when_cron XOR).
+// `channel` selects a channel target (model required); otherwise session.
+export async function saveSchedule({
   name,
   description = '',
   time,
+  at,
   timezone,
   days,
   channel,
@@ -316,78 +378,69 @@ export function saveSchedule({
   overwrite = false,
 } = {}) {
   const id = assertName(name, 'schedule name');
-  const cron = normalizeCron(time);
   const body = String(instructions || '').trim();
   if (!body) throw new Error('schedule instructions are required');
   if (channel && !model) throw new Error('model is required when channel is set');
-  const dir = join(schedulesDir(), id);
-  if (existsSync(dir) && overwrite !== true) throw new Error(`schedule "${id}" already exists`);
-  mkdirSync(dir, { recursive: true });
-  // name (== dir slug) and description lead the frontmatter per the SKILL.md
-  // convention; operational keys follow.
-  const config = { name: id, description: String(description || '').trim(), time: cron };
-  if (timezone) config.timezone = String(timezone).trim();
-  if (days && days !== 'daily') config.days = String(days).trim();
-  if (channel) config.channel = String(channel).trim();
-  if (model) config.model = String(model).trim();
-  if (enabled === false) config.enabled = false;
-  writeTextAtomic(join(dir, 'SCHEDULE.md'), serializeFrontmatterDoc(config, body));
-  return { name: id, ...config, instructions: body };
-}
-
-export function deleteSchedule(name) {
+  const hasTime = time != null && String(time).trim() !== '';
+  const hasAt = at != null && String(at).trim() !== '';
+  if (hasTime && hasAt) throw new Error('provide either `time` (recurring) or `at` (one-shot), not both');
+  if (!hasTime && !hasAt) throw new Error('either `time` (recurring cron) or `at` (one-shot datetime) is required');
+  if (overwrite !== true && (await dbGetSchedule(id))) {
+    throw new Error(`schedule "${id}" already exists`);
+  }
+  const whenCron = hasTime ? foldDaysIntoCron(normalizeCron(time), days) : null;
+  const whenAt = hasAt ? parseAtDatetime(at) : null;
+  const saved = await upsertSchedule({
+    name: id,
+    description: String(description || '').trim(),
+    whenCron,
+    whenAt,
+    timezone: timezone ? String(timezone).trim() : null,
+    target: channel ? 'channel' : 'session',
+    channelId: channel ? String(channel).trim() : null,
+    model: model ? String(model).trim() : null,
+    prompt: body,
+    enabled: enabled !== false,
+  });
+  return scheduleToDisplay(saved);
+}
+
+export async function deleteSchedule(name) {
   const id = assertName(name, 'schedule name');
-  rmSync(join(schedulesDir(), id), { recursive: true, force: true });
+  await dbDeleteSchedule(id);
   return { name: id, deleted: true };
 }
 
-export function setScheduleEnabled(name, enabled) {
+export async function setScheduleEnabled(name, enabled) {
   const id = assertName(name, 'schedule name');
-  const dir = join(schedulesDir(), id);
-  const mdPath = join(dir, 'SCHEDULE.md');
-  if (!existsSync(mdPath)) throw new Error(`schedule "${id}" does not exist`);
-  const { frontmatter, body } = readMarkdownDocument(readText(mdPath, ''));
-  // Re-spread with name/description first so the round-trip keeps SKILL.md
-  // key order; name stays the dir slug regardless of stale frontmatter.
-  const { name: _staleName, description = '', ...rest } = frontmatter;
-  writeTextAtomic(mdPath, serializeFrontmatterDoc(
-    { name: id, description, ...rest, enabled: enabled !== false },
-    body,
-  ));
+  const updated = await dbSetEnabled(id, enabled !== false);
+  if (!updated) throw new Error(`schedule "${id}" does not exist`);
   return { name: id, enabled: enabled !== false };
 }
 
-export function listWebhooks() {
-  return listEntryDirs(webhooksDir()).map((name) => {
-    const dir = join(webhooksDir(), name);
-    const { frontmatter, body } = readMarkdownDocument(readText(join(dir, 'WEBHOOK.md'), ''));
-    const config = { ...frontmatter };
-    if (Object.prototype.hasOwnProperty.call(config, 'enabled')) {
-      config.enabled = config.enabled !== 'false' && config.enabled !== false;
-    }
-    // Dir name is canonical identity/URL routing key; frontmatter `name` is
-    // display-only and must not override the slug. `description` defaults to
-    // '' for old files with no such key (backward compat).
-    const description = String(config.description || '');
-    delete config.name;
-    delete config.description;
-    // Secret lives in a side file (<name>/secret), never in frontmatter, so
-    // an arbitrary user-supplied secret (quotes/colon/newline) round-trips
-    // losslessly and setWebhookEnabled cannot corrupt it.
-    const hasSecret = Boolean(readText(join(dir, 'secret'), '').trim());
-    return {
-      name,
-      description,
-      ...config,
-      secretSet: hasSecret,
-      secret: undefined,
-      instructions: body,
-      route: config.channel ? `channel:${config.channel}` : 'session',
-    };
-  });
+// Webhook endpoints are stored in the PG table `webhooks.endpoints`
+// (webhooks-db.mjs) — the single source of truth. Legacy per-endpoint
+// WEBHOOK.md + secret folders are imported once at boot and deleted by the
+// store's migration hook.
+export async function listWebhooks() {
+  const endpoints = await dbListEndpoints();
+  return endpoints.map((ep) => ({
+    name: ep.name,
+    description: ep.description || '',
+    parser: ep.parser || 'github',
+    ...(ep.channelId ? { channel: ep.channelId } : {}),
+    ...(ep.model ? { model: ep.model } : {}),
+    enabled: ep.enabled,
+    // The store never projects the plaintext secret through list paths; it
+    // exposes a presence flag (secretSet) instead.
+    secretSet: ep.secretSet === true,
+    secret: undefined,
+    instructions: ep.instructions,
+    route: ep.channelId ? `channel:${ep.channelId}` : 'session',
+  }));
 }
 
-export function saveWebhook({
+export async function saveWebhook({
   name,
   description = '',
   parser = 'github',
@@ -406,47 +459,46 @@ export function saveWebhook({
   const body = String(instructions || '').trim();
   if (!body) throw new Error('webhook instructions are required');
   if (channel && !model) throw new Error('model is required when channel is set');
-  const dir = join(webhooksDir(), id);
-  if (existsSync(dir) && overwrite !== true) throw new Error(`webhook "${id}" already exists`);
-  mkdirSync(dir, { recursive: true });
+  if (overwrite !== true && (await dbLoadEndpoint(id))) {
+    throw new Error(`webhook "${id}" already exists`);
+  }
   const secretValue = String(secret || randomBytes(24).toString('hex')).trim();
-  // name (== dir slug) and description lead the frontmatter per the SKILL.md
-  // convention; operational keys (parser/channel/model/enabled) follow.
-  const config = { name: id, description: String(description || '').trim(), parser: nextParser };
-  if (channel) config.channel = String(channel).trim();
-  if (model) config.model = String(model).trim();
-  if (enabled === false) config.enabled = false;
-  // Secret to a side file (plaintext, same exposure level as the former
-  // config.json), kept OUT of the frontmatter to avoid unquote round-trip
-  // corruption. deleteWebhook rmSync's the whole dir, so this is removed too.
-  writeTextAtomic(join(dir, 'secret'), secretValue + '\n');
-  writeTextAtomic(join(dir, 'WEBHOOK.md'), serializeFrontmatterDoc(config, body));
-  return { name: id, ...config, secret: secretValue, instructions: body };
-}
-
-export function deleteWebhook(name) {
+  const saved = await dbUpsertEndpoint({
+    name: id,
+    description: String(description || '').trim(),
+    parser: nextParser,
+    channelId: channel ? String(channel).trim() : null,
+    model: model ? String(model).trim() : null,
+    secret: secretValue,
+    instructions: body,
+    enabled: enabled !== false,
+  });
+  return {
+    name: id,
+    description: saved.description,
+    parser: saved.parser,
+    ...(saved.channelId ? { channel: saved.channelId } : {}),
+    ...(saved.model ? { model: saved.model } : {}),
+    ...(enabled === false ? { enabled: false } : {}),
+    secret: secretValue,
+    instructions: body,
+  };
+}
+
+export async function deleteWebhook(name) {
   const id = assertName(name, 'webhook name');
-  rmSync(join(webhooksDir(), id), { recursive: true, force: true });
+  await dbDeleteEndpoint(id);
   return { name: id, deleted: true };
 }
 
-export function setWebhookEnabled(name, enabled) {
+export async function setWebhookEnabled(name, enabled) {
   const id = assertName(name, 'webhook name');
-  const dir = join(webhooksDir(), id);
-  const mdPath = join(dir, 'WEBHOOK.md');
-  if (!existsSync(mdPath)) throw new Error(`webhook "${id}" does not exist`);
-  const { frontmatter, body } = readMarkdownDocument(readText(mdPath, ''));
-  // Re-spread with name/description first so the round-trip keeps SKILL.md
-  // key order; name stays the dir slug regardless of stale frontmatter.
-  const { name: _staleName, description = '', ...rest } = frontmatter;
-  writeTextAtomic(mdPath, serializeFrontmatterDoc(
-    { name: id, description, ...rest, enabled: enabled !== false },
-    body,
-  ));
+  const updated = await dbSetEndpointEnabled(id, enabled !== false);
+  if (!updated) throw new Error(`webhook "${id}" does not exist`);
   return { name: id, enabled: enabled !== false };
 }
 
-export function channelSetup(config = null) {
+export async function channelSetup(config = null) {
   const cfg = normalizeChannelsConfig(config || readSection('channels'));
   const discordToken = getDiscordToken();
   const discordProblem = diagnoseDiscordTokenValue(discordToken, cfg);
@@ -475,13 +527,13 @@ export function channelSetup(config = null) {
       status: webhookAuth ? 'Set' : 'Off',
     },
     channel: getChannel(cfg),
-    schedules: listSchedules(),
-    webhooks: listWebhooks(),
+    schedules: await listSchedules(),
+    webhooks: await listWebhooks(),
   };
 }
 
-export function renderChannelStatus(config = null) {
-  const setup = channelSetup(config);
+export async function renderChannelStatus(config = null) {
+  const setup = await channelSetup(config);
   const lines = [];
   lines.push(`discord  ${setup.discord.status}${setup.discord.problem ? ` (${setup.discord.problem})` : ''}`);
   lines.push(`webhook  ${setup.webhook.enabled === false ? 'disabled' : 'enabled'} · auth ${setup.webhook.status} · port ${setup.webhook.port || 3333}`);

package/src/standalone/channel-worker.mjs

@@ -4,6 +4,7 @@ import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { startChildGuardian } from '../runtime/shared/child-guardian.mjs';
+import { detachedSpawnOpts } from '../runtime/shared/spawn-flags.mjs';
 import { appendBuffered } from '../runtime/shared/buffered-appender.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
@@ -441,9 +442,8 @@ export function createStandaloneChannelWorker({
           cwd,
           execArgv: ['--require', WORKER_PRELOAD],
           stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
-          detached: true,
           env: daemonEnv(),
-          windowsHide: true,
+          ...detachedSpawnOpts,
         });
       } catch (err) {
         logLine(logPath, `daemon spawn failed: ${err?.message || err}`);

package/src/standalone/memory-runtime-proxy.mjs

@@ -1,10 +1,12 @@
 import { fork } from 'node:child_process';
+import { detachedSpawnOpts } from '../runtime/shared/spawn-flags.mjs';
 import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 import http from 'node:http';
 import { dirname, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { claimSingletonOwner, handoffSingletonOwner, readSingletonOwner, releaseSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
+import { readLiveServiceAdvert } from '../runtime/shared/service-discovery.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
 import { rotateBoundedLog, PLUGIN_LOG_MAX_BYTES, PLUGIN_LOG_KEEP_BYTES } from '../lib/mixdog-debug.cjs';
 
@@ -253,10 +255,14 @@ export function createStandaloneMemoryRuntime({
   }
 
   async function findLivePort({ allowStarting = false } = {}) {
-    const active = readActiveInstance();
-    const port = parsePort(active?.memory_port);
+    // Prefer the single-writer discovery advert (discovery/memory.json); the
+    // legacy active-instance.json memory_port/memory_server_pid fields remain a
+    // cross-version fallback when no discovery advert is present.
+    const advert = readLiveServiceAdvert('memory', { requirePid: false });
+    const active = advert ? null : readActiveInstance();
+    const port = advert ? parsePort(advert.port) : parsePort(active?.memory_port);
     if (!port) return null;
-    const ownerPid = parsePid(active?.memory_server_pid);
+    const ownerPid = advert ? parsePid(advert.pid) : parsePid(active?.memory_server_pid);
     // A dead server pid means the published memory_port is stale — the daemon
     // that owned it is gone. Clearing portCache here (and letting the caller
     // re-claim + respawn) prevents the stale port from wedging recovery.
@@ -384,7 +390,6 @@ export function createStandaloneMemoryRuntime({
         cwd,
         execArgv: [],
         stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
-        detached: true,
         env: {
           ...daemonEnv,
           MIXDOG_DATA_DIR: dataDir,
@@ -407,7 +412,7 @@ export function createStandaloneMemoryRuntime({
           MIXDOG_MEMORY_DAEMON: '1',
           MIXDOG_MEMORY_IDLE_TTL_MS: String(idleTtlMs),
         },
-        windowsHide: true,
+        ...detachedSpawnOpts,
       });
       const childPid = child.pid;
       if (singletonEnabled && childPid) {

package/src/tui/App.jsx

@@ -1338,7 +1338,14 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
         copySelection();
         return;
       }
-      showSelectionCopyHint('select text to copy · Esc interrupts', 'plain');
+      // No app-owned selection. On Windows Terminal the same Ctrl+C is also the
+      // native terminal's copy shortcut for a mouse selection we can't see — so
+      // rendering a hint here fights that copy and flashes a spurious message.
+      // Suppress the hint on win32 (interrupt routing is unchanged: Esc still
+      // interrupts). Other platforms keep the guidance.
+      if (process.platform !== 'win32') {
+        showSelectionCopyHint('select text to copy · Esc interrupts', 'plain');
+      }
       return;
     }
     if (key.ctrl && (input === 'o' || input === 'O')) {
@@ -1855,19 +1862,34 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
         }
         if (channelPrompt.kind === 'schedule-add') {
           const [name, time, instructions, channel, model] = parts;
-          store.saveSchedule({ name, time, instructions, channel, model });
-          setChannelPrompt(null);
-          void openChannelSetupPicker('schedules');
+          // saveSchedule is async (PG-backed). Only close the prompt / open the
+          // list on success; surface a failure notice and keep the prompt open
+          // so the input is not lost and the user can retry.
+          Promise.resolve(store.saveSchedule({ name, time, instructions, channel, model }))
+            .then(() => {
+              setChannelPrompt(null);
+              void openChannelSetupPicker('schedules');
+            })
+            .catch((e) => {
+              store.pushNotice(`schedule save failed: ${e?.message || e}`, 'error');
+            });
           return true;
         }
         if (channelPrompt.kind === 'webhook-add') {
           const [name, instructions, channel, model, parser] = parts;
-          const result = store.saveWebhook({ name, instructions, channel, model, parser });
-          if (result?.secret) {
-            store.pushNotice(`webhook secret for ${result.name}: ${result.secret}`, 'info');
-          }
-          setChannelPrompt(null);
-          void openChannelSetupPicker('webhooks');
+          // saveWebhook is async (PG-backed). Only close the prompt / open the
+          // list on success; surface a failure notice and keep the prompt open.
+          Promise.resolve(store.saveWebhook({ name, instructions, channel, model, parser }))
+            .then((result) => {
+              if (result?.secret) {
+                store.pushNotice(`webhook secret for ${result.name}: ${result.secret}`, 'info');
+              }
+              setChannelPrompt(null);
+              void openChannelSetupPicker('webhooks');
+            })
+            .catch((e) => {
+              store.pushNotice(`webhook save failed: ${e?.message || e}`, 'error');
+            });
           return true;
         }
       } catch (e) {

package/src/tui/app/channel-pickers.mjs

@@ -27,7 +27,7 @@ export function createChannelPickers({
   // a long first-time install finishing later must not hijack whatever
   // screen/picker the user has since navigated to.
   let pickerGen = 0;
-  const openChannelTypeActionsPicker = (backend, options = {}) => {
+  const openChannelTypeActionsPicker = async (backend, options = {}) => {
     pickerGen += 1;
     const parentReturn = typeof options.returnTo === 'function'
       ? options.returnTo
@@ -38,7 +38,7 @@ export function createChannelPickers({
     setContextPanel(null);
     let setup;
     try {
-      setup = store.getChannelSetup();
+      setup = await store.getChannelSetup();
     } catch (e) {
       store.pushNotice(`channels failed: ${e?.message || e}`, 'error');
       return;
@@ -125,7 +125,7 @@ export function createChannelPickers({
     });
   };
 
-  const openChannelSettingTypePicker = (options = {}) => {
+  const openChannelSettingTypePicker = async (options = {}) => {
     pickerGen += 1;
     const returnTo = typeof options.returnTo === 'function' ? options.returnTo : () => {};
     setProviderPrompt(null);
@@ -135,7 +135,7 @@ export function createChannelPickers({
     setContextPanel(null);
     let setup;
     try {
-      setup = store.getChannelSetup();
+      setup = await store.getChannelSetup();
     } catch (e) {
       store.pushNotice(`channels failed: ${e?.message || e}`, 'error');
       return;
@@ -203,7 +203,7 @@ export function createChannelPickers({
     setContextPanel(null);
     let setup;
     try {
-      setup = store.getChannelSetup();
+      setup = await store.getChannelSetup();
     } catch (e) {
       store.pushNotice(`channels failed: ${e?.message || e}`, 'error');
       return;
@@ -239,14 +239,14 @@ export function createChannelPickers({
           _action: 'noop',
         }]),
       ];
-      const toggleSchedule = (item) => {
+      const toggleSchedule = async (item) => {
         if (item._action !== 'schedule-toggle') return;
         if (!channelRemoteEnabled) {
           store.pushNotice('enable channel first', 'warn');
           return;
         }
         try {
-          store.setScheduleEnabled?.(item._name, !item._enabled);
+          await store.setScheduleEnabled?.(item._name, !item._enabled);
           void openChannelSetupPicker('schedules', { highlightValue: `schedule:${item._name}` });
         } catch (e) {
           store.pushNotice(`schedule toggle failed: ${e?.message || e}`, 'error');
@@ -346,14 +346,14 @@ export function createChannelPickers({
           _action: 'noop',
         }]),
       ];
-      const toggleWebhook = (item) => {
+      const toggleWebhook = async (item) => {
         if (item._action !== 'webhook-toggle') return;
         if (!channelRemoteEnabled) {
           store.pushNotice('enable channel first', 'warn');
           return;
         }
         try {
-          store.setWebhookEnabled?.(item._name, !item._enabled);
+          await store.setWebhookEnabled?.(item._name, !item._enabled);
           void openChannelSetupPicker('webhooks', { highlightValue: `webhook:${item._name}` });
         } catch (e) {
           store.pushNotice(`webhook toggle failed: ${e?.message || e}`, 'error');

package/src/tui/app/clipboard.mjs

@@ -18,8 +18,22 @@ export function osc52ClipboardSequence(text) {
 // helper. ~256KB of clipboard text → ~350KB of base64.
 const OSC52_MAX_BYTES = 256 * 1024;
 
+// On native Windows (ConPTY) a large OSC 52 base64 payload written synchronously
+// to stdout can stall for multiple seconds under terminal backpressure while a
+// mouse selection is active — a debugger-confirmed Ctrl+C copy freeze. clip.exe
+// alone is the reliable local clipboard writer, so skip OSC 52 entirely on
+// win32 UNLESS we're in a remote/multiplexed session (SSH or tmux) where OSC 52
+// is the only way to reach the user's real terminal.
+function shouldSkipOsc52() {
+  if (process.platform !== 'win32') return false;
+  if (process.env.TMUX) return false;
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) return false;
+  return true;
+}
+
 export function writeOsc52Clipboard(text) {
   const value = String(text ?? '');
+  if (shouldSkipOsc52()) return false;
   if (Buffer.byteLength(value, 'utf8') > OSC52_MAX_BYTES) return false;
   try {
     process.stdout.write(osc52ClipboardSequence(value));

package/src/tui/app/doctor.mjs

@@ -161,7 +161,7 @@ export async function buildDoctorReport(runtime = {}, getState = () => ({})) {
       return;
     }
     const worker = settings.status || runtime.getChannelWorkerStatus?.() || {};
-    const setup = runtime.getChannelSetup?.() || {};
+    const setup = (await runtime.getChannelSetup?.()) || {};
     const tokens = [];
     if (setup.discord?.authenticated) tokens.push('discord');
     if (setup.telegram?.authenticated) tokens.push('telegram');