mocode-ai 1.6.4 → 1.6.6

package/dist/repl/runtime.js

@@ -1,6 +1,6 @@
 import { emitKeypressEvents } from 'node:readline';
 import { stdin } from 'node:process';
-import { config, isModelConfigured, isMemoryEnabled, buildBasePrompt, getPlanModeSuffix, pinSessionModel, } from '../config/index.js';
+import { config, isModelConfigured, isMemoryEnabled, buildBasePrompt, getPlanModeSuffix, pinSessionModel, pinSessionEffort, } from '../config/index.js';
 import { t } from '../i18n/index.js';
 import { listPresets, migrateCurrentToPreset } from '../config/presets.js';
 import { runAgent } from '../agent/index.js';
@@ -166,6 +166,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     setAgentMode('auto');
     // 钉死本会话模型：之后运行中 agent 一律用此值，其它窗口的 /model switch 不会影响本窗口。
     pinSessionModel();
+    pinSessionEffort();
     // 沙箱根:文件操作边界。优先级 --sandbox-root > SANDBOX_ROOT env > process.cwd()。
     // 纯边界记录(不 chdir),jail.ts 内部 resolve。子 agent 同进程继承全局 root。
     setSandboxRoot(sandboxRootOverride ?? config.sandboxRoot ?? process.cwd());
@@ -305,6 +306,9 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     if (!history.some((m) => m.role === 'user')) {
         layout.writeWelcomeBlock(welcomeLines());
     }
+    // 启动时限频自动 GC(24h 闸门,归档+purge 全做):fire-and-forget,
+    // 不阻塞进入主循环;runRetention 内部归档本地秒完、reflection 后台跑。可用 MOCODE_AUTO_GC=false 关闭。
+    void runtime.session.autoGc().catch(() => undefined);
     /**
      * 切换 agent 模式(Shift+Tab 触发,经 prompt.ts 的 onCycleMode 回调)。
      * cycleMode 翻 agentMode + applyMode 重写 history[0] + refreshStatusBase 设状态行 modeTag;

package/dist/repl/status-bar.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { ui } from '../ui/theme.js';
 import * as layout from '../ui/layout.js';
 import { t } from '../i18n/index.js';
-import { config } from '../config/index.js';
+import { config, getActiveEffort } from '../config/index.js';
 import { contextState } from '../session/index.js';
 import { DEFAULT_BUDGET_POLICY } from '../context/budget.js';
 import { chatTools, correctTokenEstimate, estimateMessagesTokens, estimateToolSchemaTokens, estimateTokens, } from '../llm/index.js';
@@ -47,7 +47,8 @@ export function renderContextBar(history) {
     const lifecycleLine = lifecycle
         ? `\n  lifecycle · live ${lifecycle.live} · referenced ${lifecycle.referenced} · digested ${lifecycle.digested} · stubbed ${lifecycle.stubbed}`
         : '\n  lifecycle · no active snapshot (run a tool-enabled turn first)';
-    const archiveLine = `\n  archived tool results · ${archived.stubbed}`;
+    const archiveLine = `
+  archived tool results · ${archived.stubbed}${archived.cleared > 0 ? ` · cleared ${archived.cleared} (low-pressure)` : ''}`;
     return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${t('status.messages', { count: history.length })} (${src})${measuredNote}${ui.reset}${artifactLine}${lifecycleLine}${archiveLine}`;
 }
 /** 状态行用量条(精简版,进底栏):[bar] pct% k/k。
@@ -167,6 +168,7 @@ export function refreshStatusBase(history, lastTurnUsage) {
         contextBar: renderContextBarInline(history),
         cwd: process.cwd(),
         modeTag: getAgentMode() === 'plan' ? 'Plan' : 'Auto',
+        effort: getActiveEffort() === 'auto' ? undefined : getActiveEffort(),
         planSummary: readPlanFromNotes(),
         lastTurnUsage,
     });

package/dist/rollback/store.js

@@ -3,6 +3,7 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync
 import * as fsp from 'node:fs/promises';
 import path from 'node:path';
 import { config } from '../config/index.js';
+import { MAX_SNAPSHOT_TURNS } from '../tools/constants.js';
 import { toText } from '../context/utils.js';
 import { truncateDisplay } from '../ui/render.js';
 const EXCLUDED_WORKSPACE_DIRS = Object.freeze([
@@ -192,8 +193,24 @@ export class RollbackStore {
         this.turnIdCounter += 1;
         this.currentTurnId = this.turnIdCounter;
         this.turns.push({ turnId: this.currentTurnId, firstLine });
+        // 压缩前滚动窗口:snapshots.json 此前只在 compact 后剪枝,长会话压缩前持续累积
+        // (实测单文件 2MB)。每开新 turn 即丢掉超过 MAX_SNAPSHOT_TURNS 的老 turn 及其快照。
+        // env 覆盖仅供测试:MOCODE_MAX_SNAPSHOT_TURNS=2 可立刻触发滚动剪枝。
+        const envMax = Number(process.env.MOCODE_MAX_SNAPSHOT_TURNS);
+        this.pruneOldTurns(Number.isFinite(envMax) && envMax >= 1 ? envMax : MAX_SNAPSHOT_TURNS);
         return this.currentTurnId;
     }
+    /** 仅保留最近 maxTurns 个 turn 及其快照;currentTurnId 被剪掉时归零(不应发生,当前 turn 恒在尾部)。 */
+    pruneOldTurns(maxTurns) {
+        if (this.turns.length <= maxTurns)
+            return;
+        const kept = this.turns.slice(-maxTurns);
+        const alive = new Set(kept.map((turn) => turn.turnId));
+        this.turns = kept;
+        this.snapshots = this.snapshots.filter((snapshot) => alive.has(snapshot.turnId));
+        if (!alive.has(this.currentTurnId))
+            this.currentTurnId = 0;
+    }
     getCurrentTurnId() {
         return this.currentTurnId;
     }

