@pugi/cli 0.1.0-beta.1 → 0.1.0-beta.100

package/dist/core/context/markdown-traverse.js

@@ -0,0 +1,255 @@
+/**
+ * Per-directory PUGI.md / AGENTS.md / CLAUDE.md / GEMINI.md traverse-up
+ * loader — β5a R4+P5.
+ *
+ * the upstream tool, peer CLI, and Gemini CLI all support a "walk up from
+ * cwd to the workspace root, pick up agent-context markdown at every
+ * level" pattern. Without this, a `pugi explain` invoked from
+ * `apps/admin-api/` cannot see project-local conventions encoded in
+ * `apps/admin-api/PUGI.md` (or the cross-CLI shim files) — the
+ * existing `loadMarkdownContext` only reads files at `workspaceRoot`.
+ *
+ * The β5a quality gate (≥80% win-rate vs the upstream tool per CEO)
+ * surfaces this gap repeatedly: monorepo-local conventions (NestJS
+ * controller style, Prisma migration name format, cabinet brand voice
+ * gates) live in per-app context files, and Pugi was blind to them
+ * pre-β5a.
+ *
+ * Contract:
+ *
+ *  - Walk from `cwd` upward until we reach `workspaceRoot` OR cross
+ *    the filesystem boundary. The workspace root file itself is
+ *    loaded by the legacy `loadMarkdownContext` so we do NOT include
+ *    it here (no double-load, no double-budget-charge).
+ *
+ *  - At each intermediate directory, look for the four canonical
+ *    filenames: `PUGI.md` (native), `AGENTS.md` (cross-CLI shim),
+ *    `CLAUDE.md` (the upstream tool compat), `GEMINI.md` (Gemini CLI compat).
+ *
+ *  - HTML comments stripped, identical to the legacy loader.
+ *
+ *  - `@import` expansion is intentionally NOT performed here — the
+ *    per-dir surface is "drop a small file with the local
+ *    conventions"; deep @import chains belong at workspace root.
+ *    Keeping this surface flat means the per-dir budget cannot be
+ *    blown out by a runaway @import in an unrelated subtree.
+ *
+ *  - Aggregate budget: `MAX_TRAVERSE_BYTES` across ALL files found
+ *    in the walk. When exhausted, remaining files are skipped with
+ *    a `budget_exhausted` warning. Default 32 KB — half the
+ *    workspace-root budget, because per-dir files are meant to be
+ *    terse delta conventions, not full project briefs.
+ *
+ *  - The walk is bounded: `MAX_TRAVERSE_DEPTH` levels above
+ *    workspaceRoot are NEVER traversed (defense against being
+ *    invoked from a malicious cwd outside the workspace; in
+ *    practice cwd is always inside workspaceRoot but the symlink
+ *    case demands belt + suspenders).
+ *
+ *  - Order returned: shallowest-first (workspace root would be
+ *    first if included, then each level closer to cwd). Closest-
+ *    to-cwd files are the most specific and the context builder
+ *    emits them LAST so the model treats them as the highest-
+ *    priority conventions.
+ *
+ * This module is pure: no logging, no network, no fs writes. Filesystem
+ * reads only.
+ */
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { stripHtmlComments } from './markdown-loader.js';
+/**
+ * Per-traverse total byte cap. Half the workspace-root budget — these
+ * files are meant to be terse "in this subdir, do X". 32 KB still fits
+ * ~8000 words of guidance.
+ */
+export const MAX_TRAVERSE_BYTES = 32 * 1024;
+/**
+ * Per-file byte cap. A single per-dir file should never dominate; the
+ * 8 KB cap keeps any one level honest. Files larger than this are
+ * loaded up to the cap and flagged truncated.
+ */
+export const MAX_TRAVERSE_PER_FILE_BYTES = 8 * 1024;
+/**
+ * Maximum number of parent directories above workspaceRoot we will
+ * traverse. Zero in normal operation — cwd is always inside the
+ * workspace; the cap exists so a misconfigured invocation never
+ * walks the whole filesystem looking for AGENTS.md.
+ */
+export const MAX_TRAVERSE_DEPTH = 0;
+/**
+ * Filenames we look for at every level of the walk. The order here
+ * also defines the per-directory load order: PUGI.md first (highest
+ * trust), then cross-CLI compat shims. When the same directory has
+ * multiple files (e.g. both PUGI.md AND CLAUDE.md), all are loaded
+ * — operators sometimes keep both during a tool migration.
+ */
+export const TRAVERSE_SOURCES = ['PUGI.md', 'AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
+/**
+ * Walk from `opts.cwd` upward toward `opts.workspaceRoot`, loading
+ * every PUGI.md / AGENTS.md / CLAUDE.md / GEMINI.md we encounter at
+ * intermediate levels. The workspace root itself is NOT loaded here
+ * — `loadMarkdownContext(workspaceRoot)` owns that file.
+ *
+ * Returned `loaded` is sorted shallowest-first (closest-to-root) so
+ * the caller can emit per-dir context in increasing specificity.
+ *
+ * Safety properties (proven by spec):
+ *
+ *  - Never reads outside the workspace tree (symlinks resolved via
+ *    realpathSync; off-tree symlinks rejected as
+ *    `import_escapes_workspace`).
+ *  - Never reads more than `MAX_TRAVERSE_BYTES` total or more than
+ *    `MAX_TRAVERSE_PER_FILE_BYTES` per file.
+ *  - Never walks above the workspace root.
+ *  - Never visits the workspace root itself (single source of truth
+ *    for workspace-level docs stays with `loadMarkdownContext`).
+ */
+export async function loadTraversedMarkdown(opts) {
+    const warnings = [];
+    const loaded = [];
+    let budgetRemaining = MAX_TRAVERSE_BYTES;
+    let absRoot;
+    let absCwd;
+    try {
+        absRoot = realpathSync(resolve(opts.workspaceRoot));
+        absCwd = realpathSync(resolve(opts.cwd));
+    }
+    catch (error) {
+        warnings.push({
+            kind: 'read_error',
+            message: `realpath failed for traverse anchor: ${error.message}`,
+        });
+        return { loaded, warnings, totalBytes: 0 };
+    }
+    // Containment guard: if cwd is not inside workspaceRoot, refuse
+    // to walk. Returning a clean empty result keeps the engine happy
+    // and surfaces nothing about the off-tree cwd to the model.
+    const relCwd = relative(absRoot, absCwd);
+    if (relCwd.startsWith('..') || isAbsolute(relCwd)) {
+        warnings.push({
+            kind: 'import_escapes_workspace',
+            message: `cwd is outside workspaceRoot; per-dir traverse skipped (cwd=${absCwd}, root=${absRoot})`,
+            path: absCwd,
+        });
+        return { loaded, warnings, totalBytes: 0 };
+    }
+    // Collect the walk: every directory from cwd UP TO (but not
+    // including) workspaceRoot.
+    const dirsToVisit = [];
+    let current = absCwd;
+    while (current !== absRoot) {
+        dirsToVisit.push(current);
+        const parent = dirname(current);
+        if (parent === current)
+            break; // hit filesystem root before workspaceRoot — defensive
+        current = parent;
+        if (dirsToVisit.length > 64)
+            break; // pathological depth, refuse
+    }
+    // Walk shallowest-first so we charge the budget in the order
+    // that matches what we return.
+    dirsToVisit.reverse();
+    for (const dir of dirsToVisit) {
+        if (budgetRemaining <= 0) {
+            warnings.push({
+                kind: 'budget_exhausted',
+                message: `per-dir traverse budget exhausted before reaching ${dir}`,
+                path: dir,
+            });
+            break;
+        }
+        for (const source of TRAVERSE_SOURCES) {
+            const candidate = resolve(dir, source);
+            if (!existsSync(candidate))
+                continue;
+            // Symlink guard: same realpath check as the workspace-root
+            // loader. A symlink inside the workspace that points outside
+            // the workspace must NOT be inlined.
+            let realCandidate;
+            try {
+                realCandidate = realpathSync(candidate);
+            }
+            catch (error) {
+                warnings.push({
+                    kind: 'read_error',
+                    message: `realpath failed for ${candidate}: ${error.message}`,
+                    path: candidate,
+                });
+                continue;
+            }
+            const realRel = relative(absRoot, realCandidate);
+            if (realRel.startsWith('..') || isAbsolute(realRel)) {
+                warnings.push({
+                    kind: 'import_escapes_workspace',
+                    message: `traverse file escapes workspace via symlink: ${candidate} -> ${realCandidate}`,
+                    path: candidate,
+                });
+                continue;
+            }
+            let raw;
+            let rawBytes;
+            try {
+                rawBytes = statSync(candidate).size;
+                raw = readFileSync(candidate, 'utf8');
+            }
+            catch (error) {
+                warnings.push({
+                    kind: 'read_error',
+                    message: `could not read ${candidate}: ${error.message}`,
+                    path: candidate,
+                });
+                continue;
+            }
+            const stripped = stripHtmlComments(raw);
+            // Per-file cap first, then global budget.
+            const perFileCap = Math.min(MAX_TRAVERSE_PER_FILE_BYTES, budgetRemaining);
+            let content = stripped;
+            let truncated = false;
+            let contentBytes = Buffer.byteLength(content, 'utf8');
+            if (contentBytes > perFileCap) {
+                // Codepoint-safe slice: convert byte cap to char cap by
+                // taking min(byte cap, char-length-up-to-cap). We accept
+                // mild over-trim for safety.
+                content = content.slice(0, perFileCap);
+                truncated = true;
+                contentBytes = Buffer.byteLength(content, 'utf8');
+            }
+            const distance = distanceSegments(absCwd, dir);
+            loaded.push({
+                source,
+                resolvedPath: candidate,
+                dir,
+                distanceFromCwd: distance,
+                rawBytes,
+                loadedBytes: contentBytes,
+                truncated,
+                content,
+            });
+            budgetRemaining -= contentBytes;
+            if (budgetRemaining <= 0)
+                break;
+        }
+    }
+    return {
+        loaded,
+        warnings,
+        totalBytes: MAX_TRAVERSE_BYTES - budgetRemaining,
+    };
+}
+/**
+ * How many path segments separate `from` and `to`. Both must be
+ * absolute. `to` is assumed to be an ancestor of (or equal to)
+ * `from`; if not, returns -1 so callers can ignore the file.
+ */
+function distanceSegments(from, to) {
+    if (from === to)
+        return 0;
+    const rel = relative(to, from);
+    if (rel.startsWith('..') || isAbsolute(rel))
+        return -1;
+    if (rel.length === 0)
+        return 0;
+    return rel.split(sep).length;
+}
+//# sourceMappingURL=markdown-traverse.js.map

package/dist/core/context/pugiignore.js

@@ -1,5 +1,5 @@
 /**
- * `.pugiignore` parser - α6.5 Phase 1 (three-tier context).
+ * `.pugiignore` parser - Phase 1 (three-tier context).
  *
  * The CLI walks the workspace to build a repo skeleton and to feed the
  * chokidar watcher. Both passes need a single source of truth for which
@@ -9,32 +9,32 @@
  *
  * Design choices:
  *
- *   1. We layer four sources, last-write-wins per the .gitignore spec:
- *      (a) Built-in DEFAULT_IGNORE_PATTERNS - secret / binary / build
- *          paths every workspace should drop.
- *      (b) `~/.pugi/global.pugiignore` - operator-global overrides.
- *      (c) Repo `.gitignore` (when present) - so we don't re-walk
- *          node_modules / dist / etc.
- *      (d) Repo `.pugiignore` - workspace-local extensions.
+ *  1. We layer four sources, last-write-wins per the .gitignore spec:
+ *     (a) Built-in DEFAULT_IGNORE_PATTERNS - secret / binary / build
+ *         paths every workspace should drop.
+ *     (b) `~/.pugi/global.pugiignore` - operator-global overrides.
+ *     (c) Repo `.gitignore` (when present) - so we don't re-walk
+ *         node_modules / dist / etc.
+ *     (d) Repo `.pugiignore` - workspace-local extensions.
  *
- *   2. The `ignore` npm package handles negation (`!path`) and nested
- *      directories correctly. Rolling a minimal glob matcher is doable
- *      but the test surface for gitignore semantics (esp. negation +
- *      ancestor matching) is wide enough that pulling the audited
- *      library is the safer call. It is already in the workspace via
- *      transitive deps; we add it as an explicit pugi-cli dep.
+ *  2. The `ignore` npm package handles negation (`!path`) and nested
+ *     directories correctly. Rolling a minimal glob matcher is doable
+ *     but the test surface for gitignore semantics (esp. negation +
+ *     ancestor matching) is wide enough that pulling the audited
+ *     library is the safer call. It is already in the workspace via
+ *     transitive deps; we add it as an explicit pugi-cli dep.
  *
- *   3. Privacy is defense-in-depth: even if the operator deletes the
- *      built-in defaults from their `.pugiignore`, we re-add the
- *      secret patterns at the END of the chain so a typo in user
- *      config cannot expose `.env` / `*.pem` / `*.key`. The user can
- *      explicitly negate (`!.env.example`) but cannot wipe the
- *      defense.
+ *  3. Privacy is defense-in-depth: even if the operator deletes the
+ *     built-in defaults from their `.pugiignore`, we re-add the
+ *     secret patterns at the END of the chain so a typo in user
+ *     config cannot expose `.env` / `*.pem` / `*.key`. The user can
+ *     explicitly negate (`!.env.example`) but cannot wipe the
+ *     defense.
  *
- *   4. Paths are normalised to forward slashes (the `ignore` package
- *      requires POSIX-style separators even on Windows) and stripped
- *      of any leading workspace root so `isIgnored` answers in
- *      repo-relative terms.
+ *  4. Paths are normalised to forward slashes (the `ignore` package
+ *     requires POSIX-style separators even on Windows) and stripped
+ *     of any leading workspace root so `isIgnored` answers in
+ *     repo-relative terms.
  *
  * The API surface is minimal: `loadPugiIgnore(cwd)` returns a
  * `PugiIgnore` matcher with `isIgnored(absPath): boolean`. The matcher
@@ -59,19 +59,19 @@ const ignoreFactory = ignoreModule.default
  * Built-in patterns shipped with every Pugi workspace. The list is a
  * conservative union of three categories:
  *
- *   - **Secrets** (defense in depth): `.env*`, `*.pem`, `*.key`,
- *     `secrets/**`, `.netrc`, `id_rsa*`, `*.secret`, `credentials*`.
- *     These are re-applied at the END of the chain so user config
- *     cannot accidentally expose them.
+ *  - **Secrets** (defense in depth): `.env*`, `*.pem`, `*.key`,
+ *    `secrets/**`, `.netrc`, `id_rsa*`, `*.secret`, `credentials*`.
+ *    These are re-applied at the END of the chain so user config
+ *    cannot accidentally expose them.
  *
- *   - **Build outputs / caches**: `node_modules/`, `dist/`, `build/`,
- *     `.next/`, `.nuxt/`, `.svelte-kit/`, `coverage/`, `.nx/`, `.cache/`,
- *     `.turbo/`, `.parcel-cache/`, `out/`, `.output/`, `*.tsbuildinfo`.
+ *  - **Build outputs / caches**: `node_modules/`, `dist/`, `build/`,
+ *    `.next/`, `.nuxt/`, `.svelte-kit/`, `coverage/`, `.nx/`, `.cache/`,
+ *    `.turbo/`, `.parcel-cache/`, `out/`, `.output/`, `*.tsbuildinfo`.
  *
- *   - **Large binaries / data**: lockfiles (`*.lock`, `*-lock.json`,
- *     `*-lock.yaml`), images (`*.png`, `*.jpg`, `*.jpeg`, `*.gif`,
- *     `*.ico`), PDFs, videos, archives (`*.zip`, `*.tar`, `*.gz`),
- *     DB dumps (`*.sql`, `*.dump`), logs.
+ *  - **Large binaries / data**: lockfiles (`*.lock`, `*-lock.json`,
+ *    `*-lock.yaml`), images (`*.png`, `*.jpg`, `*.jpeg`, `*.gif`,
+ *    `*.ico`), PDFs, videos, archives (`*.zip`, `*.tar`, `*.gz`),
+ *    DB dumps (`*.sql`, `*.dump`), logs.
  *
  * The split between baseline patterns (applied first) and secret
  * patterns (applied last) matters: a user `.pugiignore` can `!`-negate
@@ -173,7 +173,7 @@ export const SECRET_IGNORE_PATTERNS = Object.freeze([
     // used by Java + .NET tooling. Both can carry private keys when
     // bundled (PKCS#7 / PKCS#12) and the file extension alone does not
     // tell us whether the bundle includes a key. Treat as secrets by
-    // default. triple-review P1 (PR #380).
+    // default. triple-review P1 (PR).
     '*.cer',
     '*.der',
     '*.p12',
@@ -216,11 +216,11 @@ export function workspaceGitIgnorePath(cwd) {
  * is built in this exact order so later layers override earlier ones,
  * with the trailing secret block as the inviolable backstop:
  *
- *   1. BASELINE_IGNORE_PATTERNS  (built-in defaults)
- *   2. ~/.pugi/global.pugiignore (operator global, optional)
- *   3. <cwd>/.gitignore          (workspace, optional)
- *   4. <cwd>/.pugiignore         (workspace, optional)
- *   5. SECRET_IGNORE_PATTERNS    (defense-in-depth backstop)
+ *  1. BASELINE_IGNORE_PATTERNS (built-in defaults)
+ *  2. ~/.pugi/global.pugiignore (operator global, optional)
+ *  3. <cwd>/.gitignore         (workspace, optional)
+ *  4. <cwd>/.pugiignore        (workspace, optional)
+ *  5. SECRET_IGNORE_PATTERNS   (defense-in-depth backstop)
  *
  * Any FS error reading optional files is swallowed - workspace
  * context is best-effort and must never block the REPL bootstrap.

package/dist/core/context/repo-skeleton.js

@@ -1,40 +1,40 @@
 /**
- * Tier 0 repo skeleton builder - α6.5 Phase 1 (three-tier context).
+ * Tier 0 repo skeleton builder - Phase 1 (three-tier context).
  *
  * The skeleton is the ~5KB "always loaded" tier in the three-tier
  * model. Goal: give the agent enough structural awareness to navigate
  * an unfamiliar repo on the first turn without uploading the whole
  * tree. We capture:
  *
- *   - cwd + current branch (best-effort, no exec)
- *   - detected package manager (lockfile heuristic)
- *   - primary languages (file-extension histogram, top 5)
- *   - ASCII directory tree (depth <= MAX_TREE_DEPTH, collapses busy
- *     dirs to a "(N dirs, M files)" line)
- *   - package.json projection (name/version/scripts/deps)
- *   - first MAX_README_LINES of README.md
+ *  - cwd + current branch (best-effort, no exec)
+ *  - detected package manager (lockfile heuristic)
+ *  - primary languages (file-extension histogram, top 5)
+ *  - ASCII directory tree (depth <= MAX_TREE_DEPTH, collapses busy
+ *    dirs to a "(N dirs, M files)" line)
+ *  - package.json projection (name/version/scripts/deps)
+ *  - first MAX_README_LINES of README.md
  *
  * Hard constraints:
  *
- *   1. **5KB cap on the rendered string**. We render in priority
- *      order (headers + meta first, then tree, then package.json, then
- *      README) and truncate the tail with a "..." marker rather than
- *      omitting fields. The walker's bound is independent: it stops
- *      visiting dirs after a hard `MAX_WALK_NODES` even when the
- *      skeleton would still fit.
+ *  1. **5KB cap on the rendered string**. We render in priority
+ *     order (headers + meta first, then tree, then package.json, then
+ *     README) and truncate the tail with a "..." marker rather than
+ *     omitting fields. The walker's bound is independent: it stops
+ *     visiting dirs after a hard `MAX_WALK_NODES` even when the
+ *     skeleton would still fit.
  *
- *   2. **Ignore-aware**: every fs read is filtered through `PugiIgnore`
- *      so `.env`, `*.pem`, `node_modules/`, etc. stay out. The walker
- *      uses the same matcher so `node_modules/` is never expanded.
+ *  2. **Ignore-aware**: every fs read is filtered through `PugiIgnore`
+ *     so `.env`, `*.pem`, `node_modules/`, etc. stay out. The walker
+ *     uses the same matcher so `node_modules/` is never expanded.
  *
- *   3. **No exec**: we read `.git/HEAD` for the branch, never spawn
- *      `git`. The skeleton is built on session bootstrap; spawning
- *      git on every launch is slow + makes the CLI flaky on hosts
- *      without git installed.
+ *  3. **No exec**: we read `.git/HEAD` for the branch, never spawn
+ *     `git`. The skeleton is built on session bootstrap; spawning
+ *     git on every launch is slow + makes the CLI flaky on hosts
+ *     without git installed.
  *
- *   4. **Best-effort**: every FS read is wrapped in try/catch.
- *      Missing README / missing package.json / unreadable file -> the
- *      field is omitted but the skeleton still builds.
+ *  4. **Best-effort**: every FS read is wrapped in try/catch.
+ *     Missing README / missing package.json / unreadable file -> the
+ *     field is omitted but the skeleton still builds.
  */
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
@@ -64,7 +64,7 @@ export function buildRepoSkeleton(cwd, options) {
     // contracts, customer-specific data, NDA'd boilerplate) keeps those
     // files out of the agent context. Without this gate, the direct
     // skeleton reads would BYPASS the matcher even though the walker
-    // honours it. triple-review P1 (PR #380).
+    // honours it. triple-review P1 (PR).
     const pkg = readPackageJson(normalised, ignore);
     const packageManager = detectPackageManager(normalised, ignore);
     const walk = walkTree(normalised, ignore);
@@ -93,10 +93,10 @@ export function buildRepoSkeleton(cwd, options) {
  *
  * Section order (highest priority first):
  *
- *   1. Meta header (cwd / branch / package manager / languages)
- *   2. Directory tree
- *   3. package.json projection (name / version / scripts / deps count)
- *   4. README excerpt
+ *  1. Meta header (cwd / branch / package manager / languages)
+ *  2. Directory tree
+ *  3. package.json projection (name / version / scripts / deps count)
+ *  4. README excerpt
  *
  * Each lower-priority section is appended only when there is room for
  * its FULL body. Partial sections would mislead the model (e.g. a
@@ -132,7 +132,7 @@ export function renderSkeleton(skeleton) {
     return out;
 }
 /* ------------------------------------------------------------------ */
-/* Section renderers                                                  */
+/* Section renderers                                                 */
 /* ------------------------------------------------------------------ */
 function renderHeader(skeleton) {
     const lines = [];
@@ -184,7 +184,7 @@ function renderReadmeSection(skeleton) {
     return `\n## README (first ${MAX_README_LINES} lines)\n${skeleton.readmeExcerpt}`;
 }
 /* ------------------------------------------------------------------ */
-/* Signal readers                                                     */
+/* Signal readers                                                    */
 /* ------------------------------------------------------------------ */
 /**
  * Read the current branch from `.git/HEAD` WITHOUT spawning git. The
@@ -264,7 +264,7 @@ export function readPackageJson(cwd, ignore) {
     // package.json to .pugiignore (private template projects, customer
     // boilerplate under NDA) must not have it read into the agent
     // context even though the walker would have skipped it.
-    // triple-review P1 (PR #380). The matcher is optional so direct callers
+    // triple-review P1 (PR). The matcher is optional so direct callers
     // (e.g. unit tests of readPackageJson in isolation) keep working.
     if (ignore?.isIgnored(pkgPath))
         return undefined;
@@ -298,7 +298,7 @@ export function readReadme(cwd, overridePath, ignore) {
     for (const candidate of candidates) {
         // Skip candidates the operator has explicitly ignored. A workspace
         // README that documents private contracts / customer data must
-        // never land in the rendered skeleton. triple-review P1 (PR #380).
+        // never land in the rendered skeleton. triple-review P1 (PR).
         if (ignore?.isIgnored(candidate))
             continue;
         const raw = safeRead(candidate);
@@ -383,7 +383,7 @@ function walkTree(cwd, ignore) {
 }
 /**
  * Render a `DirNode` as a UTF-8 ASCII-tree string. Lines use the
- * Claude Code convention: `├──` / `└──` glyphs, two-space indents per
+ * the upstream tool convention: `├──` / `└──` glyphs, two-space indents per
  * level. Collapsed dirs land as `name/ (N dirs, M files)`.
  */
 function renderTree(root) {
@@ -408,12 +408,12 @@ function appendChildren(node, prefix, lines) {
         const isLast = i === children.length - 1;
         const glyph = isLast ? '└── ' : '├── ';
         lines.push(`${prefix}${glyph}${child.name}/${counts(child)}`);
-        const nextPrefix = `${prefix}${isLast ? '    ' : '│   '}`;
+        const nextPrefix = `${prefix}${isLast ? '   ' : '│  '}`;
         appendChildren(child, nextPrefix, lines);
     }
 }
 /* ------------------------------------------------------------------ */
-/* Language histogram                                                 */
+/* Language histogram                                                */
 /* ------------------------------------------------------------------ */
 /**
  * Map a filename to a human-readable language label. Returns null for
@@ -495,7 +495,7 @@ export function topLanguages(histogram, topN) {
     return entries.slice(0, topN).map(([lang]) => lang);
 }
 /* ------------------------------------------------------------------ */
-/* Small helpers                                                      */
+/* Small helpers                                                     */
 /* ------------------------------------------------------------------ */
 function safeRead(path) {
     // Stat first to keep the regular-file guard (Codex R2 P2): a FIFO or

package/dist/core/context/tool-eviction.js

@@ -0,0 +1,55 @@
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+export function evictByLRU(entries, targetTokens) {
+    const sorted = [...entries].sort((a, b) => a.usedAt.localeCompare(b.usedAt));
+    const total = sorted.reduce((sum, e) => sum + e.tokensEst, 0);
+    if (total <= targetTokens) {
+        return {
+            evicted: [],
+            kept: sorted.map((e) => e.id),
+            freedTokens: 0,
+        };
+    }
+    const evicted = [];
+    const kept = [];
+    let freedTokens = 0;
+    let remaining = total;
+    for (const entry of sorted) {
+        if (remaining > targetTokens) {
+            evicted.push(entry.id);
+            freedTokens += entry.tokensEst;
+            remaining -= entry.tokensEst;
+        }
+        else {
+            kept.push(entry.id);
+        }
+    }
+    return { evicted, kept, freedTokens };
+}
+export function evictByContentClass(entries, rules, now = new Date()) {
+    const ruleByTool = new Map(rules.map((r) => [r.tool, r]));
+    const nowMs = now.getTime();
+    const evicted = [];
+    const kept = [];
+    let freedTokens = 0;
+    for (const entry of entries) {
+        const rule = ruleByTool.get(entry.tool);
+        if (!rule) {
+            kept.push(entry.id);
+            continue;
+        }
+        const ageMs = nowMs - new Date(entry.ts).getTime();
+        const tooOld = ageMs > rule.maxAgeMs;
+        const tooBig = entry.tokensEst > rule.maxTokens;
+        if (tooOld || tooBig) {
+            evicted.push(entry.id);
+            freedTokens += entry.tokensEst;
+        }
+        else {
+            kept.push(entry.id);
+        }
+    }
+    return { evicted, kept, freedTokens };
+}
+//# sourceMappingURL=tool-eviction.js.map