thincoder 0.12.58 → 0.12.60

package/src/agent-tools/task.mjs

@@ -31,9 +31,10 @@ export const taskTool = {
   description:
     "Plan and track a task list for complex multi-step work. Each call replaces the entire list. " +
     "Keep exactly one item in_progress at a time; mark items done as you complete them; never mark done if tests fail or work is partial. " +
-    "Statuses: pending | in_progress | done. " +
-    "IMPORTANT: status must be exactly one of these three strings — no synonyms (e.g. 'completed', 'finished', 'open' are INVALID). " +
-    "IMPORTANT: title is required and must be a non-empty string — items with empty titles are silently dropped.",
+    "Statuses: pending | in_progress | done — synonyms (completed/finished/complete, todo/open/waiting, active/running/working, …) are accepted and normalized with a warning. " +
+    "IMPORTANT: title is required and must be a non-empty string — items with empty titles are silently dropped. " +
+    "For cross-session / project-level tracking, use checklist. " +
+    "Returns the updated task list (or the new item's ID on add).",
   parameters: {
     type: "object",
     properties: {

package/src/agent-tools/timer.mjs

@@ -11,25 +11,30 @@ export const timerTool = {
     "Set a timer before you start analyzing code. When the timer fires, " +
     "a system reminder will be injected suggesting you try running code or " +
     "adding debug logs. Use this to enforce a thinking budget: you get " +
-    "N seconds to reason, then the timer reminds you to act.",
+    "N seconds to reason, then the timer reminds you to act. " +
+    "Returns the set confirmation — the reminder fires at the deadline.",
   parameters: {
     type: "object",
     properties: {
       seconds: {
         type: "number",
-        description: "Thinking budget in seconds (default 30). Longer for complex reasoning, shorter for simple tasks.",
+        description: "Thinking budget in seconds (default 180). Longer for complex reasoning, shorter for simple tasks.",
       },
       message: {
         type: "string",
         description: "Custom reminder message to show when time is up. Default: a suggestion to add debug logs or run the code.",
       },
     },
-    required: ["seconds"],
+    required: [],
   },
   readonly: true,
   sideEffectExempt: true,
   execute(args, ctx) {
-    const seconds = args.seconds ?? 180
+    // D15.3#1：默认 180；非法值（非数字/非正数）显式报错——静默 NaN 定时器永不触发的坑
+    const seconds = Number(args.seconds ?? 180)
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+      throw new Error(`timer seconds must be a positive number, got: ${args.seconds}`)
+    }
     const expiresAt = Date.now() + seconds * 1000
     const message = args.message || `⏰ Time's up (${seconds}s). Have you tried running the code, adding a console.log, or checking the output? Thinking more without data is guessing.`
 

package/src/agent-tools/verify.mjs

@@ -1,218 +1,261 @@
+/**
+ * verify.mjs — verify tool: generic pre-completion verification gate (VERIFY-REDESIGN.md).
+ * Verify is language/framework/project agnostic: it does NOT hardcode any project's
+ * module→test mapping, does NOT auto-run any test/verification command, and does NOT
+ * require a test for every change. The model DECLARES its verification status via the
+ * `verification` argument (whether it already ran the project's verification and the
+ * result); verify makes a mechanical gate decision on that declaration. Which
+ * verification to run is described in natural language in each project's AGENTS.md —
+ * verify never parses or executes it. Retained mechanical checks: doc-only fast path,
+ * an advisory (non-gating) node --check hint, git diff report, and — on the code
+ * path (doc-only changes return early) — the task list and self-review checklist.
+ */
+
 import { isDocFile } from "../advisor/repos.mjs"
-import { execSync, spawn, spawnSync } from "node:child_process"
-import { readFileSync, existsSync } from "node:fs"
-import { join, resolve } from "node:path"
+import { execSync, spawnSync } from "node:child_process"
+import { existsSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+
+/**
+ * §18.12 D-VR1 path normalization — mirrors the §20.5 file-domain handling:
+ * resolved to an absolute path with forward slashes; dedup uses the win32
+ * lowercase comparison key (changedFileKey) so "D:/x/src/a.mjs" and
+ * "d:\\x\SRC\a.mjs" count as the same file.
+ */
+function normalizeChangedPath(p, base) {
+  return resolve(base, p).replace(/\\/g, "/")
+}
+
+/** Win32 comparison key: case-insensitive drives/folders (same file). */
+function changedFileKey(p) {
+  return process.platform === "win32" ? p.toLowerCase() : p
+}
 
 /**
- * Source module → test file mapping. Heuristic: the FIRST path component
- * after src/ determines the module. Map it to the test file that imports from it.
- * Modules without dedicated tests map to null.
+ * Nearest ancestor of an absolute path holding package.json or .git — the
+ * project/repo root. Walk stops at the filesystem root; returns null when no anchor exists.
  */
-const MODULE_TO_TEST = {
-  tools: "test/tools.test.mjs",
-  "agent-tools": "test/tools.test.mjs",
-  agent: "test/agent.test.mjs",
-  memory: "test/memory.test.mjs",
-  tui: "test/tui.test.mjs",
-  provider: "test/integration-provider.mjs",
-  config: "test/integration-provider.mjs",
-  skills: "test/tools.test.mjs",
-  distill: "test/tools.test.mjs",
-  markdown: "test/agent.test.mjs",
-  advisor: "test/advisor.test.mjs",
-  mcp: null,
-  prompts: null,
-  context: null,
-  session: null,
+function findProjectRoot(absPath) {
+  let dir = dirname(resolve(absPath))
+  for (;;) {
+    if (existsSync(join(dir, "package.json")) || existsSync(join(dir, ".git"))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
 }
 
 /**
- * Extract module name from a source path.
- * "src/tools/bash.mjs" → "tools", "src/agent.mjs" → "agent", "src/agent/helpers.mjs" → "agent"
+ * True when the path is under <projectRoot>/src/ (anchored via findProjectRoot —
+ * a parent-path /src/ segment outside the project must not classify a file as
+ * product code). Falls back to the loose /src/ pattern when no anchor exists.
  */
-function moduleName(srcPath) {
-  const rel = srcPath.replace(/^src[/\\]/, "")
-  const firstSlash = rel.search(/[/\\]/)
-  if (firstSlash === -1) return rel.replace(/\.mjs$/, "")
-  return rel.slice(0, firstSlash)
+function isUnderSrc(absPath) {
+  const root = findProjectRoot(absPath)
+  if (!root) return /(?:^|[\\/])src[\\/]/.test(absPath)
+  const norm = normalizeChangedPath(absPath, root)
+  return norm.startsWith(normalizeChangedPath("src", root) + "/")
 }
 
 /**
- * verify tool: pre-completion self-check. When called:
- * 0. Doc-only fast path — all changed files are docs (docs/, *.md, LICENSE…):
- *    short report, no syntax checks, no tests.
- * 1. git diff --stat — changed file list
- * 2. node --check — syntax check all changed .mjs/.js files
- * 3. Related tests — run test files that cover the changed modules (default)
- * 4. npm test — run ALL project tests (only when full=true)
- * 5. task list + self-review checklist
- * Default runs syntax checks + related tests; full=true runs the entire test suite.
- * Agent must not say "done" before verify passes. Fix-verify loop at most MAX_VERIFY_RETRIES rounds.
+ * D-V3 block guidance — a block message must not just say "not verified": it lists
+ * the changed code files and points to the project's AGENTS.md natural-language
+ * description of how to verify, so the model knows what to run/add.
+ */
+function appendBlockGuidance(lines, codeFiles) {
+  lines.push("")
+  lines.push("Changed code file(s):")
+  for (const f of codeFiles) lines.push(`  ${f}`)
+  lines.push("")
+  lines.push("verify does not run commands for you — decide and run the project's verification yourself.")
+  lines.push("Reference the verification approach declared in the project's AGENTS.md (natural language, e.g. \"tests run with npm test\" / \"no automated tests — rely on manual review\") to decide what to run, then call verify again declaring the outcome via verification.status.")
+}
+
+/**
+ * verify tool: generic pre-completion verification gate. Flow:
+ * 0. Doc-only fast path — all changed files are docs: short report, no verification needed.
+ * 1. git diff --stat — changed file list (_touchedFiles ∪ git diff)
+ * 2. Advisory syntax hint (D-V5) — node --check changed .js/.mjs when node exists; SOFT, not gating.
+ * 3. Verification gate (D-V1/D-V2) — requires the model to DECLARE verification.status:
+ *    passed → allowed; failed → blocked; skipped → allowed but needs a summary reason.
+ * 4. Task list + self-review checklist.
+ * Agent must not say "done" before verify passes.
  */
 export const verifyTool = {
   name: "verify",
   description:
-    "Run a pre-completion self-check. By default runs syntax checks on changed files AND any test files related to the changed modules, shows git diff and task list, and displays a self-review checklist. Set full=true to run the project's full test suite (npm test) instead of just related tests. Call this BEFORE declaring any coding task complete — do not say 'done' until verify passes.",
+    "Generic pre-completion verification gate — language/framework/project agnostic. verify does NOT run any test/verification command for you and does NOT require a test per change. You DECLARE your verification status via the verification argument: { status: 'passed' | 'failed' | 'skipped', command?, summary? }. 'passed' → allowed; 'failed' → blocked (cannot claim done); 'skipped' → allowed but requires a summary reason. Whether/how to verify is described in natural language in the project's AGENTS.md and is decided + executed by you — verify only mechanically gates on your declaration. Also reports changed files (git diff), an advisory node --check hint on changed .js/.mjs (not gating), the task list, and a self-review checklist. Call this BEFORE declaring a coding task complete — do not say 'done' until verify passes.",
   parameters: {
     type: "object",
     properties: {
-      full: { type: "boolean", description: "Run the full test suite (npm test) instead of just related tests. Default false — use sparingly, per the testing discipline rules." },
+      verification: {
+        type: "object",
+        description: "The model's declaration of whether it already ran the project's verification and its outcome. verify does not execute the command — it is self-reported evidence.",
+        properties: {
+          status: { type: "string", enum: ["passed", "failed", "skipped"], description: "The verification outcome you declare: 'passed' → allowed; 'failed' → blocked; 'skipped' → allowed but requires a summary reason." },
+          command: { type: "string", description: "Optional: the verification command you ran (self-reported — verify does not execute it)." },
+          summary: { type: "string", description: "Optional: summary/result of the verification. Required when status='skipped' — a concrete reason (e.g. \"project has no automated tests — verified by manual review\")." },
+        },
+        required: ["status"],
+      },
       workdir: { type: "string", description: "Optional: run verify in this subdirectory (relative to cwd or absolute) — for monorepos" },
-      filter: { type: "string", description: "Optional: limit the test run to matching test names (node --test-name-pattern / npm test -- --test-name-pattern)" },
     },
   },
   readonly: true,
-  outputPanel: true, // stream test output to a panel instead of inline
   async execute(args, ctx) {
     const cwd = ctx.agent.cwd
-    // workdir only relocates WHERE tests (and package.json) live — changed-file
-    // resolution (git diff) stays anchored to the project root.
+    // Changed-file resolution (§18.12 D-VR3): _touchedFiles (per-run bookkeeping,
+    // absolute paths) ∪ git diff fallback — git is tried at testCwd
+    // (workdir-resolved) first, then at ctx.agent.cwd; first success wins.
+    // git-diff paths are repo-root-relative — resolved against the discovered
+    // git root, then normalized (absolute, forward slashes, win32 key).
     const testCwd = args.workdir ? resolve(cwd, args.workdir) : cwd
     const lines = []
     lines.push("=== VERIFICATION REPORT ===")
     lines.push("")
 
-    // 1. Git diff — find changed files
-    let changedFiles = []
-    try {
-      const diff = execSync("git diff --stat", { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 })
-      if (diff.trim()) {
-        lines.push("Changed files (git diff --stat):")
-        lines.push(diff.trim())
-        // extract changed file paths
-        const nameOnly = execSync("git diff --name-only", { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 })
-        changedFiles = nameOnly.trim().split("\n").filter(Boolean)
-      } else {
-        lines.push("Changed files: (none — no uncommitted changes)")
-      }
-    } catch {
+    // 1. Changed files — _touchedFiles ∪ git diff (§18.12 D-VR1)
+    let gitOk = false
+    let gitStat = ""
+    let gitFiles = []
+    for (const gitCwd of new Set([testCwd, cwd])) {
+      try {
+        // Anchor the repo root FIRST (also proves git works here) — diff paths
+        // are repo-root-relative, so both diff calls run at the root.
+        const gitRoot = execSync("git rev-parse --show-toplevel", { cwd: gitCwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 }).trim() || gitCwd
+        const diff = execSync("git diff --stat", { cwd: gitRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 })
+        const nameOnly = execSync("git diff --name-only", { cwd: gitRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 })
+        gitOk = true
+        gitStat = diff.trim()
+        gitFiles = nameOnly.trim().split("\n").filter(Boolean).map((p) => normalizeChangedPath(p, gitRoot))
+        break
+      } catch { /* git unavailable here — try the next cwd in the chain */ }
+    }
+    if (gitOk && gitStat) {
+      lines.push("Changed files (git diff --stat):")
+      lines.push(gitStat)
+    } else if (gitOk) {
+      lines.push("Changed files: (none — no uncommitted changes)")
+    } else {
       lines.push("Changed files: (not a git repo or git unavailable)")
     }
+    // _touchedFiles: files written by the tools this run — captured regardless
+    // of git state (§18.12 F-VR1: subagent cwd ≠ git root must still locate).
+    const touchedFiles = (ctx.agent._touchedFiles ?? []).map((p) => normalizeChangedPath(p, cwd))
+    const gitKeys = new Set(gitFiles.map(changedFileKey))
+    const touchedOnly = touchedFiles.filter((p) => !gitKeys.has(changedFileKey(p)))
+    if (touchedOnly.length > 0) {
+      lines.push("")
+      lines.push("Changed files (this run — _touchedFiles):")
+      for (const f of touchedOnly) lines.push(`  ${f}`)
+    }
+    // Union, deduped by comparison key (win32 case-insensitive).
+    const changedKeys = new Set()
+    const changedFiles = [...touchedFiles, ...gitFiles].filter((p) => {
+      const k = changedFileKey(p)
+      if (changedKeys.has(k)) return false
+      changedKeys.add(k)
+      return true
+    })
+
+    // D-V11 G10 (doc-only/empty change set must not swallow an explicit failed):
+    // an explicit verification.status='failed' is ALWAYS respected — never
+    // overridden to pass by the doc-only fast path or the no-code-changed path
+    // below (D-V5 exception, review #6). Aligns CLI with VS Code (T-V8). Lists
+    // the changed files + points at AGENTS.md (D-V3 guidance).
+    if (args.verification?.status === "failed") {
+      lines.push("")
+      lines.push("VERIFY BLOCKED: you declared verification failed (verification.status = 'failed').")
+      lines.push("Do not say 'done' while verification fails — fix the issue, re-run the project's verification, then call verify again declaring the outcome.")
+      lines.push("")
+      lines.push("Changed file(s):")
+      for (const f of changedFiles) lines.push(`  ${f}`)
+      lines.push("")
+      lines.push("verify does not run commands for you — decide and run the project's verification yourself.")
+      lines.push("Reference the verification approach declared in the project's AGENTS.md (natural language, e.g. \"tests run with npm test\" / \"no automated tests — rely on manual review\") to decide what to run, then call verify again declaring the outcome via verification.status.")
+      ctx.agent._verifyPassed = false
+      return lines.join("\n")
+    }
 
     // 1b. Doc-only fast path: every changed file is documentation (docs/, *.md,
-    // LICENSE…) — syntax checks and tests are meaningless for doc changes, and
-    // the task list/self-review checklist add nothing either. Mirrors the
-    // advisor's doc-only review skip ("No issues found — documentation-only
-    // changes, code review skipped."). src/** (incl. prompts/*.md) is product
-    // code — excluded from the fast path, consistent with isProductCode.
-    // Empty list (no changes / git unavailable) intentionally falls through
-    // to the normal path below.
-    if (changedFiles.length > 0 && changedFiles.every((f) => !/^src[\\/]/.test(f) && isDocFile(f))) {
+    // LICENSE…) — syntax checks and a verification declaration are meaningless
+    // for doc changes, and the task list/self-review checklist add nothing either.
+    // src/** (incl. prompts/*.md) is product code — excluded from the fast path,
+    // consistent with isProductCode. Empty list (no changes / git unavailable)
+    // intentionally falls through to the normal path below.
+    if (changedFiles.length > 0 && changedFiles.every((f) => !isUnderSrc(f) && isDocFile(f))) {
       lines.push("")
       lines.push("Documentation-only changes — skipping syntax checks and tests.")
       ctx.agent._verifyPassed = true
       return lines.join("\n")
     }
 
-    // 2. Syntax check: run node --check on all changed .mjs/.js files (skip deleted files)
-    let syntaxFailed = false
-    const jsFiles = changedFiles.filter((f) => /\.(m?js)$/i.test(f))
+    // Code files needing verification: anything under src/ (incl. src/prompts/*.md)
+    // or any non-doc file (D-V1 — these require a verification declaration).
+    const codeFiles = changedFiles.filter((f) => isUnderSrc(f) || !isDocFile(f))
+
+    // 2. Advisory syntax hint (D-V5) — node --check on changed .js/.mjs when node
+    // exists. SOFT hint only — it does NOT gate done (no language-specific
+    // enforcement; a non-JS project or a missing node simply skips silently).
+    const jsFiles = codeFiles.filter((f) => /\.(m?js)$/i.test(f) && existsSync(f))
     if (jsFiles.length > 0) {
       lines.push("")
-      lines.push("Syntax check (node --check):")
+      lines.push("Advisory syntax hint (node --check — does not gate):")
       for (const f of jsFiles) {
-        const abs = join(cwd, f)
-        if (!existsSync(abs)) continue // skip deleted files
         try {
-          const result = spawnSync("node", ["--check", abs], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000 })
+          const result = spawnSync("node", ["--check", f], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000 })
           if (result.status !== 0) throw result
           lines.push(`  ✓ ${f}`)
         } catch (e) {
-          syntaxFailed = true
           const errOutput = (e.stderr || e.stdout || e.message || "").toString()
           const errMsg = errOutput.split("\n").slice(0, 3).join("\n")
-          lines.push(`  ✗ ${f}  — syntax error`)
+          lines.push(`  ⚠ ${f}  — node --check flagged it`)
           lines.push(`    ${errMsg.replace(/\n/g, "\n    ")}`)
         }
       }
-      if (!syntaxFailed) lines.push("  All syntax checks passed.")
     }
 
-    // 3. Identify related test files for changed source modules
-    const srcFiles = changedFiles.filter((f) => /^src[/\\].+\.mjs$/i.test(f) && existsSync(join(cwd, f)))
-    const modules = [...new Set(srcFiles.map(moduleName))]
-    const relatedTests = [...new Set(modules.map((m) => MODULE_TO_TEST[m]).filter(Boolean))]
-
-    // 4. Run tests
-    const pkgPath = join(testCwd, "package.json")
-    const hasTestScript = existsSync(pkgPath) && (() => { try { return !!JSON.parse(readFileSync(pkgPath, "utf8")).scripts?.test } catch { return false } })()
-
-    if (args.full) {
-      // Full mode: run the entire test suite
-      if (hasTestScript) {
+    // 3. Verification gate (D-V1/D-V2): the model declares its verification status.
+    if (codeFiles.length === 0) {
+      // No code changed (empty change set / only temp/non-code files) — nothing to verify.
+      lines.push("")
+      lines.push("No code files changed — nothing to verify.")
+      ctx.agent._verifyPassed = true
+    } else {
+      const v = args.verification ?? {}
+      const status = v?.status
+      if (!status) {
+        lines.push("")
+        lines.push("VERIFY BLOCKED: no verification status was declared.")
+        lines.push("These code changes must be verified before you say 'done' — declare whether you ran the project's verification and its result.")
+        appendBlockGuidance(lines, codeFiles)
+        ctx.agent._verifyPassed = false
+      } else if (status === "passed") {
         lines.push("")
-        lines.push("Tests (full suite):")
-        const result = await runTestSuite(testCwd, ctx, args.filter)
-        if (result.passed) {
-          lines.push("✓ All tests passed.")
-          ctx.agent._verifyPassed = !syntaxFailed
+        lines.push("Verification declared passed.")
+        if (v.command) lines.push(`  command: ${v.command}`)
+        if (v.summary) lines.push(`  summary: ${v.summary}`)
+        ctx.agent._verifyPassed = true
+      } else if (status === "skipped") {
+        const reason = (v.summary ?? "").trim()
+        if (reason) {
+          lines.push("")
+          lines.push(`Verification skipped with reason: ${reason}`)
+          ctx.agent._verifyPassed = true
         } else {
-          lines.push("✗ Tests FAILED. Review the output above, fix the issues, then run verify again.")
+          lines.push("")
+          lines.push("VERIFY BLOCKED: verification skipped with no summary reason — an empty skip is not allowed.")
+          lines.push("Give a concrete reason in verification.summary (e.g. \"project has no automated tests — verified by manual review\"), or run the project's verification and declare its result.")
+          appendBlockGuidance(lines, codeFiles)
           ctx.agent._verifyPassed = false
         }
       } else {
+        // Unknown status value — defensive (schema enum normally rejects it first).
         lines.push("")
-        lines.push("Tests: no test script in package.json — skipped.")
-        ctx.agent._verifyPassed = !syntaxFailed
-      }
-    } else if (relatedTests.length > 0) {
-      // Default mode: run only related test files
-      lines.push("")
-      lines.push(`Related tests (${relatedTests.length} file(s) for modules: ${modules.join(", ")}):`)
-      let anyTestFailed = false
-      for (const testFile of relatedTests) {
-        const abs = join(cwd, testFile)
-        if (!existsSync(abs)) {
-          lines.push(`  ? ${testFile} — file not found, skipping`)
-          continue
-        }
-        try {
-          const result = await runTestFile(cwd, testFile, ctx, args.filter)
-          if (result.passed) {
-            lines.push(`  ✓ ${testFile}`)
-          } else {
-            anyTestFailed = true
-            lines.push(`  ✗ ${testFile} — FAILED`)
-            lines.push(`    ${result.tail.replace(/\n/g, "\n    ")}`)
-          }
-        } catch (e) {
-          anyTestFailed = true
-          lines.push(`  ✗ ${testFile} — error: ${e.message}`)
-        }
-      }
-      if (anyTestFailed) {
-        lines.push("")
-        lines.push("✗ Related tests FAILED. Review the output above, fix the issues, then run verify again.")
+        lines.push(`VERIFY BLOCKED: unknown verification.status ${JSON.stringify(status)} — use 'passed' | 'failed' | 'skipped'.`)
+        appendBlockGuidance(lines, codeFiles)
         ctx.agent._verifyPassed = false
-      } else {
-        lines.push("  All related tests passed.")
-        ctx.agent._verifyPassed = !syntaxFailed
       }
-    } else {
-      // No related tests found for the changed modules
-      const uncovered = modules.filter((m) => MODULE_TO_TEST[m] === null)
-      const untested = modules.filter((m) => !(m in MODULE_TO_TEST))
-      lines.push("")
-      if (uncovered.length > 0) {
-        lines.push(`Related tests: NONE for module(s) ${uncovered.join(", ")} — these modules have no dedicated test file.`)
-        lines.push("ACTION REQUIRED: write a test that covers the change you just made.")
-        lines.push("Do NOT proceed to 'done' — a test file is required before this change is complete.")
-      } else if (untested.length > 0) {
-        lines.push(`Related tests: NONE for module(s) ${untested.join(", ")} — unknown module, no test mapping exists.`)
-        lines.push("ACTION REQUIRED: determine which test file covers this code and add it to MODULE_TO_TEST, or write a new test.")
-      } else if (srcFiles.length === 0) {
-        lines.push("Related tests: no source .mjs files changed — nothing to test.")
-        ctx.agent._verifyPassed = !syntaxFailed
-      } else {
-        lines.push("Related tests: none matched. Run verify with full=true to run the full suite.")
-        ctx.agent._verifyPassed = !syntaxFailed
-      }
-    }
-
-    // Show full-suite hint when not run
-    if (!args.full && hasTestScript) {
-      lines.push("")
-      lines.push("Note: full test suite not run. Use verify full=true to run ALL tests before committing.")
     }
 
     // 4. Task list
@@ -237,7 +280,7 @@ export const verifyTool = {
     // 5. Checklist
     lines.push("")
     lines.push("Self-review checklist:")
-    lines.push("- [ ] Did I run the project's tests and do they pass?")
+    lines.push("- [ ] Did I run the project's verification (per its AGENTS.md) and does it pass, or did I declare a concrete skip reason?")
     lines.push("- [ ] Did I read every file I changed to catch leftover debug code or stale comments?")
     lines.push("- [ ] Do comments and docstrings match what the code actually does?")
     lines.push("- [ ] Did I remove placeholder code, TODO stubs, or commented-out experiment blocks?")
@@ -247,86 +290,3 @@ export const verifyTool = {
     return lines.join("\n")
   },
 }
-
-/**
- * Run a single test file with node --test, no maxBuffer limit.
- * Returns { passed: boolean, tail: string } — the last few lines of output.
- */
-function runTestFile(cwd, testPath, ctx, filter) {
-  return new Promise((resolve, reject) => {
-    const child = spawn("node", filter ? ["--test", "--test-name-pattern", filter, testPath] : ["--test", testPath], {
-      cwd, stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, FORCE_COLOR: "0" },
-    })
-    let stdout = ""
-    let stderr = ""
-    child.stdout.on("data", (d) => {
-      const s = d.toString()
-      stdout += s
-      ctx.callbacks?.onToolOutput?.("verify", s)
-    })
-    child.stderr.on("data", (d) => {
-      const s = d.toString()
-      stderr += s
-      ctx.callbacks?.onToolOutput?.("verify", s)
-    })
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL")
-      reject(new Error(`Test ${testPath} timed out after 120s`))
-    }, 120000)
-    child.on("error", (e) => {
-      clearTimeout(timer)
-      reject(e)
-    })
-    child.on("close", (code) => {
-      clearTimeout(timer)
-      const output = (stdout + stderr).trim()
-      const tail = output.split("\n").slice(-8).join("\n")
-      resolve({ passed: code === 0, tail })
-    })
-  })
-}
-
-/**
- * Run npm test via spawn, no maxBuffer limit.
- * Test output is streamed through ctx.callbacks.onToolOutput (TUI can display progress in real time).
- * Returns { passed: boolean, tail: string }.
- */
-function runTestSuite(cwd, ctx, filter) {
-  return new Promise((resolve, reject) => {
-    const child = spawn("npm", filter ? ["test", "--", `--test-name-pattern=${filter}`] : ["test"], {
-      cwd, shell: true, stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, FORCE_COLOR: "0" },
-    })
-    let stdout = ""
-    let stderr = ""
-    child.stdout.on("data", (d) => {
-      const s = d.toString()
-      stdout += s
-      ctx.callbacks?.onToolOutput?.("verify", s)
-    })
-    child.stderr.on("data", (d) => {
-      const s = d.toString()
-      stderr += s
-      ctx.callbacks?.onToolOutput?.("verify", s)
-    })
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL")
-      const err = new Error("Tests timed out after 120s")
-      err.stdout = stdout
-      err.stderr = stderr
-      reject(err)
-    }, 120000)
-    child.on("error", (e) => {
-      clearTimeout(timer)
-      reject(e)
-    })
-    child.on("close", (code) => {
-      clearTimeout(timer)
-      const output = (stdout + stderr).trim()
-      const tail = output.split("\n").slice(-8).join("\n")
-      resolve({ passed: code === 0, tail })
-    })
-  })
-}
-

package/src/agent-tools.mjs

@@ -13,3 +13,4 @@ export { recentChangesTool } from "./agent-tools/recent-changes.mjs"
 export { timerTool } from "./agent-tools/timer.mjs"
 export { advisorTool } from "./agent-tools/advisor.mjs"
 export { engTool } from "./agent-tools/eng.mjs"
+export { readHistoryTool } from "./agent-tools/read-history.mjs"