mixdog 1.3.4 → 1.4.0

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

@@ -18,6 +18,7 @@ import {
   setNextFire,
   setSkippedUntil,
 } from './schedules-db.mjs';
+import { scheduleRenameReloadError, scheduleRenameRunningError } from './schedule-errors.mjs';
 import { appendBuffered } from '../../shared/buffered-appender.mjs';
 import { tryRead } from './settings.mjs';
 
@@ -114,72 +115,36 @@ function releaseSchedulerRuntime(scheduler) {
   releaseOwnedSchedulerLock();
 }
 class Scheduler {
-  nonInteractive;
-  interactive;
+  schedules;
   promptsDir;
   tickTimer = null;
   lastFired = /* @__PURE__ */ new Map();
   // name -> "YYYY-MM-DDTHH:MM"
   running = /* @__PURE__ */ new Set();
-  injectFn = null;
-  injectReadyFn = null;
-  pendingCheck = null;
+  // Names whose row is being renamed: no fire starts under them meanwhile.
+  renaming = /* @__PURE__ */ new Set();
   // 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
@@ -187,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);
     }
@@ -234,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;
@@ -342,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;
     }
@@ -362,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);
@@ -370,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,
           });
@@ -394,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;
@@ -415,6 +329,12 @@ ${prompt}`;
       }
       return;
     }
+    // The name is held in `running` from before the claim until the completion
+    // stamps are written, so a rename can neither complete meanwhile nor leave
+    // this fire to run under the old name. A fire refused here still claims its
+    // slot and is recorded as a skip, never run.
+    const refusal = this.fireRefusal(schedule.name);
+    if (!refusal) this.running.add(schedule.name);
     try {
       const claimed = await claimScheduleRun(schedule.name, scheduledAt, startedAt, nextFireAt);
       if (!claimed) {
@@ -425,7 +345,11 @@ ${prompt}`;
       schedule.lastStartedAt = startedAt.toISOString();
       schedule.lastFiredAt = startedAt.toISOString();
       this.lastFired.set(schedule.name, startedAt.toISOString());
