pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

package/build/src/daemon-config.js

@@ -115,8 +115,26 @@ export function defaultDaemonConfig(agentId) {
         handoverHour: 8,
         staleSocketMs: 3_600_000,
         staleExecutionMs: 3_600_000,
+        contact: { ...DEFAULT_CONTACT_CONFIG, payload: { ...DEFAULT_CONTACT_CONFIG.payload } },
+        host: { ...DEFAULT_HOST_CONFIG },
     };
 }
+/** 主动联系的缺省配置（**频次保守**：默认 1 小时一次、每天 8 次封顶）。 */
+export const DEFAULT_CONTACT_CONFIG = {
+    enabled: true,
+    target: "auto",
+    minIntervalMs: 3_600_000,
+    maxPerDay: 8,
+    deviceNotify: "fallback",
+    payload: {
+        why: "有事情需要你确认",
+        ask: "在会话里回一句就行；也可以先不管它",
+        consequence: "不处理 → 这件事会一直等着（**不会**自动替你决定）",
+        howToDisable: "运行 bash pi-proactive/tools/daemon-uninstall.sh，或把 daemon.json 的 contact.enabled 设为 false",
+    },
+};
+/** 宿主缺省（auto = 有 herdr 用 herdr，没有就回落系统宿主）。 */
+export const DEFAULT_HOST_CONFIG = { hostKind: "auto" };
 /** 配置文件路径：`<agentDir>/proactive/daemon.json`。 */
 export function daemonConfigPath(agentDir) {
     return path.join(proactiveDir(agentDir), "daemon.json");
@@ -136,12 +154,35 @@ function str(v, fallback) {
 function tier(v, fallback) {
     return v === "auto" || v === "limited" || v === "human-gated" ? v : fallback;
 }
+/** 合并主动联系配置（逐字段校验；坏字段回落缺省 —— **不得静默变成"没有上限"**）。 */
+function mergeContactConfig(base, raw) {
+    const p = isPlainObject(raw.payload) ? raw.payload : {};
+    return {
+        enabled: bool(raw.enabled, base.enabled),
+        target: str(raw.target, base.target).trim() || base.target,
+        minIntervalMs: Math.max(0, num(raw.minIntervalMs, base.minIntervalMs)),
+        maxPerDay: Math.max(0, num(raw.maxPerDay, base.maxPerDay)),
+        deviceNotify: raw.deviceNotify === "always" || raw.deviceNotify === "fallback" ? raw.deviceNotify : base.deviceNotify,
+        payload: {
+            why: str(p.why, base.payload.why),
+            ask: str(p.ask, base.payload.ask),
+            consequence: str(p.consequence, base.payload.consequence),
+            howToDisable: str(p.howToDisable, base.payload.howToDisable),
+            ...(p.title !== undefined ? { title: str(p.title, base.payload.title ?? "") } : {}),
+        },
+    };
+}
 /** 把落盘的原始 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 rawHost = isPlainObject(raw.host) ? raw.host : {};
+    // 宿主取值读取（**兼容旧键名**：`kind` 专指 DeliverKind → 宿主一律用 `hostKind`；
+    // 旧配置文件里写的 `host.kind` 仍要认，否则升级即丢用户配置）。
+    const rawHostKindValue = rawHost["hostKind"] ?? rawHost["kind"];
+    const rawHostKind = typeof rawHostKindValue === "string" ? rawHostKindValue : undefined;
     const rawRules = Array.isArray(perms.rules) ? perms.rules : [];
     const rules = [];
     for (const item of rawRules) {
@@ -176,6 +217,12 @@ export function mergeDaemonConfig(base, raw) {
         handoverHour: num(raw.handoverHour, base.handoverHour),
         staleSocketMs: num(raw.staleSocketMs, base.staleSocketMs),
         staleExecutionMs: num(raw.staleExecutionMs, base.staleExecutionMs),
+        contact: mergeContactConfig(base.contact, isPlainObject(raw.contact) ? raw.contact : {}),
+        host: {
+            hostKind: rawHostKind === "herdr" || rawHostKind === "system" || rawHostKind === "auto"
+                ? rawHostKind
+                : base.host.hostKind,
+        },
     };
 }
 /**
@@ -486,3 +533,177 @@ export function readLatestHandover(agentDir) {
     }
     return { path: file, date: name.replace(/\.md$/, ""), content };
 }
+/** 常驻目录：`<agentDir>/proactive/daemon`。 */
+export function daemonDir(agentDir) {
+    return path.join(proactiveDir(agentDir), "daemon");
+}
+/** 心跳文件路径：`<agentDir>/proactive/daemon/heartbeat.json`（**外部可验证「它还活着」**）。 */
+export function heartbeatPath(agentDir) {
+    return path.join(daemonDir(agentDir), "heartbeat.json");
+}
+/** 宿主状态文件路径：`<agentDir>/proactive/daemon/host.json`（herdr 宿主时记 workspace/pane）。 */
+export function hostStatePath(agentDir) {
+    return path.join(daemonDir(agentDir), "host.json");
+}
+/** 主动联系清单路径：`<agentDir>/proactive/daemon/contacts.jsonl`（JSONL，一行一条）。 */
+export function contactLedgerPath(agentDir) {
+    return path.join(daemonDir(agentDir), "contacts.jsonl");
+}
+/** 读清单（**坏行只丢那一行**，不整体失败；坏文件也不会抛）。 */
+export function readContactEntries(agentDir) {
+    const file = contactLedgerPath(agentDir);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const text = line.trim();
+        if (text === "")
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            continue;
+        }
+        if (!isPlainObject(parsed))
+            continue;
+        if (typeof parsed.eventId !== "string" || parsed.eventId === "")
+            continue;
+        if (typeof parsed.ts !== "number")
+            continue;
+        const p = isPlainObject(parsed.payload) ? parsed.payload : {};
+        out.push({
+            eventId: parsed.eventId,
+            ts: parsed.ts,
+            outcome: parsed.outcome ?? "session",
+            channels: Array.isArray(parsed.channels) ? parsed.channels.filter((c) => typeof c === "string") : [],
+            ...(typeof parsed.targetAgentId === "string" ? { targetAgentId: parsed.targetAgentId } : {}),
+            payload: {
+                why: str(p.why, ""),
+                ask: str(p.ask, ""),
+                consequence: str(p.consequence, ""),
+                howToDisable: str(p.howToDisable, ""),
+                ...(typeof p.title === "string" ? { title: p.title } : {}),
+                ...(typeof p.body === "string" ? { body: p.body } : {}),
+            },
+            ...(typeof parsed.reason === "string" ? { reason: parsed.reason } : {}),
+        });
+    }
+    return out;
+}
+/** 写清单（原子写：tmp + rename）。 */
+function writeContactEntries(agentDir, rows) {
+    const file = contactLedgerPath(agentDir);
+    try {
+        ensureDir(path.dirname(file));
+        const body = rows.map((r) => JSON.stringify(r)).join("\n");
+        writeAtomicFile(file, body === "" ? "" : `${body}\n`, { durable: true });
+        chmodQuiet(file, PROACTIVE_FILE_MODE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 追加一条联系记录（**按 eventId 去重**：同一事件只落一条，通道取并集）。
+ *
+ * @returns `true` = 新增了一条；`false` = 同一事件已存在（已合并通道，未重复落盘）。
+ */
+export function appendContactEntry(agentDir, entry) {
+    const rows = readContactEntries(agentDir);
+    const idx = rows.findIndex((r) => r.eventId === entry.eventId);
+    if (idx >= 0) {
+        const prev = rows[idx];
+        const channels = [...new Set([...prev.channels, ...entry.channels])];
+        const outcome = channels.includes("session") && channels.includes("device")
+            ? "both"
+            : channels.includes("session")
+                ? "session"
+                : channels.includes("device")
+                    ? "device"
+                    : entry.outcome;
+        if (channels.length !== prev.channels.length || outcome !== prev.outcome) {
+            rows[idx] = { ...prev, channels, outcome, ts: Math.max(prev.ts, entry.ts) };
+            writeContactEntries(agentDir, rows);
+        }
+        return false;
+    }
+    rows.push(entry);
+    return writeContactEntries(agentDir, rows);
+}
+/** 清单 → 人话（用户只面对「它联系了我什么」；机器细节收在括号里）。 */
+export function formatContactList(rows) {
+    if (rows.length === 0)
+        return "（还没有联系过）";
+    const lines = [`它联系了我什么（共 ${rows.length} 条）：`];
+    for (const r of rows) {
+        const when = new Date(r.ts).toLocaleString();
+        const how = r.channels.length > 0 ? r.channels.join("+") : "无";
+        lines.push(`· ${when} · ${how}${r.targetAgentId ? ` · ${r.targetAgentId}` : ""}`);
+        lines.push(`  为什么找你：${r.payload.why}`);
+        lines.push(`  需要你做什么：${r.payload.ask}`);
+        lines.push(`  不做的后果：${r.payload.consequence}`);
+        lines.push(`  怎么关掉我：${r.payload.howToDisable}`);
+        if (r.reason !== undefined && r.reason !== "")
+            lines.push(`  （${r.reason}）`);
+    }
+    return lines.join("\n");
+}
+/** 跳过审计路径：`<agentDir>/proactive/daemon/contacts-skipped.jsonl`。 */
+export function contactAuditPath(agentDir) {
+    return path.join(daemonDir(agentDir), "contacts-skipped.jsonl");
+}
+/** 读跳过审计（坏行只丢那一行）。 */
+export function readContactAudit(agentDir) {
+    const file = contactAuditPath(agentDir);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const text = line.trim();
+        if (text === "")
+            continue;
+        try {
+            const parsed = JSON.parse(text);
+            if (typeof parsed.ts !== "number" || typeof parsed.reason !== "string")
+                continue;
+            out.push({
+                ts: parsed.ts,
+                reason: parsed.reason,
+                ...(typeof parsed.targetAgentId === "string" ? { targetAgentId: parsed.targetAgentId } : {}),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return out;
+}
+/** 追加一条跳过审计（**上限 200 条**，超出丢最旧 —— 免得无限增长）。 */
+export function appendContactAudit(agentDir, entry) {
+    const rows = readContactAudit(agentDir);
+    rows.push(entry);
+    const trimmed = rows.slice(Math.max(0, rows.length - 200));
+    const file = contactAuditPath(agentDir);
+    try {
+        ensureDir(path.dirname(file));
+        writeAtomicFile(file, `${trimmed.map((r) => JSON.stringify(r)).join("\n")}\n`, { durable: true });
+        chmodQuiet(file, PROACTIVE_FILE_MODE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/build/src/daemon-contact.js

@@ -0,0 +1,103 @@
+import { dayKey } from "./daemon-config.js";
+/** 心跳过期倍数（与 `src/registry.ts` 的口径一致：3 × 心跳周期）。 */
+const OFFLINE_HEARTBEAT_FACTOR = 3;
+/** 条目是否在线（心跳新鲜且未优雅退出）。 */
+function isOnline(entry, now) {
+    if (entry.status === "offline")
+        return false;
+    if (now < entry.lastSeen)
+        return false;
+    return now - entry.lastSeen <= entry.heartbeatMs * OFFLINE_HEARTBEAT_FACTOR;
+}
+/**
+ * 判定「联系哪个会话」。
+ *
+ * 口径（**可判定**）：
+ *   - 候选 = 注册表里**带会话 id**（= 已登记会话）的条目，排除常驻进程自己；
+ *   - `target` 非 `"auto"` → 必须**逐字命中**候选，否则**不联系**（不许近似匹配）；
+ *   - `target === "auto"` → 优先在线，其次最近活跃（`lastSeen` 降序），再按 agentId 升序兜底（**确定性**）。
+ */
+export function selectContactTarget(entries, opts) {
+    const now = opts.now ?? Date.now();
+    const candidates = entries.filter((e) => e.sessionId !== undefined && e.agentId !== opts.selfAgentId);
+    if (opts.target !== "auto") {
+        const hit = candidates.find((e) => e.agentId === opts.target);
+        if (hit === undefined) {
+            return {
+                target: null,
+                reason: `指定的目标未登记（不是已登记会话）：${opts.target}`,
+                candidates: candidates.length,
+            };
+        }
+        return { target: hit, reason: `用户指定的目标会话：${hit.agentId}`, candidates: candidates.length };
+    }
+    if (candidates.length === 0) {
+        return {
+            target: null,
+            reason: "没有已登记会话（注册表里没有带会话 id 的条目）→ 不联系",
+            candidates: 0,
+        };
+    }
+    const sorted = [...candidates].sort((a, b) => {
+        const onlineA = isOnline(a, now) ? 1 : 0;
+        const onlineB = isOnline(b, now) ? 1 : 0;
+        if (onlineA !== onlineB)
+            return onlineB - onlineA;
+        if (a.lastSeen !== b.lastSeen)
+            return b.lastSeen - a.lastSeen;
+        return a.agentId < b.agentId ? -1 : a.agentId > b.agentId ? 1 : 0;
+    });
+    const picked = sorted[0];
+    return {
+        target: picked,
+        reason: `最近活跃的已登记会话：${picked.agentId}`,
+        candidates: candidates.length,
+    };
+}
+/** 这条记录是否算「真的联系过」（跳过 / 失败的不算）。 */
+function isRealContact(entry) {
+    return entry.outcome === "session" || entry.outcome === "device" || entry.outcome === "both";
+}
+/**
+ * 判定「现在该不该联系」。
+ *
+ * 顺序（刻意的）：开关 → 目标 → 频次 → 每日上限。
+ * 关掉时**最先**短路（用户说「随时可关」→ 关掉就彻底安静，不留任何动作）。
+ */
+export function decideContact(input) {
+    const { config, entries, recent, now } = input;
+    if (!config.enabled) {
+        return { action: "skip", reason: "主动联系已关闭（开关在 contact.enabled）" };
+    }
+    const selection = selectContactTarget(entries, {
+        target: config.target,
+        now,
+        ...(input.selfAgentId !== undefined ? { selfAgentId: input.selfAgentId } : {}),
+    });
+    if (selection.target === null) {
+        return { action: "skip", reason: selection.reason };
+    }
+    const real = recent.filter(isRealContact);
+    const last = real.reduce((max, e) => (e.ts > max ? e.ts : max), 0);
+    if (last > 0 && config.minIntervalMs > 0 && now - last < config.minIntervalMs) {
+        return {
+            action: "skip",
+            reason: `频次未到（距上次联系 ${Math.round((now - last) / 1000)}s < 下限 ${Math.round(config.minIntervalMs / 1000)}s）`,
+        };
+    }
+    const today = dayKey(now);
+    const todayCount = real.filter((e) => dayKey(e.ts) === today).length;
+    if (config.maxPerDay > 0 && todayCount >= config.maxPerDay) {
+        return {
+            action: "skip",
+            reason: `今日已达每日上限（${todayCount}/${config.maxPerDay} 次）`,
+        };
+    }
+    const target = selection.target;
+    return {
+        action: "contact",
+        reason: selection.reason,
+        target,
+        eventId: `evt-${now.toString(36)}-${target.agentId}`,
+    };
+}

package/build/src/daemon-host.js

@@ -0,0 +1,84 @@
+/**
+ * 常驻**宿主**判定（双宿主：herdr 优先 → 自带 launchd/systemd 回落）。
+ *
+ * 形态选型 §2.5 的硬约束：
+ * - herdr 只是**保活容器**（助理在其中纯 headless：无 TUI、不抢 stdin）；
+ * - herdr 探测不到 → **回落**自带 daemon（**不绑死单一宿主**）；
+ * - 用户入口只有两个：自己正在用的 pi 会话 + 设备级通知 —— **不让用户进另一个终端**。
+ *
+ * 本模块**只判定**（纯函数 + 可注入执行器 → 测试零副作用）。
+ */
+import { spawnSync } from "node:child_process";
+/** 默认执行器（同步、3 秒超时、不继承 stdin）。 */
+export const defaultHostExec = (cmd, args) => {
+    const res = spawnSync(cmd, args, { timeout: 3000, stdio: ["ignore", "pipe", "pipe"] });
+    return {
+        ok: res.status === 0 && !res.error,
+        code: res.status ?? 1,
+        stdout: res.stdout ? res.stdout.toString("utf8") : "",
+        stderr: res.stderr ? res.stderr.toString("utf8") : "",
+    };
+};
+/** herdr 的服务端是否在跑（`herdr status server` → `status: running`）。 */
+export function herdrServerRunning(exec = defaultHostExec) {
+    try {
+        const res = exec("herdr", ["status", "server"]);
+        return res.ok && /status:\s*running/i.test(res.stdout);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 判定宿主：
+ *
+ * - herdr 在跑 → `herdr`（保活容器 + `herdr notification show` 通知通道）；
+ * - 否则 → 平台对应的系统宿主（macOS = launchd / Linux = systemd --user），
+ *   原因里写明「回落」（**用户看得见降级发生了**）。
+ */
+export function detectHost(opts = {}) {
+    const platform = opts.platform ?? process.platform;
+    const exec = opts.exec ?? defaultHostExec;
+    let herdrOut = "";
+    try {
+        const res = exec("herdr", ["status", "server"]);
+        herdrOut = `${res.stdout}${res.stderr}`.trim();
+        if (res.ok && /status:\s*running/i.test(res.stdout)) {
+            return {
+                hostKind: "herdr",
+                available: true,
+                reason: "herdr 可用 → 常驻宿主 = herdr workspace/session（助理在其中纯 headless）",
+                detail: herdrOut,
+            };
+        }
+    }
+    catch {
+        // 探测失败 → 当作不可用（回落）
+    }
+    const hostKind = platform === "darwin" ? "launchd" : "systemd";
+    return {
+        hostKind,
+        available: true,
+        reason: `herdr 不可用 → 回落自带系统宿主（${hostKind}）`,
+        detail: herdrOut === "" ? undefined : herdrOut,
+    };
+}
+// ---------------------------------------------------------------- CLI（给安装脚本用）
+/** 判断是否为主模块直接运行。 */
+function isMainModule() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    // 产物态入口是 build/src/daemon-host.js（编译后后缀变了）→ 只认 .ts 时产物态静默不执行。
+    return entry.endsWith("daemon-host.ts") || entry.endsWith("daemon-host.js");
+}
+if (isMainModule()) {
+    const detection = detectHost();
+    // `--kind`：只打印宿主种类（给安装脚本用；免得它在 bash 里解析 JSON）。
+    if (process.argv.includes("--kind")) {
+        process.stdout.write(`${detection.hostKind}\n`);
+    }
+    else {
+        process.stdout.write(`${JSON.stringify(detection)}\n`);
+    }
+}