mixdog 0.9.67 → 0.9.69

package/src/standalone/agent-tool.mjs

@@ -1,4 +1,3 @@
-import { readFileSync, statSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
@@ -12,20 +11,16 @@ import {
   taskIdFromArgs,
 } from '../runtime/shared/background-tasks.mjs';
 import { presentErrorText, errorLine } from '../runtime/shared/err-text.mjs';
-import { updateJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { normalizeAgentPermission } from '../runtime/shared/markdown-frontmatter.mjs';
 import { ensureProcessListenerHeadroom } from '../runtime/shared/process-listener-headroom.mjs';
 import { resourceAdmission } from '../runtime/shared/resource-admission.mjs';
 import { prepareAgentSession } from '../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
 import {
-  abortAgentProgressWatchdog,
-  agentWatchdogPolicyActive,
-  evaluateAgentWatchdogAbort,
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
   watchdogPartialHandoffFromError,
-  AgentStallAbortError,
 } from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+import { createProgressWatchdogRegistry } from './agent-watchdog-registry.mjs';
 import { buildAgentTaskProgressFields } from './agent-task-status.mjs';
 import { AGENT_OWNER } from '../runtime/agent/orchestrator/agent-owner.mjs';
 import {
@@ -57,15 +52,13 @@ import { createNotify } from './agent-tool/notify.mjs';
 import { resolveAgentSpawnPreset } from './agent-tool/spawn-preset.mjs';
 import {
   TAG_TOMBSTONE_TTL_MS,
-  applyWorkerRowUpsert,
   isTerminalWorkerStatus,
-  normalizeTagTombstones,
   tagTombstoneKey,
-  workerRowKey,
   workerRowTime,
   workerRowToSession,
 } from './agent-tool/worker-rows.mjs';
 import { resolveAgentTerminalReapMs } from '../session-runtime/config-helpers.mjs';
+import { createWorkerIndex } from './agent-tool/worker-index.mjs';
 // Re-export the static tool descriptor so importers of this facade keep the
 // identical public surface (`import { AGENT_TOOL } from './agent-tool.mjs'`).
 export { AGENT_TOOL };
@@ -102,253 +95,20 @@ export function createStandaloneAgent({
   const tagAgents = new Map();
   const tagCwds = new Map();
   const reapTimers = new Map();
-  const workerIndexMutators = [];
-  let workerIndexFlushTimer = null;
-  function workerIndexPath() {
-    return dataDir ? resolve(dataDir, WORKER_INDEX_FILE) : null;
-  }
-
-  function keepWorkerRow(row = {}) {
-    if (!clean(row.tag) || !clean(row.sessionId)) return false;
-    const t = workerRowTime(row);
-    if (!t) return true;
-    if (!isTerminalWorkerStatus(row.status || row.stage)) return true;
-    const reapMs = resolveAgentTerminalReapMs(cfgMod.loadConfig(), row.provider);
-    return reapMs == null || Date.now() - t < reapMs;
-  }
-
-  function normalizeWorkerRows(value) {
-    const source = Array.isArray(value?.workers)
-      ? value.workers
-      : (value?.workers && typeof value.workers === 'object'
-        ? Object.values(value.workers)
-        : (Array.isArray(value) ? value : []));
-    return source
-      .filter((row) => row && typeof row === 'object')
-      .map((row) => ({
-        tag: clean(row.tag),
-        sessionId: clean(row.sessionId),
-        agent: clean(row.agent) || null,
-        provider: clean(row.provider) || null,
-        model: clean(row.model) || null,
-        preset: clean(row.preset) || null,
-        effort: clean(row.effort) || null,
-        fast: row.fast === true ? true : (row.fast === false ? false : null),
-        status: clean(row.status) || 'idle',
-        stage: clean(row.stage) || clean(row.status) || 'idle',
-        createdAt: clean(row.createdAt) || null,
-        updatedAt: clean(row.updatedAt) || null,
-        lastUsedAt: clean(row.lastUsedAt) || null,
-        finishedAt: clean(row.finishedAt) || null,
-        clientHostPid: positiveInt(row.clientHostPid),
-        cwd: clean(row.cwd) || null,
-        task_id: clean(row.task_id || row.taskId) || null,
-        error: clean(row.error) || null,
-        permission: clean(row.permission) || null,
-        toolPermission: clean(row.toolPermission) || null,
-        messages: positiveInt(row.messages) || 0,
-        tools: positiveInt(row.tools) || 0,
-      }))
-      .filter(keepWorkerRow);
-  }
-
-  // Mtime-keyed parse cache for the worker index. A single spawn calls
-  // refreshTagsFromSessions()/resolveTag()/nextTag() which each re-read and
-  // re-JSON.parse this file; across a parallel fanout that is O(spawns^2)
-  // synchronous reads of the same bytes on the event loop. Cache the parsed,
-  // normalized rows and reuse them while the file mtime+size is unchanged.
-  // Writes bump _workerRowsCacheDirty so the very next read re-parses.
-  let _workerRowsCache = null; // { mtimeMs, size, rows, tombstones }
-  let _workerRowsCacheDirty = true;
-  function invalidateWorkerRowsCache() {
-    _workerRowsCacheDirty = true;
-  }
-  function readAllWorkerRows() {
-    const file = workerIndexPath();
-    if (!file) return [];
-    let st = null;
-    try { st = statSync(file); } catch { _workerRowsCache = null; return []; }
-    if (!_workerRowsCacheDirty
-      && _workerRowsCache
-      && _workerRowsCache.mtimeMs === st.mtimeMs
-      && _workerRowsCache.size === st.size) {
-      return _workerRowsCache.rows;
-    }
-    let rows = [];
-    let tombstones = [];
-    try {
-      const parsed = JSON.parse(readFileSync(file, 'utf8'));
-      rows = normalizeWorkerRows(parsed);
-      tombstones = normalizeTagTombstones(parsed);
-    } catch {
-      rows = [];
-      tombstones = [];
-    }
-    _workerRowsCache = { mtimeMs: st.mtimeMs, size: st.size, rows, tombstones };
-    _workerRowsCacheDirty = false;
-    return rows;
-  }
-  function readAllTagTombstones() {
-    readAllWorkerRows();
-    return _workerRowsCache?.tombstones || [];
-  }
-  function readTagTombstones(context = {}) {
-    return readAllTagTombstones().filter((row) => rowMatchesContext(row, context));
-  }
-  function readWorkerRows(context = {}) {
-    const rows = readAllWorkerRows();
-    if (rows.length === 0) return rows;
-    return rows.filter((row) => rowMatchesContext(row, context));
-  }
-
-  function workerRowsForUpdate(cur) {
-    return normalizeWorkerRows(cur);
-  }
-
-  function writeWorkerRows(mutator) {
-    const file = workerIndexPath();
-    if (!file || typeof mutator !== 'function') return null;
-    try {
-      const result = updateJsonAtomicSync(file, (cur) => {
-        const byKey = new Map();
-        for (const row of workerRowsForUpdate(cur)) {
-          const key = workerRowKey(row);
-          if (key) byKey.set(key, row);
-        }
-        const tombstonesByKey = new Map();
-        for (const row of normalizeTagTombstones(cur, { cap: false })) {
-          tombstonesByKey.set(tagTombstoneKey(row), row);
-        }
-        const priorityTombstoneKeys = new Set();
-        mutator(byKey, tombstonesByKey, priorityTombstoneKeys);
-        const workers = {};
-        for (const row of [...byKey.values()].filter(keepWorkerRow)) {
-          const key = workerRowKey(row);
-          if (key) workers[key] = row;
-        }
-        const tombstones = {};
-        for (const row of normalizeTagTombstones(
-          { tombstones: [...tombstonesByKey.values()] },
-          { priorityKeys: priorityTombstoneKeys },
-        )) {
-          tombstones[tagTombstoneKey(row)] = row;
-        }
-        return { version: 2, updatedAt: new Date().toISOString(), workers, tombstones };
-      }, { lock: true });
-      // This process just rewrote the index; force the next read to re-parse
-      // even if the new mtime/size happen to collide with the cached stat.
-      invalidateWorkerRowsCache();
-      return result;
-    } catch {
-      return null;
-    }
-  }
-
-  function flushWorkerIndexMutations() {
-    if (workerIndexFlushTimer) {
-      try { clearImmediate(workerIndexFlushTimer); } catch {}
-      workerIndexFlushTimer = null;
-    }
-    if (workerIndexMutators.length === 0) return;
-    const batch = workerIndexMutators.splice(0, workerIndexMutators.length);
-    writeWorkerRows((byKey) => {
-      for (const mutator of batch) {
-        try { mutator(byKey); } catch {}
-      }
-    });
-  }
-
-  function queueWorkerIndexMutation(mutator) {
-    if (typeof mutator !== 'function') return false;
-    if (!workerIndexPath()) return false;
-    workerIndexMutators.push(mutator);
-    if (!workerIndexFlushTimer) {
-      workerIndexFlushTimer = setImmediate(flushWorkerIndexMutations);
-      workerIndexFlushTimer.unref?.();
-    }
-    return true;
-  }
-
-  function workerRowFromSession(session, fallbackTag = '', extra = {}) {
-    const tag = agentTagOf(session) || clean(fallbackTag) || clean(extra.tag);
-    const sessionId = clean(session?.id || extra.sessionId);
-    if (!tag || !sessionId) return null;
-    const runtime = mgr.getSessionRuntime?.(sessionId);
-    const status = clean(extra.status) || (session?.closed === true ? 'closed' : clean(session?.status) || 'idle');
-    const stage = clean(extra.stage) || clean(runtime?.stage) || status;
-    const nowIso = new Date().toISOString();
-    return {
-      tag,
-      sessionId,
-      agent: clean(extra.agent) || clean(session?.agent) || null,
-      provider: clean(extra.provider) || clean(session?.provider) || null,
-      model: clean(extra.model) || clean(session?.model) || null,
-      preset: clean(extra.preset) || clean(session?.presetName) || null,
-      effort: clean(extra.effort) || clean(session?.effort) || null,
-      fast: extra.fast === true || extra.fast === false ? extra.fast : (session?.fast === true ? true : null),
-      status,
-      stage,
-      createdAt: clean(session?.createdAt) || clean(extra.createdAt) || nowIso,
-      updatedAt: clean(extra.updatedAt) || nowIso,
-      lastUsedAt: clean(session?.lastUsedAt) || null,
-      finishedAt: clean(extra.finishedAt) || null,
-      clientHostPid: positiveInt(extra.clientHostPid) || positiveInt(session?.clientHostPid),
-      cwd: clean(session?.cwd) || clean(extra.cwd) || null,
-      task_id: clean(extra.task_id || extra.taskId) || null,
-      error: clean(extra.error) || null,
-      permission: clean(session?.permission) || null,
-      toolPermission: clean(session?.toolPermission) || null,
-      messages: Array.isArray(session?.messages) ? session.messages.length : 0,
-      tools: Array.isArray(session?.tools) ? session.tools.length : 0,
-    };
-  }
-
-  function upsertWorkerRow(row, { defer = false } = {}) {
-    const normalized = normalizeWorkerRows({ workers: [row] })[0];
-    if (!normalized) return false;
-    tags.set(normalized.tag, normalized.sessionId);
-    if (normalized.agent) tagAgents.set(normalized.tag, normalized.agent);
-    if (normalized.cwd) tagCwds.set(normalized.tag, normalized.cwd);
-    if (defer) {
-      return queueWorkerIndexMutation((byKey) => applyWorkerRowUpsert(byKey, normalized));
-    }
-    writeWorkerRows((byKey) => {
-      applyWorkerRowUpsert(byKey, normalized);
-    });
-    return true;
-  }
-
-  function upsertWorkerSession(session, fallbackTag = '', extra = {}) {
-    return upsertWorkerRow(workerRowFromSession(session, fallbackTag, extra));
-  }
-
-  function upsertWorkerSessionDeferred(session, fallbackTag = '', extra = {}) {
-    return upsertWorkerRow(workerRowFromSession(session, fallbackTag, extra), { defer: true });
-  }
-
-  function removeWorkerRow({ tag = '', sessionId = '' } = {}) {
-    const targetTag = clean(tag);
-    const targetSessionId = clean(sessionId);
-    flushWorkerIndexMutations();
-    writeWorkerRows((byKey) => {
-      for (const [key, row] of [...byKey.entries()]) {
-        if ((targetSessionId && row.sessionId === targetSessionId) || (targetTag && row.tag === targetTag)) {
-          byKey.delete(key);
-        }
-      }
-    });
-  }
-
-  function refreshTagsFromIndex(context = {}) {
-    const rows = readWorkerRows(context);
-    for (const row of rows) {
-      if (!row.tag || !row.sessionId) continue;
-      tags.set(row.tag, row.sessionId);
-      if (row.agent) tagAgents.set(row.tag, row.agent);
-      if (row.cwd) tagCwds.set(row.tag, row.cwd);
-    }
-    return rows;
-  }
+  // Worker-index persistence (row store, parse cache, batched atomic writer,
+  // tag projection) lives in agent-tool/worker-index.mjs; the tag maps are
+  // shared by reference so both sides see the same live state.
+  const {
+    readAllTagTombstones,
+    readTagTombstones,
+    readWorkerRows,
+    writeWorkerRows,
+    flushWorkerIndexMutations,
+    upsertWorkerSession,
+    upsertWorkerSessionDeferred,
+    removeWorkerRow,
+    refreshTagsFromIndex,
+  } = createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCwds });
 
   function wantsSessionScan(args = {}) {
     return args.recover === true || args.scanSessions === true || args.scan_sessions === true;
@@ -1025,95 +785,11 @@ export function createStandaloneAgent({
     }, notifyContext);
   }
 
-  const progressWatchdogs = new Map();
-  let progressWatchdogTimer = null;
-
-  function stopProgressWatchdogTimerIfIdle() {
-    if (progressWatchdogs.size > 0 || !progressWatchdogTimer) return;
-    try { clearInterval(progressWatchdogTimer); } catch {}
-    progressWatchdogTimer = null;
-  }
-
-  function checkProgressIdleWatchdog(state) {
-    const {
-      sessionId,
-      watchdogPolicy,
-      agent,
-      controller,
-      anchorTs,
-    } = state;
-    if (controller.signal?.aborted) {
-      progressWatchdogs.delete(sessionId);
-      stopProgressWatchdogTimerIfIdle();
-      return;
-    }
-    const now = Date.now();
-    const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
-      ? mgr.getSessionProgressSnapshot(sessionId)
-      : null;
-    const abortErr = snapshot
-      ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy)
-      : null;
-    const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
-    const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
-    if (!abortErr && !snapshot) {
-      const reported = mgr.getSessionLastProgressAt(sessionId);
-      const last = reported || anchorTs;
-      if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
-        abortAgentProgressWatchdog(controller, {
-          sessionId,
-          agent,
-          error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
-          policy: watchdogPolicy,
-          now,
-          anchorTs,
-          lastProgressAt: reported,
-          iteration,
-        });
-      }
-      return;
-    }
-    if (abortErr) {
-      abortAgentProgressWatchdog(controller, {
-        sessionId,
-        agent,
-        error: abortErr,
-        snapshot,
-        policy: watchdogPolicy,
-        now,
-        anchorTs,
-        iteration,
-      });
-    }
-  }
-
-  function ensureProgressWatchdogTimer() {
-    if (progressWatchdogTimer || progressWatchdogs.size === 0) return;
-    progressWatchdogTimer = setInterval(() => {
-      for (const state of [...progressWatchdogs.values()]) {
-        checkProgressIdleWatchdog(state);
-      }
-    }, 1000);
-    progressWatchdogTimer.unref?.();
-  }
-
-  function startProgressIdleWatchdog(sessionId, watchdogPolicy, agent = null) {
-    if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
-    if (typeof mgr.getSessionProgressSnapshot !== 'function' && typeof mgr.getSessionLastProgressAt !== 'function') return null;
-    if (typeof mgr.linkParentSignalToSession !== 'function') return null;
-    const controller = new AbortController();
-    const anchorTs = Date.now();
-    try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
-    const state = { sessionId, watchdogPolicy, agent, controller, anchorTs };
-    progressWatchdogs.set(sessionId, state);
-    ensureProgressWatchdogTimer();
-    return {
-      stop: () => {
-        if (progressWatchdogs.get(sessionId) === state) progressWatchdogs.delete(sessionId);
-        stopProgressWatchdogTimerIfIdle();
-      },
-    };
-  }
+  // Idle-progress watchdogs (shared sweep timer) live in
+  // agent-watchdog-registry.mjs.
+  const progressWatchdogs = createProgressWatchdogRegistry({ mgr });
+  const startProgressIdleWatchdog = (sessionId, watchdogPolicy, agent = null) =>
+    progressWatchdogs.start(sessionId, watchdogPolicy, agent);
 
   async function prepareSpawn(args, callerCwd = null, context = {}, prepState = null) {
     refreshTagsFromSessions({ context });
@@ -1824,4 +1500,4 @@ export function createStandaloneAgent({
     },
     closeAll,
   };
-}
+}