package/dist/runtime/runtime.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { runAgentCore } from '../agent/core.js';
 import { createAgentRuntimeContext, defaultAgentRuntimeContext, } from '../agent/runtime-context.js';
-import { contextState as defaultContextState, createContextState, manualCompact, } from '../session/index.js';
+import { contextState as defaultContextState, createContextState, manualCompact, planRetention, runRetention, searchArchiveIndex, shouldAutoGc, writeLastAutoGc, DEFAULT_RETENTION_POLICY, } from '../session/index.js';
 const activeRuntimes = new AsyncLocalStorage();
 /** Runtime facade active in the current agent async tree, used by nested agents to borrow the parent lifecycle. */
 export function getActiveRuntime() {
@@ -54,6 +54,36 @@ export class Runtime {
                 return this.context.sessionStore.list(limit);
             },
             clear: () => this.createSession(true),
+            gc: (async (opts = {}) => {
+                this.assertIdle('gc sessions');
+                const root = this.context.sessionStore.sessionsRoot;
+                const currentId = this.context.sessionStore.getCurrentSessionId();
+                const plan = planRetention(root, DEFAULT_RETENTION_POLICY, Date.now(), currentId);
+                if (opts.dryRun !== false)
+                    return plan;
+                const result = await runRetention(root, plan);
+                this.emit('session.gc', { archived: result.archived, purged: result.purged });
+                return result;
+            }),
+            searchArchive: (query, limit) => {
+                this.assertOpen();
+                return searchArchiveIndex(this.context.sessionStore.sessionsRoot, query, limit ?? 10);
+            },
+            autoGc: async () => {
+                this.assertOpen();
+                const root = this.context.sessionStore.sessionsRoot;
+                if (!shouldAutoGc(root))
+                    return null;
+                const currentId = this.context.sessionStore.getCurrentSessionId();
+                const plan = planRetention(root, DEFAULT_RETENTION_POLICY, Date.now(), currentId);
+                // 先写闸门:即使本次没有命中项,也 记录“已检查”,避免每次启动都重新扫描。
+                writeLastAutoGc(root);
+                if (plan.items.length === 0)
+                    return null;
+                const result = await runRetention(root, plan);
+                this.emit('session.gc', { archived: result.archived, purged: result.purged, auto: true });
+                return result;
+            },
         };
         this.rollback = {
             list: () => {

package/dist/schedule/cli.js

@@ -0,0 +1,114 @@
+// `mocode schedule …` 命令行管理：
+//   add --name <n> (--cron "<5段>" | --webhook | 两者) --prompt "<任务>" [--worktree]
+//   list | rm <id前缀> | enable <id前缀> | disable <id前缀>
+//   start | stop | status | tick
+// add 成功后打印触发方式（cron / webhook URL）；cron 类需 start 拉起守护进程才生效。
+import { createSchedule, listSchedules, deleteSchedule, updateSchedule } from './store.js';
+import { startDaemon, stopDaemon, isDaemonRunning, getDaemonState, runTick } from './daemon.js';
+function flagValue(args, flag) {
+    const i = args.indexOf(flag);
+    if (i === -1)
+        return undefined;
+    const v = args[i + 1];
+    return v && !v.startsWith('-') ? v : undefined;
+}
+function findByPrefix(prefix) {
+    const all = listSchedules();
+    if (!prefix)
+        return all.length === 1 ? all[0] : undefined;
+    const m = all.filter((s) => (prefix ? s.id.startsWith(prefix) || s.name === prefix : false));
+    return m.length === 1 ? m[0] : undefined;
+}
+export async function runScheduleCli(rawArgs) {
+    const sub = rawArgs[0] ?? 'list';
+    const args = rawArgs.slice(1);
+    switch (sub) {
+        case 'add': {
+            const name = flagValue(args, '--name');
+            const prompt = flagValue(args, '--prompt');
+            const cron = flagValue(args, '--cron');
+            const webhook = args.includes('--webhook');
+            const worktree = args.includes('--worktree');
+            const botForSchedule = flagValue(args, '--bot');
+            if (!name || !prompt) {
+                process.stderr.write('usage: mocode schedule add --name <n> --prompt "<task>" (--cron "<5 fields>" and/or --webhook) [--worktree]\n');
+                return 1;
+            }
+            try {
+                const rec = createSchedule({ name, prompt, cron, webhook, worktree, botName: botForSchedule });
+                process.stdout.write(`Schedule created: ${rec.id}\n  name: ${rec.name}\n`);
+                if (rec.cron)
+                    process.stdout.write(`  cron: ${rec.cron}（需 mocode schedule start）\n`);
+                if (rec.webhookToken) {
+                    const port = getDaemonState()?.port ?? 8788;
+                    process.stdout.write(`  webhook: POST http://127.0.0.1:${port}/trigger/${rec.webhookToken}（需 schedule start）\n`);
+                }
+                return 0;
+            }
+            catch (e) {
+                process.stderr.write(`mocode: ${e instanceof Error ? e.message : String(e)}\n`);
+                return 1;
+            }
+        }
+        case 'rm':
+        case 'remove': {
+            const rec = findByPrefix(args[0]);
+            if (!rec) {
+                process.stderr.write('mocode: no unique matching schedule\n');
+                return 1;
+            }
+            deleteSchedule(rec.id);
+            process.stdout.write(`Removed ${rec.id} (${rec.name})\n`);
+            return 0;
+        }
+        case 'enable':
+        case 'disable': {
+            const rec = findByPrefix(args[0]);
+            if (!rec) {
+                process.stderr.write('mocode: no unique matching schedule\n');
+                return 1;
+            }
+            updateSchedule(rec.id, { enabled: sub === 'enable' });
+            process.stdout.write(`${rec.name} ${sub}d\n`);
+            return 0;
+        }
+        case 'start': {
+            const r = startDaemon();
+            if (r.started && r.state) {
+                process.stdout.write(`Scheduler started (pid ${r.state.pid}, port ${r.state.port})\n`);
+            }
+            else {
+                process.stdout.write(`Scheduler not started: ${r.reason ?? 'unknown'}\n`);
+            }
+            return 0;
+        }
+        case 'stop':
+            process.stdout.write(stopDaemon() ? 'Scheduler stopped\n' : 'Scheduler was not running\n');
+            return 0;
+        case 'status': {
+            const state = getDaemonState();
+            process.stdout.write(isDaemonRunning() && state
+                ? `running (pid ${state.pid}, port ${state.port}, since ${state.startedAt})\n`
+                : 'stopped\n');
+            return 0;
+        }
+        case 'tick': {
+            const fired = await runTick();
+            process.stdout.write(`tick done: ${fired} fired\n`);
+            return 0;
+        }
+        case 'list':
+        default: {
+            const all = listSchedules();
+            if (all.length === 0) {
+                process.stdout.write('(no schedules; add one with `mocode schedule add …`)\n');
+                return 0;
+            }
+            for (const s of all) {
+                const trigger = s.cron ? s.cron : s.webhookToken ? `webhook:${s.webhookToken}` : '?';
+                process.stdout.write(`${s.enabled ? '●' : '○'} ${s.id}  ${s.name}\n    ${trigger}\n    ${s.prompt.split('\n')[0]}\n`);
+            }
+            return 0;
+        }
+    }
+}

package/dist/schedule/cron.js

@@ -0,0 +1,79 @@
+// 标准 5 段 cron 匹配（无第三方依赖）：分 时 日(月) 月 周
+// 字段支持：*、数字、逗号列表 1,2,3、范围 1-5、步长 */15 或 1-10/2。
+// 周：0-6，0=周日。
+// 经典语义：当日(月)与周都不是 * 时，满足其一即触发；其一为 * 时只看另一个。
+const RANGES = {
+    minute: { min: 0, max: 59 },
+    hour: { min: 0, max: 23 },
+    dom: { min: 1, max: 31 },
+    month: { min: 1, max: 12 },
+    dow: { min: 0, max: 6 },
+};
+/** 解析单个字段为允许值集合。非法表达式抛错。 */
+export function parseField(raw, range) {
+    const values = new Set();
+    for (const part of raw.split(',')) {
+        if (part === '')
+            throw new Error(`empty field part in "${raw}"`);
+        const [body, stepRaw] = part.split('/');
+        const step = stepRaw === undefined ? 1 : Number(stepRaw);
+        if (!Number.isInteger(step) || step < 1)
+            throw new Error(`bad step in "${part}"`);
+        let lo;
+        let hi;
+        if (body === '*') {
+            lo = range.min;
+            hi = range.max;
+        }
+        else if (body.includes('-')) {
+            const [a, b] = body.split('-');
+            lo = Number(a);
+            hi = Number(b);
+        }
+        else {
+            lo = Number(body);
+            hi = stepRaw === undefined ? lo : range.max; // "5/10" = 5,15,25…
+        }
+        if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < range.min || hi > range.max || lo > hi) {
+            throw new Error(`out-of-range or invalid "${part}" (allowed ${range.min}-${range.max})`);
+        }
+        for (let v = lo; v <= hi; v += step)
+            values.add(v);
+    }
+    return values;
+}
+export function parseCron(expr) {
+    const fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        throw new Error(`cron must have exactly 5 fields, got ${fields.length}`);
+    const [m, h, dom, mon, dow] = fields;
+    return {
+        minute: parseField(m, RANGES.minute),
+        hour: parseField(h, RANGES.hour),
+        dom: parseField(dom, RANGES.dom),
+        month: parseField(mon, RANGES.month),
+        dow: parseField(dow, RANGES.dow),
+        domRestricted: dom !== '*',
+        dowRestricted: dow !== '*',
+    };
+}
+/** 给定时间是否命中 cron。 */
+export function cronMatches(expr, date = new Date()) {
+    const c = parseCron(expr);
+    if (!c.month.has(date.getMonth() + 1))
+        return false;
+    if (!c.hour.has(date.getHours()))
+        return false;
+    if (!c.minute.has(date.getMinutes()))
+        return false;
+    const domMatch = c.dom.has(date.getDate());
+    const dowMatch = c.dow.has(date.getDay());
+    // 两者都受限 → OR；否则 AND 到 *（即只看受限方）。
+    if (c.domRestricted && c.dowRestricted)
+        return domMatch || dowMatch;
+    if (c.domRestricted)
+        return domMatch;
+    if (c.dowRestricted)
+        return dowMatch;
+    return true;
+}

package/dist/schedule/daemon.js

@@ -0,0 +1,166 @@
+// 调度守护进程：detached 常驻，两件事——
+// 1. 每 15s 扫描 schedules，cron 命中当前分钟即 launch 一个后台 job（分钟键去重，
+//    lastRunAt 落盘，重启 / tick 模式也不会同分钟重复触发）。
+// 2. 在 127.0.0.1 起 HTTP 端点：POST /trigger/<token> 立即触发，GET /health 探活。
+//    仅监听回环；用 node:http 直连（fetch 会被 HTTP_PROXY 干扰，见 notify 模块的坑）。
+//
+// 另有 runTick()：单次扫描模式，供系统任务计划（Windows 任务计划/launchd + cron）
+// 每 1-5 分钟调用一次，不想养常驻进程时用它。
+import http from 'node:http';
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawnDetached, killTree } from '../jobs/launch.js';
+import { getSandboxRoot } from '../sandbox/index.js';
+import { cronMatches } from './cron.js';
+import { listSchedules, updateSchedule } from './store.js';
+const DEFAULT_PORT = 8788;
+function stateDir() {
+    return path.join(getSandboxRoot() ?? process.cwd(), '.mocode', 'schedules');
+}
+function daemonStatePath() {
+    return path.join(stateDir(), 'daemon.json');
+}
+function daemonLogPath() {
+    return path.join(stateDir(), 'daemon.log');
+}
+export function getDaemonState() {
+    try {
+        return JSON.parse(fs.readFileSync(daemonStatePath(), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 进程是否存活（pid 复用概率低，足够判活）。 */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isDaemonRunning() {
+    const state = getDaemonState();
+    return !!state && isPidAlive(state.pid);
+}
+/** 本地分钟键（本地时区，与 cron 的 getHours 等对齐；ISO 字符串是 UTC 不能用）。 */
+function minuteKey(d) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}T${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+/** 触发一个 schedule：launch 后台 job + 记 lastRunAt。 */
+async function fireSchedule(s, now) {
+    const { launchBackgroundJob } = await import('../jobs/launch.js');
+    const { record } = launchBackgroundJob(s.prompt, {
+        ...(s.worktree ? { worktree: true } : {}),
+        ...(s.sessionDir ? { sessionDir: s.sessionDir } : {}),
+        ...(s.botName ? { botName: s.botName } : {}),
+    });
+    updateSchedule(s.id, { lastRunAt: now.toISOString() });
+    process.stdout.write(`[${now.toISOString()}] fired ${s.name} (${s.id}) → job ${record.id}\n`);
+}
+/** 单次扫描：所有 enabled 且有 cron 的 schedule，命中当前分钟且本分钟未跑过则触发。 */
+export async function runTick(now = new Date()) {
+    const key = minuteKey(now);
+    let fired = 0;
+    for (const s of listSchedules()) {
+        if (!s.enabled || !s.cron)
+            continue;
+        if (s.lastRunAt && minuteKey(new Date(s.lastRunAt)) === key)
+            continue;
+        let hit = false;
+        try {
+            hit = cronMatches(s.cron, now);
+        }
+        catch {
+            // 损坏的 cron 跳过
+        }
+        if (hit) {
+            await fireSchedule(s, now);
+            fired += 1;
+        }
+    }
+    return fired;
+}
+/** 读取并丢弃请求体。 */
+function drainBody(req) {
+    return new Promise((resolvePromise) => {
+        req.on('data', () => { });
+        req.on('end', () => resolvePromise());
+    });
+}
+/** 常驻守护：tick 循环 + HTTP 端点。 */
+export function runDaemon(port = DEFAULT_PORT) {
+    const log = (msg) => {
+        process.stdout.write(`[${new Date().toISOString()}] ${msg}\n`);
+    };
+    void runTick();
+    const timer = setInterval(() => {
+        void runTick().catch((e) => log(`tick error: ${String(e)}`));
+    }, 15000);
+    timer.unref?.();
+    const server = http.createServer((req, res) => {
+        const url = req.url ?? '';
+        if (req.method === 'GET' && url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, schedules: listSchedules().length }));
+            return;
+        }
+        const trigger = url.match(/^\/trigger\/([A-Za-z0-9]+)\/?$/);
+        if ((req.method === 'POST' || req.method === 'GET') && trigger) {
+            void drainBody(req).then(async () => {
+                const token = trigger[1] ?? '';
+                const sched = listSchedules().find((s) => s.webhookToken === token && s.enabled);
+                if (!sched) {
+                    res.writeHead(404);
+                    res.end('unknown or disabled token');
+                    return;
+                }
+                const { launchBackgroundJob } = await import('../jobs/launch.js');
+                const { record } = launchBackgroundJob(sched.prompt, {
+                    ...(sched.worktree ? { worktree: true } : {}),
+                    ...(sched.sessionDir ? { sessionDir: sched.sessionDir } : {}),
+                    ...(sched.botName ? { botName: sched.botName } : {}),
+                });
+                updateSchedule(sched.id, { lastRunAt: new Date().toISOString() });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, jobId: record.id }));
+            });
+            return;
+        }
+        res.writeHead(404);
+        res.end('not found');
+    });
+    server.listen(port, '127.0.0.1', () => log(`scheduler daemon listening on 127.0.0.1:${port}`));
+}
+/** 启动 detached 守护进程；已在跑则直接返回当前状态。 */
+export function startDaemon(port = DEFAULT_PORT) {
+    const existing = getDaemonState();
+    if (existing && isPidAlive(existing.pid)) {
+        return { started: false, state: existing, reason: 'already running' };
+    }
+    fs.mkdirSync(stateDir(), { recursive: true });
+    const logPath = daemonLogPath();
+    const child = spawnDetached(['--schedule-daemon', '--port', String(port)], logPath);
+    if (!child.pid)
+        return { started: false, state: null, reason: 'spawn failed' };
+    const state = { pid: child.pid, port, startedAt: new Date().toISOString() };
+    fs.writeFileSync(daemonStatePath(), `${JSON.stringify(state, null, 2)}\n`);
+    return { started: true, state };
+}
+/** 停止守护进程并清状态。 */
+export function stopDaemon() {
+    const state = getDaemonState();
+    if (!state)
+        return false;
+    const ok = killTree(state.pid);
+    try {
+        fs.rmSync(daemonStatePath());
+    }
+    catch {
+        // ignore
+    }
+    return ok;
+}

