@pugi/cli 0.1.0-beta.87 → 0.1.0-beta.89

package/dist/core/lsp/symbol-cache.js

@@ -0,0 +1,162 @@
+/** Default TTL for cached entries. 5 minutes matches the spec target. */
+export const DEFAULT_TTL_MS = 5 * 60 * 1000;
+/** Default size cap. Empirically large enough for a heavy navigate session. */
+export const DEFAULT_MAX_ENTRIES = 1000;
+/**
+ * Generic TTL cache. The unknown value type is intentional — the cache
+ * stores serialized result objects produced by the 13 symbol tools; we
+ * surface them back to the caller as the SAME unknown so the cache
+ * does not encode the result schema.
+ *
+ * Thread-safety: Node single-threaded, no concurrent writes possible
+ * inside one `pugi` invocation. The cache is NOT shared across
+ * spawned subagents — each subagent runs its own LspClient + cache.
+ */
+export class SymbolCache {
+    store = new Map();
+    ttlMs;
+    maxEntries;
+    now;
+    metrics = { hits: 0, misses: 0, evictions: 0, size: 0 };
+    constructor(options) {
+        this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+        this.maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES;
+        this.now = options?.now ?? (() => Date.now());
+    }
+    /**
+     * Build a canonical key from the dispatch coordinates. Workspace +
+     * language scopes the cache so two different repos opened in the same
+     * REPL session do not pollute each other.
+     */
+    static makeKey(lang, workspace, verb, args) {
+        // Sort keys deterministically so `{file: 'a', line: 1}` and
+        // `{line: 1, file: 'a'}` map to the same cache entry.
+        const sorted = {};
+        for (const key of Object.keys(args).sort()) {
+            sorted[key] = args[key];
+        }
+        return `${lang}::${workspace}::${verb}::${JSON.stringify(sorted)}`;
+    }
+    /**
+     * Look up a cached value. Returns undefined when:
+     *
+     *  - the key is not in the cache
+     *  - the entry has aged past `ttlMs` (the entry is deleted in this
+     *    case so the eviction counter is accurate)
+     *
+     * Hit updates the entry's `lastAccessed` so the LRU policy keeps
+     * frequently-touched entries warm.
+     */
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry) {
+            this.metrics.misses++;
+            return undefined;
+        }
+        const now = this.now();
+        if (now - entry.storedAt > this.ttlMs) {
+            this.store.delete(key);
+            this.metrics.evictions++;
+            this.metrics.misses++;
+            this.metrics.size = this.store.size;
+            return undefined;
+        }
+        entry.lastAccessed = now;
+        this.metrics.hits++;
+        return entry.result;
+    }
+    /**
+     * Store a value. Evicts the LRU entry when the cache hits `maxEntries`.
+     * The eviction counter increments for each LRU drop AND each TTL drop
+     * so the operator surface can distinguish "cache too small" from "TTL
+     * too short".
+     */
+    set(key, value) {
+        const now = this.now();
+        if (this.store.size >= this.maxEntries && !this.store.has(key)) {
+            // Find the LRU entry.
+            let oldestKey;
+            let oldestAccess = Number.POSITIVE_INFINITY;
+            for (const [k, entry] of this.store) {
+                if (entry.lastAccessed < oldestAccess) {
+                    oldestAccess = entry.lastAccessed;
+                    oldestKey = k;
+                }
+            }
+            if (oldestKey !== undefined) {
+                this.store.delete(oldestKey);
+                this.metrics.evictions++;
+            }
+        }
+        this.store.set(key, { result: value, storedAt: now, lastAccessed: now });
+        this.metrics.size = this.store.size;
+    }
+    /**
+     * Invalidate every entry for a workspace. Called by the post-edit
+     * hook so a successful `edit`/`write` clears stale symbol locations.
+     * Returns the number of entries dropped.
+     */
+    invalidateWorkspace(workspace) {
+        const prefix = `${workspace}::`;
+        // Two prefix forms: `<lang>::<workspace>::...` — we scan the full
+        // store and drop entries whose key contains the workspace literal.
+        let dropped = 0;
+        for (const key of Array.from(this.store.keys())) {
+            // The key shape is `lang::workspace::verb::args` — split on `::`
+            // and check the second segment. Avoid substring match because a
+            // workspace path could legally contain `::` (e.g. a Windows
+            // network path).
+            const parts = key.split('::');
+            if (parts.length >= 2 && parts[1] === workspace) {
+                this.store.delete(key);
+                dropped++;
+            }
+            else if (parts.length >= 2 && parts[1]?.startsWith(prefix)) {
+                this.store.delete(key);
+                dropped++;
+            }
+        }
+        if (dropped > 0) {
+            this.metrics.evictions += dropped;
+            this.metrics.size = this.store.size;
+        }
+        return dropped;
+    }
+    /** Drop every cached entry. */
+    clear() {
+        this.metrics.evictions += this.store.size;
+        this.store.clear();
+        this.metrics.size = 0;
+    }
+    /** Snapshot of the current metrics. The returned record is a copy. */
+    snapshot() {
+        return { ...this.metrics, size: this.store.size };
+    }
+    /** Test-only: reset metrics counters without dropping entries. */
+    resetMetrics() {
+        this.metrics = { hits: 0, misses: 0, evictions: 0, size: this.store.size };
+    }
+    /** Test-only: number of entries currently stored. */
+    size() {
+        return this.store.size;
+    }
+}
+/**
+ * Process-global symbol cache, lazily constructed on first access. The
+ * CLI surface picks this up via `getGlobalSymbolCache()` so every
+ * subagent / tool invocation in the same process shares the same cache.
+ * Subagents spawned in a fresh child process get a fresh cache (by
+ * design — the cache is process-scoped, not user-scoped).
+ */
+let globalCache;
+export function getGlobalSymbolCache(options) {
+    if (!globalCache) {
+        globalCache = new SymbolCache(options);
+    }
+    return globalCache;
+}
+/** Test-only: drop the singleton so a spec starts with a fresh cache. */
+export function __resetGlobalSymbolCache() {
+    globalCache = undefined;
+}
+//# sourceMappingURL=symbol-cache.js.map

