@thincoder/core 0.9.1 → 0.9.3

package/agent.mjs

@@ -26,8 +26,9 @@ import {
   DEFAULT_MAX_TURNS, DEFAULT_SUBAGENT_TURNS,
   MIN_REPORT_CHARS, REPORT_CONTINUATION,
   AUTO_TURN_DIGEST_DOMAIN,
+  AUTO_TURN_DIGEST_DOMAIN_ENG, // §6.15.3（F10 第三面）：工程模式 digest 基座变体（task 指针改批次档 + 台账）
   UPSTREAM_TURN_DOMAIN, // §6.27.12.8：上行唤醒轮域文本（手动档——ask 轮不沿用 digest 域文本）
-  restoreGuard, // §17 D-S6 读侧单点（P2 机制层端差批 §2.18——键清单归核）
+  restoreGuard, // digest D-S6 读侧单点（AGENT-LOOP-ASYNC-POOL.md §6.8；P2 机制层端差批 §2.18——键清单归核）
 } from "./agent/helpers.mjs"
 // ENG 提醒族 + auto-turn domain 2026-09-05 迁 agent/helpers.mjs（agent.mjs 530 > 500 硬限）
 // PROMPT-SYSTEM 施工② G1（2026-09-10）：六件槽位常量装载收口 prompt-overlays.mjs
@@ -159,13 +160,15 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       agent._advisorSession = null // advisor session is per-run: discard when the task ends, next task starts fresh
       agent._emptyRetries = 0 // empty-response retry budget is per-run: a fresh user turn restarts from zero
       agent._compressFailures = 0 // compaction summary-failure counter is per-run: a fresh user turn restarts from zero
+      // F-CC2（§6.16.2）：模型主动压缩的排队槽也是回合级——上一回合末尾未被安全点消费的请求不得跨回合生效
+      agent._pendingCompact = null
     }
   }
-  // §17 D-S6 manual tier: digest action-domain reminder (system-driven turn — organize only).
+  // digest D-S6 manual tier（AGENT-LOOP-ASYNC-POOL.md §6.8）: action-domain reminder (system-driven turn — organize only).
   // §6.27.12.4 ②: an up-stream wake turn answers a RUNNING subagent waiting for the reply — it
   // must not reuse the digest text ("no one is waiting" is the opposite of the truth).
   if ((autoTurn || upstreamTurn) && !agent.autoApprove) {
-    agent.history.push({ role: "user", content: upstreamTurn ? UPSTREAM_TURN_DOMAIN : AUTO_TURN_DIGEST_DOMAIN, transient: true })
+    agent.history.push({ role: "user", content: upstreamTurn ? UPSTREAM_TURN_DOMAIN : (agent.config?.agent?.engineering === true ? AUTO_TURN_DIGEST_DOMAIN_ENG : AUTO_TURN_DIGEST_DOMAIN), transient: true })
   }
   // eng-coder authorization (_engDesignReviewed) is eng-coder-only: set by subagent-spawn.mjs
   // (spawn gate) / design-token.mjs (design review pass) BEFORE the child runAgent — the
@@ -192,8 +195,11 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     // context.mjs compressIfNeeded 经 extras 透出到 logCtx）
     traceDepth: depth,
   }
+  // F-CC1（§6.16.4 阈值单源接线）：本回合压缩判定所用的阈值 + 固定开销面暂存——
+  // `context` 工具的 stats 报**同一口径**（不自行重算第二口径；VSC checkAndCompact 同款暂存）。
+  agent._ctxBasis = { threshold, overhead: compactionOverhead }
 
-  // SUBAGENT-UPSTREAM-CHANNEL（AGENT-LOOP-SUBAGENT.md §6.27.4 消费点）：子 → 父在飞消息的
+  // SUBAGENT-UPSTREAM-CHANNEL（AGENT-LOOP-UPSTREAM.md §6.27.4 消费点）：子 → 父在飞消息的
   // 回合边界注入单点取用一次（模块缓存 ⇒ 每 run 一次代价）；动态 import = 零新增静态边
   // （先例 = 上方 injectAsyncResult :113-117）。
   const { drainChildUpstream } = await import("./agent-tools/parent-channel.mjs")

package/config.mjs

