pi-proactive 0.0.0-stage → 0.2.0-beta.2

package/build/src/daemon-config.js

@@ -0,0 +1,488 @@
+/**
+ * DAEMON7：常驻值班进程的**配置面**与**落盘面**（预算硬上限 / 权限阶梯 / 交班摘要 / 值班状态）。
+ *
+ * 为什么不改 `src/types.ts`：类型真源是共享资产（多卡并行在用）→ 本卡**不改**它，
+ * 本文件自成一个封闭的配置与数据面（配置面 = 预算 + 权限阶梯；落盘面 = 值班状态 + 交班摘要）。
+ *
+ * 与 `src/daemon.ts` 的分工：
+ * - 本文件 = **纯数据 + 纯函数 + 落盘**（无循环、无定时器、无副作用副作用）；
+ * - `src/daemon.ts` = **值班循环**（读 TaskStore → 到点执行 → 记账 → 等待）。
+ *
+ * 成本硬约束（brief-v4 §10.4）：7×24 真跑 = 用户账号真实 token 支出 →
+ *   ① 默认**关闭**（`enabled=false`）；
+ *   ② **动作数**是硬约束（`maxActionsPerHour` / `maxActionsPerDay`）；
+ *   ③ token 只做**估算**（口径写死并写进交班摘要 → 不冒充实测值）。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { PROACTIVE_FILE_MODE, chmodQuiet, ensureDir, proactiveDir, writeAtomicFile } from "./config.js";
+/** 档位的**严格度**排序（数字越大越严格 → 命中多条规则时取最严的）。 */
+const TIER_SEVERITY = { auto: 0, limited: 1, "human-gated": 2 };
+/** 预算缺省值（**保守**：宁可少做事，也不超支）。 */
+export const DEFAULT_DAEMON_BUDGET = {
+    maxActionsPerHour: 6,
+    maxActionsPerDay: 40,
+    maxTokenUnitsPerDay: 200_000,
+    maxLimitedActionsPerDay: 20,
+    degradeToObserveWhenExhausted: true,
+};
+/**
+ * 缺省权限规则表（**最不假设**：不可逆词一律人工确认；只读词才自动执行）。
+ *
+ * 归类依据：
+ * - `auto`：只读 / 可逆（读了没改变什么）；
+ * - `limited`：有副作用但**可逆**（改了还能改回来）→ 自动执行，但在**更严的独立限额**内；
+ * - `human-gated`：**不可逆**（删了/发了/付了/发布了）→ **绝不自动执行** → 进确认队列。
+ */
+export const DEFAULT_PERMISSION_RULES = [
+    // ---- 不可逆 → 人工确认队列（绝不自动执行）----
+    { match: "删除", tier: "human-gated", reason: "删除动作不可逆" },
+    { match: "清空", tier: "human-gated", reason: "清空动作不可逆" },
+    { match: "部署", tier: "human-gated", reason: "部署影响外部世界，不可逆" },
+    { match: "发布", tier: "human-gated", reason: "发布对外可见且不可撤回" },
+    { match: "合并", tier: "human-gated", reason: "合并进主干不可轻易撤回" },
+    { match: "支付", tier: "human-gated", reason: "涉及金钱，不可逆" },
+    { match: "转账", tier: "human-gated", reason: "涉及金钱，不可逆" },
+    { match: "发送", tier: "human-gated", reason: "对外发送不可撤回" },
+    { match: "重置", tier: "human-gated", reason: "重置会丢失状态，不可逆" },
+    { match: "终止", tier: "human-gated", reason: "终止不可逆" },
+    { match: "delete", tier: "human-gated", reason: "删除动作不可逆" },
+    { match: "deploy", tier: "human-gated", reason: "部署影响外部世界，不可逆" },
+    { match: "publish", tier: "human-gated", reason: "发布对外可见且不可撤回" },
+    { match: "merge", tier: "human-gated", reason: "合并进主干不可轻易撤回" },
+    { match: "pay", tier: "human-gated", reason: "涉及金钱，不可逆" },
+    { match: "transfer", tier: "human-gated", reason: "涉及金钱，不可逆" },
+    { match: "send", tier: "human-gated", reason: "对外发送不可撤回" },
+    { match: "reset", tier: "human-gated", reason: "重置会丢失状态，不可逆" },
+    { match: "kill", tier: "human-gated", reason: "终止进程不可逆" },
+    { match: "truncate", tier: "human-gated", reason: "清空数据不可逆" },
+    { match: "revoke", tier: "human-gated", reason: "吊销不可逆" },
+    // ---- 有副作用但可逆 → limited（自动执行 + 独立限额）----
+    { match: "写入", tier: "limited", reason: "写操作有副作用但可逆" },
+    { match: "修改", tier: "limited", reason: "改操作有副作用但可逆" },
+    { match: "创建", tier: "limited", reason: "创建有副作用但可删除" },
+    { match: "安装", tier: "limited", reason: "安装有副作用但可卸载" },
+    { match: "重启", tier: "limited", reason: "重启有副作用但可恢复" },
+    { match: "提交", tier: "limited", reason: "提交有副作用但可回退" },
+    { match: "更新", tier: "limited", reason: "更新有副作用但可回退" },
+    { match: "write", tier: "limited", reason: "写操作有副作用但可逆" },
+    { match: "update", tier: "limited", reason: "更新有副作用但可回退" },
+    { match: "create", tier: "limited", reason: "创建有副作用但可删除" },
+    { match: "install", tier: "limited", reason: "安装有副作用但可卸载" },
+    { match: "restart", tier: "limited", reason: "重启有副作用但可恢复" },
+    { match: "commit", tier: "limited", reason: "提交有副作用但可回退" },
+    // ---- 只读 → auto（自动执行）----
+    { match: "读取", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "查看", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "列出", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "检查", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "汇总", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "报告", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "搜索", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "统计", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "read", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "list", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "show", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "summarize", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "inspect", tier: "auto", reason: "只读动作，无副作用" },
+    { match: "report", tier: "auto", reason: "只读动作，无副作用" },
+];
+/**
+ * token 估算口径（**写进交班摘要**，避免把估算冒充实测）。
+ *
+ * 口径：`ceil(字符数 / 4) × 2`（请求 + 响应各算一份）+ 每次动作 500 单位固定开销。
+ * 这是**粗估**，不是实测；**硬约束是动作数**，token 只作辅助观察。
+ */
+export const TOKEN_ESTIMATE_NOTE = "token 为**估算**：ceil(字符数 / 4) × 2（请求 + 响应各一份）+ 每次动作 500 单位固定开销；不是实测值，硬约束是动作数。";
+/** token 估算（见 `TOKEN_ESTIMATE_NOTE`）。 */
+export function estimateTokenUnits(text) {
+    const chars = typeof text === "string" ? text.length : 0;
+    return Math.ceil(chars / 4) * 2 + 500;
+}
+/** 缺省配置。 */
+export function defaultDaemonConfig(agentId) {
+    return {
+        version: "v1",
+        enabled: false,
+        agentId,
+        dryRun: true,
+        budget: { ...DEFAULT_DAEMON_BUDGET },
+        permissions: {
+            defaultTier: "limited",
+            rules: DEFAULT_PERMISSION_RULES.map((r) => ({ ...r })),
+        },
+        tickIntervalMs: 30_000,
+        handoverHour: 8,
+        staleSocketMs: 3_600_000,
+        staleExecutionMs: 3_600_000,
+    };
+}
+/** 配置文件路径：`<agentDir>/proactive/daemon.json`。 */
+export function daemonConfigPath(agentDir) {
+    return path.join(proactiveDir(agentDir), "daemon.json");
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function num(v, fallback) {
+    return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function bool(v, fallback) {
+    return typeof v === "boolean" ? v : fallback;
+}
+function str(v, fallback) {
+    return typeof v === "string" ? v : fallback;
+}
+function tier(v, fallback) {
+    return v === "auto" || v === "limited" || v === "human-gated" ? v : fallback;
+}
+/** 把落盘的原始 JSON 合并进缺省配置（**逐字段**校验，坏字段回落缺省）。 */
+export function mergeDaemonConfig(base, raw) {
+    if (!isPlainObject(raw))
+        return base;
+    const budget = isPlainObject(raw.budget) ? raw.budget : {};
+    const perms = isPlainObject(raw.permissions) ? raw.permissions : {};
+    const rawRules = Array.isArray(perms.rules) ? perms.rules : [];
+    const rules = [];
+    for (const item of rawRules) {
+        if (!isPlainObject(item))
+            continue;
+        const match = str(item.match, "").trim();
+        if (match === "")
+            continue;
+        rules.push({
+            match,
+            tier: tier(item.tier, base.permissions.defaultTier),
+            reason: str(item.reason, `命中关键词「${match}」`),
+        });
+    }
+    return {
+        version: "v1",
+        enabled: bool(raw.enabled, base.enabled),
+        agentId: str(raw.agentId, base.agentId),
+        dryRun: bool(raw.dryRun, base.dryRun),
+        budget: {
+            maxActionsPerHour: num(budget.maxActionsPerHour, base.budget.maxActionsPerHour),
+            maxActionsPerDay: num(budget.maxActionsPerDay, base.budget.maxActionsPerDay),
+            maxTokenUnitsPerDay: num(budget.maxTokenUnitsPerDay, base.budget.maxTokenUnitsPerDay),
+            maxLimitedActionsPerDay: num(budget.maxLimitedActionsPerDay, base.budget.maxLimitedActionsPerDay),
+            degradeToObserveWhenExhausted: bool(budget.degradeToObserveWhenExhausted, base.budget.degradeToObserveWhenExhausted),
+        },
+        permissions: {
+            defaultTier: tier(perms.defaultTier, base.permissions.defaultTier),
+            rules: rules.length > 0 ? rules : base.permissions.rules,
+        },
+        tickIntervalMs: num(raw.tickIntervalMs, base.tickIntervalMs),
+        handoverHour: num(raw.handoverHour, base.handoverHour),
+        staleSocketMs: num(raw.staleSocketMs, base.staleSocketMs),
+        staleExecutionMs: num(raw.staleExecutionMs, base.staleExecutionMs),
+    };
+}
+/**
+ * 读取配置（**只读**；坏文件 / 未知版本 → 回落缺省 + 用户可见提示，**不覆盖原文件**）。
+ *
+ * @returns 配置 + 用户可见提示（空数组 = 无提示）
+ */
+export function loadDaemonConfig(agentDir, agentId) {
+    const base = defaultDaemonConfig(agentId);
+    const file = daemonConfigPath(agentDir);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return { config: base, notices: [] };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {
+            config: base,
+            notices: [`proactive: daemon.json 不是合法 JSON → 已按缺省配置解读（未覆盖原文件）：${file}`],
+        };
+    }
+    if (isPlainObject(parsed) && parsed.version !== undefined && parsed.version !== "v1") {
+        return {
+            config: base,
+            notices: [
+                `proactive: daemon.json 版本无法识别（version=${String(parsed.version)}）→ 已按缺省配置解读（未覆盖原文件）：${file}`,
+            ],
+        };
+    }
+    return { config: mergeDaemonConfig(base, parsed), notices: [] };
+}
+/**
+ * 权限分级：**取最严**的命中档位（多规则命中 → 不可逆优先）。
+ *
+ * 为什么要「最严」而不是「先命中先算」：一句「删除临时文件并汇总」同时命中 delete 与 summarize；
+ * 取先命中会把不可逆动作判成只读 → 事故。取最严 = 保守方向。
+ */
+export function classifyAction(text, permissions) {
+    const haystack = (text ?? "").toLowerCase();
+    let best;
+    const matched = [];
+    /** 每个档位各自的理由（只取**胜出档位**的理由 → 理由与档位一致，不掺别的档位）。 */
+    const reasonsByTier = new Map();
+    for (const rule of permissions.rules) {
+        const key = rule.match.toLowerCase();
+        if (key === "" || !haystack.includes(key))
+            continue;
+        matched.push(rule.match);
+        const list = reasonsByTier.get(rule.tier) ?? [];
+        if (!list.includes(rule.reason))
+            list.push(rule.reason);
+        reasonsByTier.set(rule.tier, list);
+        if (best === undefined || TIER_SEVERITY[rule.tier] > TIER_SEVERITY[best])
+            best = rule.tier;
+    }
+    if (best === undefined) {
+        return {
+            tier: permissions.defaultTier,
+            reason: `未命中任何规则 → 按默认档位「${permissions.defaultTier}」处理（未知动作从严）`,
+            matched: [],
+        };
+    }
+    return { tier: best, reason: (reasonsByTier.get(best) ?? []).join("；"), matched };
+}
+/** 动作流水上限（防无限增长；超出丢最旧）。 */
+export const MAX_ACTION_LOG = 500;
+/** 本地日期键（`YYYY-MM-DD`，本地时区）。 */
+export function dayKey(ts) {
+    const d = new Date(ts);
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${d.getFullYear()}-${m}-${day}`;
+}
+/** 值班状态文件路径：`<agentDir>/proactive/daemon/state.json`。 */
+export function daemonStatePath(agentDir) {
+    return path.join(proactiveDir(agentDir), "daemon", "state.json");
+}
+/** 空状态。 */
+export function emptyDaemonState(now) {
+    return {
+        version: "v1",
+        lastSeenAt: now,
+        budget: {
+            hourWindowStart: now,
+            hourCount: 0,
+            dayKey: dayKey(now),
+            dayCount: 0,
+            limitedDayKey: dayKey(now),
+            limitedDayCount: 0,
+            tokenDayKey: dayKey(now),
+            tokenUnits: 0,
+        },
+        actions: [],
+        executions: {},
+        queue: [],
+        locked: false,
+    };
+}
+/**
+ * 读取值班状态（坏文件 → 备份 + 空状态；**未知版本 → 锁定**（拒绝写入，不覆盖原文件））。
+ */
+export function loadDaemonState(agentDir, now) {
+    const file = daemonStatePath(agentDir);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return emptyDaemonState(now);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        try {
+            fs.renameSync(file, `${file}.corrupt-${now}`);
+        }
+        catch {
+            // 备份失败也不抛（宁可空状态启动）
+        }
+        return emptyDaemonState(now);
+    }
+    if (!isPlainObject(parsed))
+        return emptyDaemonState(now);
+    if (parsed.version !== "v1") {
+        const state = emptyDaemonState(now);
+        state.locked = true;
+        return state;
+    }
+    const state = emptyDaemonState(now);
+    state.lastSeenAt = num(parsed.lastSeenAt, now);
+    const b = isPlainObject(parsed.budget) ? parsed.budget : {};
+    state.budget = {
+        hourWindowStart: num(b.hourWindowStart, now),
+        hourCount: num(b.hourCount, 0),
+        dayKey: str(b.dayKey, state.budget.dayKey),
+        dayCount: num(b.dayCount, 0),
+        limitedDayKey: str(b.limitedDayKey, state.budget.limitedDayKey),
+        limitedDayCount: num(b.limitedDayCount, 0),
+        tokenDayKey: str(b.tokenDayKey, state.budget.tokenDayKey),
+        tokenUnits: num(b.tokenUnits, 0),
+    };
+    if (Array.isArray(parsed.actions)) {
+        state.actions = parsed.actions.filter((a) => isPlainObject(a) && typeof a.ts === "number");
+    }
+    if (isPlainObject(parsed.executions)) {
+        for (const [k, v] of Object.entries(parsed.executions)) {
+            if (isPlainObject(v) && typeof v.ts === "number") {
+                state.executions[k] = {
+                    key: k,
+                    ts: v.ts,
+                    status: v.status === "done" ? "done" : "claimed",
+                    taskId: str(v.taskId, ""),
+                };
+            }
+        }
+    }
+    if (Array.isArray(parsed.queue)) {
+        state.queue = parsed.queue.filter((q) => isPlainObject(q) && typeof q.ts === "number");
+    }
+    return state;
+}
+/** 原子写值班状态（锁定状态 → 拒绝写）。 */
+export function saveDaemonState(agentDir, state) {
+    if (state.locked)
+        return false;
+    const file = daemonStatePath(agentDir);
+    try {
+        ensureDir(path.dirname(file));
+        writeAtomicFile(file, `${JSON.stringify(state, null, 2)}\n`, { durable: true });
+        chmodQuiet(file, PROACTIVE_FILE_MODE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 由值班状态构建交班摘要。 */
+export function buildHandoverSummary(state, now, agentId, budget) {
+    const actions = state.actions.slice();
+    const totals = {
+        executed: 0,
+        observeOnly: 0,
+        queued: 0,
+        skippedDuplicate: 0,
+        failed: 0,
+        total: actions.length,
+        tokenUnits: 0,
+    };
+    for (const a of actions) {
+        if (a.outcome === "executed")
+            totals.executed += 1;
+        else if (a.outcome === "observe-only")
+            totals.observeOnly += 1;
+        else if (a.outcome === "queued")
+            totals.queued += 1;
+        else if (a.outcome === "skipped-duplicate")
+            totals.skippedDuplicate += 1;
+        else if (a.outcome === "failed")
+            totals.failed += 1;
+        totals.tokenUnits += a.tokenUnits;
+    }
+    return {
+        date: dayKey(now),
+        generatedAt: now,
+        agentId,
+        actions,
+        totals,
+        queue: state.queue.slice(),
+        budget: { ...budget },
+    };
+}
+/** 交班摘要的 markdown 正文。 */
+export function formatHandoverSummary(summary) {
+    const lines = [];
+    lines.push(`# 交班摘要 · ${summary.date}`);
+    lines.push("");
+    lines.push(`- 生成时刻：${new Date(summary.generatedAt).toISOString()}`);
+    lines.push(`- 值班 agent：${summary.agentId}`);
+    lines.push("");
+    lines.push("## 夜里做了什么");
+    if (summary.actions.length === 0) {
+        lines.push("（无动作）");
+    }
+    else {
+        for (const a of summary.actions) {
+            const time = new Date(a.ts).toISOString();
+            lines.push(`- ${time} · 档位=${a.tier} · 结果=${a.outcome} · ${a.title}`);
+        }
+    }
+    lines.push("");
+    lines.push("## 花了多少");
+    lines.push(`- 动作数：${summary.totals.total}（执行 ${summary.totals.executed} · 只观察 ${summary.totals.observeOnly} · 进队列 ${summary.totals.queued} · 幂等跳过 ${summary.totals.skippedDuplicate} · 失败 ${summary.totals.failed}）`);
+    lines.push(`- token 估算：${summary.totals.tokenUnits} 单位`);
+    lines.push(`- token 口径：${TOKEN_ESTIMATE_NOTE}`);
+    lines.push(`- 预算上限：每小时 ${summary.budget.maxActionsPerHour} 动作 · 每日 ${summary.budget.maxActionsPerDay} 动作 · 每日 token 估算 ${summary.budget.maxTokenUnitsPerDay} 单位 · limited 档每日 ${summary.budget.maxLimitedActionsPerDay} 动作`);
+    lines.push("");
+    lines.push("## 为什么（决策理由）");
+    if (summary.actions.length === 0) {
+        lines.push("（无动作）");
+    }
+    else {
+        for (const a of summary.actions) {
+            lines.push(`- ${new Date(a.ts).toISOString()} · ${a.title} → ${a.outcome}：${a.reason}`);
+        }
+    }
+    lines.push("");
+    lines.push("## 待人工确认（human-gated · 未执行）");
+    if (summary.queue.length === 0) {
+        lines.push("（无）");
+    }
+    else {
+        for (const q of summary.queue) {
+            lines.push(`- ${new Date(q.ts).toISOString()} · ${q.title}：${q.reason}`);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/** 交班摘要目录：`<agentDir>/proactive/handover/`。 */
+export function handoverDir(agentDir) {
+    return path.join(proactiveDir(agentDir), "handover");
+}
+/** 写交班摘要（返回文件路径）。 */
+export function writeHandoverSummary(agentDir, summary) {
+    const dir = handoverDir(agentDir);
+    const file = path.join(dir, `${summary.date}.md`);
+    try {
+        ensureDir(dir);
+        writeAtomicFile(file, formatHandoverSummary(summary), { durable: true });
+        chmodQuiet(file, PROACTIVE_FILE_MODE);
+    }
+    catch {
+        // 写不进去也不抛（交班是「尽力而为」的出口，失败要有日志但不杀进程）
+    }
+    return file;
+}
+/** 读最近一次交班摘要（**只读**；没有 → undefined）。 */
+export function readLatestHandover(agentDir) {
+    const dir = handoverDir(agentDir);
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return undefined;
+    }
+    const dated = names
+        .filter((n) => n.endsWith(".md") && /^\d{4}-\d{2}-\d{2}\.md$/.test(n))
+        .sort();
+    if (dated.length === 0)
+        return undefined;
+    const name = dated[dated.length - 1];
+    const file = path.join(dir, name);
+    let content;
+    try {
+        content = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    return { path: file, date: name.replace(/\.md$/, ""), content };
+}