thincoder 0.8.11 → 0.8.13

package/src/agent-tools/verify.mjs

@@ -1,25 +1,59 @@
 import { repairHistory, listWorkDir } from "../agent.mjs"
-import { execSync, spawn } from "node:child_process"
+import { execSync, spawn, spawnSync } from "node:child_process"
 import { readFileSync, existsSync } from "node:fs"
 import { join } from "node:path"
 
+/**
+ * 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.
+ */
+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",
+  mcp: null,
+  prompts: null,
+  context: null,
+  session: null,
+}
+
+/**
+ * Extract module name from a source path.
+ * "src/tools/bash.mjs" → "tools", "src/agent.mjs" → "agent", "src/agent/helpers.mjs" → "agent"
+ */
+function moduleName(srcPath) {
+  const rel = srcPath.replace(/^src[/\\]/, "")
+  const firstSlash = rel.search(/[/\\]/)
+  if (firstSlash === -1) return rel.replace(/\.mjs$/, "")
+  return rel.slice(0, firstSlash)
+}
+
 /**
  * verify tool: pre-completion self-check. When called:
  * 1. git diff --stat — changed file list
  * 2. node --check — syntax check all changed .mjs/.js files
- * 3. npm test — run project tests only when full=true
- * 4. task list + self-review checklist
- * Default does syntax checks only (fast); full=true runs the full test suite.
+ * 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.
  */
 export const verifyTool = {
   name: "verify",
   description:
-    "Run a pre-completion self-check. By default runs syntax checks on changed files, shows git diff and task list, and displays a self-review checklist. Set full=true to also run the project's full test suite (npm test). Call this BEFORE declaring any coding task complete — do not say 'done' until verify passes.",
+    "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.",
   parameters: {
     type: "object",
     properties: {
-      full: { type: "boolean", description: "Also run the full test suite (npm test). Default false — use sparingly, per the testing discipline rules." },
+      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." },
     },
   },
   readonly: true,
@@ -57,11 +91,13 @@ export const verifyTool = {
         const abs = join(cwd, f)
         if (!existsSync(abs)) continue // skip deleted files
         try {
-          execSync(`node --check "${f}"`, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000 })
+          const result = spawnSync("node", ["--check", abs], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10000 })
+          if (result.status !== 0) throw result
           lines.push(`  ✓ ${f}`)
         } catch (e) {
           syntaxFailed = true
-          const errMsg = (e.stderr || e.stdout || e.message || "").toString().split("\n").slice(0, 3).join("\n")
+          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(`    ${errMsg.replace(/\n/g, "\n    ")}`)
         }
@@ -69,53 +105,91 @@ export const verifyTool = {
       if (!syntaxFailed) lines.push("  All syntax checks passed.")
     }
 