package/src/standalone/agent-watchdog-registry.mjs

@@ -0,0 +1,101 @@
+// Idle-progress watchdogs for running agent sessions, extracted from
+// agent-tool.mjs. One shared 1s timer sweeps every watched session, so a burst
+// of agents costs a single interval; the timer stops as soon as the last
+// watchdog is released. Abort policy itself lives in the runtime module.
+import {
+  abortAgentProgressWatchdog,
+  agentWatchdogPolicyActive,
+  evaluateAgentWatchdogAbort,
+  AgentStallAbortError,
+} from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+
+const WATCHDOG_SWEEP_INTERVAL_MS = 1000;
+
+export function createProgressWatchdogRegistry({ mgr }) {
+  const watched = new Map();
+  let timer = null;
+
+  function stopTimerIfIdle() {
+    if (watched.size > 0 || !timer) return;
+    try { clearInterval(timer); } catch {}
+    timer = null;
+  }
+
+  function check(state) {
+    const { sessionId, watchdogPolicy, agent, controller, anchorTs } = state;
+    if (controller.signal?.aborted) {
+      watched.delete(sessionId);
+      stopTimerIfIdle();
+      return;
+    }
+    const now = Date.now();
+    const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
+      ? mgr.getSessionProgressSnapshot(sessionId)
+      : null;
+    const abortErr = snapshot ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy) : null;
+    const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
+    const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
+    // No progress snapshot: fall back to the coarse last-progress timestamp so a
+    // session that never reports structured progress can still stall out.
+    if (!abortErr && !snapshot) {
+      const reported = mgr.getSessionLastProgressAt(sessionId);
+      const last = reported || anchorTs;
+      if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
+        abortAgentProgressWatchdog(controller, {
+          sessionId,
+          agent,
+          error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
+          policy: watchdogPolicy,
+          now,
+          anchorTs,
+          lastProgressAt: reported,
+          iteration,
+        });
+      }
+      return;
+    }
+    if (abortErr) {
+      abortAgentProgressWatchdog(controller, {
+        sessionId,
+        agent,
+        error: abortErr,
+        snapshot,
+        policy: watchdogPolicy,
+        now,
+        anchorTs,
+        iteration,
+      });
+    }
+  }
+
+  function ensureTimer() {
+    if (timer || watched.size === 0) return;
+    timer = setInterval(() => {
+      for (const state of [...watched.values()]) check(state);
+    }, WATCHDOG_SWEEP_INTERVAL_MS);
+    timer.unref?.();
+  }
+
+  return {
+    /** Watch a session until the returned handle is stopped; null when the
+     *  policy is off or the manager cannot link an abort signal. */
+    start(sessionId, watchdogPolicy, agent = null) {
+      if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
+      if (typeof mgr.getSessionProgressSnapshot !== 'function'
+        && typeof mgr.getSessionLastProgressAt !== 'function') return null;
+      if (typeof mgr.linkParentSignalToSession !== 'function') return null;
+      const controller = new AbortController();
+      const anchorTs = Date.now();
+      try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
+      const state = { sessionId, watchdogPolicy, agent, controller, anchorTs };
+      watched.set(sessionId, state);
+      ensureTimer();
+      return {
+        stop: () => {
+          if (watched.get(sessionId) === state) watched.delete(sessionId);
+          stopTimerIfIdle();
+        },
+      };
+    },
+  };
+}

