mixdog 0.9.25 → 0.9.26

package/src/session-runtime/runtime-core.mjs

@@ -15,7 +15,7 @@ import { writeLastSessionCwd } from '../runtime/shared/user-cwd.mjs';
 import { cancelBackgroundTasks } from '../runtime/shared/background-tasks.mjs';
 import { createTranscriptWriter } from '../runtime/shared/transcript-writer.mjs';
 import { mixdogHome } from '../runtime/shared/plugin-paths.mjs';
-import { checkLatestVersion, runGlobalUpdate, localPackageVersion } from '../runtime/shared/update-checker.mjs';
+import { checkLatestVersion, runGlobalUpdate, localPackageVersion, isDevInstall } from '../runtime/shared/update-checker.mjs';
 import {
   modelVisibleToolCompletionMessage,
   shouldPersistModelVisibleToolCompletion,
@@ -634,6 +634,12 @@ export async function createMixdogSessionRuntime({
   };
   // phase: 'idle' | 'checking' | 'installing' | 'installed' | 'failed'
   let updateProcessState = { phase: 'idle', version: null, error: null };
+  // Boot detects an available update but DEFERS the actual npm install to the
+  // graceful shutdown path (flushPendingUpdate, invoked from close()). Running
+  // `npm install -g` while the process is live overwrites the very .mjs files
+  // node has loaded → Windows TAR_ENTRY_ERROR file-locks. Installing on quit
+  // lets the parent release those handles first.
+  let pendingUpdateInstall = false;
 
   function autoUpdateEnabled() {
     return config?.update?.auto !== false;
@@ -662,6 +668,9 @@ export async function createMixdogSessionRuntime({
     if (updateProcessState.phase === 'installing') {
       return { ...updateProcessState, alreadyInstalling: true, error: 'update already in progress' };
     }
+    // A manual install consumes the boot-armed deferred install so quitting
+    // afterwards can't spawn a second redundant `npm install -g`.
+    pendingUpdateInstall = false;
     updateProcessState = { phase: 'installing', version: null, error: null };
     try {
       const result = await runGlobalUpdate();
@@ -678,36 +687,45 @@ export async function createMixdogSessionRuntime({
 
   // Non-blocking boot hook: fires after the runtime object below is fully
   // constructed (setTimeout(0) defers past the synchronous return), so a
-  // slow/hanging registry request or npm install can never delay session
-  // boot. Auto-update defaults to ON unless config.update.auto is explicitly
-  // false; a failed check or install is
-  // swallowed — getUpdateStatus()/getUpdateSettings() are the only surfaces,
-  // there is no push notice channel from runtime -> TUI today.
+  // slow/hanging registry request can never delay session boot. The check
+  // ALWAYS runs (populates updateCheckState for the maintenance picker), but
+  // the boot hook only DETECTS + arms a deferred install — the actual
+  // runGlobalUpdate now happens on graceful shutdown (flushPendingUpdate via
+  // close()) so npm never overwrites files the live process holds.
   // force:true — always hit the registry at boot (the 24h disk cache went
   // stale-visible: it kept reporting an older "latest" than the installed
   // version). checkLatestVersion() still falls back to the cache offline.
+  // isDevInstall() gate: a git checkout / clone (or non-node_modules install)
+  // must never self-update — `npm install -g` would fight the working tree.
   const updateBootTimer = setTimeout(() => {
     void (async () => {
       await checkForUpdateInternal({ force: true });
-      if (autoUpdateEnabled() && updateCheckState.updateAvailable) {
-        const result = await runUpdateNowInternal();
-        // Surface the boot auto-update outcome as a UI-only notice (TUI maps
-        // meta.kind 'update-notice' to a transcript notice, never a
-        // model-visible message). Silent before: installed-but-needs-restart
-        // and failed installs were invisible unless the user opened the
-        // maintenance picker.
-        if (result?.phase === 'installed') {
-          const v = result.version && result.version !== 'unknown'
-            ? `v${result.version}` : (updateCheckState.latestVersion ? `v${updateCheckState.latestVersion}` : 'latest');
-          emitRuntimeNotification(`mixdog ${v} installed — restart to apply.`, { kind: 'update-notice', tone: 'info' });
-        } else if (result?.phase === 'failed') {
-          emitRuntimeNotification(`mixdog auto-update failed: ${result.error || 'unknown error'}`, { kind: 'update-notice', tone: 'warn' });
-        }
+      if (autoUpdateEnabled() && !isDevInstall() && updateCheckState.updateAvailable) {
+        pendingUpdateInstall = true;
+        const v = updateCheckState.latestVersion ? `v${updateCheckState.latestVersion}` : 'latest';
+        // UI-only notice (TUI maps meta.kind 'update-notice' to a transcript
+        // notice, never a model-visible message). tone 'info': non-urgent,
+        // the install fires quietly on quit.
+        emitRuntimeNotification(`mixdog ${v} available — installs when you quit.`, { kind: 'update-notice', tone: 'info' });
       }
     })().catch(() => {});
   }, 0);
   updateBootTimer.unref?.();
 
+  // Invoked from the graceful shutdown path (lifecycle close() on exit/quit).
+  // Spawns the deferred npm install fire-and-forget: runGlobalUpdate() detaches
+  // (POSIX) / unrefs its child, so we neither await it nor block teardown —
+  // the parent exits, releasing file handles, while npm installs in the hidden
+  // background child. No-op unless an update was armed at boot.
+  function flushPendingUpdate() {
+    if (!pendingUpdateInstall) return;
+    pendingUpdateInstall = false;
+    // Re-check at flush time: the user may have turned update.auto off after
+    // the boot notice armed the install — respect the current setting.
+    if (!autoUpdateEnabled()) return;
+    try { void runGlobalUpdate(); } catch { /* best-effort: exit must not wedge */ }
+  }
+
   function emitRuntimeNotification(content, meta = {}) {
     const text = String(content || '').trim();
     if (!text) return false;
@@ -1985,6 +2003,7 @@ export async function createMixdogSessionRuntime({
     resolveRoute,
     applyDeferredToolSurface,
     standaloneTools,
+    flushPendingUpdate,
   });
   const resourceApi = createResourceApi({
     getConfig: () => config,

package/src/standalone/agent-tool.mjs

@@ -1587,17 +1587,48 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           if (!fallbackTag || fallbackTag.startsWith('sess_') || !isDeadTarget) throw err;
           const prompt = clean(args.message || args.prompt);
           if (!prompt) throw err;
-          // Inherit the dead session's agent/cwd from the tag registry so the
-          // auto-respawn doesn't die on "agent spawn: agent is required" when
-          // Lead's send (correctly) omitted them. Read BEFORE forgetTag wipes
-          // the registry entries.
-          const inheritedAgent = clean(args.agent) || clean(tagAgents.get(fallbackTag));
-          const inheritedCwd = clean(args.cwd) || clean(tagCwds.get(fallbackTag));
-          if (!inheritedAgent) throw err;
-          // Clear the terminal trace so the fresh spawn isn't rejected by
-          // the lingering-trace guard, then run the normal deferred spawn.
-          try { forgetTag(fallbackTag); } catch {}
-          try { removeWorkerRow({ tag: fallbackTag }); } catch {}
+          // Inherit the dead session's agent/cwd so the auto-respawn doesn't
+          // die on "agent spawn: agent is required" when Lead's send (correctly)
+          // omitted them. Read BEFORE forgetTag wipes the registry entries.
+          //
+          // Root cause of the surfaced "target not found" errors: when a tag is
+          // FULLY reaped (session gone past the 5m grace window), the in-memory
+          // tagAgents/tagCwds maps are cleared, so inheritedAgent came back empty
+          // and this path re-threw instead of respawning. Recover the agent/cwd
+          // from the persisted worker row, then fall back to the default `worker`
+          // agent so an unknown-but-plausible tag still cold-respawns. The guards
+          // above (empty tag / raw sess_ id / non-dead error) keep plainly invalid
+          // targets erroring.
+          // readWorkerRows is already scoped to THIS terminal (clientHostPid,
+          // via rowMatchesContext), so inheritedRow — and every mutation below
+          // keyed on its sessionId — never touches another terminal's same-tag
+          // worker row.
+          let inheritedRow = null;
+          try {
+            inheritedRow = readWorkerRows(scopedContext).find((row) => clean(row.tag) === fallbackTag) || null;
+          } catch { inheritedRow = null; }
+          // Gate the respawn on evidence the tag previously existed IN THIS
+          // terminal: a persisted, clientHostPid-scoped worker row. The
+          // in-memory tags/tagAgents/tagCwds maps are NOT reliable evidence —
+          // closeAll() calls refreshTagsFromSessions() with NO context
+          // (see ~L1501), which populates them from EVERY terminal's rows
+          // (readWorkerRows({}) — rowMatchesContext returns true with no pid),
+          // so they can hold a peer terminal's tag. A typo'd / never-existed
+          // tag has no scoped row and must keep the original "not found" error.
+          if (!inheritedRow) throw err;
+          const inheritedSessionId = clean(inheritedRow.sessionId);
+          const inheritedAgent = clean(args.agent) || clean(inheritedRow.agent) || 'worker';
+          const inheritedCwd = clean(args.cwd) || clean(inheritedRow.cwd) || clean(callerCwd);
+          // Drop this terminal's in-memory trace and remove ONLY the persisted
+          // row matching inheritedRow.sessionId. Do NOT call forgetTag here: it
+          // does a tag-wide removeWorkerRow({tag,sessionId}) (L556) whose OR
+          // match (L395) would delete peer terminals' same-tag rows. The map
+          // deletes are guarded on the tag pointing at OUR sessionId so a peer
+          // cache entry (see above) is left intact (it rebuilds from rows).
+          if (tags.get(fallbackTag) === inheritedSessionId) {
+            try { tags.delete(fallbackTag); tagAgents.delete(fallbackTag); tagCwds.delete(fallbackTag); } catch {}
+          }
+          if (inheritedSessionId) { try { removeWorkerRow({ sessionId: inheritedSessionId }); } catch {} }
           const spawnArgs = {
             ...args,
             type: 'spawn',

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) {