mixdog 1.4.1 → 1.4.3

package/src/runtime/agent/orchestrator/tools/lib/shell-run-state.mjs

@@ -6,13 +6,31 @@
 import { randomUUID } from 'node:crypto';
 import { publishForegroundShellRecord, retireForegroundShellRecord } from '../builtin/shell-jobs.mjs';
 import { ShellTextDecoder, TaskOutput, treeKill } from '../shell-exec-output.mjs';
-import { createProcessTreeTracker, killAfterSnapshot } from './shell-descendants.mjs';
+import { createContainedTreeTracker, createProcessTreeTracker } from './shell-descendants.mjs';
 import { registerOwnedShellTree } from './owned-shell-trees.mjs';
 
+/** The tracker of the run's process tree, created once. A killed tree the
+ *  spawn server contains is gone on its verified-empty report alone; every
+ *  other tree (no containment, or a root that exited on its own and left
+ *  survivors) is observed through the process table. */
+export function runTreeTracker(run) {
+  run.terminationTracker =
+    run.terminationTracker ||
+    (run.killed === true && run.child.contained === true
+      ? createContainedTreeTracker({
+          outcome: () => run.child.treeOutcome,
+          // Survivors the server kept in the job: the kill, by request id.
+          cancel: () => treeKill(run.child),
+        })
+      : createProcessTreeTracker({ pid: run.child.pid, rootCreationTime: run.child.creationTime }));
+  return run.terminationTracker;
+}
+
 /** One pre-kill identity read of the run's tree (every kill path shares it):
- *  resolves true once the capture is complete, false when it failed. */
+ *  resolves true once the capture is complete, false when it failed. A
+ *  contained kill needs none: true at once, so the kill is never delayed. */
 export function capturePreKill(run) {
-  run.terminationTracker = run.terminationTracker || createProcessTreeTracker({ pid: run.child.pid });
+  if (runTreeTracker(run).contained) return true;
   const rootExited = run.child.exitCode != null || run.child.signalCode != null;
   return run.terminationTracker.capture({ rootExited }).catch(() => false);
 }
@@ -32,6 +50,7 @@ export function registerForegroundOwnedTree(run, ownerSessionId) {
       run.killCause = run.killCause || 'session-close';
       // Always a fresh read: an earlier one predates what the run started
       // since. Pending, the kill is sent at the snapshot bound regardless.
+      // A contained tree answers true at once: its cancel is sent at once.
       return capturePreKill(run);
     },
   };
@@ -39,7 +58,7 @@ export function registerForegroundOwnedTree(run, ownerSessionId) {
 }
 
 // Treekill + exit confirmation. treeKill alone leaves settle() pending on
-// 'close'/'exit'; on Windows a taskkill miss or a grandchild holding stdio
+// 'close'/'exit'; on Windows a missed tree kill or a grandchild holding stdio
 // fds keeps the dispatch stalled until the upstream ceiling. Covers every
 // kill path (timeout / pre-aborted / abort / capture-error / size-watchdog)
 // so the hang risk does not live on outside the timeout branch.