package/dist/core/lsp/symbol-tools.js

@@ -67,15 +67,28 @@ export function symbolKindLabel(kind) {
     return SYMBOL_KIND_LABELS[kind] ?? 'unknown';
 }
 /**
- * Build a `SymbolToolsTransport` from a real `LspClient`. Production
- * wire-up. `documentSymbols` / `workspaceSymbols` are omitted on
- * purpose — the `LspClient` does not expose them, so the Phase 1
- * surface degrades to `[]`. Phase 2 follows.
+ * Build a `SymbolToolsTransport` from a real `LspClient`. PUGI-78 Phase
+ * 1: wires every method the client exposes (13 total). Methods the
+ * `LspClient` does NOT support yet stay omitted on the returned
+ * transport so the symbol-tools surface degrades to null / [] without
+ * forcing the caller to wrap.
  */
 export function transportFromLspClient(client) {
     return {
         definition: (file, pos) => client.definition(file, pos),
         references: (file, pos) => client.references(file, pos),
+        documentSymbols: (file) => client.documentSymbols(file),
+        workspaceSymbols: (query) => client.workspaceSymbols(query),
+        hover: (file, pos) => client.hover(file, pos),
+        signatureHelp: (file, pos) => client.signatureHelp(file, pos),
+        implementations: (file, pos) => client.implementations(file, pos),
+        typeDefinition: (file, pos) => client.typeDefinition(file, pos),
+        rename: (file, pos, newName) => client.rename(file, pos, newName),
+        prepareRename: (file, pos) => client.prepareRename(file, pos),
+        codeActions: (file, range) => client.codeActions(file, range),
+        formatting: (file, options) => client.formatting(file, undefined, options),
+        diagnostics: (file) => client.diagnostics(file),
+        callHierarchy: (file, pos) => client.callHierarchy(file, pos),
     };
 }
 /**
@@ -222,6 +235,284 @@ export async function findWorkspaceSymbol(transport, query) {
     }
     return out;
 }
+/**
+ * PUGI-78 Phase 1: hover (type info + docstring). Returns null when:
+ *
+ *  - `filePath` is empty / whitespace
+ *  - `line` / `character` non-finite or negative
+ *  - the transport does not implement `hover`
+ *  - `ok: false` from the transport
+ *  - the server reports no hover (cursor not on a symbol)
+ *  - the transport throws
+ *
+ * Caps the body at 4 KB so a verbose generic type signature does not
+ * blow the agent's context window. The cap mirrors the `lspHover`
+ * tool's 8 KB cap halved — the symbol surface is closer to "give me
+ * one sentence" than the full hover blob.
+ */
+export async function hoverSymbol(transport, filePath, line, character) {
+    if (!isNonEmptyString(filePath))
+        return null;
+    if (!isFiniteNonNegativeInt(line) || !isFiniteNonNegativeInt(character))
+        return null;
+    if (!transport.hover)
+        return null;
+    let result;
+    try {
+        result = await transport.hover(filePath, { line, character });
+    }
+    catch {
+        return null;
+    }
+    if (!result.ok)
+        return null;
+    if (!result.value)
+        return null;
+    const HOVER_CAP_BYTES = 4 * 1024;
+    const raw = result.value.content;
+    const bytes = Buffer.byteLength(raw, 'utf8');
+    const truncated = bytes > HOVER_CAP_BYTES;
+    const content = truncated
+        ? Buffer.from(raw, 'utf8').subarray(0, HOVER_CAP_BYTES).toString('utf8') + '\n... [truncated]'
+        : raw;
+    return {
+        content,
+        ...(result.value.range ? { range: result.value.range } : {}),
+        ...(truncated ? { truncated: true } : {}),
+    };
+}
+/**
+ * PUGI-78 Phase 1: function signature at a call site. Returns null when
+ * the transport does not implement `signatureHelp` OR the server
+ * reports no signature OR the transport fails / throws.
+ */
+export async function signatureAt(transport, filePath, line, character) {
+    if (!isNonEmptyString(filePath))
+        return null;
+    if (!isFiniteNonNegativeInt(line) || !isFiniteNonNegativeInt(character))
+        return null;
+    if (!transport.signatureHelp)
+        return null;
+    let result;
+    try {
+        result = await transport.signatureHelp(filePath, { line, character });
+    }
+    catch {
+        return null;
+    }
+    if (!result.ok)
+        return null;
+    if (!result.value)
+        return null;
+    const out = { label: result.value.label, parameters: result.value.parameters };
+    if (result.value.documentation)
+        out.documentation = result.value.documentation;
+    if (typeof result.value.activeParameter === 'number')
+        out.activeParameter = result.value.activeParameter;
+    return out;
+}
+/**
+ * PUGI-78 Phase 1: implementations of an interface / abstract method.
+ * Returns `[]` on any failure mode (parity with `findReferences`).
+ */
+export async function findImplementations(transport, filePath, line, character) {
+    if (!isNonEmptyString(filePath))
+        return [];
+    if (!isFiniteNonNegativeInt(line) || !isFiniteNonNegativeInt(character))
+        return [];
+    if (!transport.implementations)
+        return [];
+    let result;
+    try {
+        result = await transport.implementations(filePath, { line, character });
+    }
+    catch {
+        return [];
+    }
+    if (!result.ok)
+        return [];
+    return collapseLocations(result.value);
+}
+/**
+ * PUGI-78 Phase 1: type-definition (vs value-definition). Returns null
+ * matching `findDefinition`'s contract.
+ */
+export async function findTypeDefinition(transport, filePath, line, character) {
+    if (!isNonEmptyString(filePath))
+        return null;
+    if (!isFiniteNonNegativeInt(line) || !isFiniteNonNegativeInt(character))
+        return null;
+    if (!transport.typeDefinition)
+        return null;
+    let result;
+    try {
+        result = await transport.typeDefinition(filePath, { line, character });
+    }
+    catch {
+        return null;
+    }
+    if (!result.ok)
+        return null;
+    const first = result.value[0];
+    if (!first)
+        return null;
+    const file = pickFilePath(first);
+    if (!isNonEmptyString(file))
+        return null;
+    return { file, line: first.range.start.line, character: first.range.start.character };
+}
+export async function renameSymbol(transport, filePath, line, character, newName) {
+    if (!isNonEmptyString(filePath))
+        return null;
+    if (!isFiniteNonNegativeInt(line) || !isFiniteNonNegativeInt(character))
+        return null;
+    if (!isNonEmptyString(newName))
+        return null;
+    if (!transport.rename)
+        return null;
+    // Best-effort prepare-rename precheck. If the server says the cursor
+    // is not on a renameable token, we return null without dispatching
+    // the full rename — saves a wasted round-trip + avoids returning a
+    // misleading "0 edits" preview.
+    if (transport.prepareRename) {
+        try {
+            const prep = await transport.prepareRename(filePath, { line, character });
+            if (prep.ok && prep.value === null)
+                return null;
+        }
+        catch {
+            // Continue — some servers fail prepare-rename but still execute
+            // the full rename. Phase 1 honors the looser fallback.
+        }
+    }
+    let result;
+    try {
+        result = await transport.rename(filePath, { line, character }, newName);
+    }
+    catch {
+        return null;
+    }
+    if (!result.ok)
+        return null;
+    if (!result.value)
+        return null;
+    if (result.value.edits.length === 0)
+        return null;
+    return { files: result.value.files, edits: result.value.edits };
+}
+/**
+ * PUGI-78 Phase 1: code-action / quick-fix list at a range. Returns
+ * `[]` on any failure mode.
+ */
+export async function codeActionsAt(transport, filePath, startLine, startChar, endLine, endChar) {
+    if (!isNonEmptyString(filePath))
+        return [];
+    if (!isFiniteNonNegativeInt(startLine) ||
+        !isFiniteNonNegativeInt(startChar) ||
+        !isFiniteNonNegativeInt(endLine) ||
+        !isFiniteNonNegativeInt(endChar)) {
+        return [];
+    }
+    if (!transport.codeActions)
+        return [];
+    const range = {
+        start: { line: startLine, character: startChar },
+        end: { line: endLine, character: endChar },
+    };
+    let result;
+    try {
+        result = await transport.codeActions(filePath, range);
+    }
+    catch {
+        return [];
+    }
+    if (!result.ok)
+        return [];
+    return [...result.value];
+}
+/**
+ * PUGI-78 Phase 1: formatter — returns the text edits the server would
+ * apply. Returns `[]` on any failure mode.
+ */
+export async function formatFile(transport, filePath, options) {
+    if (!isNonEmptyString(filePath))
+        return [];
+    if (!transport.formatting)
+        return [];
+    let result;
+    try {
+        result = await transport.formatting(filePath, options);
+    }
+    catch {
+        return [];
+    }
+    if (!result.ok)
+        return [];
+    return [...result.value];
+}
+/**
+ * PUGI-78 Phase 1: diagnostics for `filePath`. Returns `[]` on any
+ * failure mode. Mirrors the agent surface of `lspDiagnostics` but
+ * folded into the symbols.* namespace for ergonomic discoverability.
+ */
+export async function diagnosticsFor(transport, filePath) {
+    if (!isNonEmptyString(filePath))
+        return [];
+    if (!transport.diagnostics)
+        return [];
+    let result;
+    try {
+        result = await transport.diagnostics(filePath);
+    }
+    catch {
+        return [];
+    }
+    if (!result.ok)
+        return [];
+    return [...result.value];
+}
+/**
+ * PUGI-78 Phase 1: call hierarchy at a symbol position. Returns the
+ * incoming and outgoing edges. Empty arrays on any failure mode.
+ */
+export async function callHierarchyAt(transport, filePath, line, character) {
+    const empty = { incoming: [], outgoing: [] };
+    if (!isNonEmptyString(filePath))
+        return empty;
+    if (!isFiniteNonNegativeInt(line) || !isFiniteNonNegativeInt(character))
+        return empty;
+    if (!transport.callHierarchy)
+        return empty;
+    let result;
+    try {
+        result = await transport.callHierarchy(filePath, { line, character });
+    }
+    catch {
+        return empty;
+    }
+    if (!result.ok)
+        return empty;
+    return { incoming: [...result.value.incoming], outgoing: [...result.value.outgoing] };
+}
+/**
+ * Internal: collapse `LspLocation[]` to flat references the agent
+ * surface ships. Identical to the `findReferences` loop body — lifted
+ * to avoid a second copy.
+ */
+function collapseLocations(locations) {
+    const out = [];
+    for (const loc of locations) {
+        const file = pickFilePath(loc);
+        if (!isNonEmptyString(file))
+            continue;
+        out.push({
+            file,
+            line: loc.range.start.line,
+            character: loc.range.start.character,
+        });
+    }
+    return out;
+}
 // -- internals ---------------------------------------------------------------
 function isNonEmptyString(value) {
     return typeof value === 'string' && value.trim().length > 0;
@@ -368,5 +659,6 @@ export const __test__ = {
     pickRangeStart,
     symbolKindLabel,
     walkDocumentSymbol,
+    collapseLocations,
 };
 //# sourceMappingURL=symbol-tools.js.map

package/dist/core/mcp/server-tools.js

@@ -6,7 +6,7 @@ import { bashToolSync } from '../../tools/bash.js';
  * The shapes intentionally mirror the engine-loop tool schemas in
  * `core/engine/tool-bridge.ts` so an MCP client and the Pugi engine see
  * the same parameter contracts. This is the "Pugi as MCP server"
- * surface — other agents (the upstream tool, Codex, OpenCode) call these to
+ * surface — other agents (the upstream tool, Codex, peer tooling) call these to
  * read / mutate the workspace through us, with all our security gates
  * (path containment, plan-mode refusal, bash classifier, settings) in
  * the loop.

package/dist/core/mcp/server.js

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 /**
  * Pugi MCP server (β4 M2) — exposes Pugi's native tool surface to other
- * agents (the upstream tool, OpenCode, Codex CLI, any client that speaks
+ * agents (the upstream tool, peer tooling, peer CLI, any client that speaks
  * MCP).
  *
  * Transport-agnostic core. The stdio entry-point lives at the bottom of

package/dist/core/memory/secret-scanner.js

@@ -1,10 +1,10 @@
 /**
- * Persona-memory secret scanner (backlog, ADR-0063 hardening).
+ * Persona-memory secret scanner (backlog,  hardening).
  *
  * Defense against API keys / credentials accidentally landing in shared
  * persona memory. A naive operator typing `pugi memory write fact "Use
  * API key sk-ant-..."` would silently persist that secret to the
- * `cf_admin.persona_memory` table — visible to every persona, every
+ * `the platform database.persona_memory` table — visible to every persona, every
  * recall query, every dual-write sink. This module is the chokepoint
  * that refuses such writes.
  *
@@ -25,7 +25,7 @@
  *  3. GitHub PAT / installation tokens (ghp_/ghs_/gho_/ghu_)
  *                                                      high
  *  4. AWS access key id       AKIA…                high
- *  5. Plane API token         plane_api_…          high
+ *  5. Plane API token         plane_api_…          high   [pugi-leak-ok]
  *  6. npm token               npm_…                high
  *  7. Slack token             xox[bpoars]-…        high
  *  8. Stripe secret key       sk_(live|test)_…     high
@@ -59,10 +59,10 @@
  *    instead of reject. The scanner exposes `redactSecrets` for that
  *    caller — see `runtime/commands/memory.ts`.
  *
- * # Clean-room provenance
+ * # independent implementation provenance
  *
  * Inspired by the the upstream tool teamMemorySync.secretScanner pattern
- * (intel from leak-research memos). Clean-room TypeScript
+ * (intel from leak-research memos). independent implementation TypeScript
  * implementation — no upstream code reused. Pattern vocabulary was
  * cross-referenced against the existing
  * `apps/pugi-cli/scripts/secret-scanner.mjs` tarball gate so a single
@@ -124,7 +124,7 @@ const SECRET_RULES = [
         pattern: 'plane-api-token',
         // Plane (project management) personal API tokens. Bounded to 20+
         // url-safe chars after the prefix.
-        regex: /\bplane_api_[A-Za-z0-9]{20,}(?![A-Za-z0-9])/g,
+        regex: /\bplane_api_[A-Za-z0-9]{20,}(?![A-Za-z0-9])/g, // [pugi-leak-ok]
         confidence: 'high',
     },
     {

package/dist/core/onboarding/ensure-initialized.js

@@ -119,7 +119,7 @@ export async function ensureInitialized(opts) {
     write(`No Pugi workspace found at ${root}.\n`);
     const answer = (await opts.prompt('Initialize a new Pugi workspace here? (Y/n) ')).trim().toLowerCase();
     // Default = yes (empty input OR leading 'y'). Anything else = no.
-    // Mirrors the gh CLI / claude code prompt convention where the upper-
+    // Mirrors the gh CLI / the upstream prompt convention where the upper-
     // case option in `(Y/n)` is the default-on-Enter answer.
     const acceptedShort = answer === '' || answer === 'y' || answer === 'yes';
     if (!acceptedShort) {

package/dist/core/plans/plan-artifact.js

@@ -2,7 +2,7 @@
  * Plan-as-FILE artifact store (Pugi backlog).
  *
  * Pattern absorbed from the the upstream tool `ExitPlanMode` leak intel
- * (clean-room TypeScript reimplementation — no source was copied; only
+ * (independent implementation TypeScript reimplementation — no source was copied; only
  * the file-as-artifact concept). When Pugi enters plan-mode the engine
  * routes the plan body to `.pugi/plans/<plan-id>.md` instead of the
  * message stream so it survives `/compact`, becomes diffable across
@@ -205,7 +205,7 @@ function yamlScalar(value) {
     // Empty string is also disambiguated by quoting.
     if (value.length === 0)
         return '""';
-    if (/[-"]/.test(value)) {
+    if (/[-"]/.test(value)) {
         return JSON.stringify(value);
     }
     if (/[:#\n\t]/.test(value)) {

package/dist/core/repl/ask.js

@@ -4,7 +4,7 @@
  * Pugi's persona prompt teaches Pugi to emit two structured XML envelopes
  * when she would otherwise have to guess. Operator chat then pauses on a
  * modal until the operator answers, eliminating the "fabricate a default
- * silently" failure mode that Codex CLI, the upstream tool, and Gemini CLI all
+ * silently" failure mode that peer CLI, the upstream tool, and Gemini CLI all
  * trip on with low-confidence intents.
  *
  *  <pugi-ask>

package/dist/core/repl/cap-warning.js

@@ -1,5 +1,5 @@
 /**
- * Client-side concurrent-subagent cap - Sprint (ADR-0056
+ * Client-side concurrent-subagent cap - Sprint (
  * acceptance #6, Mac safety memo
  * `feedback_max_3_parallel_agents_mac_safety.md`).
  *

package/dist/core/repl/session.js

@@ -2019,7 +2019,7 @@ export class ReplSession {
         // Surface the operator's choice as a transcript row so the
         // conversation reads linearly. The label of the chosen option
         // (or the literal custom input) is more readable than the bare
-        // value - Codex CLI's "you chose: Vercel" pattern.
+        // value - peer CLI's "you chose: Vercel" pattern.
         const humanLabel = humanLabelForVerdict(tag, sanitisedVerdict);
         this.appendOperatorLine(humanLabel);
         // Local-origin modals (operator typed `/ask`) never need an
@@ -4105,7 +4105,7 @@ export function colorizeQuotaRow(row, pct) {
  * string and emit a synthesised `ToolCallEntry`. Returns null when no
  * known tool pattern matches.
  *
- * The grammar mirrors the way the upstream tool, Codex CLI, and Gemini CLI
+ * The grammar mirrors the way the upstream tool, peer CLI, and Gemini CLI
  * display tool calls in their tool stream panes:
  *
  *  Read(path)
@@ -4293,7 +4293,7 @@ function encodePlanReviewVerdictLocal(result) {
 }
 /**
  * Compose the human-readable transcript line that records the
- * operator's ask verdict. Mirrors Codex CLI's "you chose: <label>"
+ * operator's ask verdict. Mirrors peer CLI's "you chose: <label>"
  * pattern so the conversation reads linearly.
  */
 function humanLabelForVerdict(tag, verdict) {

package/dist/core/repl/slash-commands.js

@@ -4,7 +4,7 @@
  * The REPL input box surfaces a palette of slash commands the operator
  * can run from inside a persistent session. The wave-2 expansion (CEO
  *) grows the surface from 6 to 20 commands so the `/help`
- * overlay matches the breadth the upstream tool / Codex CLI operators expect.
+ * overlay matches the breadth the upstream tool / peer CLI operators expect.
  *
  * The registry is pure: each `parseSlashCommand` call returns a
  * `SlashCommandResult` describing what the REPL session should do next.

package/dist/core/routing/pre-flight-estimator.js

@@ -1,5 +1,5 @@
 /**
- * Pre-flight token estimator — Nuekkis tokenEstimation port,
+ * Pre-flight token estimator — external tokenEstimation port,
  * adapted for Anvil's 3-tier routing.
  *
  * The auto-compact gate counts tokens AFTER a turn lands. This module