@wrongstack/tools 0.292.1 → 0.295.0

package/dist/read.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/read.ts", "../src/_util.ts"],
-  "sourcesContent": ["import * as fs from 'node:fs/promises';\nimport { type Tool, FsError, toErrorMessage, ToolValidationError } from '@wrongstack/core';\nimport { isBinaryBuffer, safeResolveReal, sha256hex } from './_util.js';\n\ninterface ReadInput {\n  path: string;\n  offset?: number | undefined;\n  limit?: number | undefined;\n  mode?: 'content' | 'summary' | undefined;\n}\n\ninterface ReadOutput {\n  text: string;\n  total_lines: number;\n  encoding: string;\n  truncated: boolean;\n  cached?: boolean | undefined;\n  note?: string | undefined;\n}\n\nconst MAX_BYTES = 5 * 1024 * 1024;\n\nexport const readTool: Tool<ReadInput, ReadOutput> = {\n  name: 'read',\n  category: 'Filesystem',\n  description:\n    'Read the contents of a file with line numbers. This is the primary way to inspect source code, configuration, or any text file before making changes. ' +\n    'Lines are returned 1-indexed with a `   N| ` prefix for easy reference in edits.',\n  usageHint:\n    'FOUNDATIONAL TOOL \u2014 call this before almost any edit operation.\\n\\n' +\n    'Best practices:\\n' +\n    '- Always read a file before using `edit`, `replace`, or `write` on it (the system often requires it for safety).\\n' +\n    '- Use `offset` + `limit` for very large files instead of reading everything at once.\\n' +\n    '- Default limit is generous (2000 lines) but can be increased.\\n' +\n    '- The output format is designed to be directly usable as context for `edit` operations.',\n  selection: {\n    doNotUseWhen: 'you need to search many files for matching content.',\n    useInstead: ['grep'],\n  },\n  permission: 'auto',\n  mutating: false,\n  capabilities: ['fs.read'],\n  icon: 'file',\n  maxOutputBytes: 262_144,\n  timeoutMs: 5_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      path: {\n        type: 'string',\n        description: 'Path to the file (relative to project root or absolute within project).',\n      },\n      offset: {\n        type: 'integer',\n        description: '1-based starting line number. Use together with `limit` for large files.',\n      },\n      limit: {\n        type: 'integer',\n        description: 'Maximum number of lines to return (default is 2000).',\n      },\n      mode: {\n        type: 'string',\n        enum: ['content', 'summary'],\n        description:\n          'Return full line-numbered content (default) or a compact file summary with imports/exports/symbols.',\n      },\n    },\n    required: ['path'],\n  },\n  async execute(input, ctx) {\n    if (!input?.path) {\n      throw new ToolValidationError({\n        message: 'read: path is required',\n        field: 'path',\n      });\n    }\n    const absPath = await safeResolveReal(input.path, ctx);\n\n    let stat: Awaited<ReturnType<typeof fs.stat>>;\n    try {\n      stat = await fs.stat(absPath);\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code;\n      if (code === 'ENOENT') {\n        throw new FsError({\n          message: `read: file not found \"${input.path}\"`,\n          code: 'FS_READ_FAILED',\n          path: absPath,\n          context: { errno: 'ENOENT' },\n        });\n      }\n      throw new FsError({\n        message: `read: failed to stat \"${input.path}\": ${toErrorMessage(err)}`,\n        code: 'FS_READ_FAILED',\n        path: absPath,\n        context: { errno: code },\n        cause: err,\n      });\n    }\n    if (!stat.isFile()) {\n      throw new FsError({\n        message: `read: \"${input.path}\" is not a regular file`,\n        code: 'FS_READ_FAILED',\n        path: absPath,\n        context: { reason: 'not-a-regular-file' },\n      });\n    }\n    if (stat.size > MAX_BYTES) {\n      throw new FsError({\n        message: `read: file too large (${stat.size} bytes, limit ${MAX_BYTES})`,\n        code: 'FS_READ_FAILED',\n        path: absPath,\n        context: { size: stat.size, limit: MAX_BYTES, reason: 'too-large' },\n      });\n    }\n\n    const offset = Math.max(1, input.offset ?? 1);\n    const limit = Math.max(0, Math.min(input.limit ?? 2000, 5000));\n    const prior = getReadRangeRecord(ctx, absPath);\n    const requestedEnd = prior\n      ? Math.min(offset + limit - 1, prior.totalLines)\n      : offset + limit - 1;\n    if (\n      input.mode !== 'summary' &&\n      limit > 0 &&\n      prior &&\n      coversRange(prior, stat.mtimeMs, offset, requestedEnd)\n    ) {\n      ctx.recordRead(absPath, stat.mtimeMs);\n      return {\n        text:\n          `[unchanged since previous read: \"${input.path}\" mtime=${Math.round(stat.mtimeMs)}; ` +\n          `requested lines ${offset}-${requestedEnd} were already shown. Use offset/limit for a new range if needed.]`,\n        total_lines: prior.totalLines,\n        encoding: 'utf8',\n        truncated: requestedEnd < prior.totalLines,\n        cached: true,\n        note: 'Repeated read suppressed to save tokens.',\n      };\n    }\n\n    const buf = await fs.readFile(absPath);\n    if (isBinaryBuffer(buf)) {\n      throw new Error(`read: \"${input.path}\" appears to be binary`);\n    }\n\n    const text = buf.toString('utf8');\n    // Content hash recorded alongside the mtime: `edit` uses it as the\n    // authoritative staleness check (mtime alone has a 2 s tolerance window\n    // on Windows). The full file is read even for offset/limit slices, so\n    // the hash always covers the whole content.\n    const contentHash = sha256hex(text);\n    const allLines = text.split(/\\r\\n|\\r|\\n/);\n    const total = allLines.length;\n\n    if (input.mode === 'summary') {\n      ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n      rememberReadRange(ctx, absPath, stat.mtimeMs, total, 1, Math.min(total, 200));\n      return {\n        text: summarizeFile(input.path, stat.size, allLines),\n        total_lines: total,\n        encoding: 'utf8',\n        truncated: total > 200,\n        note: 'Summary mode returned compact structure instead of full file content.',\n      };\n    }\n    if (limit === 0) {\n      ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n      rememberReadRange(ctx, absPath, stat.mtimeMs, total, 1, 0);\n      return { text: '', total_lines: total, encoding: 'utf8', truncated: total > 0 };\n    }\n    // Offset past EOF: return an explicit message instead of an empty string.\n    // Without this, models with weak instruction-following (e.g. k2p7) see an\n    // empty result, assume the read failed transiently, and retry the exact\n    // same offset indefinitely \u2014 a tight tool-use loop that burns iterations\n    // and context without making progress.\n    if (offset > total) {\n      ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n      rememberReadRange(ctx, absPath, stat.mtimeMs, total, total + 1, total + 1);\n      return {\n        text: `[offset ${offset} is past end of file \"${input.path}\" \u2014 file has ${total} line(s). Do not retry this offset.]`,\n        total_lines: total,\n        encoding: 'utf8',\n        truncated: false,\n      };\n    }\n\n    const slice = allLines.slice(offset - 1, offset - 1 + limit);\n    const truncated = offset - 1 + slice.length < total;\n\n    const width = String(offset + slice.length - 1).length;\n    const numbered = slice\n      .map((line, i) => `${String(offset + i).padStart(width, ' ')}\u2192${line}`)\n      .join('\\n');\n\n    ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n    rememberReadRange(ctx, absPath, stat.mtimeMs, total, offset, offset + slice.length - 1);\n\n    return {\n      text: numbered,\n      total_lines: total,\n      encoding: 'utf8',\n      truncated,\n    };\n  },\n};\n\ninterface ReadRangeRecord {\n  mtimeMs: number;\n  totalLines: number;\n  ranges: Array<{ start: number; end: number }>;\n}\n\nconst READ_RANGES_META_KEY = 'tools.read.ranges.v1';\n\nfunction getReadRanges(ctx: import('@wrongstack/core').Context): Record<string, ReadRangeRecord> {\n  const existing = ctx.meta[READ_RANGES_META_KEY];\n  if (existing && typeof existing === 'object' && !Array.isArray(existing)) {\n    return existing as Record<string, ReadRangeRecord>;\n  }\n  const next: Record<string, ReadRangeRecord> = {};\n  ctx.meta[READ_RANGES_META_KEY] = next;\n  return next;\n}\n\nfunction getReadRangeRecord(\n  ctx: import('@wrongstack/core').Context,\n  absPath: string,\n): ReadRangeRecord | undefined {\n  return getReadRanges(ctx)[absPath];\n}\n\nfunction rememberReadRange(\n  ctx: import('@wrongstack/core').Context,\n  absPath: string,\n  mtimeMs: number,\n  totalLines: number,\n  start: number,\n  end: number,\n): void {\n  if (end < start) return;\n  const ranges = getReadRanges(ctx);\n  const prior = ranges[absPath];\n  const nextRanges = prior && Math.abs(prior.mtimeMs - mtimeMs) <= 1 ? prior.ranges.slice() : [];\n  nextRanges.push({ start, end });\n  ranges[absPath] = {\n    mtimeMs,\n    totalLines,\n    ranges: mergeRanges(nextRanges),\n  };\n}\n\nfunction coversRange(\n  record: ReadRangeRecord,\n  mtimeMs: number,\n  start: number,\n  end: number,\n): boolean {\n  if (Math.abs(record.mtimeMs - mtimeMs) > 1) return false;\n  return record.ranges.some((range) => range.start <= start && range.end >= end);\n}\n\nfunction mergeRanges(\n  ranges: Array<{ start: number; end: number }>,\n): Array<{ start: number; end: number }> {\n  const sorted = ranges.slice().sort((a, b) => a.start - b.start);\n  const merged: Array<{ start: number; end: number }> = [];\n  for (const range of sorted) {\n    const last = merged[merged.length - 1];\n    if (!last || range.start > last.end + 1) {\n      merged.push({ ...range });\n      continue;\n    }\n    last.end = Math.max(last.end, range.end);\n  }\n  return merged;\n}\n\nfunction summarizeFile(filePath: string, bytes: number, lines: string[]): string {\n  const interesting = lines\n    .map((line, index) => ({ line: line.trim(), number: index + 1 }))\n    .filter(({ line }) =>\n      /^(import\\s|export\\s|class\\s|interface\\s|type\\s|function\\s|const\\s+\\w+\\s*=|let\\s+\\w+\\s*=|var\\s+\\w+\\s*=|def\\s+|async\\s+function\\s)/.test(\n        line,\n      ),\n    )\n    .slice(0, 80)\n    .map(({ line, number }) => `${number}: ${line}`);\n  return [\n    `summary: ${filePath}`,\n    `bytes=${bytes}`,\n    `total_lines=${lines.length}`,\n    interesting.length > 0\n      ? `symbols/imports:\\n${interesting.join('\\n')}`\n      : 'symbols/imports: (none detected)',\n  ].join('\\n');\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core';\nimport type { Context } from '@wrongstack/core';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import * as fs from 'node:fs/promises';\nimport { FsError, ToolValidationError, type Tool } from '@wrongstack/core/types';\nimport { toErrorMessage } from '@wrongstack/core/utils';\nimport { isBinaryBuffer, safeResolveReal, sha256hex } from './_util.js';\n\ninterface ReadInput {\n  path: string;\n  offset?: number | undefined;\n  limit?: number | undefined;\n  mode?: 'content' | 'summary' | undefined;\n}\n\ninterface ReadOutput {\n  text: string;\n  total_lines: number;\n  encoding: string;\n  truncated: boolean;\n  cached?: boolean | undefined;\n  note?: string | undefined;\n}\n\nconst MAX_BYTES = 5 * 1024 * 1024;\n\nexport const readTool: Tool<ReadInput, ReadOutput> = {\n  name: 'read',\n  category: 'Filesystem',\n  description:\n    'Read the contents of a file with line numbers. This is the primary way to inspect source code, configuration, or any text file before making changes. ' +\n    'Lines are returned 1-indexed with a `   N| ` prefix for easy reference in edits.',\n  usageHint:\n    'FOUNDATIONAL TOOL \u2014 call this before almost any edit operation.\\n\\n' +\n    'Best practices:\\n' +\n    '- Always read a file before using `edit`, `replace`, or `write` on it (the system often requires it for safety).\\n' +\n    '- Use `offset` + `limit` for very large files instead of reading everything at once.\\n' +\n    '- Default limit is generous (2000 lines) but can be increased.\\n' +\n    '- The output format is designed to be directly usable as context for `edit` operations.',\n  selection: {\n    doNotUseWhen: 'you need to search many files for matching content.',\n    useInstead: ['grep'],\n  },\n  permission: 'auto',\n  mutating: false,\n  capabilities: ['fs.read'],\n  icon: 'file',\n  maxOutputBytes: 262_144,\n  timeoutMs: 5_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      path: {\n        type: 'string',\n        description: 'Path to the file (relative to project root or absolute within project).',\n      },\n      offset: {\n        type: 'integer',\n        description: '1-based starting line number. Use together with `limit` for large files.',\n      },\n      limit: {\n        type: 'integer',\n        description: 'Maximum number of lines to return (default is 2000).',\n      },\n      mode: {\n        type: 'string',\n        enum: ['content', 'summary'],\n        description:\n          'Return full line-numbered content (default) or a compact file summary with imports/exports/symbols.',\n      },\n    },\n    required: ['path'],\n  },\n  async execute(input, ctx) {\n    if (!input?.path) {\n      throw new ToolValidationError({\n        message: 'read: path is required',\n        field: 'path',\n      });\n    }\n    const absPath = await safeResolveReal(input.path, ctx);\n\n    let stat: Awaited<ReturnType<typeof fs.stat>>;\n    try {\n      stat = await fs.stat(absPath);\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code;\n      if (code === 'ENOENT') {\n        throw new FsError({\n          message: `read: file not found \"${input.path}\"`,\n          code: 'FS_READ_FAILED',\n          path: absPath,\n          context: { errno: 'ENOENT' },\n        });\n      }\n      throw new FsError({\n        message: `read: failed to stat \"${input.path}\": ${toErrorMessage(err)}`,\n        code: 'FS_READ_FAILED',\n        path: absPath,\n        context: { errno: code },\n        cause: err,\n      });\n    }\n    if (!stat.isFile()) {\n      throw new FsError({\n        message: `read: \"${input.path}\" is not a regular file`,\n        code: 'FS_READ_FAILED',\n        path: absPath,\n        context: { reason: 'not-a-regular-file' },\n      });\n    }\n    if (stat.size > MAX_BYTES) {\n      throw new FsError({\n        message: `read: file too large (${stat.size} bytes, limit ${MAX_BYTES})`,\n        code: 'FS_READ_FAILED',\n        path: absPath,\n        context: { size: stat.size, limit: MAX_BYTES, reason: 'too-large' },\n      });\n    }\n\n    const offset = Math.max(1, input.offset ?? 1);\n    const limit = Math.max(0, Math.min(input.limit ?? 2000, 5000));\n    const prior = getReadRangeRecord(ctx, absPath);\n    const requestedEnd = prior\n      ? Math.min(offset + limit - 1, prior.totalLines)\n      : offset + limit - 1;\n    if (\n      input.mode !== 'summary' &&\n      limit > 0 &&\n      prior &&\n      coversRange(prior, stat.mtimeMs, offset, requestedEnd)\n    ) {\n      ctx.recordRead(absPath, stat.mtimeMs);\n      return {\n        text:\n          `[unchanged since previous read: \"${input.path}\" mtime=${Math.round(stat.mtimeMs)}; ` +\n          `requested lines ${offset}-${requestedEnd} were already shown. Use offset/limit for a new range if needed.]`,\n        total_lines: prior.totalLines,\n        encoding: 'utf8',\n        truncated: requestedEnd < prior.totalLines,\n        cached: true,\n        note: 'Repeated read suppressed to save tokens.',\n      };\n    }\n\n    const buf = await fs.readFile(absPath);\n    if (isBinaryBuffer(buf)) {\n      throw new Error(`read: \"${input.path}\" appears to be binary`);\n    }\n\n    const text = buf.toString('utf8');\n    // Content hash recorded alongside the mtime: `edit` uses it as the\n    // authoritative staleness check (mtime alone has a 2 s tolerance window\n    // on Windows). The full file is read even for offset/limit slices, so\n    // the hash always covers the whole content.\n    const contentHash = sha256hex(text);\n    const allLines = text.split(/\\r\\n|\\r|\\n/);\n    const total = allLines.length;\n\n    if (input.mode === 'summary') {\n      ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n      rememberReadRange(ctx, absPath, stat.mtimeMs, total, 1, Math.min(total, 200));\n      return {\n        text: summarizeFile(input.path, stat.size, allLines),\n        total_lines: total,\n        encoding: 'utf8',\n        truncated: total > 200,\n        note: 'Summary mode returned compact structure instead of full file content.',\n      };\n    }\n    if (limit === 0) {\n      ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n      rememberReadRange(ctx, absPath, stat.mtimeMs, total, 1, 0);\n      return { text: '', total_lines: total, encoding: 'utf8', truncated: total > 0 };\n    }\n    // Offset past EOF: return an explicit message instead of an empty string.\n    // Without this, models with weak instruction-following (e.g. k2p7) see an\n    // empty result, assume the read failed transiently, and retry the exact\n    // same offset indefinitely \u2014 a tight tool-use loop that burns iterations\n    // and context without making progress.\n    if (offset > total) {\n      ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n      rememberReadRange(ctx, absPath, stat.mtimeMs, total, total + 1, total + 1);\n      return {\n        text: `[offset ${offset} is past end of file \"${input.path}\" \u2014 file has ${total} line(s). Do not retry this offset.]`,\n        total_lines: total,\n        encoding: 'utf8',\n        truncated: false,\n      };\n    }\n\n    const slice = allLines.slice(offset - 1, offset - 1 + limit);\n    const truncated = offset - 1 + slice.length < total;\n\n    const width = String(offset + slice.length - 1).length;\n    const numbered = slice\n      .map((line, i) => `${String(offset + i).padStart(width, ' ')}\u2192${line}`)\n      .join('\\n');\n\n    ctx.recordRead(absPath, stat.mtimeMs, 'user', contentHash);\n    rememberReadRange(ctx, absPath, stat.mtimeMs, total, offset, offset + slice.length - 1);\n\n    return {\n      text: numbered,\n      total_lines: total,\n      encoding: 'utf8',\n      truncated,\n    };\n  },\n};\n\ninterface ReadRangeRecord {\n  mtimeMs: number;\n  totalLines: number;\n  ranges: Array<{ start: number; end: number }>;\n}\n\nconst READ_RANGES_META_KEY = 'tools.read.ranges.v1';\n\nfunction getReadRanges(ctx: import('@wrongstack/core/agent').Context): Record<string, ReadRangeRecord> {\n  const existing = ctx.meta[READ_RANGES_META_KEY];\n  if (existing && typeof existing === 'object' && !Array.isArray(existing)) {\n    return existing as Record<string, ReadRangeRecord>;\n  }\n  const next: Record<string, ReadRangeRecord> = {};\n  ctx.meta[READ_RANGES_META_KEY] = next;\n  return next;\n}\n\nfunction getReadRangeRecord(\n  ctx: import('@wrongstack/core/agent').Context,\n  absPath: string,\n): ReadRangeRecord | undefined {\n  return getReadRanges(ctx)[absPath];\n}\n\nfunction rememberReadRange(\n  ctx: import('@wrongstack/core/agent').Context,\n  absPath: string,\n  mtimeMs: number,\n  totalLines: number,\n  start: number,\n  end: number,\n): void {\n  if (end < start) return;\n  const ranges = getReadRanges(ctx);\n  const prior = ranges[absPath];\n  const nextRanges = prior && Math.abs(prior.mtimeMs - mtimeMs) <= 1 ? prior.ranges.slice() : [];\n  nextRanges.push({ start, end });\n  ranges[absPath] = {\n    mtimeMs,\n    totalLines,\n    ranges: mergeRanges(nextRanges),\n  };\n}\n\nfunction coversRange(\n  record: ReadRangeRecord,\n  mtimeMs: number,\n  start: number,\n  end: number,\n): boolean {\n  if (Math.abs(record.mtimeMs - mtimeMs) > 1) return false;\n  return record.ranges.some((range) => range.start <= start && range.end >= end);\n}\n\nfunction mergeRanges(\n  ranges: Array<{ start: number; end: number }>,\n): Array<{ start: number; end: number }> {\n  const sorted = ranges.slice().sort((a, b) => a.start - b.start);\n  const merged: Array<{ start: number; end: number }> = [];\n  for (const range of sorted) {\n    const last = merged[merged.length - 1];\n    if (!last || range.start > last.end + 1) {\n      merged.push({ ...range });\n      continue;\n    }\n    last.end = Math.max(last.end, range.end);\n  }\n  return merged;\n}\n\nfunction summarizeFile(filePath: string, bytes: number, lines: string[]): string {\n  const interesting = lines\n    .map((line, index) => ({ line: line.trim(), number: index + 1 }))\n    .filter(({ line }) =>\n      /^(import\\s|export\\s|class\\s|interface\\s|type\\s|function\\s|const\\s+\\w+\\s*=|let\\s+\\w+\\s*=|var\\s+\\w+\\s*=|def\\s+|async\\s+function\\s)/.test(\n        line,\n      ),\n    )\n    .slice(0, 80)\n    .map(({ line, number }) => `${number}: ${line}`);\n  return [\n    `summary: ${filePath}`,\n    `bytes=${bytes}`,\n    `total_lines=${lines.length}`,\n    interesting.length > 0\n      ? `symbols/imports:\\n${interesting.join('\\n')}`\n      : 'symbols/imports: (none detected)',\n  ].join('\\n');\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core/utils';\nimport type { Context } from '@wrongstack/core/agent';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
+  "mappings": "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",
   "names": ["stat"]
 }