-    // 3. Run project tests (only when full=true)
+    // 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(cwd, "package.json")
+    const hasTestScript = existsSync(pkgPath) && (() => { try { return !!JSON.parse(readFileSync(pkgPath, "utf8")).scripts?.test } catch { return false } })()
+
     if (args.full) {
-      try {
-        const pkgPath = join(cwd, "package.json")
-        if (existsSync(pkgPath)) {
-          const pkg = JSON.parse(readFileSync(pkgPath, "utf8"))
-          const testCmd = pkg.scripts?.test
-          if (testCmd) {
-            lines.push("")
-            lines.push(`Tests (${testCmd}):`)
-            try {
-              const result = await runTestSuite(cwd, ctx)
-              const tail = result.stdout.split("\n").slice(-8).join("\n")
-              lines.push(tail || "(tests completed)")
-              lines.push("")
-              lines.push("✓ Tests passed.")
-              ctx.agent._verifyPassed = !syntaxFailed // even if tests happen to pass, syntax failure still counts as fail
-            } catch (e) {
-              const output = e.stdout ? (e.stdout + (e.stderr ? "\n" + e.stderr : "")) : e.message
-              const tail = output.split("\n").slice(-15).join("\n")
-              lines.push(tail || "(no output)")
-              lines.push("")
-              lines.push("✗ Tests FAILED. Review the output above, fix the issues, then run verify again.")
-              ctx.agent._verifyPassed = false
-            }
+      // Full mode: run the entire test suite
+      if (hasTestScript) {
+        lines.push("")
+        lines.push("Tests (full suite):")
+        const result = await runTestSuite(cwd, ctx)
+        if (result.passed) {
+          lines.push("✓ All tests passed.")
+          ctx.agent._verifyPassed = !syntaxFailed
+        } else {
+          lines.push("✗ Tests FAILED. Review the output above, fix the issues, then run verify again.")
+          ctx.agent._verifyPassed = false
+        }
+      } else {
+        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)
+          if (result.passed) {
+            lines.push(`  ✓ ${testFile}`)
           } else {
-            lines.push("")
-            lines.push("Tests: no test script in package.json — skipped.")
-            ctx.agent._verifyPassed = !syntaxFailed
+            anyTestFailed = true
+            lines.push(`  ✗ ${testFile} — FAILED`)
+            lines.push(`    ${result.tail.replace(/\n/g, "\n    ")}`)
           }
+        } catch (e) {
+          anyTestFailed = true
+          lines.push(`  ✗ ${testFile} — error: ${e.message}`)
         }
-      } catch {
-        lines.push("Tests: (unable to run — no package.json or npm unavailable)")
+      }
+      if (anyTestFailed) {
+        lines.push("")
+        lines.push("✗ Related tests FAILED. Review the output above, fix the issues, then run verify again.")
+        ctx.agent._verifyPassed = false
+      } else {
+        lines.push("  All related tests passed.")
+        ctx.agent._verifyPassed = !syntaxFailed
       }
     } else {
-      // Quick mode: skip tests but hint that full verification is available
-      const pkgPath = join(cwd, "package.json")
-      if (existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(readFileSync(pkgPath, "utf8"))
-          if (pkg.scripts?.test) {
-            lines.push("")
-            lines.push("Tests: skipped (default quick mode). Run verify with full=true or npm test to run the full suite.")
-          }
-        } catch { /* ignore */ }
+      // 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
       }
-      ctx.agent._verifyPassed = !syntaxFailed // quick mode: syntax failure must not count as pass
+    }
+
+    // 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
@@ -151,10 +225,49 @@ export const verifyTool = {
   },
 }
 
+/**
+ * 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) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", ["--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).
- * On success returns { stdout, stderr }; on non-zero exit throws (with stdout/stderr for caller to extract tail).
+ * Returns { passed: boolean, tail: string }.
  */
 function runTestSuite(cwd, ctx) {
   return new Promise((resolve, reject) => {
@@ -187,13 +300,9 @@ function runTestSuite(cwd, ctx) {
     })
     child.on("close", (code) => {
       clearTimeout(timer)
-      if (code === 0) resolve({ stdout, stderr })
-      else {
-        const err = new Error(`Tests exited with code ${code}`)
-        err.stdout = stdout
-        err.stderr = stderr
-        reject(err)
-      }
+      const output = (stdout + stderr).trim()
+      const tail = output.split("\n").slice(-8).join("\n")
+      resolve({ passed: code === 0, tail })
     })
   })
 }

package/src/agent-tools.mjs

@@ -10,3 +10,4 @@ export { skillTool } from "./agent-tools/skill.mjs"
 export { goalTool } from "./agent-tools/goal.mjs"
 export { verifyTool } from "./agent-tools/verify.mjs"
 export { recentChangesTool } from "./agent-tools/recent-changes.mjs"
+export { timerTool } from "./agent-tools/timer.mjs"

package/src/agent.mjs

