mixdog 0.9.67 → 0.9.68

package/src/runtime/shared/automation-workflow.mjs

@@ -0,0 +1,41 @@
+/**
+ * Resolve a stored automation workflow id (schedule/webhook row) into
+ * createSession options: the workflow summary meta plus the WORKFLOW.md
+ * context block, exactly like a desktop New task session gets for the
+ * active workflow. An empty/unknown id resolves to the default pack via
+ * loadWorkflowPack's fallback; resolution failures degrade to no workflow
+ * context (the session still runs with the base lead ruleset).
+ */
+import { createWorkflowHelpers } from '../../session-runtime/workflow.mjs';
+import { STANDALONE_ROOT, STANDALONE_DATA_DIR } from '../../session-runtime/runtime-paths.mjs';
+import { readMarkdownDocument, normalizeAgentPermissionOrNone } from './markdown-frontmatter.mjs';
+
+let _helpers = null;
+function helpers() {
+  if (!_helpers) {
+    _helpers = createWorkflowHelpers({
+      rootDir: STANDALONE_ROOT,
+      dataDir: STANDALONE_DATA_DIR,
+      readMarkdownDocument,
+      normalizeAgentPermissionOrNone,
+    });
+  }
+  return _helpers;
+}
+
+/** { workflow, workflowContext } createSession opts for a workflow id, or {} when unset/unresolvable. */
+export function automationWorkflowOpts(workflowId) {
+  const id = String(workflowId || '').trim();
+  if (!id) return {};
+  try {
+    const h = helpers();
+    const pack = h.loadWorkflowPack(undefined, id);
+    if (!pack) return {};
+    return {
+      workflow: h.workflowSummary(pack),
+      workflowContext: h.workflowContextBlock({ workflow: { active: id } }, undefined),
+    };
+  } catch {
+    return {};
+  }
+}

package/src/runtime/shared/schedule-session-run.mjs

@@ -10,6 +10,8 @@ import { loadConfig } from '../agent/orchestrator/config.mjs';
 import { createSession } from '../agent/orchestrator/session/manager/session-lifecycle.mjs';
 import { askSession } from '../agent/orchestrator/session/manager/ask-session.mjs';
 import { parseScheduleModelRef } from './schedule-model-ref.mjs';