@@ -219,18 +238,23 @@ export function keepTerminationUnconfirmedRecord(run) {
 // Record the tree's identities while the root is still alive, THEN kill: once
 // an intermediate dies its children's parent links dangle and a snapshot taken
 // afterwards can no longer find them.
-// The kill waits for the snapshot at most PROCESS_TABLE_READ_BOUND_MS and is
-// sent whether the snapshot succeeded, failed or is still pending (a late
-// snapshot is still absorbed; a missing one leaves the outcome unknown, so the
-// workspace stays held under the observation loop). The confirmation deadline
-// starts once the kill is actually issued.
+// The kill waits until the snapshot succeeded or failed, never just for a
+// while: a read still in flight takes its table after a kill sent beside it,
+// finds the root gone, and the tree could never be confirmed terminated (the
+// workspace then stays held until a force-release). A healthy table read takes
+// seconds on a loaded host; a stuck one ends at its enumeration deadline
+// (ENUMERATION_DEADLINE_MS), and the kill is sent then, the outcome unknown.
+// A tree the spawn server contains is killed at once instead: its job holds
+// every descendant, and the server reports when that job is empty.
+// The confirmation deadline starts once the kill is actually issued.
 function snapshotThenKill(run, afterKill) {
-  if (!run.child?.pid) {
+  const snapshot = run.child?.pid ? capturePreKill(run) : true;
+  if (snapshot === true) {
     treeKill(run.child);
     afterKill();
     return;
   }
-  void killAfterSnapshot(capturePreKill(run), () => {
+  void snapshot.then(() => {
     treeKill(run.child);
     afterKill();
   });

package/src/runtime/agent/orchestrator/tools/lib/shell-warm-standby.mjs

@@ -102,6 +102,8 @@ function ensureWarmShellStandby({ shell, env }) {
         outputLimit: SHELL_OUTPUT_DISK_CAP,
         rawOutput: true,
         stdinPipe: true,
+        // The command it is fed runs contained, like a fresh spawn's.
+        contain: true,
         shellType: 'powershell',
         command: '(warm shell standby)',
       },

package/src/runtime/agent/orchestrator/tools/lib/wait-until-fixture.mjs

@@ -0,0 +1,26 @@
+// Test support: wait for a real condition on a wall-clock budget. A fixed
+// number of event-loop turns is load-dependent (async record writes and
+// process-table reads take more turns on a busy machine); elapsed time is not.
+// Polls on a short real timer (never a busy loop). The real setTimeout is
+// captured at load, before any test enables mock timers, so a mocked clock
+// cannot freeze the wait.
+import assert from 'node:assert/strict';
+
+const realSetTimeout = setTimeout;
+const POLL_MS = 5;
+const tick = () => new Promise((resolve) => realSetTimeout(resolve, POLL_MS));
+
+/** Resolves with the first truthy `read()` (sync or async); fails with `what`
+ *  once `timeoutMs` has passed without one. */
+export async function waitUntil(
+  read,
+  { timeoutMs = 10_000, what = String(read).replace(/\s+/g, ' ').slice(0, 160) } = {}
+) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const value = await read();
+    if (value) return value;
+    if (Date.now() >= deadline) assert.fail(`condition not reached within ${timeoutMs}ms: ${what}`);
+    await tick();
+  }
+}

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -21,10 +21,6 @@ import { spawnShellChild } from './lib/shell-run-spawn.mjs';
 import { createPromotedCaptureRelease, createSettle } from './lib/shell-run-settle.mjs';
 import { _abortReasonIsInterrupt, createAutoBackground } from './lib/shell-run-background.mjs';
 
-export {
-  _maybeEncodePowerShellCommand,
-  extractPowerShellCommandInner,
-} from './shell-powershell.mjs';
 export { stripAnsi, ExecResult } from './shell-exec-output.mjs';
 
 async function _execPolicyBlockMessage(command, elevationApproved = false) {
@@ -432,7 +428,7 @@ function attachChildExit(run, releasePromotedCapture) {
   // child termination regardless — give 'close' a 3 s grace then
   // settle anyway. The grace outlives the spawn server's own 2 s drain
   // deadline, so the real exit status normally still arrives first.
-  child.once('exit', (code, signal) => {
+  const onExit = (code, signal) => {
     if (!run.rootExitAtMs) run.rootExitAtMs = Date.now();
     const grace = setTimeout(() => {
       if (run.settled || run.promotionClose) return;
@@ -449,7 +445,12 @@ function attachChildExit(run, releasePromotedCapture) {
       run.settle(code == null ? 1 : code, signal);
     }, 3000);
     if (grace.unref) grace.unref();
-  });
+  };
+  // The spawn awaits the command's workspace lease before these listeners
+  // exist; a root that exited meanwhile ('close' is replayed, 'exit' is not)
+  // starts its grace now.
+  if (child.exitCode != null || child.signalCode != null) onExit(child.exitCode, child.signalCode);
+  else child.once('exit', onExit);
 }
 
 // Live-progress heartbeat: every 2 s while the foreground command runs, emit

package/src/runtime/agent/orchestrator/tools/shell-policy.mjs

@@ -1,5 +1,4 @@
 import { isDangerousDeleteTarget as _isDangerousDeleteTarget } from './shell-policy-danger-target.mjs';
-export { isDangerousDeleteTarget } from './shell-policy-danger-target.mjs';
 // Shell execution security policy — shared constants used by both
 // destructive-warning.mjs (heuristic classifier) and the shell command
 // runner (hard block list).

package/src/runtime/agent/orchestrator/tools/spawn-manifest.json

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.11",
+  "version": "0.1.12",
   "_comment": "Synced from immutable spawn-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-darwin-arm64",
-      "sha256": "6f1a7e6597dcc8785d12c5a13c42388110d9f4a2e5378ca2773172adbf50de60"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-darwin-arm64",
+      "sha256": "bc2307b1c089e07f829a8a1daf4dfdfc128e3221d8f70609ffbdcc3f8b596806"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-darwin-x64",
-      "sha256": "ff755eb9848cb3ce90f3df24136bb84a52f9ff6c67002c4d764beb6d7906e6b2"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-darwin-x64",
+      "sha256": "4b1d221a29128046c417cfae5617e2898e1b7bc564dca686b2608b6cb14bf3af"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-linux-arm64",
-      "sha256": "3bc0fccde46537046d498a2b953aa92ef4afacc95c96c563ce1d6fb92d74e593"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-linux-arm64",
+      "sha256": "2f577f54693726db0d285a16c3af2ad25b73fd705fd2fd4ac5c18ce795f657a9"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-linux-x64",
-      "sha256": "16dc4e3bf6636335c1325c88bbb5245529731525953466e761d363897b59aac7"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-linux-x64",
+      "sha256": "83b52edfe2b810d5cf6544b03ab263eedcf7b2ef3c73107a45a33f6f7871e59e"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-win32-arm64.exe",
-      "sha256": "c2fb5499d3d44405e27c79f8db65694299d61ddf029f466df68549fc2f2c5f5c"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-win32-arm64.exe",
+      "sha256": "33872113fc0ca3cd2a2f6cf36c33430431388a5e36f254c8a0c6a44932057009"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-win32-x64.exe",
-      "sha256": "50531a9f033dc22eff3ec5b2a9d10441ffdfac0e50d9acf9047e4f302e5d70d9"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-win32-x64.exe",
+      "sha256": "0070823fa03a50819077d60a407f4f8e26becafe3541ecdfabe522fc5e05a8cb"
     }
   }
 }

package/src/runtime/attachments/attachment-reference.mjs

@@ -33,7 +33,7 @@ function quotedName(name, fallback) {
 }
 
 /** How much of a PDF reads as text, in words the model can act on. */
-export function textLayerLabel(pageCount, textPages) {
+function textLayerLabel(pageCount, textPages) {
   const pages = Number(pageCount);
   const withText = Number(textPages);
   if (!(pages > 0) || !Number.isFinite(withText) || withText < 0) return 'text layer not checked';

package/src/runtime/attachments/pdf-extract.mjs

@@ -81,7 +81,7 @@ export const PDF_INTAKE_TIMEOUT_MS = 60_000;
 // least this many non-whitespace characters. A scan often keeps a stamped page
 // number or a few stray glyphs; those alone do not make its content readable
 // as text, so such a page still needs its image (or OCR).
-export const PDF_TEXT_LAYER_MIN_CHARS = 16;
+const PDF_TEXT_LAYER_MIN_CHARS = 16;
 
 /** Whether one page's extracted text is a real text layer (see above). */
 export function pageHasTextLayer(text) {

package/src/runtime/attachments/store.d.mts

@@ -1,4 +1,5 @@
 export function readAttachmentBuffer(value: string | { attachmentRef?: string }): Buffer;
+export function attachmentBlobSize(value: string | { attachmentRef?: string }, claimed?: number): number;
 export function isPermanentAttachmentError(error: unknown): boolean;
 export function isAttachmentReference(value: unknown): boolean;
 export interface MessageAttachment {

package/src/runtime/attachments/store.mjs

@@ -298,7 +298,7 @@ const ATTACHMENT_INTEGRITY = 'ATTACHMENT_INTEGRITY';
 
 // A referenced blob that is gone from disk (retention, manual cleanup, a
 // copied session) surfaces from readAttachmentBuffer as the stat ENOENT.
-export function isMissingAttachmentError(error) {
+function isMissingAttachmentError(error) {
   return error?.code === 'ENOENT';
 }
 
@@ -316,7 +316,7 @@ export function readAttachmentBase64(value) {
 // Real on-disk size of a referenced blob. Caps must never trust the client's
 // claimed sizeBytes; a blob that is not on disk cannot be read later either, so
 // only then does the claimed size stand.
-function attachmentBlobSize(value, claimed = 0) {
+export function attachmentBlobSize(value, claimed = 0) {
   try {
     return statSync(attachmentPath(typeof value === 'string' ? value : value?.attachmentRef)).size;
   } catch (error) {

package/src/runtime/channels/lib/config-reload-watch.mjs

@@ -0,0 +1,42 @@
+// The channels worker's config hot reload (schedules, webhooks, events, voice).
+// It rides the shared config-change subscription: that watches the data
+// directory, so the atomic rename of every write never orphans it, it recovers
+// from watcher errors, and it carries in-process writes and keychain changes.
+// A reload restarts the webhook server and hook tunnel, so only a change of
+// the sections the worker reads (channels: webhook, events, …; voice) reloads;
+// schedules arrive through the reload_config IPC, never through this watch.
+import { readSection, subscribeConfigChange } from '../../shared/config.mjs';
+
+function channelsConfigSnapshot() {
+  return JSON.stringify([readSection('channels') ?? null, readSection('voice') ?? null]);
+}
+
+export function createConfigReloadWatch(reload, { snapshot = channelsConfigSnapshot } = {}) {
+  let unsubscribe = null;
+  let applied = null;
+  const read = () => {
+    try {
+      return snapshot();
+    } catch {
+      return null;
+    }
+  };
+  return {
+    start() {
+      if (unsubscribe) return;
+      applied = read();
+      unsubscribe = subscribeConfigChange(() => {
+        const next = read();
+        if (next !== null && next === applied) return;
+        applied = next;
+        Promise.resolve()
+          .then(reload)
+          .catch(() => {});
+      });
+    },
+    stop() {
+      unsubscribe?.();
+      unsubscribe = null;
+    },
+  };
+}

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

@@ -1,6 +1,19 @@
 import { loadConfig } from '../config.mjs';
 
-export function createConfigReloader({ state, getConfig, setConfig, getBridgeRuntimeConnected, scheduler, services }) {
+export function createConfigReloader({
+  state,
+  getConfig,
+  setConfig,
+  getBridgeRuntimeConnected,
+  scheduler,
+  services,
+  load = loadConfig,
+}) {
+  // Reloads overlap (no debounce), so a slower load of an older config must not
+  // be applied over a newer one: only the newest started reload applies, and an
+  // older caller waits for it instead.
+  let latestStarted = 0;
+  let latestReload = null;
   function reloadScheduler() {
     // The scheduler must be RE-ARMED by the reload whenever it is supposed to
     // be running: `restart: false` only destroys the cron/one-shot bindings and
@@ -12,13 +25,20 @@ export function createConfigReloader({ state, getConfig, setConfig, getBridgeRun
       restart: state.automationRunning || getBridgeRuntimeConnected(),
     });
   }
-  return async function reloadRuntimeConfig() {
-    setConfig(await loadConfig());
-    reloadScheduler();
-    if (getBridgeRuntimeConnected() || state.automationRunning) {
-      services.syncWebhookAndEventRuntime({ reload: true });
-    } else {
-      await services.stopWebhookAndEventRuntime();
-    }
+  return function reloadRuntimeConfig() {
+    const ticket = ++latestStarted;
+    const run = (async () => {
+      const loaded = await load();
+      if (ticket !== latestStarted) return latestReload;
+      setConfig(loaded);
+      reloadScheduler();
+      if (getBridgeRuntimeConnected() || state.automationRunning) {
+        services.syncWebhookAndEventRuntime({ reload: true });
+      } else {
+        await services.stopWebhookAndEventRuntime();
+      }
+    })();
+    latestReload = run;
+    return run;
   };
 }

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

@@ -9,6 +9,7 @@ import { isPidAlive } from '../../shared/pid-liveness.mjs';
 import {
   advanceScheduleCursor,
   claimScheduleRun,
+  getSchedule,
   markFired,
   markDone,
   markScheduleFailure,
@@ -76,6 +77,14 @@ function isCronExpression(time) {
     return false;
   }
 }
+// Two one-shot times name the same instant. The database hands back a new
+// Date on every read, so identity would call an unchanged schedule changed.
+function sameInstant(left, right) {
+  if (left == null || right == null) return (left ?? null) === (right ?? null);
+  const at = (value) => (value instanceof Date ? value.getTime() : Date.parse(value));
+  const [a, b] = [at(left), at(right)];
+  return Number.isNaN(a) || Number.isNaN(b) ? String(left) === String(right) : a === b;
+}
 // True when this fire (started at `since`) ended in an overlap skip.
 function skippedSince(schedule, since) {
   const at = schedule.lastSkippedAt ? new Date(schedule.lastSkippedAt).getTime() : 0;
@@ -616,6 +625,30 @@ class Scheduler {
   }
   // ── Fire timed schedule ─────────────────────────────────────────────
   async fireTimed(schedule, opts = {}) {
+    // The armed copy may be stale (a reload that failed or has not arrived):
+    // the stored row decides whether, and with what prompt, it still fires.
+    let row;
+    try {
+      row = await getSchedule(schedule.name);
+    } catch (err) {
+      logSchedule(`${schedule.name}: not fired — schedule unreadable: ${err?.message || err}\n`);
+      this.notifyFailure(schedule, 'schedule unreadable — fire skipped');
+      return false;
+    }
+    const sameCron = (row?.whenCron ?? null) === (schedule.whenCron ?? null);
+    if (
+      !row ||
+      row.enabled === false ||
+      row.status === 'done' ||
+      !sameInstant(row.whenAt, schedule.whenAt) ||
+      !sameCron
+    ) {
+      logSchedule(`${schedule.name}: not fired — deleted or changed since it was armed\n`);
+      // A skip, not a failed run: the callers record no failure on its row.
+      schedule.lastSkippedAt = new Date().toISOString();
+      return false;
+    }
+    schedule.prompt = row.prompt;
     const prompt = this.resolvePrompt(schedule);
     if (!prompt) {
       process.stderr.write(`mixdog scheduler: prompt not found for "${schedule.name}"

package/src/runtime/channels/lib/schedules-db.mjs

@@ -60,6 +60,9 @@ ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS last_skipped_at timesta
 ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS owner_agent_id text NOT NULL DEFAULT 'lead';
 -- Legacy columns model, workflow and run_as_agent are no longer read or written (kept, not dropped, to avoid a risky migration).
 ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS run_as_agent boolean NOT NULL DEFAULT false;
+-- The workflow sub-agent that carries out each fire first (its final report is
+-- what the owner bot relays); NULL = the owner bot does the work itself.
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS executor_agent_id text;
 -- Failed runs in a row: a success or switching it back on resets it; at
 -- ROUTINE_LIMITS.pauseAfterFailures the schedule switches itself off.
 ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS consecutive_failures integer NOT NULL DEFAULT 0;
@@ -101,6 +104,7 @@ function rowToDef(row) {
     lastFailedAt: row.last_failed_at,
     lastSkippedAt: row.last_skipped_at,
     ownerAgentId: row.owner_agent_id || 'lead',
+    executorAgentId: row.executor_agent_id || null,
     consecutiveFailures: Number(row.consecutive_failures) || 0,
     resultDelivery: row.result_delivery || null,
     nextFireAt: row.next_fire_at,
@@ -136,7 +140,7 @@ function hasRequiredTargetColumn(db) {
 }
 
 const COLS =
-  'name, description, when_at, when_cron, timezone, cwd, attachments, delivery, prompt, enabled, status, last_fired_at, last_scheduled_at, last_started_at, last_success_at, last_failed_at, last_skipped_at, owner_agent_id, consecutive_failures, result_delivery, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
+  'name, description, when_at, when_cron, timezone, cwd, attachments, delivery, prompt, enabled, status, last_fired_at, last_scheduled_at, last_started_at, last_success_at, last_failed_at, last_skipped_at, owner_agent_id, executor_agent_id, consecutive_failures, result_delivery, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
 
 // ---------------------------------------------------------------------------
 // Public API
@@ -176,6 +180,7 @@ export async function upsertSchedule(def, { dataDir } = {}) {
     def.status ?? 'active',
     def.nextFireAt ?? null,
     def.ownerAgentId || 'lead',
+    def.executorAgentId || null,
   ];
   let legacyTarget = '';
   let legacyTargetValue = '';
@@ -186,10 +191,11 @@ export async function upsertSchedule(def, { dataDir } = {}) {
   }
   const { rows } = await db.query(
     `INSERT INTO scheduler.schedules
-       (name, description, when_at, when_cron, timezone, cwd, attachments, delivery, prompt, enabled, status, next_fire_at, owner_agent_id${legacyTarget})
-     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13${legacyTargetValue})
+       (name, description, when_at, when_cron, timezone, cwd, attachments, delivery, prompt, enabled, status, next_fire_at, owner_agent_id, executor_agent_id${legacyTarget})
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14${legacyTargetValue})
      ON CONFLICT (name) DO UPDATE SET
        owner_agent_id = EXCLUDED.owner_agent_id,
+       executor_agent_id = EXCLUDED.executor_agent_id,
        description  = EXCLUDED.description,
        when_at      = EXCLUDED.when_at,
        when_cron    = EXCLUDED.when_cron,
@@ -235,7 +241,7 @@ export async function renameSchedule(oldName, def, { timingChanged = false, data
     const { rows } = await db.query(
       `UPDATE scheduler.schedules SET
          name = $2, description = $3, when_at = $4, when_cron = $5, timezone = $6, cwd = $7,
-         attachments = $8, prompt = $9, enabled = $10, owner_agent_id = $11,
+         attachments = $8, prompt = $9, enabled = $10, owner_agent_id = $11, executor_agent_id = $13,
          next_fire_at = CASE WHEN $12::boolean THEN $4::timestamptz ELSE next_fire_at END,
          status = CASE WHEN $12::boolean THEN 'active' ELSE status END,
          deferred_until = CASE WHEN $12::boolean THEN NULL ELSE deferred_until END,
@@ -258,6 +264,7 @@ export async function renameSchedule(oldName, def, { timingChanged = false, data
         def.enabled ?? true,
         def.ownerAgentId || 'lead',
         timingChanged === true,
+        def.executorAgentId || null,
       ]
     );
     return rowToDef(rows[0]);

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

@@ -96,6 +96,8 @@ function createWebhookSessionDispatcher({ getBridgeDispatch, store = { recordEnd
           endpoint: name,
           // The bot whose chat the run is a turn in.
           owner: extra.owner || null,
+          // The sub-agent that carries the run out first, if the endpoint names one.
+          executor: extra.executor || null,
           deliveryId,
           event: extra.event || null,
         },
@@ -108,7 +110,7 @@ function createWebhookSessionDispatcher({ getBridgeDispatch, store = { recordEnd
 
   async function dispatchEndpoint({ name, body, headers, res, deliveryId, endpoint }) {
     try {
-      const { instructions, cwd, attachments, delivery, ownerAgentId } = endpoint;
+      const { instructions, cwd, attachments, delivery, ownerAgentId, executorAgentId } = endpoint;
       const run = webhookRunPrompt(instructions, body, headers);
       if (!getBridgeDispatch()) throw new Error(`[webhook] session dispatch requires bridgeDispatch`);
       // Kept for the app's "Run now", which re-runs the latest event. Losing
@@ -118,6 +120,7 @@ function createWebhookSessionDispatcher({ getBridgeDispatch, store = { recordEnd
       );
       await dispatchSessionRun(name, run.prompt, deliveryId, res, {
         owner: ownerAgentId || null,
+        executor: executorAgentId || null,
         cwd: cwd || null,
         event: webhookEventSummary(headers, body),
         attachments: attachments || null,

package/src/runtime/channels/lib/webhooks-db.mjs

@@ -45,6 +45,9 @@ ALTER TABLE webhooks.endpoints ALTER COLUMN role SET DEFAULT '';
 ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS owner_agent_id text NOT NULL DEFAULT 'lead';
 -- Legacy columns model, workflow and run_as_agent are no longer read or written (kept, not dropped, to avoid a risky migration).
 ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS run_as_agent boolean NOT NULL DEFAULT false;
+-- The workflow sub-agent that carries out each run first (its final report is
+-- what the owner bot relays); NULL = the owner bot does the work itself.
+ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS executor_agent_id text;
 -- The latest received event (its payload kept for a manual re-run) and the
 -- outcome stamps of the runs it started.
 ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS last_event_at timestamptz;
@@ -86,7 +89,7 @@ const getDb = createPgSchemaDb({
 // The stored payload itself is never projected here (readEndpointLastPayload
 // is its only read path); rows carry a presence flag.
 const ENDPOINT_COLS =
-  'name, description, parser, secret, cwd, attachments, delivery, instructions, enabled, owner_agent_id, last_event_at, last_success_at, last_failed_at, last_skipped_at, consecutive_failures, result_delivery, (last_payload IS NOT NULL) AS has_last_payload, created_at, updated_at';
+  'name, description, parser, secret, cwd, attachments, delivery, instructions, enabled, owner_agent_id, executor_agent_id, last_event_at, last_success_at, last_failed_at, last_skipped_at, consecutive_failures, result_delivery, (last_payload IS NOT NULL) AS has_last_payload, created_at, updated_at';
 
 function rowToEndpoint(row) {
   if (!row) return null;
@@ -104,6 +107,7 @@ function rowToEndpoint(row) {
     instructions: row.instructions,
     enabled: row.enabled,
     ownerAgentId: row.owner_agent_id || 'lead',
+    executorAgentId: row.executor_agent_id || null,
     lastEventAt: row.last_event_at || null,
     lastSuccessAt: row.last_success_at || null,
     lastFailedAt: row.last_failed_at || null,
@@ -187,15 +191,17 @@ export async function upsertEndpoint(def, { dataDir } = {}) {
     def.instructions ?? '',
     def.enabled ?? true,
     def.ownerAgentId || 'lead',
+    def.executorAgentId || null,
   ];
   // The last event and run stamps survive an edit: they describe deliveries,
   // not the definition.
   const { rows } = await db.query(
     `INSERT INTO webhooks.endpoints
-       (name, description, role, parser, secret, cwd, attachments, delivery, instructions, enabled, owner_agent_id)
-     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
+       (name, description, role, parser, secret, cwd, attachments, delivery, instructions, enabled, owner_agent_id, executor_agent_id)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)
      ON CONFLICT (name) DO UPDATE SET
        owner_agent_id = EXCLUDED.owner_agent_id,
+       executor_agent_id = EXCLUDED.executor_agent_id,
        description  = EXCLUDED.description,
        role        = EXCLUDED.role,
        parser       = EXCLUDED.parser,

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

@@ -48,22 +48,31 @@ function runOwnershipQuery(command, args) {
   });
 }
 
+// Get-NetTCPConnection prints one OwningProcess number per line: no localized words.
+export function listenerPidsInclude(stdout, pid) {
+  return stdout.split(/\r?\n/).some((line) => line.trim() === String(pid));
+}
+
 export async function whisperListenerOwned(host, port, pid) {
   if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(port)) return false;
   try {
     if (process.platform === 'win32') {
       const root = process.env.SystemRoot || 'C:\\Windows';
-      const stdout = await runOwnershipQuery(path.join(root, 'System32', 'netstat.exe'), ['-ano', '-p', 'tcp']);
+      // netstat omits listeners when the TCP table is large; the CIM-backed cmdlet does not.
+      // The State filter is skipped (it can report an unknown state for live listeners);
+      // a listening row is the one with no remote endpoint (RemotePort 0).
+      if (!/^[0-9a-fA-F:.]+$/.test(host)) return false;
+      const stdout = await runOwnershipQuery(
+        path.join(root, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+        [
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          `(Get-NetTCPConnection -LocalAddress '${host}' -LocalPort ${port} -ErrorAction SilentlyContinue | Where-Object RemotePort -eq 0).OwningProcess`,
+        ]
+      );
       if (stdout === null) return false;
-      return stdout.split(/\r?\n/).some((line) => {
-        const fields = line.trim().split(/\s+/);
-        return (
-          fields[0] === 'TCP' &&
-          fields[1] === `${host}:${port}` &&
-          fields[3] === 'LISTENING' &&
-          fields[4] === String(pid)
-        );
-      });
+      return listenerPidsInclude(stdout, pid);
     }
     if (process.platform === 'linux') {
       const stdout = await runOwnershipQuery('ss', ['-H', '-ltnp', `sport = :${port}`]);