mixdog 1.3.5 → 1.4.0

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

@@ -1,15 +1,13 @@
-// Owned-runtime lifecycle: provider connect/disconnect, automation runtime
-// (scheduler + webhook/event runtime), ownership refresh and config
-// hot-reload. The phases live under owned-runtime/ and share one explicit
-// state object; config / provider / bridgeRuntimeConnected / webhookServer /
-// eventPipeline stay on the worker (get/set) so file-level reference
-// semantics are preserved.
+// Owned-runtime lifecycle: bridge activation, automation runtime (scheduler +
+// webhook/event runtime) and config hot-reload. The phases live under
+// owned-runtime/ and share one explicit state object; config /
+// bridgeRuntimeConnected / webhookServer / eventPipeline stay on the worker
+// (get/set) so file-level reference semantics are preserved.
 import { createOwnedRuntimeState } from './owned-runtime/state.mjs';
 import { createAutomationServices } from './owned-runtime/automation-services.mjs';
 import { createAutomationStarter } from './owned-runtime/automation-start.mjs';
 import { createOwnedStarter } from './owned-runtime/owned-start.mjs';
 import { createOwnedStopper } from './owned-runtime/owned-stop.mjs';
-import { createOwnershipRefresh } from './owned-runtime/ownership-refresh.mjs';
 import { createConfigReloader } from './owned-runtime/config-reload.mjs';
 
 export function createOwnedRuntime(deps) {
@@ -26,29 +24,14 @@ export function createOwnedRuntime(deps) {
     ...deps,
     state,
     services,
-    startAutomationRuntime,
     notifyRemoteAcquired,
   });
   const stopOwnedRuntime = createOwnedStopper({ ...deps, state, services });
-  const { refreshBridgeOwnership, refreshBridgeOwnershipSafe } = createOwnershipRefresh({
-    ...deps,
-    state,
-    startOwnedRuntime,
-    stopOwnedRuntime,
-  });
-  const reloadRuntimeConfig = createConfigReloader({
-    ...deps,
-    state,
-    services,
-    stopOwnedRuntime,
-    refreshBridgeOwnershipSafe,
-  });
+  const reloadRuntimeConfig = createConfigReloader({ ...deps, state, services });
   return {
     startAutomationRuntime,
     startOwnedRuntime,
     stopOwnedRuntime,
-    refreshBridgeOwnership,
-    refreshBridgeOwnershipSafe,
     reloadRuntimeConfig,
     notifyRemoteAcquired,
   };

package/src/runtime/channels/lib/parent-bridge.mjs

