mixdog 0.7.18 → 0.8.0

package/scripts/build-runtime-windows.ps1

@@ -1,242 +0,0 @@
-# build-runtime-windows.ps1 — Build PostgreSQL 16 + pgvector runtime on Windows.
-# Uses windows-2022 GHA runner's preinstalled PostgreSQL 16 (consistent
-# pg_config + postgres.exe from same package) — avoids EDB zip's split-version
-# packaging bug that linked pgvector against PG 14 ABI.
-# Builds pgvector from source via MSVC/nmake, then assembles a self-contained
-# runtime tree (bin + lib + share at root). Final smoke: initdb + CREATE
-# EXTENSION vector + distance query.
-# Produces: dist\mixdog-runtime-win32-x64-pg{pgver}-pgvector{vecver}.tar.gz
-
-$ErrorActionPreference = 'Stop'
-
-$PG_VERSION       = '16.4'
-$PGVECTOR_VERSION = '0.8.2'
-$TARGET_OS        = $env:TARGET_OS   ?? 'win32'
-$TARGET_ARCH      = $env:TARGET_ARCH ?? 'x64'
-
-# Auto-detect highest preinstalled PG ≥ 16 OR install via chocolatey.
-$PgInstallRoot = 'C:\Program Files\PostgreSQL'
-
-function Find-PgRoot {
-    if (-not (Test-Path $PgInstallRoot)) { return $null }
-    $cands = Get-ChildItem $PgInstallRoot -Directory -ErrorAction SilentlyContinue |
-        Where-Object { $_.Name -match '^(\d+)' } |
-        Sort-Object { [int]([regex]::Match($_.Name, '^(\d+)').Groups[1].Value) } -Descending
-    foreach ($c in $cands) {
-        $major = [int]([regex]::Match($c.Name, '^(\d+)').Groups[1].Value)
-        if ($major -ge 16 -and (Test-Path "$($c.FullName)\bin\pg_config.exe")) {
-            return $c.FullName
-        }
-    }
-    return $null
-}
-
-$PgRoot = Find-PgRoot
-if (-not $PgRoot) {
-    Write-Host "==> No preinstalled PG ≥ 16 found. Installing via chocolatey..."
-    if (Test-Path $PgInstallRoot) {
-        Write-Host "Existing PG dirs (none usable):"
-        Get-ChildItem $PgInstallRoot -Directory -ErrorAction SilentlyContinue | Select-Object Name
-    }
-    choco install postgresql16 --version=16.4.0 --params '/Password:postgres' -y --no-progress 2>&1 | Out-Host
-    if ($LASTEXITCODE -ne 0) { Write-Error "choco install postgresql16 failed (exit $LASTEXITCODE)"; exit 1 }
-    $PgRoot = Find-PgRoot
-    if (-not $PgRoot) {
-        Write-Error "ASSERT FAILED: chocolatey install completed but PG ≥ 16 still not found under $PgInstallRoot"
-        Get-ChildItem $PgInstallRoot -Directory -ErrorAction SilentlyContinue | Select-Object Name
-        exit 1
-    }
-}
-
-$ScriptDir  = Split-Path -Parent $MyInvocation.MyCommand.Path
-$RootDir    = (Resolve-Path "$ScriptDir\..").Path
-$BuildDir   = "$RootDir\build\runtime-win32-$TARGET_ARCH"
-$DistDir    = "$RootDir\dist"
-$RuntimeDir = "$BuildDir\runtime"
-
-$PgBin    = "$PgRoot\bin"
-$PgConfig = "$PgBin\pg_config.exe"
-
-$OutputName = "mixdog-runtime-${TARGET_OS}-${TARGET_ARCH}-pg${PG_VERSION}-pgvector${PGVECTOR_VERSION}.tar.gz"
-
-Write-Host "==> Using preinstalled PG: $PgRoot"
-& $PgConfig --version
-$RealVersion = (& $PgConfig --version) -replace 'PostgreSQL ', ''
-Write-Host "  pg_config reports version: $RealVersion"
-
-if (Test-Path $RuntimeDir) { Remove-Item -Recurse -Force $RuntimeDir }
-New-Item -ItemType Directory -Force -Path $BuildDir, $DistDir,
-  "$RuntimeDir\bin", "$RuntimeDir\lib", "$RuntimeDir\share" | Out-Null
-
-Write-Host "==> Cloning pgvector $PGVECTOR_VERSION"
-$PgVectorDir = "$BuildDir\pgvector"
-$VectorDllBuilt = "$PgVectorDir\vector.dll"
-
-if (Test-Path $VectorDllBuilt) {
-    Write-Host "  Cache hit: vector.dll already built at $VectorDllBuilt"
-} else {
-    if (Test-Path $PgVectorDir) { Remove-Item -Recurse -Force $PgVectorDir }
-    git clone --branch "v$PGVECTOR_VERSION" --depth 1 `
-        https://github.com/pgvector/pgvector.git $PgVectorDir
-
-    Write-Host "==> Building pgvector (MSVC/nmake against system PG 16)"
-    Push-Location $PgVectorDir
-    try {
-        $VsWhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
-        $VcVarsAll = & $VsWhere -latest -find 'VC\Auxiliary\Build\vcvarsall.bat' 2>$null | Select-Object -First 1
-        if (-not $VcVarsAll) {
-            Write-Error "vswhere could not locate vcvarsall.bat — Visual Studio Build Tools required."
-            exit 1
-        }
-        # CRITICAL: prepend $PgRoot\bin to PATH so any bare `pg_config` call
-        # inside Makefile.win resolves to PG 16 — runner has PG 14/15
-        # preinstalled and would otherwise win the PATH lookup, producing
-        # PG14-ABI vector.dll that fails to load in our PG 16 postgres.exe.
-        # Set in PowerShell so cmd /c inherits; setting inside the cmd batch
-        # via %PATH% loses vcvarsall's additions due to parse-time expansion.
-        $env:PATH = "$PgRoot\bin;$env:PATH"
-        $env:PGROOT = $PgRoot
-        $BuildCmd = "`"$VcVarsAll`" amd64 && nmake /F Makefile.win PG_CONFIG=`"$PgConfig`""
-        cmd /c $BuildCmd
-        if ($LASTEXITCODE -ne 0) {
-            Write-Error "pgvector nmake build failed (exit $LASTEXITCODE)"
-            exit 1
-        }
-    } finally {
-        Pop-Location
-    }
-}
-
-Write-Host "==> Assembling runtime layout — copy bin (.exe + .dll), lib, share from $PgRoot"
-# Copy ALL .exe + .dll from PG bin so postgres.exe + libpq.dll + libcrypto/libssl/
-# libintl/libiconv/icu*/libxml2/libxslt/libwinpthread/libecpg/libpgtypes etc. all
-# ship together. PG 16 install layout puts these all in bin\.
-Copy-Item "$PgBin\*.exe","$PgBin\*.dll" "$RuntimeDir\bin\" -Force
-
-# lib\: PG extension modules (incl. contrib like pgcrypto.dll). vector.dll
-# placed here below — PG looks for $libdir/<ext>.dll which resolves to lib\.
-Copy-Item -Recurse -Force "$PgRoot\lib\*"   "$RuntimeDir\lib\"   -ErrorAction SilentlyContinue
-# share\: extension SQL/control, locale, timezone data, conf samples.
-Copy-Item -Recurse -Force "$PgRoot\share\*" "$RuntimeDir\share\" -ErrorAction SilentlyContinue
-
-Write-Host "==> Manually staging pgvector artifacts (avoid pg_config-derived install paths)"
-$RuntimeExtDir = "$RuntimeDir\share\extension"
-New-Item -ItemType Directory -Force -Path $RuntimeExtDir | Out-Null
-Copy-Item "$PgVectorDir\vector.dll"        "$RuntimeDir\lib\"  -Force
-Copy-Item "$PgVectorDir\vector.control"    $RuntimeExtDir      -Force
-Copy-Item "$PgVectorDir\sql\vector--*.sql" $RuntimeExtDir      -Force
-
-Write-Host "==> Asserting runtime layout"
-$VectorControl = "$RuntimeDir\share\extension\vector.control"
-if (-not (Test-Path $VectorControl)) { Write-Error "ASSERT FAILED: $VectorControl not found"; exit 1 }
-$VectorSql = "$RuntimeDir\share\extension\vector--$PGVECTOR_VERSION.sql"
-if (-not (Test-Path $VectorSql))     { Write-Error "ASSERT FAILED: $VectorSql not found"; exit 1 }
-if (-not (Test-Path "$RuntimeDir\lib\vector.dll")) {
-    Write-Error "ASSERT FAILED: vector.dll not found in lib\"
-    exit 1
-}
-Write-Host "  PASS runtime layout"
-
-# Licenses
-if (Test-Path "$PgRoot\doc\postgresql\COPYRIGHT") {
-    Copy-Item "$PgRoot\doc\postgresql\COPYRIGHT" "$RuntimeDir\LICENSE.postgresql" -Force
-} elseif (Test-Path "$PgRoot\doc\COPYRIGHT") {
-    Copy-Item "$PgRoot\doc\COPYRIGHT" "$RuntimeDir\LICENSE.postgresql" -Force
-}
-if (Test-Path "$PgVectorDir\LICENSE") {
-    Copy-Item "$PgVectorDir\LICENSE" "$RuntimeDir\LICENSE.pgvector" -Force
-}
-
-Write-Host "==> Self-contained smoke test (initdb + CREATE EXTENSION vector + distance query)"
-& "$RuntimeDir\bin\postgres.exe" --version
-if ($LASTEXITCODE -ne 0) { Write-Error "FAIL: postgres.exe --version exit $LASTEXITCODE"; exit 1 }
-
-$SmokeData = "$BuildDir\smoke-pgdata"
-$SmokeLog  = "$BuildDir\smoke-pg.log"
-$SmokePort = 55899
-if (Test-Path $SmokeData) { Remove-Item -Recurse -Force $SmokeData }
-
-& "$RuntimeDir\bin\initdb.exe" -D $SmokeData --username=postgres --auth-local=trust --no-locale -E UTF8 | Out-Null
-if ($LASTEXITCODE -ne 0) { Write-Error "FAIL: initdb"; exit 1 }
-
-& "$RuntimeDir\bin\pg_ctl.exe" -D $SmokeData -o "-p $SmokePort -h 127.0.0.1" -l $SmokeLog -w start
-if ($LASTEXITCODE -ne 0) { Write-Error "FAIL: pg_ctl start (see $SmokeLog)"; Get-Content $SmokeLog | Select-Object -Last 30; exit 1 }
-
-try {
-    & "$RuntimeDir\bin\psql.exe" -h 127.0.0.1 -p $SmokePort -U postgres -d postgres -c "CREATE EXTENSION vector;" | Out-Null
-    if ($LASTEXITCODE -ne 0) { throw "CREATE EXTENSION vector failed" }
-    $ExtV = & "$RuntimeDir\bin\psql.exe" -h 127.0.0.1 -p $SmokePort -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';"
-    $Dist = & "$RuntimeDir\bin\psql.exe" -h 127.0.0.1 -p $SmokePort -U postgres -d postgres -tAc "SELECT '[1,2,3]'::vector <-> '[1,2,4]'::vector;"
-    Write-Host "  vector extension version: $ExtV"
-    Write-Host "  distance query result:    $Dist"
-    if ($ExtV.Trim() -ne $PGVECTOR_VERSION) {
-        Write-Error "FAIL: extversion='$ExtV' expected='$PGVECTOR_VERSION'"
-        exit 1
-    }
-    Write-Host "  PASS smoke (extension load + vector distance)"
-}
-finally {
-    & "$RuntimeDir\bin\pg_ctl.exe" -D $SmokeData -m fast stop 2>$null | Out-Null
-    Remove-Item -Recurse -Force $SmokeData -ErrorAction SilentlyContinue
-}
-
-Write-Host "==> Creating tarball: $OutputName"
-$DistDirFwd    = $DistDir.Replace('\', '/')
-$RuntimeDirFwd = $RuntimeDir.Replace('\', '/')
-& tar -czf "$DistDirFwd/$OutputName" -C "$RuntimeDirFwd" .
-if ($LASTEXITCODE -ne 0) { Write-Error "tar failed (exit $LASTEXITCODE)"; exit 1 }
-
-Write-Host "==> Generating sha256 sidecar"
-Push-Location $DistDir
-$Hash = (Get-FileHash -Algorithm SHA256 $OutputName).Hash.ToLower()
-"$Hash  $OutputName" | Out-File -Encoding ascii "${OutputName}.sha256"
-Pop-Location
-
-# ---------------------------------------------------------------------------
-# Phase A: Re-smoke from EXTRACTED tarball with hostile env (cleared PATH,
-# only system32). Catches false-pass where the build host has VC redist /
-# preinstalled DLLs that the tarball might be missing.
-# ---------------------------------------------------------------------------
-Write-Host "==> Re-smoke from extracted tarball (hostile env)"
-$ExtractDir = "$BuildDir\extract-smoke"
-if (Test-Path $ExtractDir) { Remove-Item -Recurse -Force $ExtractDir }
-New-Item -ItemType Directory -Force -Path $ExtractDir | Out-Null
-& tar -xzf "$DistDirFwd/$OutputName" -C ($ExtractDir.Replace('\','/'))
-if ($LASTEXITCODE -ne 0) { Write-Error "extract failed"; exit 1 }
-
-$ExtractData = "$ExtractDir\extract-pgdata"
-$ExtractLog  = "$ExtractDir\extract-pg.log"
-$ExtractPort = 55898
-
-# Snapshot current env, then strip to minimal Windows PATH (no PG14/15/16
-# preinstalled bin, no chocolatey, no MSVC tools).
-$SavedPath  = $env:PATH
-$SavedPgRoot = $env:PGROOT
-$env:PATH   = "$env:SystemRoot\System32;$env:SystemRoot"
-$env:PGROOT = $null
-$env:PGDATA = $null
-
-try {
-    & "$ExtractDir\bin\postgres.exe" --version
-    if ($LASTEXITCODE -ne 0) { throw "FAIL: postgres --version under hostile env" }
-    & "$ExtractDir\bin\initdb.exe" -D $ExtractData --username=postgres --auth-local=trust --no-locale -E UTF8 | Out-Null
-    if ($LASTEXITCODE -ne 0) { throw "FAIL: initdb under hostile env" }
-    & "$ExtractDir\bin\pg_ctl.exe" -D $ExtractData -o "-p $ExtractPort -h 127.0.0.1" -l $ExtractLog -w start
-    if ($LASTEXITCODE -ne 0) { Get-Content $ExtractLog | Select-Object -Last 30; throw "FAIL: pg_ctl start under hostile env" }
-    try {
-        & "$ExtractDir\bin\psql.exe" -h 127.0.0.1 -p $ExtractPort -U postgres -d postgres -c "CREATE EXTENSION vector;" | Out-Null
-        if ($LASTEXITCODE -ne 0) { throw "FAIL: CREATE EXTENSION vector under hostile env" }
-        $ExtV2 = & "$ExtractDir\bin\psql.exe" -h 127.0.0.1 -p $ExtractPort -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';"
-        if ($ExtV2.Trim() -ne $PGVECTOR_VERSION) { throw "FAIL: extracted-smoke extversion='$ExtV2'" }
-        Write-Host "  PASS extracted-tarball smoke (hostile env)"
-    } finally {
-        & "$ExtractDir\bin\pg_ctl.exe" -D $ExtractData -m fast stop 2>$null | Out-Null
-    }
-} finally {
-    $env:PATH   = $SavedPath
-    $env:PGROOT = $SavedPgRoot
-    Remove-Item -Recurse -Force $ExtractDir -ErrorAction SilentlyContinue
-}
-
-Write-Host "==> Done: $DistDir\$OutputName"
-Get-Item "$DistDir\$OutputName" | Select-Object Name, Length

package/scripts/builtin-utils-smoke.mjs

@@ -1,398 +0,0 @@
-// Smoke test: builtin.mjs public utility helpers (path normalize / shape
-// coercion / cache key builders). Edit-input normalization helpers are
-// covered separately in edit-normalize-smoke.mjs; this file targets the
-// rest of the cross-tool surface so a regression there doesn't slip
-// through CI just because edit invariants still pass.
-
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-
-const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
-process.env.CLAUDE_PLUGIN_ROOT ||= ROOT;
-process.env.CLAUDE_PLUGIN_DATA = join(tmpdir(), `mixdog-builtin-utils-smoke-data-${process.pid}`);
-process.env.MIXDOG_HINT_LEVEL ||= 'normal';
-
-const {
-    posixPathToWindowsPath,
-    normalizeInputPath,
-    normalizeOutputPath,
-    coerceShapeFlex,
-    canonicalizeBuiltinToolName,
-    executeBuiltinTool,
-    formatUnknownBuiltinToolMessage,
-    isBuiltinTool,
-} = await import('../src/agent/orchestrator/tools/builtin.mjs');
-const {
-    clearReadDedupSession,
-    clearScopedToolsForSessionPaths,
-    drainPrefetchDiskWrites,
-    invalidatePrefetchCache,
-    setPrefetchCached,
-    setScopedToolCached,
-    setReadCached,
-    tryPrefetchCached,
-    tryScopedToolCached,
-    tryReadCached,
-} = await import('../src/agent/orchestrator/session/read-dedup.mjs');
-const {
-    TOOL_RESULT_OFFLOAD_PREFIX,
-    _internals: offloadInternals,
-    compactOffloadedToolResultText,
-} = await import('../src/agent/orchestrator/session/tool-result-offload.mjs');
-const {
-    normalizeGrepLine,
-} = await import('../src/agent/orchestrator/tools/builtin/grep-formatting.mjs');
-const {
-    _pruneCodeGraphManifestForBudget,
-} = await import('../src/agent/orchestrator/tools/code-graph.mjs');
-
-let failures = 0;
-function fail(name, msg) { console.error(`FAIL ${name}: ${msg}`); failures++; }
-
-// ── coerceShapeFlex ────────────────────────────────────────────────────────
-// Transports occasionally JSON-stringify array parameters. Helper must:
-//   • parse `[a,b]` style strings to arrays,
-//   • unwrap `"quoted"` strings to their inner value,
-//   • leave plain strings, arrays, and primitives untouched.
-const coerceCases = [
-    { name: 'plain-string',         input: 'foo',           expected: 'foo' },
-    { name: 'json-array',           input: '["a","b"]',     expected: ['a', 'b'] },
-    { name: 'json-array-numbers',   input: '[1,2,3]',       expected: [1, 2, 3] },
-    { name: 'quoted-string',        input: '"hello"',       expected: 'hello' },
-    { name: 'actual-array',         input: ['a', 'b'],      expected: ['a', 'b'] },
-    { name: 'empty-string',         input: '',              expected: '' },
-    { name: 'malformed-json',       input: '[foo',          expected: '[foo' },
-    { name: 'undefined',            input: undefined,       expected: undefined },
-    { name: 'number',               input: 42,              expected: 42 },
-];
-
-const jsonEq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-for (const { name, input, expected } of coerceCases) {
-    const got = coerceShapeFlex(input);
-    if (!jsonEq(got, expected)) {
-        fail(`coerce:${name}`, `got ${JSON.stringify(got)}, expected ${JSON.stringify(expected)}`);
-    }
-}
-
-// ── builtin tool name recovery ─────────────────────────────────────────────
-if (canonicalizeBuiltinToolName('grop') !== 'grep') fail('tool-alias:grop', 'expected grop -> grep');
-if (canonicalizeBuiltinToolName('glbo') !== 'glob') fail('tool-alias:glbo', 'expected glbo -> glob');
-if (!isBuiltinTool('grop')) fail('tool-alias:is-builtin', 'expected grop to be treated as builtin alias');
-const unknownToolHint = formatUnknownBuiltinToolMessage('grepp', { pattern: 'needle', path: 'src' }, 'tool');
-if (!unknownToolHint.includes('Did you mean "grep"') || unknownToolHint.includes('next_call:')) {
-    fail('tool-alias:unknown-hint', `expected concise grep suggestion, got ${JSON.stringify(unknownToolHint)}`);
-}
-
-// ── normalizeInputPath / normalizeOutputPath ───────────────────────────────
-// Path normalization round-trips. On Windows, forward-slash and backslash
-// representations of the same path collapse to one form, and POSIX-style
-// `/c/Users/...` drive paths decode back to Windows drive form. On POSIX,
-// those spellings are ordinary strings and must stay byte-preserved.
-// Output normalization is the inverse — the user-facing form mixdog
-// always emits regardless of how it received the path.
-const pathCases = [
-    { name: 'windows-backslash',    input: 'C:\\Users\\foo\\bar', shouldHaveSlashes: true },
-    { name: 'windows-forwardslash', input: 'C:/Users/foo/bar',    shouldHaveSlashes: true },
-    { name: 'posix-style',          input: '/c/Users/foo/bar',    shouldHaveSlashes: true },
-    { name: 'relative-path',        input: 'src/foo.js',          shouldHaveSlashes: true },
-    { name: 'empty-string',         input: '',                    shouldHaveSlashes: false },
-];
-
-// Looser invariant: idempotent + string-typed. mixdog uses a mix of
-// forward and backward slashes internally; what matters is that the
-// second normalization pass produces the same output as the first.
-for (const { name, input } of pathCases) {
-    const a = normalizeInputPath(input);
-    if (typeof a !== 'string') { fail(`path-in:${name}`, `expected string, got ${typeof a}`); continue; }
-    const b = normalizeInputPath(a);
-    if (a !== b) fail(`path-in:${name}:idempotent`, `normalizeInputPath not idempotent: ${JSON.stringify(a)} -> ${JSON.stringify(b)}`);
-}
-
-const out1 = normalizeOutputPath('C:\\Users\\foo');
-if (typeof out1 !== 'string') fail('path-out:windows', `expected string, got ${typeof out1}`);
-const out2 = normalizeOutputPath('src/foo.js');
-if (typeof out2 !== 'string') fail('path-out:relative', `expected string, got ${typeof out2}`);
-
-// posixPathToWindowsPath is intentionally Windows-only. On POSIX hosts, `/c/...`
-// is a legal absolute path, not a Windows drive alias, so assert identity there.
-const winFromPosix = posixPathToWindowsPath('/c/Users/foo');
-if (typeof winFromPosix !== 'string') {
-    fail('posix-to-win:basic', `expected string, got ${typeof winFromPosix}`);
-} else if (process.platform === 'win32') {
-    // Accept either case for the drive letter (POSIX `/c/` doesn't carry case).
-    if (!/^[a-zA-Z]:/.test(winFromPosix)) {
-        fail('posix-to-win:basic', `expected drive-letter prefix, got ${JSON.stringify(winFromPosix)}`);
-    }
-} else if (winFromPosix !== '/c/Users/foo') {
-    fail('posix-to-win:basic', `expected POSIX identity, got ${JSON.stringify(winFromPosix)}`);
-}
-
-// ── read cache key shape ───────────────────────────────────────────────────
-// Object-array reads include line/context/full and file_path aliases in their
-// key. Otherwise read({path:[{path, line:10}]}) could be reused for line:20.
-const cacheWork = join(tmpdir(), `mixdog-builtin-cache-smoke-${process.pid}-${Date.now()}`);
-mkdirSync(cacheWork, { recursive: true });
-try {
-    writeFileSync(join(cacheWork, 'cache-key.txt'), 'line-1\nline-2\nline-3\n');
-    const sessionId = `builtin-utils-${process.pid}`;
-    clearReadDedupSession(sessionId);
-    setReadCached({
-        sessionId,
-        cwd: cacheWork,
-        args: { path: [{ file_path: 'cache-key.txt', line: 1, context: 0 }] },
-        content: 'line one',
-        toolUseId: 'tool-1',
-    });
-    const hit = tryReadCached({
-        sessionId,
-        cwd: cacheWork,
-        args: { path: [{ path: 'cache-key.txt', line: 1, context: 0 }] },
-    });
-    if (!hit || hit.content !== 'line one') fail('read-cache:file_path-alias', `expected cache hit, got ${JSON.stringify(hit)}`);
-    setReadCached({
-        sessionId,
-        cwd: cacheWork,
-        args: { path: [{ path: 'cache-key.txt', line: 1, context: 0 }] },
-        content: 'line one again',
-        toolUseId: 'tool-2',
-    });
-    const miss = tryReadCached({
-        sessionId,
-        cwd: cacheWork,
-        args: { path: [{ path: 'cache-key.txt', line: 2, context: 0 }] },
-    });
-    if (miss !== null) fail('read-cache:line-partition', `line:2 should not hit line:1 cache, got ${JSON.stringify(miss)}`);
-    setReadCached({
-        sessionId,
-        cwd: cacheWork,
-        args: { path: 'cache-key.txt', line: 1, context: 0 },
-        content: 'scalar line one',
-        toolUseId: 'tool-3',
-    });
-    const scalarMiss = tryReadCached({
-        sessionId,
-        cwd: cacheWork,
-        args: { path: 'cache-key.txt', line: 2, context: 0 },
-    });
-    if (scalarMiss !== null) fail('read-cache:scalar-line-partition', `scalar line:2 should not hit line:1 cache, got ${JSON.stringify(scalarMiss)}`);
-    clearReadDedupSession(sessionId);
-} finally {
-    rmSync(cacheWork, { recursive: true, force: true });
-}
-
-// Full-file snapshots must not collapse later line-window reads.
-const readWindowWork = join(tmpdir(), `mixdog-read-window-smoke-${process.pid}-${Date.now()}`);
-mkdirSync(readWindowWork, { recursive: true });
-try {
-    writeFileSync(join(readWindowWork, 'window.txt'), Array.from({ length: 20 }, (_, i) => `line-${i + 1}`).join('\n') + '\n');
-    const sessionId = `builtin-read-window-${process.pid}`;
-    clearReadDedupSession(sessionId);
-    await executeBuiltinTool('read', { path: 'window.txt' }, readWindowWork, { readStateScope: sessionId, sessionId });
-    const reread = await executeBuiltinTool('read', { path: 'window.txt', line: 10, context: 1 }, readWindowWork, { readStateScope: sessionId, sessionId });
-    // Separator-agnostic: the read formatter renders `N<sep>content` (currently
-    // `→`). Assert the actual intent — a FRESH line-10±1 window (lines 9-11 of 20)
-    // that the prior full-file read did not collapse — not a hardcoded glyph.
-    if (!String(reread).includes('line-10') || !String(reread).includes('lines 9-11 of 20')) {
-        fail('read-window-after-full', `expected fresh window after full read, got ${JSON.stringify(reread)}`);
-    }
-    clearReadDedupSession(sessionId);
-} finally {
-    rmSync(readWindowWork, { recursive: true, force: true });
-}
-
-// ── grep context byte-exactness ───────────────────────────────────────────
-// Windows rg omits the path for a single-file search, so context lines arrive
-// as `N-content`. The formatter must not treat a later colon inside CONTENT as
-// a path delimiter and normalize source backslashes (`\n` -> `/n`).
-const grepContextWork = join(tmpdir(), `mixdog-grep-context-smoke-${process.pid}-${Date.now()}`);
-mkdirSync(grepContextWork, { recursive: true });
-try {
-    const fixture = join(grepContextWork, 'context.txt');
-    writeFileSync(fixture, 'context literal \\n \\r \\t ? a : b\nneedle\ntrailing\n');
-    const numericDir = join(grepContextWork, '12-x');
-    mkdirSync(numericDir, { recursive: true });
-    const numericFixture = join(numericDir, 'path.txt');
-    writeFileSync(numericFixture, 'numeric path literal \\n \\t ? a : b\nnumeric-needle\ntrailing\n');
-    const grepOutputs = [
-        ['single-file', await executeBuiltinTool(
-            'grep',
-            { pattern: 'needle', path: fixture, output_mode: 'content', '-C': 1 },
-            grepContextWork,
-            { sessionId: `grep-context-file-${process.pid}` },
-        )],
-        ['absolute-dir', await executeBuiltinTool(
-            'grep',
-            { pattern: 'needle', path: grepContextWork, output_mode: 'content', '-C': 1 },
-            grepContextWork,
-            { sessionId: `grep-context-dir-${process.pid}` },
-        )],
-    ];
-    for (const [caseName, rawOut] of grepOutputs) {
-        const out = String(rawOut);
-        if (!out.includes('context literal \\n \\r \\t ? a : b')) {
-            fail(`grep-context:${caseName}:literal-backslashes`, `expected literal backslash escapes in context, got ${JSON.stringify(out)}`);
-        }
-        if (out.includes('context literal /n /r /t ? a : b')) {
-            fail(`grep-context:${caseName}:no-slash-corruption`, `context backslashes were corrupted, got ${JSON.stringify(out)}`);
-        }
-    }
-    const numericOut = String(await executeBuiltinTool(
-        'grep',
-        { pattern: 'numeric-needle', path: '.', output_mode: 'content', '-C': 1 },
-        grepContextWork,
-        { sessionId: `grep-context-numeric-dir-${process.pid}` },
-    ));
-    if (!numericOut.includes('12-x/path.txt-1-numeric path literal \\n \\t ? a : b')) {
-        fail('grep-context:numeric-leading-path-normalized', `expected digit-hyphen-leading path prefix normalized and content preserved, got ${JSON.stringify(numericOut)}`);
-    }
-    if (numericOut.includes('numeric path literal /n /t ? a : b')) {
-        fail('grep-context:numeric-leading-content-exact', `numeric-leading path context backslashes were corrupted, got ${JSON.stringify(numericOut)}`);
-    }
-} finally {
-    rmSync(grepContextWork, { recursive: true, force: true });
-}
-
-if (process.platform === 'win32') {
-    const filenameOmittedContext = String.raw`1-context literal \n \t -5- ? a : b`;
-    const normalizedFilenameOmitted = normalizeGrepLine(filenameOmittedContext, false, 'content', true);
-    if (normalizedFilenameOmitted !== filenameOmittedContext) {
-        fail('grep-context:filename-omitted-exact', `expected byte-exact filename-omitted context, got ${JSON.stringify(normalizedFilenameOmitted)}`);
-    }
-    const filenamePresentContext = String.raw`12-x\path.txt-5-context literal \n \t ? a : b`;
-    const expectedFilenamePresent = String.raw`12-x/path.txt-5-context literal \n \t ? a : b`;
-    const normalizedFilenamePresent = normalizeGrepLine(filenamePresentContext);
-    if (normalizedFilenamePresent !== expectedFilenamePresent) {
-        fail('grep-context:filename-present-exact', `expected exact filename-present context prefix normalization, got ${JSON.stringify(normalizedFilenamePresent)}`);
-    }
-}
-
-// ── code graph disk cache budget pruning ──────────────────────────────────
-// The code-graph cache is per-cwd, so entry count alone is not enough:
-// a handful of large workspaces can exceed the doctor storage warning.
-// Budget pruning must keep the newest entries that fit the byte cap and
-// drop stale or missing manifest rows.
-const codeGraphCacheWork = join(tmpdir(), `mixdog-code-graph-cache-smoke-${process.pid}-${Date.now()}`);
-mkdirSync(codeGraphCacheWork, { recursive: true });
-try {
-    writeFileSync(join(codeGraphCacheWork, 'aaaaaaaaaaaaaaaa.json'), 'a'.repeat(40));
-    writeFileSync(join(codeGraphCacheWork, 'bbbbbbbbbbbbbbbb.json'), 'b'.repeat(40));
-    writeFileSync(join(codeGraphCacheWork, 'cccccccccccccccc.json'), 'c'.repeat(40));
-    const pruned = _pruneCodeGraphManifestForBudget({
-        old: { hash: 'aaaaaaaaaaaaaaaa', builtAt: 1 },
-        mid: { hash: 'bbbbbbbbbbbbbbbb', builtAt: 2 },
-        newest: { hash: 'cccccccccccccccc', builtAt: 3 },
-        missing: { hash: 'dddddddddddddddd', builtAt: 4 },
-        unsafe: { hash: '../escape', builtAt: 5 },
-    }, codeGraphCacheWork, { maxEntries: 2, maxBytes: 70 });
-    const keptKeys = Object.keys(pruned.manifest).sort();
-    if (!jsonEq(keptKeys, ['newest'])) {
-        fail('code-graph-cache:budget-prune', `expected newest only, got ${JSON.stringify(pruned)}`);
-    }
-    const reasons = new Set((pruned.evicted || []).map((row) => row.reason));
-    if (!reasons.has('max-entries') || !reasons.has('max-bytes')) {
-        fail('code-graph-cache:prune-reasons', `expected entry and byte prune reasons, got ${JSON.stringify(pruned.evicted)}`);
-    }
-} finally {
-    rmSync(codeGraphCacheWork, { recursive: true, force: true });
-}
-
-// ── scoped cache invalidation ──────────────────────────────────────────────
-// grep/list/glob cache entries are path-root scoped. Editing src/a.txt must
-// evict a prior grep({path:"src"}) result even though the exact touched path
-// differs from the cached root.
-const scopedWork = join(tmpdir(), `mixdog-scoped-cache-smoke-${process.pid}-${Date.now()}`);
-mkdirSync(join(scopedWork, 'src'), { recursive: true });
-try {
-    writeFileSync(join(scopedWork, 'src', 'a.txt'), 'needle\n');
-    const sessionId = `scoped-utils-${process.pid}`;
-    clearReadDedupSession(sessionId);
-    setScopedToolCached({
-        sessionId,
-        toolName: 'grep',
-        cwd: scopedWork,
-        args: { query: 'needle', root: 'src', mode: 'content' },
-        content: 'src/a.txt:1:needle',
-        toolUseId: 'grep-1',
-    });
-    const aliasHit = tryScopedToolCached({
-        sessionId,
-        toolName: 'grep',
-        cwd: scopedWork,
-        args: { pattern: 'needle', path: 'src', output_mode: 'content' },
-    });
-    if (!aliasHit || aliasHit.content !== 'src/a.txt:1:needle') fail('scoped-cache:alias-hit', `expected canonical alias hit, got ${JSON.stringify(aliasHit)}`);
-    setScopedToolCached({
-        sessionId,
-        toolName: 'grep',
-        cwd: scopedWork,
-        args: { pattern: 'needle', path: 'src', output_mode: 'content' },
-        content: 'src/a.txt:1:needle',
-        toolUseId: 'grep-2',
-    });
-    clearScopedToolsForSessionPaths(sessionId, ['src/a.txt'], scopedWork);
-    const stale = tryScopedToolCached({
-        sessionId,
-        toolName: 'grep',
-        cwd: scopedWork,
-        args: { pattern: 'needle', path: 'src', output_mode: 'content' },
-    });
-    if (stale !== null) fail('scoped-cache:root-invalidation', `edit under cached root should evict, got ${JSON.stringify(stale)}`);
-    clearReadDedupSession(sessionId);
-} finally {
-    rmSync(scopedWork, { recursive: true, force: true });
-}
-
-// ── prefetch cache invalidation ────────────────────────────────────────────
-const prefetchWork = join(tmpdir(), `mixdog-prefetch-cache-smoke-${process.pid}-${Date.now()}`);
-mkdirSync(prefetchWork, { recursive: true });
-try {
-    const filePath = join(prefetchWork, 'prefetch.txt');
-    writeFileSync(filePath, 'prefetch source\n');
-    invalidatePrefetchCache(filePath, prefetchWork);
-    setPrefetchCached(filePath, 'cached prefetch body');
-    const hit = tryPrefetchCached(filePath);
-    if (!hit || hit.content !== 'cached prefetch body') fail('prefetch-cache:hit', `expected prefetch cache hit, got ${JSON.stringify(hit)}`);
-    writeFileSync(filePath, 'prefetch source changed and longer\n');
-    const stale = tryPrefetchCached(filePath);
-    if (stale !== null) fail('prefetch-cache:stat-invalidate', `expected stale miss, got ${JSON.stringify(stale)}`);
-    drainPrefetchDiskWrites();
-    invalidatePrefetchCache(filePath, prefetchWork);
-} finally {
-    rmSync(prefetchWork, { recursive: true, force: true });
-}
-
-// ── offload helpers ────────────────────────────────────────────────────────
-// countLines must preserve the old split('\n') semantics without allocating
-// an array for very large tool outputs.
-if (offloadInternals.countLines('') !== 0) fail('offload:empty-lines', `expected 0, got ${offloadInternals.countLines('')}`);
-if (offloadInternals.countLines('one') !== 1) fail('offload:single-line', `expected 1, got ${offloadInternals.countLines('one')}`);
-if (offloadInternals.countLines('one\ntwo\n') !== 3) fail('offload:trailing-newline', `expected 3, got ${offloadInternals.countLines('one\ntwo\n')}`);
-const compactedOffload = compactOffloadedToolResultText(`${TOOL_RESULT_OFFLOAD_PREFIX} grep -> /tmp/r1.txt (1 KB, 2 lines)]\nline-1\nline-2`);
-if (!compactedOffload.includes('[preview omitted')) fail('offload:compact-stub', `expected compact preview marker, got ${JSON.stringify(compactedOffload)}`);
-
-// Note: cache key + rg argv builders are internal helpers with implicit
-// option-bag schemas that drift faster than this smoke can keep up with.
-// They are exercised end-to-end by the live grep / glob / list tools, so
-// invariant drift would surface there rather than as a silent miss.
-
-const totalChecks = coerceCases.length + pathCases.length + 2 /* output paths */
-    + 1 /* posix-to-win */
-    + 4 /* builtin tool name recovery */
-    + 3 /* read-cache key shape */
-    + 8 /* grep context byte-exactness */
-    + 2 /* scoped-cache root invalidation */
-    + 2 /* prefetch cache invalidation */
-    + 4 /* offload helpers */;
-
-if (failures > 0) {
-    console.error(`\n${failures} smoke check(s) failed.`);
-    process.exit(1);
-}
-console.log(`builtin-utils-smoke: ${totalChecks} checks passed.`);
-// Explicit success exit: imported builtin/read-dedup/offload modules keep a
-// background flush timer alive, so without this the process never exits and
-// the ci:core `&&` chain stalls after this step. Mirrors the failure path
-// and the sibling smokes (guard-smoke / edit-normalize) which exit explicitly.
-process.exit(0);