@@ -49,7 +49,7 @@ export const DEFAULTS = {
     advisor: { guard: false },  // code review is always available; guard: true pushes completion back until reviewed (opt-in). Also accepts provider/model/thinking/reasoningEffort/timeoutMs overrides. Deprecated: enabled (2026-08-21)
     autoThink: false,     // auto-classify task difficulty and set reasoning effort per-turn
     engineering: false,   // strict methodology enforcement — design-before-code (design review + user approval before code)
-    // Async pool limits (AGENT-LOOP-SUBAGENT.md §6.10 D-24a/R14 + R13 — POOL-CONFIG-
+    // Async pool limits (AGENT-LOOP-ASYNC-POOL.md §6.10 D-24a/R14 + R13 — POOL-CONFIG-
     // UNIFIED 2026-09-09): { engCoder, other, advisor } — eng-coder pool / other-role
     // pool / advisor-review pool, defaults 4/4/4 (user ruling "eng-coder 四路，其他
     // 4 路" + advisor 评审池并入同一可配体系——三池统一默认 4)。engCoder/other

package/context.mjs

@@ -7,56 +7,13 @@
  * typically a COMPLETED earlier task; preserving them verbatim anchored the model's attention on stale
  * work after compaction. The earliest messages now go into the summary (which distinguishes completed
  * vs in-progress work), so the post-compaction context anchors on the current task (recent tail) only.
+ *
+ * 2026-09-21（context-tool 批 · CONTEXT-COMPACTION.md §6.16.8）：计量 / 尾族 / 切分三族**逐字迁出** `token-window.mjs`（495 → ≈428——硬限 500 内）；`estimateTokens` 经本档**再导出**保既有 import 面；新增面 = 模型主动压缩接线（`force` / `focus` + 焦点块 + anchor）与 prune 应用面。
  */
 
 import { chat } from "./provider/index.mjs"
-import { estimateText } from "./provider/rate.mjs"
-import { providerSpec } from "./config.mjs"
 import { buildCompressMessages } from "./compress-form.mjs"
-
-const IMAGE_TOKEN_ESTIMATE = 2000 // rough estimate for image content tokens (CLI legacy 256 underestimated real image costs, delaying compaction)
-
-/** Rough token count for a list of messages (body + reasoning + tool_calls params) */
-export function estimateTokens(messages) {
-  let tokens = 0
-  for (const m of messages) {
-    if (typeof m.content === "string") tokens += estimateText(m.content)
-    else if (Array.isArray(m.content)) {
-      for (const part of m.content) {
-        if (part.type === "text") tokens += estimateText(part.text)
-        else if (part.type === "image_url") tokens += IMAGE_TOKEN_ESTIMATE
-      }
-    }
-    if (typeof m.reasoning_content === "string") tokens += estimateText(m.reasoning_content)
-    for (const tc of m.tool_calls ?? []) {
-      tokens += estimateText(tc.function?.name ?? "") + estimateText(tc.function?.arguments ?? "")
-    }
-  }
-  return tokens
-}
-
-const KEEP_HEAD = 0 // No dedicated head: earliest messages may be a COMPLETED earlier task in multi-task
-// sessions — keeping them verbatim anchored attention on stale work. Everything before the tail is
-// summarized (the summary itself distinguishes completed vs in-progress work; see SUMMARIZE_PROMPT).
-// Tail count formula (D4): window-adaptive (~30 msgs per 100K — old fixed 10 too thin on 1M), capped
-// at 40% of history; §6.4④ D-T1/D-T2 make the count only a CANDIDATE — a token budget (TAIL_BUDGET_FRACTION
-// × window − SUMMARY_TOKEN_ESTIMATE ≈1K, §6.9) tightens it over pair-safe boundaries when compaction runs,
-// never below TAIL_FLOOR_MESSAGES; ordinary sessions never reach it (D-T4: trigger 0.6 untouched).
-const TAIL_BUDGET_FRACTION = 0.15
-const SUMMARY_TOKEN_ESTIMATE = 1000 // §6.9: summary output target ~1K tokens — reserved from the 15%
-const TAIL_FLOOR_MESSAGES = 10 // §6.4④ D-T2: the tail keeps ≥10 verbatim messages — floor beats budget
-function keepTailSize(provider, historyLen) {
-  // provider is guaranteed at every call site (runAgent always builds one); providerSpec
-  // degrades to DEFAULT_SPEC (128K) only if provider is somehow absent — acceptable
-  // because the 40% history cap still bounds the tail. providers[].context override
-  // (K units) is honored here (PROVIDER.md §6.15 T-C2: tail formula follows the window).
-  const ctxWindow = providerSpec(provider).context
-  return Math.min(Math.max(10, Math.floor((ctxWindow / 100_000) * 30)), Math.floor(historyLen * 0.4))
-}
-// §6.4④ D-T1 tail token budget: window×15% − summary ~1K — the compressed history segment (summary + placeholder + tail) lands ≈ 15% (B 口径 §6.4④).
-function tailBudgetTokens(provider) {
-  return Math.max(0, Math.floor(providerSpec(provider).context * TAIL_BUDGET_FRACTION) - SUMMARY_TOKEN_ESTIMATE)
-}
+import { contextUsage, estimateTokens, collectStaleToolOutputs, keepTailSize, splitHistory, tailBudgetTokens } from "./token-window.mjs"
 
 export const SUMMARIZE_PROMPT = `The conversation above is our work log so far — summarize it into a compact summary for use as context in the ongoing conversation.
 Requirements:
@@ -93,72 +50,25 @@ const FALLBACK_NOTE =
   "Re-verify any state you need with tools before relying on it.]\n\n"
 
 /**
- * Split history into head / middle (to be summarized) / tail; return null if no middle to compress.
- * head is normally empty (KEEP_HEAD = 0 — earliest messages go into the summary); the tool_calls-extension logic below is defensive for future KEEP_HEAD > 0.
- * The tail boundary must include any assistant whose tool results are in the tail — if the assistant is in the middle, the summary swallows it, leaving orphan tool results → protocol 400.
- * `budgetTokens` (optional, §6.4④ D-T1): when the candidate's estimate exceeds it, the boundary moves
- * forward until the tail fits — never below the D-T2 floor (10 msgs, or the candidate itself when
- * the 40% cap made it < 10 — short history).
+ * focus 指令块（F-CC2 · §6.16.2）：模型主动压缩时追加在摘要指令**尾段**——摘要按它加权取舍。`anchor` = task/goal 状态行；
+ * `anchor == null`（无 task 且无 goal）⇒ **anchor 段省略**，focus 正文恒保留（不产空标题）。
  */
-function splitHistory(history, keepTail, budgetTokens = null) {
-  if (history.length <= KEEP_HEAD + keepTail + 1) return null
-  let headEnd = KEEP_HEAD
-  // head must not end with dangling tool_calls: when assistant declares tool_calls, all its tool results must stay in head.
-  // Parallel calls: one assistant followed by multiple tool messages — accepting only one still causes 400, must collect all
-  if (history[headEnd - 1]?.role === "assistant" && history[headEnd - 1].tool_calls?.length) {
-    while (headEnd < history.length && history[headEnd].role === "tool") headEnd++
-  }
-  const candidate = repairedTailStart(history, headEnd, history.length - keepTail)
-  if (candidate <= headEnd) return null
-  let tailStart = candidate
-  // §6.4④ D-T1: tighten only above the floor — a candidate ≤ 10 IS the floor (short history under the 40% cap must not tighten further, review #5); the floor is D5-repaired too.
-  if (budgetTokens > 0 && keepTail > TAIL_FLOOR_MESSAGES) {
-    const floor = repairedTailStart(history, headEnd, history.length - TAIL_FLOOR_MESSAGES)
-    if (floor > candidate) tailStart = tightenTailByBudget(history, candidate, floor, budgetTokens)
-  }
-  return { headEnd, tailStart }
-}
+const focusBlock = (focus, anchor) =>
+  `\n\nThis compaction happens at my own request and is weighted toward the work coming next:\n${focus}\n\n` +
+  `Keep what that work needs at full fidelity — files, decisions, constraints, open threads; compress ` +
+  `everything else harder.` +
+  (anchor ? ` Current task/goal state (attached automatically):\n${anchor}` : "")
 
 /**
- * D5 tail-side pairing repair for a raw cut at history.length − tailCount: pull into the tail any
- * assistant whose tool results are in the tail (the summary swallowing the owner leaves orphan tool
- * results → protocol 400), then skip orphan tool messages at the new boundary. Single-assistant
- * assumption (nearest owner only — a tail spans at most one assistant→tools cycle); bounds-guarded.
+ * anchor 取值（§6.16.2「自动附任务 / 目标（F-CC2 明文）」）：取值源 = **工具面单源**——`task` / `goal` 工具写入的
+ * `agent.tasks` / `agent.goal`，不新增第二份状态；行格式沿用既有任务重注入形态（`- [status] title` + goal 一行）。两者皆空 ⇒ null（anchor 段整体省略）。
  */
-function repairedTailStart(history, headEnd, tailStart) {
-  const tailToolIds = new Set()
-  for (let i = tailStart; i < history.length; i++) {
-    if (history[i].role === "tool") tailToolIds.add(history[i].tool_call_id)
-  }
-  for (let i = tailStart - 1; i > headEnd; i--) {
-    const m = history[i]
-    if (m.role === "assistant" && m.tool_calls?.some((tc) => tailToolIds.has(tc.id))) {
-      tailStart = i
-      break
-    }
-  }
-  while (tailStart < history.length && tailStart > headEnd && history[tailStart].role === "tool") {
-    tailStart++
-  }
-  return tailStart
-}
-
-/**
- * §6.4④ D-T1 budget tightening (pair-safe, review #2): walk the boundary FORWARD (fewer tail messages —
- * the rest joins the summary) while the tail's estimated tokens exceed the budget. Only pair-safe
- * positions may stop the walk: a boundary ON a tool message would orphan its owner assistant into the
- * middle (D5); pairing is contiguous in the machine line (§6.4③) — every non-tool boundary is safe.
- * No fit before the floor → keep the floor, accept the overrun.
- */
-function tightenTailByBudget(history, start, floorStart, budgetTokens) {
-  const suffixTokens = new Array(history.length + 1)
-  suffixTokens[history.length] = 0
-  for (let i = history.length - 1; i >= 0; i--) suffixTokens[i] = suffixTokens[i + 1] + estimateTokens([history[i]])
-  if (suffixTokens[start] <= budgetTokens) return start // already fits — ordinary sessions stay untouched (D-T2)
-  for (let p = start + 1; p <= floorStart; p++) { // first fit keeps the most recent verbatim context
-    if (history[p].role !== "tool" && suffixTokens[p] <= budgetTokens) return p
-  }
-  return floorStart
+function anchorText(agent) {
+  const lines = []
+  const g = agent?.goal
+  if (g?.objective) lines.push(`- goal [${g.status}] ${g.objective}${g.criteria ? ` — done when: ${g.criteria}` : ""}`)
+  for (const t of agent?.tasks ?? []) lines.push(`- [${t.status}] ${t.title}`)
+  return lines.length > 0 ? lines.join("\n") : null
 }
 
 /**
@@ -359,21 +269,16 @@ function applyCompression(agent, headEnd, tailStart, note) {
  *   generation is SILENT (never forwards onToken/onReasoning: the compaction process is an
  *   internal mechanism, not a model reply); onCompressStart fires right before the summary call
  *   (§6.8 D-C1, compression lifecycle visibility — panel start state)
- * @param {object} extras - { systemPrompt?, tools? } — estimated overhead for the pure-estimation
- *   path (no measured baseline); the measured path already includes system+tools in prompt_tokens.
+ * @param {object} extras - { systemPrompt?, tools?, force?, focus? } — 固定开销面（system + tools 估计）+
+ *   模型主动压缩面（§6.16.2）：`force` **只跳过** `tokens <= threshold` 早退，其余全同；`focus` 追加在摘要指令尾段。
  */
 export async function compressIfNeeded(agent, threshold, callbacks, extras = {}, signal) {
   const history = agent.history
-  // Prefer the real baseline: the last response's prompt_tokens is the measured value for the full context (system+tools+history).
-  // Subsequent appended messages use estimation as increment; when no measured value exists (first turn / after restore / right after compaction), fall back to pure estimation
-  const overhead =
-    (extras.systemPrompt ? estimateText(extras.systemPrompt) : 0) +
-    (extras.tools ? estimateText(JSON.stringify(extras.tools)) : 0)
-  const tokens =
-    agent._lastPromptTokens != null
-      ? agent._lastPromptTokens + estimateTokens(history.slice(agent._usageAtLen ?? history.length))
-      : estimateTokens(history) + overhead
-  if (tokens <= threshold) return false
+  // 单源（§6.16.4）：total / overhead 与 stats 面同一函数（既有内联式改调 contextUsage，判定语义零改）
+  const usage = contextUsage(agent, extras)
+  const tokens = usage.total
+  const overhead = usage.overhead
+  if (!extras.force && tokens <= threshold) return false
 
   const keepTail = keepTailSize(agent.provider, history.length)
   const split = splitHistory(history, keepTail, tailBudgetTokens(agent.provider))
@@ -398,8 +303,15 @@ export async function compressIfNeeded(agent, threshold, callbacks, extras = {},
   // the lifecycle is surfaced, never the summary body. N = the number of history messages being summarized.
   callbacks?.onCompressStart?.({ messages: middle.length })
   const startedAt = performance.now()
+  // F-CC2 焦点块（§6.16.2）：仅模型主动面携带——追加在**指令末条尾段**（`SUMMARIZE_PROMPT` 文本零改，
+  // 只追加焦点块；无 focus ⇒ 请求体逐字节同修前——compress-form.test.mjs 零回归）。
+  const messages = buildCompressMessages(history, split.tailStart, extras?.systemPrompt, SUMMARIZE_PROMPT)
+  if (extras.focus) {
+    const last = messages.at(-1)
+    messages[messages.length - 1] = { ...last, content: last.content + focusBlock(String(extras.focus), anchorText(agent)) }
+  }
   const summary = await chat({ ...agent.provider, thinking: null }, {
-    messages: buildCompressMessages(history, split.tailStart, extras?.systemPrompt, SUMMARIZE_PROMPT),
+    messages,
     tools: extras?.tools,
     signal,
     // §18.6 D-TR4：轨迹元数据增补——kind=compress（上下文构建面——agent 元数据透出；
@@ -430,6 +342,37 @@ export async function compressIfNeeded(agent, threshold, callbacks, extras = {},
   return true
 }
 
+/** prune stub 逐字（§6.16.3）：只给「已清理 + 原长度 + 重跑路径」——prune 是**删**不是摘要，不声称可复原。 */
+const pruneStub = (chars) => `[pruned: stale tool output dropped (${chars} chars) — re-run the tool if you need it again.]`
+
+/**
+ * 陈旧工具输出清理（F-CC3 · §6.16.3）：合格集 = `token-window.mjs` 单源（保护尾外 ∧ `role:"tool"` ∧ ≥ 门槛）；
+ * 命中项**原位换「内容」**（`history[i] = { ...m, content: stub }`——数组引用 / 长度 / 索引 / `tool_call_id` 全不变
+ * ⇒ 配对**结构上不可能被拆**）。记录面零改（copy-on-write：消息对象与人读线共享）；基线失效同 `shrinkOversized` 先例。
+ * @returns {{pruned:number, freed:number, candidates:number, tailKept:number, belowMin:number}}
+ */
+export function pruneStaleToolOutputs(agent) {
+  const history = agent.history
+  const stale = collectStaleToolOutputs(history, agent.provider)
+  const counts = {
+    pruned: stale.indexes.length,
+    freed: stale.tokens,
+    candidates: stale.candidates,
+    tailKept: stale.tailKept,
+    belowMin: stale.belowMin,
+  }
+  if (counts.pruned === 0) return counts
+  for (const i of stale.indexes) {
+    const m = history[i]
+    // 多模态 tool 结果（content 数组）整体替换为 stub ⇒ 图像 part 丢弃（不可再取——prune 是删；回执只给重跑路径）
+    const chars = typeof m.content === "string" ? m.content.length : JSON.stringify(m.content ?? "").length
+    history[i] = { ...m, content: pruneStub(chars) }
+  }
+  agent._lastPromptTokens = null
+  agent._usageAtLen = null
+  return counts
+}
+
 /**
  * Deterministic truncation fallback: called when the summary LLM fails repeatedly, no network call.
  * Drops the middle so the task can continue. Returns whether truncation happened.
@@ -488,6 +431,8 @@ function shrinkOversized(agent, limit = OVERSIZE_CONTENT_LIMIT) {
   return shrunk
 }
 
+// ─── 迁出面（import 面保持：TUI / verify-compress / VSC 对拍经本档取——先例 = 下方 explore-distill 再导出）──
+export { estimateTokens }
 // ─── End-of-run exploration distillation（2026-09-05 module-split：524 > 500 硬限——verbatim
 // 迁至 explore-distill.mjs，语义零变——VS Code compact.mjs 同款联动；cross-repo parity 锚改指
 // explore-distill.mjs——消费方 import 面不变（re-export））───────────────────────

package/fts-text.mjs

@@ -0,0 +1,41 @@
+/**
+ * fts-text.mjs — FTS5 语言面单一来源（会话索引批 · SESSION.md §6.19 D-SE44）。
+ *
+ * `segmentCJK` / `buildFtsQuery` 自 `memory/schema.mjs` / `memory/core.mjs` **外提**为本叶子档
+ * （两档 re-export 保名面——零行为变更）：理由 = 会话索引不得把 memory 模块链拉进
+ * `read_history` 的装配装载面（W8 契约②）+ 机制单源（D2——写入侧与查询侧同一处理）。
+ * 消费者 = memory 面（写入 / 检索）+ 会话索引面（`session-index.mjs` / `session-index-build.mjs`）。
+ *
+ * 零项目内依赖（仅 `node:`）——叶子档，可被任意装配面静态 import。
+ */
+
+/** 查询词元上限（超限截断——`buildFtsQuery` 单源）。 */
+export const FTS_TOKEN_MAX = 16
+
+/**
+ * CJK 逐字间隔：让 unicode61 把汉字 / 假名 / 谚文逐字当作独立 token。
+ * 写入与查询两侧必须用同一处理才可召回（两字词如「分号」→「分 号」短语仍命中；ASCII 保持整词）。
+ */
+export function segmentCJK(text) {
+  return text.replace(
+    /[぀-ヿ㐀-䶿一-鿿豈-﫿가-힯]+/g,
+    (run) => [...run].join(" "),
+  )
+}
+
+/**
+ * 构造 FTS5 查询：先按空白 / 标点切 token，再对每个 token 做 CJK 逐字分段。
+ * 多字 CJK 词保持为 FTS5 短语（「分号」→「分 号」→ 短语查询，邻接精确匹配），
+ * 不同 token 以 OR 连接（「命名 规范」→「命 名」OR「规 范」，各自短语要求自身邻接）。
+ * 无 token ⇒ 返回空串（消费侧据此退化——SESSION.md §6.19 边界情形表）。
+ */
+export function buildFtsQuery(query) {
+  const terms = query
+    .split(/[\s,，。、;；!！?？()（）"`]+/)
+    .map((t) => t.trim())
+    .filter(Boolean)
+    .slice(0, FTS_TOKEN_MAX)
+    .map((t) => segmentCJK(t))
+  if (terms.length === 0) return ""
+  return terms.map((t) => `"${t.replaceAll('"', '""')}"`).join(" OR ")
+}