-      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true });
+      if (refusal) {
+        this.recordRefusal(schedule, refusal);
+        return;
+      }
+      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) {
@@ -443,6 +367,8 @@ ${prompt}`;
       } catch {}
       process.stderr.write(`mixdog scheduler: ${schedule.name} failed: ${err}\n`);
       this.notifyFailure(schedule, `run failed: ${err?.message || err}`);
+    } finally {
+      if (!refusal) this.running.delete(schedule.name);
     }
   }
   stop() {
@@ -466,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`);
@@ -474,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(() => {});
@@ -506,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) {
@@ -515,18 +441,23 @@ ${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
     // (missing prompt, running guard, paused owner, dispatch error) must leave the
     // one-shot pending so a reload/restart can retry it — never retire it.
+    // The name stays in `running` until the fired/done stamps are written, so
+    // a rename cannot move the row before they land (onCronFire). A refused
+    // fire is left to fireTimedPrompt, which records the skip.
+    const reserved = !this.fireRefusal(schedule.name);
+    if (reserved) this.running.add(schedule.name);
     try {
       // awaitDispatch: for a one-shot we must wait for the actual LLM/relay
       // 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 });
+      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;
@@ -542,6 +473,8 @@ ${prompt}`;
       await markOneShotFailed(schedule);
       process.stderr.write(`mixdog scheduler: ${schedule.name} one-shot failed: ${err} — leaving pending for retry\n`);
       this.notifyFailure(schedule, `one-shot failed: ${err?.message || err} — left pending for retry`);
+    } finally {
+      if (reserved) this.running.delete(schedule.name);
     }
   }
   /** when_at one-shots must honor deferred_until / skipped_until just like
@@ -549,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(() => {});
@@ -577,10 +510,58 @@ ${prompt}`;
     releaseSchedulerRuntime(this);
     this.start();
   }
-  reloadConfig(nonInteractive, interactive, options = {}) {
-    this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
-    this.interactive = interactive.filter((s) => s.enabled !== false);
+  /** Run `rename` (which moves schedule `name`'s row) while no run of `name`
+   *  can start or be in flight. The check and the reservation are one
+   *  synchronous step, and a fire checks for the reservation (fireRefusal)
+   *  in the same step that adds the name to `running`, which it holds until
+   *  its completion stamps are written, so a fire either is already in
+   *  `running` (refused here) or finds the reservation (not fired). */
+  async renameLocked(name, rename, { newName = name, reload = async () => {} } = {}) {
+    if (this.running.has(name) || this.renaming.has(name)) throw scheduleRenameRunningError(name);
+    this.renaming.add(name);
+    this.renameBlocked?.delete(name);
+    try {
+      const saved = await rename();
+      if (!saved) return saved;
+      try {
+        await reload();
+      } catch (error) {
+        // The row has moved but the reload that arms the new name failed:
+        // nothing may keep running under the old one, and the call reports it.
+        this.dropSchedule(name);
+        throw scheduleRenameReloadError(newName, error?.message || error);
+      }
+      return saved;
+    } catch (error) {
+      // A one-shot whose timer a blocked fire consumed is armed again from the
+      // loaded schedules, so it fires once (after a failed rename the old
+      // entry is still loaded; after a dropped one only the others re-arm).
+      if (this.renameBlocked?.has(name) && this.tickTimer) this.restart();
+      throw error;
+    } finally {
+      this.renaming.delete(name);
+      this.renameBlocked?.delete(name);
+    }
+  }
+  /** Forget `name` entirely: its cron job, one-shot timer, stamps and loaded
+   *  entries. Used when its row moved but the reload that re-arms it failed. */
+  dropSchedule(name) {
+    try {
+      this.cronJobs.get(name)?.destroy();
+    } catch {}
+    this.cronJobs.delete(name);
+    clearTimeout(this.oneShotTimers.get(name));
+    this.oneShotTimers.delete(name);
+    this.lastFired.delete(name);
+    this.deferred.delete(name);
+    this.schedules = this.schedules.filter((s) => s.name !== name);
+  }
+  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.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.
     this.refreshSkipCache();
@@ -592,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,
@@ -607,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}"`;
@@ -636,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}"
@@ -644,56 +623,59 @@ ${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);
   }