@@ -28,8 +28,8 @@ function setChannelNotifySink(fn) {
 function createParentBridge({ getInstanceId, ipcProcess = process }) {
   function sendNotifyToParent(method, params) {
     // The channel schema requires meta: Record<string,string>.
-    // Coerce every meta value to string so a non-string (e.g. a Discord
-    // interaction.type number) can't fail zod and silently drop the notify.
+    // Coerce every meta value to string so a non-string (e.g. a numeric
+    // meta field) can't fail zod and silently drop the notify.
     // silent_to_agent stays boolean — an internal routing flag the daemon
     // router / agentNotify consume (=== true) before the zod boundary.
     const outParams = normalizeChannelNotifyParams(method, params);

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -81,9 +81,9 @@ function activeInstanceStaleReason(state) {
   // NOTE: ownership is no longer decided here — the machine-global channels
   // daemon (singleton-owner lock in src/standalone) is the authority. This
   // PID-death check only marks a metadata advert whose owning process is gone so
-  // refreshActiveInstance can avoid preserving its owner fields. The former
-  // ui_heartbeat_at staleness branch was removed: its false-stale eviction was
-  // the Discord-flapping root cause.
+  // refreshActiveInstance can avoid preserving its owner fields. There is no
+  // ui_heartbeat_at staleness branch: its false-stale eviction wrongly dropped
+  // live owners.
   return null;
 }
 function buildRuntimeIdentity() {
@@ -126,11 +126,8 @@ function readActiveInstance() {
 /** Caller-supplied advert fields, in the order every writer publishes them. */
 function metaFields(meta) {
   return {
-    ...(meta?.channelId ? { channelId: meta.channelId } : {}),
     ...(meta?.transcriptPath ? { transcriptPath: meta.transcriptPath } : {}),
     ...(meta?.httpPort ? { httpPort: meta.httpPort } : {}),
-    ...Object.fromEntries(Object.entries(meta || {}).filter(([k]) => k.startsWith('gateway_'))),
-    ...(typeof meta?.providerReady === 'boolean' ? { providerReady: meta.providerReady } : {}),
   };
 }
 function buildActiveInstanceState(instanceId, meta) {
@@ -143,41 +140,6 @@ function buildActiveInstanceState(instanceId, meta) {
     ...metaFields(meta),
   };
 }
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return !(e && e.code === 'ESRCH');
-  }
-}
-// gateway_* fields are preserved while the gateway owner is alive: the gateway
-// child advertises itself independently, and active-owner heartbeats must not
-// erase that discovery record while its owning server-main process is still
-// alive. Writes into `preservedExtra` (and clears from `next`).
-function preserveGatewayFields(prev, meta, identity, preservedExtra, next) {
-  const prevGatewayServerPid = parsePositivePid(prev?.gateway_server_pid);
-  const prevGatewayOwnerAlive = prevGatewayServerPid !== null && isProcessAlive(prevGatewayServerPid);
-  const sameGatewayAdvertiser =
-    prevGatewayServerPid !== null && identity.server_pid !== null && prevGatewayServerPid === identity.server_pid;
-  if (!(sameGatewayAdvertiser || prevGatewayOwnerAlive)) return;
-  if (!prev || !Object.hasOwn(prev, 'gateway_port')) return;
-  for (const [key, value] of Object.entries(prev)) {
-    if (key.startsWith('gateway_')) preservedExtra[key] = value;
-  }
-  preservedExtra.gateway_server_pid = prevGatewayServerPid;
-  // Clear session-scoped gateway metrics when the transcript changes — a new
-  // session must not inherit the previous session's context usage before the
-  // gateway re-advertises.
-  const nonEmptyString = (value) => (typeof value === 'string' && value ? value : null);
-  const metricTranscript = nonEmptyString(prev.gateway_transcript_path) ?? nonEmptyString(prev.transcriptPath);
-  if (typeof meta?.transcriptPath === 'string' && meta.transcriptPath && metricTranscript !== meta.transcriptPath) {
-    delete preservedExtra.gateway_context_used_pct;
-    delete preservedExtra.gateway_last_usage;
-    delete next.gateway_context_used_pct;
-    delete next.gateway_last_usage;
-  }
-}
 function refreshActiveInstance(instanceId, meta, options) {
   ensureRuntimeDirs();
   // Periodic refresh/heartbeat callers pass options.timeoutMs:0 (try-once) so
@@ -237,7 +199,6 @@ function refreshActiveInstance(instanceId, meta, options) {
       const preservedExtra = Object.fromEntries(
         Object.entries(prevForPreserve ?? {}).filter(([k]) => k.startsWith('pg_'))
       );
-      preserveGatewayFields(prevForPreserve, meta, identity, preservedExtra, next);
       return { ...preservedExtra, ...next };
     },
     writeOpts
@@ -354,7 +315,7 @@ function cleanupInstanceRuntimeFiles(instanceId) {
   for (const target of targets) {
     removeFileIfExists(target);
   }
-  // Remove artifacts left by pre-standalone Discord approval builds.
+  // Remove per-instance permission artifacts left by pre-standalone builds.
   forEachFile(RUNTIME_ROOT, (fullPath, file) => {
     if (file.startsWith(`perm-${sanitize(instanceId)}-`)) {
       removeFileIfExists(fullPath);

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

@@ -115,8 +115,7 @@ function releaseSchedulerRuntime(scheduler) {
   releaseOwnedSchedulerLock();
 }
 class Scheduler {
-  nonInteractive;
-  interactive;
+  schedules;
   promptsDir;
   tickTimer = null;
   lastFired = /* @__PURE__ */ new Map();
@@ -124,65 +123,28 @@ class Scheduler {
   running = /* @__PURE__ */ new Set();
   // Names whose row is being renamed: no fire starts under them meanwhile.
   renaming = /* @__PURE__ */ new Set();
-  injectFn = null;
-  injectReadyFn = null;
-  pendingCheck = null;
   // Injected by the host: (schedule, { prompt }) => Promise<{ result }>.
   scheduleRunner = null;
-  // Activity tracking
-  lastActivity = 0;
-  // timestamp of last inbound message
   deferred = /* @__PURE__ */ new Map();
   // name -> deferred-until timestamp
   cronJobs = /* @__PURE__ */ new Map();
   // name -> node-cron ScheduledTask for cron-expression entries
   oneShotTimers = /* @__PURE__ */ new Map();
   // name -> setTimeout handle for when_at one-shot entries
-  constructor(nonInteractive, interactive) {
-    this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
-    this.interactive = interactive.filter((s) => s.enabled !== false);
+  constructor(schedules) {
+    this.schedules = schedules.filter((s) => s.enabled !== false);
     this.promptsDir = join(DATA_DIR, 'prompts');
-    for (const s of [...this.nonInteractive, ...this.interactive]) {
+    for (const s of this.schedules) {
       if (s.lastFiredAt) this.lastFired.set(s.name, new Date(s.lastFiredAt).toISOString());
     }
     this.refreshSkipCache();
   }
-  setInjectHandler(fn) {
-    this.injectFn = fn;
-  }
-  /** Probe for a live Lead bridge seat. When set, the interactive
-   *  inject only fires while it reports true; otherwise the visible-session
-   *  fallback keeps the fire from being lost. Unset → inject when wired. */
-  setInjectReadyCheck(fn) {
-    this.injectReadyFn = typeof fn === 'function' ? fn : null;
-  }
-  injectReady() {
-    if (!this.injectReadyFn) return true;
-    try {
-      return !!this.injectReadyFn();
-    } catch {
-      return false;
-    }
-  }
-  setPendingCheck(fn) {
-    this.pendingCheck = typeof fn === 'function' ? fn : null;
-  }
   setScheduleRunner(fn) {
     this.scheduleRunner = typeof fn === 'function' ? fn : null;
   }
-  noteActivity() {
-    this.lastActivity = Date.now();
-  }
-  /** Every loaded schedule with its routing type, non-interactive first. */
-  typedSchedules() {
-    return [
-      ...this.nonInteractive.map((schedule) => ({ schedule, type: 'non-interactive' })),
-      ...this.interactive.map((schedule) => ({ schedule, type: 'interactive' })),
-    ];
-  }
-  /** Find a loaded schedule def by name (either routing bucket). */
+  /** Find a loaded schedule def by name. */
   findSchedule(name) {
-    return [...this.nonInteractive, ...this.interactive].find((s) => s.name === name) ?? null;
+    return this.schedules.find((s) => s.name === name) ?? null;
   }
   /** Rebuild the in-memory deferred cache (used by the status snapshot) from
    *  the loaded rows' deferred_until values. Called on construct + reload so
@@ -190,7 +152,7 @@ class Scheduler {
   refreshSkipCache() {
     this.deferred.clear();
     const now = Date.now();
-    for (const s of [...this.nonInteractive, ...this.interactive]) {
+    for (const s of this.schedules) {
       const until = s.deferredUntil ? new Date(s.deferredUntil).getTime() : 0;
       if (until > now) this.deferred.set(s.name, until);
     }
@@ -237,56 +199,6 @@ class Scheduler {
     if (skippedUntil && now < skippedUntil) until = Math.max(until, skippedUntil);
     return until;
   }
-  /** Get current session activity state.
-   *  Returns { lastActivityMs, pendingWork } — callers apply their own
-   *  thresholds. pendingWork is true when pendingCheck() reports work in
-   *  flight. lastActivityMs is 0 when no activity has been recorded. */
-  getSessionState() {
-    let pendingWork = false;
-    try {
-      if (this.pendingCheck) pendingWork = !!this.pendingCheck();
-    } catch {
-      /* probe failure is not fatal */
-    }
-    return { lastActivityMs: this.lastActivity, pendingWork };
-  }
-  /** Returns true when the session is considered idle (no pending work and
-   *  lastActivityMs is either 0 or older than the given threshold).
-   *  threshold defaults to 15 minutes but callers should pass their own. */
-  isSessionIdle(thresholdMs = 15 * 6e4) {
-    const { lastActivityMs, pendingWork } = this.getSessionState();
-    if (pendingWork) return false;
-    if (lastActivityMs === 0) return true;
-    return Date.now() - lastActivityMs >= thresholdMs;
-  }
-  /** Get time context for prompt enrichment */
-  getTimeContext() {
-    const now = /* @__PURE__ */ new Date();
-    const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-    const dow = now.getDay();
-    return {
-      hour: now.getHours(),
-      minute: now.getMinutes(),
-      dayOfWeek: days[dow],
-      isWeekend: dow === 0 || dow === 6,
-    };
-  }
-  /** Wrap prompt with session context metadata */
-  wrapPrompt(name, prompt, type) {
-    const { lastActivityMs, pendingWork } = this.getSessionState();
-    let state = 'recent';
-    if (pendingWork) state = 'active';
-    else if (lastActivityMs === 0) state = 'idle';
-    const time = this.getTimeContext();
-    const header = [
-      `[schedule: ${name} | type: ${type} | session: ${state}]`,
-      `[time: ${time.dayOfWeek} ${String(time.hour).padStart(2, '0')}:${String(time.minute).padStart(2, '0')} | weekend: ${time.isWeekend}]`,
-      `Before starting any work, briefly tell the user what you're about to do in one short sentence.`,
-    ].join('\n');
-    return `${header}
-
-${prompt}`;
-  }
   static SCHEDULER_LOCK = join(resolveRuntimeRoot(), 'scheduler.lock');
   static INSTANCE_UUID = randomUUID();
   static _exitHookInstalled = false;
@@ -345,8 +257,7 @@ ${prompt}`;
 
   start() {
     if (this.tickTimer) return;
-    const total = this.nonInteractive.length + this.interactive.length;
-    if (total === 0) {
+    if (this.schedules.length === 0) {
       process.stderr.write('mixdog scheduler: no schedules configured\n');
       return;
     }
@@ -365,7 +276,7 @@ ${prompt}`;
       Scheduler._exitHookInstalled = true;
       process.on('exit', releaseOwnedSchedulerLock);
     }
-    logSchedule(`${this.nonInteractive.length} non-interactive, ${this.interactive.length} interactive\n`);
+    logSchedule(`${this.schedules.length} schedules\n`);
     this.registerCronJobs();
     this.tick();
     this.tickTimer = setInterval(() => this.tick(), TICK_INTERVAL);
@@ -373,14 +284,14 @@ ${prompt}`;
   /** Register schedule entries. `when_cron` entries bind to node-cron (dow
    *  field covers the day guard); `when_at` entries arm a one-shot timer. */
   registerCronJobs() {
-    for (const { schedule: s, type } of this.typedSchedules()) {
+    for (const s of this.schedules) {
       if (s.whenCron) {
         if (!isCronExpression(s.whenCron)) {
           process.stderr.write(`mixdog scheduler: invalid cron "${s.name}" (${s.whenCron}) — skipped\n`);
           continue;
         }
         try {
-          const task = cron.schedule(s.whenCron, (ctx) => this.onCronFire(s, type, ctx?.date), {
+          const task = cron.schedule(s.whenCron, (ctx) => this.onCronFire(s, ctx?.date), {
             timezone: s.timezone || undefined,
             name: s.name,
           });
@@ -397,13 +308,13 @@ ${prompt}`;
           process.stderr.write(`mixdog scheduler: failed to register cron "${s.name}" (${s.whenCron}): ${err}\n`);
         }
       } else if (s.whenAt) {
-        this.armOneShot(s, type);
+        this.armOneShot(s);
       }
     }
   }
   /** Fire path for a cron-triggered entry. node-cron's dow field covers the
    *  day guard, so there is no separate days filter. Persists last_fired_at. */
-  async onCronFire(schedule, type, scheduledDate = null) {
+  async onCronFire(schedule, scheduledDate = null) {
     const startedAt = /* @__PURE__ */ new Date();
     const scheduledAt =
       scheduledDate instanceof Date && Number.isFinite(scheduledDate.getTime()) ? scheduledDate : startedAt;
@@ -438,7 +349,7 @@ ${prompt}`;
         this.recordRefusal(schedule, refusal);
         return;
       }
-      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true, reserved: true });
+      const fired = await this.fireTimed(schedule, { awaitDispatch: true, reserved: true });
       // An overlap skip is recorded as a skip, never as a failed run.
       if (!fired && skippedSince(schedule, startedAt)) return;
       if (!fired) {
@@ -481,7 +392,7 @@ ${prompt}`;
    *  entries (misfire recovery at start) fire immediately. setTimeout's
    *  ~24.8-day (2^31-1 ms) ceiling is handled by re-arming for far-future
    *  instants instead of firing early. */
-  armOneShot(schedule, type) {
+  armOneShot(schedule) {
     const fireAt = new Date(schedule.whenAt).getTime();
     if (!Number.isFinite(fireAt)) {
       process.stderr.write(`mixdog scheduler: invalid when_at for "${schedule.name}" (${schedule.whenAt}) — skipped\n`);
@@ -489,11 +400,11 @@ ${prompt}`;
     }
     const delay = fireAt - Date.now();
     if (delay > MAX_TIMER_DELAY_MS) {
-      const timer = setTimeout(() => this.armOneShot(schedule, type), MAX_TIMER_DELAY_MS);
+      const timer = setTimeout(() => this.armOneShot(schedule), MAX_TIMER_DELAY_MS);
       this.oneShotTimers.set(schedule.name, timer);
       return;
     }
-    const timer = setTimeout(() => this.fireOneShot(schedule, type), Math.max(0, delay));
+    const timer = setTimeout(() => this.fireOneShot(schedule), Math.max(0, delay));
     this.oneShotTimers.set(schedule.name, timer);
     schedule.nextFireAt = new Date(fireAt).toISOString();
     void setNextFire(schedule.name, new Date(fireAt)).catch(() => {});
@@ -521,7 +432,7 @@ ${prompt}`;
    *  Idempotent: if last_fired_at is already set (a prior fire whose markDone
    *  failed left the row 'active'), do NOT fire again — only retry markDone so
    *  the stuck-active entry stops re-arming/misfiring. */
-  async fireOneShot(schedule, type) {
+  async fireOneShot(schedule) {
     this.oneShotTimers.delete(schedule.name);
     const now = /* @__PURE__ */ new Date();
     if (schedule.lastFiredAt) {
@@ -530,7 +441,7 @@ ${prompt}`;
       return;
     }
     if (this.shouldSkip(schedule.name)) {
-      this.rearmDeferredOneShot(schedule, type);
+      this.rearmDeferredOneShot(schedule);
       return;
     }
     // Mark done ONLY after a successful fire. A false/throwing fireTimed
@@ -546,7 +457,7 @@ ${prompt}`;
       // dispatch outcome — a truthy fireTimed alone (cron's fire-and-forget
       // contract) would retire the entry even when schedulerLlm() later
       // rejects. Only a resolved dispatch counts as a real fire here.
-      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true, reserved });
+      const fired = await this.fireTimed(schedule, { awaitDispatch: true, reserved });
       if (!fired && skippedSince(schedule, now)) {
         logSchedule(`one-shot "${schedule.name}" skipped (previous run in progress) — leaving pending for retry\n`);
         return;
@@ -571,13 +482,13 @@ ${prompt}`;
    *  already elapsed and tickAsync is a no-op, so simply returning would mean
    *  it never fires until a restart. Re-arm for the deferral expiry (the
    *  later of when_at and deferred/skipped-until) so it fires on its own. */
-  rearmDeferredOneShot(schedule, type) {
+  rearmDeferredOneShot(schedule) {
     const until = this.skipUntil(schedule.name);
     const fireAt = new Date(schedule.whenAt).getTime();
     const target = Math.max(Number.isFinite(fireAt) ? fireAt : 0, until);
     const delay = Math.min(Math.max(target - Date.now(), 1), MAX_TIMER_DELAY_MS);
     logSchedule(`one-shot "${schedule.name}" deferred/skipped — re-arming for ${new Date(target).toISOString()}\n`);
-    const timer = setTimeout(() => this.fireOneShot(schedule, type), delay);
+    const timer = setTimeout(() => this.fireOneShot(schedule), delay);
     this.oneShotTimers.set(schedule.name, timer);
     schedule.nextFireAt = new Date(target).toISOString();
     void setNextFire(schedule.name, new Date(target)).catch(() => {});
@@ -643,15 +554,13 @@ ${prompt}`;
     this.oneShotTimers.delete(name);
     this.lastFired.delete(name);
     this.deferred.delete(name);
-    this.nonInteractive = this.nonInteractive.filter((s) => s.name !== name);
-    this.interactive = this.interactive.filter((s) => s.name !== name);
+    this.schedules = this.schedules.filter((s) => s.name !== name);
   }
-  reloadConfig(nonInteractive, interactive, options = {}) {
-    this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
-    this.interactive = interactive.filter((s) => s.enabled !== false);
+  reloadConfig(schedules, options = {}) {
+    this.schedules = schedules.filter((s) => s.enabled !== false);
     this.promptsDir = join(DATA_DIR, 'prompts');
     // A name that no longer exists must not keep (or later regain) a stamp.
-    const live = new Set([...this.nonInteractive, ...this.interactive].map((s) => s.name));
+    const live = new Set(this.schedules.map((s) => s.name));
     for (const name of this.lastFired.keys()) if (!live.has(name)) this.lastFired.delete(name);
     // Defer/skip state is persisted (deferred_until / skipped_until) and
     // re-read from the reloaded rows, so a reload no longer drops it.
@@ -664,10 +573,9 @@ ${prompt}`;
     this.restart();
   }
   getStatus() {
-    return this.typedSchedules().map(({ schedule: s, type }) => ({
+    return this.schedules.map((s) => ({
       name: s.name,
       time: s.whenCron ?? s.whenAt ?? null,
-      type,
       running: this.running.has(s.name),
       lastFired: this.lastFired.get(s.name) ?? s.lastFiredAt ?? null,
       lastSuccess: s.lastSuccessAt ?? null,
@@ -679,14 +587,13 @@ ${prompt}`;
     const timed = this.findSchedule(name);
     if (timed) {
       if (this.running.has(name)) return `"${name}" is already running`;
-      const isNonInteractive = this.nonInteractive.includes(timed);
       const now = /* @__PURE__ */ new Date();
       const hhmm = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
       const dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
       // Match onCronFire: record lastFired only when fireTimed actually
       // proceeds past its running/precondition guards (resolves truthy),
       // and reflect a non-fire in the returned status.
-      const fired = await this.fireTimed(timed, isNonInteractive ? 'non-interactive' : 'interactive');
+      const fired = await this.fireTimed(timed);
       if (fired) {
         this.lastFired.set(name, `${dateStr}T${hhmm}`);
         return `triggered "${name}"`;
@@ -708,7 +615,7 @@ ${prompt}`;
     // interval is kept for future cadence-driven work and lifecycle parity.
   }
   // ── Fire timed schedule ─────────────────────────────────────────────
-  async fireTimed(schedule, type, opts = {}) {
+  async fireTimed(schedule, opts = {}) {
     const prompt = this.resolvePrompt(schedule);
     if (!prompt) {
       process.stderr.write(`mixdog scheduler: prompt not found for "${schedule.name}"
@@ -716,7 +623,7 @@ ${prompt}`;
       this.notifyFailure(schedule, 'prompt not found — fire skipped');
       return false;
     }
-    return await this.fireTimedPrompt(schedule, type, prompt, opts);
+    return await this.fireTimedPrompt(schedule, prompt, opts);
   }
   /** Why a fire of `name` may not start now: 'renaming', 'running' or null. */
   fireRefusal(name) {
@@ -739,14 +646,13 @@ ${prompt}`;
   }
   /** Fire a timed schedule with the given prompt content. `reserved`: the
    *  caller already holds the name in `running` and releases it itself. */
-  async fireTimedPrompt(schedule, type, prompt, { awaitDispatch = false, reserved = false } = {}) {
-    logSchedule(`firing ${schedule.name} (${type})\n`);
+  async fireTimedPrompt(schedule, prompt, { awaitDispatch = false, reserved = false } = {}) {
+    logSchedule(`firing ${schedule.name}\n`);
     const refusal = reserved ? null : this.fireRefusal(schedule.name);
     if (refusal) {
       this.recordRefusal(schedule, refusal);
       return false;
     }
-    if (type === 'interactive' && this.injectIntoLead(schedule, type, prompt)) return true;
     if (!reserved) this.running.add(schedule.name);
     // Cron (recurring) keeps the fire-and-forget contract: return truthy now
     // and swallow async failures. A one-shot (awaitDispatch) instead awaits
@@ -757,28 +663,8 @@ ${prompt}`;
     if (awaitDispatch) return await dispatch;
     return true;
   }
-  /** Interactive schedules enqueue into the live Lead session's command
-   *  queue as system-generated task notifications (priority 'later'),
-   *  exactly like inbound channel messages — enqueue counts as the fire.
-   *  False when no live Lead seat is attached or the inject fails, so the
-   *  visible-session run remains the fallback and a fire is never lost. */
-  injectIntoLead(schedule, type, prompt) {
-    if (!this.injectFn || !this.injectReady()) return false;
-    try {
-      const wrapped = this.wrapPrompt(schedule.name, prompt, type);
-      this.injectFn('', `schedule:${schedule.name}`, ' ', { type: 'schedule', instruction: wrapped });
-      logSchedule(`${schedule.name}: injected into Lead session queue (interactive fire)\n`);
-      return true;
-    } catch (err) {
-      logSchedule(
-        `${schedule.name}: Lead inject failed (${err?.message || err}) — falling back to visible session run\n`
-      );
-      return false;
-    }
-  }
   /** Fires run as VISIBLE schedule sessions (desktop Recent / TUI resume)
-   *  via runScheduleSession; the wrapped prompt keeps the schedule context
-   *  header. Resolves true on success; a failure rejects for awaitDispatch
+   *  via runScheduleSession. Resolves true on success; a failure rejects for awaitDispatch
    *  callers and resolves false (after a logged notice) for fire-and-forget
    *  cron fires. */
   dispatchScheduleRun(schedule, prompt, awaitDispatch) {

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

@@ -26,8 +26,6 @@ CREATE TABLE IF NOT EXISTS scheduler.schedules (
   when_at        timestamptz,
   when_cron      text,
   timezone       text,
-  target         text NOT NULL CHECK (target IN ('channel','session')),
-  channel_id     text,
   model          text,
   cwd            text,
   workflow       text,
@@ -90,8 +88,6 @@ function rowToDef(row) {
     whenAt: row.when_at,
     whenCron: row.when_cron,
     timezone: row.timezone,
-    target: row.target,
-    channelId: row.channel_id,
     cwd: row.cwd,
     attachments: row.attachments || null,
     delivery: row.delivery || null,
@@ -115,8 +111,32 @@ function rowToDef(row) {
   };
 }
 
+// A table created by an older release still has `target` as a NOT NULL column
+// with no default, so an insert must keep filling it; every schedule runs as a
+// session. A table created now has no such column. The schema is probed once
+// per connection; the column is never read, altered or dropped.
+const requiredTargetColumn = new WeakMap();
+function hasRequiredTargetColumn(db) {
+  if (!requiredTargetColumn.has(db)) {
+    requiredTargetColumn.set(
+      db,
+      db
+        .query(
+          `SELECT column_name FROM information_schema.columns
+            WHERE table_schema = 'scheduler' AND table_name = 'schedules' AND column_name = 'target'`
+        )
+        .then(({ rows }) => rows.some((row) => row.column_name === 'target'))
+        .catch((error) => {
+          requiredTargetColumn.delete(db);
+          throw error;
+        })
+    );
+  }
+  return requiredTargetColumn.get(db);
+}
+
 const COLS =
-  'name, description, when_at, when_cron, timezone, target, channel_id, 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, consecutive_failures, result_delivery, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
 
 // ---------------------------------------------------------------------------
 // Public API
@@ -148,8 +168,6 @@ export async function upsertSchedule(def, { dataDir } = {}) {
     def.whenAt ?? null,
     def.whenCron ?? null,
     def.timezone ?? null,
-    def.target,
-    def.channelId ?? null,
     def.cwd ?? null,
     def.attachments ? JSON.stringify(def.attachments) : null,
     def.delivery ?? null,
@@ -159,18 +177,23 @@ export async function upsertSchedule(def, { dataDir } = {}) {
     def.nextFireAt ?? null,
     def.ownerAgentId || 'lead',
   ];
+  let legacyTarget = '';
+  let legacyTargetValue = '';
+  if (await hasRequiredTargetColumn(db)) {
+    params.push('session');
+    legacyTarget = ', target';
+    legacyTargetValue = `,$${params.length}`;
+  }
   const { rows } = await db.query(
     `INSERT INTO scheduler.schedules
-       (name, description, when_at, when_cron, timezone, target, channel_id, cwd, attachments, delivery, prompt, enabled, status, next_fire_at, owner_agent_id)
-     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)
+       (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})
      ON CONFLICT (name) DO UPDATE SET
        owner_agent_id = EXCLUDED.owner_agent_id,
        description  = EXCLUDED.description,
        when_at      = EXCLUDED.when_at,
        when_cron    = EXCLUDED.when_cron,
        timezone     = EXCLUDED.timezone,
-       target       = EXCLUDED.target,
-       channel_id   = EXCLUDED.channel_id,
        cwd          = EXCLUDED.cwd,
        attachments  = EXCLUDED.attachments,
        delivery     = EXCLUDED.delivery,

package/src/runtime/channels/lib/status-snapshot.mjs

@@ -57,7 +57,7 @@ function* armedScheduleFires(scheduler) {
     const fireAt = cronTaskNextFireAt(task);
     if (fireAt !== null) yield { name, fireAt, kind: 'cron' };
   }
-  const defs = [...(scheduler.nonInteractive || []), ...(scheduler.interactive || [])];
+  const defs = scheduler.schedules || [];
   for (const name of (scheduler.oneShotTimers || new Map()).keys()) {
     if (scheduler.shouldSkip?.(name)) continue;
     const def = defs.find((s) => s.name === name);

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

@@ -1,6 +1,5 @@
 // Worker/HTTP runtime-lifecycle dispatch (activate_channel_bridge /
-// reload_config). Channel messaging — forwarder, transcript binding, typing —
-// is deleted with Discord/Telegram; only the automation lifecycle remains.
+// reload_config). Only the automation lifecycle is dispatched here.
 // Lifecycle functions are threaded in as a bag of lazy getters so the module
 // reads the live file-level references at call time.
 import { scheduleErrorFields } from './schedule-errors.mjs';