mocode-ai 1.6.5 → 1.6.6

package/dist/repl/commands/jobs.js

@@ -0,0 +1,109 @@
+/**
+ * 后台任务命令组:/jobs · /jobs log [id前缀] · /jobs kill [id前缀]
+ *
+ * 不依赖 REPL 闭包状态（job 真相在 .mocode/jobs/），所以是这批命令里最独立的一组。
+ * id 可只给时间戳前缀（如 /jobs kill 20260926-1730），唯一定位即可。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { listJobs, readJobLog } from '../../jobs/store.js';
+import { killBackgroundJob } from '../../jobs/launch.js';
+import { unhandled, next } from './types.js';
+const STATUS_COLOR = {
+    paused: ui.cyan,
+    running: ui.yellow,
+    succeeded: ui.green,
+    failed: ui.red,
+    killed: ui.dim,
+};
+function findJob(idPrefix) {
+    const jobs = listJobs();
+    if (!idPrefix)
+        return jobs[0];
+    const matches = jobs.filter((j) => j.id.startsWith(idPrefix));
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function oneLinePrompt(prompt) {
+    const line = prompt.split('\n')[0] ?? '';
+    return line.length > 50 ? `${line.slice(0, 50)}…` : line;
+}
+function renderList() {
+    const jobs = listJobs().slice(0, 10);
+    if (jobs.length === 0) {
+        layout.contentWrite(`${ui.dim}(没有后台任务。用 mocode run --bg "任务" 启动)${ui.reset}\n`);
+        return;
+    }
+    for (const job of jobs) {
+        const color = STATUS_COLOR[job.status];
+        layout.contentWrite(`  ${color}●${ui.reset} ${ui.bold}${job.id}${ui.reset}  ${color}${job.status}${ui.reset}\n` +
+            `      ${ui.dim}${oneLinePrompt(job.prompt)}${ui.reset}\n`);
+    }
+    layout.contentWrite(`${ui.dim}  /jobs log [id前缀] 看尾日志 · /jobs kill [id前缀] 杀任务${ui.reset}\n`);
+}
+export const jobsCommands = [
+    // /jobs approve|deny [id前缀]
+    async (ctx) => {
+        if (ctx.cmd !== '/jobs')
+            return unhandled();
+        const parts = ctx.line.split(/\s+/);
+        if (parts[1] !== 'approve' && parts[1] !== 'deny')
+            return unhandled();
+        const job = findJob(parts[2]);
+        if (!job) {
+            layout.contentWrite(`${ui.yellow}(没找到唯一匹配的任务)${ui.reset}\n`);
+            return next();
+        }
+        if (job.status !== 'paused') {
+            layout.contentWrite(`${ui.dim}任务 ${job.id} 状态 ${job.status}，无需审批${ui.reset}\n`);
+            return next();
+        }
+        const { runApproveCli } = await import('../../jobs/approve-cli.js');
+        runApproveCli([job.id], parts[1] === 'approve' ? 'approved' : 'denied');
+        return next();
+    },
+    // /jobs kill [id前缀]
+    (ctx) => {
+        if (ctx.cmd !== '/jobs')
+            return unhandled();
+        const parts = ctx.line.split(/\s+/);
+        if (parts[1] !== 'kill')
+            return unhandled();
+        const job = findJob(parts[2]);
+        if (!job) {
+            layout.contentWrite(`${ui.yellow}(没找到唯一匹配的任务)${ui.reset}\n`);
+            return next();
+        }
+        if (job.status !== 'running' && job.status !== 'paused') {
+            layout.contentWrite(`${ui.dim}任务 ${job.id} 已是 ${job.status}，无需 kill${ui.reset}\n`);
+            return next();
+        }
+        const ok = killBackgroundJob(job);
+        layout.contentWrite(ok
+            ? `${ui.yellow}已 kill 任务 ${job.id}${ui.reset}\n`
+            : `${ui.red}kill 失败（进程可能已退出；PID=${job.pid ?? '?'})${ui.reset}\n`);
+        return next();
+    },
+    // /jobs log [id前缀]
+    (ctx) => {
+        if (ctx.cmd !== '/jobs')
+            return unhandled();
+        const parts = ctx.line.split(/\s+/);
+        if (parts[1] !== 'log')
+            return unhandled();
+        const job = findJob(parts[2]);
+        if (!job) {
+            layout.contentWrite(`${ui.yellow}(没找到唯一匹配的任务)${ui.reset}\n`);
+            return next();
+        }
+        layout.contentWrite(`${ui.bold}── log ${job.id} ──${ui.reset}\n`);
+        layout.contentWrite(`${readJobLog(job.id)}\n`);
+        return next();
+    },
+    // /jobs（列表）
+    (ctx) => {
+        if (ctx.line !== '/jobs')
+            return unhandled();
+        renderList();
+        return next();
+    },
+];

package/dist/repl/commands/model.js

@@ -246,26 +246,11 @@ export const modelCommands = [
         }
         // /model 无参 → 直接进入「配置新模型」4 步向导(不弹动作菜单)。
         //   切换 / 查看 / 删除已配置预设改用显式子命令:/model switch · /model list · /model delete <name>。
-        // 1) 选 provider 预设(预填 baseURL,后续仍可逐项改)。
-        let preset;
-        try {
-            const res = await promptIntervention({
-                type: 'choice',
-                title: '选择后端预设(预填 baseURL,后续可改)',
-                detail: '选一个会预填 baseURL/model/窗口,之后逐项确认。选「自定义」全部手填。',
-                options: MODEL_PRESETS.map((p) => p.label),
-            });
-            if (res.action === 'cancelled') {
-                return next();
-            }
-            const idx = MODEL_PRESETS.findIndex((p) => p.label === res.value);
-            if (idx === -1) {
-                return next();
-            }
-            preset = MODEL_PRESETS[idx];
-        }
-        catch {
-            return next(); // Ctrl+C
+        // 1) 后端预设：本地/远程都可由一个 OpenAI 兼容端点表达，故只保留「自定义 base_url」
+        //    一个入口；既然只有一个预设，不再弹选择菜单，直接进入字段填写。
+        const preset = MODEL_PRESETS[0];
+        if (!preset) {
+            return next();
         }
         // 1.5) 一键应用确认:非「自定义」预设(带预填值)给直接应用入口,免连按 4 次回车。
         //      直接应用 = 用预设 model/baseURL/window + 保留当前 apiKey(等价于下方逐项链连按回车)。

package/dist/repl/commands/registry.js

@@ -16,6 +16,9 @@ import { modelCatalogCommands } from './model-catalog.js';
 import { effortCommands } from './effort.js';
 import { routerCommands } from './router.js';
 import { toolGroupCommands } from './tool-group.js';
+import { jobsCommands } from './jobs.js';
+import { scheduleCommands } from './schedule.js';
+import { botsCommands } from './bots.js';
 /**
  * 命令注册表。顺序即匹配优先级 —— 更具体的分支放前面。
  * 组内顺序由各文件自己保证(见文件头注释);组间顺序互不影响(条件互斥)。
@@ -40,6 +43,9 @@ export const commandHandlers = [
     ...modelCommands,
     ...routerCommands,
     ...toolGroupCommands,
+    ...jobsCommands,
+    ...scheduleCommands,
+    ...botsCommands,
 ];
 /**
  * 依次询问 handler,返回第一个非 unhandled 的结果。

package/dist/repl/commands/schedule.js

@@ -0,0 +1,37 @@
+/**
+ * 调度计划命令:/schedules
+ * 只读列出 schedules + 守护进程状态；增删改/启停走 CLI `mocode schedule …`。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { listSchedules } from '../../schedule/store.js';
+import { isDaemonRunning, getDaemonState } from '../../schedule/daemon.js';
+import { unhandled, next } from './types.js';
+function oneLine(prompt) {
+    const line = prompt.split('\n')[0] ?? '';
+    return line.length > 50 ? `${line.slice(0, 50)}…` : line;
+}
+export const scheduleCommands = [
+    (ctx) => {
+        if (ctx.line !== '/schedules')
+            return unhandled();
+        const daemonState = getDaemonState();
+        const daemon = isDaemonRunning() && daemonState;
+        layout.contentWrite(daemon
+            ? `${ui.dim}scheduler:${ui.reset} ${ui.green}running${ui.reset} ` +
+                `${ui.dim}(pid ${daemonState?.pid}, port ${daemonState?.port})${ui.reset}\n`
+            : `${ui.dim}scheduler:${ui.reset} ${ui.yellow}stopped${ui.reset} ` +
+                `${ui.dim}(mocode schedule start)${ui.reset}\n`);
+        const all = listSchedules();
+        if (all.length === 0) {
+            layout.contentWrite(`${ui.dim}(no schedules; mocode schedule add …)${ui.reset}\n`);
+            return next();
+        }
+        for (const s of all) {
+            const trigger = s.cron ? s.cron : s.webhookToken ? `webhook:${s.webhookToken}` : '?';
+            layout.contentWrite(`  ${s.enabled ? ui.green + '●' : ui.dim + '○'}${ui.reset} ${ui.bold}${s.name}${ui.reset} ` +
+                `${ui.dim}${trigger}${ui.reset}\n      ${ui.dim}${oneLine(s.prompt)}${ui.reset}\n`);
+        }
+        return next();
+    },
+];

package/dist/repl/commands.js

@@ -30,6 +30,9 @@ export function buildSlashCommands() {
         { name: '/sessions', desc: d('commands.sessionBrowse') },
         { name: '/rollback', desc: d('commands.sessionRollback') },
         { name: '/ssearch <关键词>', value: '/ssearch ', submit: false, desc: '跨会话搜索归档会话' },
+        { name: '/jobs', desc: '后台任务列表(/jobs log/kill <id前缀>)' },
+        { name: '/schedules', desc: '查看定时计划与调度守护状态' },
+        { name: '/bots', desc: '查看具名 Bot 列表' },
         {
             name: '/memory',
             desc: d('commands.memory'),
@@ -271,64 +274,6 @@ export function themeDescription(name) {
 }
 /** /model 预设后端：同时声明原生协议；旧服务继续走 OpenAI-compatible。 */
 export const MODEL_PRESETS = [
-    {
-        label: 'Anthropic Claude',
-        provider: 'anthropic',
-        baseURL: 'https://api.anthropic.com',
-        model: 'claude-sonnet-4-5',
-        window: 200000,
-        anthropicPromptCache: true,
-    },
-    {
-        label: 'GLM(智谱)',
-        provider: 'openai',
-        baseURL: 'https://open.bigmodel.cn/api/v3',
-        model: 'glm-4.6',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: 'DeepSeek',
-        provider: 'openai',
-        baseURL: 'https://api.deepseek.com',
-        model: 'deepseek-chat',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: 'Qwen(阿里)',
-        provider: 'openai',
-        baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
-        model: 'qwen-plus',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    // MiniMax OpenAI 兼容端点(https://platform.minimax.io/docs/api-reference/text-openai-api)。
-    // MiniMax-M3 为唯一支持图片/视频输入的模型;M2 系列纯文本(见 llm/capabilities.ts KNOWN_TEXT_ONLY_PREFIXES)。
-    {
-        label: 'MiniMax',
-        provider: 'openai',
-        baseURL: 'https://api.minimax.io/v1',
-        model: 'MiniMax-M3',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: '本地 Ollama',
-        provider: 'openai',
-        baseURL: 'http://localhost:11434/v1',
-        model: 'qwen2.5:7b',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: '本地 vLLM',
-        provider: 'openai',
-        baseURL: 'http://localhost:8000/v1',
-        model: 'default',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
     {
         label: '自定义 base_url',
         provider: 'openai',

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;
+}