thincoder 0.12.62 → 0.12.64

package/src/agent-tools/goal.mjs

@@ -1,119 +0,0 @@
-/**
- * goal tool: lifecycle management for long-running autonomous goals (completion contract).
- * Three states: active / complete / blocked. Completion must pass a verify evidence threshold;
- * blocked is only accepted after the same condition persists 3 consecutive times.
- * The system injects status + budget progress + audit discipline every turn.
- */
-export const goalTool = {
-  name: "goal",
-  description:
-    "Manage a long-running autonomous goal. " +
-    "action='set': create or replace the goal — must have a verifiable completion criterion (a machine-checkable proof, not vague effort). " +
-    "action='complete': mark achieved — only after the criterion's check has actually passed. " +
-    "action='blocked': report an impasse (requires 'reason') — only after 3 genuine attempts. " +
-    "action='cancel': abandon the goal. " +
-    "Returns a status line — the goal set/updated/completed/blocked/cancelled confirmation, or Error: ... with the reason.",
-  parameters: {
-    type: "object",
-    properties: {
-      action: { type: "string", enum: ["set", "complete", "blocked", "cancel"], description: "Goal lifecycle action" },
-      objective: { type: "string", description: "What you are trying to accomplish (for 'set')" },
-      criteria: { type: "string", description: "How completion is PROVEN: the exact check to run, e.g. 'npm test passes', 'grep finds no TODO marker' (required for 'set')" },
-      reason: { type: "string", description: "The blocking condition (required for 'blocked')" },
-    },
-    required: ["action"],
-  },
-  readonly: true,
-  async execute(args, ctx) {
-    const agent = ctx.agent
-    if (args.action === "cancel") {
-      agent.goal = null
-      return "Goal cancelled. If the goal was blocked or impossible, explain why in your next message — the user can clarify, adjust scope, or confirm cancellation."
-    }
-    if (args.action === "set") {
-      if (!args.objective) return "Error: 'objective' required for 'set' action."
-      if (!args.criteria) {
-        return "Error: 'criteria' required for 'set' — a goal without a machine-checkable proof of completion is a wish, not a goal. Name the exact check (tests, command output, search result) that proves it's done."
-      }
-      agent.goal = {
-        objective: String(args.objective).slice(0, 500),
-        criteria: String(args.criteria).slice(0, 500),
-        setAt: Date.now(),
-        status: "active",
-        turnsUsed: 0,
-        _blockTally: null, // { reason, count } — consecutive count of the same blocking condition (for blocked audit)
-      }
-      return `Goal set: ${agent.goal.objective}\nDone when: ${agent.goal.criteria}\nThe system will inject goal status every turn. Completion and blocked claims are audited — see the reminders.`
-    }
-    if (!agent.goal || agent.goal.status !== "active") {
-      return `Error: no active goal to '${args.action}' (current: ${agent.goal?.status ?? "none"}). Set one first.`
-    }
-    if (args.action === "complete") {
-      // Evidence chain threshold: files were mutated this run without verify — refuse completion (aligns with completion guard)
-      if (agent._mutatedThisRun && !agent._verifiedThisRun) {
-        return "Error: files were modified but verify has not run. Run the check your criteria names AND the verify tool before marking the goal complete — false completion is the worst outcome of autonomous work."
-      }
-
-      // Independent judge: verify the goal was actually achieved
-      // Only applies when the agent is at depth 0 (not a subagent) and has history to review
-      if (ctx.depth === 0 && agent.history.length > 2) {
-        try {
-          // Extract recent activity: last 4 assistant messages (summarizing what was done)
-          const recent = agent.history.filter(m => m.role === "assistant").slice(-4)
-          const activity = recent.map(m => (m.content ?? "").slice(0, 500)).join("\n---\n")
-          const { chat } = await import("../provider/index.mjs")
-          const judgeRes = await chat(agent.provider, {
-            messages: [{
-              role: "user",
-              content: `You are an independent goal judge. Evaluate whether this goal has been achieved based on the agent's activity.
-
-Goal: ${agent.goal.objective}
-Success criteria: ${agent.goal.criteria}
-
-Recent agent activity:
-${activity || "(no activity recorded)"}
-
-Has this goal been achieved? Answer ONLY "YES" or "NO" followed by a one-sentence reason.`,
-            }],
-            tools: [],
-            signal: AbortSignal.timeout(10_000),
-            // §18.6 D-TR4/D-TR6（2026-09-04 fix round1）：goal 独立评审调用经 chat()
-            // 唯一采集点——补轨迹元数据 + traces 开关透传（agent.config.traces.enabled
-            // ——关=不落盘必须全覆盖——与 agent.mjs/context.mjs 同模式）
-            logCtx: {
-              stage: "goal", kind: "goal",
-              role: agent._role ?? null, depth: ctx.depth,
-              session: agent._sessionStart ?? null, cwd: agent.cwd,
-              traces: agent.config?.traces?.enabled !== false,
-            },
-          })
-          const verdict = (judgeRes.content ?? "").trim()
-          if (verdict.toUpperCase().startsWith("NO")) {
-            return `Goal NOT complete (judge says NO): ${verdict.slice(2).trim()}\n\nContinue working or report blocked if this is a true impasse.`
-          }
-          if (!verdict.toUpperCase().startsWith("YES")) {
-            return `Goal completion unverified — judge response ambiguous: "${verdict.slice(0, 200)}". Re-check your criteria and try again with clear evidence.`
-          }
-        } catch {
-          // Judge unavailable — allow completion but note it
-        }
-      }
-
-      agent.goal.status = "complete"
-      return `Goal verified complete ✓: ${agent.goal.objective}\nIn your next message, summarize the evidence (what check ran, what it showed) — the user should be able to audit this claim.`
-    }
-    if (args.action === "blocked") {
-      if (!args.reason) return "Error: 'reason' required for 'blocked' action."
-      // Blocked audit: same condition must appear 3 consecutive times (only counts as real blocking if different approaches still hit the same wall)
-      const tally = agent.goal._blockTally
-      const count = tally?.reason === args.reason ? tally.count + 1 : 1
-      agent.goal._blockTally = { reason: args.reason, count }
-      if (count < 3) {
-        return `Blocked not accepted yet (${count}/3 for this condition). Try a genuinely different approach first; report blocked only if the same condition stops you ${3 - count} more time(s).`
-      }
-      agent.goal.status = "blocked"
-      return `Goal marked blocked after 3 attempts: ${args.reason}\nExplain the blocker to the user in your next message — what you tried, and what you need (clarification, permission, a decision).`
-    }
-    return `Error: unknown action '${args.action}'.`
-  },
-}

