thincoder 0.12.61 → 0.12.63

package/src/agent-tools/eng.mjs

@@ -1,67 +0,0 @@
-/**
- * eng tool: enter/exit engineering mode.
- * In engineering mode the agent follows design-before-code methodology.
- * Toggled here at session level (in-memory flag; the session slot is the sole authority —
- * saveSession round-trips it at turn end; /eng writes the slot directly). The old ctx
- * state-persist hook was removed 2026-09-08 (ENG-SESSION-PROVIDER-CLEANUP D1.2): no
- * provider existed and its legacy payload keys were never read by applySession.
- * R16 (2026-09-06): design tokens are session-level flow credentials — mode toggles
- * do NOT clear them (ON→OFF keeps, OFF→ON does not require a fresh review); only TTL
- * expiry cleans tokens, at three points: restore filtering (session.mjs applySession) /
- * eng enter expired cleanup (below + cmd-eng ON) / spawn-gate expired rejection
- * (subagent-spawn.mjs). See docs/design/ENG-TOKEN-BINDING-TUNING.md §5/§5.1 (F-R16).
- */
-import { ENG_ON_REMINDER, ENG_OFF_REMINDER } from "../agent.mjs"
-import { purgeExpiredDesignTokens } from "../token-ttl.mjs"
-
-export const engTool = {
-  name: "eng",
-  description:
-    "Enter or exit engineering mode. In engineering mode, follow design-before-code: write a design document, run advisor design review, get user approval, then implement via eng-coder subagents. " +
-    "Returns the mode state — 'Engineering mode activated/exited' (an already-active state is acknowledged).",
-  parameters: {
-    type: "object",
-    properties: {
-      action: { type: "string", enum: ["enter", "exit"], description: "Enter or exit engineering mode" },
-    },
-    required: ["action"],
-  },
-  readonly: true,
-  async execute(args, ctx) {
-    ctx.agent.config.agent ??= {}
-    if (args.action === "exit") {
-      ctx.agent.config.agent.engineering = false
-      // R16 (F-R16a): OFF 不清 token——有效 token 跨模式存活（设计评审过的产物不因
-      // 开关重复烧）。过期清理跑在另外三处（恢复过滤 / 开模式 / spawn 门禁拒）。
-      ctx.agent._advisorRound = 0          // reset convergence budget
-      ctx.agent._advisorRuns = new Map()   // §11.2 D-24b: per-review instances die with the mode (fresh cycles)
-      ctx.agent._touchedFiles = []         // clear mutation tracking
-      ctx.agent._lastEngState = false
-      ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
-      ctx.agent._pendingReminders.push(ENG_OFF_REMINDER)
-      return "Engineering mode exited. Standard discipline now applies. You may edit files directly."
-    }
-    if (args.action === "enter") {
-      // Idempotent enter (v2 2026-08-25): already in engineering mode → pure no-op
-      // (cleanup only runs on a real off→on transition — T-R16c precondition: first
-      // exit/OFF, then enter; an already-on enter must not touch tokens at all).
-      if (ctx.agent.config.agent.engineering) {
-        return "Engineering mode already active. Existing design tokens stay valid."
-      }
-      ctx.agent.config.agent.engineering = true
-      // R16 (F-R16b ②): off→on 不重评——只清过期 token（用户裁定"打开工程模式时
-      // 应该清理"），有效 token 原样保留——遍历 Map 删过期，返回文案含清理个数。
-      const cleared = purgeExpiredDesignTokens(ctx.agent)
-      ctx.agent._advisorRuns = new Map() // §11.2 D-24b: per-review instances die with the mode (fresh cycles)
-      ctx.agent._lastEngState = true
-      ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
-      ctx.agent._pendingReminders.push(ENG_ON_REMINDER)
-      let msg = "Engineering mode activated. Design-before-code enforced: write a design document first (location per your project's document conventions), run advisor with type='design', get user approval, then implement via eng-coder subagents."
-      if (cleared > 0) {
-        msg += ` Cleared ${cleared} expired design token${cleared === 1 ? "" : "s"} — 清 ${cleared} 个过期 token，有效 token 保留（TTL 内不重评）。`
-      }
-      return msg
-    }
-    return "Invalid action: expected 'enter' or 'exit'"
-  },
-}

