thincoder 0.12.58 → 0.12.60

package/src/tui/wizard.mjs

@@ -1,6 +1,7 @@
 /**
  * wizard.mjs — first-launch config wizard
- * Extracted from index.mjs: provider select → step-by-step input (name/baseURL/model/key/embedkey) → persist → then model picker.
+ * Extracted from index.mjs: provider select → step-by-step input (name/baseURL/model/format/key/embedkey)
+ * → persist → then model picker. Custom 分支含 API format 步（D-C2，TUI.md §10.6D）。
  * Accesses shared state and UI functions from the startTUI closure via ctx object.
  * ctx: { agent, state, pushLine, pushLabel, render, persistRaw, openModelPicker }
  */
@@ -23,7 +24,13 @@ export function createWizard(ctx) {
     }
     for (const [name, p] of Object.entries(PRESETS)) {
       if (!agent.providers.some((x) => x.name === name)) {
-        items.push({ kind: "preset", name, baseURL: p.baseURL, model: p.model, label: `${name} (${p.desc})` })
+        items.push({
+          kind: "preset", name, baseURL: p.baseURL, model: p.model, label: `${name} (${p.desc})`,
+          // 预设自身声明的扩展字段随 preset 直达落盘（code review 🟡——与 pickers preset 路径同构；
+          // claude/gemini 缺 format、deepseek/glm 缺 thinking/maxTokens 会静默错配）；不新增提问步。
+          format: p.format, thinking: p.thinking, reasoningEffort: p.reasoningEffort,
+          maxTokens: p.maxTokens, chatPath: p.chatPath,
+        })
       }
     }
     items.push({ kind: "custom", name: null, label: "Custom endpoint…" })
@@ -45,6 +52,14 @@ export function createWizard(ctx) {
       prompt: "Enter model name (e.g. gpt-4o)",
       validate: (v) => v.length > 0 || "Model name required",
     },
+    // D-C2（TUI.md §10.6D）：Custom 分支的 API format 步（endpoint 后 key 前——与 Add Provider
+    // picker 路径两入口一致；默认 openai）。空输入 = openai 直过（Enter 即默认——同 D-C1 index=0）；
+    // Esc 在该步沿用 wizard 既有“Esc 随时跳过”语义（取消整个向导——无半配置落盘）。
+    format: {
+      prompt: "API format [openai/anthropic/google] (Enter = openai default)",
+      // 大小写不敏感（旧手输口径——输入统一 toLowerCase 后落盘）；空输入 = openai 默认
+      validate: (v) => !v || /^(openai|anthropic|google)$/i.test(v) || "API format must be one of: openai, anthropic, google",
+    },
     key: {
       prompt: "Enter API key",
       validate: (v) => v.length > 0 || "Key must not be empty",
@@ -54,7 +69,7 @@ export function createWizard(ctx) {
       validate: () => true, // skippable
     },
   }