package/src/agent-tools/plan.mjs

@@ -1,81 +0,0 @@
-/**
- * plan tool: enter/exit plan mode.
- * In plan mode only read-only tools are allowed — explore code, design solutions, no code writing.
- * After the user approves the plan, exit plan mode and start implementing.
- *
- * Reminder cadence (kimi-code style): while plan mode is active the agent loop
- * re-injects reminders — sparse every 2 turns, full every 5 turns or when the
- * user sends a new message — so the constraint never fades from context.
- */
-
-const PLAN_FULL_REMINDER =
-  "[System reminder: plan mode is ON. Workflow: (1) explore/read codebase with read-only tools, " +
-  "(2) design a solution considering trade-offs, (3) present your plan by calling plan with action='exit' " +
-  "so the user can approve it. Only read-only tools are allowed — do not write, edit, or run mutation commands. " +
-  "Your turn must end with either a clarifying question to the user or a call to plan with action='exit'.]"
-
-const PLAN_SPARSE_REMINDER =
-  "[System reminder: plan mode still active — read-only tools only (the current plan file exempt). " +
-  "Design the solution, then call plan with action='exit' for user approval.]"
-
-const PLAN_EXIT_REMINDER =
-  "[System reminder: plan mode is now OFF. Start implementing your plan — edit files, run commands. " +
-  "No need for a task list (plan already covered that) or further confirmation.]"
-
-/** Turns between reminder re-injections while plan mode is active */
-const SPARSE_INTERVAL = 2
-const FULL_INTERVAL = 5
-
-/**
- * Decide which plan-mode reminder (if any) to inject this turn.
- * @param {object} agent — the agent object (mutated: tracks reminder state)
- * @param {boolean} userMessageSince — whether a user message arrived since the last reminder
- * @returns {string|null} reminder text or null
- */
-export function planReminderForTurn(agent, userMessageSince) {
-  if (!agent.planMode) {
-    agent._planTurnsSinceReminder = 0
-    agent._planTurnsSinceSparse = 0
-    return null
-  }
-  agent._planTurnsSinceReminder = (agent._planTurnsSinceReminder ?? 0) + 1
-  agent._planTurnsSinceSparse = (agent._planTurnsSinceSparse ?? 0) + 1
-  if (userMessageSince || agent._planTurnsSinceReminder >= FULL_INTERVAL) {
-    agent._planTurnsSinceReminder = 0
-    agent._planTurnsSinceSparse = 0
-    return PLAN_FULL_REMINDER
-  }
-  if (agent._planTurnsSinceSparse >= SPARSE_INTERVAL) {
-    agent._planTurnsSinceSparse = 0
-    return PLAN_SPARSE_REMINDER
-  }
-  return null
-}
-
-export const planTool = {
-  name: "plan",
-  description:
-    "Enter or exit plan mode. In plan mode you are restricted to READ-ONLY tools: read files, search code, run read-only shell commands. Use plan mode before complex multi-step tasks — explore the codebase, design the architecture, present a plan to the user. When the user approves, exit plan mode and implement. For simple single-file edits, skip plan mode and just make the change.",
-  parameters: {
-    type: "object",
-    properties: {
-      action: { type: "string", enum: ["enter", "exit"], description: "Enter or exit plan mode" },
-    },
-    required: ["action"],
-  },
-  readonly: true,
-  async execute(args, ctx) {
-    if (args.action === "exit") {
-      ctx.agent.planMode = false
-      ctx.agent._planTurnsSinceReminder = 0
-      ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
-      ctx.agent._pendingReminders.push(PLAN_EXIT_REMINDER)
-      return "Plan mode exited. You may now edit files and run commands."
-    }
-    ctx.agent.planMode = true
-    ctx.agent._planTurnsSinceReminder = 0
-    ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
-    ctx.agent._pendingReminders.push(PLAN_FULL_REMINDER)
-    return "Plan mode activated. You are now restricted to READ-ONLY tools. Explore the codebase, understand the architecture, design a solution. Present your plan to the user for approval before writing any code."
-  },
-}