package/generate-title.mjs

@@ -9,6 +9,9 @@
  */
 
 import { proxyFetch } from "./proxy.mjs"
+// D7（2026-09-21 块标题行对齐批——标题链单源）：首条真实 user 消息谓词收核单源
+// （`isRealUserMsg`——纯函数零依赖，无环）。
+import { isRealUserMsg } from "./history-window.mjs"
 
 // Test seam (_-prefix, mirrors run.mjs seams): lets the proxy-branch regression
 // test swap the proxy fetch. The branch it exercises used to carry a dynamic
@@ -105,13 +108,10 @@ export async function ensureSessionTitle(agent) {
   if (agent.title) return agent.title
   try {
     // TUI-OOM-ROOTCAUSE 批（SESSION.md §6.14）：绑定态首条 user 消息在记录存储（段 1）——
-    // 内存窗口可能已滑过它（store.firstUserMessage 首扫一次并缓存）；未绑定回退内存查找。
+    // 内存窗口可能已滑过它（store.firstUserMessage 首扫一次并缓存）；未绑定回退内存查找
+    // （谓词单源 = `isRealUserMsg`——与 VSC 端壳同判据）。
     let firstUser = agent._recordStore?.firstUserMessage?.() ?? null
-    if (!firstUser) {
-      firstUser = (agent._fullHistory ?? agent.history).find(
-        (m) => m.role === "user" && typeof m.content === "string" && !m.content.startsWith("[System reminder:"),
-      )
-    }
+    if (!firstUser) firstUser = (agent._fullHistory ?? agent.history).find(isRealUserMsg)
     if (firstUser) {
       const title = await generateTitle(firstUser.content, agent.provider)
       if (title) agent.title = title

package/i18n.mjs

@@ -35,10 +35,10 @@ export const CORE_MESSAGES = Object.freeze({
   "digest.done": { en: "Digested ${n} background report(s) (${seconds}s)", zh: "已消化 ${n} 份后台报告（${seconds}s）" },
   "digest.aborted": { en: "Digestion interrupted (${seconds}s)", zh: "消化中断（${seconds}s）" },
   "digest.turnLabel": { en: "[auto-turn: digesting finished subagent reports…]", zh: "自动回合：消化已完成的子代理报告…" },
-  // M4（2026-09-20 端差·显示面消差批）：起跑标签三档（en = CLI `suspension-drive.mjs:175-176`
-  // 逐字；zh = 与上方既有档同式译法）——VSC 本地档不重复定义（单一权威容器）。
-  "digest.turnLabelAsk": { en: "[auto-turn: answering a subagent's in-flight message…]", zh: "自动回合：答复子代理的在飞提问…" },
-  "digest.turnLabelAuto": { en: "[auto-turn: continuing background work…]", zh: "自动回合：继续后台推进…" },
+  // M4（2026-09-20 端差·显示面消差批）+ F-UC8（2026-09-21 信号提示行批 · §6.27.12.13 ①–②）：起跑标签
+  // **两档**——ask 档携参「谁 + 啥」（`${from}` / `${msg}`——核单点 `upstreamAskLabelVars`）/ digest 档（下键）；
+  // manual / AUTO **同判**（`auto` 泛句无生产者 ⇒ 键退场）；VSC 本地档不重复定义（单一权威容器）。
+  "digest.turnLabelAsk": { en: "[auto-turn: answering ${from}: ${msg}]", zh: "自动回合：答复 ${from}：${msg}" },
   "digest.capAuto": { en: "[auto-turn: continuing past turn cap…]", zh: "自动回合：越过轮次上限，继续推进…" },
   "digest.capStop": { en: "[auto-turn stopped at ${turns} turns — partial digest; finished reports stay in history]", zh: "自动回合在 ${turns} 轮处停止——部分消化；已完成的报告保留在历史中" },
   // ── 限流 / 供应商状态行 ──

package/ledger-cmd.mjs

@@ -37,7 +37,7 @@ export function ledgerCount({ cwd } = {}) {
 /** 路径 = 存在的**档**？（目录 / 缺失 → false——写门存在性判据用）。 */
 const isFile = (p) => { try { return statSync(p).isFile() } catch { return false } }
 
-/** 写门·指针存在性（设计档 §6.1 · 台账 #38 · AC-M2-8）：写命令落盘前判**结果行**——`status ∈
+/** 写门·指针存在性（设计档 §6.1 · 台账 #38 · AC-M2-9）：写命令落盘前判**结果行**——`status ∈
  *  {在途, 待核销}` 且 `task_book` 非空 ⇒ 文件部分（首个 `§` 前子串，trim）须经基准 `resolve(base, …)`
  *  指向存在的档；缺文件部分（`§2` / 全空白）⇒ 拒；不在册 / 非文件 ⇒ 拒（throw，行不变）。
  *  判位与迁移表判同层（落盘前）；文案前缀 = 调用函数名（与同函数既有两条文案同款）。
@@ -67,8 +67,22 @@ export function ledgerAdd({ cwd, row }) {
   } finally { db.close() }
 }
 
-/** 更新（写命令，仅主 agent）：UPDATE——状态迁移前判允许迁移表（不在表内 → 拒，行不变）。 */
-export function ledgerUpdate({ cwd, id, patch }) {
+/** executor 目标值计算（设计档 docs/core/design/LEDGER.md §3.1——判位在 ledgerUpdate 体内：迁移表判 → 本语义 → 写门 → UPDATE）。
+ *  优先级 = patch 显式 > 自动语义（进在途 = executorSessionId / 出在途 = NULL）> 行现值兜底 > NULL。 */
+function resolveExecutorTarget(row, to, patch, executorSessionId) {
+  if (row.status === "待设计" && to === "在途") {
+    return patch.executor ?? executorSessionId ?? row.executor ?? null
+  }
+  if (row.status === "在途" && (to === "待核销" || to === "已废弃")) {
+    return null // 出边自动语义压 patch——显式传 executor 也不复活
+  }
+  return patch.executor ?? row.executor ?? null
+}
+
+/** 更新（写命令，仅主 agent）：UPDATE——状态迁移前判允许迁移表（不在表内 → 拒，行不变）。
+ *  executor 目标值随同一 UPDATE 落列（LEDGER.md §3.1）；executorSessionId = 调用会话（函数参数注入——K-LX1
+ *  纯函数可测；工具层动态 import getSessionId() 供值，零新静态边）。 */
+export function ledgerUpdate({ cwd, id, patch, executorSessionId }) {
   const db = openLedger(cwd, { create: true })
   try {
     const row = db.prepare("SELECT * FROM items WHERE id = ?").get(id)
@@ -79,9 +93,10 @@ export function ledgerUpdate({ cwd, id, patch }) {
     }
     const nextTaskBook = patch.task_book ?? row.task_book
     assertTaskBookGate(cwd, "ledgerUpdate", to, nextTaskBook) // 判序：迁移表判 → 本门 → UPDATE
+    const nextExecutor = resolveExecutorTarget(row, to, patch, executorSessionId)
     const now = nowIso()
-    db.prepare(`UPDATE items SET status = ?, title = ?, board = ?, req_doc = ?, task_book = ?, evidence = ?, trigger = ?, updated_at = ? WHERE id = ?`)
-      .run(to, patch.title ?? row.title, patch.board ?? row.board, patch.req_doc ?? row.req_doc, nextTaskBook, patch.evidence ?? row.evidence, patch.trigger ?? row.trigger, now, id)
+    db.prepare(`UPDATE items SET status = ?, title = ?, board = ?, req_doc = ?, task_book = ?, evidence = ?, trigger = ?, executor = ?, updated_at = ? WHERE id = ?`)
+      .run(to, patch.title ?? row.title, patch.board ?? row.board, patch.req_doc ?? row.req_doc, nextTaskBook, patch.evidence ?? row.evidence, patch.trigger ?? row.trigger, nextExecutor, now, id)
     return { id }
   } finally { db.close() }
 }
@@ -97,7 +112,8 @@ export function ledgerClose({ cwd, id, status }) {
       if (!row) throw new Error(`ledgerClose：行 ${id} 不存在`)
       if (status === "已核销" && row.status !== "待核销") throw new Error(`ledgerClose：勾销仅限待核销（现态 ${row.status}）`)
       const now = nowIso()
-      db.prepare("UPDATE items SET status = ?, closed_at = ?, updated_at = ? WHERE id = ?").run(status, now, now, id)
+      // 撤回（任意态 → 已废弃——含在途直撤）同步 executor = NULL（LEDGER.md §3.1 ④）；勾销路径 executor 已在离场迁移清空，零触碰
+      db.prepare("UPDATE items SET status = ?, closed_at = ?, updated_at = ?, executor = ? WHERE id = ?").run(status, now, now, status === "已废弃" ? null : row.executor, id)
       db.exec("COMMIT")
       return { id, status }
     } catch (e) { db.exec("ROLLBACK"); throw e }
@@ -181,12 +197,19 @@ export const ledgerUpdateTool = {
       task_book: { type: "string", description: "任务书指针（缺省 = 不变）" },
       evidence: { type: "string", description: "证据（缺省 = 不变）" },
       trigger: { type: "string", enum: ["归批", "条件", "认账不排期"], description: "触发（缺省 = 不变）" },
+      executor: { type: "string", description: "执行者 sessionId（可选——接手改写归属用；缺省 = 按状态迁移语义：进在途自动写本会话 / 出在途自动清空 / 其余不变）" },
     },
   },
   readonly: false,
   async execute(args, ctx) {
     const { cwd, id, ...patch } = args
-    return JSON.stringify(ledgerUpdate({ cwd: cwd ?? cwdOf(ctx), id, patch }))
+    let executorSessionId
+    if (patch.executor === undefined) {
+      // 动态 import——零新静态边（K-LX1）；工具层供值，核心函数保持参数注入纯函数
+      const { getSessionId } = await import("./session-slots.mjs")
+      executorSessionId = getSessionId()
+    }
+    return JSON.stringify(ledgerUpdate({ cwd: cwd ?? cwdOf(ctx), id, patch, executorSessionId }))
   },
 }
 

package/ledger-db.mjs

@@ -57,13 +57,30 @@ CREATE TABLE IF NOT EXISTS items (
   task_book  TEXT,
   evidence   TEXT,
   trigger    TEXT CHECK(trigger IN ('归批','条件','认账不排期') OR trigger IS NULL),
+  executor   TEXT,
   created_at TEXT,
   updated_at TEXT,
   closed_at  TEXT,
   CHECK (status NOT IN ('在途','待核销') OR (task_book IS NOT NULL AND task_book <> ''))
 )`
 
-/** 开库（cwd = 项目根——仅作关联键）→ DatabaseSync 句柄 + 幂等建表。
+/** 老库幂等迁移：items 表缺 executor 列（旧 DDL 建的库）→ ALTER 补列。
+ *  判据 = PRAGMA table_info 实查（不猜版本号）；ALTER duplicate column 竞争 → 复核列在吞 / 不在抛真错。
+ *  列存在性谓词抽成单元（param exists），便于并发竞争拍直测。K-LX5：老库零删改、零重建。 */
+export function ensureExecutorColumn(db, { exists } = {}) {
+  const columnExists = exists
+    ?? (() => db.prepare("SELECT 1 FROM pragma_table_info('items') WHERE name = 'executor'").get() !== undefined)
+  if (columnExists()) return false
+  try {
+    db.exec("ALTER TABLE items ADD COLUMN executor TEXT")
+    return true
+  } catch (e) {
+    if (columnExists()) return false // 并发竞争——另一连接已加列：吞
+    throw new Error(`台账库 executor 列迁移失败：${e.message}`)
+  }
+}
+
+/** 开库（cwd = 项目根——仅作关联键）→ DatabaseSync 句柄 + 幂等建表 + 老库幂等迁移（executor 列）。
  *  读面（create=false）：库文件不存在 → 返回 null（空账——读面不建库、无副作用）。
  *  写面（create=true）：库文件不存在自动建（台账目录随之创建）；项目根目录不存在 → 抛友好错误。 */
 export function openLedger(cwd, { create = false } = {}) {
@@ -75,7 +92,10 @@ export function openLedger(cwd, { create = false } = {}) {
   if (!existsSync(file) && !create) return null
   try { mkdirSync(ledgerDir, { recursive: true }) } catch { /* 已存在 / 并发建目录竞争——忽略 */ }
   const db = new DatabaseSync(file)
-  try { db.exec(DDL) } catch (e) {
+  try {
+    db.exec(DDL)
+    ensureExecutorColumn(db)
+  } catch (e) {
     db.close()
     throw new Error(`台账库打开失败：${file}（${e.message}）`)
   }

package/ledger-executors.mjs

@@ -0,0 +1,103 @@
+/**
+ * ledger-executors.mjs — 在途 executor 判活展示（F-LX1 · 设计档 LEDGER.md §7.3.1）。
+ *
+ * 红线：写径零探测——判活只落显示面。本档从 ledger.mjs 拆出（2026-09-21 executor 判活批，
+ * ledger.mjs 307 → ≤300 软线回落），语义零变：`resolveExecutorStates` async 单源 + `executorTail`
+ * 三态文案（双端同文——CLI L2 与 VSC tooltip 共此函数）+ TTL 缓存（与 peer-instances 同源口径）。
+ */
+import { classifyEnd, ownerState, probeOwnersAsync } from "./process-probe.mjs"
+import { PEER_PROBE_TTL_MS } from "./peer-instances.mjs"
+
+/** 判活解析 TTL 缓存（模块级——与 peer-instances `PEER_PROBE_TTL_MS` 同源口径；TTL 内重复解析零 exec）。
+ *  键 = pid；值 = { probedAt, state, end }。`_setExecutorProbeTtlForTest` = 测试缝（裁定 #8——测试间不串；用后恢复）。 */
+const executorProbeCache = new Map()
+let _executorProbeTtlOverride = null
+
+/** 测试缝：覆盖 TTL 毫秒数（0 = 禁缓存恒重探）；返回前值，测试 finally 恢复。 */
+export function _setExecutorProbeTtlForTest(ms) {
+  const prev = _executorProbeTtlOverride
+  _executorProbeTtlOverride = ms
+  executorProbeCache.clear()
+  return prev
+}
+
+const executorTtlMs = () => _executorProbeTtlOverride ?? PEER_PROBE_TTL_MS
+
+/** sessionId → pid（首段整数——peer-instances `groupSlotSessions` 同款解析；不可解析 ⇒ null→unknown）。 */
+function executorPid(sessionId) {
+  const n = Number.parseInt(String(sessionId).split("-")[0], 10)
+  return Number.isFinite(n) && n > 0 ? n : null
+}
+
+/** 行时间戳 → 距今天数（向下取整；缺 → null——「N 天未动」标注源，零新状态）。 */
+function staleDaysOf(ts, now) {
+  if (ts == null) return null
+  const ms = Date.parse(ts)
+  if (!Number.isFinite(ms)) return null
+  return Math.floor(Math.max(0, now - ms) / 86400000)
+}
+
+/** 在途 executor 判活批量解析（async 单源——LEDGER.md §7.3.1）：收集各 scan 的 `inflightExecutors`
+ *  → pid 去重 → **一次 `probeOwnersAsync` 束**（≤1 判活 + ≤1 cmdline——禁止逐行 exec）→ 逐 executor
+ *  `ownerState` → 每 scan 挂 `executors: [{executor, pid, end, state, staleDays}]` + `deadExecutors: n`。
+ *  `end` = cmdline 可得时的 `classifyEnd` 值；`staleDays` = 该行 `updated_at ?? created_at` 距今天数。
+ *  TTL 缓存按 pid（5s 同源口径）；**无在途 executor ⇒ 零 exec 快返**（不探、不缓存）。
+ *  写径零探测——本函数仅供显示面调用（§7.3.1 红线）。 */
+export async function resolveExecutorStates(scans, { now = Date.now() } = {}) {
+  const list = Array.isArray(scans) ? scans : []
+  const entries = []
+  for (const s of list) {
+    for (const e of Array.isArray(s?.inflightExecutors) ? s.inflightExecutors : []) entries.push({ scan: s, ...e })
+  }
+  // 每 scan 先挂空形（无在途 ⇒ 空数组 + 0——不触缓存不探测）
+  for (const s of list) { s.executors = []; s.deadExecutors = 0 }
+  if (entries.length === 0) return list
+
+  const pids = new Map() // pid → sessionId（去重——同 pid 多条只探一次）
+  for (const e of entries) {
+    const pid = executorPid(e.executor)
+    if (pid !== null && !pids.has(pid)) pids.set(pid, e.executor)
+  }
+
+  // TTL 命中/未命中分流：未命中的 pid 集成一次批量探测
+  const ttl = executorTtlMs()
+  const need = [...pids.keys()].filter((pid) => {
+    const hit = executorProbeCache.get(pid)
+    return !hit || now - hit.probedAt >= ttl
+  })
+  const bundle = need.length > 0 ? await probeOwnersAsync(need) : { aliveSet: null, cmds: null }
+  for (const pid of need) {
+    const cmdline = typeof bundle?.cmds?.get?.(pid) === "string" ? bundle.cmds.get(pid) : undefined
+    executorProbeCache.set(pid, {
+      probedAt: now,
+      state: ownerState(pid, bundle),
+      end: cmdline ? classifyEnd(cmdline) : undefined,
+    })
+  }
+  const deadByScan = new Map()
+  for (const e of entries) {
+    const pid = executorPid(e.executor)
+    const hit = pid !== null ? executorProbeCache.get(pid) : null
+    const state = hit ? hit.state : "unknown" // pid 不可解析 ⇒ unknown（不判死——保守）
+    const end = hit ? hit.end : undefined
+    const staleDays = staleDaysOf(e.updated_at ?? e.created_at, now)
+    e.scan.executors.push({ executor: e.executor, pid, end, state, staleDays })
+    if (state === "dead") deadByScan.set(e.scan, (deadByScan.get(e.scan) ?? 0) + 1)
+  }
+  for (const [scan, n] of deadByScan) scan.deadExecutors = n
+  return list
+}
+
+/** 判活尾段（三态文案单源——LEDGER.md §7.3.1；双端同文——CLI L2 与 VSC tooltip 共此函数）：
+ *  dead>0 → `（属主已死 <n>，可接手）`（dead 优先）；死 0 · 在途 executor >0 · 最长 staleDays ≥1 →
+ *  `（执行中 <n> · 最长 <d> 天未动）`；死 0 · staleDays <1 或 null → `（执行中 <n>）`；
+ *  在途 executor =0 → 空串（既有文案零破）。 */
+export function executorTail(scan) {
+  const exs = Array.isArray(scan?.executors) ? scan.executors : []
+  if (exs.length === 0) return ""
+  const dead = exs.filter((x) => x.state === "dead").length
+  if (dead > 0) return `（属主已死 ${dead}，可接手）`
+  const maxStale = Math.max(...exs.map((x) => (x.staleDays == null ? 0 : x.staleDays)))
+  if (maxStale >= 1) return `（执行中 ${exs.length} · 最长 ${maxStale} 天未动）`
+  return `（执行中 ${exs.length}）`
+}