package/dist/replace.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '@wrongstack/core';
+import type { Tool } from '@wrongstack/core/types';
 interface ReplaceInput {
     pattern: string;
     replacement: string;

package/dist/replace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replace.d.ts","sourceRoot":"","sources":["../src/replace.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGtD,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,UAAU,aAAa;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,EAAE,CAAC;IAC7E,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,eAAO,MAAM,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,CAkMzD,CAAC"}
+{"version":3,"file":"replace.d.ts","sourceRoot":"","sources":["../src/replace.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAGnD,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,UAAU,aAAa;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,EAAE,CAAC;IAC7E,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,eAAO,MAAM,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,CAkMzD,CAAC"}

package/dist/replace.js

@@ -1,5 +1,5 @@
 // src/replace.ts
-import { expectDefined } from "@wrongstack/core";
+import { expectDefined } from "@wrongstack/core/utils";
 import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path2 from "node:path";
@@ -10,9 +10,9 @@ import {
   detectNewlineStyle,
   normalizeToLf,
   toStyle,
-  ToolValidationError,
   unifiedDiff
-} from "@wrongstack/core";
+} from "@wrongstack/core/utils";
+import { ToolValidationError } from "@wrongstack/core/types";
 
 // src/_regex.ts
 var MAX_PATTERN_LEN = 256;
@@ -59,7 +59,7 @@ var MAX_SUBJECT_LEN = 64 * 1024;
 // src/_util.ts
 import { createHash } from "node:crypto";
 import * as path from "node:path";
-import * as Core from "@wrongstack/core";
+import * as Core from "@wrongstack/core/utils";
 function sha256hex(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }

package/dist/replace.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/replace.ts", "../src/_regex.ts", "../src/_util.ts"],
-  "sourcesContent": ["import { expectDefined } from '@wrongstack/core';\nimport { spawn } from 'node:child_process';\nimport * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport {\n  atomicWrite,\n  buildChildEnv,\n  compileGlob,\n  detectNewlineStyle,\n  normalizeToLf,\n  toStyle,\n  ToolValidationError,\n  unifiedDiff,\n} from '@wrongstack/core';\nimport type { Context, Tool } from '@wrongstack/core';\nimport { compileUserRegex } from './_regex.js';\nimport { isBinaryBuffer, safeResolve, sha256hex } from './_util.js';\ninterface ReplaceInput {\n  pattern: string;\n  replacement: string;\n  files: string | string[];\n  glob?: string | undefined;\n  replace_all?: boolean | undefined;\n  dry_run?: boolean | undefined;\n}\n\ninterface ReplaceOutput {\n  files_modified: number;\n  total_replacements: number;\n  results: { path: string; replacements: number; diff?: string | undefined }[];\n  dry_run: boolean;\n}\n\nconst DEFAULT_IGNORE = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage'];\n\nexport const replaceTool: Tool<ReplaceInput, ReplaceOutput> = {\n  name: 'replace',\n  category: 'Transform',\n  description:\n    'Perform a search-and-replace across multiple files using a regex pattern. ' +\n    'This is a powerful bulk transformation tool. Dry-run is ON by default \u2014 set `dry_run: false` to apply changes.',\n  usageHint:\n    'DANGEROUS IF USED CARELESSLY \u2014 review the diff output carefully.\\n\\n' +\n    'Recommended workflow:\\n' +\n    '1. Run without `dry_run: false` first to see exactly what would change (dry-run is the default).\\n' +\n    '2. Review the diff output, then re-run with `dry_run: false` to apply.\\n' +\n    '3. Use a specific enough `pattern` (and `glob` / `files`) to avoid accidental broad changes.\\n' +\n    '4. `replace_all` controls whether only the first match per file or all matches are replaced.\\n' +\n    'This tool is excellent for large-scale refactors (renaming, import updates, etc.) but must be used with caution.',\n  permission: 'confirm',\n  mutating: true,\n  capabilities: ['fs.write'],\n  icon: 'edit',\n  timeoutMs: 30_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      pattern: { type: 'string', description: 'Regex pattern to match' },\n      replacement: { type: 'string', description: 'Replacement string' },\n      files: {\n        type: 'string',\n        description: 'File(s) to target: single path, comma-separated list, or glob pattern',\n      },\n      glob: { type: 'string', description: 'Additional glob filter (e.g. \"*.ts\")' },\n      replace_all: {\n        type: 'boolean',\n        description: 'Replace all occurrences in each file (default: true)',\n      },\n      dry_run: { type: 'boolean', description: 'Preview changes without writing (default: true)' },\n    },\n    required: ['pattern', 'replacement', 'files'],\n  },\n  async execute(input: ReplaceInput, ctx: Context) {\n    if (!input?.pattern) {\n      throw new ToolValidationError({\n        message: 'replace: pattern is required',\n        field: 'pattern',\n      });\n    }\n    if (input.replacement === undefined) {\n      throw new ToolValidationError({\n        message: 'replace: replacement is required',\n        field: 'replacement',\n      });\n    }\n    if (!input?.files) {\n      throw new ToolValidationError({\n        message: 'replace: files is required',\n        field: 'files',\n      });\n    }\n\n    const replaceAll = input.replace_all ?? true;\n    // Always compile with 'g' so matchAll() works \u2014 matchAll throws\n    // TypeError on non-global regexes. The replaceAll flag controls\n    // how many matches we act on, not whether the regex is global.\n    const compiled = compileUserRegex(input.pattern, 'g');\n    if (!compiled.ok) {\n      throw new ToolValidationError({\n        message: `replace: ${compiled.reason}`,\n        field: 'pattern',\n      });\n    }\n    const re = compiled.regex;\n    const globRe = input.glob ? compileGlob(input.glob) : null;\n    const dryRun = input.dry_run ?? true;\n\n    const filesInput = Array.isArray(input.files) ? input.files.join(',') : input.files;\n    const fileList = await resolveFiles(filesInput, ctx, globRe);\n\n    // Resolve the project root through realpath ONCE so the sandbox check\n    // below compares like-for-like with realpath(file). The project root\n    // itself can be a symlink or short name \u2014 e.g. macOS temp dirs live under\n    // /var -> /private/var, and Windows CI runners expose an 8.3 short name\n    // (C:\\Users\\RUNNER~1\\...). Comparing realpath(file) against the raw root\n    // then makes every legitimately-inside file look \"outside\" and skips it.\n    const realRoot = await fs.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);\n\n    const results: ReplaceOutput['results'] = [];\n    let totalReplacements = 0;\n\n    for (const absPath of fileList) {\n      // Use lstat to detect symlinks. resolveFiles already applies\n      // safeResolve, but a symlink with a target outside the project\n      // root would still pass that string check \u2014 explicitly skip it\n      // so we never read or write through a link.\n      const lstat = await fs.lstat(absPath).catch((err) => {\n        if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;\n        /* v8 ignore next -- non-ENOENT lstat failure (EACCES etc.) is a defensive rethrow. */\n        throw err;\n      });\n      if (!lstat?.isFile()) continue;\n      if (lstat.isSymbolicLink()) continue;\n\n      // Cross-check via realpath: if the resolved target lives outside the\n      // project root (e.g. a bind mount or a parent-dir traversal we missed),\n      // skip rather than rewrite through it.\n      let realPath: string;\n      try {\n        realPath = await fs.realpath(absPath);\n      } catch {\n        /* v8 ignore next -- realpath failing after a successful lstat is a TOCTOU race; defensive. */\n        continue;\n      }\n      const rel = path.relative(realRoot, realPath);\n      if (rel.startsWith('..') || path.isAbsolute(rel)) continue;\n\n      // Now stat the real target so we use its mode for atomicWrite.\n      const stat = await fs.stat(realPath).catch(() => null);\n      if (!stat?.isFile()) continue;\n\n      let content: string;\n      try {\n        const buf = await fs.readFile(realPath);\n        if (isBinaryBuffer(buf)) continue;\n        content = buf.toString('utf8');\n      } catch {\n        /* v8 ignore next -- readFile failing after a successful stat is a TOCTOU race; defensive. */\n        continue;\n      }\n\n      const style = detectNewlineStyle(content);\n      const contentLf = normalizeToLf(content);\n      re.lastIndex = 0;\n      const allMatches = [...contentLf.matchAll(re)];\n      if (allMatches.length === 0) continue;\n\n      // When replace_all is false, only act on the first match.\n      const matches = replaceAll ? allMatches : allMatches.slice(0, 1);\n      const count = matches.length;\n\n      // Rebuild: splice the replacement into each match position from\n      // right to left so earlier indices stay valid.\n      let newContentLf = contentLf;\n      for (let i = matches.length - 1; i >= 0; i--) {\n        const m = expectDefined(matches[i]);\n        newContentLf =\n          newContentLf.slice(0, m.index) +\n          input.replacement +\n          newContentLf.slice(expectDefined(m.index) + m[0].length);\n      }\n      re.lastIndex = 0;\n      totalReplacements += count;\n\n      if (!dryRun) {\n        const newContent = toStyle(newContentLf, style);\n        // Write to the real path (already validated inside project root)\n        // so atomicWrite's temp-and-rename can't be redirected through a\n        // freshly-planted symlink at absPath.\n        await atomicWrite(realPath, newContent, { mode: stat.mode & 0o777 });\n        // Same bookkeeping as `edit`: record the new mtime + hash (tagged\n        // 'write' so the permission bypass does not widen) so a later `edit`\n        // of this file doesn't trip the stale-read guard on our own write,\n        // and record the change for session rewind. Optional calls: embedders\n        // may hand in a duck-typed Context without these members.\n        const written = await fs.stat(realPath).catch(() => null);\n        if (written) {\n          ctx.recordRead?.(realPath, written.mtimeMs, 'write', sha256hex(newContent));\n        }\n        ctx.session?.recordFileChange?.({\n          path: realPath,\n          action: 'modified',\n          before: content,\n          after: newContent,\n        });\n      }\n\n      const diff =\n        dryRun || matches.length > 0\n          ? unifiedDiff(content, toStyle(newContentLf, style), {\n              fromFile: absPath,\n              toFile: absPath,\n            })\n          : undefined;\n\n      results.push({\n        path: absPath,\n        replacements: matches.length,\n        diff,\n      });\n    }\n\n    return {\n      files_modified: results.length,\n      total_replacements: totalReplacements,\n      results,\n      dry_run: dryRun,\n    };\n  },\n};\n\nasync function resolveFiles(\n  filesInput: string,\n  ctx: Context,\n  extraGlob?: RegExp | null | undefined,\n): Promise<string[]> {\n  const base = ctx.cwd;\n  const normalized = filesInput.trim();\n\n  if (normalized.startsWith('**/') || normalized.startsWith('*') || normalized.includes('**')) {\n    return await globFiles(normalized, base, extraGlob);\n  }\n\n  const parts = normalized\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean);\n  const resolved: string[] = [];\n\n  for (const p of parts) {\n    const absPath = safeResolve(p, ctx);\n    const stat = await fs.stat(absPath).catch(() => null);\n    if (stat?.isFile()) {\n      resolved.push(absPath);\n    }\n  }\n\n  return resolved;\n}\n\nasync function globFiles(\n  pattern: string,\n  base: string,\n  extraGlob?: RegExp | null | undefined,\n): Promise<string[]> {\n\n  const rgAvailable = await checkRg();\n  if (rgAvailable) {\n    try {\n      const { promise } = spawnRgFind(pattern, base);\n      return await promise;\n    } catch {\n      // fall through\n    }\n  }\n\n  return await globNative(pattern, base, extraGlob);\n}\n\nfunction checkRg(): Promise<boolean> {\n  return new Promise((resolve) => {\n    try {\n      const p = spawn('rg', ['--version'], { env: buildChildEnv(), stdio: 'ignore', windowsHide: true });\n      p.on('error', () => resolve(false));\n      p.on('close', (code) => resolve(code === 0));\n    } catch {\n      resolve(false);\n    }\n  });\n}\n\nfunction spawnRgFind(pattern: string, base: string): { promise: Promise<string[]> } {\n  const args = ['--files', '--glob', pattern, base];\n  // 30-second safety net to prevent zombie rg processes. Unlike the main\n  // grep tool, glob file enumeration is fast and should never need more time.\n  const child = spawn('rg', args, {\n    signal: AbortSignal.timeout(30_000),\n    env: buildChildEnv(),\n    stdio: ['ignore', 'pipe', 'pipe'],\n    windowsHide: true,\n  });\n  let buf = '';\n  child.stdout?.on('data', (chunk: Buffer) => {\n    buf += chunk.toString();\n  });\n  return {\n    promise: new Promise((resolve, reject) => {\n      child.on('error', reject);\n      child.on('close', () => {\n        resolve(buf.split('\\n').filter(Boolean));\n      });\n    }),\n  };\n}\n\nasync function globNative(\n  pattern: string,\n  base: string,\n  extraGlob?: RegExp | null | undefined,\n): Promise<string[]> {\n  const results: string[] = [];\n  const globRe = compileGlob(pattern);\n\n  const walk = async (dir: string): Promise<void> => {\n    let entries: import('node:fs').Dirent[];\n    try {\n      entries = await fs.readdir(dir, { withFileTypes: true });\n    } catch {\n      /* v8 ignore next -- unreadable directory during the walk; defensive. */\n      return;\n    }\n    for (const e of entries) {\n      if (DEFAULT_IGNORE.includes(e.name)) continue;\n      const full = path.join(dir, e.name);\n      // Dirent.isSymbolicLink() uses readdir's d_type, which may not detect\n      // directory symlinks on Windows (d_type = DT_UNKNOWN). Defensive stat\n      // call: skip any entry whose lstat shows a symlink \u2014 file or directory.\n      try {\n        const stat = await fs.lstat(full);\n        if (stat.isSymbolicLink()) continue;\n      } catch {\n        // lstat fails for very unusual entries (e.g. broken symlinks to deleted\n        // files on NFS); skip safely rather than surfacing an error.\n        /* v8 ignore next -- lstat failing on a readdir entry is a rare NFS/race case; defensive. */\n        continue;\n      }\n      if (e.isDirectory()) {\n        await walk(full);\n      } else if (e.isFile()) {\n        const name = e.name;\n        if (globRe.test(name) || globRe.test(full)) {\n          if (extraGlob && !extraGlob.test(name) && !extraGlob.test(full)) continue;\n          results.push(full);\n        }\n        globRe.lastIndex = 0;\n        if (extraGlob) extraGlob.lastIndex = 0;\n      }\n    }\n  };\n\n  await walk(base);\n  return results;\n}\n", "/**\n * Compile a user-supplied regex with conservative bounds against ReDoS.\n *\n * Node's regex engine (V8) is backtracking-based and cannot interrupt a\n * synchronous match \u2014 a pattern like `(a+)+$` against a sufficiently long\n * line will pin a worker for seconds. The executor's outer `timeoutMs` only\n * fires between async boundaries, so a long regex eval inside a sync loop\n * is uninterruptible.\n *\n * We can't fully prevent ReDoS without an alternative engine (re2-wasm), but\n * we can sharply limit the blast radius:\n *\n *  1. Cap pattern length \u2014 practically all legitimate user patterns are\n *     under 256 characters. A 4 KB pattern is almost certainly malicious\n *     or a copy-paste accident.\n *  2. Reject patterns containing the most obvious super-linear structures.\n *     This is a coarse filter (false-positives are likely; we accept that\n *     for hostile-input contexts).\n *\n * Callers should additionally bound the *subject* length (e.g. by capping\n * line size before matching).\n */\n\nconst MAX_PATTERN_LEN = 256;\n\n// Heuristics for catastrophic-backtracking constructs. Not exhaustive; bias\n// toward false-positives in tools that accept LLM-generated input.\nconst DANGEROUS_PATTERNS: ReadonlyArray<RegExp> = [\n  // (a+)+, (.*)+, etc \u2014 nested quantifier on a group with internal quantifier\n  /(\\([^)]*[+*][^)]*\\))[+*]/,\n  /(\\(\\?:[^)]*[+*][^)]*\\))[+*]/,\n  // Adjacent quantifiers: a++ a*+\n  /[+*]{2,}/,\n  // Quantifier on alternation with length 2+\n  /\\([^|)]+\\|[^)]+\\)[+*][+*]/,\n  // Greedy quantifier inside lookahead/lookbehind \u2014 (?!.*a+)\n  /[([][^)\\]]*[+*][^)\\]]*[)\\]][^)]*\\?\\??/,\n];\n\nexport interface CompileResult {\n  ok: true;\n  regex: RegExp;\n}\n\nexport interface CompileFail {\n  ok: false;\n  reason: string;\n}\n\nexport function compileUserRegex(pattern: string, flags: string): CompileResult | CompileFail {\n  if (typeof pattern !== 'string') {\n    return { ok: false, reason: 'pattern must be a string' };\n  }\n  if (pattern.length === 0) {\n    return { ok: false, reason: 'pattern is empty' };\n  }\n  if (pattern.length > MAX_PATTERN_LEN) {\n    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };\n  }\n  for (const rx of DANGEROUS_PATTERNS) {\n    if (rx.test(pattern)) {\n      return {\n        ok: false,\n        reason:\n          'pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers',\n      };\n    }\n  }\n  try {\n    return { ok: true, regex: new RegExp(pattern, flags) };\n  } catch (err) {\n    return {\n      ok: false,\n      reason: err instanceof Error ? err.message : 'invalid regex',\n    };\n  }\n}\n\n/**\n * Truncate a subject line to a safe length for synchronous regex eval.\n * The cap is conservative; tools that need exact-line matching against very\n * long lines should use ripgrep externally rather than the native walker.\n */\nexport const MAX_SUBJECT_LEN = 64 * 1024;\n\nexport function capSubject(line: string): string {\n  return line.length > MAX_SUBJECT_LEN ? line.slice(0, MAX_SUBJECT_LEN) : line;\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core';\nimport type { Context } from '@wrongstack/core';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { expectDefined } from '@wrongstack/core/utils';\nimport { spawn } from 'node:child_process';\nimport * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport {\n  atomicWrite,\n  buildChildEnv,\n  compileGlob,\n  detectNewlineStyle,\n  normalizeToLf,\n  toStyle,\n  unifiedDiff,\n} from '@wrongstack/core/utils';\nimport { ToolValidationError } from '@wrongstack/core/types';\nimport type { Context } from '@wrongstack/core/agent';\nimport type { Tool } from '@wrongstack/core/types';\nimport { compileUserRegex } from './_regex.js';\nimport { isBinaryBuffer, safeResolve, sha256hex } from './_util.js';\ninterface ReplaceInput {\n  pattern: string;\n  replacement: string;\n  files: string | string[];\n  glob?: string | undefined;\n  replace_all?: boolean | undefined;\n  dry_run?: boolean | undefined;\n}\n\ninterface ReplaceOutput {\n  files_modified: number;\n  total_replacements: number;\n  results: { path: string; replacements: number; diff?: string | undefined }[];\n  dry_run: boolean;\n}\n\nconst DEFAULT_IGNORE = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage'];\n\nexport const replaceTool: Tool<ReplaceInput, ReplaceOutput> = {\n  name: 'replace',\n  category: 'Transform',\n  description:\n    'Perform a search-and-replace across multiple files using a regex pattern. ' +\n    'This is a powerful bulk transformation tool. Dry-run is ON by default \u2014 set `dry_run: false` to apply changes.',\n  usageHint:\n    'DANGEROUS IF USED CARELESSLY \u2014 review the diff output carefully.\\n\\n' +\n    'Recommended workflow:\\n' +\n    '1. Run without `dry_run: false` first to see exactly what would change (dry-run is the default).\\n' +\n    '2. Review the diff output, then re-run with `dry_run: false` to apply.\\n' +\n    '3. Use a specific enough `pattern` (and `glob` / `files`) to avoid accidental broad changes.\\n' +\n    '4. `replace_all` controls whether only the first match per file or all matches are replaced.\\n' +\n    'This tool is excellent for large-scale refactors (renaming, import updates, etc.) but must be used with caution.',\n  permission: 'confirm',\n  mutating: true,\n  capabilities: ['fs.write'],\n  icon: 'edit',\n  timeoutMs: 30_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      pattern: { type: 'string', description: 'Regex pattern to match' },\n      replacement: { type: 'string', description: 'Replacement string' },\n      files: {\n        type: 'string',\n        description: 'File(s) to target: single path, comma-separated list, or glob pattern',\n      },\n      glob: { type: 'string', description: 'Additional glob filter (e.g. \"*.ts\")' },\n      replace_all: {\n        type: 'boolean',\n        description: 'Replace all occurrences in each file (default: true)',\n      },\n      dry_run: { type: 'boolean', description: 'Preview changes without writing (default: true)' },\n    },\n    required: ['pattern', 'replacement', 'files'],\n  },\n  async execute(input: ReplaceInput, ctx: Context) {\n    if (!input?.pattern) {\n      throw new ToolValidationError({\n        message: 'replace: pattern is required',\n        field: 'pattern',\n      });\n    }\n    if (input.replacement === undefined) {\n      throw new ToolValidationError({\n        message: 'replace: replacement is required',\n        field: 'replacement',\n      });\n    }\n    if (!input?.files) {\n      throw new ToolValidationError({\n        message: 'replace: files is required',\n        field: 'files',\n      });\n    }\n\n    const replaceAll = input.replace_all ?? true;\n    // Always compile with 'g' so matchAll() works \u2014 matchAll throws\n    // TypeError on non-global regexes. The replaceAll flag controls\n    // how many matches we act on, not whether the regex is global.\n    const compiled = compileUserRegex(input.pattern, 'g');\n    if (!compiled.ok) {\n      throw new ToolValidationError({\n        message: `replace: ${compiled.reason}`,\n        field: 'pattern',\n      });\n    }\n    const re = compiled.regex;\n    const globRe = input.glob ? compileGlob(input.glob) : null;\n    const dryRun = input.dry_run ?? true;\n\n    const filesInput = Array.isArray(input.files) ? input.files.join(',') : input.files;\n    const fileList = await resolveFiles(filesInput, ctx, globRe);\n\n    // Resolve the project root through realpath ONCE so the sandbox check\n    // below compares like-for-like with realpath(file). The project root\n    // itself can be a symlink or short name \u2014 e.g. macOS temp dirs live under\n    // /var -> /private/var, and Windows CI runners expose an 8.3 short name\n    // (C:\\Users\\RUNNER~1\\...). Comparing realpath(file) against the raw root\n    // then makes every legitimately-inside file look \"outside\" and skips it.\n    const realRoot = await fs.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);\n\n    const results: ReplaceOutput['results'] = [];\n    let totalReplacements = 0;\n\n    for (const absPath of fileList) {\n      // Use lstat to detect symlinks. resolveFiles already applies\n      // safeResolve, but a symlink with a target outside the project\n      // root would still pass that string check \u2014 explicitly skip it\n      // so we never read or write through a link.\n      const lstat = await fs.lstat(absPath).catch((err) => {\n        if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;\n        /* v8 ignore next -- non-ENOENT lstat failure (EACCES etc.) is a defensive rethrow. */\n        throw err;\n      });\n      if (!lstat?.isFile()) continue;\n      if (lstat.isSymbolicLink()) continue;\n\n      // Cross-check via realpath: if the resolved target lives outside the\n      // project root (e.g. a bind mount or a parent-dir traversal we missed),\n      // skip rather than rewrite through it.\n      let realPath: string;\n      try {\n        realPath = await fs.realpath(absPath);\n      } catch {\n        /* v8 ignore next -- realpath failing after a successful lstat is a TOCTOU race; defensive. */\n        continue;\n      }\n      const rel = path.relative(realRoot, realPath);\n      if (rel.startsWith('..') || path.isAbsolute(rel)) continue;\n\n      // Now stat the real target so we use its mode for atomicWrite.\n      const stat = await fs.stat(realPath).catch(() => null);\n      if (!stat?.isFile()) continue;\n\n      let content: string;\n      try {\n        const buf = await fs.readFile(realPath);\n        if (isBinaryBuffer(buf)) continue;\n        content = buf.toString('utf8');\n      } catch {\n        /* v8 ignore next -- readFile failing after a successful stat is a TOCTOU race; defensive. */\n        continue;\n      }\n\n      const style = detectNewlineStyle(content);\n      const contentLf = normalizeToLf(content);\n      re.lastIndex = 0;\n      const allMatches = [...contentLf.matchAll(re)];\n      if (allMatches.length === 0) continue;\n\n      // When replace_all is false, only act on the first match.\n      const matches = replaceAll ? allMatches : allMatches.slice(0, 1);\n      const count = matches.length;\n\n      // Rebuild: splice the replacement into each match position from\n      // right to left so earlier indices stay valid.\n      let newContentLf = contentLf;\n      for (let i = matches.length - 1; i >= 0; i--) {\n        const m = expectDefined(matches[i]);\n        newContentLf =\n          newContentLf.slice(0, m.index) +\n          input.replacement +\n          newContentLf.slice(expectDefined(m.index) + m[0].length);\n      }\n      re.lastIndex = 0;\n      totalReplacements += count;\n\n      if (!dryRun) {\n        const newContent = toStyle(newContentLf, style);\n        // Write to the real path (already validated inside project root)\n        // so atomicWrite's temp-and-rename can't be redirected through a\n        // freshly-planted symlink at absPath.\n        await atomicWrite(realPath, newContent, { mode: stat.mode & 0o777 });\n        // Same bookkeeping as `edit`: record the new mtime + hash (tagged\n        // 'write' so the permission bypass does not widen) so a later `edit`\n        // of this file doesn't trip the stale-read guard on our own write,\n        // and record the change for session rewind. Optional calls: embedders\n        // may hand in a duck-typed Context without these members.\n        const written = await fs.stat(realPath).catch(() => null);\n        if (written) {\n          ctx.recordRead?.(realPath, written.mtimeMs, 'write', sha256hex(newContent));\n        }\n        ctx.session?.recordFileChange?.({\n          path: realPath,\n          action: 'modified',\n          before: content,\n          after: newContent,\n        });\n      }\n\n      const diff =\n        dryRun || matches.length > 0\n          ? unifiedDiff(content, toStyle(newContentLf, style), {\n              fromFile: absPath,\n              toFile: absPath,\n            })\n          : undefined;\n\n      results.push({\n        path: absPath,\n        replacements: matches.length,\n        diff,\n      });\n    }\n\n    return {\n      files_modified: results.length,\n      total_replacements: totalReplacements,\n      results,\n      dry_run: dryRun,\n    };\n  },\n};\n\nasync function resolveFiles(\n  filesInput: string,\n  ctx: Context,\n  extraGlob?: RegExp | null | undefined,\n): Promise<string[]> {\n  const base = ctx.cwd;\n  const normalized = filesInput.trim();\n\n  if (normalized.startsWith('**/') || normalized.startsWith('*') || normalized.includes('**')) {\n    return await globFiles(normalized, base, extraGlob);\n  }\n\n  const parts = normalized\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean);\n  const resolved: string[] = [];\n\n  for (const p of parts) {\n    const absPath = safeResolve(p, ctx);\n    const stat = await fs.stat(absPath).catch(() => null);\n    if (stat?.isFile()) {\n      resolved.push(absPath);\n    }\n  }\n\n  return resolved;\n}\n\nasync function globFiles(\n  pattern: string,\n  base: string,\n  extraGlob?: RegExp | null | undefined,\n): Promise<string[]> {\n\n  const rgAvailable = await checkRg();\n  if (rgAvailable) {\n    try {\n      const { promise } = spawnRgFind(pattern, base);\n      return await promise;\n    } catch {\n      // fall through\n    }\n  }\n\n  return await globNative(pattern, base, extraGlob);\n}\n\nfunction checkRg(): Promise<boolean> {\n  return new Promise((resolve) => {\n    try {\n      const p = spawn('rg', ['--version'], { env: buildChildEnv(), stdio: 'ignore', windowsHide: true });\n      p.on('error', () => resolve(false));\n      p.on('close', (code) => resolve(code === 0));\n    } catch {\n      resolve(false);\n    }\n  });\n}\n\nfunction spawnRgFind(pattern: string, base: string): { promise: Promise<string[]> } {\n  const args = ['--files', '--glob', pattern, base];\n  // 30-second safety net to prevent zombie rg processes. Unlike the main\n  // grep tool, glob file enumeration is fast and should never need more time.\n  const child = spawn('rg', args, {\n    signal: AbortSignal.timeout(30_000),\n    env: buildChildEnv(),\n    stdio: ['ignore', 'pipe', 'pipe'],\n    windowsHide: true,\n  });\n  let buf = '';\n  child.stdout?.on('data', (chunk: Buffer) => {\n    buf += chunk.toString();\n  });\n  return {\n    promise: new Promise((resolve, reject) => {\n      child.on('error', reject);\n      child.on('close', () => {\n        resolve(buf.split('\\n').filter(Boolean));\n      });\n    }),\n  };\n}\n\nasync function globNative(\n  pattern: string,\n  base: string,\n  extraGlob?: RegExp | null | undefined,\n): Promise<string[]> {\n  const results: string[] = [];\n  const globRe = compileGlob(pattern);\n\n  const walk = async (dir: string): Promise<void> => {\n    let entries: import('node:fs').Dirent[];\n    try {\n      entries = await fs.readdir(dir, { withFileTypes: true });\n    } catch {\n      /* v8 ignore next -- unreadable directory during the walk; defensive. */\n      return;\n    }\n    for (const e of entries) {\n      if (DEFAULT_IGNORE.includes(e.name)) continue;\n      const full = path.join(dir, e.name);\n      // Dirent.isSymbolicLink() uses readdir's d_type, which may not detect\n      // directory symlinks on Windows (d_type = DT_UNKNOWN). Defensive stat\n      // call: skip any entry whose lstat shows a symlink \u2014 file or directory.\n      try {\n        const stat = await fs.lstat(full);\n        if (stat.isSymbolicLink()) continue;\n      } catch {\n        // lstat fails for very unusual entries (e.g. broken symlinks to deleted\n        // files on NFS); skip safely rather than surfacing an error.\n        /* v8 ignore next -- lstat failing on a readdir entry is a rare NFS/race case; defensive. */\n        continue;\n      }\n      if (e.isDirectory()) {\n        await walk(full);\n      } else if (e.isFile()) {\n        const name = e.name;\n        if (globRe.test(name) || globRe.test(full)) {\n          if (extraGlob && !extraGlob.test(name) && !extraGlob.test(full)) continue;\n          results.push(full);\n        }\n        globRe.lastIndex = 0;\n        if (extraGlob) extraGlob.lastIndex = 0;\n      }\n    }\n  };\n\n  await walk(base);\n  return results;\n}\n", "/**\n * Compile a user-supplied regex with conservative bounds against ReDoS.\n *\n * Node's regex engine (V8) is backtracking-based and cannot interrupt a\n * synchronous match \u2014 a pattern like `(a+)+$` against a sufficiently long\n * line will pin a worker for seconds. The executor's outer `timeoutMs` only\n * fires between async boundaries, so a long regex eval inside a sync loop\n * is uninterruptible.\n *\n * We can't fully prevent ReDoS without an alternative engine (re2-wasm), but\n * we can sharply limit the blast radius:\n *\n *  1. Cap pattern length \u2014 practically all legitimate user patterns are\n *     under 256 characters. A 4 KB pattern is almost certainly malicious\n *     or a copy-paste accident.\n *  2. Reject patterns containing the most obvious super-linear structures.\n *     This is a coarse filter (false-positives are likely; we accept that\n *     for hostile-input contexts).\n *\n * Callers should additionally bound the *subject* length (e.g. by capping\n * line size before matching).\n */\n\nconst MAX_PATTERN_LEN = 256;\n\n// Heuristics for catastrophic-backtracking constructs. Not exhaustive; bias\n// toward false-positives in tools that accept LLM-generated input.\nconst DANGEROUS_PATTERNS: ReadonlyArray<RegExp> = [\n  // (a+)+, (.*)+, etc \u2014 nested quantifier on a group with internal quantifier\n  /(\\([^)]*[+*][^)]*\\))[+*]/,\n  /(\\(\\?:[^)]*[+*][^)]*\\))[+*]/,\n  // Adjacent quantifiers: a++ a*+\n  /[+*]{2,}/,\n  // Quantifier on alternation with length 2+\n  /\\([^|)]+\\|[^)]+\\)[+*][+*]/,\n  // Greedy quantifier inside lookahead/lookbehind \u2014 (?!.*a+)\n  /[([][^)\\]]*[+*][^)\\]]*[)\\]][^)]*\\?\\??/,\n];\n\nexport interface CompileResult {\n  ok: true;\n  regex: RegExp;\n}\n\nexport interface CompileFail {\n  ok: false;\n  reason: string;\n}\n\nexport function compileUserRegex(pattern: string, flags: string): CompileResult | CompileFail {\n  if (typeof pattern !== 'string') {\n    return { ok: false, reason: 'pattern must be a string' };\n  }\n  if (pattern.length === 0) {\n    return { ok: false, reason: 'pattern is empty' };\n  }\n  if (pattern.length > MAX_PATTERN_LEN) {\n    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };\n  }\n  for (const rx of DANGEROUS_PATTERNS) {\n    if (rx.test(pattern)) {\n      return {\n        ok: false,\n        reason:\n          'pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers',\n      };\n    }\n  }\n  try {\n    return { ok: true, regex: new RegExp(pattern, flags) };\n  } catch (err) {\n    return {\n      ok: false,\n      reason: err instanceof Error ? err.message : 'invalid regex',\n    };\n  }\n}\n\n/**\n * Truncate a subject line to a safe length for synchronous regex eval.\n * The cap is conservative; tools that need exact-line matching against very\n * long lines should use ripgrep externally rather than the native walker.\n */\nexport const MAX_SUBJECT_LEN = 64 * 1024;\n\nexport function capSubject(line: string): string {\n  return line.length > MAX_SUBJECT_LEN ? line.slice(0, MAX_SUBJECT_LEN) : line;\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core/utils';\nimport type { Context } from '@wrongstack/core/agent';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
+  "mappings": "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",
   "names": ["path", "lstat", "stat", "resolve"]
 }

package/dist/scaffold.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '@wrongstack/core';
+import type { Tool } from '@wrongstack/core/types';
 interface ScaffoldInput {
     template: string;
     name: string;

package/dist/scaffold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAI7C,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,UAAU,cAAc;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAwDD,eAAO,MAAM,YAAY,EAAE,IAAI,CAAC,aAAa,EAAE,cAAc,CA6D5D,CAAC"}
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAInD,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,UAAU,cAAc;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAwDD,eAAO,MAAM,YAAY,EAAE,IAAI,CAAC,aAAa,EAAE,cAAc,CA6D5D,CAAC"}

package/dist/scaffold.js

@@ -1,11 +1,11 @@
 // src/scaffold.ts
 import * as fs from "node:fs/promises";
 import * as path2 from "node:path";
-import { atomicWrite } from "@wrongstack/core";
+import { atomicWrite } from "@wrongstack/core/utils";
 
 // src/_util.ts
 import * as path from "node:path";
-import * as Core from "@wrongstack/core";
+import * as Core from "@wrongstack/core/utils";
 function resolvePath(input, ctx) {
   return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
 }

package/dist/scaffold.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/scaffold.ts", "../src/_util.ts"],
-  "sourcesContent": ["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport type { Tool } from '@wrongstack/core';\nimport { atomicWrite } from '@wrongstack/core';\nimport { safeResolve } from './_util.js';\n\ninterface ScaffoldInput {\n  template: string;\n  name: string;\n  cwd?: string | undefined;\n  vars?: Record<string, string>;\n  dry_run?: boolean | undefined;\n}\n\ninterface ScaffoldOutput {\n  template: string;\n  name: string;\n  files_created: number;\n  files: string[];\n  dry_run: boolean;\n  output: string;\n}\n\nconst BUILT_IN_TEMPLATES: Record<string, { description: string; files: Record<string, string> }> = {\n  'npm-package': {\n    description: 'Basic npm package with ESM',\n    files: {\n      'package.json': JSON.stringify(\n        {\n          name: '{{name}}',\n          version: '0.1.1',\n          type: 'module',\n          main: './dist/index.js',\n          scripts: { build: 'tsc', test: 'vitest run' },\n          devDependencies: { typescript: '^5.0.0' },\n        },\n        null,\n        2,\n      ),\n      'tsconfig.json': JSON.stringify(\n        {\n          compilerOptions: { target: 'ES2022', module: 'ESNext', strict: true },\n          include: ['src'],\n        },\n        null,\n        2,\n      ),\n      'src/index.ts': `export function hello() {\\n  return 'Hello from {{name}}';\\n}\\n`,\n      'src/index.test.ts': `import { hello } from './index';\\nimport { describe, it, expect } from 'vitest';\\n\\ndescribe('hello', () => {\\n  it('returns greeting', () => {\\n    expect(hello()).toBe('Hello from {{name}}');\\n  });\\n});\\n`,\n    },\n  },\n  'cli-tool': {\n    description: 'CLI tool with argparse',\n    files: {\n      'package.json': JSON.stringify(\n        {\n          name: '{{name}}',\n          version: '0.1.1',\n          type: 'module',\n          bin: { '{{name}}': './src/index.js' },\n          scripts: { build: 'tsc', start: 'node dist/index.js' },\n        },\n        null,\n        2,\n      ),\n      'src/index.ts': `#!/usr/bin/env node\\n\\nasync function main() {\\n  console.log('Hello from {{name}}');\\n}\\n\\nmain();\\n`,\n    },\n  },\n  'react-component': {\n    description: 'React component with TypeScript',\n    files: {\n      '{{name}}.tsx': `interface {{Name}}Props {\\n  className?: string;\\n}\\n\\nexport function {{Name}}({ className }: {{Name}}Props) {\\n  return (\\n    <div className={className}>\\n      {{Name}} Component\\n    </div>\\n  );\\n}\\n`,\n      '{{name}}.test.tsx': `import { render, screen } from '@testing-library/react';\\nimport { {{Name}} } from './{{Name}}';\\n\\ndescribe('{{Name}}', () => {\\n  it('renders', () => {\\n    render(<{{Name}} />);\\n    expect(screen.getByText('{{Name}} Component')).toBeInTheDocument();\\n  });\\n});\\n`,\n    },\n  },\n};\n\nexport const scaffoldTool: Tool<ScaffoldInput, ScaffoldOutput> = {\n  name: 'scaffold',\n  category: 'Project',\n  description:\n    'Generate new files and folder structures from built-in templates or custom definitions. ' +\n    'This is the recommended way to bootstrap new packages, components, or modules instead of creating files one by one with `write`.',\n  usageHint:\n    'PREFERRED FOR SCAFFOLDING:\\n\\n' +\n    '- Use built-in templates when they match your needs (e.g. react-component, npm-package).\\n' +\n    '- Supports `dry_run` so you can preview exactly what will be created.\\n' +\n    '- Has the powerful `fs.write.outside-project` capability \u2014 review paths carefully.\\n' +\n    'Much cleaner and safer than manually writing multiple files.',\n  permission: 'confirm',\n  mutating: true,\n  capabilities: ['fs.write.outside-project', 'fs.write'],\n  icon: 'scaffold',\n  timeoutMs: 30_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      template: {\n        type: 'string',\n        description:\n          'Template name (npm-package, cli-tool, react-component) or path to template directory',\n      },\n      name: {\n        type: 'string',\n        description: 'Project/component name (used in generated files)',\n      },\n      cwd: { type: 'string', description: 'Working directory (default: cwd)' },\n      vars: {\n        type: 'object',\n        additionalProperties: { type: 'string' },\n        description: 'Template variables for custom templates',\n      },\n      dry_run: {\n        type: 'boolean',\n        description: 'Preview generated files without creating (default: false)',\n      },\n    },\n    required: ['template', 'name'],\n  },\n  async execute(input, ctx) {\n    const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;\n    const name = input.name;\n    const vars = { name, ...input.vars };\n\n    const builtIn = BUILT_IN_TEMPLATES[input.template];\n    if (builtIn) {\n      return await handleBuiltIn(name, builtIn.files, cwd, ctx, input.dry_run ?? false, vars);\n    }\n\n    return {\n      template: input.template,\n      name,\n      files_created: 0,\n      files: [],\n      dry_run: input.dry_run ?? false,\n      output: `Template \"${input.template}\" not found. Available: ${Object.keys(BUILT_IN_TEMPLATES).join(', ')}`,\n    };\n  },\n};\n\nasync function handleBuiltIn(\n  name: string,\n  templateFiles: Record<string, string>,\n  cwd: string,\n  ctx: Parameters<Tool['execute']>[1],\n  dryRun: boolean,\n  vars: Record<string, string>,\n): Promise<ScaffoldOutput> {\n  const files: string[] = [];\n  let filesCreated = 0;\n\n  for (const [filePath, content] of Object.entries(templateFiles)) {\n    const resolvedPath = substituteVars(filePath, name, vars);\n    const joinedPath = path.join(cwd, resolvedPath);\n    // Ensure generated files cannot escape the project root via template variable injection (e.g. name containing \"../\")\n    const root = path.resolve(ctx.projectRoot);\n    const target = path.resolve(joinedPath);\n    const rel = path.relative(root, target);\n    if (rel.startsWith('..') || path.isAbsolute(rel)) {\n      throw new Error(`scaffold: generated path \"${resolvedPath}\" would escape project root`);\n    }\n    const fullPath = target;\n\n    if (!dryRun) {\n      await fs.mkdir(path.dirname(fullPath), { recursive: true });\n      // atomicWrite: scaffolded files land in the user's tracked tree.\n      // A torn write here would commit a corrupt file to their repo.\n      await atomicWrite(fullPath, substituteVars(content, name, vars));\n    }\n    files.push(resolvedPath);\n    filesCreated++;\n  }\n\n  return {\n    template: 'built-in',\n    name,\n    files_created: filesCreated,\n    files,\n    dry_run: dryRun,\n    output: dryRun\n      ? `Would create ${filesCreated} files: ${files.join(', ')}`\n      : `Created ${filesCreated} files: ${files.join(', ')}`,\n  };\n}\n\nfunction substituteVars(content: string, name: string, vars: Record<string, string>): string {\n  let result = content;\n  result = result.replace(/\\{\\{name\\}\\}/g, name.toLowerCase().replace(/\\s+/g, '-'));\n  result = result.replace(\n    /\\{\\{Name\\}\\}/g,\n    name.replace(/(?:^|[-_\\s]+)([a-z])/g, (_, c) => c.toUpperCase()),\n  );\n  for (const [k, v] of Object.entries(vars)) {\n    result = result.replace(new RegExp(`\\\\{\\\\{${k}\\\\}\\\\}`, 'g'), v);\n  }\n  return result;\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core';\nimport type { Context } from '@wrongstack/core';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
+  "sourcesContent": ["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport type { Tool } from '@wrongstack/core/types';\nimport { atomicWrite } from '@wrongstack/core/utils';\nimport { safeResolve } from './_util.js';\n\ninterface ScaffoldInput {\n  template: string;\n  name: string;\n  cwd?: string | undefined;\n  vars?: Record<string, string>;\n  dry_run?: boolean | undefined;\n}\n\ninterface ScaffoldOutput {\n  template: string;\n  name: string;\n  files_created: number;\n  files: string[];\n  dry_run: boolean;\n  output: string;\n}\n\nconst BUILT_IN_TEMPLATES: Record<string, { description: string; files: Record<string, string> }> = {\n  'npm-package': {\n    description: 'Basic npm package with ESM',\n    files: {\n      'package.json': JSON.stringify(\n        {\n          name: '{{name}}',\n          version: '0.1.1',\n          type: 'module',\n          main: './dist/index.js',\n          scripts: { build: 'tsc', test: 'vitest run' },\n          devDependencies: { typescript: '^5.0.0' },\n        },\n        null,\n        2,\n      ),\n      'tsconfig.json': JSON.stringify(\n        {\n          compilerOptions: { target: 'ES2022', module: 'ESNext', strict: true },\n          include: ['src'],\n        },\n        null,\n        2,\n      ),\n      'src/index.ts': `export function hello() {\\n  return 'Hello from {{name}}';\\n}\\n`,\n      'src/index.test.ts': `import { hello } from './index';\\nimport { describe, it, expect } from 'vitest';\\n\\ndescribe('hello', () => {\\n  it('returns greeting', () => {\\n    expect(hello()).toBe('Hello from {{name}}');\\n  });\\n});\\n`,\n    },\n  },\n  'cli-tool': {\n    description: 'CLI tool with argparse',\n    files: {\n      'package.json': JSON.stringify(\n        {\n          name: '{{name}}',\n          version: '0.1.1',\n          type: 'module',\n          bin: { '{{name}}': './src/index.js' },\n          scripts: { build: 'tsc', start: 'node dist/index.js' },\n        },\n        null,\n        2,\n      ),\n      'src/index.ts': `#!/usr/bin/env node\\n\\nasync function main() {\\n  console.log('Hello from {{name}}');\\n}\\n\\nmain();\\n`,\n    },\n  },\n  'react-component': {\n    description: 'React component with TypeScript',\n    files: {\n      '{{name}}.tsx': `interface {{Name}}Props {\\n  className?: string;\\n}\\n\\nexport function {{Name}}({ className }: {{Name}}Props) {\\n  return (\\n    <div className={className}>\\n      {{Name}} Component\\n    </div>\\n  );\\n}\\n`,\n      '{{name}}.test.tsx': `import { render, screen } from '@testing-library/react';\\nimport { {{Name}} } from './{{Name}}';\\n\\ndescribe('{{Name}}', () => {\\n  it('renders', () => {\\n    render(<{{Name}} />);\\n    expect(screen.getByText('{{Name}} Component')).toBeInTheDocument();\\n  });\\n});\\n`,\n    },\n  },\n};\n\nexport const scaffoldTool: Tool<ScaffoldInput, ScaffoldOutput> = {\n  name: 'scaffold',\n  category: 'Project',\n  description:\n    'Generate new files and folder structures from built-in templates or custom definitions. ' +\n    'This is the recommended way to bootstrap new packages, components, or modules instead of creating files one by one with `write`.',\n  usageHint:\n    'PREFERRED FOR SCAFFOLDING:\\n\\n' +\n    '- Use built-in templates when they match your needs (e.g. react-component, npm-package).\\n' +\n    '- Supports `dry_run` so you can preview exactly what will be created.\\n' +\n    '- Has the powerful `fs.write.outside-project` capability \u2014 review paths carefully.\\n' +\n    'Much cleaner and safer than manually writing multiple files.',\n  permission: 'confirm',\n  mutating: true,\n  capabilities: ['fs.write.outside-project', 'fs.write'],\n  icon: 'scaffold',\n  timeoutMs: 30_000,\n  inputSchema: {\n    type: 'object',\n    properties: {\n      template: {\n        type: 'string',\n        description:\n          'Template name (npm-package, cli-tool, react-component) or path to template directory',\n      },\n      name: {\n        type: 'string',\n        description: 'Project/component name (used in generated files)',\n      },\n      cwd: { type: 'string', description: 'Working directory (default: cwd)' },\n      vars: {\n        type: 'object',\n        additionalProperties: { type: 'string' },\n        description: 'Template variables for custom templates',\n      },\n      dry_run: {\n        type: 'boolean',\n        description: 'Preview generated files without creating (default: false)',\n      },\n    },\n    required: ['template', 'name'],\n  },\n  async execute(input, ctx) {\n    const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;\n    const name = input.name;\n    const vars = { name, ...input.vars };\n\n    const builtIn = BUILT_IN_TEMPLATES[input.template];\n    if (builtIn) {\n      return await handleBuiltIn(name, builtIn.files, cwd, ctx, input.dry_run ?? false, vars);\n    }\n\n    return {\n      template: input.template,\n      name,\n      files_created: 0,\n      files: [],\n      dry_run: input.dry_run ?? false,\n      output: `Template \"${input.template}\" not found. Available: ${Object.keys(BUILT_IN_TEMPLATES).join(', ')}`,\n    };\n  },\n};\n\nasync function handleBuiltIn(\n  name: string,\n  templateFiles: Record<string, string>,\n  cwd: string,\n  ctx: Parameters<Tool['execute']>[1],\n  dryRun: boolean,\n  vars: Record<string, string>,\n): Promise<ScaffoldOutput> {\n  const files: string[] = [];\n  let filesCreated = 0;\n\n  for (const [filePath, content] of Object.entries(templateFiles)) {\n    const resolvedPath = substituteVars(filePath, name, vars);\n    const joinedPath = path.join(cwd, resolvedPath);\n    // Ensure generated files cannot escape the project root via template variable injection (e.g. name containing \"../\")\n    const root = path.resolve(ctx.projectRoot);\n    const target = path.resolve(joinedPath);\n    const rel = path.relative(root, target);\n    if (rel.startsWith('..') || path.isAbsolute(rel)) {\n      throw new Error(`scaffold: generated path \"${resolvedPath}\" would escape project root`);\n    }\n    const fullPath = target;\n\n    if (!dryRun) {\n      await fs.mkdir(path.dirname(fullPath), { recursive: true });\n      // atomicWrite: scaffolded files land in the user's tracked tree.\n      // A torn write here would commit a corrupt file to their repo.\n      await atomicWrite(fullPath, substituteVars(content, name, vars));\n    }\n    files.push(resolvedPath);\n    filesCreated++;\n  }\n\n  return {\n    template: 'built-in',\n    name,\n    files_created: filesCreated,\n    files,\n    dry_run: dryRun,\n    output: dryRun\n      ? `Would create ${filesCreated} files: ${files.join(', ')}`\n      : `Created ${filesCreated} files: ${files.join(', ')}`,\n  };\n}\n\nfunction substituteVars(content: string, name: string, vars: Record<string, string>): string {\n  let result = content;\n  result = result.replace(/\\{\\{name\\}\\}/g, name.toLowerCase().replace(/\\s+/g, '-'));\n  result = result.replace(\n    /\\{\\{Name\\}\\}/g,\n    name.replace(/(?:^|[-_\\s]+)([a-z])/g, (_, c) => c.toUpperCase()),\n  );\n  for (const [k, v] of Object.entries(vars)) {\n    result = result.replace(new RegExp(`\\\\{\\\\{${k}\\\\}\\\\}`, 'g'), v);\n  }\n  return result;\n}\n", "import { createHash } from 'node:crypto';\nimport * as fsp from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as Core from '@wrongstack/core/utils';\nimport type { Context } from '@wrongstack/core/agent';\n\n/**\n * sha-256 hex of a UTF-8 string. Used by the file tools to record a content\n * hash alongside the mtime in `ctx.recordRead` \u2014 the hash is the authoritative\n * staleness arbiter for `edit` (mtime has a 2 s tolerance window on Windows).\n */\nexport function sha256hex(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex');\n}\n/** Detected package manager for a project directory. */\nexport type PackageManager = 'pnpm' | 'yarn' | 'npm';\n\n/**\n * Detect the project's package manager by inspecting lockfiles in `cwd`.\n * Order: pnpm \u2192 yarn \u2192 npm (default). Missing or unreadable directories fall\n * back to `npm` rather than throwing, so a `safeResolve`-checked cwd that\n * happens to be empty never aborts the tool.\n */\nexport async function detectPackageManager(cwd: string): Promise<PackageManager> {\n  const { stat } = await import('node:fs/promises');\n  try {\n    await stat(`${cwd}/pnpm-lock.yaml`);\n    return 'pnpm';\n  } catch {\n    /* not pnpm */\n  }\n  try {\n    await stat(`${cwd}/yarn.lock`);\n    return 'yarn';\n  } catch {\n    /* not yarn */\n  }\n  return 'npm';\n}\n\nexport function resolvePath(input: string, ctx: Context): string {\n  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);\n}\n\n/**\n * Roots every file tool may always reach, even in restricted mode: the\n * project root and the user-global `~/.wrongstack` directory (config, memory,\n * sessions, skills). `~/.wrongstack` honors the `WRONGSTACK_HOME` override.\n */\nfunction allowedRoots(ctx: Context): string[] {\n  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];\n}\n\n/** True if `target` is `root` itself or nested inside any of `roots`. */\nfunction isInsideAny(target: string, roots: string[]): boolean {\n  return roots.some((root) => {\n    const rel = path.relative(root, target);\n    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));\n  });\n}\n\nexport function ensureInsideRoot(absPath: string, ctx: Context): string {\n  const target = path.resolve(absPath);\n  // Unrestricted filesystem access: skip the project-root containment check.\n  if (ctx.allowOutsideProjectRoot) return target;\n  if (isInsideAny(target, allowedRoots(ctx))) return target;\n  throw new Error(`Path \"${absPath}\" is outside project root \"${path.resolve(ctx.projectRoot)}\"`);\n}\n\nexport function safeResolve(input: string, ctx: Context): string {\n  return ensureInsideRoot(resolvePath(input, ctx), ctx);\n}\n\n/**\n * Defense against in-root\u2192out-of-root symlink escape (CWE-59). `safeResolve`\n * only does a syntactic `../` check, so a symlink that lives *inside* the\n * project root but points outside still passes it. This resolves the path\n * through `fs.realpath` and re-verifies containment against the realpath of\n * the project root (comparing like-for-like, since the root itself may be a\n * symlink \u2014 macOS `/var`\u2192`/private/var`, Windows 8.3 short names). For a path\n * that does not exist yet (e.g. a `write` to a new file) the nearest existing\n * ancestor directory is checked instead. Throws if the real target escapes.\n *\n * Mirrors the per-file guard already used in `replace.ts`/`grep.ts`; applied\n * to single-file `read`/`edit`/`write` it throws (rather than skips) because\n * the caller named exactly one file.\n */\nexport async function assertRealInsideRoot(absPath: string, ctx: Context): Promise<void> {\n  // Unrestricted filesystem access: no symlink-escape check to perform.\n  if (ctx.allowOutsideProjectRoot) return;\n  // Compare like-for-like against the realpath of each always-allowed root\n  // (project root + ~/.wrongstack), since a root may itself be a symlink.\n  const realRoots = await Promise.all(\n    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r))),\n  );\n  let probe = absPath;\n  for (;;) {\n    let real: string;\n    try {\n      real = await fsp.realpath(probe);\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {\n        const parent = path.dirname(probe);\n        if (parent === probe) return; // reached fs root without escaping\n        probe = parent;\n        continue;\n      }\n      throw err;\n    }\n    if (isInsideAny(real, realRoots)) return;\n    throw new Error(\n      `Path \"${absPath}\" resolves through a symlink outside project root \"${realRoots[0]}\"`,\n    );\n  }\n}\n\n/** `safeResolve` + symlink realpath containment check. Async. */\nexport async function safeResolveReal(input: string, ctx: Context): Promise<string> {\n  const abs = safeResolve(input, ctx);\n  await assertRealInsideRoot(abs, ctx);\n  return abs;\n}\n\nexport function truncateMiddle(s: string, max: number): string {\n  if (Buffer.byteLength(s, 'utf8') <= max) return s;\n  const half = Math.floor(max / 2);\n  return (\n    s.slice(0, half) +\n    `\\n\u2026[truncated ${Buffer.byteLength(s, 'utf8') - max} bytes from middle]\u2026\\n` +\n    s.slice(-half)\n  );\n}\n\nexport function isBinaryBuffer(buf: Buffer): boolean {\n  const len = Math.min(buf.length, 8192);\n  for (let i = 0; i < len; i++) {\n    if (buf[i] === 0) return true;\n  }\n  return false;\n}\n\n// \u2500\u2500\u2500 Command-output normalization (token-saving) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Raw process output is full of tokens the model gains nothing from: ANSI\n// escapes, carriage-return progress spam, runs of identical warning lines, and\n// huge tails of build noise. These helpers strip that noise before the output\n// reaches the LLM. They are scoped to COMMAND tools (bash/git/exec and the\n// _spawn-stream consumers) \u2014 never applied to structured/code outputs.\n\n/** Unified byte cap for all command tool output fed to the model. */\nexport const COMMAND_OUTPUT_MAX_BYTES = 32_768;\n\n/** Runs of >= this many identical consecutive lines are collapsed. */\nconst REPEAT_RUN_THRESHOLD = 3;\n\n/**\n * Collapse carriage-return overwrites the way a terminal would: `\\r\\n` becomes\n * `\\n`, and a bare `\\r` (progress redraw) keeps only the text after the LAST\n * `\\r` on its physical line. Without this, a single progress bar that redraws\n * 200 times explodes into 200 lines.\n */\nexport function collapseCarriageReturns(text: string): string {\n  const lf = text.replace(/\\r\\n/g, '\\n');\n  if (!lf.includes('\\r')) return lf;\n  return lf\n    .split('\\n')\n    .map((line) => (line.includes('\\r') ? line.slice(line.lastIndexOf('\\r') + 1) : line))\n    .join('\\n');\n}\n\n/**\n * Collapse a run of `minRun`+ identical consecutive lines into the line once\n * plus a marker. Consecutive-only \u2014 it never reorders or dedups non-adjacent\n * lines, so diffs/source stay intact.\n */\nexport function collapseConsecutiveDuplicates(text: string, minRun = REPEAT_RUN_THRESHOLD): string {\n  const lines = text.split('\\n');\n  const out: string[] = [];\n  let i = 0;\n  while (i < lines.length) {\n    let j = i + 1;\n    while (j < lines.length && lines[j] === lines[i]) j++;\n    const run = j - i;\n    if (run >= minRun) {\n      out.push(lines[i]!, `\u2026 \u27E8repeated ${run}\u00D7\u27E9`);\n    } else {\n      for (let k = i; k < j; k++) out.push(lines[k]!);\n    }\n    i = j;\n  }\n  return out.join('\\n');\n}\n\n/** Largest prefix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeHeadBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(0, mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(0, lo);\n}\n\n/** Largest suffix of `s` whose UTF-8 byte length is <= `maxBytes`. */\nfunction takeTailBytes(s: string, maxBytes: number): string {\n  if (maxBytes <= 0) return '';\n  /* v8 ignore next -- only caller (truncateHeadTail) passes a budget smaller than s; defensive. */\n  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;\n  let lo = 0;\n  let hi = s.length;\n  while (lo < hi) {\n    const mid = Math.ceil((lo + hi) / 2);\n    if (Buffer.byteLength(s.slice(s.length - mid), 'utf8') <= maxBytes) lo = mid;\n    else hi = mid - 1;\n  }\n  return s.slice(s.length - lo);\n}\n\n/**\n * Truncate to `maxBytes` keeping BOTH ends \u2014 the head (what ran / early context)\n * and the tail (errors and summaries usually land last), biased ~45/55 toward\n * the tail. The result never exceeds `maxBytes`.\n */\nexport function truncateHeadTail(s: string, maxBytes: number): string {\n  const total = Buffer.byteLength(s, 'utf8');\n  if (total <= maxBytes) return s;\n  // Reserve a fixed allowance for the marker so the final string can't exceed\n  // the cap even though the dropped-byte count's digit width varies.\n  const MARKER_RESERVE = 64;\n  const avail = Math.max(0, maxBytes - MARKER_RESERVE);\n  const headBudget = Math.floor(avail * 0.45);\n  const head = takeHeadBytes(s, headBudget);\n  const tail = takeTailBytes(s, avail - Buffer.byteLength(head, 'utf8'));\n  const kept = Buffer.byteLength(head, 'utf8') + Buffer.byteLength(tail, 'utf8');\n  return `${head}\\n\u2026[truncated ${total - kept} bytes]\u2026\\n${tail}`;\n}\n\n/**\n * Full token-saving pipeline for command tool output: strip ANSI \u2192 collapse\n * carriage-return progress \u2192 trim trailing whitespace \u2192 collapse identical\n * consecutive lines \u2192 squeeze blank-line runs \u2192 head+tail truncate to the cap.\n */\nexport function normalizeCommandOutput(\n  raw: string,\n  opts: { maxBytes?: number | undefined } = {},\n): string {\n  if (!raw) return raw;\n  let text = Core.stripAnsi(raw);\n  text = collapseCarriageReturns(text);\n  text = text.replace(/[ \\t]+$/gm, ''); // trailing whitespace per line\n  text = collapseConsecutiveDuplicates(text);\n  text = text.replace(/\\n{3,}/g, '\\n\\n'); // >=2 blank lines \u2192 1\n  return truncateHeadTail(text, opts.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES);\n}\n"],
   "mappings": "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",
   "names": ["path"]
 }

package/dist/search.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '@wrongstack/core';
+import type { Tool } from '@wrongstack/core/types';
 interface SearchInput {
     query: string;
     num_results?: number | undefined;

package/dist/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAmB,MAAM,kBAAkB,CAAC;AAiB9D,UAAU,WAAW;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,MAAM,CAAC,EAAE,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;IACtD,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClC;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB;AAcD,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,YAAY,CA8JtD,CAAC;AAmBF,gFAAgF;AAChF,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAmB,MAAM,wBAAwB,CAAC;AAiBpE,UAAU,WAAW;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,MAAM,CAAC,EAAE,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;IACtD,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClC;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB;AAcD,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,YAAY,CA8JtD,CAAC;AAmBF,gFAAgF;AAChF,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/search.js

@@ -1,15 +1,15 @@
 // src/search.ts
-import { expectDefined, FetchError as FetchError2, ToolValidationError as ToolValidationError2 } from "@wrongstack/core";
+import { FetchError as FetchError2, ToolValidationError as ToolValidationError2 } from "@wrongstack/core/types";
+import { expectDefined } from "@wrongstack/core/utils";
 
 // src/_fetch-guard.ts
 import * as dns from "node:dns/promises";
 import * as net from "node:net";
 import {
-  FetchError,
-  ToolValidationError,
   isPrivateIPv4,
   isPrivateIPv6
-} from "@wrongstack/core";
+} from "@wrongstack/core/utils";
+import { FetchError, ToolValidationError } from "@wrongstack/core/types";
 import { Agent, fetch as undiciFetch } from "undici";
 var nativeGlobalFetch = globalThis.fetch;
 var ALLOW_PRIVATE = process.env["WRONGSTACK_FETCH_ALLOW_PRIVATE"] === "1";