package/src/agent-tools/escalate-async.mjs

@@ -1,289 +0,0 @@
-/**
- * escalate-async.mjs — async 飞刀 runner (AGENT-LOOP.md §25 D-R17b — R17, 2026-09-06).
- *
- * The subagent action:"escalate" is DEFAULT-async at depth 0 (decision ③: the
- * depth-0-only escalate flips to async like every other background family;
- * `async: false` keeps the legacy synchronous flight). An async escalate runs in
- * the SHARED "other" pool domain (decision Q2 🅰 — the entry lives in
- * `_asyncSubagents` with role "escalate"/_pool "other", so it shares the 4-slot
- * other domain with explore/plan/coder spawns — capacity, queueing, refill,
- * status and cancel all come from the generic machinery):
- * - launch → ack {id, role:"escalate", status:"running"|"queued"[, position]};
- *   the turn ends naturally, the session suspends (poolLive counts the entry).
- * - settle THREE-WAY classification (review #4): done → merge-all mutations back
- *   into the parent's bookkeeping + overlap warning appended to the report
- *   (report-level, not a gate — round2 #4); error (child failure / turn cap) →
- *   partial mutations merged ONLY when the parent did not touch overlapping
- *   files since launch (overlap → no merge + differences listed in the report);
- *   cancelled → never reaches the digest stream (D-M6 — no merge, stopped
- *   reminder).
- * - the classified report lands in `_pendingAsyncResults`（pending 单容器 +role——
- *   ASYNC-RESULT-CONTAINER.md D2——挂起期 settle 移交）when the settle happens in a
- *   suspension, or stays pooled for the turn-end collection otherwise;
- *   injectAsyncResult's escalate
- *   role branch delivers the digest ("报告已 merge——可继续处置" — the action
- *   domain still follows the consuming turn's tier — no family exception).
- */
-import { relative, isAbsolute } from "node:path"
-import { runAgent, createAgent, DEFAULT_SUBAGENT_TURNS } from "../agent.mjs"
-import { runWithContinue, TURN_CAP_MARK, wrapChildCallbacks } from "../agent/spawn-child.mjs"
-import { logEvent } from "../log.mjs"
-import { deathLine } from "../abort-provenance.mjs"
-import {
-  mergeChildMutations, runningPoolCount, poolDomainOf, poolLimitsFor, ASYNC_POOL_LIMITS, enqueueAsk,
-} from "./subagent-async.mjs"
-import { refreshQueuedTokens, nextSubagentId } from "./subagent-scheduler.mjs"
-import { mutationSeqOf } from "./advisor-async.mjs"
-// ASYNC-RESULT-CONTAINER.md D3/D6：settle 公共收尾单点 + child signal 构建单点
-import { buildChildSignal, settleAsyncEntry } from "./async-settle.mjs"
-
-/** Parent-side mutations (absolute paths) committed AFTER the escalate launch —
- *  the overlap scan feeds the settle classification (review #4/round2 #4: the
- *  parent may have edited files while the flight ran). */
-function parentMutationsSince(parent, launchSeq) {
-  const out = []
-  for (const m of parent?._mutLog ?? []) {
-    if (m.seq <= (launchSeq ?? -1)) continue
-    for (const p of m.paths ?? []) if (!out.includes(p)) out.push(p)
-  }
-  return out
-}
-
-/** Files BOTH sides touched since launch (case-insensitive key on win32 —
- *  filesOverlap precedent). */
-function overlapPaths(parent, launchSeq, childTouched) {
-  const since = parentMutationsSince(parent, launchSeq)
-  if (since.length === 0 || !childTouched?.length) return []
-  const key = (p) => (process.platform === "win32" ? String(p).toLowerCase() : String(p))
-  const sinceKeys = new Set(since.map(key))
-  const hits = childTouched.filter((p) => sinceKeys.has(key(p)))
-  // relative display form (touchedFilesNote precedent)
-  const cwd = parent?.cwd ?? process.cwd()
-  return hits.map((p) => {
-    const r = relative(cwd, p)
-    return r && !r.startsWith("..") && !isAbsolute(r) ? r : p
-  })
-}
-
-/** Escalate-side touched files, relative display (or a placeholder). */
-function childTouchedDisplay(child, cwd) {
-  const touched = child?._touchedFiles ?? []
-  if (touched.length === 0) return "(none recorded)"
-  const shown = touched.map((f) => {
-    const r = relative(cwd ?? process.cwd(), f)
-    return r && !r.startsWith("..") && !isAbsolute(r) ? r : f
-  })
-  return shown.join(", ")
-}
-
-/** Relative touched-file list (mirror of the sync path's note). */
-function touchedFilesNote(child, cwd) {
-  const touched = child?._touchedFiles ?? []
-  if (touched.length === 0) return ""
-  const shown = touched.map((f) => {
-    const r = relative(cwd ?? process.cwd(), f)
-    return r && !r.startsWith("..") && !isAbsolute(r) ? r : f
-  })
-  return `\nTouched files: ${shown.join(", ")}`
-}
-
-/**
- * Async escalate settle — three-way classification (§25 D-R17b review #4):
- *  - done: merge ALL mutations (the escalation's changes are the parent's —
- *    verify/advisor guards must see them) + overlap warning into the report
- *    (report-level hint — not a gate — round2 #4);
- *  - error (child failure / turn cap): partial mutations merge ONLY without a
- *    parent-side overlap — overlap → NO merge + differences listed (the report
- *    carries both sides so the model can decide);
- *  - cancelled: nothing merges, never reaches pending (D-M6 — stopped reminder).
- * Runs BEFORE the pending transfer / digest injection. Mutates entry.report /
- * entry.error into the FINAL digest body (the family wording rides
- * injectAsyncResult's escalate branch).
- */
-export function classifyEscalateSettle(parent, entry) {
-  if (entry.cancelled) return { cancelled: true }
-  const child = entry.childAgent
-  const touched = child?._touchedFiles ?? []
-  const overlap = overlapPaths(parent, entry.launchSeq, touched)
-  const hasError = entry.error != null
-  const raw = hasError ? entry.error : entry.report
-  if (hasError) {
-    // error branch (child failure / turn cap — review #4): partial mutations
-    // merge ONLY when the parent did not touch overlapping files since launch.
-    // childAgent may be null when the flight died before child creation (advisor
-    // 复评 🟡2——防御：无 child 即无 partial mutations——不 merge 不崩）。
-    const merged = child != null && overlap.length === 0 && mergeChildMutations(parent, child)
-    let decision = ""
-    if (merged) {
-      decision = `\nPartial changes merged into the parent's bookkeeping (no parent-side overlap since launch).`
-    } else if (overlap.length > 0) {
-      decision = `\nPartial changes NOT merged — the parent changed overlapping files while this escalate ran: ${overlap.join(", ")}. Escalate-side changes: ${childTouchedDisplay(child, parent?.cwd)}. Review the conflict and decide what to keep (report-level — not a gate; AGENT-LOOP.md §25 D-R17b).`
-    }
-    // (nothing to merge + no overlap → the plain error report stands alone)
-    entry.error = `${raw}${decision}`
-    entry.report = null
-    return { cancelled: false, merged, overlap }
-  }
-  // done — merge-all + overlap warning into the report (report-level — not a gate)
-  const merged = mergeChildMutations(parent, child)
-  const overlapNote = overlap.length > 0
-    ? `\n⚠ Overlapping writes: the parent changed ${overlap.join(", ")} while this escalate ran — mutations merged all the same; review those files before building on the report (report-level warning — not a gate; AGENT-LOOP.md §25 D-R17b round2 #4).`
-    : ""
-  entry.report = `${raw}${overlapNote}`
-  return { cancelled: false, merged, overlap }
-}
-
-/**
- * Launch the async escalate (preflights already passed in executeEscalateAction):
- * pool admission into the shared OTHER domain → entry in `_asyncSubagents`
- * (generic queue/refill/status/cancel machinery) → ack. The flight starts on
- * entry.start() (immediately, or later via maybeRefillAsync when a slot frees).
- */
-export function launchEscalateAsync(parent, ctx, launch) {
-  const { task, provider, tag, effortNote } = launch
-  parent._asyncSubagents ??= new Map()
-  parent._asyncQueue ??= []
-  // Async id allocation (AGENT-LOOP.md §15 D-A1 precedent): reserve the relay
-  // counter at launch — the returned id stays stable while the entry sits queued.
-  // The [model] token (TUI block creation) is DEFERRED to actual start so queued
-  // flights don't paint an empty panel block (subagent-parity).
-  // SUBAGENT-ID-COUNTER-AGENT（2026-09-09）：取号统一走 nextSubagentId（池活续号
-  // 兜底——counter 载体= agent 本体 _subAgentCounter——跨 run/跨压缩存活）。
-  const id = nextSubagentId(parent)
-  const relayPrefix = `escalate#${id}/`
-  const entry = {
-    id, role: "escalate", relayPrefix,
-    _pool: poolDomainOf("escalate"), // other — shares the domain with explore/plan/coder (§11.1 D-24a)
-    status: "queued",
-    position: undefined,
-    report: null, error: null, done: false, cancelled: false,
-    promise: null, _settle: null, _settleSeq: 0,
-    model: provider.model ?? null,
-    startedAt: null,
-    turn: 0, maxTurns: 0,
-    controller: null,
-    _files: undefined, _dependsOn: undefined,
-    childAgent: null,
-    tag, effortNote, launchSeq: mutationSeqOf(parent),
-  }
-  const limits = poolLimitsFor(parent)
-  entry.status = runningPoolCount(parent, entry._pool) >= (limits[entry._pool] ?? ASYNC_POOL_LIMITS[entry._pool])
-    ? "queued" : "running"
-  entry.promise = new Promise((res) => { entry._settle = res })
-  const ctrl = new AbortController()
-  entry.controller = ctrl
-  // D6 buildChildSignal 单点（ASYNC-RESULT-CONTAINER.md——D5 同款：_sessionSignal 兜底）。
-  const baseSignal = buildChildSignal(parent, ctx)
-  if (baseSignal) {
-    // §20.3 站点 #10（第 24 批）：hop 逐跳保 reason
-    if (baseSignal.aborted) ctrl.abort(baseSignal.reason)
-    else baseSignal.addEventListener("abort", () => ctrl.abort(baseSignal.reason), { once: true })
-  }
-  // Turn mirror (⟦ev⟧turn from the child runAgent → entry.turn/maxTurns — status parity).
-  const flight = async () => {
-    entry.status = "running"
-    entry.position = undefined
-    entry.startedAt = Date.now()
-    ctx.callbacks?.onToken?.(relayPrefix + "⟦ev⟧async\x1e")
-    ctx.callbacks?.onToken?.(relayPrefix + "[model]" + (provider.model ?? ""))
-    const child = createAgent({
-      provider,
-      tools: parent.tools,
-      config: parent.config,
-      cwd: parent.cwd,
-      memory: parent.memory,
-      // G3（施工②）：overlay 摘除——coder 人格槽由 assemblePrompt 场景表承载（G3 映射）。
-      role: "coder",
-    })
-    entry.childAgent = child // settle 分类/status touched 摘要绑定（start 时刻）
-    child._logId = relayPrefix.slice(0, -1)
-    logEvent("child:spawn", { role: "escalate", id: child._logId, kind: "async", status: "running", ms: 0 })
-    const childCallbacks = wrapChildCallbacks(relayPrefix, ctx.callbacks ?? {})
-    const relayOnToken = childCallbacks.onToken
-    if (relayOnToken) {
-      childCallbacks.onToken = (t) => {
-        const ev = String(t).match(/^⟦ev⟧turn\x1e(\d+)\x1e(\d+)\x1e/)
-        if (ev) {
-          entry.turn = Number(ev[1]) || 0
-          entry.maxTurns = Number(ev[2]) || 0
-        }
-        return relayOnToken(t)
-      }
-    }
-    const runner = ctx.runAgent ?? runAgent
-    const runOpts = {
-      depth: 1,
-      maxTurns: parent.config?.agent?.subagentTurns ?? DEFAULT_SUBAGENT_TURNS,
-      signal: entry.controller.signal,
-    }
-    // 权限按 async 子代理同款装配：AUTO 直放行；手动档经父 _permQueue（并行子代理
-    // 审批不叠弹窗）——背景飞行撞门时无 handler → denied 不悬挂（D-S7 同规则）。
-    const childPermission = parent.autoApprove
-      ? async () => true
-      : async (name, toolArgs) => {
-          if (!ctx.onPermissionRequest) return false
-          const ask = () => ctx.onPermissionRequest(`escalate/${name}`, toolArgs)
-          return enqueueAsk(parent, "_permQueue", ask)
-        }
-    const report = await runWithContinue(
-      (childAgent, input, cbs, opts) => runner(childAgent, input, cbs, opts),
-      child, task,
-      { ...childCallbacks, onPermissionRequest: childPermission },
-      runOpts,
-      {
-        // 后台飞行不弹 continue 面板（D-A3 §15 例外同款）：AUTO && engineering 自动
-        // resume——escalate 只在 normal 模式可用（engineering 拒）——恒自动拒 → partial。
-        askContinue: () => Promise.resolve(Boolean(parent.config?.agent?.engineering && parent.autoApprove)),
-        onDeclined: (e, output) => `escalate (${tag})${entry.effortNote} ${TURN_CAP_MARK} (${e.turn} turns) — work may be partial; review recent_changes before deciding next steps.\nPartial output: ${output.slice(0, 2000)}`,
-      },
-    )
-    // done: compose the post-op body (the settle classification appends the
-    // overlap warning / merge notes afterwards)
-    return `escalate (${tag})${entry.effortNote} post-op report:\n${report || (child._capturedOutput ?? "").slice(0, 4000)}${touchedFilesNote(child, parent.cwd)}`
-  }
-  entry.start = () => {
-    flight()
-      .then((report) => {
-        // Turn-cap partial (runWithContinue auto-declined) classifies as the ERROR
-        // branch (design: 撞 turn cap = error — partial-merge decision applies):
-        // move it to entry.error so the classification + error digest wording fire.
-        if (String(report).includes(TURN_CAP_MARK)) entry.error = report
-        else entry.report = report
-      })
-      .catch((e) => {
-        // 运行失败/中止：错误文本落 entry.error（子代理同款——cancel 分支忽略它；
-        // Ctrl+I 中止的残条目由收尾消化带错误文本——不落空 "(no report)" digest）。
-        const child = entry.childAgent
-        // §20.3 第 3 条合成器（第 24 批）：原 message 前缀逐字保留 + 来源后缀
-        entry.error = `escalate (${tag}) error: ${deathLine(e, entry.controller?.signal)}\nPartial output: ${(child?._capturedOutput ?? "").slice(0, 2000)}`
-      })
-      .finally(() => {
-        // settle 公共收尾单点（ASYNC-RESULT-CONTAINER.md D3——settleAsyncEntry）：日志三连
-        // /cancelled 分支（出池+墓碑+⟦ev⟧stopped+提醒）/挂起分流（pending 单容器+出池——
-        // 统一守卫 !parentAborted——D4）/公共尾部（settleSeq/_settle/唤醒 waiter + 腾槽补位
-        // ——helper 尾部恒补）统一走共享 helper。族特有 hook = 三分类 merge 决策
-        // （classifyEscalateSettle——done/error 分类；cancelled 不经此——helper cancelled
-        // 分支先行）。
-        settleAsyncEntry(parent, entry, {
-          pool: parent._asyncSubagents,
-          ctx,
-          onAccounting: () => {
-            // Three-way settle classification (done/error/cancelled — review #4)：
-            // done → merge-all + 重叠警告；error → 无父侧重叠才 partial merge；
-            // cancelled 不经此（helper cancelled 分支先行）。
-            void classifyEscalateSettle(parent, entry)
-          },
-        })
-      })
-  }
-  parent._asyncSubagents.set(String(id), entry)
-  logEvent("child:spawn", { role: "escalate", id: `escalate#${id}`, kind: "async", status: entry.status, ms: 0 })
-  if (entry.status === "queued") {
-    parent._asyncQueue.push(entry)
-    entry.position = parent._asyncQueue.length
-    refreshQueuedTokens(parent, ctx.callbacks?.onToken)
-    return JSON.stringify({ id: String(id), role: "escalate", status: "queued", position: entry.position })
-  }
-  entry.start()
-  return JSON.stringify({ id: String(id), role: "escalate", status: "running" })
-}

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."
-  },
-}