@thincoder/core 0.10.4 → 0.10.5

package/session-lifecycle.mjs

@@ -20,7 +20,7 @@
 import { existsSync } from "node:fs"
 import { resolveCompactThreshold } from "./config.mjs"
 // 槽面判据单源（#841 KD-841-2：槽渠道 key 门 + 模型面序——PROVIDER.md §6.22）。
-import { resolveProviderPlan } from "./model-ref.mjs"
+import { hasKey, resolveChannelModel, resolveProviderPlan } from "./model-ref.mjs"
 import {
   slotPath, loadManifest, saveManifest, slotDigest, writeSessionFile, getSessionId,
   writeEndMarker, sessionEnd, ownerPid, ownerPids,
@@ -77,10 +77,10 @@ function stripTruncatedToolArgs(m) {
  *
  *  MODEL-MERGE-SESSION（F-4）applySession 重写为两支 + 删旧支（评审 #7/#9 措辞——防
  *  "三支"误读）：
- *  ① 槽 provider 存在 → provider/model 按槽值设（双字段恒非空——模型取 data.activeModel（**串值**；
- *     非串 ∕ null ∕ 空串 = 未登记 ⇒ 回该渠道默认模型 `providers[].model` 单值——2026-09-10 MODEL-SELECTION
- *     v2；老 models[] 首候选形态已退场）+ 重算
- *     compactThreshold（auto 时——按恢复后模型）——不看 config（defaultModel 只是新会话起点）；
+ *  ① 槽 provider 存在 → provider/model 按槽值设（模型链 = 槽模型 → `defaultModel` 属本渠道 ⇒ 其模型段；
+ *     两档皆无 ⇒ `null`——2026-10-09 清除批：原 `providers[].model` 回落退场；`defaultModel` 经
+ *     `resolveProviderPlan` 参与模型面）+ 重算
+ *     compactThreshold（auto 时——按恢复后模型）；
  *  ② 槽 provider 没了 → D-S3 保留——静默保持现状（config 有效则有效——两方都无效由调用侧
  *     复验 validateProvider 弹重选）。
  *  删旧支："activeModel==null 清 stale override 回渠道默认"——前提 = 渠道默认字段——已随
@@ -172,8 +172,8 @@ export function applySession(agent, data, opts = {}) {
   if (slotPlan.source === "slot") {
     const slotProvider = agent.providers?.find((pr) => pr.name === slotPlan.channel)
     // ① 槽 provider 存在 → 按槽值设（不看 config）：双字段恒非空。
-    //    模型面序（#841）：槽模型 → `defaultModel` 属本渠道 ⇒ 其模型段 → 渠道默认单值
-    //    （`providers[].model`）；三档皆无 ⇒ `null`（不落 model 键——下游沿既有「model 缺失」处置）。
+    //    模型面序（#841）：槽模型 → `defaultModel` 属本渠道 ⇒ 其模型段；两档皆无 ⇒ `null`（不落
+    //    model 键——下游沿既有「model 缺失」处置；渠道单值模型退场——2026-10-09 清除批）。
     //    F-2d（MODEL-400-FIX）径保留：空串 / 非串槽模型同样兜（#638 非串 = 未登记）——slotPlan.model
     //    已按同归一出值（单源，无第二判据）。
     const prevName = agent.activeProvider
@@ -379,21 +379,25 @@ export function slotOccupancy(cwd, slot) {
  *  读数百分数（整数）。与 `applySession` 后读数**同源同式**（四事同判——组合既有件，零新公式）：
  *  ① 线选 = `contextHistory` 非空取之，否则 `history` 经 `stripTruncatedToolArgs` 回退（同 applySession）；
  *  ② 回声归并 = `mergeAdjacentAssistantEchoes`（同 applySession 装线前一步）；
- *  ③ 渠道合并 = `providers` 命中 `data.activeProvider` ⇒ 串值 `activeModel` 覆盖 `entry.model`（非串 ∕
- *     空串 = 未登记 ⇒ 回退 `entry.model`——模型合并支 ① 同归一）；未命中 ⇒ `fallback`（支 ②「静默保持现状」的装配口径 = `loadConfig().provider`）；
+ *  ③ 渠道合并 = `providers` 命中 `data.activeProvider` ⇒ 槽模型（串值 `activeModel`；非串 ∕ 空串 = 未登记
+ *     ⇒ 落链）∥ 无槽模型 ⇒ 现行模型链回落（`defaultModel` 属本渠道 ⇒ 其模型段；两档皆无 ⇒ `null`——
+ *     `resolveChannelModel`，2026-10-09 清除批：渠道单值模型退场，零静默回落）；未命中 ⇒ `fallback`
+ *     （支 ②「静默保持现状」的装配口径 = `loadConfig().provider`）；
  *  ④ 公式 = `historyPercent`（`thincoder-core/token-window.mjs`——与 CLI 状态行 / VSC 同式）。
- *  **零副作用**：`data` / `providers` / `fallback` 皆入参（不读盘、不写盘、不改任何进程态）；
+ *  **零副作用**：`data` / `providers` / `fallback` / `defaultModel` 皆入参（不读盘、不写盘、不改任何进程态）；
  *  `data` 非对象 ⇒ `0`（与空历史同值——「非正 ⇒ 零节点」显示门归端侧，沿 `historyPercent` 空历史口径）。 */
-export function sessionReading(data, { providers, fallback } = {}) {
+export function sessionReading(data, { providers, fallback, defaultModel } = {}) {
   if (data === null || typeof data !== "object") return 0
   const full = Array.isArray(data.history) ? data.history : []
   const ch = data.contextHistory
   const machine = (Array.isArray(ch) && ch.length > 0) ? ch : full.map(stripTruncatedToolArgs)
   const line = mergeAdjacentAssistantEchoes(machine)
-  const entry = data.activeProvider ? providers?.find((pr) => pr.name === data.activeProvider) : null
-  // #638：非串 `activeModel` 归一（与 applySession 模型合并支 ① 同判）——脏值不达 `historyPercent`。
+  const entry = data.activeProvider ? providers?.find((pr) => pr.name === data.activeProvider && hasKey(pr)) : null
+  // #638：非串 ∕ 空串 `activeModel` 归一（与 applySession 模型合并支 ① 同判）——脏值不达 `historyPercent`；
+  // 未登记 ⇒ 落现行模型链（`defaultModel` 属本渠段 ∥ `null`——渠道单值退场，2026-10-09 清除批）。
+  const slotModel = (typeof data.activeModel === "string" && data.activeModel) ? data.activeModel : null
   const provider = entry
-    ? { ...entry, model: (typeof data.activeModel === "string" && data.activeModel) ? data.activeModel : entry.model }
+    ? { ...entry, model: slotModel ?? resolveChannelModel(entry, defaultModel ?? null) }
     : fallback
   return historyPercent(line, provider)
 }

package/session-slot-claims.mjs

@@ -16,7 +16,7 @@
  * `unknown`（探测失败 / 缺行）⇒ 不认领 / 不判死 / 不删（D-MI10）。
  */
 import { existsSync } from "node:fs"
-// 探测束（判活）+ 属主三态判据 / 死主判定（本档零自有 exec——判据面与探测面分离）。
+// 探测束（判活）+ 属主三态判据 / 死主判定（本档零自有 exec——判据与探测面分离）。
 import { probeOwnersSync, ownerState, filterDeadOwners } from "./process-probe.mjs"
 // 存储原语（路径 / 原子写 / 进程 sessionId）——静态环见头注。
 import { getSessionId, manifestPath, slotPath } from "./session-slots.mjs"
@@ -210,7 +210,7 @@ export const _releaseStats = { calls: 0 }
  *  早退面：磁盘无 manifest ⇒ `existsSync` 单条目早退**零写**（不造盘面）；本进程无认领 ⇒
  *  零写返回 false。失败容忍（F-XR1「退出恒达」）：整体 try/catch **永不抛出**，返回 boolean
  *  （true = 有释放且落盘成功；false = 早退 / 失败 / **写面拒写**——`saveManifest` 返回值透传，
- *  §6.23 判据句 3——断言面）；写失败盘面 = 认领残留 →
+ *  §6.23 判据句 3——断言）；写失败盘面 = 认领残留 →
  *  恢复走既有探测面（现状形态，数据零险）。 */
 export function releaseClaimsAll(cwd) {
   _releaseStats.calls += 1

package/session-slots-manifest.mjs

@@ -1,7 +1,7 @@
 /**
  * session-slots-manifest.mjs — 清单 / 认领 / 属主面（init-block 批 · F-MI7 拆分：
  * `session-slots.mjs` 探测束接线后实读 517 行，破 490 判定线并越 500 硬限 ⇒ 按
- * `CORE-UNIFICATION.md` §2.8.1 表第 3 行随批执行外提；各函数语义**原样**迁移）：
+ * `CORE-UNIFICATION.md` §2.8.1 子表原行 3（已随 2026-10-08 批清账）随批执行外提；各函数语义**原样**迁移）：
  * 摘要面（`extractSlotMeta` / `slotDigest`）· 清单读写（`loadManifest` / `saveManifest`）·
  * 属主面（`ownerPid` / `ownerPids` / `ownerStateOf` / `ownerArgs` / `cleanDeadOwners`）·
  * 认领面（`ensureActive` / `allocateFresh` / `claimSlot` / `activeSlot` / **认领释放集

package/session-slots.mjs

@@ -4,7 +4,7 @@
  * re-export 全部导出以保持既有 import 兼容）。
  *
  * init-block 批 · F-MI7 二次拆分：探测束接线后本档实读 517 行（破 490 判定线并越 500 硬限）
- * ⇒ 按 `CORE-UNIFICATION.md` §2.8.1 表第 3 行**随批**外提清单 / 认领 / 属主面至
+ * ⇒ 按 `CORE-UNIFICATION.md` §2.8.1 子表原行 3（已随 2026-10-08 批清账）**随批**外提清单 / 认领 / 属主面至
  * `session-slots-manifest.mjs`（语义原样迁移；本档 re-export 该档导出保既有 import 面——
  * 消费档 import 路径与名面不动）。本档保留 = 存储原语（cwd 哈希 / 路径 / 原子写 / 进程
  * sessionId）· 端记录（end marker）· 列表面（listSlots——条目集 = 盘面实读；扫描面住
@@ -33,14 +33,14 @@ import { join, dirname, basename } from "node:path"
 import { configDir } from "./config.mjs"
 import { migrateHashLength } from "./session-migrate.mjs"
 // §6.10 D-2（2026-09-05）：resumeSlot 决策归本文件（slot/claim 层）；data 层读（loadSlotFile/
-// legacy 过滤）属 session.mjs（500 行内不迁移）——静态环（本档 ↔ session.mjs；init-block 批起
+// legacy 过滤）属 session.mjs（800 行内不迁移）——静态环（本档 ↔ session.mjs；init-block 批起
 // 另加本档 ↔ session-slots-manifest.mjs，见头注与 L38-47）：函数声明实例化期已初始化、只函数
 // 体内运行时使用（环安全）；VS Code 端 session-slots ↔ session-io 同构镜像。
 import { loadSlotFile, isLegacyTransient } from "./session.mjs"
 // TUI-OOM-ROOTCAUSE 批（SESSION.md §6.14 生命周期联动）：删槽联动记录存储（store 零项目内依赖——无环）。
 import { unlinkRecordStore } from "./session-store.mjs"
 // 探测束（init-block 批 · F-MI7）：实现 / 判据单源住 process-probe.mjs——本档零自有 exec、
-// 零逐 pid 探测（判据面与探测面分离）；单 pid 判活 re-export 见下方「判活兼容面」。
+// 零逐 pid 探测（判据与探测面分离）；单 pid 判活 re-export 见下方「判活兼容面」。
 import { probeOwnersAsync, isProcessAlive } from "./process-probe.mjs"
 // 清单 / 认领 / 属主面（init-block 批外提——双向静态环见头注）：本档 import 取用 + re-export
 // 保既有 import 面（消费档路径与名面不动）。

package/team-ledger.mjs

@@ -0,0 +1,282 @@
+/**
+ * team-ledger.mjs — 团队台账核工具 `team_ledger`（端侧面单源；`docs/core/design/TEAM-LEDGER.md` §2——三端同 import，
+ * 2026-10-13 team-ledger 批）。
+ *
+ * 面：① 工具声明（五 action——depth-0 全量 ∥ 子代理只读变体；两变体同名单对象、schema 窄化；写三 action 于
+ * 只读变体 schema 级不可达——D-TL5）；② 仓标记派生（会话项目根 ⇒ `git rev-parse --show-toplevel` ⇒
+ * `git config --get remote.origin.url` ⇒ **原文**上送 ⇒ 服务端归一——KD-SV-144/D-TL3；端侧零归一实现）；
+ * ③ 登录态门（`teamStatus().loggedIn` 判据单源——D-TL4；未登录 ⇒ 明示 + **零网络调用**）；④ 传输（直接
+ * `fetch` + Bearer `team.token` + 超时——沿 `team.mjs` 现形；零第三方 ∥ 零持久化 ∥ 零缓存回读——需求 ③④）。
+ *
+ * 接线（`agent/family-tools.mjs` 动态 import——沿 `ledgerTool`/`ledgerReadTool` 同位；`W8 契约②` 同律）。
+ * 零 import 本机台账模块（KD-SV-145/D-TL2——上送 = 本工具 + 本机 ledger 两步显式动作，零跨账代码路径）。
+ */
+import { execFileSync } from "node:child_process"
+import { loadConfig } from "./config.mjs"
+import { teamStatus } from "./team.mjs"
+import { DESC } from "./tools/shared.mjs"
+
+/** 请求超时（同 `team.mjs` `TEAM_FETCH_TIMEOUT_MS` 现值——该常量未导出（`team.mjs` ±0 面），两处同值即口径）。 */
+const TEAM_FETCH_TIMEOUT_MS = 15_000
+
+/** action 枚举（全量 / 只读两变体；顺序 = 文档与按钮序）。 */
+const FULL_ACTIONS = ["query", "count", "add", "update", "close"]
+const READ_ACTIONS = ["query", "count"]
+
+/** 六态（服务端 CHECK 同集——ledger/LEDGER.md §3）。 */
+const STATUSES = ["待讨论", "待设计", "在途", "待核销", "已核销", "已废弃"]
+
+/** 工具 cwd 供值面（缺省 → 当前项目根）。 */
+const cwdOf = (ctx) => ctx?.agent?.cwd ?? ctx?.cwd ?? process.cwd()
+
+// ── 仓标记派生（§2.2） ───────────────────────────────────────────────────────
+
+/** git 读取面（缺省 = 真 git；失败 ⇒ `null`——allowFail 口径）。 */
+function realGitRun(cwd, args) {
+  try {
+    return String(execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 })).trim()
+  } catch {
+    return null
+  }
+}
+
+let gitRun = realGitRun
+
+/** 测试注入：假 git 面（缺省 / 传非函数 ⇒ 复位真 git）。 */
+export function _setGitRunnerForTest(fn) {
+  gitRun = typeof fn === "function" ? fn : realGitRun
+}
+
+/** 仓标记派生（§2.2 三步）：会话项目根 ⇒ `rev-parse --show-toplevel` ⇒ `config --get remote.origin.url`；
+ *  无 git 仓 ∥ 无 origin ⇒ `null`（**原文**返回——归一在服务端）。出 = origin 原文 ∥ null。 */
+export function deriveRepo(cwd) {
+  const root = gitRun(cwd, ["rev-parse", "--show-toplevel"])
+  if (root === null || root === "") return null
+  const url = gitRun(root, ["config", "--get", "remote.origin.url"])
+  if (url === null || url === "") return null
+  return url
+}
+
+/** 派生出词（无仓 / 无 origin ⇒ 明示失败——判于网络前，零请求零写库）。 */
+function deriveRepoOrFail(cwd) {
+  const repo = deriveRepo(cwd)
+  if (repo === null) throw new Error("未检出 git 源（origin）——团队账按 git 源记账")
+  return repo
+}
+
+// ── 传输（§2.4——沿 teamVerify 现形） ────────────────────────────────────────
+
+/** 请求：`<server>/api/client/ledger*` + `Authorization: Bearer <team.token>` + 超时。出 = JSON 体。
+ *  401 ⇒ 「登录已失效」（端侧零清盘——沿 `teamVerify` 三值口径）∥ 网络失败 ⇒ 「服务器不可达」（零缓存回读）
+ *  ∥ 其余非 2xx ⇒ 服务端人话透传（400/403/404——错误形零新码）。 */
+async function request(server, token, method, path, body = null) {
+  let res
+  try {
+    res = await fetch(`${server}${path}`, {
+      method,
+      headers: { authorization: `Bearer ${token}`, ...(body === null ? {} : { "content-type": "application/json" }) },
+      ...(body === null ? {} : { body: JSON.stringify(body) }),
+      signal: AbortSignal.timeout(TEAM_FETCH_TIMEOUT_MS),
+    })
+  } catch {
+    throw new Error("服务器不可达——团队账不可用（零离线缓存）")
+  }
+  const text = await res.text().catch(() => "")
+  if (res.status === 401) throw new Error("登录已失效——请重新登录")
+  let payload = null
+  try {
+    payload = JSON.parse(text)
+  } catch {
+    payload = null
+  }
+  if (!res.ok) {
+    const message = payload?.error?.message
+    throw new Error(typeof message === "string" && message !== "" ? message : `团队账请求失败（HTTP ${res.status}）`)
+  }
+  if (payload === null || typeof payload !== "object") throw new Error("团队账响应形非法（非 JSON 对象）——服务不符合预期面")
+  return payload
+}
+
+// ── 工具层参数守卫（沿 `ledger` 工具面先例——声明派生；判于网络前，非法 ⇒ 零请求） ──
+
+/** 值预览（文案的 `<预览>`）：`JSON.stringify`，超 80 字符截断加 `…`。 */
+const argPreview = (v) => {
+  const s = JSON.stringify(v) ?? String(v)
+  return s.length > 80 ? `${s.slice(0, 80)}…` : s
+}
+
+/** 枚举取值域文本。 */
+const enumText = (values) => `{${values.join(", ")}}`
+
+/** 参数守卫（P1–P5：入参形 → 未知键 → 缺失（必填）→ 枚举 / 类型——只判不改）。 */
+function assertArgs(name, decl, args) {
+  const props = decl?.properties ?? {}
+  const fields = Object.keys(props)
+  if (args == null) args = {}
+  else if (typeof args !== "object" || Array.isArray(args)) throw new Error(`${name}：参数须为对象（收到 ${argPreview(args)}）`)
+  const unknown = Object.keys(args).filter((key) => !Object.hasOwn(props, key))
+  if (unknown.length > 0) throw new Error(`${name}：未知参数：${unknown.join(" / ")}（可用参数 = ${fields.join(" / ")}）`)
+  for (const field of fields) {
+    const spec = props[field]
+    const value = args[field]
+    if (value === undefined || value === null) {
+      if ((decl.required ?? []).includes(field)) {
+        const suffix = spec.enum ? `；取值 ∈ ${enumText(spec.enum)}` : spec.type === "string" ? "；非空字符串" : ""
+        throw new Error(`${name}：${field} 缺失（必填${suffix}）`)
+      }
+      continue
+    }
+    if (spec.enum) {
+      if (!spec.enum.includes(value)) throw new Error(`${name}：${field} 非法：${argPreview(value)}（取值 ∈ ${enumText(spec.enum)}）`)
+    } else if (spec.type === "string" && typeof value !== "string") {
+      throw new Error(`${name}：${field} 非法：${argPreview(value)}（应为字符串）`)
+    } else if (spec.type === "number" && typeof value !== "number") {
+      throw new Error(`${name}：${field} 非法：${argPreview(value)}（应为数字）`)
+    }
+  }
+  return args
+}
+
+/** 各 action 声明条目（= 参数并集按 action 收窄的单源；schema 与守卫同源）。 */
+const SCOPE_DESC = `"repo"（缺省——当前仓，自动派生）∥ "team"（全队跨仓）`
+const ACTION_SPECS = {
+  query: {
+    type: "object",
+    properties: {
+      scope: { type: "string", enum: ["repo", "team"], description: SCOPE_DESC },
+      status: { type: "string", enum: STATUSES, description: "按状态过滤（六态之一，缺省 = 不过滤）" },
+      owner: { type: "string", description: "按负责人过滤（用户名精确匹配）" },
+    },
+    additionalProperties: false,
+  },
+  count: {
+    type: "object",
+    properties: {
+      scope: { type: "string", enum: ["repo", "team"], description: SCOPE_DESC },
+      status: { type: "string", enum: STATUSES, description: "按状态过滤（六态之一，缺省 = 不过滤）" },
+      owner: { type: "string", description: "按负责人过滤（用户名精确匹配）" },
+    },
+    additionalProperties: false,
+  },
+  add: {
+    type: "object",
+    required: ["title"],
+    properties: {
+      title: { type: "string", description: "标题（必填——trim 非空 ∥ ≤200）" },
+      detail: { type: "string", description: "正文（可空 ∥ ≤4000）" },
+      owner: { type: "string", description: "负责人（缺省 = 自己）" },
+    },
+    additionalProperties: false,
+  },
+  update: {
+    type: "object",
+    required: ["id"],
+    properties: {
+      id: { type: "number", description: "条目编号（全局）" },
+      title: { type: "string", description: "标题（缺省 = 不变）" },
+      detail: { type: "string", description: "正文（缺省 = 不变；追认核销前须非空）" },
+      owner: { type: "string", description: "负责人（交接 = 换负责人；缺省 = 不变）" },
+      status: { type: "string", enum: STATUSES, description: "目标状态（迁移表合法后继——非法由服务端 400）" },
+    },
+    additionalProperties: false,
+  },
+  close: {
+    type: "object",
+    required: ["id", "status"],
+    properties: {
+      id: { type: "number", description: "条目编号（全局）" },
+      status: { type: "string", enum: ["已核销", "已废弃"], description: "目标态（收口 / 撤回）" },
+    },
+    additionalProperties: false,
+  },
+}
+
+/** 并集 schema（`action` 枚举 + 五 action 参数并集；per-action 必填 / 收窄由运行时守卫裁）。 */
+const UNION_PARAMETERS = {
+  type: "object",
+  required: ["action"],
+  properties: {
+    action: { type: "string", enum: FULL_ACTIONS, description: "" }, // 变体构造时填描述
+    scope: { type: "string", enum: ["repo", "team"], description: SCOPE_DESC },
+    status: { type: "string", enum: STATUSES, description: "状态（query ∥ count 过滤——六态之一；update 目标态——迁移表合法后继；close ∈ {已核销, 已废弃}）" },
+    owner: { type: "string", description: "负责人（query ∥ count 过滤——用户名精确匹配；add ∥ update 设值）" },
+    title: { type: "string", description: "标题（add 必填 ∥ update 可改——trim 非空 ∥ ≤200）" },
+    detail: { type: "string", description: "正文（add ∥ update——可空 ∥ ≤4000；追认核销须非空）" },
+    id: { type: "number", description: "条目编号（update ∥ close 必填——全局编号）" },
+  },
+  additionalProperties: false,
+}
+
+/** 变体构造（同名单对象、schema 窄化、两形永不同装配——先例 = `ledger` 工具 depth 面变体）。 */
+function makeTeamLedgerTool(actions, { readonly = false, writeFace = false } = {}) {
+  return {
+    name: "team_ledger",
+    description: DESC("team_ledger"), // 文本单点 = tool-docs/team_ledger.md（DESC 加载面）
+    parameters: {
+      ...UNION_PARAMETERS,
+      properties: {
+        ...UNION_PARAMETERS.properties,
+        action: {
+          ...UNION_PARAMETERS.properties.action,
+          enum: actions,
+          description: writeFace ? "操作（五值）：query 查询 / count 计数 / add 新增 / update 更新 / close 收口或撤回——写三仅主 agent 装配面" : "操作（只读二值）：query 查询 / count 计数",
+        },
+      },
+    },
+    readonly,
+    isReadonlyAction(args) { return READ_ACTIONS.includes(args?.action) },
+    async execute(args, ctx) {
+      if (args == null) args = {}
+      else if (typeof args !== "object" || Array.isArray(args)) throw new Error(`team_ledger：参数须为对象（收到 ${argPreview(args)}）`)
+      const { action, ...rest0 } = args
+      assertArgs("team_ledger", { properties: { action: { type: "string", enum: actions } }, required: ["action"] }, { action })
+      const rest = assertArgs(`team_ledger(${action})`, ACTION_SPECS[action], rest0)
+      // 登录态门（D-TL4——判据单源 = teamStatus().loggedIn；未登录 ⇒ 明示 + 零网络调用）
+      const status = teamStatus()
+      if (!status.loggedIn || status.server === null) throw new Error("未登录——团队账不可用（本机台账照常）；请先登录")
+      const token = loadConfig().team?.token // token 取值面（状态读面不下发 token——TEAM.md §2.1）
+      const server = status.server
+      const cwd = cwdOf(ctx)
+      switch (action) {
+        case "query": {
+          const payload = await request(server, token, "GET", `/api/client/ledger${queryOf(rest, cwd)}`)
+          return JSON.stringify(payload, null, 2)
+        }
+        case "count": {
+          const payload = await request(server, token, "GET", `/api/client/ledger${queryOf(rest, cwd)}`)
+          return JSON.stringify({ count: payload.total })
+        }
+        case "add": {
+          const repo = deriveRepoOrFail(cwd)
+          const payload = await request(server, token, "POST", "/api/client/ledger", { repo, title: rest.title, detail: rest.detail, owner: rest.owner })
+          return JSON.stringify(payload, null, 2)
+        }
+        case "update": {
+          const payload = await request(server, token, "PATCH", `/api/client/ledger/${encodeURIComponent(String(rest.id))}`, { title: rest.title, detail: rest.detail, owner: rest.owner, status: rest.status })
+          return JSON.stringify(payload, null, 2)
+        }
+        case "close": {
+          const payload = await request(server, token, "POST", `/api/client/ledger/${encodeURIComponent(String(rest.id))}/close`, { status: rest.status })
+          return JSON.stringify(payload, null, 2)
+        }
+        default:
+          // 不可达（入口枚举守门已先拒）——fail-loud 兜底（防未来变体增量 drift）
+          throw new Error(`team_ledger：action 非法：${argPreview(action)}（取值 ∈ ${enumText(actions)}）`)
+      }
+    },
+  }
+}
+
+/** 查询串装配（§2.1）：`scope = "repo"`（缺省）⇒ 派生当前仓（无源 ⇒ 明示失败）∥ `"team"` ⇒ 不带 `repo`。 */
+function queryOf(rest, cwd) {
+  const params = new URLSearchParams()
+  if ((rest.scope ?? "repo") === "repo") params.set("repo", deriveRepoOrFail(cwd))
+  if (rest.status != null) params.set("status", rest.status)
+  if (rest.owner != null) params.set("owner", rest.owner)
+  const text = params.toString()
+  return text === "" ? "" : `?${text}`
+}
+
+/** 统一入口两变体（同名 `team_ledger`——depth-0 装配全量 ∥ depth>0 各角色段装配只读）。 */
+export const teamLedgerTool = makeTeamLedgerTool(FULL_ACTIONS, { writeFace: true })
+export const teamLedgerReadTool = makeTeamLedgerTool(READ_ACTIONS, { readonly: true })

package/team.mjs

@@ -0,0 +1,223 @@
+/**
+ * team.mjs — 团队登录机制（TEAM.md §2——三端共用单源：CLI ∥ VSC ∥ 桌面同 import）。
+ *
+ * 面：登录 ∥ 退出 ∥ 登录态读面 ∥ 活校验（`teamVerify`——只读三值，登录面补全批增）∥ 端标签（自动生成）∥
+ * 派生 provider 条目（登录写入 / 退出停用）∥ 服务地址归一 ∥ 失败分类。**写面单源** = 本档（`writeConfigAtomic`
+ * 一次 mutate——经 `persistRaw`；端侧零自写盘，三端同源）——`teamVerify` **只读**（零写盘、零状态）。
+ *
+ * 形（TEAM.md §2.1）：顶层 `team` 段 `{ server, member{username,name}, label, token }`——`token` 在场 ⇔
+ * 已登录（权威源；不入 `DEFAULTS`）；派生条目 `{ name:"team", baseURL:"<server>/v1", apiKey:"<token>",
+ * derived:true }` —— 登录 upsert（有则更新 ∥ 无则追加 `providers[]` 表尾——不劫持既有回退序）；退出 =
+ * 摘 `token` ∥ 摘 `apiKey`（条目与 `derived` 保留——重登自动恢复）。同名手工条目 ⇒ 登录成但不覆盖
+ * （D-TM4——返回提示码）。
+ *
+ * 返回形（B1 批端侧契约——父侧裁定 2026-10-10）：
+ *   `teamLogin`  ⇒ `{ ok:true, notice?:"manual-name-conflict" }` ∥ `{ ok:false, reason }`
+ *   `teamLogout` ⇒ `{ ok:true, revokeDelivered:boolean }` ∥ `{ ok:false, reason }`
+ *   `reason` 取值域：`network`（不可达 ∥ DNS/TLS ∥ 超时 ∥ 非 401/429 应答——服务不符合预期面）∥
+ *   `credentials`（401——同措辞）∥ `rate_limited`（429——锁定期）∥ `write_failed`（服务端已应答、本地
+ *   写盘失败——mtime 冲突 ∥ 畸形档拒写）。`notice` 携**码**不携文（文本归端侧 i18n）；
+ *   `revokeDelivered:false` = 服务端吊销未达（网络失败——本地照清）。
+ */
+import { hostname } from "node:os"
+
+import { loadConfig } from "./config.mjs"
+import { persistRaw } from "./config-io.mjs"
+import { sessionEnd } from "./session-slots.mjs"
+
+/** 派生 provider 条目固定名（TEAM.md §2.1 ∥ PROVIDER.md §6.25）。 */
+const TEAM_PROVIDER_NAME = "team"
+
+/** 端标签总长上限（= key 名称上限——accounts/ACCOUNTS.md §1.1；自动生成超长 ⇒ 裁剪）。 */
+const LABEL_MAX = 40
+
+/** 登录/退出请求超时（毫秒）——超时归 `network` 分类（防悬挂）。 */
+const TEAM_FETCH_TIMEOUT_MS = 15_000
+
+/** 登录提示码：同名手工 provider 存在 ⇒ 派生条目未写（不覆盖——D-TM4；端侧就地提示）。 */
+export const NOTICE_MANUAL_NAME_CONFLICT = "manual-name-conflict"
+
+/** 写入口根形守卫：`writeConfigAtomic` 不校验根形——数组 ∥ 非对象根会让 mutate 落空（`JSON.stringify` 丢弃
+ *  非索引属性——写回原文）⇒ 假「已写」；本档 0 值 = 不产出假成功 ⇒ 拒写（上层归一 `write_failed`）。 */
+function assertWritableRoot(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("config 根非对象——拒写")
+}
+
+/** 服务地址归一（TEAM.md §2.1 ∥ 用例 E2）：去首尾空白；缺协议补 `http://`；去尾斜杠；尾 `/v1` 去。 */
+export function normalizeTeamServer(server) {
+  let text = typeof server === "string" ? server.trim() : ""
+  if (text === "") return null
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(text)) text = `http://${text}` // 缺协议补 http://
+  text = text.replace(/\/+$/, "")     // 去尾斜杠
+  text = text.replace(/\/v1$/i, "")   // 尾 `/v1` 去（粘贴 OpenAI 形基址）
+  text = text.replace(/\/+$/, "")
+  return /^[a-z][a-z0-9+.-]*:\/\/.+/i.test(text) ? text : null // 纯协议（空 host）⇒ 无效
+}
+
+/** 端标签自动生成（D-TM5）：`端名@主机名`（端名 = 进程端名缝——`sessionEnd()`，cli/vscode/desktop）；
+ *  总长 ≤40 裁剪。零输入字段（表单无标签项）。 */
+export function defaultTeamLabel() {
+  let host = ""
+  try {
+    host = hostname() // os.hostname 失败面兜底（不阻登录）
+  } catch {
+    host = ""
+  }
+  return `${sessionEnd()}@${host}`.slice(0, LABEL_MAX)
+}
+
+/** 登录态读面（桌面 `team:status` ∥ VSC `teamStatus` 投影源）：`loggedIn` ⇔ `team.token` 在场。 */
+export function teamStatus() {
+  const team = loadConfig().team
+  return {
+    loggedIn: Boolean(team?.token),
+    server: team?.server ?? null,
+    member: team?.member ?? null,
+    label: team?.label ?? null,
+  }
+}
+
+/**
+ * 登录态**活校验**（TEAM.md §2.6 ∥ 登录面补全批 · 2026-10-10 · 台账 #1231——本批新增）：`GET <server>/api/client/me`
+ * （Bearer = `team.token`）⇒ **三值闭集**：`{ state: "valid" }`（200——token 有效）∥ `{ state: "invalid" }`（401——
+ * 被吊销 ∥ 无效）∥ `{ state: "unreachable" }`（网络不可达 ∥ 其他非 401 失败——**不判失效**：离线容忍）。
+ * **只读**——零写盘、零状态（调用面持结果）；零周期轮询（触发点制 = 启动一次 ∥ 登/退面开合 ∥ CLI `/team status`）。
+ * token ∥ 地址缺席（未登录 ∥ 畸形档）⇒ `unreachable`（无从校验——不假报失效；端侧未登录面零调本函数）。
+ */
+export async function teamVerify() {
+  const team = loadConfig().team
+  const token = typeof team?.token === "string" && team.token !== "" ? team.token : null
+  const server = typeof team?.server === "string" && team.server !== "" ? team.server : null
+  if (token === null || server === null) return { state: "unreachable" }
+  let res
+  try {
+    res = await fetch(`${server}/api/client/me`, {
+      headers: { authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(TEAM_FETCH_TIMEOUT_MS),
+    })
+  } catch {
+    return { state: "unreachable" } // 不可达 ∥ DNS ∥ TLS ∥ 超时
+  }
+  await res.text().catch(() => {}) // 回执体零消费面（三值只看状态）
+  if (res.status === 200) return { state: "valid" }
+  if (res.status === 401) return { state: "invalid" }
+  return { state: "unreachable" } // 其余（403 ∥ 404 地址非本服务 ∥ 5xx）⇒ 不判失效
+}
+
+/**
+ * 登录（TEAM.md §2.2；三端同构）：请求 `POST <server>/api/client/login` ⇒ 成 ⇒ **一次写盘**（`team` 段 +
+ * 派生条目 upsert）；败 ⇒ 分类出词、零写盘。`label` 缺省 ⇒ 自动生成（`defaultTeamLabel()`）；显式传入
+ * 同口径裁剪 ≤40（服务端 >40 ⇒ 400）。网络面成功但写盘失败 ⇒ `write_failed`（服务端 token 已签发——
+ * 可见于 key 列表，本地未落）。
+ */
+export async function teamLogin({ server = null, username = null, password = null, label = null } = {}) {
+  const base = normalizeTeamServer(server)
+  if (base === null) return { ok: false, reason: "network" } // 无地址可打（端侧表单门兜底面）
+  if (typeof username !== "string" || username === "" || typeof password !== "string" || password === "") {
+    return { ok: false, reason: "credentials" } // 凭据不全（端侧表单门兜底面）
+  }
+  const resolvedLabel = (typeof label === "string" && label.trim() !== "" ? label.trim() : defaultTeamLabel()).slice(0, LABEL_MAX) // 端标签 ≤40 裁剪（显式传入同口径——服务端 >40 ⇒ 400）
+  let res
+  try {
+    res = await fetch(`${base}/api/client/login`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ username, password, label: resolvedLabel }),
+      signal: AbortSignal.timeout(TEAM_FETCH_TIMEOUT_MS),
+    })
+  } catch {
+    return { ok: false, reason: "network" } // 不可达 ∥ DNS ∥ TLS ∥ 超时
+  }
+  if (!res.ok) {
+    await res.text().catch(() => {}) // 错误体零消费面（分类只看状态——零新码）
+    if (res.status === 401) return { ok: false, reason: "credentials" }
+    if (res.status === 429) return { ok: false, reason: "rate_limited" }
+    return { ok: false, reason: "network" } // 404（地址不是本服务）∥ 5xx 等——服务不符合预期面
+  }
+  let body = null
+  try {
+    body = await res.json()
+  } catch {
+    body = null
+  }
+  const token = typeof body?.token === "string" && body.token !== "" ? body.token : null
+  if (token === null) return { ok: false, reason: "network" } // 200 而形不符（代理 ∥ 非本服务应答）
+  const memberInfo = body?.member !== null && typeof body?.member === "object" ? body.member : null
+  const memberUsername = typeof memberInfo?.username === "string" && memberInfo.username !== "" ? memberInfo.username : username
+  const memberName = typeof memberInfo?.name === "string" && memberInfo.name !== "" ? memberInfo.name : memberUsername
+  let notice = null
+  try {
+    const result = persistRaw((raw) => {
+      assertWritableRoot(raw)
+      // 一次 mutate：team 段 + 派生条目（同一次写盘落）
+      raw.team = { server: base, member: { username: memberUsername, name: memberName }, label: resolvedLabel, token }
+      if (!Array.isArray(raw.providers)) raw.providers = []
+      const existing = raw.providers.find((p) => p !== null && typeof p === "object" && p.name === TEAM_PROVIDER_NAME)
+      if (existing !== undefined && existing.derived !== true) {
+        notice = NOTICE_MANUAL_NAME_CONFLICT // 同名手工条目 ⇒ 不覆盖（D-TM4）——登录仍成
+        return
+      }
+      if (existing !== undefined) {
+        existing.baseURL = `${base}/v1`
+        existing.apiKey = token
+        existing.derived = true
+      } else {
+        raw.providers.push({ name: TEAM_PROVIDER_NAME, baseURL: `${base}/v1`, apiKey: token, derived: true }) // 表尾追加
+      }
+    })
+    if (result !== null && result.ok === false) return { ok: false, reason: "write_failed" } // mtime 冲突（F5b——不自动合并）
+  } catch {
+    return { ok: false, reason: "write_failed" } // 畸形档拒写等（writeConfigAtomic fail-closed）
+  }
+  return notice !== null ? { ok: true, notice } : { ok: true }
+}
+
+/**
+ * 退出（TEAM.md §2.3）：`POST <server>/api/client/logout`（best-effort——网络失败 ⇒ 仍清本地）⇒ **一次
+ * 写盘**：摘 `team.token`（server/member/label 留存）+ 摘派生条目 `apiKey`（条目与 `derived` 保留）。
+ * `revokeDelivered:false` = 服务端吊销未达（端侧提示）；401 = token 已失效（视同已送达——照清本地）。
+ */
+export async function teamLogout() {
+  const config = loadConfig()
+  const team = config.team
+  const token = team?.token ?? null
+  const providers = Array.isArray(config.providers) ? config.providers : []
+  const derived = providers.find((p) => p !== null && typeof p === "object" && p.name === TEAM_PROVIDER_NAME && p.derived === true)
+  const hasDerivedKey = typeof derived?.apiKey === "string" && derived.apiKey !== ""
+  let revokeDelivered = true
+  if (token !== null) {
+    if (team.server === null) {
+      revokeDelivered = false // 有 token 无地址 ⇒ 无法吊销（畸形档面）
+    } else {
+      try {
+        const res = await fetch(`${team.server}/api/client/logout`, {
+          method: "POST",
+          headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+          body: "{}",
+          signal: AbortSignal.timeout(TEAM_FETCH_TIMEOUT_MS),
+        })
+        await res.text().catch(() => {})
+        revokeDelivered = res.status === 200 || res.status === 401 // 401 = 已失效（端侧视同「已失效」——照清本地）
+      } catch {
+        revokeDelivered = false // 不可达 ⇒ 本地仍清 + 提示「服务端吊销未达」
+      }
+    }
+  }
+  if (token !== null || hasDerivedKey) {
+    try {
+      const result = persistRaw((raw) => {
+        assertWritableRoot(raw)
+        const section = raw.team
+        if (section !== null && typeof section === "object" && !Array.isArray(section)) delete section.token
+        if (Array.isArray(raw.providers)) {
+          const entry = raw.providers.find((p) => p !== null && typeof p === "object" && p.name === TEAM_PROVIDER_NAME && p.derived === true)
+          if (entry !== undefined) delete entry.apiKey // 条目与 derived 标记保留（重登自动恢复）
+        }
+      })
+      if (result !== null && result.ok === false) return { ok: false, reason: "write_failed" }
+    } catch {
+      return { ok: false, reason: "write_failed" }
+    }
+  }
+  return { ok: true, revokeDelivered }
+}

package/tool-docs/bash.md

@@ -12,6 +12,7 @@ Parameters:
 - command (required): Shell command to execute
 - timeout: Timeout in milliseconds (default 120000, max ~300000)
 - filter: Optional — a regex; only output lines matching it are returned (case-insensitive). Use instead of hand-writing a pipe into `findstr`/`grep`.
+- async: Run in the background (default false) — returns an ack at once (bash#<id>, log path); the result arrives as a digest when the process exits. Depth-0 only.
 {{inject:bash-terminal-face}}
 
 Output format: