mixdog 0.9.14 → 0.9.16

package/scripts/recall-usecase-cases.json

@@ -15,4 +15,4 @@
   { "id": "uc5-yesterday", "label": "UC5 calendar yesterday", "args": { "period": "yesterday", "limit": 10 }, "expect": "browse" },
   { "id": "uc5-thisweek", "label": "UC5 calendar this_week", "args": { "period": "this_week", "limit": 10 }, "expect": "browse" },
   { "id": "uc6-category", "label": "UC6 category decision 7d", "args": { "period": "7d", "category": "decision", "limit": 10 }, "expect": "browse" }
-]
+]

package/scripts/smoke-runtime-negative.ps1

@@ -1,106 +1,106 @@
-# smoke-runtime-negative.ps1 — Negative-path tests against released win32-x64
-# runtime tarball. Validates: download, sha256, corrupt-tarball, fresh-extract
-# boot, double-init refusal, hostile-env survival.
-#
-# Env: TAG / OS / ARCH / RUNTIME_RELEASE_REPOSITORY (default tribgames/mixdog)
-
-$ErrorActionPreference = 'Stop'
-
-$Tag         = if ($env:TAG)                { $env:TAG }  else { 'runtime-v0.4.0' }
-$Os          = if ($env:OS)                 { $env:OS }   else { 'win32' }
-$Arch        = if ($env:ARCH)               { $env:ARCH } else { 'x64' }
-$ReleaseRepo = if ($env:RUNTIME_RELEASE_REPOSITORY) { $env:RUNTIME_RELEASE_REPOSITORY } else { 'tribgames/mixdog' }
-$PgVer       = '16.4'
-$PgvectorVer = '0.8.2'
-
-$Asset = "mixdog-runtime-${Os}-${Arch}-pg${PgVer}-pgvector${PgvectorVer}.tar.gz"
-$Url   = "https://github.com/${ReleaseRepo}/releases/download/${Tag}/${Asset}"
-
-$Work = New-Item -ItemType Directory -Force -Path "$env:TEMP\smoke-$([guid]::NewGuid().ToString('N'))" | Select-Object -ExpandProperty FullName
-
-try {
-    Write-Host "==> Negative-path smoke for ${Os}-${Arch} from $Url"
-
-    Write-Host "==> Test 1: HEAD reaches release asset"
-    $resp = Invoke-WebRequest -Uri $Url -Method Head -UseBasicParsing -ErrorAction Stop
-    Write-Host "  HTTP $($resp.StatusCode)"
-
-    Write-Host "==> Test 2: full download + sha256"
-    $TarPath = Join-Path $Work $Asset
-    Invoke-WebRequest -Uri $Url -OutFile $TarPath -UseBasicParsing
-    $sha = (Get-FileHash -Algorithm SHA256 $TarPath).Hash.ToLower()
-    Write-Host "  sha256=$sha"
-
-    Write-Host "==> Test 3: corrupt tarball — flip a byte and ensure tar errors"
-    $CorruptPath = "$Work\corrupt.tar.gz"
-    Copy-Item $TarPath $CorruptPath
-    $bytes = [byte[]]::new(1); $rand = [System.Random]::new(); $rand.NextBytes($bytes)
-    $stream = [System.IO.File]::OpenWrite($CorruptPath)
-    $stream.Position = 102400
-    $stream.Write($bytes, 0, 1)
-    $stream.Close()
-    $CorruptDir = "$Work\corrupt"
-    New-Item -ItemType Directory -Force -Path $CorruptDir | Out-Null
-    $TarProc = Start-Process -FilePath tar -ArgumentList @('-xzf', $CorruptPath, '-C', $CorruptDir.Replace('\','/')) -Wait:$false -PassThru -WindowStyle Hidden
-    if (-not $TarProc.WaitForExit(15000)) {
-        Stop-Process -Id $TarProc.Id -Force -ErrorAction SilentlyContinue
-        Write-Host "  PASS: corrupted tarball extraction timed out and was stopped"
-    } elseif ($TarProc.ExitCode -eq 0) {
-        Write-Host "  WARN: corrupted tarball extracted without error (tar gzip recovery)"
-    } else {
-        Write-Host "  PASS: corrupted tarball rejected by tar (exit $($TarProc.ExitCode))"
-    }
-
-    Write-Host "==> Test 4: fresh-extract boot (extension load + distance query)"
-    $FreshDir = "$Work\fresh"
-    New-Item -ItemType Directory -Force -Path $FreshDir | Out-Null
-    & tar -xzf $TarPath -C ($FreshDir.Replace('\','/'))
-    if ($LASTEXITCODE -ne 0) { throw "fresh extract failed" }
-
-    $PgBin   = "$FreshDir\bin"
-    $Data    = "$FreshDir\pgdata"
-    $Log     = "$FreshDir\pg.log"
-    $Port    = 55897
-
-    # Hostile env: minimal PATH (System32 only), no PGROOT/PGDATA
-    $SavedPath = $env:PATH
-    $SavedPgRoot = $env:PGROOT
-    $env:PATH   = "$env:SystemRoot\System32;$env:SystemRoot"
-    $env:PGROOT = $null
-    $env:PGDATA = $null
-
-    try {
-        & "$PgBin\postgres.exe" --version
-        if ($LASTEXITCODE -ne 0) { throw "FAIL: postgres --version" }
-        & "$PgBin\initdb.exe" -D $Data --username=postgres --auth-local=trust --no-locale -E UTF8 | Out-Null
-        if ($LASTEXITCODE -ne 0) { throw "FAIL: initdb" }
-        & "$PgBin\pg_ctl.exe" -D $Data -o "-p $Port -h 127.0.0.1" -l $Log -w start
-        if ($LASTEXITCODE -ne 0) { Get-Content $Log | Select-Object -Last 30; throw "FAIL: pg_ctl start" }
-
-        try {
-            & "$PgBin\psql.exe" -h 127.0.0.1 -p $Port -U postgres -d postgres -c "CREATE EXTENSION vector;" | Out-Null
-            if ($LASTEXITCODE -ne 0) { throw "FAIL: CREATE EXTENSION" }
-            $ExtV = & "$PgBin\psql.exe" -h 127.0.0.1 -p $Port -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';"
-            if ($ExtV.Trim() -ne $PgvectorVer) { throw "FAIL: extversion='$ExtV' expected='$PgvectorVer'" }
-            Write-Host "  PASS: fresh-extract boot + vector extension"
-        } finally {
-            & "$PgBin\pg_ctl.exe" -D $Data -m fast stop 2>$null | Out-Null
-        }
-
-        Write-Host "==> Test 5: second initdb on initialized dir refused"
-        $rc = (Start-Process -FilePath "$PgBin\initdb.exe" -ArgumentList "-D",$Data,"-U","postgres" -Wait -PassThru -NoNewWindow).ExitCode
-        if ($rc -eq 0) {
-            Write-Host "  WARN: second initdb succeeded (unexpected)"
-        } else {
-            Write-Host "  PASS: second initdb refused (exit $rc)"
-        }
-    } finally {
-        $env:PATH   = $SavedPath
-        $env:PGROOT = $SavedPgRoot
-    }
-
-    Write-Host "==> All negative-path smokes: PASS"
-}
-finally {
-    Remove-Item -Recurse -Force $Work -ErrorAction SilentlyContinue
-}
+# smoke-runtime-negative.ps1 — Negative-path tests against released win32-x64
+# runtime tarball. Validates: download, sha256, corrupt-tarball, fresh-extract
+# boot, double-init refusal, hostile-env survival.
+#
+# Env: TAG / OS / ARCH / RUNTIME_RELEASE_REPOSITORY (default tribgames/mixdog)
+
+$ErrorActionPreference = 'Stop'
+
+$Tag         = if ($env:TAG)                { $env:TAG }  else { 'runtime-v0.4.0' }
+$Os          = if ($env:OS)                 { $env:OS }   else { 'win32' }
+$Arch        = if ($env:ARCH)               { $env:ARCH } else { 'x64' }
+$ReleaseRepo = if ($env:RUNTIME_RELEASE_REPOSITORY) { $env:RUNTIME_RELEASE_REPOSITORY } else { 'tribgames/mixdog' }
+$PgVer       = '16.4'
+$PgvectorVer = '0.8.2'
+
+$Asset = "mixdog-runtime-${Os}-${Arch}-pg${PgVer}-pgvector${PgvectorVer}.tar.gz"
+$Url   = "https://github.com/${ReleaseRepo}/releases/download/${Tag}/${Asset}"
+
+$Work = New-Item -ItemType Directory -Force -Path "$env:TEMP\smoke-$([guid]::NewGuid().ToString('N'))" | Select-Object -ExpandProperty FullName
+
+try {
+    Write-Host "==> Negative-path smoke for ${Os}-${Arch} from $Url"
+
+    Write-Host "==> Test 1: HEAD reaches release asset"
+    $resp = Invoke-WebRequest -Uri $Url -Method Head -UseBasicParsing -ErrorAction Stop
+    Write-Host "  HTTP $($resp.StatusCode)"
+
+    Write-Host "==> Test 2: full download + sha256"
+    $TarPath = Join-Path $Work $Asset
+    Invoke-WebRequest -Uri $Url -OutFile $TarPath -UseBasicParsing
+    $sha = (Get-FileHash -Algorithm SHA256 $TarPath).Hash.ToLower()
+    Write-Host "  sha256=$sha"
+
+    Write-Host "==> Test 3: corrupt tarball — flip a byte and ensure tar errors"
+    $CorruptPath = "$Work\corrupt.tar.gz"
+    Copy-Item $TarPath $CorruptPath
+    $bytes = [byte[]]::new(1); $rand = [System.Random]::new(); $rand.NextBytes($bytes)
+    $stream = [System.IO.File]::OpenWrite($CorruptPath)
+    $stream.Position = 102400
+    $stream.Write($bytes, 0, 1)
+    $stream.Close()
+    $CorruptDir = "$Work\corrupt"
+    New-Item -ItemType Directory -Force -Path $CorruptDir | Out-Null
+    $TarProc = Start-Process -FilePath tar -ArgumentList @('-xzf', $CorruptPath, '-C', $CorruptDir.Replace('\','/')) -Wait:$false -PassThru -WindowStyle Hidden
+    if (-not $TarProc.WaitForExit(15000)) {
+        Stop-Process -Id $TarProc.Id -Force -ErrorAction SilentlyContinue
+        Write-Host "  PASS: corrupted tarball extraction timed out and was stopped"
+    } elseif ($TarProc.ExitCode -eq 0) {
+        Write-Host "  WARN: corrupted tarball extracted without error (tar gzip recovery)"
+    } else {
+        Write-Host "  PASS: corrupted tarball rejected by tar (exit $($TarProc.ExitCode))"
+    }
+
+    Write-Host "==> Test 4: fresh-extract boot (extension load + distance query)"
+    $FreshDir = "$Work\fresh"
+    New-Item -ItemType Directory -Force -Path $FreshDir | Out-Null
+    & tar -xzf $TarPath -C ($FreshDir.Replace('\','/'))
+    if ($LASTEXITCODE -ne 0) { throw "fresh extract failed" }
+
+    $PgBin   = "$FreshDir\bin"
+    $Data    = "$FreshDir\pgdata"
+    $Log     = "$FreshDir\pg.log"
+    $Port    = 55897
+
+    # Hostile env: minimal PATH (System32 only), no PGROOT/PGDATA
+    $SavedPath = $env:PATH
+    $SavedPgRoot = $env:PGROOT
+    $env:PATH   = "$env:SystemRoot\System32;$env:SystemRoot"
+    $env:PGROOT = $null
+    $env:PGDATA = $null
+
+    try {
+        & "$PgBin\postgres.exe" --version
+        if ($LASTEXITCODE -ne 0) { throw "FAIL: postgres --version" }
+        & "$PgBin\initdb.exe" -D $Data --username=postgres --auth-local=trust --no-locale -E UTF8 | Out-Null
+        if ($LASTEXITCODE -ne 0) { throw "FAIL: initdb" }
+        & "$PgBin\pg_ctl.exe" -D $Data -o "-p $Port -h 127.0.0.1" -l $Log -w start
+        if ($LASTEXITCODE -ne 0) { Get-Content $Log | Select-Object -Last 30; throw "FAIL: pg_ctl start" }
+
+        try {
+            & "$PgBin\psql.exe" -h 127.0.0.1 -p $Port -U postgres -d postgres -c "CREATE EXTENSION vector;" | Out-Null
+            if ($LASTEXITCODE -ne 0) { throw "FAIL: CREATE EXTENSION" }
+            $ExtV = & "$PgBin\psql.exe" -h 127.0.0.1 -p $Port -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';"
+            if ($ExtV.Trim() -ne $PgvectorVer) { throw "FAIL: extversion='$ExtV' expected='$PgvectorVer'" }
+            Write-Host "  PASS: fresh-extract boot + vector extension"
+        } finally {
+            & "$PgBin\pg_ctl.exe" -D $Data -m fast stop 2>$null | Out-Null
+        }
+
+        Write-Host "==> Test 5: second initdb on initialized dir refused"
+        $rc = (Start-Process -FilePath "$PgBin\initdb.exe" -ArgumentList "-D",$Data,"-U","postgres" -Wait -PassThru -NoNewWindow).ExitCode
+        if ($rc -eq 0) {
+            Write-Host "  WARN: second initdb succeeded (unexpected)"
+        } else {
+            Write-Host "  PASS: second initdb refused (exit $rc)"
+        }
+    } finally {
+        $env:PATH   = $SavedPath
+        $env:PGROOT = $SavedPgRoot
+    }
+
+    Write-Host "==> All negative-path smokes: PASS"
+}
+finally {
+    Remove-Item -Recurse -Force $Work -ErrorAction SilentlyContinue
+}

package/scripts/termio-input-smoke.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * termio-input-smoke.mjs — throwaway smoke for the vendored termio input
+ * pipeline. Feeds synthetic chunk sequences through createInputParser() and
+ * asserts the typed event kinds / channel routing decisions.
+ *
+ * Run: node scripts/termio-input-smoke.mjs
+ */
+import { createInputParser } from '../vendor/ink/build/input-parser.js';
+
+let failures = 0;
+function check(name, cond, detail) {
+  if (cond) {
+    console.log(`ok   - ${name}`);
+  } else {
+    failures++;
+    console.log(`FAIL - ${name}${detail ? ' :: ' + detail : ''}`);
+  }
+}
+
+// Helper: push a list of chunks, collect all emitted events.
+function run(chunks) {
+  const p = createInputParser();
+  const events = [];
+  for (const c of chunks) events.push(...p.push(c));
+  return { p, events };
+}
+
+// 1. ESC split across two chunks -> single arrow-up key, no lone escape.
+{
+  const { events } = run(['\x1b', '[A']);
+  check('split ESC -> one up key',
+    events.length === 1 && events[0].kind === 'key' && events[0].name === 'up',
+    JSON.stringify(events));
+}
+
+// 2. SGR mouse click (button 0 press) -> ParsedMouse.
+{
+  const { events } = run(['\x1b[<0;12;34M']);
+  const m = events[0];
+  check('SGR click -> mouse press',
+    events.length === 1 && m.kind === 'mouse' && m.action === 'press' &&
+      m.col === 12 && m.row === 34 && m.button === 0,
+    JSON.stringify(events));
+}
+
+// 3. SGR wheel-up (button 64) -> key wheelup (stays a key, routes to mouse chan).
+{
+  const { events } = run(['\x1b[<64;5;5M']);
+  const k = events[0];
+  check('SGR wheel -> wheelup key',
+    events.length === 1 && k.kind === 'key' && k.name === 'wheelup',
+    JSON.stringify(events));
+}
+
+// 4. X10 mouse: CSI M + 3 payload bytes (wheel-up: Cb = 0x40+32 = 96 = '`').
+{
+  const { events } = run(['\x1b[M\x60\x30\x30']);
+  const k = events[0];
+  check('X10 wheel -> wheelup key',
+    events.length === 1 && k.kind === 'key' && k.name === 'wheelup',
+    JSON.stringify(events));
+}
+
+// 5. Bracketed paste split across 3 chunks -> one pasted key with full body.
+{
+  const { events } = run(['\x1b[200~hel', 'lo wor', 'ld\x1b[201~']);
+  const paste = events.find((e) => e.isPasted);
+  check('split paste -> one pasted key "hello world"',
+    events.length === 1 && paste && paste.sequence === 'hello world',
+    JSON.stringify(events));
+}
+
+// 6. Paste whose body ends with an X10 mouse tail `\x1b[M` — the ESC in the
+//    payload slot must NOT be consumed as X10 mouse; it stays paste content and
+//    PASTE_END still terminates the paste.
+{
+  const { events } = run(['\x1b[200~abc\x1b[M12\x1b[201~']);
+  const paste = events.find((e) => e.isPasted);
+  check('paste with \\x1b[M tail stays paste',
+    events.length === 1 && paste && paste.sequence === 'abc\x1b[M12',
+    JSON.stringify(events));
+}
+
+// 7. Terminal response (DA1) -> ParsedResponse.
+{
+  const { events } = run(['\x1b[?62;1c']);
+  const r = events[0];
+  check('DA1 -> response',
+    events.length === 1 && r.kind === 'response' && r.response.type === 'da1',
+    JSON.stringify(events));
+}
+
+// 8. Lone ESC buffered -> hasPendingEscape true; flushPendingEscape -> escape key.
+{
+  const p = createInputParser();
+  const first = p.push('\x1b');
+  check('lone ESC buffers (no immediate events)', first.length === 0, JSON.stringify(first));
+  check('hasPendingEscape true for lone ESC', p.hasPendingEscape() === true);
+  const flushed = p.flushPendingEscape();
+  check('flushPendingEscape -> escape key',
+    Array.isArray(flushed) && flushed.length === 1 && flushed[0].name === 'escape',
+    JSON.stringify(flushed));
+}
+
+// 9. Incomplete paste-start marker must NOT arm the escape flush timer.
+{
+  const p = createInputParser();
+  p.push('\x1b[200');
+  check('partial paste-start does not arm flush', p.hasPendingEscape() === false);
+}
+
+// 9b. Generic partial CSI (`\x1b[`, `\x1b[2`, `\x1b[20`) — none of these are
+//     paste-start prefixes/penultimate, so hasPendingEscape MUST arm to avoid
+//     buffering indefinitely.
+{
+  for (const partial of ['\x1b[', '\x1b[2', '\x1b[20']) {
+    const p = createInputParser();
+    p.push(partial);
+    check(`generic partial CSI ${JSON.stringify(partial)} arms flush`,
+      p.hasPendingEscape() === true);
+  }
+}
+
+// 9c. `\x1b[200` and `\x1b[200~`-prefixed pending must NOT arm the flush
+//     (paste-start marker / its penultimate prefix complete on their own).
+{
+  const p1 = createInputParser();
+  p1.push('\x1b[200');
+  check('"\\x1b[200" does not arm flush', p1.hasPendingEscape() === false);
+
+  const p2 = createInputParser();
+  p2.push('\x1b[200~hel'); // still inside paste body once PASTE_START token completes
+  check('paste-start-prefixed pending does not arm flush', p2.hasPendingEscape() === false);
+}
+
+// 9d. Held-backspace chunk splits into individual key events; `\r`/`\t` in
+//     text are NOT split.
+{
+  const { events } = run(['abc\x7f\x7f\x7f']);
+  const names = events.map((e) => e.name || e.sequence);
+  check('abc + 3x backspace -> text key(s) + 3 separate backspace keys',
+    events.length === 4 &&
+      events[0].sequence === 'abc' &&
+      events.slice(1).every((e) => e.name === 'backspace' || e.sequence === '\x7f'),
+    JSON.stringify(names));
+}
+{
+  const { events } = run(['a\rb\tc']);
+  check('\\r and \\t inside text are not split (single key for whole run)',
+    events.length === 1 && events[0].sequence === 'a\rb\tc',
+    JSON.stringify(events));
+}
+
+// 10. Plain text -> key events, sequence carries the character.
+{
+  const { events } = run(['a']);
+  check('plain char -> key "a"',
+    events.length === 1 && events[0].kind === 'key' && events[0].sequence === 'a',
+    JSON.stringify(events));
+}
+
+// 11. Consumer-level routing: synthetic 'mouse' channel events reach the
+//     use-mouse-input dispatch decisions exactly once each. We replicate the
+//     hook's branch keys (kind:'key' wheel with ctrl-mask from sequence vs.
+//     kind:'mouse' press) to guard against double-handling / mis-routing.
+//     MOUSE_CTRL_MASK = 16; wheel ctrl bit is read from the SGR button in
+//     the ParsedKey.sequence via /\x1b\[<(\d+);/ (no button field on wheel).
+{
+  const MOUSE_CTRL_MASK = 16;
+  const WHEEL_SGR = /\x1b\[<(\d+);/;
+  // Feed real parser output so field shapes match production.
+  const wheelPlain = run(['\x1b[<64;5;5M']).events[0];      // wheelup, no ctrl
+  const wheelCtrl = run(['\x1b[<80;5;5M']).events[0];        // 64|16 -> ctrl wheelup
+  const click = run(['\x1b[<0;12;34M']).events[0];           // left press
+
+  const routes = { zoom: 0, scroll: 0, press: 0, ignored: 0 };
+  function route(event) {
+    if (!event || typeof event !== 'object') return;
+    if (event.kind === 'key') {
+      if (event.name !== 'wheelup' && event.name !== 'wheeldown') { routes.ignored++; return; }
+      const wm = WHEEL_SGR.exec(typeof event.sequence === 'string' ? event.sequence : '');
+      const ctrl = wm ? ((Number(wm[1]) & MOUSE_CTRL_MASK) !== 0) : false;
+      if (ctrl) routes.zoom++; else routes.scroll++;
+      return;
+    }
+    if (event.kind !== 'mouse') { routes.ignored++; return; }
+    const button = Number(event.button);
+    if ((button & 3) === 0 && event.action === 'press' && (button & 32) === 0) routes.press++;
+  }
+  for (const e of [wheelPlain, wheelCtrl, click]) route(e);
+  check('mouse routing: plain wheel -> scroll x1', routes.scroll === 1, JSON.stringify(routes));
+  check('mouse routing: ctrl wheel -> zoom x1', routes.zoom === 1, JSON.stringify(routes));
+  check('mouse routing: left press -> press x1 (no double)', routes.press === 1, JSON.stringify(routes));
+  check('mouse routing: nothing mis-routed', routes.ignored === 0, JSON.stringify(routes));
+}
+
+console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILURE(S)`);
+process.exit(failures === 0 ? 0 : 1);

package/scripts/tool-efficiency-diag.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// Tool-usage efficiency diag for worker/heavy-worker (before/after rule changes).
+// Usage: node scripts/tool-efficiency-diag.mjs [--since 24h|<epoch-ms>|ISO]
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+
+function sinceArg() {
+  const i = process.argv.indexOf('--since');
+  const raw = i >= 0 ? process.argv[i + 1] : '24h';
+  const rel = String(raw).match(/^(\d+(?:\.\d+)?)(h|m|d)$/i);
+  if (rel) {
+    const mult = { m: 60_000, h: 3_600_000, d: 86_400_000 }[rel[2].toLowerCase()];
+    return Date.now() - Number(rel[1]) * mult;
+  }
+  if (/^\d+$/.test(raw)) return Number(raw);
+  const p = Date.parse(raw);
+  return Number.isFinite(p) ? p : Date.now() - 86_400_000;
+}
+
+const dataDir = process.env.MIXDOG_DATA_DIR || resolve(homedir(), '.mixdog', 'data');
+const files = [resolve(dataDir, 'history', 'agent-trace.jsonl.1'), resolve(dataDir, 'history', 'agent-trace.jsonl')];
+const since = sinceArg();
+const rows = [];
+for (const f of files) {
+  if (!existsSync(f)) continue;
+  for (const line of readFileSync(f, 'utf8').split(/\r?\n/)) {
+    if (!line) continue;
+    try { const r = JSON.parse(line); if ((r.ts || 0) >= since) rows.push(r); } catch {}
+  }
+}
+const F = (r, n) => (r[n] != null ? r[n] : (r.payload && r.payload[n] != null ? r.payload[n] : null));
+const bySess = new Map();
+for (const r of rows) {
+  const k = r.sessionId || r.session_id || '?';
+  if (!bySess.has(k)) bySess.set(k, []);
+  bySess.get(k).push(r);
+}
+console.log(`window since ${new Date(since).toISOString()}`);
+for (const target of ['heavy-worker', 'worker']) {
+  let batch1 = 0, batchTot = 0, llmCalls = 0, sessions = 0, toolCalls = 0;
+  let grepContent = 0, grepContentWithCtx = 0, grepThenRead = 0, rereads = 0, outTok = 0;
+  for (const [, rs] of bySess) {
+    let agent = null;
+    for (const r of rs) { const x = F(r, 'agent'); if (x) { agent = x; break; } }
+    if (agent !== target) continue;
+    sessions++;
+    rs.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    for (const b of rs.filter((r) => r.kind === 'batch')) {
+      const c = Number(F(b, 'tool_call_count')) || 0;
+      batchTot++; if (c === 1) batch1++;
+    }
+    const usage = rs.filter((r) => r.kind === 'usage_raw');
+    llmCalls += usage.length;
+    outTok += usage.reduce((s, r) => s + (Number(F(r, 'output_tokens')) || 0), 0);
+    const tools = rs.filter((r) => r.kind === 'tool');
+    toolCalls += tools.length;
+    const seenRead = new Map();
+    for (let i = 0; i < tools.length; i++) {
+      const t = tools[i];
+      const n = String(F(t, 'tool_name'));
+      const a = F(t, 'tool_args_summary') || {};
+      if (n === 'read') {
+        const p = typeof a.path === 'string' ? a.path : JSON.stringify(a.path);
+        seenRead.set(p, (seenRead.get(p) || 0) + 1);
+      }
+      if (n === 'grep' && ['content', 'content_with_context'].includes(String(a.output_mode || ''))) {
+        grepContent++;
+        if (a['-C'] != null || a['-A'] != null || a['-B'] != null) grepContentWithCtx++;
+        const gpath = typeof a.path === 'string' ? a.path : JSON.stringify(a.path || '');
+        for (let j = i + 1; j < Math.min(i + 4, tools.length); j++) {
+          const u = tools[j];
+          if (String(F(u, 'tool_name')) !== 'read') continue;
+          const ra = F(u, 'tool_args_summary') || {};
+          const rpath = typeof ra.path === 'string' ? ra.path : JSON.stringify(ra.path || '');
+          if (rpath && gpath && (rpath.includes(gpath) || gpath.includes(rpath))) { grepThenRead++; break; }
+        }
+      }
+    }
+    for (const [, c] of seenRead) if (c >= 3) rereads++;
+  }
+  const pct = (a, b) => (b ? Math.round((a / b) * 100) : 0);
+  console.log(`\n${target}: sessions=${sessions} llmCalls=${llmCalls} toolCalls=${toolCalls} outTok=${outTok}`);
+  console.log(`  llmCalls/session=${sessions ? Math.round(llmCalls / sessions) : 0}  tools/llmCall=${llmCalls ? (toolCalls / llmCalls).toFixed(2) : '-'}`);
+  console.log(`  single-call batches: ${batch1}/${batchTot} (${pct(batch1, batchTot)}%)`);
+  console.log(`  content greps with -C/-A/-B: ${grepContentWithCtx}/${grepContent} (${pct(grepContentWithCtx, grepContent)}%)  grep->read follow-ups: ${grepThenRead}`);
+  console.log(`  same-path re-reads >=3x: ${rereads}`);
+}

package/scripts/tool-smoke.mjs

@@ -42,6 +42,7 @@ import { mergeSessionRowsIntoGlobal } from '../src/runtime/memory/lib/memory-ses
 import { TOOL_DEFS as SEARCH_TOOL_DEFS } from '../src/runtime/search/tool-defs.mjs';
 import { TOOL_DEFS as CHANNEL_TOOL_DEFS } from '../src/runtime/channels/tool-defs.mjs';
 import { AGENT_OWNER } from '../src/runtime/agent/orchestrator/agent-owner.mjs';
+import { recursiveWrapperToolNameForPublicAgent } from '../src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
 import { composeSystemPrompt } from '../src/runtime/agent/orchestrator/context/collect.mjs';
 import { setInternalToolsProvider } from '../src/runtime/agent/orchestrator/internal-tools.mjs';
 import { prepareAgentSession } from '../src/runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
@@ -386,7 +387,7 @@ assertOk('glob explicit src', explicitSrcGlobOut, /src[\\/].*engine\.mjs/i);
 
 const globPathOnlyOut = await executeBuiltinTool('glob', {
   path: 'scripts',
-  head_limit: 8,
+  head_limit: 200,
 }, root);
 assertOk('glob path-only default *', globPathOnlyOut, /tool-smoke\.mjs/i);
 
@@ -398,8 +399,8 @@ const grepNoPatternGlobOut = await executeBuiltinTool('grep', {
 assertOk('grep without pattern routes to glob', grepNoPatternGlobOut, /tool-smoke\.mjs/i);
 
 const grepManyPatterns = [
-  ...Array.from({ length: 20 }, (_, i) => `__tool_smoke_miss_${i}__`),
   'tool-smoke',
+  ...Array.from({ length: 20 }, (_, i) => `__tool_smoke_miss_${i}__`),
 ];
 const grepManyPatternsOut = await executeBuiltinTool('grep', {
   pattern: grepManyPatterns,
@@ -407,12 +408,12 @@ const grepManyPatternsOut = await executeBuiltinTool('grep', {
   glob: '*.mjs',
   head_limit: 5,
 }, root);
-if (/exceeds the 20-pattern cap/i.test(String(grepManyPatternsOut))) {
-  throw new Error(`grep should chunk >20 patterns instead of error:\n${grepManyPatternsOut.slice(0, 400)}`);
+if (/exceeds the \d+-pattern cap/i.test(String(grepManyPatternsOut))) {
+  throw new Error(`grep should truncate oversized pattern[] instead of error:\n${grepManyPatternsOut.slice(0, 400)}`);
 }
-assertOk('grep >20 pattern chunk merge', grepManyPatternsOut, /tool-smoke\.mjs/i);
-if (!/\[pattern set split into 2 chunks\]/.test(String(grepManyPatternsOut))) {
-  throw new Error(`grep >20 patterns should emit chunk advisory:\n${grepManyPatternsOut.slice(0, 400)}`);
+assertOk('grep >10 pattern cap keeps first patterns', grepManyPatternsOut, /tool-smoke\.mjs/i);
+if (!/\[capped at 10 of 21 patterns\]/.test(String(grepManyPatternsOut))) {
+  throw new Error(`grep >10 patterns should emit cap note:\n${grepManyPatternsOut.slice(0, 400)}`);
 }
 
 function grepCountTotalMatches(body) {
@@ -431,9 +432,8 @@ if (singleCountTotal == null || singleCountTotal < 1) {
 }
 
 const grepCountOverlapPatterns = [
-  ...Array.from({ length: 19 }, (_, i) => `__count_overlap_a_${i}__`),
   'assertOk',
-  ...Array.from({ length: 19 }, (_, i) => `__count_overlap_b_${i}__`),
+  ...Array.from({ length: 8 }, (_, i) => `__count_overlap_a_${i}__`),
   'assertOk',
 ];
 const grepCountOverlapOut = await executeBuiltinTool('grep', {
@@ -444,36 +444,37 @@ const grepCountOverlapOut = await executeBuiltinTool('grep', {
 const overlapCountTotal = grepCountTotalMatches(grepCountOverlapOut);
 if (overlapCountTotal !== singleCountTotal) {
   throw new Error(
-    `chunked count must not double-count overlapping lines (single=${singleCountTotal} overlap=${overlapCountTotal}):\n${grepCountOverlapOut.slice(0, 600)}`,
+    `multi-pattern count must not double-count overlapping lines (single=${singleCountTotal} overlap=${overlapCountTotal}):\n${grepCountOverlapOut.slice(0, 600)}`,
   );
 }
 
 const grepChunkContextPatterns = [
-  ...Array.from({ length: 20 }, (_, i) => `__ctx_chunk_miss_${i}__`),
   'grepCountTotalMatches',
+  ...Array.from({ length: 20 }, (_, i) => `__ctx_chunk_miss_${i}__`),
 ];
 const grepChunkContextOut = await executeBuiltinTool('grep', {
   pattern: grepChunkContextPatterns,
-  path: 'scripts/tool-smoke.mjs',
+  path: 'scripts',
+  glob: 'tool-smoke.mjs',
   '-C': 1,
   head_limit: 30,
 }, root);
-if (!/\[pattern set split into 2 chunks\]/.test(String(grepChunkContextOut))) {
-  throw new Error(`chunked -C grep should split patterns:\n${grepChunkContextOut.slice(0, 500)}`);
+if (!/\[capped at 10 of 21 patterns\]/.test(String(grepChunkContextOut))) {
+  throw new Error(`oversized -C pattern[] should emit cap note:\n${grepChunkContextOut.slice(0, 500)}`);
 }
 if (!/tool-smoke\.mjs:\d+:/.test(String(grepChunkContextOut))) {
-  throw new Error(`chunked -C must emit path-prefixed match lines:\n${grepChunkContextOut.slice(0, 800)}`);
+  throw new Error(`capped -C must emit path-prefixed match lines:\n${grepChunkContextOut.slice(0, 800)}`);
 }
 if (!/tool-smoke\.mjs-\d+-/.test(String(grepChunkContextOut))) {
-  throw new Error(`chunked -C must keep path-prefixed context lines:\n${grepChunkContextOut.slice(0, 800)}`);
+  throw new Error(`capped -C must keep path-prefixed context lines:\n${grepChunkContextOut.slice(0, 800)}`);
 }
 const ctxBodyLines = String(grepChunkContextOut).split('\n').filter((l) => l && !/^\[/.test(l) && !/^\(no matches\)/.test(l));
 const orphanLineOnlyContext = ctxBodyLines.some((l) => /^\d+-/.test(l));
 if (orphanLineOnlyContext) {
-  throw new Error(`chunked -C must not leave line-only context orphans:\n${grepChunkContextOut.slice(0, 800)}`);
+  throw new Error(`capped -C must not leave line-only context orphans:\n${grepChunkContextOut.slice(0, 800)}`);
 }
 if (!/function grepCountTotalMatches/.test(String(grepChunkContextOut))) {
-  throw new Error(`chunked -C should include match span:\n${grepChunkContextOut.slice(0, 800)}`);
+  throw new Error(`capped -C should include match span:\n${grepChunkContextOut.slice(0, 800)}`);
 }
 
 const findOut = await executeBuiltinTool('find', {
@@ -1165,12 +1166,19 @@ setInternalToolsProvider({
     if (!/Read-only retrieval role/i.test(visible) || /# environment/i.test(visible) || /git operations deferred to Lead/i.test(visible)) {
       throw new Error(`explorer hidden retrieval context should stay slim: ${visible.slice(0, 1200)}`);
     }
-    if (!/# Role: explorer/i.test(systemVisible) || /# Role: explorer/i.test(userReminderVisible) || !/one-shot locator/i.test(systemVisible)) {
+    if (!/# Role: explorer/i.test(systemVisible) || /# Role: explorer/i.test(userReminderVisible) || !/Coordinate locator/i.test(systemVisible)) {
       throw new Error(`explorer role md must ride BP2 system, not BP3 user reminder: system=${systemVisible.slice(0, 600)} user=${userReminderVisible.slice(0, 600)}`);
     }
-    const visibleBytes = Buffer.byteLength(visible, 'utf8');
-    if (visibleBytes > 1800) {
-      throw new Error(`explorer hidden retrieval context too large: ${visibleBytes} bytes`);
+    // System layers (BP1 tool policy + BP2 role md) are shared/frozen and sized
+    // elsewhere; the slimness cap guards only the per-session injected layers
+    // (BP3 user reminder etc.), so measure non-system messages only.
+    const injectedVisible = (explorerSession.messages || [])
+      .filter((m) => m?.role !== 'system')
+      .map((m) => String(m.content || ''))
+      .join('\n');
+    const injectedBytes = Buffer.byteLength(injectedVisible, 'utf8');
+    if (injectedBytes > 1800) {
+      throw new Error(`explorer hidden retrieval context too large: ${injectedBytes} bytes (injected layers only)`);
     }
   } finally {
     closeSession(explorerSession.id, 'tool-smoke');
@@ -1298,8 +1306,16 @@ setInternalToolsProvider({
     if (!fullTools.includes('explore')) {
       throw new Error(`full agent schema must expose explore: full=${fullTools.join(', ')}`);
     }
-    if (publicExploreTools.includes('explore')) {
-      throw new Error(`public explore role must not expose recursive explore tool: ${publicExploreTools.join(', ')}`);
+    // Unified-shard policy (v0.9.13): the explore wrapper stays IN the schema
+    // for every read role — including the explore agent itself — so the
+    // read-only bundle is bit-identical across roles (one cache group).
+    // Recursion is broken at call time in pre-dispatch-deny.mjs via
+    // recursiveWrapperToolNameForPublicAgent, not by schema stripping.
+    if (JSON.stringify(publicExploreTools) !== JSON.stringify(expectedReadTools)) {
+      throw new Error(`public explore role must ship the shared read-only bundle (incl. explore): expected=${expectedReadTools.join(', ')} actual=${publicExploreTools.join(', ')}`);
+    }
+    if (recursiveWrapperToolNameForPublicAgent('explore') !== 'explore') {
+      throw new Error('call-time anti-recursion must map public explore agent to its own wrapper tool');
     }
   } finally {
     closeSession(readAgentSession.id, 'tool-smoke');