mixdog 0.9.174 → 1.0.0

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

@@ -1,5 +1,4 @@
-import { readFileSync, writeFileSync, appendFileSync, unlinkSync } from 'node:fs';
-import { appendFile as _appendFile } from 'node:fs';
+import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { join, isAbsolute } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { DATA_DIR } from './config.mjs';
@@ -17,42 +16,21 @@ import {
   setDeferred,
   setNextFire,
   setSkippedUntil,
-} from '../../shared/schedules-db.mjs';
-import { runScheduleSession } from '../../shared/schedule-session-run.mjs';
+} from './schedules-db.mjs';
+import { appendBuffered } from '../../shared/buffered-appender.mjs';
+import { tryRead } from './settings.mjs';
 
 const SCHEDULE_LOG = join(DATA_DIR, 'schedule.log');
-// Buffered async logger — coalesces per-line appends into batched writes.
-let _schedLogBuf = [];
-let _schedLogTimer = null;
-function _flushScheduleLog() {
-  _schedLogTimer = null;
-  if (_schedLogBuf.length === 0) return;
-  const lines = _schedLogBuf.join('');
-  _schedLogBuf = [];
-  _appendFile(SCHEDULE_LOG, lines, () => {});
-}
-function _flushSchedLogSync() {
-  if (_schedLogBuf.length === 0) return;
-  const lines = _schedLogBuf.join('');
-  _schedLogBuf = [];
-  try {
-    appendFileSync(SCHEDULE_LOG, lines);
-  } catch {}
-}
-process.on('exit', _flushSchedLogSync);
-// Note: do not install a module-level SIGTERM handler that calls
-// process.exit() here. The channels worker owns shutdown sequencing
-// (drain queues, persist baselines, release the scheduler lock, etc.)
-// and a library-level exit(0) preempts that drain. The `exit` listener
-// above still flushes pending log lines synchronously when the worker
-// finishes its own shutdown.
+// Do not install a module-level SIGTERM handler that calls process.exit()
+// here. The channels worker owns shutdown sequencing (drain queues, persist
+// baselines, release the scheduler lock, etc.) and a library-level exit(0)
+// preempts that drain. The buffered appender drains pending log lines on exit.
 function logSchedule(msg) {
+  msg = msg.replace(/\n$/, '');
   process.stderr.write(`mixdog scheduler: ${msg}\n`);
-  _schedLogBuf.push(`[${new Date().toISOString()}] ${msg}\n`);
-  if (!_schedLogTimer) _schedLogTimer = setTimeout(_flushScheduleLog, 2000);
+  appendBuffered(SCHEDULE_LOG, `[${new Date().toISOString()}] ${msg}\n`);
 }
 
-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
 // bump), cron expressions are disabled (cron stays null below) instead
@@ -67,6 +45,8 @@ try {
   );
 }
 const TICK_INTERVAL = 6e4;
+// setTimeout's delay ceiling (~24.8 days); longer waits re-arm instead of firing early.
+const MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
 // All schedule `time` values must be valid 5- or 6-field cron expressions
 // (node-cron format). Legacy formats (HH:MM, everyNm, hourly, daily) are
 // no longer accepted — migrate to cron: "MM HH * * *", "*/N * * * *", etc.
