mixdog 0.9.24 → 0.9.26

package/src/runtime/memory/lib/recall-format.mjs

@@ -157,22 +157,18 @@ export function renderEntryLines(rows, { recencyOrder = false } = {}) {
   // this global re-sort a multi-member chunk would emit oldest-first lines and
   // break a strict newest-first contract (bench: recency-today).
   const units = []
-  // Bound total emitted lines (roots x members) so a many-member recall can't
-  // inject unbounded output. Per-line content is already capped at 1000 chars;
-  // this caps the line COUNT. Narrow the query (limit/period/projectScope) for more.
-  const RECALL_LINE_CAP = 200
-  // recencyOrder collects every unit first (so the ts sort sees the full set)
-  // and caps AFTER sorting; the default path keeps the original cap-as-we-go.
-  const COLLECT_CAP = recencyOrder ? Infinity : RECALL_LINE_CAP
-  let _capped = false
-  outer:
+  // No line-count cap here: the orchestrator enforces a global tool-output KB
+  // cap (builtin.mjs tool_output_token_limit), so recall need not self-truncate.
+  // recencyOrder still collects every unit first so the ts sort sees the full
+  // set; the default path emits in row order. Per-line body is bounded by a
+  // loose 8000-char safety cap so one giant pasted-log row can't monopolize
+  // the envelope.
   for (const r of rows) {
     // Collapsed near-duplicate (search path only — set by
     // collapseNearDuplicateRows). Emit a one-line stub carrying its #id so an
     // id-lookup follow-up can still fetch the full body; never rendered for
     // id-lookup output (those rows never carry _dupStub).
     if (r && r._dupStub) {
-      if (units.length >= COLLECT_CAP) { _capped = true; break }
       units.push({ ts: Number(r.ts) || 0, text: `[${formatTs(r.ts)}] (near-duplicate of #${r._dupOf} — collapsed) #${r.id}` })
       continue
     }
@@ -182,14 +178,12 @@ export function renderEntryLines(rows, { recencyOrder = false } = {}) {
       // grouping artifact for retrieval — the caller wants the chunk
       // content (cycle1 raw), not the cycle2-compressed summary.
       for (const m of r.members) {
-        if (units.length >= COLLECT_CAP) { _capped = true; break outer }
         const mTs = formatTs(m.ts)
         const role = m.role === 'user' ? 'u' : m.role === 'assistant' ? 'a' : (m.role || '?')
-        const content = cleanMemoryText(String(m.content ?? '')).slice(0, 1000)
+        const content = cleanMemoryText(String(m.content ?? '')).slice(0, 8000)
         units.push({ ts: Number(m.ts) || 0, text: `[${mTs}] ${role}: ${content} #${m.id}` })
       }
     } else {
-      if (units.length >= COLLECT_CAP) { _capped = true; break }
       // No chunks (root not yet chunked by cycle1, or orphan leaf): emit
       // the row itself in the same shape. element/summary fall back to
       // raw content when both are absent.
@@ -205,28 +199,25 @@ export function renderEntryLines(rows, { recencyOrder = false } = {}) {
         : ''
       const body = element || summary
         ? `${element}${summary ? ' — ' + summary : ''}`
-        : cleanMemoryText(String(r.content ?? '')).slice(0, 1000)
+        : cleanMemoryText(String(r.content ?? '')).slice(0, 8000)
       // Unchunked raw leaf (cycle1 hasn't classified it yet): mark it so
       // callers can tell fresh-but-unprocessed rows from chunked memory.
       const pendingMark = (r.is_root === 0 && r.chunk_root == null) ? ' [pending]' : ''
-      units.push({ ts: Number(r.ts) || 0, text: `[${ts}] ${rolePrefix}${body.slice(0, 1000)}${pendingMark} #${r.id}` })
+      units.push({ ts: Number(r.ts) || 0, text: `[${ts}] ${rolePrefix}${body.slice(0, 8000)}${pendingMark} #${r.id}` })
     }
   }
   if (recencyOrder) {
     // Array.sort is stable in V8, so units sharing the same ts keep their
     // insertion (root/member) order; only cross-unit ts breaks are corrected.
     units.sort((a, b) => b.ts - a.ts)
-    if (units.length > RECALL_LINE_CAP) { units.length = RECALL_LINE_CAP; _capped = true }
   }
-  const lines = units.map((u) => u.text)
-  if (_capped) lines.push(`[recall truncated — showing first ${RECALL_LINE_CAP} lines; narrow the query (limit/period/projectScope) for the rest]`)
-  return lines.join('\n')
+  return units.map((u) => u.text).join('\n')
 }
 
 // Search-result de-duplication. Within a SINGLE formatted result set, hybrid
 // recall frequently returns several long rows that restate the same design in
 // slightly different words (e.g. a root summary plus a chunk that paraphrases
-// it). They each spend the ~1000-char line budget on near-identical text.
+// it). They each spend a large slice of the envelope on near-identical text.
 // Cheap heuristic (no embeddings): normalize each row's body to word tokens,
 // build 3-gram shingle sets, and measure containment overlap = |A∩B| /
 // min(|A|,|B|) against already-kept rows. Rows arrive rank/date-ordered, so the
@@ -308,6 +299,31 @@ function shortSessionLabel(sid) {
   return `…${s.slice(-16)}`
 }
 
+// Collect every ts in a session group (roots + their inline members) so the
+// span header reflects the true activity window, not just the root ts.
+function collectGroupTs(groupRows) {
+  const all = []
+  for (const r of groupRows) {
+    const t = Number(r?.ts)
+    if (Number.isFinite(t)) all.push(t)
+    if (Array.isArray(r?.members)) for (const m of r.members) {
+      const mt = Number(m?.ts)
+      if (Number.isFinite(mt)) all.push(mt)
+    }
+  }
+  return all
+}
+
+// Activity-span header suffix: `(MM-DD HH:mm ~ HH:mm, n건)`; the end keeps the
+// MM-DD prefix only when it falls on a different calendar day than the start.
+function spanHeaderSuffix(minTs, maxTs, n) {
+  const min = formatTs(minTs) // "YYYY-MM-DD HH:mm"
+  const max = formatTs(maxTs)
+  const startPart = min.slice(5) // "MM-DD HH:mm"
+  const endPart = min.slice(0, 10) === max.slice(0, 10) ? max.slice(11) : max.slice(5)
+  return `(${startPart} ~ ${endPart}, ${n}건)`
+}
+
 // Session-grouped rendering for the GLOBAL query-less browse ("what did we
 // work on recently") when the window spans multiple sessions. A flat ts-desc
 // list interleaves sessions into one indistinguishable stream and lets one
@@ -320,7 +336,7 @@ function shortSessionLabel(sid) {
 // group's lines are globally ts-desc: without it a chunk root's members (stored
 // ts-ASC) interleave with raw rows and invert the visible timeline within a
 // session (e.g. 04:33 rendered above 04:41).
-export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder = false } = {}) {
+export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder = false, spanHeaders = false } = {}) {
   if (!rows || rows.length === 0) return '(no results)'
   const groups = new Map()
   for (const r of rows) {
@@ -329,8 +345,30 @@ export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder
     if (!groups.has(key)) groups.set(key, [])
     groups.get(key).push(r)
   }
-  if (groups.size <= 1) return renderEntryLines(rows, { recencyOrder })
+  if (!spanHeaders && groups.size <= 1) return renderEntryLines(rows, { recencyOrder })
   const current = String(currentSessionId || '').trim()
+  // period='last' session-grouped browse: activity-span headers over each
+  // group's body. No line budget — the orchestrator's global tool-output KB
+  // cap bounds total size; each group's body is already row-capped by the
+  // caller.
+  if (spanHeaders) {
+    const parts = []
+    for (const [sid, groupRows] of groups) {
+      const mark = current && sid === current ? ' (current)' : ''
+      const label = sid === '(no session)' ? sid : `session ${shortSessionLabel(sid)}`
+      const tsAll = collectGroupTs(groupRows)
+      const suffix = tsAll.length
+        ? ` ${spanHeaderSuffix(Math.min(...tsAll), Math.max(...tsAll), groupRows.length)}`
+        : ` (${groupRows.length}건)`
+      parts.push(`## ${label}${mark}${suffix}`)
+      const bodyStr = renderEntryLines(groupRows, { recencyOrder })
+      const bodyLines = bodyStr === '(no results)'
+        ? []
+        : bodyStr.split('\n')
+      for (const l of bodyLines) parts.push(l)
+    }
+    return parts.join('\n')
+  }
   const parts = []
   for (const [sid, groupRows] of groups) {
     const mark = current && sid === current ? ' (current)' : ''

package/src/runtime/memory/lib/session-ingest-runtime.mjs

@@ -371,17 +371,31 @@ export function createSessionIngestRuntime({
     //     cap). Serialized on _rawEmbedFlushChain so bursts don't stack full
     //     backlog scans; the ~60s tick still sweeps whatever this misses.
     if (insertedIds.length > 0) {
-      const run = flushRawEmbeddings(db, { limit: 200, ids: insertedIds })
+      const runOwnFlush = () => flushRawEmbeddings(db, { limit: 200, ids: insertedIds })
         .then((r) => {
           if (r.attempted > 0) log(`[embed] post-ingest raw flush (own) attempted=${r.attempted} embedded=${r.embedded}\n`)
           return r
         })
         .catch((err) => log(`[embed] post-ingest raw flush failed: ${err?.message || err}\n`))
-      let timer
-      await Promise.race([
-        run,
-        new Promise((resolve) => { timer = setTimeout(resolve, INGEST_EMBED_WAIT_MS) }),
-      ]).finally(() => clearTimeout(timer))
+      // Clear/manual-compact path opts out (embedWait:false): those rows are
+      // about to be summarized away, so dense-search immediacy is pointless and
+      // the bounded wait would only delay compaction. Enqueue the flush onto
+      // _rawEmbedFlushChain (append, don't await) so clear-path ingest bursts
+      // stay serialized like the backlog sweep — never running concurrent raw
+      // flushes. All other callers keep the awaited (bounded) wait so a
+      // following recall sees the rows.
+      if (args.embedWait === false) {
+        _rawEmbedFlushChain = _rawEmbedFlushChain
+          .catch(() => {})
+          .then(runOwnFlush)
+          .catch(() => {})
+      } else {
+        let timer
+        await Promise.race([
+          runOwnFlush(),
+          new Promise((resolve) => { timer = setTimeout(resolve, INGEST_EMBED_WAIT_MS) }),
+        ]).finally(() => clearTimeout(timer))
+      }
     }
     // Background backlog sweep — kicked, never awaited. Runs even when THIS
     // call inserted 0 rows, so pre-existing backlog is not left waiting for

package/src/runtime/memory/tool-defs.mjs

@@ -36,7 +36,7 @@ export const TOOL_DEFS = [
       properties: {
         query: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Search text, or array for independent fan-out queries.' },
         id: { anyOf: [{ type: 'number' }, { type: 'array', items: { type: 'number' }, minItems: 1 }], description: 'Exact #id(s) from recall. Do not invent ids.' },
-        period: { type: 'string', description: "last (all history newest-first), Nm/Nh/Nd (rolling), today/yesterday/this_week/last_week, all, YYYY-MM-DD, YYYY-MM-DD~YYYY-MM-DD, HH:MM~HH:MM (today), or 'YYYY-MM-DD HH:MM~HH:MM'." },
+        period: { type: 'string', description: "last (recent sessions grouped, newest-active first; limit=session count [default 5], offset=session paging), Nm/Nh/Nd (rolling), today/yesterday/this_week/last_week, all, YYYY-MM-DD, YYYY-MM-DD~YYYY-MM-DD, HH:MM~HH:MM (today), or 'YYYY-MM-DD HH:MM~HH:MM'." },
         limit: { type: 'number', description: 'Max entries.' },
         offset: { type: 'number', description: 'Skip entries.' },
         sort: { type: 'string', enum: ['importance', 'date'], description: 'importance or date.' },

package/src/runtime/shared/child-guardian.mjs

@@ -1,6 +1,7 @@
 'use strict';
 
 import { spawn, spawnSync } from 'node:child_process';
+import { detachedSpawnOpts } from './spawn-flags.mjs';
 
 function positiveInt(value) {
   const n = Number(value);
@@ -141,14 +142,13 @@ export function startChildGuardian({
         forceGraceMs: Math.max(100, Math.floor(Number(forceGraceMs) || Number(graceMs) || 3000)),
       }),
     ], {
-      detached: true,
       stdio: 'ignore',
-      windowsHide: true,
       env: {
         PATH: process.env.PATH || '',
         SystemRoot: process.env.SystemRoot || process.env.WINDIR || '',
         WINDIR: process.env.WINDIR || process.env.SystemRoot || '',
       },
+      ...detachedSpawnOpts,
     });
     guardian.unref?.();
     return { pid: guardian.pid || null, label, childPid: child };

package/src/runtime/shared/open-url.mjs

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import { isWSL } from './wsl.mjs';
+import { detachedSpawnOpts } from './spawn-flags.mjs';
 
 /**
  * Open a URL in the user's default browser. Best-effort and non-blocking.
@@ -29,7 +30,7 @@ function tryOpenCandidates(candidates, index) {
   if (index >= candidates.length) return;
   const [cmd, args] = candidates[index];
   try {
-    const child = spawn(cmd, args, { stdio: 'ignore', detached: true, windowsHide: true });
+    const child = spawn(cmd, args, { stdio: 'ignore', ...detachedSpawnOpts });
     child.on('error', () => { tryOpenCandidates(candidates, index + 1); });
     child.unref();
   } catch {

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

@@ -0,0 +1,350 @@
+/**
+ * PG-backed schedules store — the single source of truth for registered
+ * schedules (schema `scheduler`, table `scheduler.schedules`).
+ *
+ * All schedule readers/writers (scheduler.mjs, config.mjs, channel-admin.mjs)
+ * go through this module. Legacy `<dataDir>/schedules/<name>/SCHEDULE.md`
+ * files are imported once by the migration hook in getDb and the directory is
+ * renamed to `schedules.migrated`; the old file-based schedules-store.mjs has
+ * been removed.
+ *
+ * DDL is idempotent and runs once on the first call per process. All queries
+ * fully-qualify `scheduler.schedules` so they are correct regardless of the
+ * connection search_path.
+ */
+
+import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
+import { resolvePluginData } from './plugin-paths.mjs';
+import { readdirSync, readFileSync, renameSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { readMarkdownDocument } from './markdown-frontmatter.mjs';
+
+const SCHEMA = 'scheduler';
+
+// ---------------------------------------------------------------------------
+// Lazy connection + one-shot idempotent DDL (keyed per resolved dataDir).
+// ---------------------------------------------------------------------------
+
+const _ready = new Map(); // dataDir → Promise<db>
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS scheduler.schedules (
+  name           text PRIMARY KEY,
+  description    text NOT NULL DEFAULT '',
+  when_at        timestamptz,
+  when_cron      text,
+  timezone       text,
+  target         text NOT NULL CHECK (target IN ('channel','session')),
+  channel_id     text,
+  model          text,
+  prompt         text NOT NULL,
+  enabled        boolean NOT NULL DEFAULT true,
+  status         text NOT NULL DEFAULT 'active' CHECK (status IN ('active','done')),
+  last_fired_at  timestamptz,
+  next_fire_at   timestamptz,
+  deferred_until timestamptz,
+  skipped_until  timestamptz,
+  created_at     timestamptz NOT NULL DEFAULT now(),
+  updated_at     timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT schedules_when_xor CHECK ((when_at IS NOT NULL) <> (when_cron IS NOT NULL))
+);
+`;
+
+async function getDb(dataDir = resolvePluginData()) {
+  if (_ready.has(dataDir)) return _ready.get(dataDir);
+  const p = (async () => {
+    const { db, pool } = await ensurePgInstance(dataDir, { schema: SCHEMA });
+    // Serialize the CREATE TABLE across concurrent first-boot processes on the
+    // same cluster-global advisory lock the adapter uses for schema bootstrap,
+    // so racing first calls can't run the DDL simultaneously.
+    await withSchemaBootstrapLock(pool, () => db.exec(DDL));
+    await migrateLegacySchedules(db, dataDir);
+    return db;
+  })();
+  _ready.set(dataDir, p);
+  try {
+    return await p;
+  } catch (err) {
+    _ready.delete(dataDir); // let the next call retry DDL after a transient failure
+    throw err;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// One-time legacy SCHEDULE.md migration (additive; runs once per dataDir on
+// first getDb, right after DDL). Imports every `<dataDir>/schedules/<name>/
+// SCHEDULE.md` not already present in the table (by name), using the same
+// days->cron folding as the admin write path, then renames the directory to
+// `schedules.migrated` (never deletes user data). Per-entry failures are
+// isolated and never block store readiness.
+// ---------------------------------------------------------------------------
+
+// Day-name / keyword -> cron day-of-week number (Sun=0 .. Sat=6).
+const MIGRATE_DAY_TO_DOW = {
+  sun: 0, sunday: 0,
+  mon: 1, monday: 1,
+  tue: 2, tues: 2, tuesday: 2,
+  wed: 3, weds: 3, wednesday: 3,
+  thu: 4, thur: 4, thurs: 4, thursday: 4,
+  fri: 5, friday: 5,
+  sat: 6, saturday: 6,
+};
+
+function foldLegacyDaysIntoCron(cron, days) {
+  const parts = String(cron || '').trim().split(/\s+/).filter(Boolean);
+  if (parts.length !== 5 && parts.length !== 6) {
+    throw new Error(`invalid cron "${cron}"`);
+  }
+  const raw = String(days || '').trim().toLowerCase();
+  const dowIndex = parts.length - 1;
+  // days absent -> keep the cron's own day-of-week field ('0 9 * * 1' stays
+  // Monday-only). Only an explicit selector rewrites the dow field.
+  if (!raw) return parts.join(' ');
+  let dow;
+  if (raw === 'daily' || raw === 'everyday' || raw === 'every day') dow = '*';
+  else if (raw === 'weekday' || raw === 'weekdays') dow = '1-5';
+  else if (raw === 'weekend' || raw === 'weekends') dow = '0,6';
+  else {
+    const nums = raw.split(/[\s,]+/).filter(Boolean).map((t) => (
+      /^[0-6]$/.test(t) ? Number(t) : MIGRATE_DAY_TO_DOW[t]
+    ));
+    if (nums.some((n) => n === undefined)) {
+      throw new Error(`days "${days}" is not a recognizable day selector`);
+    }
+    dow = nums.join(',');
+  }
+  parts[dowIndex] = dow;
+  return parts.join(' ');
+}
+
+async function migrateLegacySchedules(db, dataDir) {
+  const dir = join(dataDir, 'schedules');
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return; // no legacy schedules/ dir -> nothing to migrate
+  }
+  let imported = 0;
+  let skipped = 0;
+  const failed = [];
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    const name = ent.name;
+    try {
+      const { rows } = await db.query('SELECT 1 FROM scheduler.schedules WHERE name = $1', [name]);
+      if (rows.length) { skipped++; continue; }
+      let md;
+      try { md = readFileSync(join(dir, name, 'SCHEDULE.md'), 'utf8'); }
+      catch { skipped++; continue; }
+      const { frontmatter, body } = readMarkdownDocument(md);
+      const cron = foldLegacyDaysIntoCron(frontmatter.time, frontmatter.days);
+      const channel = String(frontmatter.channel || '').trim();
+      const enabled = frontmatter.enabled !== 'false' && frontmatter.enabled !== false;
+      await db.query(
+        `INSERT INTO scheduler.schedules
+           (name, description, when_cron, timezone, target, channel_id, model, prompt, enabled)
+         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
+         ON CONFLICT (name) DO NOTHING`,
+        [
+          name,
+          String(frontmatter.description || '').trim(),
+          cron,
+          frontmatter.timezone ? String(frontmatter.timezone).trim() : null,
+          channel ? 'channel' : 'session',
+          channel || null,
+          frontmatter.model ? String(frontmatter.model).trim() : null,
+          String(body || '').trim(),
+          enabled,
+        ],
+      );
+      imported++;
+    } catch (err) {
+      failed.push(name);
+      console.error(`[schedules] migration failed for "${name}": ${err?.message || err}`);
+    }
+  }
+  if (failed.length) {
+    // Some entries failed to import. Leave schedules/ in place (do NOT rename)
+    // so the next boot retries them; already-imported entries are skipped by
+    // the name check above, so retry is idempotent.
+    console.error(`[schedules] migrated ${imported} legacy schedule(s), ${failed.length} failed (${failed.join(', ')}); leaving schedules/ for retry`);
+    return;
+  }
+  try {
+    let target = `${dir}.migrated`;
+    if (existsSync(target)) target = `${dir}.migrated-${Date.now()}`;
+    renameSync(dir, target);
+  } catch (err) {
+    console.error(`[schedules] migrated ${imported} legacy schedule(s) but could not rename schedules/: ${err?.message || err}`);
+    return;
+  }
+  console.error(`[schedules] migrated ${imported} legacy schedule(s) (${skipped} skipped); renamed schedules/ -> schedules.migrated`);
+}
+
+// ---------------------------------------------------------------------------
+// Row <-> def mapping
+// ---------------------------------------------------------------------------
+
+function rowToDef(row) {
+  if (!row) return null;
+  return {
+    name:          row.name,
+    description:   row.description,
+    whenAt:        row.when_at,
+    whenCron:      row.when_cron,
+    timezone:      row.timezone,
+    target:        row.target,
+    channelId:     row.channel_id,
+    model:         row.model,
+    prompt:        row.prompt,
+    enabled:       row.enabled,
+    status:        row.status,
+    lastFiredAt:   row.last_fired_at,
+    nextFireAt:    row.next_fire_at,
+    deferredUntil: row.deferred_until,
+    skippedUntil:  row.skipped_until,
+    createdAt:     row.created_at,
+    updatedAt:     row.updated_at,
+  };
+}
+
+const COLS = 'name, description, when_at, when_cron, timezone, target, channel_id, model, prompt, enabled, status, last_fired_at, next_fire_at, deferred_until, skipped_until, created_at, updated_at';
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export async function listSchedules({ dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(`SELECT ${COLS} FROM scheduler.schedules ORDER BY name`);
+  return rows.map(rowToDef);
+}
+
+export async function getSchedule(name, { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(`SELECT ${COLS} FROM scheduler.schedules WHERE name = $1`, [name]);
+  return rowToDef(rows[0]);
+}
+
+/**
+ * Insert-or-replace a schedule by name. Exactly one of `whenAt`/`whenCron`
+ * must be provided (enforced by the table's XOR CHECK constraint).
+ */
+export async function upsertSchedule(def, { dataDir } = {}) {
+  if (!def || !def.name) throw new Error('upsertSchedule: def.name is required');
+  if (!def.prompt) throw new Error('upsertSchedule: def.prompt is required');
+  const db = await getDb(dataDir);
+  const params = [
+    def.name,
+    def.description ?? '',
+    def.whenAt ?? null,
+    def.whenCron ?? null,
+    def.timezone ?? null,
+    def.target,
+    def.channelId ?? null,
+    def.model ?? null,
+    def.prompt,
+    def.enabled ?? true,
+    def.status ?? 'active',
+    def.nextFireAt ?? null,
+  ];
+  const { rows } = await db.query(
+    `INSERT INTO scheduler.schedules
+       (name, description, when_at, when_cron, timezone, target, channel_id, model, prompt, enabled, status, next_fire_at)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)
+     ON CONFLICT (name) DO UPDATE SET
+       description  = EXCLUDED.description,
+       when_at      = EXCLUDED.when_at,
+       when_cron    = EXCLUDED.when_cron,
+       timezone     = EXCLUDED.timezone,
+       target       = EXCLUDED.target,
+       channel_id   = EXCLUDED.channel_id,
+       model        = EXCLUDED.model,
+       prompt       = EXCLUDED.prompt,
+       enabled      = EXCLUDED.enabled,
+       next_fire_at = EXCLUDED.next_fire_at,
+       -- Redefinition clears stale runtime state and reactivates so the
+       -- re-registered schedule is due again in listDue.
+       status         = 'active',
+       deferred_until = NULL,
+       skipped_until  = NULL,
+       last_fired_at  = NULL,
+       updated_at   = now()
+     RETURNING ${COLS}`,
+    params,
+  );
+  return rowToDef(rows[0]);
+}
+
+export async function deleteSchedule(name, { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rowCount } = await db.query(`DELETE FROM scheduler.schedules WHERE name = $1`, [name]);
+  return rowCount > 0;
+}
+
+export async function setEnabled(name, enabled, { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules SET enabled = $2, updated_at = now() WHERE name = $1 RETURNING ${COLS}`,
+    [name, !!enabled],
+  );
+  return rowToDef(rows[0]);
+}
+
+export async function markFired(name, ts = new Date(), { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules SET last_fired_at = $2, updated_at = now() WHERE name = $1 RETURNING ${COLS}`,
+    [name, ts],
+  );
+  return rowToDef(rows[0]);
+}
+
+export async function markDone(name, { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules SET status = 'done', next_fire_at = NULL, updated_at = now() WHERE name = $1 RETURNING ${COLS}`,
+    [name],
+  );
+  return rowToDef(rows[0]);
+}
+
+export async function setDeferred(name, untilTs, { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules SET deferred_until = $2, updated_at = now() WHERE name = $1 RETURNING ${COLS}`,
+    [name, untilTs ?? null],
+  );
+  return rowToDef(rows[0]);
+}
+
+export async function setSkippedUntil(name, ts, { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `UPDATE scheduler.schedules SET skipped_until = $2, updated_at = now() WHERE name = $1 RETURNING ${COLS}`,
+    [name, ts ?? null],
+  );
+  return rowToDef(rows[0]);
+}
+
+/**
+ * Schedules that are eligible to fire at `now`: active, enabled, with a
+ * next_fire_at at/before `now`, and not currently deferred or skipped past
+ * `now`.
+ */
+export async function listDue(now = new Date(), { dataDir } = {}) {
+  const db = await getDb(dataDir);
+  const { rows } = await db.query(
+    `SELECT ${COLS} FROM scheduler.schedules
+      WHERE status = 'active'
+        AND enabled = true
+        AND next_fire_at IS NOT NULL
+        AND next_fire_at <= $1
+        AND (deferred_until IS NULL OR deferred_until <= $1)
+        AND (skipped_until  IS NULL OR skipped_until  <= $1)
+      ORDER BY next_fire_at`,
+    [now],
+  );
+  return rows.map(rowToDef);
+}