package/src/agent-tools/read-history.mjs

@@ -1,309 +0,0 @@
-/**
- * agent-tools/read-history.mjs — read_history tool (SESSION.md §9 + §13 R19 cross-session).
- *
- * Query message history — THIS session by default, any session on disk with `path`
- * (SESSION.md §13 R19): an explicit session file path deep-queries that file's
- * history line; "cwd:<dir>" discovers the sessions stored for that directory.
- *
- * Default (no path) — THIS session's full human-readable record (record store when bound
- * — disk-backed, SESSION.md §14.3.7; agent._fullHistory memory fallback otherwise:
- * NEVER compacted, audit-complete). Use to recall what was said or done earlier:
- * design decisions, tool-call timing, past rulings.
- *
- * Filters AND together: role / keyword (message text) / tool (tool messages by
- * name + assistant messages that declared the call) / since-until (epoch ms
- * window, inclusive-inclusive, matches ONLY messages that carry ts) /
- * limit (default 50, clamped to 200) / direction (oldest/newest — which end of
- * the matched set the limit window is taken from).
- *
- * Returns a JSON array in chronological order. Every message without ts comes
- * back as ts:null and can never match a time window (legacy sessions). Content
- * is truncated to ~500 chars with an explicit marker — full text lives in the
- * session file. assistant tool_calls are summarized to a name list (arguments
- * never expanded).
- *
- * Cross-session (SESSION.md §13 D-R19a): path = a session file path (absolute, or
- * relative to the project cwd) → read that file's history line and apply the SAME
- * filter surface; path = "cwd:<dir>" → list every slot stored for that directory
- * (slot number + full file path + title/message count/updatedAt — no dead-slot
- * filtering, v1 decision). Single-file retrieval is guarded by a line-scan cap
- * (READ_HISTORY_SCAN_MAX — an oversized file is refused before it is read whole)
- * plus a message-count cap (READ_HISTORY_MAX_MESSAGES = 50,000 — L24 双保险第二道).
- *
- * readonly: true — planMode pass / no permission ask. Registered depth-0 only:
- * subagents get their own throwaway history, so querying "the session" from a
- * child would be semantically confusing (SESSION.md §9.5 refinement 1 + §13 T-R19.4).
- * §13 R19 extension mirrored per SESSION.md §13 — double-end isomorphic, no
- * cross-end byte test (thincoder-vscode/src/agent-tools/read-history.mjs).
- */
-
-import { openSync, readSync, closeSync, readFileSync, existsSync, statSync } from "node:fs"
-import { isAbsolute, resolve } from "node:path"
-import { listSlots, slotPath } from "../session-slots.mjs"
-
-const DEFAULT_LIMIT = 50
-const MAX_LIMIT = 200
-const CONTENT_CAP = 500
-const VALID_ROLES = new Set(["user", "assistant", "tool"])
-
-/** 单槽检索行扫护栏（SESSION.md §13 D-R19a——评审 #3 定稿：超限不再读全文，返回定稿错误文案）。 */
-export const READ_HISTORY_SCAN_MAX = 200_000
-
-/** L24 消息数预算（评审 #2 钉死——双保险第二道）：行扫按物理 \n 行计——JSON 单行槽
- *  行扫不设防——parse 后 history 数组长度超限即拒（同款定稿文案——双端同常量同文案）。 */
-export const READ_HISTORY_MAX_MESSAGES = 50_000
-
-/** 超限错误文案（SESSION.md §13——逐字定稿——T-R19.7 断言）。 */
-const TOO_LARGE_ERROR = JSON.stringify({ error: "session too large — refine keyword or since/until" })
-
-/** 检索/记忆族消歧总纲（SESSION.md §13 D-R19b——逐字定稿——read_history 描述尾段——T-R19.5 锚）。 */
-const SEARCH_FAMILY_GUIDE =
-  "检索/记忆族选哪个：查**本会话**说过/裁定过 → read_history（默认）；查**别的会话/项目**旧对话 → read_history 带 path/cwd 参数；查**本 run 改过哪些文件** → recent_changes；查**跨会话已存知识/约定**（memory）→ memory search；查**项目设计文档** → doc_search；查**代码实现** → code_search；查 git 历史快照 → checkpoint cat/versions。read_history 只查会话消息——文件级改动用 recent_changes——知识与约定用 memory——互相不替代。"
-
-/** Message text for keyword matching + output: strings pass through; multimodal content arrays → text parts joined (never crashes, empty parts skipped, images ignored). */
-function messageText(m) {
-  if (typeof m?.content === "string") return m.content
-  if (Array.isArray(m?.content)) {
-    return m.content
-      .map((p) => (p && typeof p === "object" && p.type === "text" ? p.text ?? "" : ""))
-      .filter((t) => t.length > 0)
-      .join(" ")
-  }
-  return ""
-}
-
-/** Truncate long content (~500 chars) with an explicit marker. The cut never splits a UTF-16
- *  surrogate pair (emoji etc.) — a lone high surrogate in tool output would be an eyesore at
- *  minimum; the send layer sanitizes it anyway, but clean output costs nothing (setup.mjs
- *  safeSliceUTF16 same rule). */
-function truncateContent(text) {
-  const t = String(text ?? "")
-  if (t.length <= CONTENT_CAP) return t
-  let end = CONTENT_CAP
-  if (t.charCodeAt(end - 1) >= 0xd800 && t.charCodeAt(end - 1) <= 0xdbff) end-- // high surrogate at the cut → step back
-  return t.slice(0, end) + `\n… (truncated: ${t.length - end} chars — full text is in the session file)`
-}
-
-/** Tool name across both stored shapes ({function:{name}} and flat {name}). */
-function toolCallName(tc) {
-  return tc?.function?.name ?? tc?.name ?? ""
-}
-
-/** Parse a ts window boundary (epoch ms number; numeric strings tolerated). Returns the number or an error string. */
-function parseTs(value, label) {
-  if (value === undefined || value === null) return null
-  const n = typeof value === "number" ? value : Number(value)
-  if (!Number.isFinite(n)) return `Error: invalid ${label} "${value}" — must be epoch milliseconds (number)`
-  return n
-}
-
-/** Map one matched message to its JSON entry shape. */
-function toEntry(m) {
-  const entry = {
-    ts: typeof m.ts === "number" ? m.ts : null,
-    role: m.role ?? null,
-  }
-  if (m.name !== undefined) entry.name = m.name
-  if (m.tool_call_id !== undefined) entry.tool_call_id = m.tool_call_id
-  entry.content = truncateContent(messageText(m))
-  if (Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
-    entry.tool_calls = m.tool_calls.map(toolCallName).filter(Boolean)
-  }
-  return entry
-}
-
-/** AND-filter one history message (role/keyword/tool/since-until) — shared by the in-memory
- *  default and the cross-session file query (SESSION.md §13 D-R19a: 同 filter 面应用). */
-function matches(m, { role, kwRe, tool, since, until }) {
-  if (!m || typeof m !== "object") return false
-  if (role !== undefined && m.role !== role) return false
-  if (kwRe) {
-    const text = messageText(m)
-    if (!kwRe.test(text)) return false
-  }
-  if (tool) {
-    const byName = m.role === "tool" && m.name === tool
-    const byDeclaration = m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.some((tc) => toolCallName(tc) === tool)
-    if (!byName && !byDeclaration) return false
-  }
-  const ts = m.ts
-  if (since !== null || until !== null) {
-    if (typeof ts !== "number") return false // no ts → no time-window match
-    if (since !== null && ts < since) return false
-    if (until !== null && ts > until) return false
-  }
-  return true
-}
-
-/** Direction picks the END of the matched set; output stays chronological either way. */
-function formatMatches(matched, direction, limit) {
-  const windowed = direction === "oldest" ? matched.slice(0, limit) : matched.slice(-limit)
-  return JSON.stringify(windowed.map(toEntry))
-}
-
-/** Line-scan guard: stream-count physical newlines, bailing the moment the cap is crossed —
- *  an oversized file is refused BEFORE it is read whole ("不再读全文"——SESSION.md §13 D-R19a). */
-function exceedsScanMax(file) {
-  const CHUNK = 64 * 1024
-  let fd = null
-  try {
-    fd = openSync(file, "r")
-    const buf = Buffer.alloc(CHUNK)
-    let newlines = 0
-    for (;;) {
-      const n = readSync(fd, buf, 0, CHUNK, null)
-      if (n <= 0) break
-      for (let i = 0; i < n; i++) {
-        if (buf[i] === 0x0a) newlines++
-      }
-      if (newlines > READ_HISTORY_SCAN_MAX) return true
-    }
-    return false
-  } catch {
-    return false // 行扫失败 → 交由后续读取/解析路径给出真实错误
-  } finally {
-    if (fd !== null) {
-      try { closeSync(fd) } catch { /* ignore */ }
-    }
-  }
-}
-
-/** Cross-session deep query: one session file, same filter surface (§13 D-R19a). */
-function querySessionFile(pathArg, { role, kwRe, tool, since, until, direction, limit }, baseCwd) {
-  const file = isAbsolute(pathArg) ? pathArg : resolve(baseCwd ?? process.cwd(), pathArg)
-  if (!existsSync(file)) return `Error: session file not found: ${file}`
-  if (exceedsScanMax(file)) return TOO_LARGE_ERROR
-  let text
-  try {
-    text = readFileSync(file, "utf8")
-  } catch (e) {
-    return `Error: failed to read session file ${file}: ${e.message}`
-  }
-  let data
-  try {
-    data = JSON.parse(text)
-  } catch (e) {
-    return `Error: ${file} is not a valid session file (corrupt JSON: ${e.message})`
-  }
-  if (!data || typeof data !== "object" || !Array.isArray(data.history)) {
-    return `Error: ${file} is not a valid session file (no history array)`
-  }
-  if (data.history.length > READ_HISTORY_MAX_MESSAGES) {
-    // L24 消息数第二道（parse 后——行扫按物理行、单行 JSON 槽行扫不设防——超限同款拒绝）。
-    return TOO_LARGE_ERROR
-  }
-  const matched = data.history.filter((m) => matches(m, { role, kwRe, tool, since, until }))
-  return formatMatches(matched, direction, limit)
-}
-
-/** Discovery surface (path = "cwd:<dir>"): list every slot stored for that directory, one line
- *  per slot — slot number + FULL session file path + title/message count/updatedAt（§13 D-R19a
- *  ——评审 #2：摘要必须含寻址字段——模型第二步深查 = 复制行内文件路径重调 path=）。 */
-function discoverCwd(raw, baseCwd) {
-  const dir = resolve(baseCwd ?? process.cwd(), raw)
-  let st = null
-  try {
-    st = statSync(dir)
-  } catch { /* fallthrough to the explicit error below */ }
-  if (st === null || !st.isDirectory()) {
-    return `Error: unknown cwd "${raw}" — no session directory for this cwd (directory not found: ${dir})`
-  }
-  const slots = listSlots(dir) // 时间序（updatedAt 降序）——含 manifest 记录的全部槽（v1 不做死槽过滤）
-  if (slots.length === 0) {
-    return `(no session slots found for cwd: ${dir} — no sessions started there yet)`
-  }
-  const lines = slots.map((s) => {
-    const title = s.title ? `"${s.title}"` : "(untitled)"
-    return `slot ${s.slot}: ${slotPath(dir, s.slot)} — title: ${title}, messages: ${s.messageCount}, updatedAt: ${s.updatedAt}`
-  })
-  return `Session slots for cwd: ${dir} (newest first):\n${lines.join("\n")}`
-}
-
-export const readHistoryTool = {
-  name: "read_history",
-  description:
-    "Query message history — THIS session by default, any session on disk with `path`. " +
-    "Default (no path): THIS session's full record (never compacted, audit-complete) — recall what " +
-    "was said or done earlier: design decisions, tool-call timing, past rulings. " +
-    "Filters combine with AND: role / keyword (case-insensitive substring of message text) / " +
-    "tool (tool result messages by name AND the assistant messages that declared the call — pair with tool_call_id / ts for timing) / " +
-    "since-until (epoch ms time window; only messages with ts can match) / limit (default 50, clamped to 200) / direction (which end of the matches to take). " +
-    "Returns a JSON array in chronological order: [{ts, role, name?, tool_call_id?, content (≈500 chars, truncated marker), tool_calls (names only)}]. " +
-    "Messages without ts return ts:null. Content is truncated — the full text is in the session file. " +
-    "Cross-session (path, optional): a session file path deep-queries THAT session's history with the same filters " +
-    "(relative paths resolve against the project cwd); \"cwd:<dir>\" lists every session slot stored for that directory — " +
-    "one line per slot: slot number + full session file path + title + message count + updatedAt; copy a listed file path into path= to deep-query it. " +
-    "A session file over 50,000 messages or 200,000 lines is refused (\"session too large\") instead of being read whole.\n" +
-    SEARCH_FAMILY_GUIDE,
-  parameters: {
-    type: "object",
-    properties: {
-      role: { type: "string", enum: ["user", "assistant", "tool"], description: "Only messages with this role." },
-      keyword: { type: "string", description: "Case-insensitive substring of the message text (multimodal messages match on their text parts)." },
-      tool: { type: "string", description: "Only messages for this tool: role=tool messages with name=tool, plus assistant messages that declared a call to it." },
-      since: { type: "integer", description: "Earliest ts to match, epoch ms, INCLUSIVE. Messages without ts never match a time window." },
-      until: { type: "integer", description: "Latest ts to match, epoch ms, INCLUSIVE. since > until yields an empty result." },
-      limit: { type: "integer", description: "Maximum messages to return (default 50; larger values are clamped to 200)." },
-      direction: { type: "string", enum: ["oldest", "newest"], description: "Take the limit window from the oldest or newest end of the matched set (default newest)." },
-      path: { type: "string", description: "Optional — query another session instead of this one: a session file path (as listed by a \"cwd:<dir>\" call) deep-queries that session; \"cwd:<dir>\" lists that directory's session slots (slot number + full file path + title + message count + updatedAt)." },
-    },
-  },
-  readonly: true,
-  execute(args, ctx) {
-    const a = args ?? {}
-    if (a.path !== undefined && (typeof a.path !== "string" || a.path.trim().length === 0)) {
-      return `Error: invalid path "${a.path}" — must be a session file path or "cwd:<dir>"`
-    }
-    const role = a.role
-    if (role !== undefined && (typeof role !== "string" || !VALID_ROLES.has(role))) {
-      return `Error: invalid role "${role}" — valid roles: user, assistant, tool`
-    }
-    const direction = a.direction ?? "newest"
-    if (direction !== "oldest" && direction !== "newest") {
-      return `Error: invalid direction "${direction}" — valid values: oldest, newest`
-    }
-    const since = parseTs(a.since, "since")
-    if (typeof since === "string") return since
-    const until = parseTs(a.until, "until")
-    if (typeof until === "string") return until
-    let limit = DEFAULT_LIMIT
-    if (a.limit !== undefined) {
-      limit = Math.floor(Number(a.limit))
-      if (!Number.isFinite(limit)) return `Error: invalid limit "${a.limit}" — must be a number`
-      limit = Math.min(Math.max(1, limit), MAX_LIMIT)
-    }
-    const keyword = typeof a.keyword === "string" && a.keyword.length > 0 ? a.keyword : null
-    // Case-insensitive substring WITHOUT copying the full message text: the human line is
-    // never compacted (绑定态存储行 = slimForDisplay 产物——匹配基准 delta 见 SESSION.md
-    // §14.3.7 / T-RS8b) — single tool results can be hundreds of KB to MBs. Lowercase the
-    // needle once and run a regex-i test over the haystack (escaping regex metachars so the
-    // keyword stays a literal substring).
-    const kwRe = keyword ? new RegExp(keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i") : null
-    const tool = typeof a.tool === "string" && a.tool.length > 0 ? a.tool : null
-    const baseCwd = ctx.agent?.cwd ?? process.cwd()
-
-    const pathArg = typeof a.path === "string" && a.path.trim().length > 0 ? a.path.trim() : null
-    if (pathArg !== null) {
-      return pathArg.startsWith("cwd:")
-        ? discoverCwd(pathArg.slice("cwd:".length), baseCwd)
-        : querySessionFile(pathArg, { role, kwRe, tool, since, until, direction, limit }, baseCwd)
-    }
-
-    // 本会话（无 path）：绑定记录存储 → 方向流式迭代（磁盘为准——全量可见、内存窗口外
-    // 可命中；§14.3.7）；未绑定（测试 / 模式 F）→ 内存 _fullHistory 既有过滤路径（回退保留）。
-    // 方向语义不变：newest 自尾向前取满 limit → 反转回时间序（输出恒时间序）。
-    const store = ctx.agent?._recordStore
-    if (store?.iterate) {
-      const taken = []
-      for (const m of store.iterate(direction)) {
-        if (!matches(m, { role, kwRe, tool, since, until })) continue
-        taken.push(m)
-        if (taken.length >= limit) break
-      }
-      return formatMatches(direction === "newest" ? taken.reverse() : taken, "oldest", limit)
-    }
-    const history = Array.isArray(ctx.agent?._fullHistory) ? ctx.agent._fullHistory : []
-    const matched = history.filter((m) => matches(m, { role, kwRe, tool, since, until }))
-    return formatMatches(matched, direction, limit)
-  },
-}

package/src/agent-tools/recent-changes.mjs

@@ -1,24 +0,0 @@
-/**
- * recent_changes tool: list files touched by this agent run (write/edit/insert_after/delete).
- * More precise than git status — only looks at this session's changes, independent of git tracking.
- * Helps the model recall what it already modified during long tasks.
- */
-export const recentChangesTool = {
-  name: "recent_changes",
-  description:
-    "Show files modified in this agent run (write/edit/insert_after/delete). " +
-    "Use when you need to remember which files you've already touched — during long multi-file tasks, " +
-    "it's easy to lose track. This is scoped to the current run, unlike git status which shows all uncommitted changes. " +
-    "For session-level history (what was said in a session), use read_history.",
-  parameters: {
-    type: "object",
-    properties: {},
-  },
-  readonly: true,
-  execute(args, ctx) {
-    const files = ctx.agent._touchedFiles ?? []
-    if (files.length === 0) return "(no files modified in this run yet)"
-    const deduped = [...new Set(files)]
-    return `Touched ${deduped.length} file(s) this run:\n${deduped.join("\n")}`
-  },
-}

package/src/agent-tools/review-streak.mjs

@@ -1,93 +0,0 @@
-/**
- * review-streak.mjs — design-review failure streak guard（第 33 批——2026-09-11）。
- *
- * 同一 doc-set 的 design 评审**连续**未产出可用结算（宿主截断尾五 kind + 陈旧结算 +
- * 凭证落盘失败 + 无报告结算）达 `MAX_DESIGN_REVIEW_STREAK` 次 ⇒ 后续发起被拒
- * （工具层预检 + `runAdvisorReview` 内防线两级——零 LLM / 不耗轮次 / 不置「评审已覆盖」）。
- * 设计权威 = `docs/design/ADVISOR-CONVERGENCE.md` §17（需求 = requirements 档 §12 F28/F29 + N20/N21）。
- *
- * 中立模块（**不 import 任何 src/ 模块**——打断潜在环，§17.5 模块图）：
- *  - `normAbs` 自 advisor-settle.mjs 迁入（原处 re-export——既有 import 面零变）；
- *  - `docSetKey` 自 advisor-async.mjs 迁入（原为私有——零 import 面）。
- * 分类单源：`designReviewOutcome` 为异步结算 / 同步面两计数点共用（D-SK8——防两处分类漂移）。
- * 载体 = 会话级内存 `agent._designReviewStreaks`（Map——不落盘、不进 session 文件；
- * eng 模式切换不清护栏——与 `_advisorRuns` 刻意不同步，§17.9 #5 定案）。
- */
-import { join } from "node:path"
-
-/** 连续未产出可用结算的阈值（三振——§17.2 表 1 选定 N=3；`MAX_ADVISOR_ROUNDS` 零改动）。 */
-export const MAX_DESIGN_REVIEW_STREAK = 3
-
-/** ABS 归一（cwd 相对 → cwd 拼接）——陈旧判定 / 冻结拦截 / doc-set 键同源（§14.14 E-4）。 */
-export function normAbs(p, cwd) {
-  const s = String(p)
-  return /^[a-zA-Z]:[\\/]/.test(s) || s.startsWith("/") || s.startsWith("\\\\") ? s : join(cwd, s)
-}
-
-/** Canonical scope key for design reviews — the document multi-set
- *  (order-insensitive, ABS-path normalized — launch 与 continuation 的写法差异
- *  ("./docs/x.md" vs "docs/x.md"、反斜杠) 不误建新实例).
- *  第 33 批自 advisor-async.mjs 逐字迁入（护栏与实例续跑同锚单源）。 */
-export function docSetKey(documents, cwd) {
-  const list = [...new Set((documents ?? [])
-    .filter((d) => typeof d === "string" && d.trim())
-    .map((d) => normAbs(d, cwd)))]
-  return JSON.stringify(list.sort())
-}
-
-/** 护栏适用的键判据：空清单（`[]` / `null` 的 `docSetKey` 产出 = "[]"）不适用——不计数、
- *  不停止（§17.9 #3 登记；fail-open 于此面）。 */
-export function designReviewStreakApplies(key) {
-  return typeof key === "string" && key.length > 0 && key !== "[]"
-}
-
-/**
- * 结算分类（纯函数单源——§17.3 优先级表，自上而下首个命中；输入 = 宿主可见事实，
- * **零 LLM 输出解析**，N20）。neutral = 无信息事件（取消 / 中断 / 拒发）——不打断连续计数。
- * @param {{launchRefused?: boolean, stale?: boolean, hasResult?: boolean,
- *          incomplete?: string|null, persistFailed?: boolean}} input
- * @returns {{reset: boolean, count: string|null}} reset=true 计数复位；count=需加一的类名；
- *   两者皆空 = neutral（不动计数）。
- */
-export function designReviewOutcome(input) {
-  const { launchRefused = false, stale = false, hasResult = true, incomplete = null, persistFailed = false } = input ?? {}
-  if (launchRefused) return { reset: false, count: null } // 1. 未发起请求（无尝试发生——§14.4 既有语义）
-  if (stale) return { reset: false, count: "stale" } // 2. 陈旧结算（未产出可用凭证）
-  if (!hasResult) return { reset: false, count: "no_report" } // 3. 无报告（fail-closed）
-  if (incomplete && incomplete !== "interrupted") return { reset: false, count: String(incomplete) } // 4. 宿主截断尾五 kind
-  if (incomplete === "interrupted") return { reset: false, count: null } // 5. 用户 / 系统中断类（与 cancelled 同族）
-  if (persistFailed) return { reset: false, count: "no_credential" } // 6. pass 但槽落盘失败（无可用凭证）
-  return { reset: true, count: null } // 7. 可用判决（pass 且落盘成功 / changes-required）——连续链断点
-}
-
-/** 记录只读视图（停止判定与结论表的数据源）；空清单键 / 无载体 ⇒ null。 */
-export function designReviewStreakRecord(agent, key) {
-  if (!designReviewStreakApplies(key)) return null
-  const streaks = agent?._designReviewStreaks
-  return streaks instanceof Map ? (streaks.get(key) ?? null) : null
-}
-
-/** 计数落账（§17.4）：reset ⇒ 删除该键记录；count ⇒ `{count: prev+1, log: […].slice(-N)}`；
- *  neutral ⇒ 不动。载体懒初始化。 */
-export function noteDesignReviewOutcome(agent, key, outcome) {
-  if (!agent || !designReviewStreakApplies(key) || !outcome) return
-  if (outcome.reset) {
-    if (agent._designReviewStreaks instanceof Map) agent._designReviewStreaks.delete(key)
-    return
-  }
-  if (typeof outcome.count !== "string" || !outcome.count) return
-  const streaks = agent._designReviewStreaks instanceof Map
-    ? agent._designReviewStreaks
-    : (agent._designReviewStreaks = new Map())
-  const prev = streaks.get(key)
-  streaks.set(key, {
-    count: (prev?.count ?? 0) + 1,
-    log: [...(prev?.log ?? []), outcome.count].slice(-MAX_DESIGN_REVIEW_STREAK),
-  })
-}
-
-/** 停止判定：记录达阈值即停；空清单键恒 false。停止不可自解除（复位仅经可用判决——被拒后
- *  无法发生；会话结束随载体清零）。 */
-export function designReviewStreakStopped(agent, key) {
-  return (designReviewStreakRecord(agent, key)?.count ?? 0) >= MAX_DESIGN_REVIEW_STREAK
-}