package/dist/schedule/store.js

@@ -0,0 +1,98 @@
+// 调度计划存储：<sandboxRoot>/.mocode/schedules/<id>.json。
+// 一个 schedule 有两种触发方式：cron（周期）或 webhook（仅 HTTP 触发，cron 为空串）。
+// 同一 schedule 也可两者并存（cron 表达式 + webhookToken 都配）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { getSandboxRoot } from '../sandbox/index.js';
+import { parseCron } from './cron.js';
+function schedulesRoot() {
+    return path.join(getSandboxRoot() ?? process.cwd(), '.mocode', 'schedules');
+}
+function recordPath(id) {
+    return path.join(schedulesRoot(), `${id}.json`);
+}
+export function createScheduleId() {
+    return `sch-${Date.now()}-${randomBytes(2).toString('hex')}`;
+}
+/** 校验候选字段；非法（cron 语法错 / 无任何触发器）抛错。 */
+function validate(cron, webhookToken) {
+    if (cron.trim() !== '')
+        parseCron(cron);
+    if (!cron.trim() && !webhookToken) {
+        throw new Error('schedule needs a cron expression or a webhook token (no trigger configured)');
+    }
+}
+export function saveSchedule(record) {
+    fs.mkdirSync(schedulesRoot(), { recursive: true });
+    const target = recordPath(record.id);
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+    fs.renameSync(tmp, target);
+}
+export function getSchedule(id) {
+    try {
+        return JSON.parse(fs.readFileSync(recordPath(id), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** 创建并落盘一个 schedule。 */
+export function createSchedule(input) {
+    const cron = (input.cron ?? '').trim();
+    const webhookToken = input.webhook ? randomBytes(8).toString('hex') : undefined;
+    validate(cron, webhookToken);
+    const record = {
+        id: createScheduleId(),
+        name: input.name,
+        prompt: input.prompt,
+        cron,
+        enabled: true,
+        ...(webhookToken ? { webhookToken } : {}),
+        ...(input.worktree ? { worktree: true } : {}),
+        ...(input.sessionDir ? { sessionDir: input.sessionDir } : {}),
+        createdAt: new Date().toISOString(),
+    };
+    saveSchedule(record);
+    return record;
+}
+export function updateSchedule(id, patch) {
+    const current = getSchedule(id);
+    if (!current)
+        return null;
+    const next = { ...current, ...patch };
+    validate(next.cron, next.webhookToken);
+    saveSchedule(next);
+    return next;
+}
+export function deleteSchedule(id) {
+    try {
+        fs.rmSync(recordPath(id));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function listSchedules() {
+    let files;
+    try {
+        files = fs.readdirSync(schedulesRoot());
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const file of files) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            records.push(JSON.parse(fs.readFileSync(path.join(schedulesRoot(), file), 'utf8')));
+        }
+        catch {
+            // skip corrupt
+        }
+    }
+    return records.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
+}