@@ -64,6 +64,7 @@ export function createAgent({
     _mutatedThisRun: false, _verifiedThisRun: false, _verifyPassed: undefined,
     _touchedFiles: [], _verifyRetries: 0,
     _pendingReminders: [],
+    _pendingTimers: [],
     _sessionStart: sessionStart,
     _lastPromptTokens: null, _usageAtLen: null,
     _compressFailures: 0,
@@ -91,7 +92,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     const lastRole = agent.history.at(-1)?.role
     if (lastRole === "user" || lastRole === "tool") {
       try {
-        if (await compressIfNeeded(agent, threshold)) {
+        if (await compressIfNeeded(agent, threshold, callbacks)) {
           agent._compressFailures = 0
           recentCallSigs.length = 0 // After compression history is rebuilt, reset stall detection counter
           callbacks.onCompress?.()
@@ -111,13 +112,74 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     }
 
     const messages = [{ role: "system", content: systemPrompt }, ...agent.history]
-    const response = await chat(agent.provider, {
-      messages, tools: toolSchemas,
-      onToken: callbacks.onToken,
-      onReasoning: callbacks.onReasoning,
-      onWait: callbacks.onWait,
-      signal,
-    })
+    let response
+
+    // Auto-think: classify task difficulty and set reasoning effort before the real prompt.
+    // Runs only on turn 0 of user input; failure is silent — falls back to current setting.
+    if (agent.config?.agent?.autoThink && turn === 0) {
+      const { classifyAndApply } = await import("./auto-think.mjs")
+      await classifyAndApply(agent, turn).catch(() => {})
+    }
+
+    try {
+      response = await chat(agent.provider, {
+        messages, tools: toolSchemas,
+        onToken: callbacks.onToken,
+        onReasoning: callbacks.onReasoning,
+        onWait: callbacks.onWait,
+        signal,
+        streamRules: agent.config.agent?.streamRules ?? [],
+      })
+    } catch (e) {
+      // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message: "…" }).
+      // Inject the message into history and let the outer loop recreate the controller.
+      if (e.name === "AbortError" && signal?.reason?.interrupt) {
+        agent.history.push({
+          role: "user",
+          content: `[User interrupt: ${signal.reason.message}]`,
+        })
+      }
+      throw e
+    }
+
+    // Stream rule triggered mid-generation (action: "abort"): halt current output,
+    // inject rule's message as a reminder, and retry from the same context.
+    if (response.ruleTriggered) {
+      if (response.content) {
+        agent.history.push({ role: "assistant", content: response.content })
+      }
+      const label = response.ruleName ? ` — stream rule "${response.ruleName}"` : ""
+      agent.history.push({
+        role: "user",
+        content: `[System reminder${label}: ${response.ruleMessage}]`,
+      })
+      continue
+    }
+
+    // Stream rule warnings (action: "warn"): the stream completed, but one or more
+    // non-interrupting rules matched. Inject warnings after the turn so the model
+    // sees them before its next response — without aborting mid-generation.
+    if (response._warnings?.length) {
+      const deDuplicated = [...new Map(response._warnings.map(w => [w.name || w.pattern, w])).values()]
+      agent.history.push({
+        role: "user",
+        content: `[System reminder — stream rule warnings from your last response:\n${deDuplicated.map(w => `- ${w.name || w.pattern}: ${w.message}`).join("\n")}]`,
+      })
+    }
+
+    // User interrupted mid-generation (Ctrl+I): the SSE stream was aborted while content
+    // was partially generated. Commit partial output + inject user message, then signal
+    // the outer loop to recreate the controller and resume.
+    if (response.interrupted) {
+      if (response.content) {
+        agent.history.push({ role: "assistant", content: response.content })
+      }
+      agent.history.push({
+        role: "user",
+        content: `[User interrupt: ${response.interruptMessage}]`,
+      })
+      throw Object.assign(new Error("User interrupted"), { name: "AbortError" })
+    }
 
     if (response.usage) {
       callbacks.onUsage?.(response.usage)
@@ -127,6 +189,21 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
     }
 
+    // Warn on abnormal finish reasons — the model stopped for a reason other than
+    // "stop" or "tool_calls", meaning the response may be incomplete or truncated.
+    if (response.finishReason && response.finishReason !== "stop" && response.finishReason !== "tool_calls") {
+      const reasonMap = {
+        length: "output token limit reached after exhausting continuations",
+        insufficient_system_resource: "provider inference resources exhausted — consider retrying or switching models",
+        content_filter: "response blocked by provider content filtering",
+      }
+      const detail = reasonMap[response.finishReason] || `unknown reason "${response.finishReason}"`
+      agent.history.push({
+        role: "user",
+        content: `[System reminder: the previous turn ended abnormally — ${detail}. The assistant response that follows may be incomplete.]`,
+      })
+    }
+
     if (response.toolCalls.length === 0) {
       if (!response.content) {
         throw new Error(
@@ -211,11 +288,20 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
           if (parsed.images?.length) {
             // tool message first — closes the tool_call pairing (OpenAI API requires tool result immediately after assistant with tool_calls)
             agent.history.push({ role: "tool", tool_call_id: toolCall.id, content: parsed.text })
-            // then inject multimodal user message with base64 images for the model to actually "see" them on the next turn
-            agent.history.push({
-              role: "user",
-              content: [{ type: "text", text: parsed.text }, ...parsed.images],
-            })
+            if (specForModel(agent.provider.model).multimodal) {
+              // then inject multimodal user message with base64 images for the model to actually "see" them on the next turn
+              agent.history.push({
+                role: "user",
+                content: [{ type: "text", text: parsed.text }, ...parsed.images],
+              })
+            } else {
+              // Non-vision model: image parts must never enter history — text-only APIs 400 on them on EVERY
+              // subsequent request, poisoning the conversation. (read_image itself already refuses; this is defense-in-depth.)
+              agent.history.push({
+                role: "user",
+                content: `[System reminder: the image returned by ${toolCall.name} was NOT injected — model ${agent.provider.model} does not support image input. Do not call ${toolCall.name} again under this provider; verify visual output programmatically instead.]`,
+              })
+            }
             continue
           }
         } catch { /* Parse failure doesn't affect normal tool messages */ }
@@ -231,21 +317,31 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
             const abs = join(agent.cwd, p)
             agent._touchedFiles.push(abs)
             if (agent.memory) {
-              try {
-                if (!_reindexFile) {
-                  const mod = await import("./memory.mjs")
-                  _reindexFile = mod.reindexFile
-                }
-                await _reindexFile(agent.memory, agent.cwd, abs)
-              } catch (e) { /* Index failure doesn't block agent, surface in TUI as pending reminder */
-                agent._pendingReminders.push(`[System reminder: background indexing failed for ${toolCall.name} on ${abs}: ${e.message}. This does not affect your work — the code index will catch up on next reindex.]`)
+              // Fire-and-forget: don't block the agent loop on indexing.
+              // Reuses a single cached import; errors surface as pending reminders on next turn.
+              if (!_reindexFile) {
+                const mod = await import("./memory.mjs")
+                _reindexFile = mod.reindexFile
               }
+              _reindexFile(agent.memory, agent.cwd, abs).catch((e) => {
+                agent._pendingReminders.push(`[System reminder: background indexing failed for ${toolCall.name} on ${abs}: ${e.message}. This does not affect your work — the code index will catch up on next reindex.]`)
+              })
             }
           }
         }
       }
     }
 
+    // Expired timers — inject reminders when thinking budget is up
+    if (agent._pendingTimers.length > 0) {
+      const now = Date.now()
+      const expired = agent._pendingTimers.filter((t) => t.expiresAt <= now)
+      agent._pendingTimers = agent._pendingTimers.filter((t) => t.expiresAt > now)
+      for (const t of expired) {
+        agent.history.push({ role: "user", content: `[System reminder: ⏰ timer — ${t.message}]` })
+      }
+    }
+
     // Pending reminders
     if (agent._pendingReminders.length > 0) {
       for (const reminder of agent._pendingReminders) {
@@ -290,6 +386,17 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     }
 
     callbacks.onTurnEnd?.(agent, turn)
+
+    // Advisor: automated code review after each tool-execution turn.
+    // Runs asynchronously — failure is silent, main loop continues regardless.
+    if (agent.config?.advisor?.enabled) {
+      const { runAdvisor } = await import("./advisor.mjs")
+      const note = await runAdvisor(agent)
+      if (note) {
+        agent.history.push({ role: "user", content: note })
+        callbacks.onAdvisor?.(note)
+      }
+    }
   }
 
   throw new ContinueError(maxTurns)

package/src/auto-think.mjs

@@ -0,0 +1,83 @@
+/**
+ * auto-think.mjs — automatic difficulty classification for reasoning effort.
+ *
+ * When enabled, before each user-facing turn a cheap classification call determines
+ * the task difficulty, then maps it to the model's reasoning effort. This replaces
+ * manual /think toggling with per-prompt automatic selection.
+ *
+ * Config:
+ *   { agent: { autoThink: true } }
+ *
+ * Mechanism:
+ *   1. Take the last user message from history
+ *   2. Send a minimal classification prompt (expects one-word reply)
+ *   3. Map difficulty → reasoningEffort using the model's valid effort enum
+ *   4. Set agent.provider.reasoningEffort before the real chat() call
+ */
+import { chat } from "./provider/core.mjs"
+import { specForModel } from "./config.mjs"
+
+const CLASSIFY_PROMPT = `Classify this coding task's difficulty: low, medium, or high.
+
+- low — trivial: rename, typo, formatting, one-liner, direct question
+- medium — localized: small feature, straightforward bug fix, moderate change
+- high — complex: multi-file, debugging, design decisions, large refactor
+
+Reply with exactly one word.`
+
+const EFFORT_MAP = {
+  low: ["low", "minimal", "none", "low"],
+  medium: ["high", "medium", "high"],
+  high: ["max", "max", "xhigh", "max"],
+}
+
+/**
+ * Classify the difficulty of the user's prompt and adjust reasoning effort.
+ * Only runs on the first turn (turn === 0) of a user message.
+ * Returns the resolved level or null if auto-thinking is disabled or classification fails.
+ * @param {object} agent
+ * @param {number} turn
+ * @returns {Promise<string|null>}
+ */
+export async function classifyAndApply(agent, turn) {
+  if (!agent.config?.agent?.autoThink) return null
+  if (turn !== 0) return null // Only classify on the first turn of user input
+
+  const spec = specForModel(agent.provider.model)
+  const validEfforts = spec.reasoningEffortEnum
+  if (!validEfforts) return null // Model doesn't support reasoning effort
+
+  // Get the last user message (should be the most recent history entry or the input)
+  const lastUser = [...agent.history].reverse().find(m => m.role === "user")
+  if (!lastUser) return null
+  const prompt = typeof lastUser.content === "string" ? lastUser.content : ""
+
+  // Classification call: use same provider, minimal tokens, no tools, no streaming
+  let level
+  try {
+    const classifierProvider = { ...agent.provider, maxTokens: 10 }
+    const response = await chat(classifierProvider, {
+      messages: [
+        { role: "system", content: CLASSIFY_PROMPT },
+        { role: "user", content: prompt.slice(0, 2000) },
+      ],
+      tools: [],
+      signal: AbortSignal.timeout(5_000),
+    })
+    const word = (response.content ?? "").trim().toLowerCase()
+    if (word.startsWith("low")) level = "low"
+    else if (word.startsWith("medium") || word.startsWith("med")) level = "medium"
+    else if (word.startsWith("high")) level = "high"
+    else return null // Unparseable
+  } catch {
+    return null // Classification failure → fall back to current setting
+  }
+
+  // Map difficulty to the closest valid reasoning effort
+  const candidates = EFFORT_MAP[level] || EFFORT_MAP.medium
+  const matched = candidates.find(e => validEfforts.includes(e))
+  if (!matched) return null
+
+  agent.provider.reasoningEffort = matched
+  return matched
+}

package/src/cli/make-agent.mjs

@@ -5,6 +5,7 @@ import { loadConfig, configDir } from "../config.mjs"
 import { createMemory, memoryTools, syncDir, codeSearchTool, docSearchTool } from "../memory.mjs"
 import { repoOutlineTool } from "../tools/repomap.mjs"
 import { builtinTools } from "../tools/index.mjs"
+import { discoverRules } from "../rules.mjs"
 
 /** Assemble an agent with memory, MCP tools, and code/doc indices attached (sync all layers, then return) */
 export async function assembleAgent() {
@@ -18,6 +19,14 @@ export async function assembleAgent() {
     memory.embedder = createEmbedder(config.embedding)
   }
   const cwd = process.cwd()
+  // Merge project-level rules (.thincoder/rules/*.md) into config; file rules take priority (first),
+  // config.json rules append (deduped by pattern). Users can override with explicit config rules.
+  const fileRules = discoverRules(cwd)
+  if (fileRules.length) {
+    const filePatterns = new Set(fileRules.map(r => r.pattern))
+    const configRules = (config.agent?.streamRules || []).filter(r => !filePatterns.has(r.pattern))
+    config.agent.streamRules = [...fileRules, ...configRules]
+  }
   // code/doc indices isolated by origin (project root dir): search only scoped to this project
   memory.codeOrigin = cwd
   // Project layer: sync .thincoder/memory/ dir to index on startup (sync if present, skip otherwise)