+import { automationWorkflowOpts } from './automation-workflow.mjs';
+import { automationPromptContent } from './automation-attachments.mjs';
 
 /** Resolve schedule.model into a {provider,model,effort?,fast?} route. */
 function scheduleRouteFromModelRef(modelRef, config = null) {
@@ -43,6 +45,9 @@ export async function runScheduleSession(schedule, { config = null, prompt: prom
   }
   const route = scheduleRouteFromModelRef(schedule.model, config);
   const cwd = schedule.cwd ? String(schedule.cwd) : null;
+  // Every fire is a fresh New task (user decision): one prompt, the
+  // schedule's model/workflow/project, a brand-new session in the sidebar
+  // Automations section (newest per name wins there).
   const session = createSession({
     provider: route.provider,
     model: route.model,
@@ -51,13 +56,17 @@ export async function runScheduleSession(schedule, { config = null, prompt: prom
     owner: 'user',
     sourceType: 'schedule',
     sourceName: schedule.name,
+    sourceDelivery: schedule.delivery || null,
     ...(cwd ? { cwd } : {}),
     desktopSession: cwd
       ? { classification: 'project', projectPath: cwd }
       : { classification: 'task', projectPath: null },
+    ...automationWorkflowOpts(schedule.workflow),
   });
   // The user message is the schedule's instructions verbatim: the desktop
   // title/preview derive from it, so no "[Scheduled task: …]" header noise.
-  const result = await askSession(session.id, prompt, null, null, cwd || undefined);
+  // Stored attachments ride along as composer-style content parts.
+  const content = automationPromptContent(prompt, schedule.attachments);
+  const result = await askSession(session.id, content, null, null, cwd || undefined);
   return { sessionId: session.id, result: String(result?.content || '') };
 }

package/src/runtime/shared/schedules-db.mjs

@@ -33,6 +33,9 @@ CREATE TABLE IF NOT EXISTS scheduler.schedules (
   channel_id     text,
   model          text,
   cwd            text,
+  workflow       text,
+  attachments    jsonb,
+  delivery       text,
   prompt         text NOT NULL,
   enabled        boolean NOT NULL DEFAULT true,
   status         text NOT NULL DEFAULT 'active' CHECK (status IN ('active','done')),
@@ -45,6 +48,9 @@ CREATE TABLE IF NOT EXISTS scheduler.schedules (
   CONSTRAINT schedules_when_xor CHECK ((when_at IS NOT NULL) <> (when_cron IS NOT NULL))
 );
 ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS cwd text;
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS workflow text;
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS attachments jsonb;
+ALTER TABLE scheduler.schedules ADD COLUMN IF NOT EXISTS delivery text;
 `;
 
 async function getDb(dataDir = resolvePluginData()) {
@@ -82,6 +88,9 @@ function rowToDef(row) {
     channelId:     row.channel_id,
     model:         row.model,
     cwd:           row.cwd,
+    workflow:      row.workflow,
+    attachments:   row.attachments || null,
+    delivery:      row.delivery || null,
     prompt:        row.prompt,
     enabled:       row.enabled,
     status:        row.status,
@@ -94,7 +103,7 @@ function rowToDef(row) {
   };
 }
 
-const COLS = 'name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, prompt, enabled, status, last_fired_at, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
+const COLS = 'name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, workflow, attachments, delivery, prompt, enabled, status, last_fired_at, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
 
 // ---------------------------------------------------------------------------
 // Public API
@@ -130,6 +139,9 @@ export async function upsertSchedule(def, { dataDir } = {}) {
     def.channelId ?? null,
     def.model ?? null,
     def.cwd ?? null,
+    def.workflow ?? null,
+    def.attachments ? JSON.stringify(def.attachments) : null,
+    def.delivery ?? null,
     def.prompt,
     def.enabled ?? true,
     def.status ?? 'active',
@@ -137,8 +149,8 @@ export async function upsertSchedule(def, { dataDir } = {}) {
   ];
   const { rows } = await db.query(
     `INSERT INTO scheduler.schedules
-       (name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, prompt, enabled, status, next_fire_at)
-     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)
+       (name, description, when_at, when_cron, timezone, target, channel_id, model, cwd, workflow, attachments, delivery, prompt, enabled, status, next_fire_at)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)
      ON CONFLICT (name) DO UPDATE SET
        description  = EXCLUDED.description,
        when_at      = EXCLUDED.when_at,
@@ -148,6 +160,9 @@ export async function upsertSchedule(def, { dataDir } = {}) {
        channel_id   = EXCLUDED.channel_id,
        model        = EXCLUDED.model,
        cwd          = EXCLUDED.cwd,
+       workflow     = EXCLUDED.workflow,
+       attachments  = EXCLUDED.attachments,
+       delivery     = EXCLUDED.delivery,
        prompt       = EXCLUDED.prompt,
        enabled      = EXCLUDED.enabled,
        next_fire_at = EXCLUDED.next_fire_at,

package/src/runtime/shared/webhook-session-run.mjs

@@ -0,0 +1,57 @@
+/**
+ * Run an inbound webhook as a VISIBLE Mixdog session (schedules parity, user
+ * decision): no Lead-context injection, no channel forward — every fire is a
+ * fresh New task with the endpoint's prompt/model/workflow/project, owned by
+ * 'user' + sourceType 'webhook' (sidebar Automations section, newest per
+ * name). Invoked from the channels worker's webhook dispatch.
+ */
+import { loadConfig } from '../agent/orchestrator/config.mjs';
+import { createSession } from '../agent/orchestrator/session/manager/session-lifecycle.mjs';
+import { askSession } from '../agent/orchestrator/session/manager/ask-session.mjs';
+import { parseScheduleModelRef } from './schedule-model-ref.mjs';
+import { automationWorkflowOpts } from './automation-workflow.mjs';
+import { automationPromptContent } from './automation-attachments.mjs';
+
+/** Endpoint model ref wins; the maintenance.webhook route is the fallback. */
+function webhookRoute(modelRef) {
+  if (modelRef) {
+    const ref = parseScheduleModelRef(modelRef);
+    if (ref && typeof ref === 'object') return ref;
+  }
+  const cfg = loadConfig({ secrets: false });
+  const maintenance = cfg?.maintenance?.webhook;
+  if (maintenance?.provider && maintenance?.model) {
+    return { provider: maintenance.provider, model: maintenance.model };
+  }
+  throw new Error('webhook run has no model: set one on the endpoint or configure maintenance.webhook');
+}
+
+export async function runWebhookSession({ name, model = null, prompt, cwd = null, workflow = null, attachments = null, delivery = null }) {
+  const endpoint = String(name || '').trim();
+  const body = String(prompt || '').trim();
+  if (!endpoint) throw new Error('runWebhookSession: endpoint name required');
+  if (!body) throw new Error(`webhook "${endpoint}" has no prompt body`);
+  const route = webhookRoute(model);
+  const projectCwd = cwd ? String(cwd) : null;
+  const session = createSession({
+    provider: route.provider,
+    model: route.model,
+    ...(route.effort ? { effort: route.effort } : {}),
+    ...(route.fast === true ? { fast: true } : {}),
+    owner: 'user',
+    sourceType: 'webhook',
+    sourceName: endpoint,
+    sourceDelivery: delivery || null,
+    ...(projectCwd ? { cwd: projectCwd } : {}),
+    desktopSession: projectCwd
+      ? { classification: 'project', projectPath: projectCwd }
+      : { classification: 'task', projectPath: null },
+    ...automationWorkflowOpts(workflow),
+  });
+  // The user message leads with the endpoint's instructions, so Recent titles
+  // read as the user-authored intent rather than payload noise.
+  // Stored attachments ride along as composer-style content parts.
+  const content = automationPromptContent(body, attachments);
+  const result = await askSession(session.id, content, null, null, projectCwd || undefined);
+  return { sessionId: session.id, result: String(result?.content || '') };
+}

package/src/runtime/shared/webhooks-db.mjs

@@ -40,6 +40,10 @@ CREATE TABLE IF NOT EXISTS webhooks.endpoints (
   created_at   timestamptz NOT NULL DEFAULT now(),
   updated_at   timestamptz NOT NULL DEFAULT now()
 );
+ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS cwd text;
+ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS workflow text;
+ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS attachments jsonb;
+ALTER TABLE webhooks.endpoints ADD COLUMN IF NOT EXISTS delivery text;
 CREATE TABLE IF NOT EXISTS webhooks.deliveries (
   endpoint        text NOT NULL,
   delivery_id     text NOT NULL,
@@ -77,7 +81,7 @@ async function getDb(dataDir = resolvePluginData()) {
 // Row <-> def mapping
 // ---------------------------------------------------------------------------
 
-const ENDPOINT_COLS = 'name, description, channel_id, role, model, parser, secret, instructions, enabled, created_at, updated_at';
+const ENDPOINT_COLS = 'name, description, channel_id, role, model, parser, secret, cwd, workflow, attachments, delivery, instructions, enabled, created_at, updated_at';
 
 function rowToEndpoint(row) {
   if (!row) return null;
@@ -88,6 +92,10 @@ function rowToEndpoint(row) {
     role:         row.role,
     model:        row.model,
     parser:       row.parser,
+    cwd:          row.cwd,
+    workflow:     row.workflow,
+    attachments:  row.attachments || null,
+    delivery:     row.delivery || null,
     // Never project the plaintext secret through list/load config paths;
     // callers get a presence flag and must fetch the value via
     // readEndpointSecret (the single, explicit secret-read path).
@@ -165,13 +173,17 @@ export async function upsertEndpoint(def, { dataDir } = {}) {
     def.model ?? null,
     def.parser ?? null,
     def.secret ?? null,
+    def.cwd ?? null,
+    def.workflow ?? null,
+    def.attachments ? JSON.stringify(def.attachments) : null,
+    def.delivery ?? null,
     def.instructions ?? '',
     def.enabled ?? true,
   ];
   const { rows } = await db.query(
     `INSERT INTO webhooks.endpoints
-       (name, description, channel_id, role, model, parser, secret, instructions, enabled)
-     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
+       (name, description, channel_id, role, model, parser, secret, cwd, workflow, attachments, delivery, instructions, enabled)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)
      ON CONFLICT (name) DO UPDATE SET
        description  = EXCLUDED.description,
        channel_id   = EXCLUDED.channel_id,
@@ -179,6 +191,10 @@ export async function upsertEndpoint(def, { dataDir } = {}) {
        model        = EXCLUDED.model,
        parser       = EXCLUDED.parser,
        secret       = EXCLUDED.secret,
+       cwd          = EXCLUDED.cwd,
+       workflow     = EXCLUDED.workflow,
+       attachments  = EXCLUDED.attachments,
+       delivery     = EXCLUDED.delivery,
        instructions = EXCLUDED.instructions,
        enabled      = EXCLUDED.enabled,
        updated_at   = now()

package/src/session-runtime/channel-config-api.mjs

@@ -17,7 +17,7 @@ import { runScheduleSession } from '../runtime/shared/schedule-session-run.mjs';
 // API object; the mutating admin helpers are imported directly here and the
 // runtime injects only the closure-owned callbacks (backend flush, channel
 // worker handle, soft reload).
-export function createChannelConfigApi({ flushBackendSave, channels, reloadChannelsSoon }) {
+export function createChannelConfigApi({ flushBackendSave, channels, reloadChannelsSoon, ensureAutomationRuntime = () => {} }) {
   return {
     async getChannelSetup() {
       // Flush a pending debounced backend switch first so setup readers
@@ -42,6 +42,10 @@ export function createChannelConfigApi({ flushBackendSave, channels, reloadChann
     async saveSchedule(entry) {
       const result = await saveSchedule(entry);
       reloadChannelsSoon();
+      // First automation created while the app is already running: the boot-
+      // time autostart check has passed, so kick the worker start path now
+      // (no-op when it is already up).
+      ensureAutomationRuntime();
       return result;
     },
     async deleteSchedule(name) {
@@ -52,11 +56,13 @@ export function createChannelConfigApi({ flushBackendSave, channels, reloadChann
     async setScheduleEnabled(name, enabled) {
       const result = await setScheduleEnabled(name, enabled);
       reloadChannelsSoon();
+      if (enabled !== false) ensureAutomationRuntime();
       return result;
     },
     async saveWebhook(entry) {
       const result = await saveWebhook(entry);
       reloadChannelsSoon();
+      ensureAutomationRuntime();
       return result;
     },
     async deleteWebhook(name) {
@@ -67,6 +73,7 @@ export function createChannelConfigApi({ flushBackendSave, channels, reloadChann
     async setWebhookEnabled(name, enabled) {
       const result = await setWebhookEnabled(name, enabled);
       reloadChannelsSoon();
+      if (enabled !== false) ensureAutomationRuntime();
       return result;
     },
     // Read-only secret fetch for the webhook editor; no worker reload.

package/src/session-runtime/lifecycle-api.mjs

@@ -69,6 +69,9 @@ export function createLifecycleApi(deps) {
       // Recent / TUI resume next to lead sessions instead of hiding like
       // agent dispatches.
       || sourceType === 'schedule'
+      // Webhook fires run as visible sessions too (user decision: no Lead
+      // injection — the session row IS the notification).
+      || sourceType === 'webhook'
       || (!sourceType && !sourceName && !isAgentOwner(owner));
     if (!leadish) return null;
     const rawPreview = s.preview || '';
@@ -106,6 +109,10 @@ export function createLifecycleApi(deps) {
       // after a turn had already finished.
       heartbeatAt: Number(heartbeatMtimes.get(s.id)) || 0,
       desktopSession: s.desktopSession || null,
+      // Automation origin: lets the desktop group schedule/webhook runner
+      // sessions under the sidebar Automations section instead of Recent.
+      sourceType: sourceType || null,
+      sourceName: clean(s.sourceName || '') || null,
     };
     }).filter(Boolean);
   };

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

@@ -329,6 +329,11 @@ export async function createMixdogSessionRuntime({
   // past its remoteEnabled guards without prematurely showing this session as
   // remote (single-holder: a live owner must not be stolen by autoStart).
   let remoteClaimPending = false;
+  // SESSION-SCOPED remote (user decision): the session that toggled remote
+  // OWNS the channel relay. Other sessions' turns never rebind or relay; a
+  // dead/replaced owner (clear, delete) hands the seat to the next current
+  // session that asks.
+  let remoteSessionId = null;
   // Remote-mode transcript writer (Discord outbound). Lazily created per
   // session.id + cwd inside ask(); only active while remoteEnabled.
   let _transcriptWriter = null;
@@ -1032,6 +1037,7 @@ export async function createMixdogSessionRuntime({
         // would re-fork/activate). Idempotent: no-op when already enabled.
         if (msg?.params?.state === 'acquired' && !remoteEnabled) {
           remoteEnabled = true;
+          if (!remoteSessionId) remoteSessionId = session?.id || null;
           ensureRemoteTranscriptWriter();
           // Auto-acquire: the worker restored yesterday's transcript from
           // persisted status and we just created the CURRENT writer. Push the
@@ -1719,6 +1725,16 @@ export async function createMixdogSessionRuntime({
   // when a writer is bound.
   function ensureRemoteTranscriptWriter() {
     if (!remoteEnabled || !session?.id) return false;
+    // Owner gate: late adopt covers lazy create (owner unknown at /remote
+    // time); a live owner blocks every other session; a dead owner (cleared
+    // or deleted session) hands the relay to the current session.
+    if (!remoteSessionId) {
+      remoteSessionId = session.id;
+    } else if (session.id !== remoteSessionId) {
+      const owner = mgr.getSession(remoteSessionId);
+      if (owner && owner.closed !== true && owner.status !== 'closed') return false;
+      remoteSessionId = session.id;
+    }
     const twKey = `${session.id}\u0000${currentCwd}`;
     if (_twKey !== twKey) {
       try {
@@ -1826,6 +1842,9 @@ export async function createMixdogSessionRuntime({
       remoteClaimPending = true;
     } else {
       remoteEnabled = true;
+      // Explicit toggle: the CURRENT session owns the relay (lazy create
+      // adopts inside ensureRemoteTranscriptWriter when no session exists yet).
+      remoteSessionId = session?.id || null;
     }
     // Boot the memory daemon eagerly. The channels worker forwards
     // transcript ingests/entries to the memory HTTP service, whose port is
@@ -1937,23 +1956,63 @@ export async function createMixdogSessionRuntime({
         else process.env.MIXDOG_REMOTE_INTENT = _prevIntent;
       }
       if ((!remoteEnabled && !remoteClaimPending) || closeRequested) { remoteClaimPending = false; return; }
-      // Explicit start: unconditional claim + forwarder rebind (last-wins seat
-      // overwrite + transcript rebind onto this session). AUTO start SKIPS this
-      // — the freshly-forked worker already ran its claim-if-vacant boot claim,
-      // and forcing activate here would steal a live owner that autoStart is
-      // meant to yield to. The worker's acquire notification drives remote ON.
-      if (intent !== 'auto') {
-        await channels.execute('activate_channel_bridge', { active: true });
-      }
+      // Explicit claims are unconditional. Auto-start dispatches the same
+      // activation as claim-if-vacant so it can promote an existing
+      // automation-only daemon without stealing a live remote owner.
+      await channels.execute('activate_channel_bridge', {
+        active: true,
+        claimIfVacant: intent === 'auto',
+        sessionId: session?.id || remoteSessionId || null,
+        transcriptPath: _transcriptWriter?.transcriptPath || null,
+      });
       // Claim attempt dispatched; the worker's acquire/supersede notification
       // now owns the remoteEnabled transition. Drop the transient marker.
       remoteClaimPending = false;
-    })().catch((error) => { remoteClaimPending = false; bootProfile('channels:claim-failed', { error: error?.message || String(error) }); });
+    })().catch((error) => {
+      remoteClaimPending = false;
+      if (remoteEnabled) {
+        remoteEnabled = false;
+        remoteSessionId = null;
+        channels.stop('remote-claim-failed').catch(() => {});
+        emitRemoteStateChange(false, 'claim-failed');
+      }
+      bootProfile('channels:claim-failed', { error: error?.message || String(error) });
+    });
     return true;
   }
 
+  // Explicit user OFF is a desired-state command, not a toggle retry. Ask the
+  // daemon to deactivate the machine-global bridge before detaching this
+  // client; the call runs in the background so the UI never waits through a
+  // daemon spawn/reconnect window. Repeated releases remain idempotent.
+  function releaseRemote(reason) {
+    const releasingSessionId = remoteSessionId || session?.id || null;
+    remoteEnabled = false;
+    remoteSessionId = null;
+    remoteClaimPending = false;
+    if (prewarmTimers.channelStartTimer) {
+      clearTimeout(prewarmTimers.channelStartTimer);
+      prewarmTimers.channelStartTimer = null;
+    }
+    void (async () => {
+      try {
+        await channels.execute('activate_channel_bridge', {
+          active: false,
+          sessionId: releasingSessionId,
+        });
+      } catch (error) {
+        bootProfile('channels:release-failed', { error: error?.message || String(error) });
+        emitRemoteStateChange(false, 'release-failed');
+      } finally {
+        await channels.stop(reason || 'remote-disabled').catch(() => {});
+      }
+    })();
+    return false;
+  }
+
   function stopRemote(reason) {
     remoteEnabled = false;
+    remoteSessionId = null;
     // A pending auto-claim is abandoned by an explicit stop/supersede.
     remoteClaimPending = false;
     // Cancel any pending deferred start so it can't fire after remote is off.
@@ -2008,8 +2067,11 @@ export async function createMixdogSessionRuntime({
   // Channels are opt-in: only boot the worker when this session started in (or
   // was toggled into) remote mode. Non-remote sessions never contend for the
   // channel; see startRemote()/stopRemote() and the `/remote` toggle.
-  // `remote.autoStart` in mixdog-config.json makes every session claim remote
-  // at boot (same force-takeover semantics as `mixdog --remote` / `/remote`).
+  // `remote.autoStart` in mixdog-config.json makes terminal sessions attempt a
+  // remote claim at boot. Desktop sessions are explicit-only: opening the app
+  // must never claim or spawn the channel bridge until its Remote button is
+  // pressed, while the shared owner-state watcher still reflects a terminal
+  // that already owns it.
   // The flag lives in the TOP-LEVEL `remote` section of mixdog-config.json
   // (sibling of agent/ui/channels), not inside the agent section that
   // cfgMod.loadConfig returns — read it via the shared whole-file reader.
@@ -2022,7 +2084,7 @@ export async function createMixdogSessionRuntime({
   // known to have won). Track it as a separate deferred auto request; the
   // worker's acquire notification flips remoteEnabled if/when it wins the seat.
   let remoteAutoStartRequested = false;
-  if (!remoteEnabled) {
+  if (!remoteEnabled && !desktopSession) {
     try {
       if (config?.remote?.autoStart === true
         || sharedCfgMod?.readSection?.('remote')?.autoStart === true) {
@@ -2054,9 +2116,9 @@ export async function createMixdogSessionRuntime({
     prewarmTimers.channelStartTimer.unref?.();
   } else {
     // Automation decoupling (user decision): enabled schedules/webhooks boot
-    // the worker on their own — no remote flag, no remote.autoStart, no
-    // messaging backend required. Claim-if-vacant auto intent reuses the
-    // exact autoStart semantics (a live owner elsewhere wins silently).
+    // the worker on their own — no remote flag, no remote.autoStart, and no
+    // messaging backend. A later explicit/auto Remote claim promotes the same
+    // daemon without restarting schedules or webhooks.
     prewarmTimers.channelStartTimer = setTimeout(() => {
       prewarmTimers.channelStartTimer = null;
       if (closeRequested || remoteEnabled) return;
@@ -2064,7 +2126,7 @@ export async function createMixdogSessionRuntime({
         .then((active) => {
           if (!active || closeRequested || remoteEnabled) return;
           bootProfile('channels:automation-autostart');
-          startRemote({ intent: 'auto' });
+          void invokeChannelStart();
         })
         .catch(() => { /* automation probe is best-effort */ });
     }, remoteAutoStartDelayMs);
@@ -2127,7 +2189,14 @@ export async function createMixdogSessionRuntime({
     setBackend,
   });
 
-  const channelConfigApi = createChannelConfigApi({ flushBackendSave, channels, reloadChannelsSoon });
+  const channelConfigApi = createChannelConfigApi({
+    flushBackendSave,
+    channels,
+    reloadChannelsSoon,
+    // Automation saved mid-session boots the worker (claim-if-vacant) even
+    // though the boot-time autostart window has already passed.
+    ensureAutomationRuntime: () => scheduleChannelStart(0),
+  });
   const providerAuthApi = createProviderAuthApi({
     cfgMod,
     getConfig: () => config,
@@ -2404,9 +2473,26 @@ export async function createMixdogSessionRuntime({
     stopRemote(reason) {
       return stopRemote(reason);
     },
+    releaseRemote(reason) {
+      return releaseRemote(reason);
+    },
     isRemoteEnabled() {
       return isRemoteEnabled();
     },
+    // Session-scoped remote: the owning session id (null when off/unassigned).
+    getRemoteSessionId() {
+      return remoteSessionId;
+    },
+    // Move the relay seat to the CURRENT session (last-wins within this
+    // engine): rebind the transcript writer + forwarder without restarting
+    // the worker. No-op when remote is off or no session exists.
+    claimRemoteForCurrentSession() {
+      if (!remoteEnabled || !session?.id) return false;
+      remoteSessionId = session.id;
+      ensureRemoteTranscriptWriter();
+      pushTranscriptRebind();
+      return true;
+    },
     // Subscribe to non-user-initiated remote flips (seat superseded). Returns
     // an unsubscribe function. TUI uses this to sync its Remote indicator and
     // show a "remote taken over" notice.

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