thincoder 0.12.68 → 0.12.70

package/CHANGELOG.md

@@ -1,3 +1,35 @@
+## [0.12.70] — 2026-10-04
+
+> 0.12.69 → 0.12.70（连续号——发布时定号）
+
+### Added
+
+- **ACP 面第二批（#870–#873）**：`resource_link`（Zed @ 文件引用——含三降级态）∥ `usage_update` {used,size} + `session/list` updatedAt ISO（超域钳位）∥ 会话身份归一（槽号串 ∥ delete→new 同键处置）∥ `set_config_option` 全量 `configOptions` 回执 + `SessionConfigOption.type` 判别键。
+- **`thincoder ledger list --json`（#886）**：台账只读接口（多项目 ∥ 空集 ∥ 全程只读）；schemaVersion + evidence 默认省。
+- **OpenCode Go 预设（#906）**：`/model` 与配置面开箱可选（双协议侧）。
+
+### Changed
+
+- **核依赖升级**：`@thincoder/core` `^0.10.2` → `^0.10.3`（MCP 自愈 ∥ 环边界中止前置 ∥ 回执汇总行等随核生效）。
+- **会话选定写回默认模型（#883）**：会话内 `/model` 选定 ⇒ `defaultModel` 同拍写回（新会话自动采用；失败不反扑 ∥ 零静默）。
+- **设置面扇出修复（#842）**：设置改动即时生效面收正（免重启）。
+
+### Fixed
+
+- **ACP batch-2 跟进**：delete→new 处置 ∥ `updatedAt` 钳位（T1–T20 + 2 腿全绿）。
+- **Home 启动整盘索引守卫（#867）**：home 检测双触发面 + 假旧引擎版本门（逐字错误 + exit 1）。
+- **TUI-OOM 余项（#863）**：/undo 双上界 ∥ console 采集 cap ∥ advisor 轻量化。
+- **台账幽灵根（#899）**：歧义根发现修复（空壳库不再遮蔽）。
+
+## [0.12.69] — 2026-10-03
+
+> 0.12.68 → 0.12.69（连续号——发布时定号）
+
+### Changed
+
+- **核依赖升级**：`@thincoder/core` `^0.10.1` → `^0.10.2`（统一 provider 解析随核生效）。
+- **无效 provider 态分流（#841）**：TUI——`fallback`（可运行但未设默认模型）⇒ 不弹选择器 + 一行明示（`模型` 缺 ⇒ 词形仅渠道名）；真无效（无 provider ∕ 无 key）⇒ 选择器 + 引导提示行。headless——真无效 ⇒ 可读错误 + 明确退出码；`fallback` ⇒ stderr 一行 + **继续运行**（不退出）。
+
 ## [0.12.68] — 2026-10-03
 
 > 0.12.67 → 0.12.68（连续号——发布时定号）

package/README.md

