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

package/tools/daemon-install.sh

@@ -0,0 +1,397 @@
+#!/usr/bin/env bash
+
+
+# pi-proactive 常驻助理：**一键安装**（用户只跑这一条命令 → 看到「已常驻」）。
+#
+# 用户要做的事：跑一条命令（或一条命令面指令）。
+# 我方要做的事：检测平台与宿主 → 生成单元文件 → 设置权限 → 启动 → **验证真的起来了** → 回执。
+# **用户不编辑任何单元文件 / 权限 / 开机自启**（那是我方的事）。
+#
+# 验证三证据（**缺一即失败，不谎报成功**）：
+#   ① 进程在      —— 心跳文件里的 pid 活着（kill -0）
+#   ② 心跳在更新  —— 两次读取的 ts 前进
+#   ③ 宿主已加载  —— launchctl print / systemctl is-active / herdr pane 在
+#
+# 宿主（双宿主）：herdr 可用 → 用 herdr workspace/session 承载（助理在其中**纯 headless**）；
+#                 不可用 → 回落自带 launchd / systemd --user（**不绑死单一宿主**）。
+#
+# 成本硬约束：装上**不等于花钱** —— 配置默认 `enabled=false` + 干跑。
+#
+# 用法：
+#   bash pi-proactive/tools/daemon-install.sh
+#   bash pi-proactive/tools/daemon-install.sh --agent-dir <dir>   # 指定 agent 根目录
+#   bash pi-proactive/tools/daemon-install.sh --agent-id <id>     # 指定稳定身份
+#   bash pi-proactive/tools/daemon-install.sh --host auto|herdr|system
+#   bash pi-proactive/tools/daemon-install.sh --no-start         # 只渲染配置，不启动（自测用）
+#   bash pi-proactive/tools/daemon-install.sh --label <label>    # 指定 launchd 单元标签（默认 com.pi-proactive.daemon）
+#   bash pi-proactive/tools/daemon-install.sh --service-name <n> # 指定 systemd 单元名（默认 pi-proactive-daemon.service）
+#
+# 退出码：0=已常驻（验证通过）；1=失败；2=环境不支持。
+set -uo pipefail
+
+PKG_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TEMPLATE_DIR="${PKG_ROOT}/daemon"
+LABEL="${PI_PROACTIVE_DAEMON_LABEL:-com.pi-proactive.daemon}"
+SERVICE_NAME="${PI_PROACTIVE_DAEMON_SERVICE:-pi-proactive-daemon.service}"
+WORKSPACE_LABEL="pi-proactive-daemon"
+
+AGENT_DIR="${PI_CODING_AGENT_DIR:-${HOME}/.pi/agent}"
+AGENT_ID="${PI_PROACTIVE_AGENT_ID:-}"
+HOST_PREF="auto"
+NO_START=0
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --agent-dir) AGENT_DIR="$2"; shift 2 ;;
+    --agent-id) AGENT_ID="$2"; shift 2 ;;
+    --host) HOST_PREF="$2"; shift 2 ;;
+    --label) LABEL="$2"; shift 2 ;;
+    --service-name) SERVICE_NAME="$2"; shift 2 ;;
+    --no-start) NO_START=1; shift ;;
+    -h|--help) sed -n '2,28p' "$0"; exit 0 ;;
+    *) echo "未知参数：$1" >&2; exit 2 ;;
+  esac
+done
+
+NODE_BIN="${NODE_BIN:-$(command -v node || true)}"
+if [ -z "${NODE_BIN}" ]; then
+  echo "找不到 node（常驻助理需要 Node ≥ 22.19）" >&2
+  exit 2
+fi
+if [ -z "${AGENT_ID}" ]; then
+  HOST="$(hostname 2>/dev/null || echo localhost)"
+  AGENT_ID="employee#${HOST}#pi-proactive-daemon"
+fi
+
+# 常驻入口按【运行环境】解析：两种布局都要能跑。
+#   · 开发态（仓库）：src/*.ts 是真源 → 优先用它（build/ 是编译产物，可能陈旧 →
+#     在仓库里跑陈旧产物 = 测的不是当前代码）；
+#   · 产物态（npm 包）：包里**没有** src/（files 白名单只有 build/）→ 自动落到 build/*.js。
+# 候选清单与错误信息**同源** → 报错时说的就是真的试过的路径（不写死一份会漂移的清单）。
+DAEMON_CANDIDATES="src/daemon.ts build/src/daemon.js"
+DAEMON_TS=""
+for c in ${DAEMON_CANDIDATES}; do
+	[ -f "${PKG_ROOT}/${c}" ] && { DAEMON_TS="${PKG_ROOT}/${c}"; break; }
+done
+[ -n "${DAEMON_TS}" ] || { echo "找不到常驻入口（试过 ${DAEMON_CANDIDATES// /、}）" >&2; exit 2; }
+DAEMON_HOST_CANDIDATES="src/daemon-host.ts build/src/daemon-host.js"
+DAEMON_HOST_ENTRY=""
+for c in ${DAEMON_HOST_CANDIDATES}; do
+	[ -f "${PKG_ROOT}/${c}" ] && { DAEMON_HOST_ENTRY="${PKG_ROOT}/${c}"; break; }
+done
+[ -n "${DAEMON_HOST_ENTRY}" ] || { echo "找不到宿主判定入口（试过 ${DAEMON_HOST_CANDIDATES// /、}）" >&2; exit 2; }
+LOG_DIR="${AGENT_DIR}/proactive/daemon"
+CONFIG_FILE="${AGENT_DIR}/proactive/daemon.json"
+DAEMON_DIR="${AGENT_DIR}/proactive/daemon"
+HEARTBEAT_FILE="${DAEMON_DIR}/heartbeat.json"
+HOST_STATE_FILE="${DAEMON_DIR}/host.json"
+RUNNER_FILE="${DAEMON_DIR}/run-daemon.sh"
+
+
+mkdir -p "${LOG_DIR}" "${AGENT_DIR}/proactive" || exit 1
+
+# ---- 配置：不存在才写（**不覆盖**用户已有的配置；enabled 默认 false = 默认不花钱）----
+if [ ! -f "${CONFIG_FILE}" ]; then
+  cat >"${CONFIG_FILE}" <<EOF
+{
+  "version": "v1",
+  "enabled": false,
+  "agentId": "${AGENT_ID}",
+  "dryRun": true,
+  "budget": {
+    "maxActionsPerHour": 6,
+    "maxActionsPerDay": 40,
+    "maxTokenUnitsPerDay": 200000,
+    "maxLimitedActionsPerDay": 20,
+    "degradeToObserveWhenExhausted": true
+  },
+  "permissions": {
+    "defaultTier": "limited"
+  },
+  "tickIntervalMs": 30000,
+  "handoverHour": 8,
+  "staleSocketMs": 3600000,
+  "staleExecutionMs": 3600000,
+  "contact": {
+    "enabled": true,
+    "target": "auto",
+    "minIntervalMs": 3600000,
+    "maxPerDay": 8,
+    "deviceNotify": "fallback"
+  },
+  "host": {
+    "hostKind": "auto"
+  }
+}
+EOF
+  echo "已写值班配置（enabled=false · 默认干跑）：${CONFIG_FILE}"
+else
+  echo "值班配置已存在，保持不动：${CONFIG_FILE}"
+fi
+
+# ---- 宿主判定（herdr 优先 → 回落系统宿主）----
+detect_host() {
+  "$NODE_BIN" --experimental-strip-types "${DAEMON_HOST_ENTRY}" --kind 2>/dev/null || echo ""
+}
+HOST_KIND="$(detect_host)"
+HOST_REASON="$("$NODE_BIN" --experimental-strip-types "${DAEMON_HOST_ENTRY}" 2>/dev/null | sed -n 's/.*"reason":"\([^"]*\)".*/\1/p')"
+case "$(uname -s)" in
+Darwin) SYSTEM_KIND="launchd" ;;
+Linux) SYSTEM_KIND="systemd" ;;
+*) SYSTEM_KIND="" ;;
+esac
+if [ "${HOST_PREF}" = "system" ]; then
+  HOST_KIND="${SYSTEM_KIND}"
+  # 用户显式指定 → 回执里的理由必须**说实话**（不能还挂着探测结论「herdr 可用 → …」）
+  HOST_REASON="用户指定使用自带系统宿主（--host system）"
+elif [ "${HOST_PREF}" = "herdr" ]; then
+  HOST_KIND="herdr"
+  HOST_REASON="用户指定使用 herdr 宿主（--host herdr）"
+fi
+case "${HOST_KIND}" in
+  herdr|launchd|systemd) : ;;
+  *) HOST_KIND="${SYSTEM_KIND}" ;;
+esac
+
+# ---- 渲染模板（占位符替换）----
+render() {
+  sed -e "s|__NODE__|${NODE_BIN}|g" \
+      -e "s|__DAEMON_TS__|${DAEMON_TS}|g" \
+      -e "s|__AGENT_DIR__|${AGENT_DIR}|g" \
+      -e "s|__AGENT_ID__|${AGENT_ID}|g" \
+      -e "s|__PKG_ROOT__|${PKG_ROOT}|g" \
+      -e "s|__LOG_DIR__|${LOG_DIR}|g" \
+      -e "s|__LOG_DIR__|${LOG_DIR}|g" \
+      -e "s|__LABEL__|${LABEL}|g" \
+      -e "s|__RUNNER__|${RUNNER_FILE}|g" \
+      "$1"
+}
+
+# ---- 保活启动器（herdr 宿主用：pane 里跑这个 → 崩溃自动重来；systemd/launchd 自带自愈）----
+render "${TEMPLATE_DIR}/run-daemon.sh" >"${RUNNER_FILE}" || exit 1
+chmod 700 "${RUNNER_FILE}" 2>/dev/null || true
+
+write_host_state() {
+  cat >"${HOST_STATE_FILE}" <<EOF
+{
+  "hostKind": "$1",
+  "label": "${WORKSPACE_LABEL}",
+  "workspaceId": "${2:-}",
+  "paneId": "${3:-}",
+  "unitPath": "${4:-}",
+  "agentId": "${AGENT_ID}",
+  "installedAt": $(date +%s000)
+}
+EOF
+  chmod 600 "${HOST_STATE_FILE}" 2>/dev/null || true
+}
+
+# ---- 启动（按宿主分派）----
+UNIT_PATH=""
+UNIT_LOADED=0
+WS_ID=""
+PANE_ID=""
+case "$(uname -s)" in
+Darwin|Linux) : ;;
+*)
+  echo "不支持的操作系统：$(uname -s)（本脚本只支持 macOS launchd 与 Linux systemd --user）" >&2
+  exit 2
+  ;;
+esac
+
+if [ "${HOST_KIND}" = "herdr" ]; then
+  # ---- herdr 宿主：workspace + pane（**纯 headless**：不抢焦点、不占用户终端）----
+  if ! command -v herdr >/dev/null 2>&1; then
+    echo "herdr 不可用 → 回落自带系统宿主" >&2
+    HOST_KIND="${SYSTEM_KIND}"
+  elif ! herdr status server 2>/dev/null | grep -q "status: running"; then
+    echo "herdr 服务端没在跑 → 回落自带系统宿主" >&2
+    HOST_KIND="${SYSTEM_KIND}"
+  fi
+fi
+
+# ---- 系统宿主单元（launchd / systemd --user）：既是「宿主就是系统时的主角」，
+#      也是「宿主是 herdr 时的兜底保活」（形态选型 §2.5：server 挂 → 助理可判定的降级）。
+#      两种情况跑的都是同一个监督器脚本（run-daemon.sh）→ 靠**心跳 + 值班锁**保证只有一个值班进程。
+SYSTEM_UNIT_PATH=""
+render_system_unit() {
+  case "$(uname -s)" in
+    Darwin)
+      SYSTEM_UNIT_PATH="${HOME}/Library/LaunchAgents/${LABEL}.plist"
+      mkdir -p "$(dirname "${SYSTEM_UNIT_PATH}")" || return 1
+      render "${TEMPLATE_DIR}/launchd.plist" >"${SYSTEM_UNIT_PATH}" || return 1
+      chmod 600 "${SYSTEM_UNIT_PATH}" 2>/dev/null || true
+      ;;
+    Linux)
+      SYSTEM_UNIT_PATH="${HOME}/.config/systemd/user/${SERVICE_NAME}"
+      mkdir -p "$(dirname "${SYSTEM_UNIT_PATH}")" || return 1
+      render "${TEMPLATE_DIR}/pi-proactive-daemon.service" >"${SYSTEM_UNIT_PATH}" || return 1
+      ;;
+  esac
+  return 0
+}
+
+install_system_unit() {
+  render_system_unit || return 1
+  case "$(uname -s)" in
+    Darwin)
+      launchctl bootout "gui/$(id -u)/${LABEL}" >/dev/null 2>&1 || true
+      launchctl unload "${SYSTEM_UNIT_PATH}" >/dev/null 2>&1 || true
+      if launchctl bootstrap "gui/$(id -u)" "${SYSTEM_UNIT_PATH}" >/dev/null 2>&1; then
+        :
+      elif launchctl load -w "${SYSTEM_UNIT_PATH}" >/dev/null 2>&1; then
+        :
+      else
+        return 1
+      fi
+      ;;
+    Linux)
+      if ! command -v systemctl >/dev/null 2>&1; then
+        echo "找不到 systemctl（systemd --user 不可用）" >&2
+        return 2
+      fi
+      systemctl --user disable --now "${SERVICE_NAME}" >/dev/null 2>&1 || true
+      systemctl --user daemon-reload || return 1
+      systemctl --user enable --now "${SERVICE_NAME}" || return 1
+      ;;
+  esac
+  return 0
+}
+
+# ---- 只渲染不启动（--no-start）：**不得**创建 workspace / 不得启动任何进程 ----
+if [ "${NO_START}" -eq 1 ]; then
+  render_system_unit || exit 1
+  echo "已渲染配置（--no-start · 未启动）：${SYSTEM_UNIT_PATH}"
+  exit 0
+fi
+
+if [ "${HOST_KIND}" = "herdr" ]; then
+  # 幂等：先关掉同名旧 workspace（没有就忽略）
+  OLD_WS="$(herdr workspace list 2>/dev/null | "$NODE_BIN" -e '
+let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{
+try{const j=JSON.parse(s);const ws=(j.result?.workspaces??[]).filter(w=>w.label===process.argv[1]);console.log(ws.map(w=>w.workspace_id).join(" "))}catch{console.log("")}})' "${WORKSPACE_LABEL}")"
+  for w in ${OLD_WS}; do herdr workspace close "$w" >/dev/null 2>&1 || true; done
+  WS_JSON="$(herdr workspace create --cwd "${PKG_ROOT}" --label "${WORKSPACE_LABEL}" --no-focus 2>/dev/null)"
+  WS_ID="$(printf '%s' "${WS_JSON}" | "$NODE_BIN" -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).result.workspace.workspace_id)}catch{console.log("")}})')"
+  PANE_ID="$(printf '%s' "${WS_JSON}" | "$NODE_BIN" -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).result.root_pane.pane_id)}catch{console.log("")}})')"
+  if [ -z "${WS_ID}" ]; then
+    echo "herdr workspace 创建失败 → 回落自带系统宿主" >&2
+    HOST_KIND="${SYSTEM_KIND}"
+    HOST_REASON="回落自带系统宿主（herdr workspace 创建失败）"
+  else
+    # pane 里跑监督器脚本（**纯 headless**：不抢焦点、不占用户终端、不进 TUI）
+    herdr pane run "${PANE_ID}" bash "${RUNNER_FILE}" >/dev/null 2>&1 || true
+    write_host_state herdr "${WS_ID}" "${PANE_ID}" ""
+    UNIT_PATH="herdr workspace ${WS_ID} / pane ${PANE_ID}"
+  fi
+fi
+
+# 系统单元：宿主是系统时它是主角；宿主是 herdr 时它是**兜底保活**（herdr 挂了它接管）。
+if ! install_system_unit; then
+  echo "系统宿主单元安装失败（单元文件已写入：${SYSTEM_UNIT_PATH}）" >&2
+  exit 1
+fi
+if [ "${HOST_KIND}" != "herdr" ]; then
+  write_host_state "${SYSTEM_KIND}" "" "" "${SYSTEM_UNIT_PATH}"
+  UNIT_PATH="${SYSTEM_UNIT_PATH}"
+fi
+
+
+# ---- 验证三证据（不谎报成功）----
+hb_ts() {
+  "$NODE_BIN" -e '
+const fs=require("fs");try{const j=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));console.log(String(j.ts??""))}catch{console.log("")}' "$1"
+}
+hb_pid() {
+  "$NODE_BIN" -e '
+const fs=require("fs");try{const j=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));console.log(String(j.pid??""))}catch{console.log("")}' "$1"
+}
+
+WAITED=0
+TS1=""
+while [ "${WAITED}" -lt 120 ]; do   # 最多 60s：launchd 冷启动 + 崩溃重启的 ThrottleInterval(10s) 都要覆盖
+  TS1="$(hb_ts "${HEARTBEAT_FILE}")"
+  if [ -n "${TS1}" ]; then break; fi
+  sleep 0.5
+  WAITED=$((WAITED + 1))
+done
+if [ -z "${TS1}" ]; then
+  echo "验证失败：没有看到心跳文件（${HEARTBEAT_FILE}）→ 助理没起来" >&2
+  # 诊断：把值班进程自己的错误日志尾部打出来（否则失败无法归因）。
+  for f in "${LOG_DIR}/daemon.err.log" "${LOG_DIR}/daemon.out.log"; do
+    if [ -f "${f}" ] && [ -s "${f}" ]; then
+      echo "---- ${f}（尾部 20 行）----" >&2
+      tail -20 "${f}" >&2
+    fi
+  done
+  exit 1
+fi
+PID="$(hb_pid "${HEARTBEAT_FILE}")"
+if [ -z "${PID}" ] || ! kill -0 "${PID}" 2>/dev/null; then
+  echo "验证失败：心跳里的进程不在（pid=${PID:-?}）→ 助理没起来" >&2
+  exit 1
+fi
+TS2="$(hb_ts "${HEARTBEAT_FILE}")"
+WAITED=0
+while [ "${TS2}" = "${TS1}" ] && [ "${WAITED}" -lt 30 ]; do
+  sleep 0.5
+  TS2="$(hb_ts "${HEARTBEAT_FILE}")"
+  WAITED=$((WAITED + 1))
+done
+if [ "${TS2}" = "${TS1}" ]; then
+  echo "验证失败：心跳没有更新（ts 一直是 ${TS1}）→ 助理没在跑" >&2
+  exit 1
+fi
+case "${HOST_KIND}" in
+herdr)
+  if [ -z "${WS_ID}" ] || ! herdr pane list 2>/dev/null | grep -q "${PANE_ID}"; then
+    echo "验证失败：herdr pane 不在了（${PANE_ID}）→ 助理没在跑" >&2
+    exit 1
+  fi
+  # 兜底保活单元也必须已加载（herdr 挂了就靠它接管）
+  case "${SYSTEM_KIND}" in
+    launchd)
+      if ! launchctl print "gui/$(id -u)/${LABEL}" >/dev/null 2>&1; then
+        echo "验证失败：兜底 LaunchAgent 没加载（${SYSTEM_UNIT_PATH}）→ herdr 挂了就没人接管" >&2
+        exit 1
+      fi
+      ;;
+    systemd)
+      if ! systemctl --user is-active "${SERVICE_NAME}" >/dev/null 2>&1; then
+        echo "验证失败：兜底 systemd 单元没在跑（${SYSTEM_UNIT_PATH}）→ herdr 挂了就没人接管" >&2
+        exit 1
+      fi
+      ;;
+  esac
+  UNIT_LOADED=1
+  ;;
+launchd)
+  if ! launchctl print "gui/$(id -u)/${LABEL}" >/dev/null 2>&1; then
+    echo "验证失败：LaunchAgent 没加载（${UNIT_PATH}）→ 助理没在跑" >&2
+    exit 1
+  fi
+  UNIT_LOADED=1
+  ;;
+systemd)
+  if ! systemctl --user is-active "${SERVICE_NAME}" >/dev/null 2>&1; then
+    echo "验证失败：systemd 单元没在跑（${UNIT_PATH}）→ 助理没在跑" >&2
+    exit 1
+  fi
+  UNIT_LOADED=1
+  ;;
+esac
+if [ "${UNIT_LOADED}" -ne 1 ]; then
+  echo "验证失败：宿主未确认加载 → 不谎报「已常驻」" >&2
+  exit 1
+fi
+
+echo "已常驻"
+echo "  · 主宿主：${HOST_KIND}${HOST_REASON:+（${HOST_REASON}）}"
+echo "  · 单元：${UNIT_PATH}"
+if [ "${HOST_KIND}" = "herdr" ]; then
+  echo "  · 兜底宿主：${SYSTEM_KIND}（${SYSTEM_UNIT_PATH}）→ herdr 挂了自动接管"
+fi
+echo "  · 进程：pid=${PID} 在跑"
+echo "  · 心跳：${HEARTBEAT_FILE}（ts ${TS1} → ${TS2} 在前进）"
+echo "  · 想关掉：bash pi-proactive/tools/daemon-uninstall.sh"
+echo "提醒：默认 enabled=false + 干跑 → 装上不会花钱；要真跑请开开关与预算上限。"
+exit 0

package/tools/daemon-uninstall.sh

@@ -0,0 +1,226 @@
+#!/usr/bin/env bash
+
+
+# pi-proactive 常驻助理：**一键卸载**（幂等 · 卸载后**零残留**）。
+#
+# 做四件事（顺序固定）：
+#   ① 停（herdr workspace / launchd / systemd；再兜底杀掉残留进程）
+#   ② 删（单元文件 / 日志 / socket / 状态目录）
+#   ③ 校验（**逐项列出证据**；有残留即非零退出 —— 不谎报「卸载成功」）
+#
+# 保留（默认不删）：`$agentDir/proactive/` 下的任务表 / 事件流 / 邮箱（**用户数据**，删不删由用户决定；
+#                `--purge-data` 才连它一起删）。
+#
+# 用法：
+#   bash pi-proactive/tools/daemon-uninstall.sh
+#   bash pi-proactive/tools/daemon-uninstall.sh --agent-dir <dir>
+#   bash pi-proactive/tools/daemon-uninstall.sh --no-start        # 只删文件，不动服务管理器（自测用）
+#   bash pi-proactive/tools/daemon-uninstall.sh --label <label>   # 指定 launchd 单元标签（必须与安装时一致）
+#   bash pi-proactive/tools/daemon-uninstall.sh --service-name <n># 指定 systemd 单元名（必须与安装时一致）
+#   bash pi-proactive/tools/daemon-uninstall.sh --purge-data      # 连用户数据一起删
+#
+# 退出码：0=卸载完成且无残留；1=有残留；2=环境不支持。
+set -uo pipefail
+
+PKG_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+LABEL="${PI_PROACTIVE_DAEMON_LABEL:-com.pi-proactive.daemon}"
+SERVICE_NAME="${PI_PROACTIVE_DAEMON_SERVICE:-pi-proactive-daemon.service}"
+WORKSPACE_LABEL="pi-proactive-daemon"
+
+AGENT_DIR="${PI_CODING_AGENT_DIR:-${HOME}/.pi/agent}"
+NO_START=0
+PURGE_DATA=0
+AGENT_ID="${PI_PROACTIVE_AGENT_ID:-}"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --agent-dir) AGENT_DIR="$2"; shift 2 ;;
+    --agent-id) AGENT_ID="$2"; shift 2 ;;
+    --label) LABEL="$2"; shift 2 ;;
+    --service-name) SERVICE_NAME="$2"; shift 2 ;;
+    # --host 只为与 cli 的参数契约一致（卸载会把所有宿主都停掉 → 不区分宿主）
+    --host) if [ $# -ge 2 ]; then shift 2; else shift; fi ;;
+    --no-start) NO_START=1; shift ;;
+    --purge-data) PURGE_DATA=1; shift ;;
+    -h|--help) sed -n '2,20p' "$0"; exit 0 ;;
+    *) echo "未知参数：$1" >&2; exit 2 ;;
+  esac
+done
+
+NODE_BIN="${NODE_BIN:-$(command -v node || true)}"
+DAEMON_DIR="${AGENT_DIR}/proactive/daemon"
+LOG_DIR="${DAEMON_DIR}"
+HOST_STATE_FILE="${DAEMON_DIR}/host.json"
+HEARTBEAT_FILE="${DAEMON_DIR}/heartbeat.json"
+RUNNER_FILE="${DAEMON_DIR}/run-daemon.sh"
+PROACTIVE_DIR="${AGENT_DIR}/proactive"
+
+# ---- 停 ----
+KIND=""
+AGENT_ID="${AGENT_ID:-}"
+if [ -f "${HOST_STATE_FILE}" ]; then
+  KIND="$(sed -n 's/.*"hostKind"[ ]*:[ ]*"\([^"]*\)".*/\1/p' "${HOST_STATE_FILE}")"
+  [ -n "${AGENT_ID}" ] || AGENT_ID="$(sed -n 's/.*"agentId"[ ]*:[ ]*"\([^"]*\)".*/\1/p' "${HOST_STATE_FILE}")"
+fi
+OLD_PID=""
+if [ -f "${HEARTBEAT_FILE}" ] && [ -n "${NODE_BIN}" ]; then
+  OLD_PID="$("$NODE_BIN" -e '
+const fs=require("fs");try{const j=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));console.log(String(j.pid??""))}catch{console.log("")}' "${HEARTBEAT_FILE}")"
+fi
+
+if [ "${NO_START}" -ne 1 ]; then
+  # ---- 停（**不依赖 host.json**）----
+  # 为什么必须无条件停：host.json 可能缺失/损坏（用户手动删过状态目录、被别的工具清过）。
+  # 若「停」只按 host.json 里的 kind 走，卸载就只会删文件、**停不掉服务** →
+  # 留下「单元仍加载 + 进程还在」的孤儿，用户永远卸不干净
+  # （实测：只删 plist 后 `launchctl print` 仍成功 → 脚本自检报「残留」并 exit 1）。
+  WS_ID=""
+  case "$(uname -s)" in
+    Darwin)
+      launchctl bootout "gui/$(id -u)/${LABEL}" >/dev/null 2>&1 || true
+      launchctl unload "${HOME}/Library/LaunchAgents/${LABEL}.plist" >/dev/null 2>&1 || true
+      ;;
+    Linux)
+      if command -v systemctl >/dev/null 2>&1; then
+        systemctl --user disable --now "${SERVICE_NAME}" >/dev/null 2>&1 || true
+        systemctl --user reset-failed "${SERVICE_NAME}" >/dev/null 2>&1 || true
+      fi
+      ;;
+  esac
+  # herdr 宿主：按 label 关掉同名 workspace（纯 headless 容器，不影响用户自己的 pane）
+  if command -v herdr >/dev/null 2>&1 && [ -n "${NODE_BIN}" ]; then
+    WS_ID="$(sed -n 's/.*"workspaceId"[ ]*:[ ]*"\([^"]*\)".*/\1/p' "${HOST_STATE_FILE}" 2>/dev/null || true)"
+    if [ -z "${WS_ID}" ]; then
+      WS_ID="$(herdr workspace list 2>/dev/null | "${NODE_BIN}" -e '
+let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{
+try{const j=JSON.parse(s);const ws=(j.result?.workspaces??[]).filter(w=>w.label===process.argv[1]);console.log(ws.map(w=>w.workspace_id).join(" "))}catch{console.log("")}})' "${WORKSPACE_LABEL}")"
+    fi
+    for w in ${WS_ID}; do
+      herdr workspace close "$w" >/dev/null 2>&1 || true
+    done
+  fi
+  case "${KIND}" in
+    herdr) echo "已停（herdr workspace）：${WS_ID:-无}" ;;
+    systemd) echo "已停（systemd --user）：${SERVICE_NAME}" ;;
+    launchd) echo "已停（launchd）：${LABEL}" ;;
+    *) echo "已停（按平台默认宿主；状态文件缺失 → 未能确认原宿主，仍按默认停了一遍）" ;;
+  esac
+  # ★监督器也要杀：监督器（run-daemon.sh）会**把值班进程再拉起来** →
+  #   只杀值班进程 = 没卸载干净（单元还在 → 几秒后又活了）。
+  if [ -f "${RUNNER_FILE}" ] || [ -n "${RUNNER_FILE}" ]; then
+    if pgrep -f "${RUNNER_FILE}" >/dev/null 2>&1; then
+      pkill -f "${RUNNER_FILE}" 2>/dev/null || true
+      sleep 1
+      pkill -9 -f "${RUNNER_FILE}" 2>/dev/null || true
+      echo "已结束残留监督器（${RUNNER_FILE}）"
+    fi
+  fi
+  # 兜底：进程还在就杀掉（常驻进程不该留在用户机器上）。
+  if [ -n "${OLD_PID}" ] && kill -0 "${OLD_PID}" 2>/dev/null; then
+    kill "${OLD_PID}" 2>/dev/null || true
+    sleep 1
+    kill -9 "${OLD_PID}" 2>/dev/null || true
+    echo "已结束残留进程：pid=${OLD_PID}"
+  fi
+fi
+
+# ---- 删 ----
+case "$(uname -s)" in
+Darwin)
+  rm -f "${HOME}/Library/LaunchAgents/${LABEL}.plist"
+  ;;
+Linux)
+  rm -f "${HOME}/.config/systemd/user/${SERVICE_NAME}"
+  if [ "${NO_START}" -ne 1 ] && command -v systemctl >/dev/null 2>&1; then
+    systemctl --user daemon-reload >/dev/null 2>&1 || true
+  fi
+  ;;
+esac
+
+# socket（常驻进程的端点；正常没有 → 顺手清掉）
+# socket 端点路径：模块按【运行环境】解析（产物态 build/… 优先，开发态 src/… 回落）
+SOCKET_MODULE=""
+SOCKET_CANDIDATES="src/socket.ts build/src/socket.js"
+for c in ${SOCKET_CANDIDATES}; do
+	[ -f "${PKG_ROOT}/${c}" ] && { SOCKET_MODULE="${PKG_ROOT}/${c}"; break; }
+done
+if [ -z "${SOCKET_MODULE}" ]; then
+  echo "警告：找不到 socket 模块（试过 ${SOCKET_CANDIDATES// /、}）→ socket 端点文件可能残留" >&2
+elif [ -n "${NODE_BIN}" ] && [ -n "${AGENT_ID}" ]; then
+  SOCK="$("$NODE_BIN" --experimental-strip-types -e '
+import(process.argv[1]).then(m=>{console.log(m.socketPathFor(process.argv[2], process.argv[3]))}).catch(()=>console.log(""))' "file://${SOCKET_MODULE}" "${AGENT_ID}" "${AGENT_DIR}" 2>/dev/null || true)"
+  [ -n "${SOCK}" ] && rm -f "${SOCK}"
+fi
+
+# 日志 / 状态目录（心跳 / 联系清单 / 交班摘要 / 宿主状态 / 启动器）
+rm -rf "${DAEMON_DIR}"
+
+if [ "${PURGE_DATA}" -eq 1 ]; then
+  rm -rf "${PROACTIVE_DIR}"
+  echo "已删用户数据（--purge-data）：${PROACTIVE_DIR}"
+else
+  echo "保留（未删）：${PROACTIVE_DIR} 下的任务表 / 事件流 / 邮箱（用户数据；--purge-data 才删）"
+fi
+
+# ---- 校验（逐项；有残留即非零退出）----
+RESIDUE=0
+check_gone() {
+  if [ -e "$1" ]; then
+    echo "残留：$2 仍在 $1" >&2
+    RESIDUE=1
+  else
+    echo "已清：$2"
+  fi
+}
+case "$(uname -s)" in
+Darwin) check_gone "${HOME}/Library/LaunchAgents/${LABEL}.plist" "LaunchAgent 单元" ;;
+Linux) check_gone "${HOME}/.config/systemd/user/${SERVICE_NAME}" "systemd 单元" ;;
+esac
+check_gone "${DAEMON_DIR}" "状态/日志目录"
+if pgrep -f "${RUNNER_FILE}" >/dev/null 2>&1; then
+  echo "残留：监督器进程还在（${RUNNER_FILE}）" >&2
+  RESIDUE=1
+else
+  echo "已清：监督器进程"
+fi
+if [ -n "${OLD_PID}" ] && kill -0 "${OLD_PID}" 2>/dev/null; then
+  echo "残留：进程还在（pid=${OLD_PID}）" >&2
+  RESIDUE=1
+else
+  echo "已清：进程（pid=${OLD_PID:-无}）"
+fi
+if [ "${NO_START}" -ne 1 ]; then
+  case "$(uname -s)" in
+  Darwin)
+    if launchctl print "gui/$(id -u)/${LABEL}" >/dev/null 2>&1; then
+      echo "残留：服务仍处于加载状态（launchctl print 成功）" >&2
+      RESIDUE=1
+    else
+      echo "已清：服务未加载"
+    fi
+    ;;
+  Linux)
+    if command -v systemctl >/dev/null 2>&1 && systemctl --user is-enabled "${SERVICE_NAME}" >/dev/null 2>&1; then
+      echo "残留：服务仍处于 enabled 状态" >&2
+      RESIDUE=1
+    else
+      echo "已清：服务未 enabled"
+    fi
+    ;;
+  esac
+fi
+
+if [ "${RESIDUE}" -ne 0 ]; then
+  echo "结果：存在残留（见上方）" >&2
+  echo "手工清理命令（逐条执行即可清干净）：" >&2
+  case "$(uname -s)" in
+    Darwin) echo "  launchctl bootout \"gui/$(id -u)/${LABEL}\" || true" >&2
+            echo "  rm -f \"${HOME}/Library/LaunchAgents/${LABEL}.plist\"" >&2 ;;
+    Linux)  echo "  systemctl --user disable --now \"${SERVICE_NAME}\" || true" >&2
+            echo "  rm -f \"${HOME}/.config/systemd/user/${SERVICE_NAME}\"" >&2 ;;
+  esac
+  echo "  pkill -f \"${RUNNER_FILE}\" || true" >&2
+  echo "  rm -rf \"${DAEMON_DIR}\"" >&2
+  exit 1
+fi
+echo "结果：卸载完成，无残留（exit 0）"
+exit 0