package/src/standalone/channel-admin.mjs

@@ -38,6 +38,7 @@ import {
   deleteEndpoint as dbDeleteEndpoint,
   setEndpointEnabled as dbSetEndpointEnabled,
 } from '../runtime/shared/webhooks-db.mjs';
+import { normalizeAutomationAttachments } from '../runtime/shared/automation-attachments.mjs';
 import { readHookPublicBase } from '../runtime/channels/lib/webhook/relay-tunnel.mjs';
 
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
@@ -358,6 +359,11 @@ function scheduleToDisplay(s) {
     channel: s.channelId || undefined,
     model: s.model || undefined,
     cwd: s.cwd || undefined,
+    workflow: s.workflow || undefined,
+    attachments: s.attachments || undefined,
+    // Delivery mode: legacy channel-target rows (pre-delivery) behaved as
+    // relay+visible, which maps to 'both'.
+    delivery: s.delivery || (s.target === 'channel' ? 'both' : 'app'),
     enabled: s.enabled !== false,
     instructions: s.prompt,
     route: s.target === 'channel' ? `channel:${s.channelId}` : 'session',
@@ -383,6 +389,9 @@ export async function saveSchedule({
   channel,
   model,
   cwd,
+  workflow,
+  attachments,
+  delivery,
   enabled,
   instructions,
   overwrite = false,
@@ -391,6 +400,11 @@ export async function saveSchedule({
   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');
+  // 'app' → session-only; 'channel'/'both' → the run result relays to the
+  // main channel (target 'channel', channelId resolved at fire time).
+  const mode = ['app', 'channel', 'both'].includes(String(delivery || '').trim())
+    ? String(delivery).trim()
+    : (channel ? 'both' : 'app');
   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');
@@ -406,10 +420,13 @@ export async function saveSchedule({
     whenCron,
     whenAt,
     timezone: timezone ? String(timezone).trim() : null,
-    target: channel ? 'channel' : 'session',
+    target: mode === 'app' ? 'session' : 'channel',
     channelId: channel ? String(channel).trim() : null,
     model: model ? String(model).trim() : null,
     cwd: cwd ? String(cwd).trim() : null,
+    workflow: workflow ? String(workflow).trim() : null,
+    attachments: normalizeAutomationAttachments(attachments),
+    delivery: mode,
     prompt: body,
     enabled: enabled !== false,
   });
@@ -441,6 +458,10 @@ async function listWebhooks() {
     parser: ep.parser || 'github',
     ...(ep.channelId ? { channel: ep.channelId } : {}),
     ...(ep.model ? { model: ep.model } : {}),
+    ...(ep.cwd ? { cwd: ep.cwd } : {}),
+    ...(ep.workflow ? { workflow: ep.workflow } : {}),
+    ...(ep.attachments ? { attachments: ep.attachments } : {}),
+    delivery: ep.delivery || 'app',
     enabled: ep.enabled,
     // The store never projects the plaintext secret through list paths; it
     // exposes a presence flag (secretSet) instead.
@@ -458,6 +479,10 @@ export async function saveWebhook({
   secret,
   channel,
   model,
+  cwd,
+  workflow,
+  attachments,
+  delivery,
   enabled,
   instructions,
   overwrite = false,
@@ -486,6 +511,12 @@ export async function saveWebhook({
     parser: nextParser,
     channelId: channel ? String(channel).trim() : null,
     model: model ? String(model).trim() : null,
+    cwd: cwd ? String(cwd).trim() : null,
+    workflow: workflow ? String(workflow).trim() : null,
+    attachments: normalizeAutomationAttachments(attachments),
+    delivery: ['app', 'channel', 'both'].includes(String(delivery || '').trim())
+      ? String(delivery).trim()
+      : 'app',
     secret: secretValue,
     instructions: body,
     enabled: enabled !== false,
@@ -496,6 +527,10 @@ export async function saveWebhook({
     parser: saved.parser,
     ...(saved.channelId ? { channel: saved.channelId } : {}),
     ...(saved.model ? { model: saved.model } : {}),
+    ...(saved.cwd ? { cwd: saved.cwd } : {}),
+    ...(saved.workflow ? { workflow: saved.workflow } : {}),
+    ...(saved.attachments ? { attachments: saved.attachments } : {}),
+    delivery: saved.delivery || 'app',
     ...(enabled === false ? { enabled: false } : {}),
     secret: secretValue,
     instructions: body,

package/src/standalone/channel-daemon-client.mjs

@@ -147,7 +147,11 @@ export async function attachToDaemon({
       token: serverToken,
       method: 'POST',
       path: '/client/register',
-      body: { leadPid, cwd },
+      // Initial attachment is transport-only. Mark it with the legacy
+      // non-stealing registration intent as well as relying on the current
+      // daemon contract, so a newly updated desktop cannot supersede a
+      // terminal still served by an older machine-global daemon.
+      body: { leadPid, cwd, reattach: true },
       timeoutMs: 3000,
     });
   } catch (err) {