-  const WIZARD_NEXT = { name: "baseURL", baseURL: "model", model: "key", key: "embedkey", embedkey: null }
+  const WIZARD_NEXT = { name: "baseURL", baseURL: "model", model: "format", format: "key", key: "embedkey", embedkey: null }
 
   function startWizard() {
     state.wizard = { step: "provider", index: 0, scroll: 0, selectedLine: 0, fields: {}, error: null, lines: [] }
@@ -94,6 +109,11 @@ export function createWizard(ctx) {
       w.step = "name"
     } else {
       w.fields = { name: item.name, baseURL: item.baseURL, model: item.model }
+      // preset 直达：预设声明的扩展字段（format/thinking/maxTokens/chatPath…）直接带进 fields——
+      // 无 format 提问步（T-C4）但落盘不丢字段（code review 🟡——picker preset 路径同款复制）。
+      for (const k of ["format", "thinking", "reasoningEffort", "maxTokens", "chatPath"]) {
+        if (item[k]) w.fields[k] = item[k]
+      }
       w.step = "key"
     }
     renderWizard()
@@ -111,7 +131,9 @@ export function createWizard(ctx) {
     w.error = null
     state.input = []
     state.cursor = 0
-    w.fields[w.step === "key" ? "key" : w.step] = w.step === "baseURL" ? value.replace(/\/+$/, "") : value
+    w.fields[w.step === "key" ? "key" : w.step] = w.step === "baseURL" ? value.replace(/\/+$/, "")
+      : w.step === "format" ? (value.toLowerCase() || "openai") // 空输入 = openai 默认（D-C2）
+      : value
     const next = WIZARD_NEXT[w.step]
     if (next) {
       w.step = next
@@ -131,9 +153,27 @@ export function createWizard(ctx) {
   async function finishWizard() {
     const f = state.wizard.fields
     state.wizard = null
+    // D-C2：format 非默认（anthropic/google）时落盘；openai = 默认省略（与 D-C1 picker 路径同构）
+    const providerRec = { name: f.name, baseURL: f.baseURL, model: f.model, apiKey: f.key }
+    if (f.format && f.format !== "openai") providerRec.format = f.format
+    // code review 🟡：preset 直达带来的扩展字段一并落盘（truthy 语义与 pickers preset 分支一致——
+    // thinking: null 不落；Custom 路径无这些字段不受影响）
+    for (const k of ["thinking", "reasoningEffort", "maxTokens", "chatPath"]) {
+      if (f[k]) providerRec[k] = f[k]
+    }
+    // D-F5a（wizard finishWizard——清单外同型写回补正）先盘后存：磁盘 fresh raw 单操作
+    // （upsert 目标项 + active 指针）——冲突放弃不留下内存 ghost（F5 约定）
+    await persistRaw((raw) => {
+      raw.providers ??= []
+      const existing = raw.providers.find((p) => p?.name === f.name)
+      if (existing) Object.assign(existing, providerRec)
+      else raw.providers.push(providerRec)
+      raw.activeProvider = f.name
+      raw.activeModel = undefined  // reset to default model
+    })
     const existing = agent.providers.find((p) => p.name === f.name)
-    if (existing) Object.assign(existing, { baseURL: f.baseURL, model: f.model, apiKey: f.key })
-    else agent.providers.push({ name: f.name, baseURL: f.baseURL, model: f.model, apiKey: f.key })
+    if (existing) Object.assign(existing, providerRec)
+    else agent.providers.push(providerRec)
     agent.activeProvider = f.name
     agent.activeModel = null
     agent.provider = { ...agent.providers.find((p) => p.name === f.name) }
@@ -141,20 +181,16 @@ export function createWizard(ctx) {
       const { resolveCompactThreshold } = await import("../config.mjs")
       agent.config.agent.compactThreshold = resolveCompactThreshold(null, f.model).value
     }
-    await persistRaw((raw) => {
-      raw.providers = agent.providers
-      raw.activeProvider = f.name
-      raw.activeModel = undefined  // reset to default model
-    })
     agent.config.activeProvider = f.name
     agent.config.activeModel = null
     pushLabel(`❯ Setup`, ansi.bold + C.tool)
     pushLine(`Setup complete: ${f.name} / ${f.model} (saved to config)`, C.tool)
     // embedding key: if provided, enable vector search; if not, show how to enable later
     if (f.embedkey) {
+      // D-F5b 语义先盘后存（embedding 单键补丁——冲突放弃不留 ghost）
+      await persistRaw((raw) => { raw.embedding = { ...(raw.embedding ?? {}), apiKey: f.embedkey } })
       agent.config.embedding ??= {}
       agent.config.embedding.apiKey = f.embedkey
-      await persistRaw((raw) => { raw.embedding = { ...(raw.embedding ?? {}), apiKey: f.embedkey } })
       if (agent.memory && !agent.memory.embedder) {
         const { createEmbedder } = await import("../embedding.mjs")
         agent.memory.embedder = createEmbedder(agent.config.embedding)

package/src/agent-tools/escalate.mjs

@@ -1,179 +0,0 @@
-/**
- * escalate.mjs — 飞刀 (the "flying knife", docs/design/ESCALATE.md). CLI port.
- *
- * Hand an implementation task to a STRONGER model — like a hospital flying in an
- * outside expert (飞刀): the expert arrives, operates personally (WRITE access),
- * hands back the post-op report, leaves. Complementary to consult (parallel
- * READ-ONLY opinions for judgment calls).
- *
- * Candidate pool = all consultModels rows. The tool is only registered when the
- * pool is non-empty (setup.mjs).
- *
- * CLI adaptation (vs the VS Code plugin): the child runner is CLI's runAgent
- * (runAgent(child, input, callbacks, opts) — an agent object, not provider+cwd);
- * the child is createAgent({ role: "coder", CODER_OVERLAY }); activity streams to
- * the parent TUI via the relay prefix `escalate#<id>/`; mutations merge via the
- * CLI mergeChildMutations(parent, child) (agent object, not a state sink).
- */
-import { isAbsolute, relative } from "node:path"
-import { createAgent, runAgent, CODER_OVERLAY, DEFAULT_SUBAGENT_TURNS } from "../agent.mjs"
-import { resolveChildProvider, mergeChildMutations } from "./subagent.mjs"
-import { makeRelay, wrapChildCallbacks, runWithContinue, ensureChildApiKey, clampEffort, TURN_CAP_MARK } from "../agent/spawn-child.mjs"
-
-const label = (m) => `${m.provider}:${m.model}`
-
-export const escalateTool = {
-  name: "escalate",
-  sideEffectExempt: true, // the child's mutations are tracked and reviewed, like subagent
-  description:
-    "TERMINOLOGY (one word for one thing): 'escalate' is the ONLY name — the tool, and the " +
-    "role of the expert sub-agent it spawns, are both called 'escalate'; 飞刀 is the Chinese " +
-    "alias. When the user says 飞刀 / escalate / 'fly in <model>', call THIS tool directly — " +
-    "never via a script importing this module. " +
-    "Hand an implementation task to a stronger model (飞刀 — a flown-in expert). " +
-    "It gets WRITE access and does the work itself — reads, edits, runs tests — then returns " +
-    "a post-op report (what changed, why, verification). You review the report and report to " +
-    "the user. Use it when YOU judge the task calls for stronger hands (complex multi-file " +
-    "refactoring, an intractable bug, intricate algorithm work — or work beyond your " +
-    "comfortable ability). Early or late, your judgment; the cost is one expert run, " +
-    "comparable to doing it yourself. For parallel READ-ONLY opinions use consult_start instead. " +
-    "Not available in engineering mode (implementation goes through eng-coder subagents there).\n" +
-    "Parameters:\n" +
-    "- task (required): the task description — goal, constraints, entry files, acceptance criteria\n" +
-    "- model (optional): pick a specific consultant as 'provider:model'; default = the first consult model",
-  parameters: {
-    type: "object",
-    properties: {
-      task: { type: "string", description: "Task description with acceptance criteria" },
-      model: { type: "string", description: "Candidate 'provider:model' from the consult models (optional)" },
-    },
-    required: ["task"],
-  },
-  async execute({ task, model }, ctx) {
-    const parent = ctx.agent
-    if ((ctx.depth ?? 0) > 0) return "Error: escalate is only available at depth 0 (an escalate's work cannot be delegated again)"
-    if (parent?.config?.agent?.engineering) {
-      return "Error: engineering mode is ON — escalate is unavailable (it spawns a coder sub-agent, which engineering mode forbids). Use subagent with role='eng-coder' and a designToken from advisor(type='design') instead."
-    }
-    const pool = parent?.config?.agent?.consultModels ?? []
-    if (pool.length === 0) return "Error: no escalate candidates — configure at least one consult model (agent.consultModels)"
-
-    const wanted = typeof model === "string" ? model.replace(/\s+\([^)]*\)\s*$/, "").trim() : model
-    const pick = wanted ? pool.find((m) => label(m) === wanted) : pool[0]
-    if (!pick) {
-      return `Error: "${model}" is not a consult candidate. Available: ${pool.map(label).join(", ")}`
-    }
-
-    let provider
-    try {
-      provider = resolveChildProvider(parent, `${pick.provider}:${pick.model}`)
-    } catch (e) {
-      return `Error: ${e.message}`
-    }
-    if (!ensureChildApiKey(provider)) {
-      return `Error: provider "${pick.provider}" has no API key — set it in config.json before flying it in`
-    }
-    let effortNote = ""
-    if (pick.effort && !clampEffort(provider, pick.model, pick.effort)) {
-      // Out-of-enum effort dropped (see clampEffort): the provider preset default may ALSO be
-      // out-of-enum for this override model — e.g. qwenplan preset default "high" is
-      // invalid for qwen3.8-max, enum xhigh/medium/low.
-      effortNote = ` (effort "${pick.effort}" unsupported by ${pick.model}, dropped)`
-    }
-
-    const tag = label(pick)
-    const relayPrefix = makeRelay(parent, "escalate", ctx.callbacks?.onToken, provider.model ?? tag)
-    // Report the escalated model to the display layer (it may differ from the parent's)
-    // — makeRelay already emitted the `[model]` metadata token above.
-
-    // No wall-clock watchdog — turn cap only, exactly like subagent (the verified write
-    // path). Rationale (2026-08-16): a fixed wall-clock aborts NORMAL-but-slow surgery —
-    // two max-effort consultants hit a 10min wall just READING files. Hang protection is
-    // already covered by FETCH_TIMEOUT_MS (per LLM call) and the user's Stop (parent
-    // signal propagates directly below). maxTurns is the cost budget; hitting it asks
-    // the user whether to continue (main-agent parity), falling back to partial work.
-
-    // No custom onToken here (consult P2, 2026-08-30): wrapChildCallbacks already
-    // applies the prefixed relay + D7 sentinel strip for the display path, and
-    // runWithContinue owns the capture (stripEventTokensForCapture) for the
-    // partial-output return — a hand-rolled duplicate ran the strip twice and
-    // maintained a second output buffer.
-    const childCallbacks = wrapChildCallbacks(relayPrefix, ctx.callbacks ?? {})
-
-    // Declared outside try so the catch can merge mutations even on a partial failure.
-    let child = null
-    try {
-      // Full write path (role "coder"): permission gate via the parent's onPermissionRequest,
-      // recent-changes tracking, mutations merge into the parent below.
-      child = createAgent({
-        provider,
-        tools: parent.tools,
-        config: parent.config,
-        cwd: parent.cwd,
-        memory: parent.memory,
-        overlay: CODER_OVERLAY,
-        role: "coder",
-      })
-      const runner = ctx.runAgent ?? runAgent
-      const runOpts = {
-        depth: 1,
-        maxTurns: parent.config?.agent?.subagentTurns ?? DEFAULT_SUBAGENT_TURNS, // review #7: constant, not literal (single source with subagent.mjs)
-        signal: ctx.signal ?? null,
-      }
-      // Turn-cap continue via runWithContinue (§7.2 D3), main-agent parity (tui/agent-turn.mjs):
-      // when the child hits ContinueError, ask the user through the SAME channel as child
-      // write approval (ctx.onPermissionRequest). The name "continue" renders the TUI's
-      // dedicated y/n Continue panel. The resumed run passes resume:true, so runAgent does
-      // NOT re-inject the task text (setup.mjs skips input on resume) and keeps the child's
-      // history + mutation bookkeeping, with a fresh maxTurns budget per run. No permission
-      // handler (headless) or a declined prompt falls through to the partial-work return.
-      // Continues are UNLIMITED — the user can decline at any prompt.
-      const report = await runWithContinue(
-        async (childAgent, input, cbs, opts) => {
-          // Merge mid-run mutations even when the run throws — the outer catch keeps
-          // handling createAgent failures; AbortError still propagates (user Stop).
-          try {
-            return await runner(childAgent, input, cbs, opts)
-          } catch (e) {
-            mergeChildMutations(parent, childAgent)
-            throw e
-          }
-        },
-        child, task, { ...childCallbacks, onPermissionRequest: parent.autoApprove ? async () => true : (ctx.onPermissionRequest ?? null) },
-        runOpts,
-        {
-          // escalate has NO permQueue: prompts go straight to the user (T-L spec).
-          askContinue: (e) => (ctx.onPermissionRequest
-            ? ctx.onPermissionRequest("continue", { turns: e.turn, agent: tag })
-            : Promise.resolve(false)),
-          onDeclined: (e, output) => `escalate (${tag}) ${TURN_CAP_MARK} (${e.turn} turns) — work may be partial; review recent_changes before deciding next steps.\nPartial output: ${output.slice(0, 2000)}`,
-        },
-      ).catch((e) => {
-        // Generic run failure (not ContinueError): match the original loop's return shape —
-        // error text + partial output, mutations already merged in the runner wrapper.
-        if (ctx.signal?.aborted || e?.name === "AbortError") throw e
-        return `escalate (${tag}) error: ${e?.message ?? String(e)}\nPartial output: ${(child._capturedOutput ?? "").slice(0, 2000)}`
-      })
-      // Escalate mutations are the parent's mutations: verify/advisor guards must see them
-      mergeChildMutations(parent, child)
-      return `escalate (${tag})${effortNote} post-op report:\n${report || (child._capturedOutput ?? "").slice(0, 4000)}${touchedFilesNote(child, parent.cwd)}`
-    } catch (e) {
-      // Reached only when createAgent itself fails or the continue prompt throws —
-      // run failures are handled above (mutations merge inside the runner wrapper).
-      if (child) mergeChildMutations(parent, child)
-      if (ctx.signal?.aborted || e?.name === "AbortError") throw e
-      return `escalate (${tag}) error: ${e?.message ?? String(e)}`
-    }
-  },
-}
-
-/** Relative touched-file list appended to every return (child paths are absolute). */
-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(", ")}`
-}

package/src/agent-tools/subagent-check.mjs

@@ -1,107 +0,0 @@
-/**
- * subagent-check.mjs — async subagent 结果消费侧（AGENT-LOOP.md §15 D-A2）。
- *
- * 与 subagent.mjs 的生成侧（async 分支 + 槽位队列）分离，保持 subagent.mjs
- * 在 500 行硬限内；本模块只承载 subagent_check 工具 + 其等待机制。
- *
- * 语义（D-A2）：
- * - id 缺省 → 按 ARRIVAL ORDER 返回下一个已完成的子代理（先完成先返回）
- * - id 给定 → 阻塞到该 id 完成（queued 项先等启动再等完成）
- * - n（必填）→ 1-based 递增读数，per-run 计数器（runAgent 非 resume 重置、
- *   turn-end 清空）；乱序/重复 n 拒绝且不消费结果；超 MAX_ASYNC_CHECKS 上限
- *   报错引导走回合收尾自动等待
- * - 消费后从 map 删除——已消费 id 再查 = 与未知 id 同款错误（T12）
- */
-import { MAX_ASYNC_CHECKS } from "./subagent.mjs"
-
-/** Wait for an async entry to settle (or the parent signal to abort), parked on
- *  the agent's waiter list — the entry settle finally wakes every waiter (same
- *  pattern as consult_check's session waiters). Returns "aborted" on signal. */
-function wakeOnAsyncSettle(agent, ctx) {
-  return new Promise((resolve) => {
-    const cleanup = () => {
-      const i = (agent._asyncWaiters ?? []).indexOf(w)
-      if (i >= 0) agent._asyncWaiters.splice(i, 1)
-      ctx.signal?.removeEventListener("abort", onAbort)
-    }
-    const w = () => { cleanup(); resolve("settled") }
-    const onAbort = () => { cleanup(); resolve("aborted") }
-    ;(agent._asyncWaiters ??= []).push(w)
-    if (ctx.signal) {
-      if (ctx.signal.aborted) { onAbort(); return }
-      ctx.signal.addEventListener("abort", onAbort, { once: true })
-    }
-  })
-}
-
-/**
- * subagent_check (AGENT-LOOP.md §15 D-A2) — fetch async subagent results.
- * - id omitted → the next completed child in ARRIVAL order (first finished first)
- * - id given → block until THAT child finishes (queued items wait for their start)
- * - n (required) → 1-based read counter, strictly incrementing per run (loop
- *   guard); capped at MAX_ASYNC_CHECKS per turn — beyond that, use the turn-end
- *   auto-wait. Errors never consume results.
- * Consumed entries are deleted from the map — a re-check of the same id is the
- * same "unknown async subagent id" error (T12).
- */
-export const subagentCheckTool = {
-  name: "subagent_check",
-  readonly: true,
-  description:
-    "Fetch the result of an async subagent (subagent with async:true). Spawn async children to keep working in your own turn while they run in the background, then collect their reports here. Multiple async children return in completion (arrival) order — the first finished is returned first, so fast results are handled immediately instead of waiting for the slowest. Blocks until the target finishes.\n" +
-    "When done is true, no more results are coming (all finished and consumed) — anything left arrives automatically at turn end.\n" +
-    "Parameters:\n" +
-    "- id (optional): the subagent id from the async spawn return. Omit to fetch the next completed child (arrival order).\n" +
-    "- n (required): 1-based read counter — pass 1 on the first check, 2 on the next, and so on. Consecutive checks must be distinct tool calls (loop detector); at most 3 checks per turn — use the turn-end auto-wait for the rest.",
-  parameters: {
-    type: "object",
-    properties: {
-      id: { type: "string", description: "Optional subagent id (from the async spawn return). Omit = next completed child (arrival order)." },
-      n: { type: "number", description: "1-based read counter: 1 for the first check of the turn, incrementing with each subsequent check (loop detector — consecutive checks must be distinct tool calls)." },
-    },
-    required: ["n"],
-  },
-  async execute({ id, n }, ctx) {
-    const agent = ctx.agent
-    const map = agent._asyncSubagents ?? new Map()
-    // Strict 1-based incrementing read counter (D-A2, review #1): out-of-order /
-    // repeated n is rejected WITHOUT consuming a result (T14).
-    const lastN = agent._asyncCheckLastN ?? 0
-    if (!Number.isInteger(n) || n !== lastN + 1) {
-      return JSON.stringify({ status: "error", error: "invalid read counter — pass n = lastN+1" })
-    }
-    if (n > MAX_ASYNC_CHECKS) {
-      return JSON.stringify({ status: "error", error: "check limit exceeded — use turn-end auto-wait for the rest" })
-    }
-    agent._asyncCheckLastN = n
-
-    let target = null
-    if (id !== undefined && id !== null && String(id) !== "") {
-      target = map.get(String(id))
-      // Unknown OR already-consumed ids (consumed entries are deleted) — same error (T12).
-      if (!target) return JSON.stringify({ id: String(id), status: "error", error: `unknown async subagent id: ${id}` })
-    }
-
-    // Block until the target settles (specific id / next completed in arrival order).
-    for (;;) {
-      if (target) {
-        if (target.done) break
-        const woke = await wakeOnAsyncSettle(agent, ctx)
-        if (woke === "aborted") return JSON.stringify({ done: true, stopped: true })
-        continue
-      }
-      const completed = [...map.values()].filter((e) => e.done)
-      if (completed.length > 0) {
-        target = completed.sort((a, b) => (a._settleSeq ?? 0) - (b._settleSeq ?? 0))[0]
-        break
-      }
-      if (map.size === 0) return JSON.stringify({ done: true })
-      const woke = await wakeOnAsyncSettle(agent, ctx)
-      if (woke === "aborted") return JSON.stringify({ done: true, stopped: true })
-    }
-
-    map.delete(String(target.id))
-    if (target.error) return JSON.stringify({ id: String(target.id), status: "error", error: target.error })
-    return JSON.stringify({ id: String(target.id), role: target.role, status: "done", report: target.report ?? "" })
-  },
-}

package/src/tools/exec-prelude.mjs

@@ -1,84 +0,0 @@
-/**
- * exec-prelude.mjs — sandbox API injected into `execute`'s child process.
- *
- * The `execute` tool spawns `node --input-type=module --eval` and `import()`-s
- * this file first, so the user's code gets readFile/writeFile/glob/grep/log/require
- * without hand-writing fs boilerplate. Confines file paths to the workspace root
- * (THINCODER_EXEC_ROOT, default cwd) — an orthopedic guard, NOT a sandbox:
- * require()/process/import()/fetch() are full Node, the same boundary as bash
- * (project philosophy: no fake sandbox; transparency + audit).
- */
-import { createRequire } from "node:module"
-import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync, readdirSync } from "node:fs"
-import { resolve, relative, dirname, join, isAbsolute, sep } from "node:path"
-
-const require = createRequire(join(process.cwd(), "__exec__.js"))
-const root = process.env.THINCODER_EXEC_ROOT || process.cwd()
-
-/** Resolve a path against the working dir, asserting it stays within the workspace root. */
-function safe(p) {
-  if (typeof p !== "string") throw new Error(`Path must be a string, got ${typeof p}`)
-  const abs = resolve(process.cwd(), p)
-  const rel = relative(root, abs)
-  // isAbsolute(rel) covers cross-drive (relative() returns an absolute path then)
-  if (isAbsolute(rel) || rel === ".." || rel.startsWith(".." + sep)) {
-    throw new Error(`Path traversal denied: ${p}`)
-  }
-  return abs
-}
-
-function globToRegex(pattern) {
-  const DS = "\u0001", DP = "\u0002"
-  const escaped = pattern
-    .replace(/\*\*\//g, DS).replace(/\*\*/g, DP)
-    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-    .replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")
-    .replace(new RegExp(DS, "g"), "(?:.+/)?").replace(new RegExp(DP, "g"), ".*")
-  return new RegExp(`^${escaped}$`)
-}
-
-globalThis.require = require
-globalThis.readFile = (p) => {
-  const abs = safe(p)
-  if (!existsSync(abs)) throw new Error(`File not found: ${p}`)
-  if (statSync(abs).size > 5_000_000) throw new Error(`File too large: ${p}`)
-  return readFileSync(abs, "utf8").replace(/\r\n/g, "\n")
-}
-globalThis.writeFile = (p, content) => {
-  const abs = safe(p)
-  mkdirSync(dirname(abs), { recursive: true })
-  writeFileSync(abs, String(content), "utf8")
-}
-globalThis.glob = (pattern) => {
-  if (typeof pattern !== "string") throw new Error("glob pattern must be a string")
-  const re = globToRegex(pattern)
-  const out = []
-  function walk(dir, rel) {
-    let entries
-    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
-    for (const e of entries) {
-      if (e.name.startsWith(".") || e.name === "node_modules") continue
-      const rp = rel ? `${rel}/${e.name}` : e.name
-      if (e.isDirectory()) walk(join(dir, e.name), rp)
-      else if (re.test(rp)) out.push(rp)
-    }
-  }
-  walk(process.cwd(), "")
-  const capped = out.slice(0, 200)
-  if (out.length > 200) capped.push(`... (${out.length - 200} more)`)
-  return capped
-}
-globalThis.grep = (pattern, file) => {
-  if (typeof pattern !== "string") throw new Error("grep pattern must be a string")
-  if (typeof file !== "string") throw new Error("grep file must be a string")
-  const abs = safe(file)
-  if (!existsSync(abs)) throw new Error(`File not found: ${file}`)
-  const re = new RegExp(pattern)
-  const lines = readFileSync(abs, "utf8").replace(/\r\n/g, "\n").split("\n")
-  const m = []
-  for (let i = 0; i < lines.length; i++) if (re.test(lines[i])) m.push(`${i + 1}: ${lines[i].slice(0, 200)}`)
-  const capped = m.slice(0, 100)
-  if (m.length > 100) capped.push(`... (${m.length - 100} more)`)
-  return capped
-}
-globalThis.log = (...a) => console.log(a.map((x) => (x && typeof x === "object" ? JSON.stringify(x) : String(x))).join(" "))