@@ -17,8 +17,8 @@ resolved from the npm registry for releases).
 - **Checkpoint system**: auto-snapshot before every user task, `list`/`create`/`rewind` tools for the model, single-file restore — rewinding itself is reversible (pre-rewind state auto-saved)
 - **Codebase understanding** ⭐0.5.0: `repo_outline` (dependency outline, auto-injected at startup), `code_search` (source FTS5 + vectors + JSDoc extraction), `doc_search` (docs chunked by ## headings) — background indexing, auto-incremental updates on file writes, three tools
 guided by "structure → intent → details"
-- **Model adaptation** ⭐: top-tier only, latest only. Built-in flagship models from twenty-two providers — DeepSeek / Kimi / Kimi For Coding / GLM / GLM Coding Plan (智谱 Coding) / Qwen / Qwen Token Plan / MiMo (小米) / MiMo Token Plan (小米套餐) / MiniMax / OpenAI / Claude / Gemini /
-Grok / Mistral / Volcengine Ark (豆包) / Hunyuan (腾讯混元) / Tencent TokenHub (腾讯混元网关) / Huawei Cloud MaaS (华为云 MaaS) / SiliconFlow (硅基流动) / OpenRouter / Groq. No legacy model compatibility. Auto-matched context windows, truncation-resume protocols (prefix/partial), thinking-mode APIs (thinking.type /
+- **Model adaptation** ⭐: top-tier only, latest only. Built-in flagship models from twenty-four providers — DeepSeek / Kimi / Kimi For Coding / GLM / GLM Coding Plan (智谱 Coding) / Qwen / Qwen Token Plan / MiMo (小米) / MiMo Token Plan (小米套餐) / MiniMax / OpenAI / Claude / Gemini /
+Grok / Mistral / Volcengine Ark (豆包) / Hunyuan (腾讯混元) / Tencent TokenHub (腾讯混元网关) / Huawei Cloud MaaS (华为云 MaaS) / SiliconFlow (硅基流动) / OpenRouter / Groq / OpenCode Go (same key for both protocol sides: OpenAI-compatible + Anthropic Messages). No legacy model compatibility. Auto-matched context windows, truncation-resume protocols (prefix/partial), thinking-mode APIs (thinking.type /
 reasoning_effort), reasoning_content echo strategies (reasoningEcho), output limits, temperature range clamping — all deeply adapted.
 - **Toolset**: `read` / `write` / `edit` / `bash` / `glob` (supports `**`) / `grep` / `websearch` / `ls` / `fetch` + `read_image` (image/video paste) + three retrieval tools + MCP — all zero-dependency, file tools confined to the working directory
 - **Memory system**: three layers (personal/project/team), FTS5 + vector RRF hybrid retrieval, git-friendly markdown format
@@ -57,7 +57,7 @@ Three layers, all "query if present, skip if absent", unified hybrid retrieval:
   - IDE-native diffs — `write`/`edit` route through the editor buffer
   - Persisted sessions: list / load (history replay) / resume / delete
   - Per-session config: model / thinking / mode
-  - Setup: [ACP 接入设计](../docs/cli/design/ACP-CLIENT.md)
+  - Setup: [ACP 接入指南](https://thincoder.com/acp.html)
   - Login: `thincoder acp --login` — one interactive terminal login; ACP clients and orchestrators then drive sessions headlessly
 
 
@@ -231,6 +231,18 @@ Code conventions: pure `.mjs`, no semicolons, no third-party npm dependencies al
 
 ## Changelog
 
+### 0.12.70 (2026-10)
+- **ACP face round 2 (#870–#873)** — `resource_link` (@ file references from Zed, with three graceful degradations); `usage_update` `{used,size}` + ISO `updatedAt`; stable session identity (slot-key ids, delete→new); `set_config_option` returns full `configOptions` + a `type` discriminator.
+- **`thincoder ledger list --json` (#886)** — read-only ledger interface (multi-project / empty set / fully read-only).
+- **OpenCode Go presets (#906)** — `opencode-go` / `opencode-go-anthropic` available in `/model` and config (dual-protocol sides).
+- **Session-default model carryover (#883)** — picking a model inside a session writes it back as `defaultModel` for new sessions (no silent failures).
+- **Core `^0.10.3`** — MCP 404 self-heal, turn-loop abort front-guards (Stop wins over the continue prompt), big edit-receipt summary line, manifest unknown-keys warning.
+- Fixed: ACP batch-2 follow-ups (delete→new disposal, `updatedAt` clamp); Home full-index version gate (#867); `/undo` bounds, console cap, advisor lightweighting (#863); ledger ghost-root discovery (#899).
+
+### 0.12.69 (2026-10)
+- **Provider-state unify (#841)** — one core resolution for the three ends (slot → `defaultModel` → first keyed channel) with three states: `ok`; `fallback` (runnable but no default model — one clear notice line, never blocked); `invalid` (no provider/key — guided picker; headless exits with a readable message and a clear code, while `fallback` prints one stderr line and keeps running). No more false "API key not configured" on a working channel.
+- **Core `^0.10.2`** — unified provider resolution (`resolveProviderPlan` / `resolveChannelModel`), `providerState` / `providerStateReason` keys, slot key gate.
+
 ### 0.12.68 (2026-10)
 - **Idle wake** — suspended sessions wake to timers: they resume on schedule (visibility surface + abort accommodation).
 - **Ledger health signals** — an unhealthy ledger database now shows a warning line in the TUI (empty values render as `—`).

package/bin/node-version-gate.cjs

@@ -0,0 +1,28 @@
+/**
+ * node-version-gate.cjs — Node.js 主版本运行期校验（fail-fast · 2026-10-04 · 台账 #867 ∥ `docs/cli/design/CLI-ENTRY.md` §1）。
+ *
+ * 执行点 = `bin/thincoder.cjs`（shim）**首行**——先于 `.mjs` 链任何 ESM 静态 import 求值；不满足 ⇒
+ * 一行显式错误（当前版本 + 要求）+ `exit 1`（`node:sqlite` 等核 API 在旧版行为不可期）。
+ * 纯函数 `nodeVersionError(version = process.versions.node)` 版本串入参 ⇒ 供直测假版本；
+ * 零依赖（主版本整数比较）。射程 = npm bin 入口（`node bin/thincoder.mjs` 直跑 = 开发 ∥ 测试面）。
+ */
+"use strict"
+
+const REQUIRED_MAJOR = 24
+
+/** 版本串 ⇒ `null`（达标：主版本 ≥ 24）∥ 逐字一行错误串（不达标 —— 含不可解析版本串）。 */
+function nodeVersionError(version = process.versions.node) {
+  const major = Number.parseInt(String(version), 10)
+  if (Number.isInteger(major) && major >= REQUIRED_MAJOR) return null
+  return `thincoder requires Node.js >= 24 (current: ${version})`
+}
+
+/** 执行门（shim 首行调用）：不达标 ⇒ 一行错误 + `exit 1`；达标 ⇒ 静默返回。 */
+function enforceNodeMajor() {
+  const error = nodeVersionError()
+  if (error === null) return
+  console.error(error)
+  process.exit(1)
+}
+
+module.exports = { nodeVersionError, enforceNodeMajor }

package/bin/thincoder.cjs

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
 // CommonJS shim — npm 12 may reject ESM bin entries.
 // This is a tiny CJS wrapper that delegates to the real .mjs entry point.
+// #867：Node 主版本前置校验（fail-fast——先于 `.mjs` 链任何 ESM 静态 import 求值）。
+require("./node-version-gate.cjs").enforceNodeMajor()
 import("./thincoder.mjs")

package/bin/thincoder.mjs

@@ -136,6 +136,8 @@ Usage:
                             messages / tool calls + coverage + size; --rebuild reindexes every session file
   thincoder ledger migrate --dry-run | --confirm   Ledger variant-key merge (dry-run report / backup then import; source recycled)
   thincoder ledger audit                           Read-only ledger dir audit (classify every db + suggestions)
+  thincoder ledger list --json [--full] [--family] [--cwd <dir>]
+                            Read-only ledger export as single-segment JSON (--full adds evidence; --family exports the discovered family)
   thincoder upgrade         Update to the latest version from npm
   thincoder completion <sh>  Generate shell completion script (bash / zsh / fish)
   thincoder -v, --version   Print version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.68",
+  "version": "0.12.70",
   "description": "Thin coding agent - zero third-party dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",
@@ -20,7 +20,7 @@
     "node": ">=24"
   },
   "dependencies": {
-    "@thincoder/core": "^0.10.1"
+    "@thincoder/core": "^0.10.3"
   },
   "files": [
     "bin/",

package/src/acp/bridge.mjs

@@ -5,9 +5,13 @@
  * Wire shapes verified against the ACP schema v1 + kimi acp-adapter:
  * - agent text   → `agent_message_chunk`  { content: { type: "text", text } }
  * - thinking     → `agent_thought_chunk`  (same content shape)
+ * - subagent ev  → `session_info_update` { _meta: { "thincoder.dev/subagent":
+ *                  { role, id, state, progress?, detail? } } } (event token behind the relay
+ *                  prefix — the text face stays stripped; §12 extension contract)
  * - tool start   → `tool_call`  { toolCallId, title, kind, status: "in_progress", rawInput, content }
  * - tool result  → `tool_call_update`  { toolCallId, status: "completed"|"failed", content } (REPLACE semantics)
- * - usage        → `usage_update` { usage }
+ * - usage        → `usage_update` { used, size } (used = prompt + completion tokens;
+ *                  size = the model's context window — providerSpec single source)
  * - permission   → reverse-RPC request `session/request_permission`
  *                  { sessionId, options, toolCall } → client responds with
  *                  { outcome: { outcome: "selected", optionId } | { outcome: "cancelled" } }
@@ -25,6 +29,11 @@ import { computeEditEntry, validateEditEntry, assertEditArgsExclusive, assertEdi
 import { parseRelayPath } from "@thincoder/core/agent/relay-prefix.mjs"
 // 批 1 CORE-DEFECT-FIXES B3：onWait 相位值域 + 文案单源（本面仅日志——PROVIDER.md §6.20）
 import { waitStatusText } from "@thincoder/core/provider/wait-status.mjs"
+// §2.1（ACP-PROTOCOL-COMPLIANCE）：usage_update.size = 模型上下文窗口单源（含 providers[].context 覆写）。
+import { providerSpec } from "@thincoder/core/config.mjs"
+// 2026-10-04 批（ACP 协议面补全）：事件 token 文法单源（形态判据 ∥ 逐事件投影——
+// ACP-CLIENT.md §12.4）——剥离判据经本调用唯一决定，本档不再自持 ⟦ev⟧ 判据副本。
+import { parseSubagentEvent } from "@thincoder/core/agent/subagent-event.mjs"
 
 /** ACP ToolKind inference (schema v1 enum) — best-effort, clients render by kind. */
 function inferToolKind(name) {
@@ -52,14 +61,31 @@ function permissionToBoolean(response) {
   return false
 }
 
+/** §12.2（ACP-CLIENT.md）：`_meta` 扩展键——命名空间防保留键碰撞（对外契约逐字）。 */
+const SUBAGENT_META_KEY = "thincoder.dev/subagent"
+
+/** 事件 token → `_meta["thincoder.dev/subagent"]` 载荷（§12.2 形状冻结——无值键缺席：
+ *  progress/detail 键只在有值时在场；`state` = 事件名原文，形态域开集）。
+ *  role/id = relay 前缀**最内段**（嵌套 `explore#1/eng-coder#2/…` ⇒ `eng-coder`/2——
+ *  段形 `role#id` 由 parseRelayPath 保证）。 */
+function subagentMetaPayload(path, ev) {
+  const inner = path.inner.length > 0 ? path.inner[path.inner.length - 1] : path.head
+  const [role, id] = inner.split("#")
+  const meta = { role, id: Number(id), state: ev.name }
+  if (ev.progress) meta.progress = ev.progress
+  if (ev.detail) meta.detail = ev.detail
+  return meta
+}
+
 /**
  * Build the runAgent callbacks for an ACP session.
- * @param {{ sessionId: string, notify: (m, p) => void, request: (m, p, o?) => Promise<any>, log?: (s) => void,
+ * @param {{ sessionId: string, agent?: object, notify: (m, p) => void, request: (m, p, o?) => Promise<any>, log?: (s) => void,
  *           clientCaps?: { fs?: { readTextFile?: boolean, writeTextFile?: boolean } } }} deps
- *   `clientCaps` = the §3.4 snapshot (taken at `session/new`); capabilities omitted by the
+ *   `agent` = 会话的活引用（§2.4——`set_config_option` 切模型后 `usage_update.size` 随动；
+ *   不得在构造期固化数值）；`clientCaps` = the §3.4 snapshot (taken at `session/new`); capabilities omitted by the
  *   client are UNSUPPORTED ⇒ the fs reverse-RPC face stays local (§11.4 — never 30s 干等).
  */
-export function buildAcpCallbacks({ sessionId, notify, request, log = () => {}, clientCaps = {} }) {
+export function buildAcpCallbacks({ sessionId, agent, notify, request, log = () => {}, clientCaps = {} }) {
   const update = (sessionUpdate, extra = {}) =>
     notify("session/update", { sessionId, update: { sessionUpdate, ...extra } })
   // §11.4 fs 能力位（默认 false——文档「MUST treat all capabilities omitted … as UNSUPPORTED」）；
@@ -188,13 +214,18 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {},
       // TUI/webview display signal, not conversation content, and must not reach ACP clients.
       if (/^\[model\]/.test(payload)) return
       // D7 + 批 1 B2/D13（ACP-CLIENT.md §7.2）：剥离判据 = **形态**（`⟦ev⟧<小写名>` + RS
-      // 终止符同现），不再枚举事件名——枚举是漏项发生器（`queued` / `cancelled` 发射点在位
-      // 而白名单未跟 ⇒ 随 agent_message_chunk 泄漏给客户端）。终止符约束 load-bearing：
-      // 放宽为无终止符形态会吞真实正文（先例教训见 src/tui/render.mjs:250-252）。
-      // 事件 token 是 TUI 显示信号；结构化 ACP 映射（tool_call_update）另行跟踪
-      // （docs/TODO.md）。
-      // 有意为之：控制字符协议/转义序列剥离正则（ANSI/⟦ev⟧/SGR/history 双线分隔）
-      if (/^⟦ev⟧[a-z]+\x1e/.test(payload)) return
+      // 终止符同现）——枚举是漏项发生器（`queued` / `cancelled` 发射点在位而白名单未跟 ⇒
+      // 随 agent_message_chunk 泄漏给客户端）。终止符约束 load-bearing：放宽为无终止符形态
+      // 会吞真实正文（先例教训见 src/tui/render.mjs:250-252）。
+      // 判据单源 = 核模块 `subagent-event.mjs`（2026-10-04 批统一——桥内联式退役，剥离语义
+      // 零改）：`parseSubagentEvent` 非空 ⇒ 剥；§12 结构化发射 = 同一调用取投影载荷。
+      const ev = parseSubagentEvent(payload)
+      if (ev) {
+        // §12.1 发射规则：relay 前缀在场 ⇒ **增量**一条 `session_info_update`（文本面剥离
+        // 照旧——零 `agent_message_chunk`）；无前缀 ⇒ 仅剥离零发射（防御面）。
+        if (path) update("session_info_update", { _meta: { [SUBAGENT_META_KEY]: subagentMetaPayload(path, ev) } })
+        return
+      }
       if (!payload) return // D6：剥后空载荷不发通知（防噪声空 chunk）
       update("agent_message_chunk", { content: { type: "text", text: payload } })
     },
@@ -205,7 +236,14 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {},
       if (!payload) return
       update("agent_thought_chunk", { content: { type: "text", text: payload } })
     },
-    onUsage: (usage) => update("usage_update", { usage }),
+    // §2.1（ACP-PROTOCOL-COMPLIANCE）：`UsageUpdate.required = ["used","size"]`——
+    // used = 本轮 prompt + completion（量级近似「当前在上下文中的 token」）；size = 模型上下文
+    // 窗口（`providerSpec` 单源——含 providers[].context 覆写；未知模型 128_000 兜底）。
+    // agent 为活引用：切模型后 size 随动（不得构造期固化）。
+    onUsage: (usage) => update("usage_update", {
+      used: (usage?.prompt_tokens ?? 0) + (usage?.completion_tokens ?? 0),
+      size: providerSpec(agent?.provider).context,
+    }),
     onWait: (ev) => {
       const s = waitStatusText(ev)
       if (s) log(`[rate-limit] ${s}`)

package/src/acp/handlers-session.mjs

@@ -1,8 +1,9 @@
 /**
  * handlers-session.mjs — in-memory ACP session family (ACP-CLIENT.md §3.5):
  * `session/{new,prompt,cancel,close,set_mode,set_config_option}` + `findSession` /
- * `applyConfigOption` + the shared credential gate consumed by every gated handler
- * across the four handler modules (§11.5).
+ * `applyConfigOption` / `sessionConfigOptions`（configOptions 全形投影单源——四响应 + 两通知）/
+ * `createSlotReleaser`（认领释放单点——close ∥ load/resume 替换同源）+ the shared credential
+ * gate consumed by every gated handler across the four handler modules (§11.5).
  *
  * 认证门 = **凭据状态即时判据**（§11.2 改法① / D15——撤 `authenticated` 闩锁）：
  * 受门 handler 首行求值，真 ⇒ 放行、假 ⇒ `-32000`。客户端可以不调 `authenticate`
@@ -13,7 +14,7 @@
  * 释放该会话认领（保留集 = 本进程其余在存会话的活绑定槽，同 cwd；落盘判据三条沿用）。
  */
 import { resolve } from "node:path"
-import { loadManifest, normalizeCwd, bindRecordStore, newSession, saveManifest, slotPath } from "@thincoder/core/session.mjs"
+import { loadManifest, normalizeCwd, bindRecordStore, deleteSlot, newSession, saveManifest, slotPath } from "@thincoder/core/session.mjs"
 // 认领释放谓词单源（SESSION.md §6.2 / §6.16——与 VSC 端壳 `releaseClaimsAll` 同源档；
 // core `session.mjs` 未 re-export 该名——直引 manifest 档，先例 = `thincoder-vscode/src/extension/session-io.mjs`）。
 import { staleClaims } from "@thincoder/core/session-slots-manifest.mjs"
@@ -22,18 +23,53 @@ import { PLAN_ENGINEERING_REFUSED } from "@thincoder/core/agent-tools/plan.mjs"
 import { thinkOffShape } from "@thincoder/core/think-off.mjs"
 import { providerSpec } from "@thincoder/core/config.mjs"
 import { ACP_ERRORS } from "./transport.mjs"
+// §2.5（ACP-PROTOCOL-COMPLIANCE）：prompt 内容块聚合（resource_link 内联 ∥ 降级标记——基线 MUST）。
+import { buildPromptText } from "./resource-link.mjs"
 
 /** ENG-PLAN-EXCLUSION（FR31 ② · E7「命令面逐面钉定」）：工程真值 = 核单源同键
  *  `agent.config.agent.engineering`。 */
 const isEngineering = (agent) => agent?.config?.agent?.engineering === true
 
-/** Session-level config options exposed to clients — schema `SessionConfigOption.required = ["id","name"]`
- *  (响应侧用 `id`；请求侧 `SetSessionConfigOptionRequest` 用 `configId`——不对称属契约本身 · §11.3 G2-8). */
-export const CONFIG_OPTIONS = [
-  { id: "model", name: "Model" },
-  { id: "thinking", name: "Thinking" },
-  { id: "mode", name: "Mode" },
-]
+/** configOptions 全形单源投影（§2.3——四处响应 + 两处通知同源）：`SessionConfigOption` =
+ *  `required [id,name]` + oneOf select/boolean 判别键 `type`（select 另需 `currentValue` + `options[]`；
+ *  boolean 需 `currentValue`）；带**现值**投影（静态常量不可——`currentValue` 就地失真）。
+ *  `model` 项在模型不可解析时**缺席**（`currentValue` 必填——无值不可虚构）；`thinking` 现值 =
+ *  「非 off 形」（off 两形 = `null`（effort 族）∥ `{type:"disabled"}`；含自定义开值族——
+ *  §11 语义登记：`undefined`（未显式设置）⇒ `false`，不发服务端生效态探测）；数组序 =
+ *  model（在位时）→ thinking → mode。 */
+export function sessionConfigOptions(agent) {
+  const opts = []
+  const model = agent?.provider?.model
+  if (typeof model === "string" && model) {
+    const provider = agent?.provider?.name
+    const value = provider ? `${provider}:${model}` : model
+    opts.push({ id: "model", name: "Model", type: "select", currentValue: value, options: [{ value, name: value }] })
+  }
+  const th = agent?.provider?.thinking
+  opts.push({ id: "thinking", name: "Thinking", type: "boolean", currentValue: th != null && th.type !== "disabled" })
+  opts.push({ id: "mode", name: "Mode", type: "select", currentValue: agent?.planMode ? "plan" : "normal",
+    options: [{ value: "normal", name: "Normal" }, { value: "plan", name: "Plan" }] })
+  return opts
+}
+
+/** 认领释放单点（§2.4 提取；#168① 公式——SESSION.md §6.15 / §6.16 · 2026-09-22 定裁）：
+ *  释放 A ⟺ `slotSessions[A]` 为本进程 ∧ `A ∉ 保留集`；**保留集 = 本进程其余在存会话的活
+ *  绑定槽**（同 cwd——ACP 单 cwd 模型）。取值点：会话记录容器 = `ctx.sessions`
+ *  （`Map<id, session>`——`thincoder-cli/src/acp.mjs` 单容器）；槽值 = `session.agent._slot`
+ *  （认领写入同源 = `handlers-slots.mjs` load/resume 钉槽 / 本档 `session/new` 认领点）。
+ *  调用点三处同源消费 = close ∥ load 替换 ∥ resume 替换（`acp.mjs` 建一次入
+ *  `ctx.releaseClosedSlot`——同 `requireConfigured` 先例）。落盘判据三条由核 `saveManifest`
+ *  `opts.release` 自动继承（fresh 同次快照 / 值条件删除 / 内存认领表移除）——**零新增写盘
+ *  路径**；本进程无残留认领 ⇒ 零写早退（判据单源 `staleClaims`——同核 `releaseClaimsAll` 早退形）。 */
+export function createSlotReleaser({ getCwd, sessions }) {
+  return () => {
+    const cwd = getCwd()
+    const m = loadManifest(cwd)
+    const keep = [...sessions.values()].map((s) => s.agent?._slot).filter((slot) => slot != null)
+    if (staleClaims(m, keep).length === 0) return
+    saveManifest(cwd, m, null, { release: keep })
+  }
+}
 
 /**
  * Credential gate (§11.5 判据拆分 · 评审 #1). Evaluated per call — **no cross-call latch**.
@@ -111,12 +147,11 @@ export function applyConfigOption(agent, configId, value) {
 
 /**
  * Build the in-memory session family. Shared state arrives via the single `ctx`
- * (§3.5 — `{ getCwd, sessions, allocSessionId, notifyRef, requestRef, createSession,
- * requireConfigured, log }`), so the id allocator and the slot family stay on one
- * namespace.
+ * (§3.5 — `{ getCwd, sessions, notifyRef, requestRef, createSession, requireConfigured,
+ * releaseClosedSlot, log }`)；会话 id = 持久槽位号串（load/new 同命名空间——G5 收正）。
  */
 export function createSessionHandlers(ctx) {
-  const { getCwd, sessions, allocSessionId, notifyRef, requestRef, createSession, requireConfigured, log } = ctx
+  const { getCwd, sessions, notifyRef, requestRef, createSession, requireConfigured, releaseClosedSlot, log } = ctx
 
   const findSession = (params) => {
     const s = sessions.get(String(params?.sessionId))
@@ -124,22 +159,6 @@ export function createSessionHandlers(ctx) {
     return { session: s }
   }
 
-  /** #168①（SESSION.md §6.15 / §6.16——2026-09-22 定裁 · 台账 #168①）：`session/close` ⇒
-   *  释放被关闭会话的槽认领。公式代入：释放 A ⟺ `slotSessions[A]` 为本进程 ∧ `A ∉ 保留集`；
-   *  **保留集 = 本进程其余在存会话的活绑定槽**（同 cwd——ACP 单 cwd 模型）。取值点（实施轮定位报告）：
-   *  会话记录容器 = `ctx.sessions`（`Map<id, session>`——`thincoder-cli/src/acp.mjs:98` 单容器）；
-   *  槽值 = `session.agent._slot`（认领写入同源 = `handlers-slots.mjs:96-100` / `:151-155` /
-   *  `handlers-session.mjs` 的 newSession 认领点）。落盘判据三条由核 `saveManifest` `opts.release`
-   *  自动继承（fresh 同次快照 / 值条件删除 / 内存认领表移除）——**零新增写盘路径**；本进程无残留认领
-   *  ⇒ 零写早退（判据单源 `staleClaims`——同核 `releaseClaimsAll` 早退形）。 */
-  const releaseClosedSessionSlot = () => {
-    const cwd = getCwd()
-    const m = loadManifest(cwd)
-    const keep = [...sessions.values()].map((s) => s.agent?._slot).filter((slot) => slot != null)
-    if (staleClaims(m, keep).length === 0) return
-    saveManifest(cwd, m, null, { release: keep })
-  }
-
   return {
     "session/new": async (params) => {
       const gate = requireConfigured()
@@ -163,12 +182,20 @@ export function createSessionHandlers(ctx) {
       if (params.mcpServers?.length) {
         log(`[acp] MCP forwarding is M2 scope — ignoring ${params.mcpServers.length} server(s)`)
       }
+      // §2.4（G5 收正）：**先认领持久槽**——`createSession` 的 id 在构造期烧入 callbacks，
+      // 而 id = 槽号串（`String(slot)`——全族单一命名空间），故认领必须先于装配。
+      // 失败回滚（新序引入的孤儿面——必处置）：装配抛错 ∥ `_providerInvalid` ⇒ `deleteSlot`
+      // （文件 + manifest 条目 + 认领由核单点清理）；`committed` 旗标守卫——`sessions.set`
+      // 之后不回滚（在存会话的槽不因尾段异常被误删）。
+      let slot = null
+      let committed = false
       try {
-        const id = allocSessionId()
+        slot = await newSession(getCwd())
+        const id = String(slot)
         const session = await createSession({ id, notify: notifyRef.current, request: requestRef.current, log })
         // §11.5 装配后检查（兜底，与门互补）：门拦「key 缺失 / defaultModel 不可解析」；
         // 本行拦「门放行但 provider 仍不可用」的残余（如 defaultModel 可解析而 provider 缺
-        // baseURL）——显式报错而**不建半死会话**（槽未认领、sessions 未登记——无半态）。
+        // baseURL）——显式报错而**不建半死会话**（槽已认领 ⇒ 由 finally 回滚撤除——无半态）。
         if (session?.agent?._providerInvalid) {
           return {
             error: {
@@ -182,15 +209,36 @@ export function createSessionHandlers(ctx) {
         // 走 _slot ??= activeSlot() → ensureActive 早退分支（slotSessions[active]===
         // mySessionId 同进程恒真）→ 第二个会话拿到与第一个相同的槽号 → 双写同槽
         // F2 互旋。getSessionId() 是进程级，_slot 是 agent 级——粒度错配必须在此切断。
-        session.agent._slot = await newSession(getCwd())
+        session.agent._slot = slot
         // TUI-OOM-ROOTCAUSE（SESSION.md §6.14）：新建槽绑定记录存储（baseHistory 空——
         // identity 待固化）——与 /new 同语义
         bindRecordStore(session.agent, { slotFile: slotPath(getCwd(), session.agent._slot), identity: session.agent._sessionStart ?? null, baseHistory: [] })
+        // §2.4 new 途处置点钉定（delete→new 槽号回收面 · 修正轮）：`session/delete` 删档后槽号
+        // 回流，`session/new` 复得同号时会撞**同键在存实例**（键 = 槽号串而 `_slot` 已与键分离
+        // 的旧实例不受 delete 重钉环处置——`handlers-slots.mjs` 按 `_slot` 匹配）——close 同法
+        // 处置：cancel ∥ 删键。位次 = `sessions.set` 直前——此前任何一步失败均不改动旧实例。
+        const stale = sessions.get(id)
+        if (stale) {
+          stale.cancel()
+          sessions.delete(id)
+        }
         sessions.set(id, session)
-        // §11.3 G2-5：NewSessionResponse.required = ["sessionId"]（`id` / `configId` 键已收正）
-        return { sessionId: id, configOptions: [...CONFIG_OPTIONS] }
+        committed = true
+        // §2.4 new 途认领释放位次（修正轮）：置于 `sessions.set`/`committed` 之后——保留集须含
+        // 新会话槽（`createSlotReleaser` 保留集 = 在存 Map 槽）；先释后装会把 `newSession` 刚写
+        // 的新认领当残留释放（`staleClaims` 谓词）⇒ 复开 F2 双写窗口；置 committed 后 ⇒ 释放
+        // 失败不误删已建会话（finally 回滚仅对未 committed 生效）。
+        if (stale) releaseClosedSlot()
+        // §11.3 G2-5：NewSessionResponse.required = ["sessionId"]（`id` / `configId` 键已收正）；
+        // configOptions = 全形（§2.3 单源投影）。
+        return { sessionId: id, configOptions: sessionConfigOptions(session.agent) }
       } catch (e) {
         return { error: { code: ACP_ERRORS.INTERNAL.code, message: `failed to create session: ${e.message}` } }
+      } finally {
+        if (slot != null && !committed) {
+          try { deleteSlot(getCwd(), slot) }
+          catch (e) { log(`[acp] failed to roll back slot ${slot} after a failed session/new: ${e.message}`) }
+        }
       }
     },
 
@@ -199,11 +247,12 @@ export function createSessionHandlers(ctx) {
       if (gate.error) return gate
       const found = findSession(params)
       if (found.error) return found
-      // §11.3 G2-6：PromptRequest.required = ["sessionId","prompt"]（`prompt` = ContentBlock[]）——
-      // 读取位置由 `params.content` 收正为 `params.prompt`；取块策略不变（首个 text 块——G6 登记项）。
+      // §11.3 G2-6：PromptRequest.required = ["sessionId","prompt"]（`prompt` = ContentBlock[]）
+      // ——读取位置由 `params.content` 收正为 `params.prompt`；§2.5：首个**合法** text 块 +
+      // resource_link 内联（基线 MUST——逐块失败降级不中断，标记内联）。
       const blocks = Array.isArray(params?.prompt) ? params.prompt : []
-      const text = blocks.find((b) => b?.type === "text")?.text ?? ""
-      if (!text) return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: "prompt requires a text content block" } }
+      const text = await buildPromptText(blocks, { cwd: getCwd() })
+      if (!text) return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: "prompt requires a text or resource_link content block" } }
       try {
         await found.session.run(text)
         return { stopReason: "end_turn" }
@@ -234,7 +283,7 @@ export function createSessionHandlers(ctx) {
         found.session.cancel()
         // 先出容器再释放（保留集 = 其余在存会话——被关闭者不留在保留集内）。
         sessions.delete(String(params.sessionId))
-        releaseClosedSessionSlot() // #168①：释放该会话认领（保留集 = 同 cwd 其余在存会话槽）
+        releaseClosedSlot() // #168①：释放该会话认领（保留集 = 同 cwd 其余在存会话槽）
         log(`session ${params.sessionId} closed by client`)
       }
       return {}
@@ -260,12 +309,13 @@ export function createSessionHandlers(ctx) {
       if (!applied) {
         return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: `unknown configId: ${configId}` } }
       }
-      // Last-write-wins on the internal state; notify the client of the change.
+      // Last-write-wins on the internal state；§2.4：通知 = `ConfigOptionUpdate.required =
+      // ["configOptions"]`——**全量数组**（非增量 `{configId,value}`）；响应同源全形（§2.3）。
       notifyRef.current("session/update", {
         sessionId: String(params.sessionId),
-        update: { sessionUpdate: "config_option_update", configId, value },
+        update: { sessionUpdate: "config_option_update", configOptions: sessionConfigOptions(found.session.agent) },
       })
-      return {}
+      return { configOptions: sessionConfigOptions(found.session.agent) }
     },
 
     "session/set_mode": (params) => {
@@ -282,9 +332,10 @@ export function createSessionHandlers(ctx) {
         return { error: { ...ACP_ERRORS.INVALID_PARAMS, message: PLAN_ENGINEERING_REFUSED } }
       }
       found.session.agent.planMode = params.mode === "plan"
+      // §2.4：`CurrentModeUpdate.required = ["currentModeId"]`（`mode` 键与 schema 相抵——字段收正）。
       notifyRef.current("session/update", {
         sessionId: String(params.sessionId),
-        update: { sessionUpdate: "current_mode_update", mode: params.mode },
+        update: { sessionUpdate: "current_mode_update", currentModeId: params.mode },
       })
       return {}
     },

package/src/acp/handlers-slots.mjs

@@ -3,13 +3,14 @@
  * `session/{list,load,resume,delete}` + the #41 engineering-manifest predicate
  * helpers (`slotEngineering` / `reattach`).
  *
- * id 命名空间边界（§11.3 · 评审 #7——本批只改字段名、不改语义）：本族按**持久化槽位号**
- * 解析 `params.sessionId`（`Number(params.sessionId)`）；而 `session/prompt` / `cancel` /
- * `close` / `set_*` 认的是 **ACP 会话 id**（入口分配器——与槽位号不同物，§6.1）⇒
- * 把 `session/list` 的输出直喂 `session/prompt` 仍会 `unknown session`（原 G5，本批不做）。
+ * id 语义（§2.4 · G5 收正）：**全族单一命名空间**——`session id = 持久槽位号字符串`。
+ * 本族按槽位号解析 `params.sessionId`（`Number(...)`——list/load/resume/delete）；
+ * `session/prompt` / `cancel` / `close` / `set_*` 认的 id 同源 = `session/new` 的槽号串 /
+ * load/resume 沿用的**客户端原文 id**（同字面读回即可命中）⇒ `session/list` 输出可直喂
+ * 全族方法（不变量：`session/new` 返回 id ∈ 随后 list 集）。
  */
 import { ACP_ERRORS } from "./transport.mjs"
-import { CONFIG_OPTIONS } from "./handlers-session.mjs"
+import { sessionConfigOptions } from "./handlers-session.mjs"
 import { loadConfig } from "@thincoder/core/config.mjs"
 import { resolveEngineeringManifest } from "@thincoder/core/manifest.mjs"
 import { replayHistory } from "./bridge.mjs"
@@ -17,7 +18,7 @@ import { listSlots, applySession, deleteSlot, loadSlotFile, slotOccupancy, loadM
 
 /** Build the persisted-slot family. Shared state arrives via the single `ctx` (§3.5). */
 export function createSlotsHandlers(ctx) {
-  const { getCwd, sessions, allocSessionId, notifyRef, requestRef, createSession, requireConfigured, log } = ctx
+  const { getCwd, sessions, notifyRef, requestRef, createSession, requireConfigured, releaseClosedSlot, log } = ctx
 
   /** #41 翻转族合值判据（MANIFEST.md §2.8 F3 触发条件口径 = §2.2 会话权威值）：「槽带
    *  `engineering` 字段 ? 槽值 : config 回退」。本路装配期（`applySession` 之前）无会话
@@ -43,13 +44,19 @@ export function createSlotsHandlers(ctx) {
       if (gate.error) return gate
       const slots = listSlots(getCwd())
       return {
-        // §11.3 G2-7：SessionInfo.required = ["sessionId","cwd"]（条目键 `id` 已收正）
+        // §11.3 G2-7：SessionInfo.required = ["sessionId","cwd"]（条目键 `id` 已收正）；
+        // §2.2：updatedAt = ISO 8601 字符串（核 `listSlots` 发出 epoch ms——此处收正）；
+        // 值域钳（修正轮——防 `toISOString` RangeError ⇒ list 整方法 -32603）：有限 ∧
+        // `|v| <= 8.64e15`（ECMA-262 TimeClip 上限）⇒ ISO；非法 ∥ 超域 ⇒ `undefined`
+        //（JSON 序列化 ⇒ 键缺席——null 语义；不用 epoch 0 占位——0 谎报 1970）；
+        // `messageCount` 剔除（非 SessionInfo 字段——无 schema 位）。
         sessions: slots.map((s) => ({
           sessionId: String(s.slot),
           cwd: getCwd(), // single-cwd model (design §4.5)
-          updatedAt: s.updatedAt ?? 0,
+          updatedAt: Number.isFinite(s.updatedAt) && Math.abs(s.updatedAt) <= 8.64e15
+            ? new Date(s.updatedAt).toISOString()
+            : undefined,
           title: s.title ?? "",
-          messageCount: s.messageCount ?? 0,
         })),
       }
     },
@@ -76,7 +83,18 @@ export function createSlotsHandlers(ctx) {
         }
       }
       try {
-        const id = allocSessionId()
+        // §2.4（G5 收正）：会话 id = **客户端原文形态**（同值读回保续——`"008"` 类非规范
+        // 字面按原文注册，同字面读回即可命中）；同 id 在存 ⇒ 替换（close 同法——置换点在
+        // 既有前置判据之后、`createSession` 之前：拒载路径零副作用，旧实例保留不误杀在飞
+        // 回合）。置前理由：① 旧实例的钉槽不再计入 `sameProcessPinned`（重载同槽 ⇒ 可正常
+        // 钉回原槽，不误 fork）；② 防旧实例成为不可达孤儿（同 id 在 Map 上唯一）。
+        const id = String(params.sessionId)
+        const stale = sessions.get(id)
+        if (stale) {
+          stale.cancel()
+          sessions.delete(id)
+          releaseClosedSlot()
+        }
         const session = await createSession({ id, notify: notifyRef.current, request: requestRef.current, log })
         // 2026-08-31 advisor round2 🟡：钉 _slot 前查活主——目标槽被另一活进程（CLI/另一
         // IDE）占用时不得钉回（双方 sessionStart 一致 → F2 永不轮转 → 同槽 last-write-wins
@@ -110,8 +128,9 @@ export function createSlotsHandlers(ctx) {
         // client renders the restored conversation.
         replayHistory({ sessionId: id, notify: notifyRef.current, history: data.history, log })
         log(`session ${slot} loaded as session ${id} (${data.history?.length ?? 0} messages replayed)${occ.occupied || sameProcessPinned ? ` — slot busy, forked to ${session.agent._slot}` : ""}`)
-        // §11.3：load/resume 响应 required = []（`id` / `cwd` 属多余键——同批收敛）
-        return { configOptions: [...CONFIG_OPTIONS] }
+        // §11.3：load/resume 响应 required = []（`id` / `cwd` 属多余键——同批收敛）；
+        // configOptions = 全形（§2.3 单源投影）。
+        return { configOptions: sessionConfigOptions(session.agent) }
       } catch (e) {
         return { error: { code: ACP_ERRORS.INTERNAL.code, message: `failed to load session ${slot}: ${e.message}` } }
       }
@@ -136,7 +155,15 @@ export function createSlotsHandlers(ctx) {
         }
       }
       try {
-        const id = allocSessionId()
+        // §2.4：同 session/load——id = 客户端原文形态（同值读回保续）；同 id 在存 ⇒ 替换
+        // （置换点在既有前置判据之后、`createSession` 之前——拒载路径零副作用）。
+        const id = String(params.sessionId)
+        const stale = sessions.get(id)
+        if (stale) {
+          stale.cancel()
+          sessions.delete(id)
+          releaseClosedSlot()
+        }
         const session = await createSession({ id, notify: notifyRef.current, request: requestRef.current, log })
         // 2026-08-31 advisor round2 🟡：同 session/load——活主占用的槽不钉回（防同槽双写，
         // 下次保存 fork 新槽）；空闲则认领后钉回。
@@ -161,7 +188,7 @@ export function createSlotsHandlers(ctx) {
         sessions.set(id, session)
         // resume: no history replay — the client keeps its own rendering.
         log(`session ${slot} resumed as session ${id} (no replay)${occ.occupied || sameProcessPinned ? ` — slot busy, forked to ${session.agent._slot}` : ""}`)
-        return { configOptions: [...CONFIG_OPTIONS] }
+        return { configOptions: sessionConfigOptions(session.agent) }
       } catch (e) {
         return { error: { code: ACP_ERRORS.INTERNAL.code, message: `failed to resume session ${slot}: ${e.message}` } }
       }