@konglx/rotom 2.21.0

package/dist/master/scheduler.js

@@ -0,0 +1,201 @@
+import { toBeijing } from "../shared/time.js";
+/**
+ * Scheduler — 群内定时任务调度器
+ *
+ * 设计要点(参考 hermes-agent cron/scheduler.py + cron/jobs.py,简化后落到 rotom):
+ *
+ *  - `next_run_at` 字段驱动:不靠 `last_run_at + interval` 算,而是显式维护下次运行时间。
+ *  - schedule 两形态:
+ *      - schedule_kind='interval' + interval_sec: 每 N 秒跑一次
+ *      - schedule_kind='once' + run_at: 在指定时间戳跑一次,跑完自动 enabled=0
+ *  - grace window 防宕机堆积:Master 宕机后重启,如果 now - next_run_at > grace 就
+ *    fast-forward 到下一个未来时间点,不补跑历史。recurring 用 `computeGraceSec`
+ *    (max(120, min(interval_sec/2, 7200)));一次性任务用 ONESHOT_GRACE_SEC=120。
+ *  - at-most-once:执行前先把 next_run_at 推进到下一个时间点,再派 Issue / 发消息,
+ *    崩溃后重启不会重跑。
+ *  - 两种触发模式:
+ *      - mode='agent': 创建 Issue + hub.pushIssueAssignment(group_id, agent_name),
+ *        agent 离线或上一轮 Issue 仍 in_progress 就跳过,但 next_run_at 仍推进。
+ *      - mode='message': 直接调 hub.postSystemToGroup(group_id, prompt),无需 agent。
+ *  - 串行 tick:30s 一次,无需并行池;Issue 在 worker 进程跑,不阻塞 scheduler。
+ *
+ * 不在本期:
+ *  - tryClaimNextIssue 的 poller(plan 已选 push 路径)
+ *  - Dashboard UI / WS 协议变更 / 跨 Master 协调 / cron 表达式 / file lock
+ */
+import { randomUUID } from "node:crypto";
+import { resolveGroupAgentWorkingDir } from "./group-paths.js";
+import { createLogger } from "../shared/logger.js";
+import { getSchedulerHandler } from "./scheduler-handlers.js";
+const log = createLogger("mesh-scheduler");
+/** 调度器扫描周期。每 20s 看一眼:扫 scheduled_tasks(含 ask-bridge handler)。 */
+const TICK_MS = 20_000;
+/** 一次性任务的 grace window,固定 120s。 */
+const ONESHOT_GRACE_SEC = 120;
+/** recurring 任务 grace 下界 / 上界。 */
+const MIN_GRACE_SEC = 120;
+const MAX_GRACE_SEC = 7200;
+function computeGraceSec(intervalSec) {
+    return Math.max(MIN_GRACE_SEC, Math.min(Math.floor(intervalSec / 2), MAX_GRACE_SEC));
+}
+export class Scheduler {
+    db;
+    hub;
+    timer = null;
+    ticking = false;
+    constructor(db, hub) {
+        this.db = db;
+        this.hub = hub;
+    }
+    start() {
+        if (this.timer)
+            return;
+        log.info(`Scheduler started (tick=${TICK_MS}ms)`);
+        this.timer = setInterval(() => this.tick().catch((err) => log.error("scheduler tick failed", err)), TICK_MS);
+        // 启动时立刻扫一次,避免冷启动后等满 30s
+        this.tick().catch((err) => log.error("scheduler initial tick failed", err));
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        log.info("Scheduler stopped");
+    }
+    async tick() {
+        if (this.ticking)
+            return; // 上一轮还没跑完,跳过(避免 tick 重叠)
+        this.ticking = true;
+        try {
+            const now = Date.now();
+            const due = this.db.getDueScheduledTasks(now);
+            if (due.length === 0)
+                return;
+            log.info(`tick: ${due.length} task(s) due`);
+            for (const task of due) {
+                await this.runOne(task, now);
+            }
+        }
+        finally {
+            this.ticking = false;
+        }
+    }
+    async runOne(task, now) {
+        // 1. 宕机堆积保护:recurring 任务错过超过 grace 窗口,fast-forward 不补跑
+        if (task.schedule_kind === "interval") {
+            const graceSec = computeGraceSec(task.interval_sec);
+            if (now - task.next_run_at > graceSec * 1000) {
+                const next = now + task.interval_sec * 1000;
+                this.db.rescheduleTask(task.id, next);
+                log.info(`task #${task.id} "${task.name}" stale, fast-forward to ${toBeijing(next)}`);
+                return;
+            }
+        }
+        else if (task.schedule_kind === "once") {
+            // 一次性任务用更小的 grace;过了太久没跑就当过期,直接 disable
+            if (now - task.next_run_at > ONESHOT_GRACE_SEC * 1000) {
+                this.db.disableScheduledTask(task.id);
+                log.info(`task #${task.id} "${task.name}" oneshot expired, disabled`);
+                return;
+            }
+        }
+        // 2. at-most-once:先把 next_run_at 推进,再执行。崩溃后重启不会重跑
+        const nextRun = this.computeNextRun(task, now);
+        if (nextRun !== null) {
+            this.db.rescheduleTask(task.id, nextRun);
+        }
+        const newRepeatCount = task.repeat_count + 1;
+        try {
+            // handler 模式:跑硬编码逻辑(ask-bridge-check 等),不走 prompt/agent 路径
+            if (task.handler_key) {
+                const handler = getSchedulerHandler(task.handler_key);
+                if (!handler) {
+                    this.db.markScheduledTaskRun(task.id, now, "error", `unknown handler: ${task.handler_key}`, null, newRepeatCount);
+                    log.error(`task #${task.id} "${task.name}" unknown handler: ${task.handler_key}`);
+                    this.autoDisableIfDone(task, newRepeatCount);
+                    return;
+                }
+                let payload;
+                try {
+                    payload = task.handler_payload ? JSON.parse(task.handler_payload) : {};
+                }
+                catch (e) {
+                    this.db.markScheduledTaskRun(task.id, now, "error", `bad handler_payload JSON: ${e.message}`, null, newRepeatCount);
+                    log.error(`task #${task.id} "${task.name}" bad handler_payload`, e);
+                    this.autoDisableIfDone(task, newRepeatCount);
+                    return;
+                }
+                const result = await handler(payload, { db: this.db, hub: this.hub });
+                this.db.markScheduledTaskRun(task.id, now, result.status, result.error ?? null, result.issueId ?? null, newRepeatCount);
+                log.info(`task #${task.id} "${task.name}" handler "${task.handler_key}" → ${result.status}${result.issueId ? ` (issue ${result.issueId})` : ""}`);
+                this.autoDisableIfDone(task, newRepeatCount);
+                return;
+            }
+            if (task.mode === "message") {
+                this.hub.postSystemToGroup(task.group_id, task.prompt);
+                this.db.markScheduledTaskRun(task.id, now, "ok", null, null, newRepeatCount);
+                log.info(`task #${task.id} "${task.name}" message posted to group ${task.group_id}`);
+            }
+            else {
+                // agent 模式:防堆积,上一轮 Issue 仍 in_progress 就跳过(但 next_run_at 已推进)
+                if (task.last_issue_id) {
+                    const prev = this.db.getIssueById(task.last_issue_id);
+                    if (prev && prev.status === "in_progress") {
+                        this.db.markScheduledTaskRun(task.id, now, "skipped", "prev issue in_progress", null, newRepeatCount);
+                        log.info(`task #${task.id} "${task.name}" skipped: prev issue still in_progress`);
+                        this.autoDisableIfDone(task, newRepeatCount);
+                        return;
+                    }
+                }
+                const agent = this.db.getAgentByName(task.agent_name);
+                if (!agent || agent.status !== "online") {
+                    const reason = !agent ? "agent not found" : "agent offline";
+                    this.db.markScheduledTaskRun(task.id, now, "skipped", reason, null, newRepeatCount);
+                    log.info(`task #${task.id} "${task.name}" skipped: ${reason}`);
+                    this.autoDisableIfDone(task, newRepeatCount);
+                    return;
+                }
+                const issueId = randomUUID();
+                this.db.createIssue({
+                    id: issueId,
+                    groupId: task.group_id,
+                    title: `[定时] ${task.name}`,
+                    description: task.prompt,
+                    createdBy: "system:scheduler",
+                    workingDir: resolveGroupAgentWorkingDir(this.db, task.group_id, task.agent_name),
+                    assignedTo: task.agent_name,
+                });
+                const pushed = this.hub.pushIssueAssignment(issueId, task.agent_name);
+                if (!pushed) {
+                    this.db.markScheduledTaskRun(task.id, now, "error", "pushIssueAssignment failed", null, newRepeatCount);
+                    log.warn(`task #${task.id} "${task.name}" push failed`);
+                    this.autoDisableIfDone(task, newRepeatCount);
+                    return;
+                }
+                this.db.markScheduledTaskRun(task.id, now, "ok", null, issueId, newRepeatCount);
+                log.info(`task #${task.id} "${task.name}" dispatched issue ${issueId} → ${task.agent_name}`);
+            }
+            this.autoDisableIfDone(task, newRepeatCount);
+        }
+        catch (err) {
+            this.db.markScheduledTaskRun(task.id, now, "error", String(err?.message ?? err), null, newRepeatCount);
+            log.error(`task #${task.id} "${task.name}" threw`, err);
+            this.autoDisableIfDone(task, newRepeatCount);
+        }
+    }
+    /** 一次性任务或 repeat_times 用尽,自动 enabled=0。 */
+    autoDisableIfDone(task, newCount) {
+        if (task.schedule_kind === "once") {
+            this.db.disableScheduledTask(task.id);
+        }
+        else if (task.repeat_times != null && newCount >= task.repeat_times) {
+            this.db.disableScheduledTask(task.id);
+            log.info(`task #${task.id} "${task.name}" reached repeat_times=${task.repeat_times}, disabled`);
+        }
+    }
+    computeNextRun(task, now) {
+        if (task.schedule_kind === "once")
+            return null; // 一次性跑完靠 disable 兜底
+        return now + task.interval_sec * 1000;
+    }
+}