@@ -127,6 +107,8 @@ class Scheduler {
   sendFn = null;
   injectReadyFn = null;
   pendingCheck = null;
+  // Injected by the host: (schedule, { prompt }) => Promise<{ result }>.
+  scheduleRunner = null;
   // Activity tracking
   lastActivity = 0;
   // timestamp of last inbound message
@@ -172,6 +154,9 @@ class Scheduler {
   setPendingCheck(fn) {
     this.pendingCheck = typeof fn === 'function' ? fn : null;
   }
+  setScheduleRunner(fn) {
+    this.scheduleRunner = typeof fn === 'function' ? fn : null;
+  }
   noteActivity() {
     this.lastActivity = Date.now();
   }
@@ -268,6 +253,7 @@ class Scheduler {
     const dow = now.getDay();
     return {
       hour: now.getHours(),
+      minute: now.getMinutes(),
       dayOfWeek: days[dow],
       isWeekend: dow === 0 || dow === 6,
     };
@@ -281,7 +267,7 @@ class Scheduler {
     const time = this.getTimeContext();
     const header = [
       `[schedule: ${name} | type: ${type} | session: ${state}]`,
-      `[time: ${time.dayOfWeek} ${String(time.hour).padStart(2, '0')}:${String(/* @__PURE__ */ new Date().getMinutes()).padStart(2, '0')} | weekend: ${time.isWeekend}]`,
+      `[time: ${time.dayOfWeek} ${String(time.hour).padStart(2, '0')}:${String(time.minute).padStart(2, '0')} | weekend: ${time.isWeekend}]`,
       `Before starting any work, briefly tell the user what you're about to do in one short sentence.`,
     ].join('\n');
     return `${header}
@@ -475,9 +461,8 @@ ${prompt}`;
       return;
     }
     const delay = fireAt - Date.now();
-    const MAX = 2 ** 31 - 1;
-    if (delay > MAX) {
-      const timer = setTimeout(() => this.armOneShot(schedule, type), MAX);
+    if (delay > MAX_TIMER_DELAY_MS) {
+      const timer = setTimeout(() => this.armOneShot(schedule, type), MAX_TIMER_DELAY_MS);
       this.oneShotTimers.set(schedule.name, timer);
       return;
     }
@@ -552,9 +537,7 @@ ${prompt}`;
     const until = this.skipUntil(schedule.name);
     const fireAt = new Date(schedule.whenAt).getTime();
     const target = Math.max(Number.isFinite(fireAt) ? fireAt : 0, until);
-    const MAX = 2 ** 31 - 1;
-    let delay = target - Date.now();
-    delay = delay > MAX ? MAX : Math.max(delay, 1);
+    const delay = Math.min(Math.max(target - Date.now(), 1), MAX_TIMER_DELAY_MS);
     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);
@@ -703,7 +686,10 @@ ${prompt}`;
    *  success; a failure rejects for awaitDispatch callers and resolves false
    *  (after a channel notice) for fire-and-forget cron fires. */
   dispatchScheduleRun(schedule, prompt, channelId, awaitDispatch) {
-    return runScheduleSession(schedule, { prompt })
+    const run = this.scheduleRunner
+      ? this.scheduleRunner(schedule, { prompt })
+      : Promise.reject(new Error('schedule runner not configured'));
+    return run
       .then(({ result }) => {
         this.running.delete(schedule.name);
         if (result && channelId && this.sendFn) {
@@ -720,8 +706,8 @@ ${prompt}`;
         // The cron fire-and-forget contract swallowed failures entirely;
         // surface them on the channel so a failed scheduled run is never
         // silent (one-shots propagate via the awaitDispatch throw instead).
-        if (!awaitDispatch) this.notifyFailure(schedule, `run failed: ${err.message}`);
         if (awaitDispatch) throw err;
+        this.notifyFailure(schedule, `run failed: ${err.message}`);
         return false;
       });
   }
@@ -744,9 +730,7 @@ ${prompt}`;
   resolvePrompt(schedule) {
     const ref = schedule.prompt ?? `${schedule.name}.md`;
     const fromFile = this.loadPrompt(ref);
-    if (fromFile) return fromFile;
-    if (schedule.prompt) return schedule.prompt;
-    return null;
+    return fromFile || schedule.prompt || null;
   }
   loadPrompt(nameOrPath) {
     const full = isAbsolute(nameOrPath) ? nameOrPath : join(this.promptsDir, nameOrPath);

package/src/runtime/{shared → channels/lib}/schedules-db.mjs

@@ -11,9 +11,9 @@
  * connection search_path.
  */
 
-import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
-import { createPgSchemaDb } from './pg-schema-db.mjs';
-import { resolvePluginData } from './plugin-paths.mjs';
+import { ensurePgInstance, withSchemaBootstrapLock } from '../../memory/lib/pg/adapter.mjs';
+import { createPgSchemaDb } from '../../shared/pg-schema-db.mjs';
+import { resolvePluginData } from '../../shared/plugin-paths.mjs';
 
 const SCHEMA = 'scheduler';
 

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

@@ -10,7 +10,6 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
     setChannelBridgeActive,
     writeBridgeState,
     notifyRemoteAcquired,
-    refreshBridgeOwnership,
     startChannelBridge,
     stopOwnedRuntime,
     reloadRuntimeConfig,
@@ -36,15 +35,11 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
             // (getOwned() is always true), so activate never needs to claim a
             // seat or pre-notify — the not-connected -> connected transition
             // inside startOwnedRuntime fires notifyRemoteAcquired exactly once.
-            if (getOwned?.() !== true) {
-              notifyRemoteAcquired?.();
+            if (getOwned() !== true) {
+              notifyRemoteAcquired();
             }
             try {
-              if (typeof startChannelBridge === 'function') {
-                await startChannelBridge();
-              } else {
-                await refreshBridgeOwnership({ restoreBinding: true });
-              }
+              await startChannelBridge();
             } catch (e) {
               process.stderr.write(`mixdog: bridge activate refresh failed (non-fatal): ${e?.message || e}\n`);
             }

package/src/runtime/channels/lib/voice-runtime-fetcher.mjs

@@ -141,6 +141,13 @@ async function _withInstallLock(rootDir, lockName, fn, { pollMs = 250 } = {}) {
   // "alive" indefinitely without ever releasing this lockfile.
   let foreignWaitSince = 0;
   let samePidWaitSince = 0;
+  const reclaim = () => {
+    try {
+      rmSync(lockPath, { force: true });
+    } catch {}
+    foreignWaitSince = 0;
+    samePidWaitSince = 0;
+  };
   while (true) {
     try {
       fd = openSync(lockPath, 'wx');
@@ -159,11 +166,7 @@ async function _withInstallLock(rootDir, lockName, fn, { pollMs = 250 } = {}) {
         const holder = _readInstallLockToken(lockPath);
         if (!holder) {
           // empty or invalid PID — orphan lockfile, reclaim
-          try {
-            rmSync(lockPath, { force: true });
-          } catch {}
-          foreignWaitSince = 0;
-          samePidWaitSince = 0;
+          reclaim();
           continue;
         }
         const { pid: holderPid, ts: holderTs, token: holderToken } = holder;
@@ -181,11 +184,7 @@ async function _withInstallLock(rootDir, lockName, fn, { pollMs = 250 } = {}) {
           }
           if (ageMs > LOCK_MAX_AGE_MS) {
             if (_installLockTokenMatches(lockPath, holderPid, holderTs, holderToken)) {
-              try {
-                rmSync(lockPath, { force: true });
-              } catch {}
-              foreignWaitSince = 0;
-              samePidWaitSince = 0;
+              reclaim();
               continue;
             }
           }
@@ -196,11 +195,7 @@ async function _withInstallLock(rootDir, lockName, fn, { pollMs = 250 } = {}) {
         try {
           process.kill(holderPid, 0);
         } catch {
-          try {
-            rmSync(lockPath, { force: true });
-          } catch {}
-          foreignWaitSince = 0;
-          samePidWaitSince = 0;
+          reclaim();
           continue;
         }
         // Live foreign pid. Apply age ceiling so a recycled/unrelated
@@ -213,11 +208,7 @@ async function _withInstallLock(rootDir, lockName, fn, { pollMs = 250 } = {}) {
         if (!foreignWaitSince) foreignWaitSince = Date.now();
         if (ageMs > LOCK_MAX_AGE_MS) {
           if (_installLockTokenMatches(lockPath, holderPid, holderTs, holderToken)) {
-            try {
-              rmSync(lockPath, { force: true });
-            } catch {}
-            foreignWaitSince = 0;
-            samePidWaitSince = 0;
+            reclaim();
             continue;
           }
         }
@@ -491,13 +482,18 @@ async function downloadFile(url, destPath, { onProgress = null, timeoutMs = 180_
 // the unzip command (preinstalled on every distro we support, apt-get on
 // Ubuntu / dnf on Fedora). Platform decision is a single switch — no fallback
 // chain, no probing.
-function extractZip(zipPath, destDir) {
+export function extractZip(zipPath, destDir) {
   // Windows: bundled tar.exe (libarchive) misreads `C:` drive letter as
   // host:path and tries DNS resolution. Use PowerShell Expand-Archive,
   // which is Windows-native and path-safe.
   if (process.platform === 'win32') {
-    const ps = `Expand-Archive -LiteralPath ${JSON.stringify(zipPath)} -DestinationPath ${JSON.stringify(destDir)} -Force`;
-    const r = spawnSync('powershell', ['-NoProfile', '-Command', ps], { stdio: 'pipe', windowsHide: true });
+    // Paths travel via env vars so `$` / backticks in them are never expanded.
+    const ps = 'Expand-Archive -LiteralPath $env:MIXDOG_ZIP_PATH -DestinationPath $env:MIXDOG_ZIP_DEST -Force';
+    const r = spawnSync('powershell', ['-NoProfile', '-Command', ps], {
+      stdio: 'pipe',
+      windowsHide: true,
+      env: { ...process.env, MIXDOG_ZIP_PATH: zipPath, MIXDOG_ZIP_DEST: destDir },
+    });
     if (r.status !== 0) {
       throw new Error(
         `[voice-runtime] zip extract failed via Expand-Archive: ${r.stderr?.toString() || r.stdout?.toString() || 'unknown'}`

package/src/runtime/channels/lib/voice-transcription.mjs

@@ -152,6 +152,17 @@ function createVoiceWavCache() {
   };
 }
 
+// Configured whisper thread count, else a quarter of the cores (at least one).
+function whisperThreadCount(config) {
+  let cpuCount;
+  try {
+    cpuCount = os.cpus().length;
+  } catch {
+    cpuCount = 2;
+  }
+  return config.voice?.transcription?.threadCount ?? Math.max(1, Math.ceil(cpuCount / 4));
+}
+
 // The one resolution of the managed runtime and the exact whisper-server
 // contract, shared by transcription and warm-up. Returns { error } (a
 // user-actionable message) when the runtime is not installed.
@@ -169,14 +180,7 @@ function resolveVoiceTranscriptionRuntime(config, dataDir) {
       error: `voice runtime not installed (missing: ${missing}) — open the setup wizard and click "Install voice"`,
     };
   }
-  const cpuCount = (() => {
-    try {
-      return os.cpus().length;
-    } catch {
-      return 2;
-    }
-  })();
-  const threadCount = config.voice?.transcription?.threadCount ?? Math.max(1, Math.ceil(cpuCount / 4));
+  const threadCount = whisperThreadCount(config);
   return {
     runtime,
     threadCount,
@@ -289,4 +293,4 @@ function createVoiceTranscription({ getConfig, dataDir }) {
   return { isVoiceAttachment, transcribeVoice, prepareTranscription };
 }
 
-export { createVoiceTranscription };
+export { createVoiceTranscription, whisperThreadCount };

package/src/runtime/channels/lib/webhook/log.mjs

@@ -1,31 +1,8 @@
 import { join } from 'node:path';
-import { appendFileSync } from 'node:fs';
-import { appendFile } from 'node:fs/promises';
 import { DATA_DIR } from '../config.mjs';
+import { appendBuffered } from '../../../shared/buffered-appender.mjs';
 
 const WEBHOOK_LOG = join(DATA_DIR, 'webhook.log');
-let webhookLogBuffer = [];
-let webhookLogTimer = null;
-function flushWebhookLog() {
-  if (webhookLogTimer) {
-    clearTimeout(webhookLogTimer);
-    webhookLogTimer = null;
-  }
-  if (!webhookLogBuffer.length) return;
-  const lines = webhookLogBuffer.join('');
-  webhookLogBuffer = [];
-  void appendFile(WEBHOOK_LOG, lines).catch(() => {});
-}
-try {
-  process.on('beforeExit', flushWebhookLog);
-  process.on('exit', () => {
-    if (!webhookLogBuffer.length) return;
-    try {
-      appendFileSync(WEBHOOK_LOG, webhookLogBuffer.join(''));
-    } catch {}
-    webhookLogBuffer = [];
-  });
-} catch {}
 function logWebhook(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
 `;
@@ -33,11 +10,7 @@ function logWebhook(msg) {
     process.stderr.write(`mixdog webhook: ${msg}
 `);
   } catch {}
-  webhookLogBuffer.push(line);
-  if (!webhookLogTimer) {
-    webhookLogTimer = setTimeout(flushWebhookLog, 1000);
-    webhookLogTimer.unref?.();
-  }
+  appendBuffered(WEBHOOK_LOG, line);
 }
 
 export { logWebhook };

package/src/runtime/channels/lib/webhook/request-handler.mjs

@@ -4,7 +4,7 @@ import {
   readEndpointSecret,
   claimDelivery,
   updateDeliveryStatus,
-} from '../../../shared/webhooks-db.mjs';
+} from '../webhooks-db.mjs';
 import { contentDeliveryId, extractDeliveryId, buildHeadersSummary } from './deliveries.mjs';
 
 const MAX_BODY_BYTES = 5 * 1024 * 1024;
@@ -202,15 +202,14 @@ async function processWebhookBody(req, res, name, rawBody, { getConfig, verifyRe
     logWebhook(invalidJson ? `JSON parse error for ${name}: ${err}` : `${name}: request failed: ${err}`);
     // Terminal failed row: an error return must close out the `received` claim
     // so retries don't loop on dedup.
-    const _id = typeof deliveryId === 'string' && deliveryId ? deliveryId : null;
-    if (_id) {
+    if (typeof deliveryId === 'string' && deliveryId) {
       try {
-        await updateDeliveryStatus(name, _id, 'failed', {
+        await updateDeliveryStatus(name, deliveryId, 'failed', {
           error: invalidJson ? `invalid JSON: ${err?.message || err}` : String(err?.message || err),
         });
       } catch (e2) {
         process.stderr.write(
-          `mixdog webhook: failed to mark delivery ${name}/${_id} failed \u2014 ${e2?.message || e2}\n`
+          `mixdog webhook: failed to mark delivery ${name}/${deliveryId} failed \u2014 ${e2?.message || e2}\n`
         );
       }
     }

package/src/runtime/channels/lib/webhook/session-dispatch.mjs

@@ -1,20 +1,16 @@
 import { logWebhook } from './log.mjs';
-import { updateDeliveryStatus } from '../../../shared/webhooks-db.mjs';
+import { updateDeliveryStatus } from '../webhooks-db.mjs';
+import { UNTRUSTED_MARKER, scrubFenceMarker } from './untrusted-fence.mjs';
 
 const DISPATCH_TIMEOUT_MS = 10 * 60 * 1000;
 
 function buildFencedPayload(body, headers) {
-  // Trust boundary: webhook body + headers are external, attacker-
-  // controllable input and must be treated as DATA, never instructions.
-  // Fence them with a guarded marker and scrub that marker token from the
-  // content so a payload field cannot close the fence early and smuggle
-  // instructions into the delegate/agent prompt (indirect prompt
-  // injection). The directive line gives the downstream prompt a trust
-  // boundary it can rely on.
-  const _UNTRUSTED = 'WEBHOOK_UNTRUSTED_DATA';
-  const _scrubFence = (s) => String(s).split(_UNTRUSTED).join('WEBHOOK_DATA');
-  const payload = _scrubFence(JSON.stringify(body, null, 2));
-  const headersSummary = _scrubFence(
+  // Trust boundary: webhook body + headers are external input and must be
+  // treated as DATA, never instructions. The directive line gives the
+  // downstream prompt a trust boundary it can rely on.
+  const _UNTRUSTED = UNTRUSTED_MARKER;
+  const payload = scrubFenceMarker(JSON.stringify(body, null, 2));
+  const headersSummary = scrubFenceMarker(
     Object.entries(headers)
       .filter(([k]) => k.startsWith('x-') || k === 'content-type')
       .map(([k, v]) => `${k}: ${v}`)

package/src/runtime/channels/lib/webhook/signature.mjs

@@ -23,6 +23,18 @@ function extractSignature(headers, parser) {
 // Stripe's documented replay tolerance. A captured signature older (or more
 // than this skew newer) than the window is rejected even if the HMAC matches.
 const STRIPE_TOLERANCE_MS = 5 * 60 * 1000;
+// timingSafeEqual throws on length mismatch / malformed hex; wrap so a crafted
+// signature header can't crash the request handler.
+function hexDigestsEqual(providedHex, expectedHex) {
+  try {
+    const a = Buffer.from(providedHex, 'hex');
+    const b = Buffer.from(expectedHex, 'hex');
+    if (a.length !== b.length) return false;
+    return crypto.timingSafeEqual(a, b);
+  } catch {
+    return false;
+  }
+}
 function verifySignature(secret, rawBody, signatureValue, parser) {
   if (parser === 'stripe') {
     // Stripe signs `${t}.${payload}`, not the body alone, and the t= field
@@ -34,27 +46,11 @@ function verifySignature(secret, rawBody, signatureValue, parser) {
     if (!vMatch || !tMatch) return false;
     const ts = Number(tMatch[1]);
     if (!Number.isFinite(ts) || Math.abs(Date.now() - ts * 1000) > STRIPE_TOLERANCE_MS) return false;
-    const expected = crypto.createHmac('sha256', secret).update(`${tMatch[1]}.${rawBody}`).digest('hex');
-    // timingSafeEqual throws on length mismatch / malformed hex; wrap so a
-    // crafted signature header can't crash the request handler.
-    try {
-      const a = Buffer.from(vMatch[1], 'hex');
-      const b = Buffer.from(expected, 'hex');
-      if (a.length !== b.length) return false;
-      return crypto.timingSafeEqual(a, b);
-    } catch {
-      return false;
-    }
+    const expected = crypto.createHmac('sha256', secret).update(Buffer.concat([Buffer.from(`${tMatch[1]}.`), Buffer.from(rawBody)])).digest('hex');
+    return hexDigestsEqual(vMatch[1], expected);
   }
   const expected = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
-  try {
-    const a = Buffer.from(signatureValue, 'hex');
-    const b = Buffer.from(expected, 'hex');
-    if (a.length !== b.length) return false;
-    return crypto.timingSafeEqual(a, b);
-  } catch {
-    return false;
-  }
+  return hexDigestsEqual(signatureValue, expected);
 }
 
 export { extractSignature, verifySignature };

package/src/runtime/channels/lib/webhook/untrusted-fence.mjs

@@ -0,0 +1,9 @@
+// Webhook fields are external, attacker-controllable input. Prompts fence them
+// with this marker token and scrub the token from the content, so a field
+// cannot close its own fence early and smuggle instructions into the agent
+// prompt (indirect prompt injection).
+export const UNTRUSTED_MARKER = 'WEBHOOK_UNTRUSTED_DATA';
+
+export function scrubFenceMarker(value) {
+  return String(value).split(UNTRUSTED_MARKER).join('WEBHOOK_DATA');
+}

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

@@ -1,5 +1,5 @@
 import { logWebhook } from './webhook/log.mjs';
-import { updateDeliveryStatus } from '../../shared/webhooks-db.mjs';
+import { updateDeliveryStatus } from './webhooks-db.mjs';
 import { createWebhookListener } from './webhook/listener-lifecycle.mjs';
 import { createWebhookRequestHandler } from './webhook/request-handler.mjs';
 import { createWebhookVerifier } from './webhook/verification.mjs';

package/src/runtime/{shared → channels/lib}/webhooks-db.mjs

@@ -14,9 +14,9 @@
  * the connection search_path.
  */
 
-import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
-import { createPgSchemaDb } from './pg-schema-db.mjs';
-import { resolvePluginData } from './plugin-paths.mjs';
+import { ensurePgInstance, withSchemaBootstrapLock } from '../../memory/lib/pg/adapter.mjs';
+import { createPgSchemaDb } from '../../shared/pg-schema-db.mjs';
+import { resolvePluginData } from '../../shared/plugin-paths.mjs';
 
 const SCHEMA = 'webhooks';
 

package/src/runtime/channels/lib/whisper-server.mjs

@@ -39,6 +39,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { spawn, spawnSync } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
+import { windowsSystemRoot } from '../../agent/orchestrator/tools/builtin/windows-roots.mjs';
 import { selectWhisperPort, whisperListenerOwned } from './whisper-port.mjs';
 
 // ── Tunables (deterministic; no ranges) ──────────────────────────────────────
@@ -149,7 +150,8 @@ function readPidMeta() {
 // closed (never kill, never reuse).
 function readProcessCommandLine(pid) {
   if (IS_WIN) {
-    const sysRoot = process.env.SystemRoot || process.env.windir || 'C\u003a\\Windows';
+    const sysRoot = windowsSystemRoot();
+    if (!sysRoot) return '';
     const wmic = path.join(sysRoot, 'System32', 'wbem', 'wmic.exe');
     try {
       const r = spawnSync(wmic, ['process', 'where', `ProcessId=${pid}`, 'get', 'CommandLine', '/FORMAT:LIST'], {
@@ -354,7 +356,6 @@ function wireChildExit() {
     mgr.inflight.clear();
     detachChildHandlers();
     clearPidMeta();
-    mgr.state = STATE.DEAD;
     mgr.child = null;
     mgr.port = null;
     mgr.runtimeKey = null;

package/src/runtime/channels/lib/worker-bootstrap.mjs

@@ -25,10 +25,10 @@ const STALE_WORKER_FILE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 
 // Rotate additional worker logs (10 MB threshold).
 function rotateWorkerLogs() {
-  for (const _rotLog of ROTATED_WORKER_LOGS) {
-    const _rotPath = path.join(DATA_DIR, _rotLog);
+  for (const name of ROTATED_WORKER_LOGS) {
+    const logPath = path.join(DATA_DIR, name);
     try {
-      if (fs.statSync(_rotPath).size > 10 * 1024 * 1024) fs.renameSync(_rotPath, `${_rotPath}.1`);
+      if (fs.statSync(logPath).size > 10 * 1024 * 1024) fs.renameSync(logPath, `${logPath}.1`);
     } catch {}
   }
 }
@@ -39,17 +39,17 @@ function rotateWorkerLogs() {
 // cleanup signal. 7-day TTL keeps recent crash forensics while bounding leak.
 function pruneStaleScopedLogs() {
   try {
-    const _now = Date.now();
-    for (const _f of fs.readdirSync(DATA_DIR)) {
+    const now = Date.now();
+    for (const name of fs.readdirSync(DATA_DIR)) {
       if (
-        !/^(channels|memory)-worker\.\d+\.\d+\.log$/.test(_f) &&
-        !/^mcp-debug\.\d+\.\d+\.log$/.test(_f) &&
-        !/^supervisor\.\d+\.log$/.test(_f)
+        !/^(channels|memory)-worker\.\d+\.\d+\.log$/.test(name) &&
+        !/^mcp-debug\.\d+\.\d+\.log$/.test(name) &&
+        !/^supervisor\.\d+\.log$/.test(name)
       )
         continue;
-      const _p = path.join(DATA_DIR, _f);
+      const filePath = path.join(DATA_DIR, name);
       try {
-        if (_now - fs.statSync(_p).mtimeMs > STALE_WORKER_FILE_TTL_MS) fs.unlinkSync(_p);
+        if (now - fs.statSync(filePath).mtimeMs > STALE_WORKER_FILE_TTL_MS) fs.unlinkSync(filePath);
       } catch {}
     }
   } catch {}
@@ -61,14 +61,14 @@ function pruneStaleScopedLogs() {
 // 7-day TTL is safe because live agent sessions touch their JSON file on
 // every ask iteration, so any file older than 7 days is provably abandoned.
 function pruneStaleSessionFiles() {
-  const _SESSIONS_DIR = path.join(DATA_DIR, 'sessions');
+  const sessionsDir = path.join(DATA_DIR, 'sessions');
   try {
-    const _now = Date.now();
-    for (const _f of fs.readdirSync(_SESSIONS_DIR)) {
-      if (!_f.endsWith('.json')) continue;
-      const _p = path.join(_SESSIONS_DIR, _f);
+    const now = Date.now();
+    for (const name of fs.readdirSync(sessionsDir)) {
+      if (!name.endsWith('.json')) continue;
+      const filePath = path.join(sessionsDir, name);
       try {
-        if (_now - fs.statSync(_p).mtimeMs > STALE_WORKER_FILE_TTL_MS) fs.unlinkSync(_p);
+        if (now - fs.statSync(filePath).mtimeMs > STALE_WORKER_FILE_TTL_MS) fs.unlinkSync(filePath);
       } catch {}
     }
   } catch {}
@@ -88,14 +88,12 @@ export function runWorkerBootstrap({
   try {
     pruneStalePluginDataLogSiblings(DATA_DIR, DEFAULT_STALE_LOG_SIBLING_MAX);
   } catch {}
-  // SIGTERM: do NOT exit here in worker mode — the graceful
-  // `_channelsShutdownHandler` below owns shutdown (stop() → cleanup →
-  // process.exit). In non-worker mode defer to default termination so
-  // process.on('exit') hooks still run.
+  // SIGTERM: do NOT exit here in worker mode — the graceful shutdown handler in
+  // worker-ipc.mjs owns shutdown (stop() → cleanup → process.exit). In
+  // non-worker mode exit explicitly so process.on('exit') hooks still run.
   process.on('SIGTERM', () => {
     if (!isWorkerMode) process.exit(0);
   });
-  // ────────────────────────────────────────────────────────────────────────────
   ensureRuntimeDirs();
   cleanupStaleRuntimeFiles();
   if (!isWorkerMode) {