negotium 0.1.12 → 0.1.13

package/dist/chunk-8f2sqmrj.js

@@ -1,1712 +0,0 @@
-// @bun
-import {
-  backgroundSessionProgress,
-  registerBackgroundSessionProvider
-} from "./chunk-h7bj5zwb.js";
-import"./chunk-tcs9qjps.js";
-import {
-  purgeTopicLogs,
-  rotateTopicLogs
-} from "./chunk-7k19pcg8.js";
-import"./chunk-8dy7e2a9.js";
-import"./chunk-9hjeemfz.js";
-import"./chunk-1k7t7bnx.js";
-import {
-  triggerTopicAiTurn
-} from "./chunk-xhm1rfpt.js";
-import {
-  isParticipant
-} from "./chunk-mnwaext5.js";
-import"./chunk-xpcps28p.js";
-import {
-  runtimeBus
-} from "./chunk-fbtb3v0s.js";
-import {
-  getTopic
-} from "./chunk-ejcm6zx8.js";
-import"./chunk-hp4g7wx7.js";
-import"./chunk-s74rdyqe.js";
-import"./chunk-k778y16p.js";
-import"./chunk-xag86ng3.js";
-import"./chunk-wx83ep8e.js";
-import {
-  buildStdioMcpServer,
-  registerRuntimeMcpServer
-} from "./chunk-00q25k7p.js";
-import"./chunk-gaknyw04.js";
-import"./chunk-mh5mexsf.js";
-import {
-  WORKSPACE_DIR,
-  resolveTopicWorkspaceDir
-} from "./chunk-ezs352qs.js";
-import"./chunk-j0kjscb7.js";
-import {
-  abortRoom,
-  cancelDeferredInject,
-  getRoomQuery,
-  listRuntimeTurnLeases
-} from "./chunk-82qhv1mq.js";
-import {
-  logger
-} from "./chunk-ffefbd3r.js";
-import {
-  db
-} from "./chunk-81tbfbmt.js";
-import"./chunk-sffqdkvq.js";
-import"./chunk-f5xgprg1.js";
-import"./chunk-hwy3n31w.js";
-
-// ../../packages/module-cron/src/store.ts
-import { randomUUID } from "crypto";
-
-// ../../packages/module-cron/src/schedule.ts
-var FIELD_RANGES = [
-  [0, 59],
-  [0, 23],
-  [1, 31],
-  [1, 12],
-  [0, 7]
-];
-function parseNumber(raw, min, max) {
-  if (!/^\d+$/.test(raw))
-    throw new Error(`invalid cron value: ${raw}`);
-  const value = Number.parseInt(raw, 10);
-  if (value < min || value > max) {
-    throw new Error(`cron value ${value} is outside ${min}-${max}`);
-  }
-  return value;
-}
-function parseField(raw, min, max, normalize) {
-  const values = new Set;
-  const wildcard = raw === "*";
-  for (const item of raw.split(",")) {
-    if (!item)
-      throw new Error("empty cron list item");
-    const [base, stepRaw, extra] = item.split("/");
-    if (extra !== undefined)
-      throw new Error(`invalid cron step: ${item}`);
-    const step = stepRaw === undefined ? 1 : parseNumber(stepRaw, 1, max - min + 1);
-    let start;
-    let end;
-    if (base === "*") {
-      start = min;
-      end = max;
-    } else if (base.includes("-")) {
-      const [startRaw, endRaw, rangeExtra] = base.split("-");
-      if (!startRaw || !endRaw || rangeExtra !== undefined) {
-        throw new Error(`invalid cron range: ${base}`);
-      }
-      start = parseNumber(startRaw, min, max);
-      end = parseNumber(endRaw, min, max);
-      if (end < start)
-        throw new Error(`descending cron range: ${base}`);
-    } else {
-      start = parseNumber(base, min, max);
-      end = stepRaw === undefined ? start : max;
-    }
-    for (let value = start;value <= end; value += step) {
-      values.add(normalize ? normalize(value) : value);
-    }
-  }
-  return { values, wildcard };
-}
-function parseCronExpression(expression) {
-  const fields = expression.trim().split(/\s+/);
-  if (fields.length !== 5)
-    throw new Error("cron expression must have exactly 5 fields");
-  const parsed = fields.map((field, index) => {
-    const [min, max] = FIELD_RANGES[index];
-    return parseField(field, min, max, index === 4 ? (value) => value === 7 ? 0 : value : undefined);
-  });
-  return {
-    minute: parsed[0],
-    hour: parsed[1],
-    dayOfMonth: parsed[2],
-    month: parsed[3],
-    dayOfWeek: parsed[4]
-  };
-}
-function validateCronExpression(expression) {
-  try {
-    parseCronExpression(expression);
-    return { ok: true };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-}
-var formatters = new Map;
-function normalizeCronTimezone(timezone) {
-  const value = timezone?.trim();
-  if (!value)
-    return;
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: value }).format(new Date);
-    return value;
-  } catch {
-    return;
-  }
-}
-function dateParts(date, timezone) {
-  if (!timezone) {
-    return {
-      minute: date.getMinutes(),
-      hour: date.getHours(),
-      dayOfMonth: date.getDate(),
-      month: date.getMonth() + 1,
-      dayOfWeek: date.getDay()
-    };
-  }
-  let formatter = formatters.get(timezone);
-  if (!formatter) {
-    formatter = new Intl.DateTimeFormat("en-US", {
-      timeZone: timezone,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      hourCycle: "h23"
-    });
-    formatters.set(timezone, formatter);
-  }
-  const values = Object.fromEntries(formatter.formatToParts(date).filter((part) => part.type !== "literal").map((part) => [part.type, Number.parseInt(part.value, 10)]));
-  const year = values.year;
-  const month = values.month;
-  const dayOfMonth = values.day;
-  return {
-    minute: values.minute,
-    hour: values.hour,
-    dayOfMonth,
-    month,
-    dayOfWeek: new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay()
-  };
-}
-function cronMatchesDate(expression, date, timezone) {
-  const cron = typeof expression === "string" ? parseCronExpression(expression) : expression;
-  const parts = dateParts(date, timezone);
-  return cronMatchesParts(cron, parts);
-}
-function cronMatchesParts(cron, parts) {
-  if (!cron.minute.values.has(parts.minute))
-    return false;
-  if (!cron.hour.values.has(parts.hour))
-    return false;
-  if (!cron.month.values.has(parts.month))
-    return false;
-  const dom = cron.dayOfMonth.values.has(parts.dayOfMonth);
-  const dow = cron.dayOfWeek.values.has(parts.dayOfWeek);
-  const dayMatches = cron.dayOfMonth.wildcard ? dow : cron.dayOfWeek.wildcard ? dom : dom || dow;
-  return dayMatches;
-}
-function computeNextCronRun(expression, after = new Date, timezone) {
-  const parsed = parseCronExpression(expression);
-  if (timezone && !normalizeCronTimezone(timezone))
-    throw new Error(`invalid timezone: ${timezone}`);
-  const candidate = new Date(after.getTime());
-  candidate.setSeconds(0, 0);
-  candidate.setMinutes(candidate.getMinutes() + 1);
-  const deadline = candidate.getTime() + 366 * 24 * 60 * 60000 * 5;
-  while (candidate.getTime() <= deadline) {
-    const parts = dateParts(candidate, timezone);
-    if (cronMatchesParts(parsed, parts))
-      return candidate;
-    const dom = parsed.dayOfMonth.values.has(parts.dayOfMonth);
-    const dow = parsed.dayOfWeek.values.has(parts.dayOfWeek);
-    const dayMatches = parsed.dayOfMonth.wildcard ? dow : parsed.dayOfWeek.wildcard ? dom : dom || dow;
-    if (!parsed.month.values.has(parts.month) || !dayMatches || !parsed.hour.values.has(parts.hour)) {
-      const minutes = parts.minute === 0 ? 60 : 60 - parts.minute;
-      candidate.setTime(candidate.getTime() + minutes * 60000);
-      continue;
-    }
-    candidate.setTime(candidate.getTime() + 60000);
-  }
-  throw new Error("cron expression has no match within 5 years");
-}
-
-// ../../packages/module-cron/src/scripts.ts
-import { spawn } from "child_process";
-import { existsSync, mkdirSync, readdirSync } from "fs";
-import { resolve, sep } from "path";
-var CRON_JOBS_DIR = resolve(process.env.NEGOTIUM_CRON_JOBS_DIR?.trim() || resolve(WORKSPACE_DIR, "cron", "jobs"));
-var DEFAULT_SCRIPT_TIMEOUT_MS = 10 * 60000;
-var DEFAULT_OUTPUT_LIMIT_BYTES = 1024 * 1024;
-var KILL_GRACE_MS = 2500;
-
-class CronScriptError extends Error {
-  kind;
-  constructor(message, kind = "error") {
-    super(message);
-    this.kind = kind;
-    this.name = "CronScriptError";
-  }
-}
-function validateCronScriptName(script) {
-  if (!/^[A-Za-z0-9_][A-Za-z0-9_.-]*\.py$/.test(script) || script.includes("..") || script.includes("/") || script.includes("\\")) {
-    return { ok: false, error: `script must be a plain .py filename under ${CRON_JOBS_DIR}` };
-  }
-  return { ok: true };
-}
-function resolveCronScriptPath(script) {
-  const valid = validateCronScriptName(script);
-  if (!valid.ok)
-    throw new Error(valid.error);
-  const path = resolve(CRON_JOBS_DIR, script);
-  if (!path.startsWith(`${CRON_JOBS_DIR}${sep}`))
-    throw new Error("script path escaped jobs directory");
-  return path;
-}
-function listCronScripts() {
-  mkdirSync(CRON_JOBS_DIR, { recursive: true });
-  return readdirSync(CRON_JOBS_DIR, { withFileTypes: true }).filter((entry) => entry.isFile() && validateCronScriptName(entry.name).ok).map((entry) => entry.name).sort();
-}
-function cronScriptExists(script) {
-  try {
-    return existsSync(resolveCronScriptPath(script));
-  } catch {
-    return false;
-  }
-}
-function commandForScript(scriptPath) {
-  const configured = process.env.NEGOTIUM_CRON_PYTHON?.trim();
-  if (configured)
-    return { executable: configured, args: [scriptPath] };
-  if (Bun.which("uv")) {
-    return {
-      executable: "uv",
-      args: ["run", "--project", CRON_JOBS_DIR, "python", scriptPath]
-    };
-  }
-  return { executable: "python3", args: [scriptPath] };
-}
-function signalTree(child, signal) {
-  if (!child.pid)
-    return;
-  try {
-    process.kill(-child.pid, signal);
-  } catch {
-    try {
-      child.kill(signal);
-    } catch {}
-  }
-}
-async function runCronPromptScript(options) {
-  if (options.signal?.aborted)
-    throw new CronScriptError("script run aborted");
-  const scriptPath = resolveCronScriptPath(options.script);
-  if (!existsSync(scriptPath))
-    throw new CronScriptError(`cron script not found: ${options.script}`);
-  const timeoutMs = Math.max(5000, options.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS);
-  const outputLimitBytes = Math.max(1024, options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES);
-  const command = commandForScript(scriptPath);
-  let child;
-  try {
-    child = spawn(command.executable, command.args, {
-      cwd: options.cwd,
-      detached: true,
-      env: {
-        ...process.env,
-        NEGOTIUM_CRON_JOB_ID: options.jobId,
-        NEGOTIUM_CRON_TOPIC_ID: options.topicId
-      },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch (error) {
-    throw new CronScriptError(`script spawn failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!child.stdout || !child.stderr) {
-    signalTree(child, "SIGKILL");
-    throw new CronScriptError("script spawn failed: stdout/stderr pipes unavailable");
-  }
-  const stdout = [];
-  const stderr = [];
-  let outputBytes = 0;
-  let failure;
-  let killTimer;
-  const terminate = (error) => {
-    if (failure)
-      return;
-    failure = error;
-    signalTree(child, "SIGTERM");
-    killTimer = setTimeout(() => signalTree(child, "SIGKILL"), KILL_GRACE_MS);
-    killTimer.unref?.();
-  };
-  const collect = (target) => (chunk) => {
-    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    outputBytes += buffer.length;
-    if (outputBytes > outputLimitBytes) {
-      terminate(new CronScriptError(`script output exceeded ${outputLimitBytes} bytes`, "output-limit"));
-      return;
-    }
-    target.push(buffer);
-  };
-  child.stdout.on("data", collect(stdout));
-  child.stderr.on("data", collect(stderr));
-  const timeout = setTimeout(() => terminate(new CronScriptError(`script exceeded ${timeoutMs}ms`, "timeout")), timeoutMs);
-  timeout.unref?.();
-  const onAbort = () => terminate(new CronScriptError("script run aborted"));
-  options.signal?.addEventListener("abort", onAbort, { once: true });
-  const result = await new Promise((resolvePromise, reject) => {
-    child.once("error", reject);
-    child.once("close", (code, signal) => resolvePromise({ code, signal }));
-  }).finally(() => {
-    clearTimeout(timeout);
-    if (killTimer)
-      clearTimeout(killTimer);
-    options.signal?.removeEventListener("abort", onAbort);
-  });
-  if (failure)
-    throw failure;
-  if (result.code !== 0) {
-    const detail = result.signal ? `signal ${result.signal}` : `code ${result.code ?? "unknown"}`;
-    const errorText = Buffer.concat(stderr).toString("utf8").trim();
-    throw new CronScriptError(`script exited with ${detail}${errorText ? `: ${errorText.slice(0, 2000)}` : ""}`);
-  }
-  return Buffer.concat(stdout).toString("utf8").trim();
-}
-
-// ../../packages/module-cron/src/store.ts
-var schemaReady = false;
-var db2 = db;
-function configureCronDatabase(database) {
-  const previous = db2;
-  db2 = database;
-  schemaReady = false;
-  let disposed = false;
-  return () => {
-    if (disposed)
-      return;
-    disposed = true;
-    db2 = previous;
-    schemaReady = false;
-  };
-}
-function ensureCronSchema() {
-  if (schemaReady)
-    return;
-  db2.exec(`
-    CREATE TABLE IF NOT EXISTS negotium_cron_jobs (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      owner_user_id TEXT NOT NULL,
-      topic_id TEXT NOT NULL REFERENCES api_topics(id) ON DELETE CASCADE,
-      prompt TEXT NOT NULL,
-      script TEXT,
-      summary TEXT,
-      schedule TEXT NOT NULL,
-      timezone TEXT,
-      enabled INTEGER NOT NULL DEFAULT 1,
-      agent TEXT,
-      model TEXT,
-      effort TEXT,
-      session_id TEXT,
-      next_run_at TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_negotium_cron_owner_name
-      ON negotium_cron_jobs(owner_user_id, name);
-    CREATE INDEX IF NOT EXISTS idx_negotium_cron_due
-      ON negotium_cron_jobs(enabled, next_run_at);
-    CREATE TABLE IF NOT EXISTS negotium_cron_runs (
-      id TEXT PRIMARY KEY,
-      job_id TEXT NOT NULL REFERENCES negotium_cron_jobs(id) ON DELETE CASCADE,
-      source TEXT NOT NULL,
-      scheduled_at TEXT NOT NULL,
-      started_at TEXT,
-      finished_at TEXT,
-      status TEXT NOT NULL,
-      query_id TEXT,
-      duration_ms INTEGER,
-      output_preview TEXT,
-      error TEXT,
-      exit_code INTEGER,
-      topic_id TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_negotium_cron_runs_job
-      ON negotium_cron_runs(job_id, scheduled_at DESC);
-    CREATE TABLE IF NOT EXISTS negotium_cron_requests (
-      id TEXT PRIMARY KEY,
-      job_id TEXT NOT NULL REFERENCES negotium_cron_jobs(id) ON DELETE CASCADE,
-      requested_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS negotium_cron_cancellations (
-      id TEXT PRIMARY KEY,
-      job_id TEXT NOT NULL REFERENCES negotium_cron_jobs(id) ON DELETE CASCADE,
-      requested_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS negotium_cron_topic_sessions (
-      topic_id TEXT NOT NULL,
-      agent TEXT NOT NULL,
-      owner_user_id TEXT NOT NULL,
-      session_id TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (topic_id, agent)
-    );
-    CREATE INDEX IF NOT EXISTS idx_negotium_cron_topic_sessions_owner
-      ON negotium_cron_topic_sessions(owner_user_id, topic_id);
-    CREATE TABLE IF NOT EXISTS negotium_cron_topic_context (
-      topic_id TEXT PRIMARY KEY REFERENCES api_topics(id) ON DELETE CASCADE,
-      successful_runs_since_rotation INTEGER NOT NULL DEFAULT 0,
-      last_rotated_at TEXT,
-      updated_at TEXT NOT NULL
-    );
-  `);
-  const jobColumns = new Set(db2.query("PRAGMA table_info(negotium_cron_jobs)").all().map((column) => column.name));
-  if (!jobColumns.has("script")) {
-    db2.exec("ALTER TABLE negotium_cron_jobs ADD COLUMN script TEXT");
-  }
-  if (!jobColumns.has("summary")) {
-    db2.exec("ALTER TABLE negotium_cron_jobs ADD COLUMN summary TEXT");
-  }
-  const runColumns = new Set(db2.query("PRAGMA table_info(negotium_cron_runs)").all().map((column) => column.name));
-  if (!runColumns.has("exit_code")) {
-    db2.exec("ALTER TABLE negotium_cron_runs ADD COLUMN exit_code INTEGER");
-  }
-  if (!runColumns.has("topic_id")) {
-    db2.exec("ALTER TABLE negotium_cron_runs ADD COLUMN topic_id TEXT");
-  }
-  const legacySessions = db2.query(`SELECT j.topic_id, COALESCE(j.agent, t.agent) AS agent,
-              j.owner_user_id, j.session_id, j.created_at, j.updated_at
-       FROM negotium_cron_jobs j
-       LEFT JOIN api_topics t ON t.id = j.topic_id
-       WHERE j.session_id IS NOT NULL AND COALESCE(j.agent, t.agent) IS NOT NULL
-       ORDER BY j.updated_at ASC`).all();
-  for (const legacy of legacySessions) {
-    db2.query(`INSERT INTO negotium_cron_topic_sessions
-         (topic_id,agent,owner_user_id,session_id,created_at,updated_at)
-       VALUES (?,?,?,?,?,?)
-       ON CONFLICT(topic_id,agent) DO UPDATE SET
-         owner_user_id = excluded.owner_user_id,
-         session_id = excluded.session_id,
-         updated_at = excluded.updated_at`).run(legacy.topic_id, legacy.agent, legacy.owner_user_id, legacy.session_id, legacy.created_at, legacy.updated_at);
-  }
-  if (legacySessions.length > 0) {
-    db2.query("UPDATE negotium_cron_jobs SET session_id = NULL WHERE session_id IS NOT NULL").run();
-  }
-  schemaReady = true;
-}
-function toJob(row) {
-  const topicAgent = row.agent ? row.agent : db2.query("SELECT agent FROM api_topics WHERE id = ?").get(row.topic_id)?.agent;
-  const topicSession = topicAgent ? db2.query("SELECT session_id FROM negotium_cron_topic_sessions WHERE topic_id = ? AND agent = ?").get(row.topic_id, topicAgent) : undefined;
-  return {
-    id: row.id,
-    name: row.name,
-    ownerUserId: row.owner_user_id,
-    topicId: row.topic_id,
-    prompt: row.prompt.trim() || undefined,
-    script: row.script?.trim() || undefined,
-    summary: row.summary?.trim() || undefined,
-    schedule: row.schedule,
-    timezone: row.timezone ?? undefined,
-    enabled: row.enabled !== 0,
-    agent: row.agent ?? undefined,
-    model: row.model ?? undefined,
-    effort: row.effort ?? undefined,
-    sessionId: topicSession?.session_id,
-    nextRunAt: row.next_run_at,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
-}
-function toTopicSession(row) {
-  return {
-    topicId: row.topic_id,
-    agent: row.agent,
-    ownerUserId: row.owner_user_id,
-    sessionId: row.session_id,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
-}
-function toTopicContext(row) {
-  return {
-    topicId: row.topic_id,
-    successfulRunsSinceRotation: row.successful_runs_since_rotation,
-    lastRotatedAt: row.last_rotated_at ?? undefined,
-    updatedAt: row.updated_at
-  };
-}
-function cronTopicSessionName(topicId) {
-  return `cron-${topicId}`;
-}
-function toRun(row) {
-  return {
-    id: row.id,
-    jobId: row.job_id,
-    source: row.source,
-    scheduledAt: row.scheduled_at,
-    startedAt: row.started_at ?? undefined,
-    finishedAt: row.finished_at ?? undefined,
-    status: row.status,
-    queryId: row.query_id ?? undefined,
-    durationMs: row.duration_ms ?? undefined,
-    outputPreview: row.output_preview ?? undefined,
-    error: row.error ?? undefined,
-    exitCode: row.exit_code ?? undefined
-  };
-}
-function createCronJob(input) {
-  ensureCronSchema();
-  const prompt = input.prompt?.trim() || undefined;
-  const script = input.script?.trim() || undefined;
-  if (Boolean(prompt) === Boolean(script)) {
-    throw new Error("cron job requires exactly one of prompt or script");
-  }
-  if (script) {
-    const valid = validateCronScriptName(script);
-    if (!valid.ok)
-      throw new Error(valid.error);
-  }
-  const otherOwner = db2.query(`SELECT owner_user_id
-       FROM negotium_cron_jobs
-       WHERE topic_id = ? AND owner_user_id <> ?
-       LIMIT 1`).get(input.topicId, input.ownerUserId);
-  if (otherOwner) {
-    throw new Error(`topic cron context is already owned by ${otherOwner.owner_user_id}; ` + "all cron jobs in one topic must share one owner");
-  }
-  parseCronExpression(input.schedule);
-  const timezone = input.timezone ? normalizeCronTimezone(input.timezone) : undefined;
-  if (input.timezone && !timezone)
-    throw new Error(`invalid timezone: ${input.timezone}`);
-  const now = input.now ?? new Date;
-  const nowIso = now.toISOString();
-  const job = {
-    id: randomUUID(),
-    name: input.name,
-    ownerUserId: input.ownerUserId,
-    topicId: input.topicId,
-    prompt,
-    script,
-    summary: input.summary?.trim() || undefined,
-    schedule: input.schedule.trim(),
-    timezone,
-    enabled: true,
-    agent: input.agent,
-    model: input.model,
-    effort: input.effort,
-    nextRunAt: computeNextCronRun(input.schedule, now, timezone).toISOString(),
-    createdAt: nowIso,
-    updatedAt: nowIso
-  };
-  db2.query(`INSERT INTO negotium_cron_jobs
-      (id,name,owner_user_id,topic_id,prompt,script,summary,schedule,timezone,enabled,agent,model,effort,session_id,next_run_at,created_at,updated_at)
-     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(job.id, job.name, job.ownerUserId, job.topicId, job.prompt ?? "", job.script ?? null, job.summary ?? null, job.schedule, job.timezone ?? null, 1, job.agent ?? null, job.model ?? null, job.effort ?? null, null, job.nextRunAt, job.createdAt, job.updatedAt);
-  return job;
-}
-function listCronJobs(ownerUserId) {
-  ensureCronSchema();
-  const rows = ownerUserId ? db2.query("SELECT * FROM negotium_cron_jobs WHERE owner_user_id = ? ORDER BY created_at DESC").all(ownerUserId) : db2.query("SELECT * FROM negotium_cron_jobs ORDER BY created_at DESC").all();
-  return rows.map(toJob);
-}
-function listEnabledCronJobs() {
-  ensureCronSchema();
-  return db2.query("SELECT * FROM negotium_cron_jobs WHERE enabled = 1 ORDER BY created_at DESC").all().map(toJob);
-}
-function listCronJobsForTopic(topicId) {
-  ensureCronSchema();
-  return db2.query("SELECT * FROM negotium_cron_jobs WHERE topic_id = ? ORDER BY created_at DESC").all(topicId).map(toJob);
-}
-function listCronJobsForTopicOwner(topicId, ownerUserId) {
-  ensureCronSchema();
-  return db2.query("SELECT * FROM negotium_cron_jobs WHERE topic_id = ? AND owner_user_id = ? ORDER BY created_at DESC").all(topicId, ownerUserId).map(toJob);
-}
-function getCronJob(id) {
-  ensureCronSchema();
-  const row = db2.query("SELECT * FROM negotium_cron_jobs WHERE id = ?").get(id);
-  return row ? toJob(row) : null;
-}
-function getCronJobByOwnerAndName(ownerUserId, name) {
-  ensureCronSchema();
-  const row = db2.query("SELECT * FROM negotium_cron_jobs WHERE owner_user_id = ? AND name = ?").get(ownerUserId, name);
-  return row ? toJob(row) : null;
-}
-function cronJobPatchChangesContext(job, patch) {
-  return patch.topicId !== undefined && patch.topicId !== job.topicId || patch.prompt !== undefined && (patch.prompt?.trim() || undefined) !== job.prompt || patch.script !== undefined && (patch.script?.trim() || undefined) !== job.script || patch.agent !== undefined && (patch.agent ?? undefined) !== job.agent || patch.model !== undefined && (patch.model?.trim() || undefined) !== job.model || patch.effort !== undefined && (patch.effort ?? undefined) !== job.effort;
-}
-function updateCronJob(id, patch, now = new Date) {
-  ensureCronSchema();
-  const job = getCronJob(id);
-  if (!job)
-    return null;
-  if (Object.values(patch).every((value) => value === undefined))
-    return job;
-  const nextName = patch.name !== undefined ? patch.name.trim() : job.name;
-  if (!/^[A-Za-z0-9_-]+$/.test(nextName)) {
-    throw new Error("name must use only letters, numbers, dashes, and underscores");
-  }
-  const nextPrompt = patch.prompt !== undefined ? patch.prompt?.trim() || undefined : job.prompt;
-  const nextScript = patch.script !== undefined ? patch.script?.trim() || undefined : job.script;
-  if (Boolean(nextPrompt) === Boolean(nextScript)) {
-    throw new Error("cron job requires exactly one of prompt or script");
-  }
-  if (nextScript) {
-    const valid = validateCronScriptName(nextScript);
-    if (!valid.ok)
-      throw new Error(valid.error);
-  }
-  const nextSchedule = patch.schedule?.trim() ?? job.schedule;
-  parseCronExpression(nextSchedule);
-  const rawTimezone = patch.timezone !== undefined ? patch.timezone?.trim() || undefined : job.timezone;
-  const nextTimezone = rawTimezone ? normalizeCronTimezone(rawTimezone) : undefined;
-  if (rawTimezone && !nextTimezone)
-    throw new Error(`invalid timezone: ${rawTimezone}`);
-  const nextTopicId = patch.topicId?.trim() || job.topicId;
-  const otherOwner = db2.query(`SELECT owner_user_id FROM negotium_cron_jobs
-       WHERE topic_id = ? AND owner_user_id <> ? AND id <> ? LIMIT 1`).get(nextTopicId, job.ownerUserId, id);
-  if (otherOwner) {
-    throw new Error(`topic cron context is already owned by ${otherOwner.owner_user_id}; ` + "all cron jobs in one topic must share one owner");
-  }
-  const enabled = patch.enabled ?? job.enabled;
-  const scheduleChanged = nextSchedule !== job.schedule || nextTimezone !== job.timezone;
-  const nextRunAt = enabled && (scheduleChanged || !job.enabled && enabled) ? computeNextCronRun(nextSchedule, now, nextTimezone).toISOString() : job.nextRunAt;
-  const timestamp = now.toISOString();
-  const sessionSensitiveChanged = cronJobPatchChangesContext(job, patch);
-  if (sessionSensitiveChanged) {
-    const active = db2.query("SELECT 1 FROM negotium_cron_runs WHERE job_id = ? AND status IN ('pending','running') LIMIT 1").get(id);
-    if (active) {
-      throw new Error("cannot change Cron context while a run is active; cancel it first");
-    }
-  }
-  db2.transaction(() => {
-    db2.query(`UPDATE negotium_cron_jobs SET
-         name = ?, topic_id = ?, prompt = ?, script = ?, summary = ?, schedule = ?, timezone = ?,
-         enabled = ?, agent = ?, model = ?, effort = ?, next_run_at = ?, updated_at = ?
-       WHERE id = ?`).run(nextName, nextTopicId, nextPrompt ?? "", nextScript ?? null, patch.summary !== undefined ? patch.summary?.trim() || null : job.summary ?? null, nextSchedule, nextTimezone ?? null, enabled ? 1 : 0, patch.agent !== undefined ? patch.agent : job.agent ?? null, patch.model !== undefined ? patch.model?.trim() || null : job.model ?? null, patch.effort !== undefined ? patch.effort : job.effort ?? null, nextRunAt, timestamp, id);
-  })();
-  return getCronJob(id);
-}
-function updateCronJobSummaryIfPromptMatches(id, expectedPrompt, summary) {
-  ensureCronSchema();
-  const result = db2.query("UPDATE negotium_cron_jobs SET summary = ? WHERE id = ? AND prompt = ?").run(summary.trim(), id, expectedPrompt.trim());
-  return Number(result.changes) > 0;
-}
-function setCronJobEnabled(id, enabled, now = new Date) {
-  ensureCronSchema();
-  const job = getCronJob(id);
-  if (!job)
-    return null;
-  const nextRunAt = enabled ? computeNextCronRun(job.schedule, now, job.timezone).toISOString() : job.nextRunAt;
-  db2.query("UPDATE negotium_cron_jobs SET enabled = ?, next_run_at = ?, updated_at = ? WHERE id = ?").run(enabled ? 1 : 0, nextRunAt, now.toISOString(), id);
-  return getCronJob(id);
-}
-function setCronJobSessionId(id, sessionId) {
-  const job = getCronJob(id);
-  if (!job)
-    return;
-  const topic = db2.query("SELECT agent FROM api_topics WHERE id = ?").get(job.topicId);
-  const agent = job.agent ?? topic?.agent;
-  if (!agent)
-    return;
-  if (sessionId)
-    setCronTopicSession(job.topicId, agent, job.ownerUserId, sessionId);
-  else
-    resetCronTopicSessions(job.topicId);
-}
-function getCronTopicSession(topicId, agent) {
-  ensureCronSchema();
-  const row = db2.query("SELECT * FROM negotium_cron_topic_sessions WHERE topic_id = ? AND agent = ?").get(topicId, agent);
-  return row ? toTopicSession(row) : null;
-}
-function listCronTopicSessions(topicId) {
-  ensureCronSchema();
-  return db2.query("SELECT * FROM negotium_cron_topic_sessions WHERE topic_id = ? ORDER BY agent").all(topicId).map(toTopicSession);
-}
-function setCronTopicSession(topicId, agent, ownerUserId, sessionId, now = new Date) {
-  ensureCronSchema();
-  const timestamp = now.toISOString();
-  db2.query(`INSERT INTO negotium_cron_topic_sessions
-       (topic_id,agent,owner_user_id,session_id,created_at,updated_at)
-     VALUES (?,?,?,?,?,?)
-     ON CONFLICT(topic_id,agent) DO UPDATE SET
-       owner_user_id = excluded.owner_user_id,
-       session_id = excluded.session_id,
-       updated_at = excluded.updated_at`).run(topicId, agent, ownerUserId, sessionId, timestamp, timestamp);
-  return getCronTopicSession(topicId, agent);
-}
-function setCronTopicSessionIfJobUpdatedAt(jobId, expectedJobUpdatedAt, topicId, agent, ownerUserId, sessionId, now = new Date) {
-  ensureCronSchema();
-  let updated = false;
-  db2.transaction(() => {
-    const current = db2.query("SELECT topic_id, updated_at FROM negotium_cron_jobs WHERE id = ?").get(jobId);
-    if (!current || current.topic_id !== topicId || current.updated_at !== expectedJobUpdatedAt)
-      return;
-    setCronTopicSession(topicId, agent, ownerUserId, sessionId, now);
-    updated = true;
-  })();
-  return updated ? getCronTopicSession(topicId, agent) : null;
-}
-function clearCronTopicSession(topicId, agent) {
-  ensureCronSchema();
-  const result = db2.query("DELETE FROM negotium_cron_topic_sessions WHERE topic_id = ? AND agent = ?").run(topicId, agent);
-  return Number(result.changes) > 0;
-}
-function resetCronTopicSessions(topicId) {
-  ensureCronSchema();
-  const sessions = listCronTopicSessions(topicId);
-  db2.query("DELETE FROM negotium_cron_topic_sessions WHERE topic_id = ?").run(topicId);
-  return sessions;
-}
-function getCronTopicContext(topicId) {
-  ensureCronSchema();
-  const row = db2.query("SELECT * FROM negotium_cron_topic_context WHERE topic_id = ?").get(topicId);
-  return row ? toTopicContext(row) : null;
-}
-function incrementCronTopicSuccess(topicId, now) {
-  const timestamp = now.toISOString();
-  db2.query(`INSERT INTO negotium_cron_topic_context
-       (topic_id,successful_runs_since_rotation,last_rotated_at,updated_at)
-     VALUES (?,1,NULL,?)
-     ON CONFLICT(topic_id) DO UPDATE SET
-       successful_runs_since_rotation = successful_runs_since_rotation + 1,
-       updated_at = excluded.updated_at`).run(topicId, timestamp);
-  return getCronTopicContext(topicId).successfulRunsSinceRotation;
-}
-function markCronTopicContextRotated(topicId, now = new Date) {
-  ensureCronSchema();
-  const timestamp = now.toISOString();
-  db2.query(`INSERT INTO negotium_cron_topic_context
-       (topic_id,successful_runs_since_rotation,last_rotated_at,updated_at)
-     VALUES (?,0,?,?)
-     ON CONFLICT(topic_id) DO UPDATE SET
-       successful_runs_since_rotation = 0,
-       last_rotated_at = excluded.last_rotated_at,
-       updated_at = excluded.updated_at`).run(topicId, timestamp, timestamp);
-}
-function resetCronTopicContextState(topicId) {
-  ensureCronSchema();
-  const result = db2.query("DELETE FROM negotium_cron_topic_context WHERE topic_id = ?").run(topicId);
-  return Number(result.changes) > 0;
-}
-function listOrphanedCronTopicSessions() {
-  ensureCronSchema();
-  return db2.query(`SELECT s.* FROM negotium_cron_topic_sessions s
-         LEFT JOIN api_topics t ON t.id = s.topic_id
-         WHERE t.id IS NULL
-         ORDER BY s.topic_id, s.agent`).all().map(toTopicSession);
-}
-function deleteCronJob(id) {
-  ensureCronSchema();
-  const result = db2.query("DELETE FROM negotium_cron_jobs WHERE id = ?").run(id);
-  return Number(result.changes) > 0;
-}
-function requestCronRun(jobId, now = new Date) {
-  ensureCronSchema();
-  const id = randomUUID();
-  db2.query("INSERT INTO negotium_cron_requests (id,job_id,requested_at) VALUES (?,?,?)").run(id, jobId, now.toISOString());
-  return id;
-}
-function requestCronCancel(jobId, now = new Date) {
-  ensureCronSchema();
-  const id = randomUUID();
-  db2.query("INSERT INTO negotium_cron_cancellations (id,job_id,requested_at) VALUES (?,?,?)").run(id, jobId, now.toISOString());
-  return id;
-}
-function claimCronCancellations(limit = 100) {
-  ensureCronSchema();
-  const jobIds = [];
-  db2.transaction(() => {
-    const rows = db2.query(`SELECT id, job_id FROM negotium_cron_cancellations
-         ORDER BY requested_at LIMIT ?`).all(limit);
-    for (const row of rows) {
-      db2.query("DELETE FROM negotium_cron_cancellations WHERE id = ?").run(row.id);
-      if (!jobIds.includes(row.job_id))
-        jobIds.push(row.job_id);
-    }
-  })();
-  return jobIds;
-}
-function insertRun(jobId, topicId, source, scheduledAt) {
-  const run = {
-    id: randomUUID(),
-    jobId,
-    source,
-    scheduledAt,
-    status: "pending"
-  };
-  db2.query("INSERT INTO negotium_cron_runs (id,job_id,topic_id,source,scheduled_at,status) VALUES (?,?,?,?,?,?)").run(run.id, run.jobId, topicId, run.source, run.scheduledAt, run.status);
-  return run;
-}
-function claimCronRuns(now = new Date, limit = 20) {
-  ensureCronSchema();
-  const claimed = [];
-  db2.transaction(() => {
-    const requests = db2.query(`SELECT r.id AS request_id, r.requested_at, j.*
-         FROM negotium_cron_requests r JOIN negotium_cron_jobs j ON j.id = r.job_id
-         ORDER BY r.requested_at LIMIT ?`).all(limit);
-    for (const row of requests) {
-      db2.query("DELETE FROM negotium_cron_requests WHERE id = ?").run(row.request_id);
-      claimed.push({
-        job: toJob(row),
-        run: insertRun(row.id, row.topic_id, "manual", row.requested_at)
-      });
-    }
-    const remaining = Math.max(0, limit - claimed.length);
-    if (remaining === 0)
-      return;
-    const due = db2.query(`SELECT * FROM negotium_cron_jobs
-         WHERE enabled = 1 AND next_run_at <= ? ORDER BY next_run_at LIMIT ?`).all(now.toISOString(), remaining);
-    for (const row of due) {
-      const job = toJob(row);
-      const run = insertRun(job.id, job.topicId, "schedule", job.nextRunAt);
-      const nextRunAt = computeNextCronRun(job.schedule, now, job.timezone).toISOString();
-      db2.query("UPDATE negotium_cron_jobs SET next_run_at = ? WHERE id = ?").run(nextRunAt, job.id);
-      claimed.push({ job: { ...job, nextRunAt }, run });
-    }
-  })();
-  return claimed;
-}
-function markCronRunStarted(runId, queryId, now = new Date) {
-  ensureCronSchema();
-  db2.query(`UPDATE negotium_cron_runs
-     SET status = 'running', query_id = ?, started_at = COALESCE(started_at, ?)
-     WHERE id = ?`).run(queryId, now.toISOString(), runId);
-}
-function finishCronRun(runId, result, now = new Date) {
-  ensureCronSchema();
-  const row = db2.query(`SELECT r.started_at, r.status, COALESCE(r.topic_id, j.topic_id) AS topic_id
-       FROM negotium_cron_runs r
-       JOIN negotium_cron_jobs j ON j.id = r.job_id
-       WHERE r.id = ?`).get(runId);
-  if (!row || row.status !== "pending" && row.status !== "running")
-    return null;
-  const durationMs = row?.started_at ? Math.max(0, now.getTime() - Date.parse(row.started_at)) : null;
-  let successfulRunsSinceRotation = null;
-  db2.transaction(() => {
-    const exitCode = result.exitCode ?? { succeeded: 0, skipped: 0, failed: 1, aborted: 130, interrupted: 137 }[result.status];
-    const updated = db2.query(`UPDATE negotium_cron_runs
-       SET status = ?, finished_at = ?, duration_ms = ?, output_preview = ?, error = ?, exit_code = ?
-       WHERE id = ? AND status IN ('pending','running')`).run(result.status, now.toISOString(), durationMs, result.outputPreview?.slice(0, 500) ?? null, result.error ?? null, exitCode, runId);
-    if (Number(updated.changes) > 0 && result.status === "succeeded") {
-      successfulRunsSinceRotation = incrementCronTopicSuccess(row.topic_id, now);
-    }
-  })();
-  return successfulRunsSinceRotation;
-}
-function listCronRuns(jobId, limit = 20) {
-  ensureCronSchema();
-  return db2.query("SELECT * FROM negotium_cron_runs WHERE job_id = ? ORDER BY scheduled_at DESC LIMIT ?").all(jobId, limit).map(toRun);
-}
-function getLastCronRun(jobId) {
-  return listCronRuns(jobId, 1)[0] ?? null;
-}
-function countCronRuns(jobId) {
-  ensureCronSchema();
-  const row = db2.query("SELECT COUNT(*) AS count FROM negotium_cron_runs WHERE job_id = ?").get(jobId);
-  return row?.count ?? 0;
-}
-function recoverPendingCronRuns(limit = 100) {
-  ensureCronSchema();
-  const rows = db2.query(`SELECT r.id AS run_id, r.job_id AS run_job_id, r.source AS run_source,
-              r.scheduled_at AS run_scheduled_at, r.started_at AS run_started_at,
-              r.finished_at AS run_finished_at, r.status AS run_status,
-              r.query_id AS run_query_id, r.duration_ms AS run_duration_ms,
-              r.output_preview AS run_output_preview, r.error AS run_error,
-              r.exit_code AS run_exit_code,
-              r.topic_id AS run_topic_id,
-              j.*
-       FROM negotium_cron_runs r
-       JOIN negotium_cron_jobs j ON j.id = r.job_id
-       WHERE r.status = 'pending'
-       ORDER BY r.scheduled_at
-       LIMIT ?`).all(limit);
-  return rows.map((row) => ({
-    job: toJob(row),
-    run: toRun({
-      id: row.run_id,
-      job_id: row.run_job_id,
-      source: row.run_source,
-      scheduled_at: row.run_scheduled_at,
-      started_at: row.run_started_at,
-      finished_at: row.run_finished_at,
-      status: row.run_status,
-      query_id: row.run_query_id,
-      duration_ms: row.run_duration_ms,
-      output_preview: row.run_output_preview,
-      error: row.run_error,
-      exit_code: row.run_exit_code,
-      topic_id: row.run_topic_id
-    })
-  }));
-}
-function finalizeOrphanedCronRuns(now = new Date) {
-  ensureCronSchema();
-  const result = db2.query(`UPDATE negotium_cron_runs
-       SET status = 'interrupted', finished_at = ?, exit_code = 137,
-           error = 'node restarted after dispatch; final outcome is unknown'
-       WHERE status = 'running'`).run(now.toISOString());
-  return Number(result.changes);
-}
-
-// ../../packages/module-cron/src/background-sessions.ts
-function promptForJob(job) {
-  return job.prompt ?? `Script: ${job.script ?? "unknown"}`;
-}
-function latestRun(jobs) {
-  return jobs.flatMap((job) => {
-    const run = getLastCronRun(job.id);
-    return run ? [{ job, run }] : [];
-  }).sort((left, right) => right.run.scheduledAt.localeCompare(left.run.scheduledAt))[0];
-}
-function listCronBackgroundSessions(userId) {
-  const jobsByTopic = new Map;
-  for (const job of listCronJobs()) {
-    const topic = getTopic(job.topicId);
-    if (!topic || !isParticipant(topic, userId))
-      continue;
-    const jobs = jobsByTopic.get(job.topicId) ?? [];
-    jobs.push(job);
-    jobsByTopic.set(job.topicId, jobs);
-  }
-  const cronLeases = listRuntimeTurnLeases().filter((lease) => lease.origin.startsWith("cron:"));
-  return [...jobsByTopic].flatMap(([topicId, jobs]) => {
-    const topic = getTopic(topicId);
-    if (!topic)
-      return [];
-    const lease = cronLeases.find((candidate) => candidate.topicId === topicId);
-    const activeJobId = lease?.origin.split(":")[1];
-    const recent = latestRun(jobs);
-    const displayJob = jobs.find((job) => job.id === activeJobId) ?? (recent?.job.id ? jobs.find((job) => job.id === recent.job.id) : undefined) ?? jobs[0];
-    if (!displayJob)
-      return [];
-    const queryId = lease?.queryId ?? recent?.run.queryId;
-    const progress = queryId ? backgroundSessionProgress(topicId, queryId) : undefined;
-    const enabledJobs = jobs.filter((job) => job.enabled);
-    const nextJob = [...enabledJobs].sort((left, right) => left.nextRunAt.localeCompare(right.nextRunAt))[0];
-    const steps = progress?.steps.length ? progress.steps : [
-      ...recent ? [`Last run: ${recent.job.name} \xB7 ${recent.run.status}`] : ["No runs yet"],
-      ...nextJob ? [`Next: ${nextJob.name} \xB7 ${nextJob.nextRunAt}`] : []
-    ];
-    return [
-      {
-        id: `cron:${topicId}`,
-        kind: "cron",
-        title: topic.title,
-        topicId,
-        startedAt: (lease ? new Date(lease.startedAt).toISOString() : recent?.run.startedAt) ?? displayJob.createdAt,
-        status: lease ? lease.abortRequested ? "Stopping" : progress?.status ?? "Running" : enabledJobs.length > 0 ? "Scheduled" : "Paused",
-        active: Boolean(lease),
-        agent: displayJob.agent ?? topic.agent,
-        model: displayJob.model ?? topic.effectiveModel ?? topic.defaultModel,
-        effort: displayJob.effort ?? topic.effectiveEffort ?? topic.defaultEffort,
-        prompt: promptForJob(displayJob),
-        promptTitle: `Prompt \xB7 ${displayJob.name}`,
-        steps
-      }
-    ];
-  });
-}
-// ../../packages/module-cron/src/host.ts
-var defaultHost = {
-  getTopic,
-  getRoomQuery,
-  abortRoom,
-  resolveTopicWorkspaceDir,
-  purgeTopicLogs,
-  rotateTopicLogs,
-  registerRuntimeMcpServer,
-  registerBackgroundSessionProvider,
-  buildStdioMcpServer
-};
-var activeHost = defaultHost;
-function cronHost() {
-  return activeHost;
-}
-function configureCronHost(overrides) {
-  const previous = activeHost;
-  activeHost = { ...previous, ...overrides };
-  let disposed = false;
-  return () => {
-    if (disposed)
-      return;
-    disposed = true;
-    activeHost = previous;
-  };
-}
-
-// ../../packages/module-cron/src/context.ts
-var CRON_CONTEXT_ROTATE_EVERY = 5;
-var CRON_CONTEXT_RETAIN_TURNS = 5;
-async function updateCronJobWithContextReset(id, patch, now = new Date) {
-  const previous = getCronJob(id);
-  if (!previous)
-    return null;
-  const resetRequired = cronJobPatchChangesContext(previous, patch);
-  const updated = updateCronJob(id, patch, now);
-  if (!updated || !resetRequired)
-    return updated;
-  await resetCronTopicContext(previous.topicId, [previous.ownerUserId]);
-  if (updated.topicId !== previous.topicId) {
-    await resetCronTopicContext(updated.topicId, [updated.ownerUserId]);
-  }
-  return getCronJob(id);
-}
-async function resetCronTopicContext(topicId, extraOwnerUserIds = []) {
-  const host = cronHost();
-  const sessions = listCronTopicSessions(topicId);
-  const owners = new Set([
-    ...sessions.map((session) => session.ownerUserId),
-    ...listCronJobsForTopic(topicId).map((job) => job.ownerUserId),
-    ...extraOwnerUserIds
-  ]);
-  for (const ownerUserId of owners) {
-    await host.purgeTopicLogs({
-      userId: ownerUserId,
-      topicName: cronTopicSessionName(topicId),
-      cwd: host.resolveTopicWorkspaceDir(topicId),
-      extraSessions: sessions.filter((session) => session.ownerUserId === ownerUserId).map((session) => ({ agent: session.agent, sessionId: session.sessionId }))
-    });
-  }
-  const removed = resetCronTopicSessions(topicId).length;
-  resetCronTopicContextState(topicId);
-  logger.info({ topicId, sessions: removed, owners: owners.size }, "cron: reset topic context");
-  return removed;
-}
-async function rotateCronTopicContext(topicId, retainTurns = CRON_CONTEXT_RETAIN_TURNS) {
-  const host = cronHost();
-  const sessions = listCronTopicSessions(topicId);
-  const jobs = listCronJobsForTopic(topicId);
-  const owners = new Set([
-    ...sessions.map((session) => session.ownerUserId),
-    ...jobs.map((job) => job.ownerUserId)
-  ]);
-  let totalTurns = 0;
-  let retained = 0;
-  for (const ownerUserId of owners) {
-    const result = await host.rotateTopicLogs({
-      userId: ownerUserId,
-      topicName: cronTopicSessionName(topicId),
-      cwd: host.resolveTopicWorkspaceDir(topicId),
-      retainTurns,
-      extraSessions: sessions.filter((session) => session.ownerUserId === ownerUserId).map((session) => ({ agent: session.agent, sessionId: session.sessionId }))
-    });
-    if (!result.rotated) {
-      return {
-        rotated: false,
-        clearedProviderSessions: 0,
-        totalTurns: result.totalTurns,
-        retainedTurns: result.retainedTurns
-      };
-    }
-    totalTurns = Math.max(totalTurns, result.totalTurns);
-    retained = Math.max(retained, result.retainedTurns);
-  }
-  const clearedProviderSessions = resetCronTopicSessions(topicId).length;
-  markCronTopicContextRotated(topicId);
-  logger.info({ topicId, clearedProviderSessions, totalTurns, retainedTurns: retained }, "cron: rotated bounded topic context");
-  return {
-    rotated: true,
-    clearedProviderSessions,
-    totalTurns,
-    retainedTurns: retained
-  };
-}
-// ../../packages/module-cron/src/module.ts
-import { existsSync as existsSync2 } from "fs";
-import { fileURLToPath } from "url";
-
-// ../../packages/module-cron/src/scheduler.ts
-var DEFAULT_POLL_INTERVAL_MS = 1000;
-var DEFAULT_RUN_TIMEOUT_MS = 10 * 60000;
-var DEFAULT_QUEUE_TIMEOUT_MS = 5 * 60000;
-
-class CronScheduler {
-  #dispatch;
-  #bus;
-  #pollIntervalMs;
-  #runTimeoutMs;
-  #queueTimeoutMs;
-  #now;
-  #activeByTopic = new Map;
-  #activeByQuery = new Map;
-  #queuedByTopic = new Map;
-  #maintenanceByTopic = new Set;
-  #rotationBypassOnce = new Set;
-  #timer;
-  #unsubscribe;
-  #ticking = false;
-  #stopped = false;
-  constructor(options) {
-    this.#dispatch = options.dispatch;
-    this.#bus = options.bus ?? runtimeBus();
-    this.#pollIntervalMs = Math.max(250, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
-    this.#runTimeoutMs = Math.max(1000, options.runTimeoutMs ?? DEFAULT_RUN_TIMEOUT_MS);
-    this.#queueTimeoutMs = Math.max(1000, options.queueTimeoutMs ?? DEFAULT_QUEUE_TIMEOUT_MS);
-    this.#now = options.now ?? (() => new Date);
-  }
-  start() {
-    if (this.#timer)
-      return () => this.stop();
-    this.#stopped = false;
-    const orphaned = finalizeOrphanedCronRuns(this.#now());
-    if (orphaned > 0)
-      logger.warn({ orphaned }, "cron: finalized interrupted runs on startup");
-    this.#unsubscribe = this.#bus.subscribe((event) => {
-      if (event.type !== "message")
-        return;
-      const message = event.payload;
-      if (!message?.queryId || message.authorId !== "ai")
-        return;
-      const active = this.#activeByQuery.get(message.queryId);
-      if (active)
-        active.outputPreview = message.text.slice(0, 500);
-    });
-    this.#timer = setInterval(() => void this.tick(), this.#pollIntervalMs);
-    this.#timer.unref?.();
-    const recovered = recoverPendingCronRuns();
-    for (const pending of recovered)
-      this.#enqueueOrStart(pending.job, pending.run);
-    if (recovered.length > 0) {
-      logger.info({ recovered: recovered.length }, "cron: recovered pending pre-dispatch runs");
-    }
-    this.tick();
-    return () => this.stop();
-  }
-  stop() {
-    const host = cronHost();
-    if (this.#timer)
-      clearInterval(this.#timer);
-    this.#timer = undefined;
-    this.#stopped = true;
-    this.#unsubscribe?.();
-    this.#unsubscribe = undefined;
-    for (const active of [...this.#activeByTopic.values()]) {
-      active.abortController.abort();
-      active.cancelDeferred?.();
-      if (active.queryId && host.getRoomQuery(active.job.topicId)?.queryId === active.queryId) {
-        host.abortRoom(active.job.topicId);
-      }
-      this.#finish(active, "aborted", "scheduler stopped before run completed");
-    }
-    for (const queued of this.#queuedByTopic.values()) {
-      for (const entry of queued) {
-        finishCronRun(entry.run.id, {
-          status: "aborted",
-          error: "scheduler stopped before queued run dispatched"
-        });
-      }
-    }
-    this.#queuedByTopic.clear();
-    this.#activeByTopic.clear();
-    this.#activeByQuery.clear();
-    this.#rotationBypassOnce.clear();
-  }
-  async tick() {
-    if (this.#ticking || this.#stopped)
-      return;
-    this.#ticking = true;
-    try {
-      for (const jobId of claimCronCancellations())
-        this.#cancelJob(jobId);
-      for (const claimed of claimCronRuns(this.#now())) {
-        this.#enqueueOrStart(claimed.job, claimed.run);
-      }
-    } catch (error) {
-      logger.warn({ err: error }, "cron: scheduler tick failed");
-    } finally {
-      this.#ticking = false;
-    }
-  }
-  #enqueueOrStart(job, run) {
-    const topic = cronHost().getTopic(job.topicId);
-    if (!topic?.agent) {
-      setCronJobEnabled(job.id, false, this.#now());
-      finishCronRun(run.id, {
-        status: "failed",
-        error: "target topic is missing or has no agent; job disabled"
-      });
-      return;
-    }
-    if (!topic.participants.some((participant) => participant.userId === job.ownerUserId)) {
-      setCronJobEnabled(job.id, false, this.#now());
-      finishCronRun(run.id, {
-        status: "failed",
-        error: "job owner is no longer a topic participant; job disabled"
-      });
-      return;
-    }
-    if (this.#activeByTopic.has(job.topicId) || this.#maintenanceByTopic.has(job.topicId)) {
-      const queue = this.#queuedByTopic.get(job.topicId) ?? [];
-      queue.push({ job, run, queuedAt: this.#now().getTime() });
-      this.#queuedByTopic.set(job.topicId, queue);
-      return;
-    }
-    const rotationDue = (getCronTopicContext(job.topicId)?.successfulRunsSinceRotation ?? 0) >= CRON_CONTEXT_ROTATE_EVERY;
-    if (rotationDue && !this.#rotationBypassOnce.delete(job.topicId)) {
-      const queue = this.#queuedByTopic.get(job.topicId) ?? [];
-      queue.push({ job, run, queuedAt: this.#now().getTime() });
-      this.#queuedByTopic.set(job.topicId, queue);
-      this.#beginContextRotation(job.topicId);
-      return;
-    }
-    this.#start(job, run, job.agent ?? topic.agent);
-  }
-  #start(job, run, agent) {
-    const storedSession = getCronTopicSession(job.topicId, agent);
-    if (storedSession && storedSession.ownerUserId !== job.ownerUserId) {
-      setCronJobEnabled(job.id, false, this.#now());
-      finishCronRun(run.id, {
-        status: "failed",
-        error: "topic Cron context belongs to another owner; job disabled"
-      });
-      this.#drainTopic(job.topicId);
-      return;
-    }
-    const active = { job, run, agent, abortController: new AbortController };
-    this.#activeByTopic.set(job.topicId, active);
-    const hooks = {
-      onDispatched: (queryId) => this.#markDispatched(active, queryId),
-      onSessionId: (sessionId) => {
-        if (this.#isActive(active)) {
-          setCronTopicSessionIfJobUpdatedAt(job.id, job.updatedAt, job.topicId, agent, job.ownerUserId, sessionId, this.#now());
-        }
-      },
-      onSessionReset: () => {
-        if (this.#isActive(active) && getCronJob(job.id)?.updatedAt === job.updatedAt) {
-          clearCronTopicSession(job.topicId, agent);
-        }
-      },
-      onSettled: (result) => this.#settle(active, result)
-    };
-    const context = {
-      agent,
-      sessionId: storedSession?.sessionId,
-      sessionName: cronTopicSessionName(job.topicId),
-      signal: active.abortController.signal
-    };
-    Promise.resolve().then(() => this.#dispatch(job, run, hooks, context)).then((result) => this.#handleDispatchResult(active, result)).catch((error) => {
-      this.#finish(active, "failed", error instanceof Error ? error.message : String(error));
-    });
-  }
-  #handleDispatchResult(active, result) {
-    if (!this.#isActive(active))
-      return;
-    if (typeof result === "string") {
-      if (active.queryId !== result)
-        this.#markDispatched(active, result);
-      return;
-    }
-    if (result === null) {
-      this.#finish(active, "failed", "dispatch returned no query and no deferred handle");
-      return;
-    }
-    if (result.status === "skipped") {
-      this.#finish(active, "skipped", result.reason);
-      return;
-    }
-    active.cancelDeferred = result.cancel;
-    if (result.status === "dispatched") {
-      if (result.queryId && active.queryId !== result.queryId) {
-        this.#markDispatched(active, result.queryId);
-      }
-      return;
-    }
-    active.deferredTimeout = setTimeout(() => {
-      if (!this.#isActive(active) || active.queryId)
-        return;
-      const cancelled = active.cancelDeferred?.() ?? false;
-      this.#finish(active, cancelled ? "skipped" : "failed", cancelled ? `topic remained busy for more than ${this.#queueTimeoutMs}ms` : "deferred run disappeared before dispatch");
-    }, this.#queueTimeoutMs);
-    active.deferredTimeout.unref?.();
-  }
-  #markDispatched(active, queryId) {
-    if (!this.#isActive(active))
-      return;
-    if (active.queryId)
-      this.#activeByQuery.delete(active.queryId);
-    if (active.timeout)
-      clearTimeout(active.timeout);
-    if (active.deferredTimeout)
-      clearTimeout(active.deferredTimeout);
-    active.deferredTimeout = undefined;
-    active.queryId = queryId;
-    this.#activeByQuery.set(queryId, active);
-    markCronRunStarted(active.run.id, queryId, this.#now());
-    active.timeout = setTimeout(() => {
-      const host = cronHost();
-      const room = host.getRoomQuery(active.job.topicId);
-      if (room?.queryId === active.queryId)
-        host.abortRoom(active.job.topicId);
-      else
-        active.cancelDeferred?.();
-      this.#finish(active, "failed", `run exceeded ${this.#runTimeoutMs}ms`);
-    }, this.#runTimeoutMs);
-    active.timeout.unref?.();
-  }
-  #settle(active, result) {
-    if (!this.#isActive(active))
-      return;
-    if (result.queryId && active.queryId && result.queryId !== active.queryId)
-      return;
-    if (result.kind === "completed")
-      this.#finish(active, "succeeded");
-    else if (result.kind === "aborted")
-      this.#finish(active, "aborted", result.error);
-    else
-      this.#finish(active, "failed", result.error ?? "agent turn failed");
-  }
-  #finish(active, status, error) {
-    if (!this.#isActive(active))
-      return;
-    active.abortController.abort();
-    if (active.timeout)
-      clearTimeout(active.timeout);
-    if (active.deferredTimeout)
-      clearTimeout(active.deferredTimeout);
-    if (active.queryId)
-      this.#activeByQuery.delete(active.queryId);
-    this.#activeByTopic.delete(active.job.topicId);
-    const successfulRunsSinceRotation = finishCronRun(active.run.id, { status, outputPreview: active.outputPreview, error }, this.#now());
-    if (status === "succeeded" && successfulRunsSinceRotation !== null && successfulRunsSinceRotation >= CRON_CONTEXT_ROTATE_EVERY) {
-      this.#beginContextRotation(active.job.topicId);
-      return;
-    }
-    if (!this.#stopped)
-      queueMicrotask(() => this.#drainTopic(active.job.topicId));
-  }
-  #beginContextRotation(topicId) {
-    if (this.#stopped || this.#maintenanceByTopic.has(topicId))
-      return;
-    this.#maintenanceByTopic.add(topicId);
-    rotateCronTopicContext(topicId).then((result) => {
-      if (!result.rotated) {
-        this.#rotationBypassOnce.add(topicId);
-        logger.warn({ topicId }, "cron: context rotation deferred after cleanup failure");
-      }
-    }).catch((error) => {
-      this.#rotationBypassOnce.add(topicId);
-      logger.warn({ err: error, topicId }, "cron: context rotation failed");
-    }).finally(() => {
-      this.#maintenanceByTopic.delete(topicId);
-      if (!this.#stopped)
-        this.#drainTopic(topicId);
-    });
-  }
-  #drainTopic(topicId) {
-    if (this.#stopped || this.#activeByTopic.has(topicId) || this.#maintenanceByTopic.has(topicId))
-      return;
-    const queue = this.#queuedByTopic.get(topicId);
-    while (queue?.length) {
-      const next = queue.shift();
-      if (this.#now().getTime() - next.queuedAt > this.#queueTimeoutMs) {
-        finishCronRun(next.run.id, {
-          status: "skipped",
-          error: `topic Cron queue wait exceeded ${this.#queueTimeoutMs}ms`
-        });
-        continue;
-      }
-      const currentJob = getCronJob(next.job.id);
-      if (!currentJob)
-        continue;
-      if (queue.length === 0)
-        this.#queuedByTopic.delete(topicId);
-      this.#enqueueOrStart(currentJob, next.run);
-      return;
-    }
-    this.#queuedByTopic.delete(topicId);
-  }
-  #cancelJob(jobId) {
-    for (const active of [...this.#activeByTopic.values()]) {
-      if (active.job.id !== jobId)
-        continue;
-      active.abortController.abort();
-      active.cancelDeferred?.();
-      const host = cronHost();
-      if (active.queryId && host.getRoomQuery(active.job.topicId)?.queryId === active.queryId) {
-        host.abortRoom(active.job.topicId);
-      }
-      this.#finish(active, "aborted", "run cancelled by cron_kill");
-    }
-    for (const [topicId, queue] of this.#queuedByTopic) {
-      const kept = [];
-      for (const queued of queue) {
-        if (queued.job.id === jobId) {
-          finishCronRun(queued.run.id, {
-            status: "aborted",
-            error: "queued run cancelled by cron_kill"
-          });
-        } else {
-          kept.push(queued);
-        }
-      }
-      if (kept.length > 0)
-        this.#queuedByTopic.set(topicId, kept);
-      else
-        this.#queuedByTopic.delete(topicId);
-    }
-  }
-  #isActive(active) {
-    return this.#activeByTopic.get(active.job.topicId) === active;
-  }
-}
-
-// ../../packages/module-cron/src/module.ts
-var SOURCE_MCP_SERVER_FILE = fileURLToPath(new URL("./mcp-server.ts", import.meta.url));
-var PACKAGED_MCP_SERVER_FILE = fileURLToPath(new URL("./runtime/cron/mcp-server.ts", import.meta.url));
-function envMs(name, fallback) {
-  const parsed = Number.parseInt(process.env[name] ?? "", 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function createCronModule(options = {}) {
-  return {
-    name: "cron",
-    singleton: true,
-    capabilities: ["scheduler.cron.v1", "scheduler.cron.v2"],
-    start(context) {
-      const restoreDatabase = options.database ? configureCronDatabase(options.database) : () => {};
-      const restoreHost = configureCronHost(options.host ?? {});
-      const host = cronHost();
-      ensureCronSchema();
-      const cleanupTasks = new Set;
-      const trackCleanup = (promise) => {
-        cleanupTasks.add(promise);
-        promise.then(() => cleanupTasks.delete(promise), (error) => {
-          cleanupTasks.delete(promise);
-          logger.warn({ err: error }, "cron: topic context cleanup failed");
-        });
-      };
-      for (const topicId of new Set(listOrphanedCronTopicSessions().map((entry) => entry.topicId))) {
-        trackCleanup(resetCronTopicContext(topicId));
-      }
-      const unsubscribeTopicCleanup = context.bus.subscribe((event) => {
-        if (event.type === "topic-deleted")
-          trackCleanup(resetCronTopicContext(event.topicId));
-      });
-      const mcpServerFile = options.mcpServerFile ?? (existsSync2(SOURCE_MCP_SERVER_FILE) ? SOURCE_MCP_SERVER_FILE : PACKAGED_MCP_SERVER_FILE);
-      const unregisterMcp = host.registerRuntimeMcpServer("cron-manager", {
-        scopes: ["forum", "manager"],
-        forumRequired: true,
-        build({ userId, session, topicId, agent }) {
-          const args = [`--user-id=${userId}`, `--topic=${session}`];
-          if (topicId)
-            args.push(`--topic-id=${topicId}`);
-          if (host.authorize?.(userId, "cron:admin", { type: "cron" })) {
-            args.push("--authorized=true");
-          }
-          return host.buildStdioMcpServer(agent, mcpServerFile, args);
-        }
-      });
-      const unregisterBackgroundSessions = host.registerBackgroundSessionProvider(listCronBackgroundSessions);
-      const schedulerOptions = {
-        bus: context.bus,
-        pollIntervalMs: options.pollIntervalMs ?? envMs("NEGOTIUM_CRON_POLL_INTERVAL_MS", 1000),
-        runTimeoutMs: options.runTimeoutMs ?? envMs("NEGOTIUM_CRON_RUN_TIMEOUT_MS", 10 * 60000),
-        queueTimeoutMs: options.queueTimeoutMs ?? envMs("NEGOTIUM_CRON_QUEUE_TIMEOUT_MS", 5 * 60000),
-        dispatch: options.host?.dispatch ?? (async (job, run, hooks, execution) => {
-          const taskPrompt = job.prompt ?? await runCronPromptScript({
-            script: job.script,
-            cwd: host.resolveTopicWorkspaceDir(job.topicId),
-            jobId: job.id,
-            topicId: job.topicId,
-            timeoutMs: options.scriptTimeoutMs ?? envMs("NEGOTIUM_CRON_SCRIPT_TIMEOUT_MS", 10 * 60000),
-            signal: execution.signal
-          });
-          if (!taskPrompt.trim()) {
-            return { status: "skipped", reason: "prompt script produced no output" };
-          }
-          if (!host.getTopic(job.topicId)?.agent)
-            throw new Error("target topic was deleted during run");
-          const prompt = [
-            `<scheduled-task name="${job.name}" run-id="${run.id}">`,
-            "This is a background scheduled run. Do not ask interactive questions.",
-            "All scheduled tasks in this topic share one Cron conversation.",
-            "Use relevant conclusions and state from previous scheduled runs before acting.",
-            "Complete the task and report only meaningful results in the user's language.",
-            taskPrompt,
-            "</scheduled-task>"
-          ].join(`
-`);
-          const requestId = `cron:${run.id}`;
-          const queryId = triggerTopicAiTurn(job.topicId, job.ownerUserId, prompt, execution.agent, {
-            origin: `cron:${job.id}:${run.id}`,
-            requestId,
-            hideInjectMessage: true,
-            modelOverride: job.model,
-            effortOverride: job.effort,
-            sessionId: execution.sessionId ?? null,
-            sessionName: execution.sessionName,
-            sessionType: "cron",
-            onDispatched: hooks.onDispatched,
-            onSessionId: hooks.onSessionId,
-            onSessionReset: hooks.onSessionReset,
-            bridgeSessionFromHistory: true,
-            onSettled: hooks.onSettled
-          });
-          return {
-            status: queryId ? "dispatched" : "deferred",
-            requestId,
-            ...queryId ? { queryId } : {},
-            cancel: () => cancelDeferredInject(job.topicId, requestId)
-          };
-        })
-      };
-      const scheduler = new CronScheduler(schedulerOptions);
-      scheduler.start();
-      return {
-        async stop() {
-          scheduler.stop();
-          unsubscribeTopicCleanup();
-          unregisterBackgroundSessions();
-          unregisterMcp();
-          await Promise.allSettled(cleanupTasks);
-          restoreHost();
-          restoreDatabase();
-        }
-      };
-    }
-  };
-}
-// ../../packages/module-cron/src/summarize.ts
-var DEFAULT_URL = "https://api.deepseek.com/v1/chat/completions";
-var DEFAULT_MODEL = "deepseek-chat";
-var MAX_SUMMARY_LENGTH = 60;
-var MAX_CONCURRENT_SUMMARIES = 3;
-function cleanCronPromptSummary(raw) {
-  let text = raw.replace(/\s+/g, " ").trim();
-  text = text.replace(/^["'\u201C\u201D]+|["'\u201C\u201D]+$/g, "").trim();
-  text = text.replace(/^(task|summary|label|\uC694\uC57D|\uC791\uC5C5)\s*[:\uFF1A]\s*/i, "").trim();
-  text = text.replace(/^["'\u201C\u201D]+|["'\u201C\u201D]+$/g, "").trim();
-  text = text.replace(/[.\u3002]+$/, "").trim();
-  if (!text)
-    return null;
-  return text.length > MAX_SUMMARY_LENGTH ? `${text.slice(0, MAX_SUMMARY_LENGTH - 3)}...` : text;
-}
-async function summarizeCronPrompt(prompt) {
-  const clean = prompt.trim();
-  const apiKey = process.env.NEGOTIUM_CRON_SUMMARY_API_KEY ?? process.env.DEEPSEEK_API_KEY;
-  if (!clean || !apiKey)
-    return null;
-  const controller = new AbortController;
-  const timeoutMs = Number.parseInt(process.env.NEGOTIUM_CRON_SUMMARY_TIMEOUT_MS ?? "8000", 10);
-  const timer = setTimeout(() => controller.abort(), Number.isFinite(timeoutMs) ? timeoutMs : 8000);
-  try {
-    const response = await fetch(process.env.NEGOTIUM_CRON_SUMMARY_URL ?? DEFAULT_URL, {
-      method: "POST",
-      signal: controller.signal,
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
-      body: JSON.stringify({
-        model: process.env.NEGOTIUM_CRON_SUMMARY_MODEL ?? DEFAULT_MODEL,
-        messages: [
-          {
-            role: "system",
-            content: "Label the scheduled task in the instruction's language using at most 8 words. " + "Describe the outcome only. Return no quotes, prefix, or trailing period."
-          },
-          { role: "user", content: clean.slice(0, 4000) }
-        ],
-        max_tokens: 512,
-        temperature: 0.2,
-        stream: false
-      })
-    });
-    if (!response.ok) {
-      logger.warn({ status: response.status }, "cron: prompt summary request failed");
-      return null;
-    }
-    const body = await response.json();
-    return cleanCronPromptSummary(body.choices?.[0]?.message?.content ?? "");
-  } catch (error) {
-    logger.warn({ err: error }, "cron: prompt summary request errored");
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-var generations = new Map;
-var pending = [];
-var active = 0;
-var nextGeneration = 0;
-function drain() {
-  while (active < MAX_CONCURRENT_SUMMARIES) {
-    const next = pending.shift();
-    if (!next)
-      return;
-    if (generations.get(next.jobId) !== next.generation)
-      continue;
-    active += 1;
-    next.summarize(next.prompt).then((summary) => {
-      if (summary && generations.get(next.jobId) === next.generation) {
-        updateCronJobSummaryIfPromptMatches(next.jobId, next.prompt, summary);
-      }
-    }).catch((error) => logger.warn({ err: error, jobId: next.jobId }, "cron: summary persist failed")).finally(() => {
-      active -= 1;
-      if (generations.get(next.jobId) === next.generation)
-        generations.delete(next.jobId);
-      drain();
-    });
-  }
-}
-function queueCronPromptSummary(jobId, prompt, summarize = summarizeCronPrompt) {
-  const generation = ++nextGeneration;
-  generations.set(jobId, generation);
-  for (let index = pending.length - 1;index >= 0; index -= 1) {
-    if (pending[index]?.jobId === jobId)
-      pending.splice(index, 1);
-  }
-  pending.push({ jobId, prompt, generation, summarize });
-  drain();
-}
-export {
-  validateCronScriptName,
-  validateCronExpression,
-  updateCronJobWithContextReset,
-  updateCronJobSummaryIfPromptMatches,
-  updateCronJob,
-  summarizeCronPrompt,
-  setCronTopicSessionIfJobUpdatedAt,
-  setCronTopicSession,
-  setCronJobSessionId,
-  setCronJobEnabled,
-  runCronPromptScript,
-  rotateCronTopicContext,
-  resolveCronScriptPath,
-  resetCronTopicSessions,
-  resetCronTopicContextState,
-  resetCronTopicContext,
-  requestCronRun,
-  requestCronCancel,
-  recoverPendingCronRuns,
-  queueCronPromptSummary,
-  parseCronExpression,
-  normalizeCronTimezone,
-  markCronTopicContextRotated,
-  markCronRunStarted,
-  listOrphanedCronTopicSessions,
-  listEnabledCronJobs,
-  listCronTopicSessions,
-  listCronScripts,
-  listCronRuns,
-  listCronJobsForTopicOwner,
-  listCronJobsForTopic,
-  listCronJobs,
-  listCronBackgroundSessions,
-  getLastCronRun,
-  getCronTopicSession,
-  getCronTopicContext,
-  getCronJobByOwnerAndName,
-  getCronJob,
-  finishCronRun,
-  finalizeOrphanedCronRuns,
-  ensureCronSchema,
-  deleteCronJob,
-  cronTopicSessionName,
-  cronScriptExists,
-  cronMatchesDate,
-  cronJobPatchChangesContext,
-  createCronModule,
-  createCronJob,
-  countCronRuns,
-  configureCronHost,
-  configureCronDatabase,
-  computeNextCronRun,
-  clearCronTopicSession,
-  cleanCronPromptSummary,
-  claimCronRuns,
-  claimCronCancellations,
-  CronScheduler,
-  CRON_JOBS_DIR,
-  CRON_CONTEXT_ROTATE_EVERY,
-  CRON_CONTEXT_RETAIN_TURNS
-};
-export { CRON_JOBS_DIR, cronScriptExists, createCronJob, listCronJobs, getCronJob, getCronJobByOwnerAndName, setCronJobEnabled, deleteCronJob, requestCronRun, requestCronCancel, listCronRuns, updateCronJobWithContextReset, resetCronTopicContext, queueCronPromptSummary };
-
-//# debugId=38E78E450D25029964756E2164756E21