-  /** Fire a timed schedule with the given prompt content */
-  async fireTimedPrompt(schedule, type, prompt, { awaitDispatch = false } = {}) {
-    logSchedule(`firing ${schedule.name} (${type})\n`);
-    if (this.running.has(schedule.name)) {
+  /** Why a fire of `name` may not start now: 'renaming', 'running' or null. */
+  fireRefusal(name) {
+    if (this.renaming.has(name)) return 'renaming';
+    return this.running.has(name) ? 'running' : null;
+  }
+  /** Record a fire refused for `reason` (fireRefusal) as a skip. */
+  recordRefusal(schedule, reason) {
+    if (reason === 'running') {
       this.recordSkip(schedule);
+      return;
+    }
+    logSchedule(`${schedule.name}: not fired — being renamed\n`);
+    // A skip, not a failure: a one-shot stays pending (fireOneShot) and
+    // renameLocked re-arms it if the rename does not go through.
+    schedule.lastSkippedAt = new Date().toISOString();
+    // Per name: another rename settling meanwhile must not hide this one.
+    this.renameBlocked ??= new Set();
+    this.renameBlocked.add(schedule.name);
+  }
+  /** 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, 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;
-    this.running.add(schedule.name);
+    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
     // the dispatch so a rejected run propagates and the caller leaves the
     // entry pending for retry instead of retiring it.
-    const dispatch = this.dispatchScheduleRun(schedule, prompt, awaitDispatch);
+    const run = this.dispatchScheduleRun(schedule, prompt, awaitDispatch);
+    const dispatch = reserved ? run : run.finally(() => this.running.delete(schedule.name));
     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) {
-    const run = this.scheduleRunner
-      ? this.scheduleRunner(schedule, { prompt })
-      : Promise.reject(new Error('schedule runner not configured'));
-    return run
+    // Called inside a then, so a runner that throws synchronously rejects
+    // like one that rejects, and the caller's cleanup still runs.
+    return Promise.resolve()
+      .then(() => {
+        if (!this.scheduleRunner) throw new Error('schedule runner not configured');
+        return this.scheduleRunner(schedule, { prompt });
+      })
       .then((outcome) => {
-        this.running.delete(schedule.name);
         // The run path found this schedule's previous run still going (a
         // "run now" from the app) or backing off after failures in a row; it
         // already persisted the skip.
@@ -706,7 +688,6 @@ ${prompt}`;
         return true;
       })
       .catch((err) => {
-        this.running.delete(schedule.name);
         logSchedule(`${schedule.name} LLM error: ${err.message}\n`);
         // The cron fire-and-forget contract swallowed failures entirely;
         // log them so a failed scheduled run is never

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

@@ -15,6 +15,7 @@ import { ensurePgInstance, withSchemaBootstrapLock } from '../../memory/lib/pg/a
 import { createPgSchemaDb } from '../../shared/pg-schema-db.mjs';
 import { resolvePluginData } from '../../shared/plugin-paths.mjs';
 import { ROUTINE_LIMITS } from '../../shared/routine-limits.mjs';
+import { scheduleNameTakenError } from './schedule-errors.mjs';
 
 const SCHEMA = 'scheduler';
 
@@ -25,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,
@@ -89,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,
@@ -114,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
@@ -147,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,
@@ -158,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,
@@ -195,6 +219,54 @@ export async function upsertSchedule(def, { dataDir } = {}) {
   return rowToDef(rows[0]);
 }
 
+/**
+ * Rename schedule `oldName` to `def.name` in one UPDATE of the primary key,
+ * applying the edited settings. Run history (last_* stamps, failure streak,
+ * undelivered results), status and the next_fire_at cursor (a deferral, or
+ * none for a finished one-shot) stay on the row. When `timingChanged`, the row
+ * is re-armed the way `upsertSchedule` re-arms a redefinition: a one-shot's
+ * cursor becomes its `when_at`, a recurring one's is cleared for the scheduler
+ * to compute. Resolves null when `oldName` is gone; an occupied `def.name`
+ * rejects and changes nothing.
+ */
+export async function renameSchedule(oldName, def, { timingChanged = false, dataDir } = {}) {
+  const db = await getDb(dataDir);
+  try {
+    const { rows } = await db.query(
+      `UPDATE scheduler.schedules SET
+         name = $2, description = $3, when_at = $4, when_cron = $5, timezone = $6, cwd = $7,
+         attachments = $8, prompt = $9, enabled = $10, owner_agent_id = $11,
+         next_fire_at = CASE WHEN $12::boolean THEN $4::timestamptz ELSE next_fire_at END,
+         status = CASE WHEN $12::boolean THEN 'active' ELSE status END,
+         deferred_until = CASE WHEN $12::boolean THEN NULL ELSE deferred_until END,
+         skipped_until = CASE WHEN $12::boolean THEN NULL ELSE skipped_until END,
+         last_fired_at = CASE WHEN $12::boolean THEN NULL ELSE last_fired_at END,
+         last_scheduled_at = CASE WHEN $12::boolean THEN NULL ELSE last_scheduled_at END,
+         updated_at = now()
+       WHERE name = $1
+       RETURNING ${COLS}`,
+      [
+        oldName,
+        def.name,
+        def.description ?? '',
+        def.whenAt ?? null,
+        def.whenCron ?? null,
+        def.timezone ?? null,
+        def.cwd ?? null,
+        def.attachments ? JSON.stringify(def.attachments) : null,
+        def.prompt,
+        def.enabled ?? true,
+        def.ownerAgentId || 'lead',
+        timingChanged === true,
+      ]
+    );
+    return rowToDef(rows[0]);
+  } catch (error) {
+    if (error?.code === '23505') throw scheduleNameTakenError(def.name);
+    throw error;
+  }
+}
+
 export async function deleteSchedule(name, { dataDir } = {}) {
   const db = await getDb(dataDir);
   const { rowCount } = await db.query(`DELETE FROM scheduler.schedules WHERE name = $1`, [name]);