mixdog 0.9.66 → 0.9.68

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

@@ -2,6 +2,7 @@ import {
   channelSetup,
   deleteSchedule,
   deleteWebhook,
+  getWebhookSecret,
   setChannelAsync,
   saveSchedule,
   saveWebhook,
@@ -16,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
@@ -41,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) {
@@ -51,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) {
@@ -66,8 +73,13 @@ 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.
+    async getWebhookSecret(name) {
+      return getWebhookSecret(name);
+    },
     async runScheduleNow(name) {
       const id = String(name || '').trim();
       const schedule = await getSchedule(id);

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 || '';
@@ -89,6 +92,11 @@ export function createLifecycleApi(deps) {
     return {
       id: s.id,
       updatedAt: s.updatedAt,
+      // Conversation-activity timestamp for Recent ordering. Without this the
+      // desktop falls back to updatedAt, which detach/resume bookkeeping
+      // bumps — clicking a session reshuffled the sidebar (the row just left
+      // jumped to the top).
+      lastUsedAt: Number(s.lastUsedAt) || 0,
       cwd: s.cwd || '',
       model: s.model,
       provider: s.provider,
@@ -101,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/prewarm.mjs

@@ -15,6 +15,7 @@ export function createPrewarmSchedulers({
   getSession,
   isRemoteEnabled,
   channelsEnabled,
+  hasActiveAutomation,
   getCodeGraphModule,
   createCurrentSession,
   channels,
@@ -111,25 +112,30 @@ export function createPrewarmSchedulers({
       bootProfile('channels:start-skipped');
       return;
     }
-    if (!channelsEnabled()) {
-      bootProfile('channels:start-disabled');
-      return;
-    }
     if (timers.channelStartTimer || state.channelStartPromise || isCloseRequested()) return;
     bootProfile('channels:start-scheduled', { delayMs });
-    timers.channelStartTimer = setTimeout(() => {
+    timers.channelStartTimer = setTimeout(() => void (async () => {
       timers.channelStartTimer = null;
       if (isCloseRequested()) return;
+      // Channels-module and remote toggles gate MESSAGING; automation
+      // (enabled schedules/webhooks) keeps the worker boot alive — its
+      // backend runs headless when messaging is off or unconfigured.
+      const automation = await hasActiveAutomation().catch(() => false);
+      if (!channelsEnabled() && !automation) {
+        bootProfile('channels:start-disabled');
+        return;
+      }
       // A deferred start may straddle a stopRemote(); re-check before booting so
       // a turned-off session neither starts channels nor keeps rescheduling.
-      if (!isRemoteEnabled()) return;
+      if (!isRemoteEnabled() && !automation) return;
+      if (isCloseRequested()) return;
       if (getActiveTurnCount() > 0 || getSessionCreatePromise()) {
         bootProfile('channels:start-deferred', { reason: getActiveTurnCount() > 0 ? 'turn-active' : 'session-create' });
         scheduleChannelStart(backgroundBusyRetryMs);
         return;
       }
       void invokeChannelStart();
-    }, delayMs);
+    })(), delayMs);
     timers.channelStartTimer.unref?.();
   }
 

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

@@ -65,13 +65,12 @@ import {
   deleteWebhook,
   forgetDiscordToken,
   forgetTelegramToken,
-  forgetWebhookAuthtoken,
+  hasActiveAutomation,
   setChannel,
   saveDiscordToken,
   saveTelegramToken,
   saveSchedule,
   saveWebhook,
-  saveWebhookAuthtoken,
   setBackend,
   setBackendAsync,
   setScheduleEnabled,
@@ -330,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;
@@ -1033,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
@@ -1694,6 +1699,7 @@ export async function createMixdogSessionRuntime({
     getSession: () => session,
     isRemoteEnabled: () => remoteEnabled,
     channelsEnabled,
+    hasActiveAutomation,
     getCodeGraphModule,
     createCurrentSession,
     channels,
@@ -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
@@ -1884,10 +1903,6 @@ export async function createMixdogSessionRuntime({
       bootProfile('channels:start-skipped');
       return true;
     }
-    if (!channelsEnabled()) {
-      bootProfile('channels:start-disabled');
-      return true;
-    }
     if (closeRequested) return true;
     if (prewarmTimers.channelStartTimer) {
       clearTimeout(prewarmTimers.channelStartTimer);
@@ -1895,6 +1910,14 @@ export async function createMixdogSessionRuntime({
     }
     bootProfile('channels:start-scheduled', { delayMs: 0, immediate: true });
     void (async () => {
+      // Channels-module toggle gates MESSAGING only: automation (schedules/
+      // webhooks) still boots the worker — its backend runs headless when
+      // messaging is off or unconfigured (see channels/lib/config.mjs).
+      if (!channelsEnabled() && !(await hasActiveAutomation().catch(() => false))) {
+        bootProfile('channels:start-disabled');
+        remoteClaimPending = false;
+        return;
+      }
       // A backend switch may still be pending or writing asynchronously. Drain
       // it before the worker reads config; never race it with a sync lock wait.
       try { await flushBackendSave(); } catch {}
@@ -1933,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.
@@ -2004,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.
@@ -2018,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) {
@@ -2035,9 +2101,9 @@ export async function createMixdogSessionRuntime({
   // early /remote (startRemote clears it), stopRemote(), and close() all
   // cancel it through the existing clearTimeout paths. Runtime /remote calls
   // still start immediately (user-initiated, UI already painted).
+  const remoteAutoStartDelayMs = envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 });
   if (remoteEnabled || remoteAutoStartRequested) {
     const remoteStartIntent = remoteEnabled ? 'explicit' : 'auto';
-    const remoteAutoStartDelayMs = envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 });
     bootProfile('channels:autostart-deferred', { delayMs: remoteAutoStartDelayMs, intent: remoteStartIntent });
     prewarmTimers.channelStartTimer = setTimeout(() => {
       prewarmTimers.channelStartTimer = null;
@@ -2048,6 +2114,23 @@ export async function createMixdogSessionRuntime({
       startRemote({ intent: remoteStartIntent });
     }, remoteAutoStartDelayMs);
     prewarmTimers.channelStartTimer.unref?.();
+  } else {
+    // Automation decoupling (user decision): enabled schedules/webhooks boot
+    // 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;
+      void hasActiveAutomation()
+        .then((active) => {
+          if (!active || closeRequested || remoteEnabled) return;
+          bootProfile('channels:automation-autostart');
+          void invokeChannelStart();
+        })
+        .catch(() => { /* automation probe is best-effort */ });
+    }, remoteAutoStartDelayMs);
+    prewarmTimers.channelStartTimer.unref?.();
   }
 
   // Pure settings-delegate methods (onboarding status/skip, autoClear, profile,
@@ -2103,12 +2186,17 @@ export async function createMixdogSessionRuntime({
     forgetDiscordToken,
     saveTelegramToken,
     forgetTelegramToken,
-    saveWebhookAuthtoken,
-    forgetWebhookAuthtoken,
     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,
@@ -2385,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/session-runtime/session-text.mjs

@@ -39,6 +39,12 @@ const SYNTHETIC_SESSION_TEXT_PATTERNS = Object.freeze([
   /^\[mixdog-runtime\]/i,
   /^\[(?:truncated|request interrupted by user)\]$/i,
   /^a previous model worked on this task and produced the compacted handoff summary below\b/i,
+  // Compact/auto-clear re-seed handoff variants: these lead the FIRST user
+  // message of every post-compaction session, so titling from them painted
+  // "Re-attached after compaction…" rows in Recent (user report). Skipping
+  // them titles the session from its first REAL user message instead.
+  /^re-attached after compaction\b/i,
+  /^reference files:\s/i,
   /^the async (?:agent|shell) task\b/i,
 ]);
 

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

@@ -56,8 +56,6 @@ export function createSettingsApi({
   forgetDiscordToken,
   saveTelegramToken,
   forgetTelegramToken,
-  saveWebhookAuthtoken,
-  forgetWebhookAuthtoken,
   setBackend,
 }) {
   return {
@@ -378,15 +376,5 @@ export function createSettingsApi({
       scheduleBackendSave(value);
       return { ok: true, backend: value };
     },
-    saveWebhookAuthtoken(token) {
-      const result = saveWebhookAuthtoken(token);
-      reloadChannelsSoon();
-      return result;
-    },
-    forgetWebhookAuthtoken() {
-      const result = forgetWebhookAuthtoken();
-      reloadChannelsSoon();
-      return result;
-    },
   };
 }