package/dist/master/server.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+/**
+ * Digital Employee Mesh — Master server (standalone entry point)
+ *
+ * Usage:
+ *   node dist/master/server.js [--port 28800] [--host 0.0.0.0] [--data ~/.rotom]
+ *
+ * Or via package.json bin:
+ *   mesh-master [--port 28800] [--data ~/.rotom]
+ */
+import express from "express";
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MeshDb } from "./db.js";
+import { AuthService } from "./auth.js";
+import { WSHub } from "./ws-hub.js";
+import { Router } from "./router.js";
+import { OfflineQueue } from "./offline-queue.js";
+import { createApi } from "./api/index.js";
+import { TerminalHub } from "./terminal-hub.js";
+import { Scheduler } from "./scheduler.js";
+import { ShareTokenStore } from "./share-tokens.js";
+import { handleIssuePatrolTerminal, handleLinkPatrolIssueTerminal } from "./patrol-terminal.js";
+import { DEFAULT_MASTER_PORT, DEFAULT_MASTER_HOST } from "../shared/constants.js";
+import os from "node:os";
+import { createLogger, enableFileLogging, closeFileLogging } from "../shared/logger.js";
+import { getMasterIdentity } from "./federation/identity.js";
+import { runOpcBootstrap, ensureLocalExecutor } from "./opc-bootstrap.js";
+import { initFederationManager } from "./federation/manager.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const log = createLogger("mesh-master");
+function resolveDataDir() {
+    return process.env.ROTOM_HOME || path.join(os.homedir(), ".rotom");
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {
+        port: DEFAULT_MASTER_PORT,
+        host: DEFAULT_MASTER_HOST,
+        dataDir: resolveDataDir(),
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case "--port":
+            case "-p":
+                config.port = parseInt(args[++i]) || DEFAULT_MASTER_PORT;
+                break;
+            case "--host":
+            case "-h":
+                config.host = args[++i] || DEFAULT_MASTER_HOST;
+                break;
+            case "--data":
+            case "-d":
+                config.dataDir = args[++i] || resolveDataDir();
+                break;
+        }
+    }
+    return config;
+}
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+async function main() {
+    const config = parseArgs();
+    // Enable daily-rotated file logging under data directory
+    enableFileLogging(path.join(path.resolve(config.dataDir), "logs"));
+    log.info("Starting...");
+    log.info(`Data directory: ${path.resolve(config.dataDir)}`);
+    // Database
+    const db = new MeshDb(path.join(config.dataDir, "mesh.db"));
+    // OPC bootstrap — 解析本机 master 身份 + 首次启动建默认 agent / group。
+    // 失败(hostname 校验等)直接终止启动 —— OPC 是底层身份,不能没有。
+    const identity = getMasterIdentity({ rotomHome: config.dataDir });
+    const opcResult = runOpcBootstrap(db, identity);
+    // Patrol auto-sync: when an issue reaches terminal state, advance patrol state
+    db._onIssueTerminal = (issueId) => {
+        const issue = db.getIssueById(issueId);
+        if (!issue)
+            return;
+        const group = db.getGroupByIdFull(issue.group_id);
+        if (group?.type === "patrol") {
+            handleIssuePatrolTerminal(db, issue);
+            return;
+        }
+        if (group?.type === "patrol-link") {
+            handleLinkPatrolIssueTerminal(db, issue);
+            return;
+        }
+    };
+    // Reset stale online status from previous run
+    const resetCount = db.resetAllOnline();
+    if (resetCount > 0) {
+        log.info(`Reset ${resetCount} stale online agent(s) to offline`);
+    }
+    // Services — single AuthService shared between WSHub and API
+    const auth = new AuthService(db);
+    const offlineQueue = new OfflineQueue(db);
+    const router = new Router(db, log);
+    const shareTokens = new ShareTokenStore();
+    // HTTP + Express
+    const app = express();
+    // 15mb to allow base64-encoded image uploads via /api/uploads (see
+    // uploads.ts MAX_UPLOAD_BYTES — kept in sync). Regular JSON endpoints
+    // don't approach this; the limit is a ceiling, not a default allocation.
+    app.use(express.json({ limit: "15mb" }));
+    // Dashboard (static files)
+    // Prod (running from dist/master): build:master copies React dashboard
+    // build output to dist/master/dashboard.
+    // Dev (running src/master via tsx): fall back to packages/dashboard build
+    // output — run `pnpm dashboard:build` first.
+    let dashboardDir = path.resolve(__dirname, "dashboard");
+    if (!fs.existsSync(dashboardDir)) {
+        dashboardDir = path.resolve(__dirname, "../../packages/dashboard/dist/src/master/dashboard");
+    }
+    if (!fs.existsSync(dashboardDir)) {
+        log.warn(`Dashboard files not found. Run \`pnpm dashboard:build\` then retry. Looked in: ${dashboardDir}`);
+    }
+    else {
+        log.info(`Dashboard files: ${dashboardDir}`);
+    }
+    app.use("/dashboard", express.static(dashboardDir));
+    // SPA fallback — serve index.html for all /dashboard/* routes (client-side routing)
+    app.get("/dashboard/*", (_req, res) => {
+        res.sendFile(path.join(dashboardDir, "index.html"));
+    });
+    // Root redirect
+    app.get("/", (_req, res) => res.redirect("/dashboard"));
+    // Health check (unauthenticated)
+    app.get("/health", (_req, res) => {
+        res.json({ status: "ok", ...db.stats() });
+    });
+    // Create HTTP server first — needed by WSHub
+    const httpServer = http.createServer(app);
+    // WebSocket Hub (attaches to HTTP server) — shares auth service
+    const hub = new WSHub(httpServer, db, auth, router, offlineQueue, log);
+    hub.start();
+    // Federation:FederationManager 封装 fedClient/fedPublisher/fedServer 生命周期。
+    // API 层(POST /api/teams/join)可通过 getFederationManager() runtime 切换 federation 状态。
+    const federationManager = initFederationManager({
+        db, hub, router, httpServer, identity,
+        rotomHome: config.dataDir,
+        masterPort: config.port,
+    });
+    federationManager.initFromRole();
+    // Web terminal hub — mounts on /api/terminal alongside the agent /ws.
+    // Lazy-loads node-pty; no-op if the optional dep isn't installed.
+    const terminalHub = new TerminalHub(httpServer, db, log);
+    await terminalHub.start();
+    // Scheduled-task scheduler — 30s tick interval, drives scheduled_tasks rows
+    // that trigger pushIssueAssignment (agent mode) or postSystemToGroup (message mode).
+    const scheduler = new Scheduler(db, hub);
+    scheduler.start();
+    // REST API — shares auth service and hub with WSHub
+    app.use("/api", createApi(db, auth, hub, router, config.port, shareTokens));
+    // Listen
+    let localExecutor = null;
+    await new Promise((resolve) => {
+        httpServer.listen(config.port, config.host, () => {
+            log.info(`Running on http://${config.host}:${config.port}`);
+            log.info(`Dashboard: http://localhost:${config.port}/dashboard`);
+            log.info(`WebSocket: ws://localhost:${config.port}/ws`);
+            log.info(`Terminal:  ws://localhost:${config.port}/api/terminal`);
+            log.info(`API: http://localhost:${config.port}/api`);
+            log.warn("API authentication is DISABLED (internal network mode)");
+            // master 监听 ready 后再 spawn 本机 executor —— 避免 executor 比 master 早起来连不上。
+            // 注意:即使用户已有 agents(OPC bootstrap 没建 defaultAgent),也要 spawn executor,
+            // 否则用户的 agents 上不了线。defaultAgentName 仅用于 .auto-executor.json 的兜底,
+            // scanClis 模式下用不到。
+            localExecutor = ensureLocalExecutor({
+                rotomHome: config.dataDir,
+                masterPort: config.port,
+                defaultAgentName: opcResult.defaultAgent?.name,
+            });
+            resolve();
+        });
+    });
+    // Graceful shutdown
+    const shutdown = () => {
+        log.info("Shutting down...");
+        federationManager.stop();
+        localExecutor?.stop();
+        scheduler.stop();
+        hub.stop();
+        terminalHub.stop();
+        router.stop();
+        db.close();
+        httpServer.close(() => {
+            log.info("Goodbye.");
+            closeFileLogging();
+            process.exit(0);
+        });
+        // Force exit after 5s
+        setTimeout(() => process.exit(1), 5000);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+    log.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/master/services/link-collector.js

@@ -0,0 +1,82 @@
+/**
+ * Link collector —— 消息发送路径上的 inline hook。
+ *
+ * 用法:在 4 个 addGroupMessage 调用点之后,直接调
+ *   collectLinksFromText(text, ctx, db)
+ * 函数内部纯函数式抽 URL → 规范化 → dedup by url_norm → 入库。
+ *
+ * 错误隔离:整个流程包 try/catch,失败只 log.warn,绝不影响消息发送主路径。
+ * 不抓 system sender 的消息(系统消息不含真实业务链接,且会重复触发)。
+ */
+import { randomUUID } from "node:crypto";
+import { extractUrls, normalizeUrl, extractContextSnippet, } from "../../shared/url-extractor.js";
+import { createLogger } from "../../shared/logger.js";
+const log = createLogger("link-collector");
+/**
+ * 从消息正文抽 URL 入库。
+ * 同一消息内多次出现的同一 URL 也各算一次 occurrence(防漏抓上下文)。
+ */
+export function collectLinksFromText(text, ctx, db) {
+    if (!text)
+        return;
+    // system sender 跳过
+    if (ctx.sourceSender && ctx.sourceSender === "system")
+        return;
+    let extracted;
+    try {
+        extracted = extractUrls(text);
+    }
+    catch (err) {
+        log.warn(`extractUrls failed: ${err.message}`);
+        return;
+    }
+    if (extracted.length === 0)
+        return;
+    for (const item of extracted) {
+        try {
+            const norm = normalizeUrl(item.raw);
+            if (!norm)
+                continue; // 非法 / 非 http(s) 丢弃
+            const snippet = extractContextSnippet(text, item.index, item.raw.length);
+            const existing = db.getLinkByUrlNorm(norm.norm);
+            if (existing) {
+                db.addLinkOccurrence(existing.id, {
+                    sourceType: ctx.sourceType,
+                    sourceId: ctx.sourceId,
+                    sourceGroupId: ctx.sourceGroupId,
+                    sourceSender: ctx.sourceSender,
+                    contextSnippet: snippet,
+                });
+                db.touchLinkLastSeen(existing.id);
+                if (ctx.sourceGroupId)
+                    db.addLinkSourceGroup(existing.id, ctx.sourceGroupId);
+            }
+            else {
+                const linkId = randomUUID();
+                db.createLink({
+                    id: linkId,
+                    urlNorm: norm.norm,
+                    urlRaw: norm.raw,
+                    host: norm.host,
+                });
+                // 并发情况:另一个 collector tick 可能在我们 createLink 之前抢先 INSERT,
+                // INSERT OR IGNORE 后再查一次确保有 row(若已被抢先,existing 就拿到那个 id)
+                const again = db.getLinkByUrlNorm(norm.norm);
+                const finalId = again?.id ?? linkId;
+                db.addLinkOccurrence(finalId, {
+                    sourceType: ctx.sourceType,
+                    sourceId: ctx.sourceId,
+                    sourceGroupId: ctx.sourceGroupId,
+                    sourceSender: ctx.sourceSender,
+                    contextSnippet: snippet,
+                });
+                if (ctx.sourceGroupId)
+                    db.addLinkSourceGroup(finalId, ctx.sourceGroupId);
+            }
+        }
+        catch (err) {
+            // 单条失败不影响其他链接
+            log.warn(`collectLinksFromText: URL "${item.raw}" 失败: ${err.message}`);
+        }
+    }
+}

package/dist/master/services/link-patrol-bootstrap.js

@@ -0,0 +1,50 @@
+/**
+ * Link-patrol group bootstrap —— type=patrol-link 群建群时的副作用。
+ *
+ * 仿 services/patrol-bootstrap.ts:
+ *   - 创建 recurring link-patrol scheduled task(interval 3600s,handler_key="link-patrol")
+ *   - 绑定 link-patrol-rules skill 到巡检员 agent(skill seed 在 migration 053 里)
+ *
+ * Failed skill binding 非致命 —— schedule 仍跑,agent 没规则 prompt 时用兜底判断。
+ */
+export function buildLinkPatrolPayload(groupId, agentName) {
+    return {
+        patrolGroupId: groupId,
+        patrolAgentName: agentName,
+        scanBatch: 20,
+    };
+}
+// 默认 5 小时一次:链接分类的 few-shot 增量慢,1h 太频会浪费 token,4h 以上更稳。
+// 改这块要 dashboard 那边的 "Link 分类" tab 也跟着(intervalSec 默认值)。
+const LINK_PATROL_DEFAULT_INTERVAL_SEC = 5 * 60 * 60;
+export function bootstrapLinkPatrolGroup(db, log, groupId, agentName) {
+    if (!agentName)
+        return;
+    const payload = buildLinkPatrolPayload(groupId, agentName);
+    db.createScheduledTask({
+        name: "链接智能分类",
+        groupId,
+        mode: "agent",
+        agentName,
+        scheduleKind: "interval",
+        intervalSec: LINK_PATROL_DEFAULT_INTERVAL_SEC,
+        prompt: "",
+        enabled: true,
+        handlerKey: "link-patrol",
+        handlerPayload: JSON.stringify(payload),
+    });
+    const skill = db.getSkillByName("link-patrol-rules");
+    if (skill) {
+        db.bindSkill({
+            groupId,
+            agentName,
+            skillId: skill.id,
+            createdBy: "system:link-patrol-bootstrap",
+        });
+        log.info(`Link-patrol group ${groupId}: bound link-patrol-rules to ${agentName}`);
+    }
+    else {
+        log.warn(`Link-patrol group ${groupId}: link-patrol-rules skill not found, skip binding`);
+    }
+    log.info(`Link-patrol group ${groupId}: auto-created link-patrol schedule (interval 3600s, enabled)`);
+}

package/dist/master/services/memory-extract-prompt.js

@@ -0,0 +1,34 @@
+/**
+ * Memory-extract prompt builder — extracted from api/issues.ts so the API
+ * handler stays thin and the prompt text is testable in isolation.
+ *
+ * When the dashboard triggers "extract memory from this issue", the API
+ * creates a child issue assigned to a chosen agent with this prompt as its
+ * description. The agent reads the parent issue, distills 0..N memory
+ * entries (fact / decision / convention / pitfall / todo / playbook), and
+ * writes them via `rotom memory add ... --pending` for human review.
+ */
+/**
+ * Build the Chinese prompt that instructs the agent to extract durable
+ * memory entries from a finished issue.
+ */
+export function buildMemoryExtractPrompt(sourceIssue, sourceShortId) {
+    return [
+        `[记忆提取任务] 请从 Issue #${sourceShortId} 的产出中提炼值得长期记住的经验。`,
+        ``,
+        `原 Issue 标题:${sourceIssue.title}`,
+        `原 Issue 描述:`,
+        sourceIssue.description || "(无)",
+        ``,
+        `步骤:`,
+        `1. 用 \`rotom issue show ${sourceIssue.id}\` 或读 issue 详情,了解这次任务做了什么、关键决策、踩过的坑、用到的技术栈/约定`,
+        `2. 提炼 0~N 条记忆,每条选定 category(fact/decision/convention/pitfall/todo/playbook)`,
+        `3. 每条用 \`rotom memory add ${sourceIssue.group_id} --key <主题> --value <内容> --category <cat> --summary <一句话> --pending\` 写入`,
+        `   - --pending 必须加,写入后处于待审核状态,由人在 dashboard 审核`,
+        `   - key 用 "decision:xxx" / "pitfall:xxx" / "fact:xxx" 等带前缀的形式`,
+        `   - 只提炼真正值得长期记住的,无关细节不要记。没有值得记的就一条都不写`,
+        `4. 完成后在群里回复"已提取 N 条记忆,待审核"`,
+        ``,
+        `重要:不要记临时性的、任务特定的、下次不会复用的信息。`,
+    ].join("\n");
+}

package/dist/master/services/patrol-bootstrap.js

@@ -0,0 +1,63 @@
+/**
+ * Patrol-group bootstrap — extracted from api/groups.ts createGroup handler
+ * so the API layer stays thin. Owns the side-effects that fire when a group
+ * with `type === "patrol"` is created:
+ *   - create the recurring `issue-patrol` scheduled task (default interval 7200s = 2h)
+ *   - bind the `issue-patrol-rules` skill to the patrol agent (if it exists)
+ *
+ * Failed skill binding is non-fatal — the schedule still runs, the agent
+ * just doesn't get the rules prompt injected.
+ */
+// 默认 2 小时一次:巡检本质是观察 + 预警,1h 太频反而是噪音;2h 留出足够的处理窗口
+// 又不至于错过新 issue(常见新 issue 在群聊触发,2h 内会被人工认领)。
+const PATROL_DEFAULT_INTERVAL_SEC = 2 * 60 * 60;
+/**
+ * Build the handler payload used by both the scheduled task and the
+ * dashboard's "what does this patrol do?" view. Pulled out so the shape
+ * stays in one place if the patrol handler evolves.
+ */
+export function buildPatrolPayload(groupId, agentName) {
+    return {
+        patrolGroupId: groupId,
+        patrolAgentName: agentName,
+        throughputCap: 3,
+        candidateCap: 3,
+        scanBatch: 10,
+    };
+}
+/**
+ * Create the recurring `issue-patrol` schedule and bind the
+ * `issue-patrol-rules` skill to the patrol agent. No-op if `agentName`
+ * is empty.
+ */
+export function bootstrapPatrolGroup(db, log, groupId, agentName) {
+    if (!agentName)
+        return;
+    const payload = buildPatrolPayload(groupId, agentName);
+    db.createScheduledTask({
+        name: "Issue 巡检",
+        groupId,
+        mode: "agent", // handler 模式下 mode 不被使用,但 schema NOT NULL,保留 agent
+        agentName,
+        scheduleKind: "interval",
+        intervalSec: PATROL_DEFAULT_INTERVAL_SEC,
+        prompt: "", // handler 模式不用 prompt,但 schema NOT NULL
+        enabled: true,
+        handlerKey: "issue-patrol",
+        handlerPayload: JSON.stringify(payload),
+    });
+    const skill = db.getSkillByName("issue-patrol-rules");
+    if (skill) {
+        db.bindSkill({
+            groupId,
+            agentName,
+            skillId: skill.id,
+            createdBy: "system:patrol-bootstrap",
+        });
+        log.info(`Patrol group ${groupId}: bound issue-patrol-rules to ${agentName}`);
+    }
+    else {
+        log.warn(`Patrol group ${groupId}: issue-patrol-rules skill not found, skip binding`);
+    }
+    log.info(`Patrol group ${groupId}: auto-created issue-patrol schedule (interval ${PATROL_DEFAULT_INTERVAL_SEC}s, enabled)`);
+}