package/node_modules/typebox/build/guard/unicode/unicode.d.mts

@@ -1,6 +0,0 @@
-/** Returns the total number of Unicode code points in the string */
-export declare function CodePointCount(value: string): number;
-/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
-export declare function IsMaxLength(value: string, maxLength: number): boolean;
-/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
-export declare function IsMinLength(value: string, minLength: number): boolean;

package/node_modules/typebox/build/guard/unicode/unicode.mjs

@@ -1,35 +0,0 @@
-// ------------------------------------------------------------------
-// CodePointCount (10-bit Shift Branchless)
-//
-// Counts code points by enumerating UTF-16 sequences and incrementing
-// when not within a high/low pairing. Because surrogate blocks are
-// 1024 (2^10) wide and aligned, by shifting right by (0xA), we can
-// collapse each unit to a constant per block (high: 0x36, low: 0x37)
-// and shift again into a packed (0x3637) for comparison. Fetch calls
-// to charCodeAt(...) are kept to one call per iteration.
-//
-// ------------------------------------------------------------------
-/** Returns the total number of Unicode code points in the string */
-export function CodePointCount(value) {
-    let result = 0, index = 0, prev = 0;
-    while (index < value.length) {
-        const next = value.charCodeAt(index++) >> 0xA; // shift  (10-bits into high/low)
-        result += +(((prev << 8) | next) !== 0x3637); // packed (or +!(prev === 0x36 && next === 0x37))
-        prev = next;
-    }
-    return result;
-}
-// ------------------------------------------------------------------
-// IsMaxLength
-// ------------------------------------------------------------------
-/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
-export function IsMaxLength(value, maxLength) {
-    return value.length <= maxLength || (value.length <= (maxLength << 1) && CodePointCount(value) <= maxLength);
-}
-// ------------------------------------------------------------------
-// IsMinLength
-// ------------------------------------------------------------------
-/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
-export function IsMinLength(value, minLength) {
-    return value.length >= (minLength << 1) || (value.length >= minLength && CodePointCount(value) >= minLength);
-}

package/node_modules/typebox/build/schema/engine/_pathing.d.mts

@@ -1 +0,0 @@
-export declare function EncodeFragment(fragment: string): string;