pi-ast-sgrep 2.1.1 → 2.2.0

package/dist/runtime/freshness.js

@@ -18,7 +18,7 @@ async function probeIndexHealth(runtime, rootContext, options) {
         const status = runtime.nativeCall
             ? await runtime.nativeCall("index_status", {}, rootContext, options)
             : await runtime.run(["status", ".", "--json"], rootContext, options);
-        return indexHealth(status, hinted === "ready");
+        return indexHealth(status);
     }
     catch (cause) {
         if (!incompatibleStatusFailure(cause))
@@ -26,11 +26,18 @@ async function probeIndexHealth(runtime, rootContext, options) {
         return "incompatible";
     }
 }
-/** Run index_repo via native sticky pool or CLI argv. force=true → reindex. */
+/**
+ * Run index_repo via the host's native call (the extension routes it out of
+ * process — see host/tools.ts) or CLI argv. force=true → reindex.
+ *
+ * Implicit (freshness-driven) refreshes index lexical/AST rows only: neural
+ * embeddings for a cold repo took 36-60s on large trees before the first search
+ * could answer. Embeddings are built by the explicit index/reindex tool.
+ */
 async function runIndex(runtime, force, rootContext, options) {
     const response = runtime.nativeCall
-        ? await runtime.nativeCall("index_repo", { force }, rootContext, options)
-        : await runtime.run([force ? "reindex" : "index", ".", "--json"], rootContext, options);
+        ? await runtime.nativeCall("index_repo", { force, use_embed: false }, rootContext, options)
+        : await runtime.run([force ? "reindex" : "index", ".", "--json", "--no-embed"], rootContext, options);
     const { failed, walkErrors } = indexCompletion(response, true);
     if (failed > 0 || walkErrors) {
         throw new RuntimeError("INDEX_UPDATE_INCOMPLETE", "ast-sgrep did not complete the full index reconciliation", { failed, walkErrors, force });
@@ -41,8 +48,8 @@ async function runTargetedIndex(runtime, paths, rootContext, options) {
     for (let offset = 0; offset < paths.length; offset += MAX_TARGETED_INDEX_PATHS) {
         const chunk = paths.slice(offset, offset + MAX_TARGETED_INDEX_PATHS);
         const response = runtime.nativeCall
-            ? await runtime.nativeCall("index_repo", { paths: chunk }, rootContext, options)
-            : await runtime.run(["index", ".", "--json", ...chunk.flatMap((path) => ["--path", path])], rootContext, options);
+            ? await runtime.nativeCall("index_repo", { paths: chunk, use_embed: false }, rootContext, options)
+            : await runtime.run(["index", ".", "--json", "--no-embed", ...chunk.flatMap((path) => ["--path", path])], rootContext, options);
         const { failed } = indexCompletion(response, false);
         if (failed > 0) {
             throw new RuntimeError("INDEX_UPDATE_INCOMPLETE", `ast-sgrep failed to update ${failed} changed path${failed === 1 ? "" : "s"}`, { failed, pathCount: chunk.length });
@@ -133,6 +140,22 @@ function markStateFullScan(state) {
 function cancelledRefreshWait() {
     return new RuntimeError("CANCELLED", "ast-sgrep freshness wait was cancelled");
 }
+/**
+ * A cancellation that belongs to another caller's dead refresh, not to this
+ * caller. The last waiter's cancel aborts shared work (resource hygiene); a
+ * caller holding a live signal must never inherit that teardown as its own
+ * failure — it settles the dead refresh and owns a fresh one instead.
+ */
+function isForeignRefreshCancel(cause, signal) {
+    if (signal?.aborted === true)
+        return false;
+    if (cause instanceof RuntimeError)
+        return cause.code === "CANCELLED";
+    if (cause instanceof Error && cause.name === "AbortError")
+        return true;
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return /aborted|was cancelled/i.test(message);
+}
 /** Stop one caller waiting without transferring cancellation ownership to shared work. */
 function waitForRefresh(refresh, signal, waitMs) {
     if (!signal && (!waitMs || waitMs <= 0))
@@ -293,7 +316,17 @@ export class FreshnessCoordinator {
                 this.#pending.delete(pendingRoot);
         }
         if (state.inFlight) {
-            await attachRefreshWaiter(state, state.inFlight, options.signal, this.#waitBudget(options));
+            const shared = state.inFlight;
+            try {
+                await attachRefreshWaiter(state, shared, options.signal, this.#waitBudget(options));
+            }
+            catch (cause) {
+                if (!isForeignRefreshCancel(cause, options.signal))
+                    throw cause;
+                // Another caller's cancel tore down the shared refresh. This caller is
+                // still alive: settle the dead promise, then decide for itself below.
+                await shared.catch(() => undefined);
+            }
             return this.ensureFresh(runtime, rootContext, options);
         }
         if (options.signal?.aborted)

package/dist/runtime/index-health.d.ts

@@ -2,7 +2,7 @@ import { type MachineEnvelope } from "./types.js";
 export type IndexHealth = "ready" | "missing" | "incompatible";
 export declare function pathContained(parent: string, child: string): boolean;
 export declare function record(value: unknown): Record<string, unknown> | undefined;
-export declare function indexHealth(status: MachineEnvelope, knownExisting?: boolean): IndexHealth;
+export declare function indexHealth(status: MachineEnvelope): IndexHealth;
 export declare function incompatibleStatusFailure(cause: unknown): boolean;
 export declare function indexCompletion(response: MachineEnvelope, requireWalkErrors: boolean): {
     failed: number;

package/dist/runtime/index-health.js

@@ -14,7 +14,7 @@ export function pathContained(parent, child) {
 export function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
-export function indexHealth(status, knownExisting = false) {
+export function indexHealth(status) {
     const index = record(status.index);
     const state = typeof index?.status === "string" ? index.status :
         typeof status.index_status === "string" ? status.index_status : undefined;
@@ -25,7 +25,9 @@ export function indexHealth(status, knownExisting = false) {
     if (state === "ready" || state === "current" || index?.exists === true || status.indexed === true)
         return "ready";
     if (typeof status.index_path === "string" && typeof status.file_count === "number") {
-        return knownExisting || status.file_count > 0 ? "ready" : "missing";
+        // A present-but-empty index answers nothing: report it as unindexed so the
+        // caller indexes instead of reading zero rows as a legitimate no-match.
+        return status.file_count > 0 ? "ready" : "missing";
     }
     throw new RuntimeError("INDEX_STATUS_UNKNOWN", "ast-sgrep status did not report index freshness", { index: status.index, index_status: status.index_status });
 }

package/dist/runtime/types.d.ts

@@ -2,7 +2,7 @@
  * Shared leaf module: version constants, wire types, RuntimeError.
  * Imports nothing from sibling modules — any file may depend on it.
  */
-export declare const RUNTIME_VERSION = "2.0.0";
+export declare const RUNTIME_VERSION = "2.1.0";
 export declare const MACHINE_SCHEMA_VERSION = "1.0.0";
 export declare const CONFIG_SCHEMA_VERSION: 1;
 /** Index format this release ships. Must equal INDEX_SCHEMA_VERSION in crates/ast-sgrep-core (check-contract gates it). */

package/dist/runtime/types.js

@@ -2,7 +2,7 @@
  * Shared leaf module: version constants, wire types, RuntimeError.
  * Imports nothing from sibling modules — any file may depend on it.
  */
-export const RUNTIME_VERSION = "2.0.0";
+export const RUNTIME_VERSION = "2.1.0";
 export const MACHINE_SCHEMA_VERSION = "1.0.0";
 export const CONFIG_SCHEMA_VERSION = 1;
 /** Index format this release ships. Must equal INDEX_SCHEMA_VERSION in crates/ast-sgrep-core (check-contract gates it). */

package/dist/ui/card.d.ts

@@ -26,6 +26,8 @@ export type CardModel = {
         ms: number;
     }>;
     resultLines?: string[];
+    /** Warnings that qualify the answer (stale index, unindexed repo). */
+    notes?: string[];
     error?: string;
     running?: boolean;
     expanded?: boolean;
@@ -55,9 +57,10 @@ type RenderOptions = {
 };
 type RenderContext = {
     lastComponent?: unknown;
+    args?: object;
 };
 /** Build the card model from the tool result's details payload. */
-export declare function cardModel(result: ResultLike, options: RenderOptions): CardModel;
+export declare function cardModel(result: ResultLike, options: RenderOptions, callArgs?: Record<string, unknown>): CardModel;
 /** renderResult entrypoint: bind one card per result slot, feed it details. */
 export declare function renderAsgrepResult(result: ResultLike, options: RenderOptions, theme: PresentTheme, context?: RenderContext): AsgrepCard;
 export {};

package/dist/ui/card.js

@@ -1,7 +1,7 @@
 /** Pi TUI result card — supernova-style: the call slot is empty; one card
  * owns the whole lifecycle (running → ops ledger → result → error). Rows are
  * fixed-column and theme-painted; nothing here writes to the model channel. */
-import { hitLabel, hitLocation, paint, truncateToWidth, visibleWidth, } from "./present.js";
+import { displayWidth, hitLabel, hitLocation, paint, sanitizeContent, summarizeValue, truncateToWidth, visibleWidth, } from "./present.js";
 /** Header text that rides the top border: "asgrep search · 4 hits · 12ms · napi". */
 function frameLabel(model) {
     const bits = ["asgrep", model.command, ...model.title.filter((b) => Boolean(b))];
@@ -22,7 +22,6 @@ export const EMPTY_CALL = {
 };
 const TOOL_COL = 12;
 const DUR_COL = 7;
-const MAX_CARD_WIDTH = 100;
 /** Rounded frame glyphs — pi themes may provide theme.boxRound; default ASCII-art set. */
 const BOX = { tl: "\u256d", tr: "\u256e", bl: "\u2570", br: "\u256f", h: "\u2500", v: "\u2502" };
 function boxOf(theme) {
@@ -39,45 +38,54 @@ function borderKey(model) {
         return "accent";
     return "dim";
 }
+/** Tool box background per state — the same keys pi themes tint native tool rows with. */
+function backgroundKey(model) {
+    if (model.error)
+        return "toolErrorBg";
+    if (model.running)
+        return "toolPendingBg";
+    return "toolSuccessBg";
+}
+/**
+ * Paint the tool box background across the full row, when the theme has one.
+ * Without this the host's message background shows through the card, which
+ * reads as a dark band beside the border.
+ */
+function backgroundPaint(theme, model) {
+    const bg = theme?.bg;
+    if (typeof bg !== "function")
+        return undefined;
+    try {
+        const key = backgroundKey(model);
+        if (typeof bg.call(theme, key, "x") !== "string")
+            return undefined;
+        return (text) => {
+            const painted = bg.call(theme, key, text);
+            return typeof painted === "string" ? painted : text;
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Top/bottom bar with an optional label embedded in the rule. Geometry is in
- * display cells (frameW): \u256d + 3 rules on the left, corner on the right. */
+ * display cells (displayWidth): \u256d + 3 rules on the left, corner on the right. */
 function frameBar(theme, box, border, left, right, label, width) {
     const leftRaw = left + box.h.repeat(3);
-    const shown = label ? clamp(" " + label + " ", Math.max(0, width - frameW(leftRaw) - 1)) : "";
-    const fill = Math.max(0, width - frameW(leftRaw) - frameW(shown) - 1);
+    const shown = label ? clamp(" " + label + " ", Math.max(0, width - displayWidth(leftRaw) - 1)) : "";
+    const fill = Math.max(0, width - displayWidth(leftRaw) - displayWidth(shown) - 1);
     return border(leftRaw) + shown + border(box.h.repeat(fill)) + border(right);
 }
-/** ANSI-aware cut to `width` display columns on the same scale as frameW
- * (stripped code-point count). Unlike truncateToWidth this never leaves an
- * unclosed SGR color behind: a cut inside a painted span appends \x1b[0m
- * before the ellipsis so the row cannot bleed color into the right border. */
+/**
+ * Cut a row to `width` display columns (pi's cell scale: tab = 3, wide = 2).
+ *
+ * Delegates to the shared cell-aware truncator so every surface measures with
+ * one rule. Counting code units here instead (the previous shape) under-counted
+ * tabs threefold and made tab-indented code rows overflow the card — the crash
+ * pi reports as "Rendered line N exceeds terminal width".
+ */
 function clamp(text, width) {
-    const limit = Math.max(1, width);
-    if (frameW(text) <= limit)
-        return text;
-    const budget = Math.max(1, limit - 1); // room for the ellipsis
-    const ansi = /\u001b\[[0-9;]*m/gu;
-    const stops = [];
-    for (let match = ansi.exec(text); match !== null; match = ansi.exec(text)) {
-        stops.push([match.index, match.index + match[0].length]);
-    }
-    let kept = "";
-    let visible = 0;
-    let index = 0;
-    let stopIndex = 0;
-    while (index < text.length && visible < budget) {
-        if (stopIndex < stops.length && index === stops[stopIndex][0]) {
-            const [, end] = stops[stopIndex];
-            kept += text.slice(index, end);
-            index = end;
-            stopIndex += 1;
-            continue;
-        }
-        kept += text[index];
-        visible += 1;
-        index += 1;
-    }
-    return kept + (stops.length > 0 ? "\u001b[0m" : "") + "\u2026";
+    return truncateToWidth(text, Math.max(1, width), "\u2026");
 }
 function fitPath(text, budget) {
     if (visibleWidth(text) <= budget)
@@ -86,12 +94,6 @@ function fitPath(text, budget) {
         return "\u2026";
     return "\u2026" + text.slice(Math.max(0, text.length - budget + 1));
 }
-/** Display columns for frame geometry: ANSI-stripped code-point count.
- * Box glyphs/·/✓ render width-1 in real terminals; the conservative
- * visibleWidth() over-counts them (width 2) which would ragged the box. */
-function frameW(text) {
-    return text.replace(/\u001b\[[0-9;]*m/g, "").length;
-}
 function fmtMs(ms) {
     if (!Number.isFinite(ms) || ms < 0)
         return "";
@@ -134,9 +136,11 @@ export class AsgrepCard {
             return [];
         if (this.cache?.width === width)
             return this.cache.lines;
-        // Pi hands us the full terminal width — a hollow frame at 200+ cols is a
-        // wall of empty border. Cap at a readable card width; pi pads the rest.
-        const lines = framedLines(theme, model, Math.min(Math.max(8, width), MAX_CARD_WIDTH));
+        // Pi hands us the full terminal width and renders this card with
+        // renderShell "self", so the frame must span every column the host gave
+        // us. Capping it left the host's message background showing as a dark
+        // band to the right of the border.
+        const lines = framedLines(theme, model, Math.max(8, width));
         this.cache = { width, lines };
         return lines;
     }
@@ -149,13 +153,15 @@ function framedLines(theme, model, width) {
     const inner = Math.max(1, width - 4); // "\u2502 " + content + " \u2502"
     const label = frameLabel(model);
     const rows = bodyLines(theme, model, inner);
-    const out = [frameBar(theme, box, border, box.tl, box.tr, label, width)];
+    const background = backgroundPaint(theme, model);
+    const fill = (line) => (background ? background(line) : line);
+    const out = [fill(frameBar(theme, box, border, box.tl, box.tr, label, width))];
     for (const row of rows) {
         const body = clamp(row, inner);
-        const pad = Math.max(0, inner - frameW(body));
-        out.push(border(box.v) + " " + body + " ".repeat(pad) + " " + border(box.v));
+        const pad = Math.max(0, inner - displayWidth(body));
+        out.push(fill(border(box.v) + " " + body + " ".repeat(pad) + " " + border(box.v)));
     }
-    out.push(frameBar(theme, box, border, box.bl, box.br, null, width));
+    out.push(fill(frameBar(theme, box, border, box.bl, box.br, null, width)));
     return out;
 }
 function bodyLines(theme, model, width) {
@@ -174,13 +180,13 @@ function bodyLines(theme, model, width) {
         lines.push(paint(theme, "dim", "   \u2026 " + ((model.hits?.length ?? 0) - hits.length) + " more"));
     }
     for (const edit of (model.edits ?? []).slice(0, model.expanded ? 12 : 4)) {
-        const head = " " + paint(theme, "accent", edit.path ?? "?") + (edit.line ? paint(theme, "dim", ":" + edit.line) : "");
+        const head = " " + paint(theme, "accent", sanitizeContent(edit.path ?? "?")) + (edit.line ? paint(theme, "dim", ":" + edit.line) : "");
         lines.push(clamp(head, width));
         for (const line of (edit.removed ?? []).slice(0, model.expanded ? 24 : 8)) {
-            lines.push("   " + paint(theme, "error", "- " + clamp(line, width - 4)));
+            lines.push("   " + paint(theme, "error", "- " + clamp(line, width - 5)));
         }
         for (const line of (edit.added ?? []).slice(0, model.expanded ? 24 : 8)) {
-            lines.push("   " + paint(theme, "success", "+ " + clamp(line, width - 4)));
+            lines.push("   " + paint(theme, "success", "+ " + clamp(line, width - 5)));
         }
         if (edit.truncated)
             lines.push(paint(theme, "dim", "   \u2026"));
@@ -198,11 +204,49 @@ function bodyLines(theme, model, width) {
             lines.push(paint(theme, "dim", "   \u2026 " + (model.resultLines.length - shown.length) + " more result lines"));
         }
     }
+    for (const note of model.notes ?? []) {
+        lines.push(" " + paint(theme, "warning", "! " + clamp(note, width - 3)));
+    }
     return lines;
 }
+/** Target bits taken from the call arguments, so a running card can name what
+ * the call is about before any result exists. Never duplicated on completion:
+ * once details land they own the label. */
+function callTargetBits(args) {
+    if (!args)
+        return [];
+    const bits = [];
+    if (typeof args.query === "string" && args.query)
+        bits.push(JSON.stringify(sanitizeContent(args.query)));
+    else if (typeof args.symbol === "string" && args.symbol)
+        bits.push(sanitizeContent(args.symbol));
+    else if (typeof args.code === "string" && args.code)
+        bits.push(sanitizeContent(args.code.trim().replace(/\s+/gu, " ")).slice(0, 60));
+    if (typeof args.path === "string" && args.path)
+        bits.push(sanitizeContent(args.path));
+    else if (typeof args.ref === "string" && args.ref)
+        bits.push(sanitizeContent(args.ref));
+    return bits;
+}
 function editsOf(value) {
     if (value && typeof value === "object" && Array.isArray(value.edits)) {
-        return value.edits.filter((e) => !!e && typeof e === "object" && (Array.isArray(e.removed) || Array.isArray(e.added)));
+        return value.edits
+            .filter((e) => !!e && typeof e === "object")
+            .filter((e) => Array.isArray(e.removed) || Array.isArray(e.added))
+            .map((e) => {
+            const entry = {
+                truncated: e.truncated === true,
+            };
+            if (typeof e.path === "string")
+                entry.path = sanitizeContent(e.path);
+            if (typeof e.line === "number")
+                entry.line = e.line;
+            if (Array.isArray(e.removed))
+                entry.removed = e.removed.map((line) => sanitizeContent(String(line)));
+            if (Array.isArray(e.added))
+                entry.added = e.added.map((line) => sanitizeContent(String(line)));
+            return entry;
+        });
     }
     return undefined;
 }
@@ -216,37 +260,44 @@ function resultPreviewLines(value) {
     if (value === undefined || value === null)
         return undefined;
     if (typeof value === "string")
-        return value.split("\n").filter((l) => l.length > 0).slice(0, 16);
+        return value.split("\n").filter((line) => line.length > 0).slice(0, 16).map(sanitizeContent);
     if (Array.isArray(value))
         return [value.length + " value" + (value.length === 1 ? "" : "s")];
     if (typeof value === "object") {
-        return Object.entries(value).slice(0, 12).map(([k, v]) => {
-            const text = typeof v === "string" ? v : JSON.stringify(v);
-            return k + ": " + (text.length > 80 ? text.slice(0, 79) + "\u2026" : text);
-        });
+        // Shaped summary only: transport fields (tool/command/schema_version/ok)
+        // describe the wire envelope, not the answer, and a raw JSON dump of them
+        // is noise in the transcript.
+        const rows = summarizeValue(value);
+        return rows.length > 0 ? rows : undefined;
     }
-    return [String(value)];
+    return [sanitizeContent(String(value))];
 }
 /** Build the card model from the tool result's details payload. */
-export function cardModel(result, options) {
+export function cardModel(result, options, callArgs) {
     const details = (result.details && typeof result.details === "object" ? result.details : {});
     const command = typeof details.command === "string" ? details.command : "asgrep";
     const expanded = options.expanded === true;
     // In-flight partial updates carry only {command, phase}.
     if (options.isPartial && !("ok" in details)) {
-        return { command, title: [typeof details.phase === "string" ? details.phase : undefined], running: true, expanded };
+        const phase = typeof details.phase === "string" && details.phase !== "started" ? details.phase : undefined;
+        return {
+            command,
+            title: [...callTargetBits(callArgs), phase],
+            running: true,
+            expanded,
+        };
     }
     const title = [];
     if (typeof details.query === "string" && details.query)
-        title.push(JSON.stringify(details.query));
+        title.push(JSON.stringify(sanitizeContent(details.query)));
     if (typeof details.mode === "string")
-        title.push(details.mode);
+        title.push(sanitizeContent(details.mode));
     const error = details.error;
     if (result.isError || details.ok === false || error) {
         return {
             command,
             title,
-            error: typeof error?.message === "string" ? error.message : "tool failed",
+            error: typeof error?.message === "string" ? sanitizeContent(error.message) : "tool failed",
             expanded,
         };
     }
@@ -289,8 +340,8 @@ export function cardModel(result, options) {
         ? response.windows
         : undefined;
     const readLines = windows?.flatMap((w) => [
-        (w.path ?? "?") + ":" + (w.start ?? 1) + "-" + (w.end ?? ""),
-        ...(typeof w.text === "string" ? w.text.split("\n").slice(0, expanded ? 20 : 6).map((l) => "  " + l) : []),
+        sanitizeContent((w.path ?? "?") + ":" + (w.start ?? 1) + "-" + (w.end ?? "")),
+        ...(typeof w.text === "string" ? sanitizeContent(w.text).split("\n").slice(0, expanded ? 20 : 6).map((l) => "  " + l) : []),
     ]);
     // When edits carry diffs they are the interesting part of the result.
     const resultLines = hits || resultEdits ? undefined : (readLines ?? resultPreviewLines(details.result));
@@ -303,13 +354,21 @@ export function cardModel(result, options) {
         model.edits = resultEdits;
     if (resultLines)
         model.resultLines = resultLines;
+    // Warnings travel with the model-visible text; keep them visible in the TUI
+    // too, or the transcript looks clean while the answer is qualified.
+    if (Array.isArray(details.notes)) {
+        const notes = details.notes.filter((note) => typeof note === "string" && note.length > 0);
+        if (notes.length > 0)
+            model.notes = notes.map((note) => sanitizeContent(note));
+    }
     return model;
 }
 /** renderResult entrypoint: bind one card per result slot, feed it details. */
 export function renderAsgrepResult(result, options, theme, context) {
     const prev = context?.lastComponent;
     const card = prev instanceof AsgrepCard ? prev : new AsgrepCard();
-    card.set(theme, cardModel(result, options));
+    const args = context?.args;
+    card.set(theme, cardModel(result, options, args && !Array.isArray(args) ? args : undefined));
     if (context)
         context.lastComponent = card;
     return card;

package/dist/ui/present.d.ts

@@ -2,6 +2,8 @@
 export type PresentTheme = {
     bold(text: string): string;
     fg(role: string, text: string): string;
+    /** Optional: pi themes expose tool box backgrounds (toolSuccessBg/toolErrorBg/toolPendingBg). */
+    bg?(role: string, text: string): string;
 };
 export type HitLike = {
     file?: unknown;
@@ -25,47 +27,55 @@ export type EnvelopeLike = {
     backend?: unknown;
     [key: string]: unknown;
 };
-export declare const ASGREP_PROMPT_SNIPPET = "Search this repo by intent, symbol, callers, defs, or pattern (asgrep; use without being asked)";
-export declare const ASGREP_PROMPT_GUIDELINES: readonly ["For any code lookup (find a function, callers, defs, intent, or structural pattern), call asgrep immediately. Do not wait for the user to mention ast-sgrep.", "Prefer the asgrep Code Mode tool. Write JavaScript: asgrep.search(\"query\"), asgrep.defs(\"Symbol\"), asgrep.callers(\"Symbol\"), asgrep.read({ refs }). Independent lookups: Promise.all. Return a small shaped value.", "Use grep only for exact log strings, filenames, or config keys. asgrep.edit does unique string replace plus targeted reindex; oldText must match exactly once.", "If a search returns 0 hits, use suggested_next or retry with asgrep.find, asgrep.defs, or asgrep.search(query, { in: \"src\" })."];
+export declare const ASGREP_PROMPT_SNIPPET = "Code search by intent, symbol, defs, callers, pattern (asgrep; use without being asked)";
+export declare const ASGREP_PROMPT_GUIDELINES: readonly ["Any code lookup (function, def, caller, intent, pattern): call asgrep first.", "Compose in Code Mode (search/defs/read with Promise.all, return a small shaped value); grep only for exact strings or filenames. Bound with in: \"path\"; on 0 hits use suggested_next."];
 export declare function paint(theme: PresentTheme | undefined, role: string, text: string, bold?: boolean): string;
 export declare function hitLocation(hit: HitLike): string;
 export declare function hitLabel(hit: HitLike): string;
-export declare function header(theme: PresentTheme | undefined, verb: string, bits: Array<string | null | undefined>): string;
-export declare function formatSearchCall(params: {
-    query?: string;
-    mode?: string;
-    limit?: number;
-    excerptLines?: number;
-}, theme?: PresentTheme): string;
-export declare function formatIndexCall(force: boolean, theme?: PresentTheme): string;
-export declare function formatStatusCall(theme?: PresentTheme): string;
-export declare function formatEditCall(params: {
-    path?: string;
-    edits?: unknown[];
-}, theme?: PresentTheme): string;
-export declare function formatReadCall(params: {
-    path?: string;
-    ref?: string;
-    start?: number;
-    end?: number;
-}, theme?: PresentTheme): string;
-/** Model-visible text for an edit envelope: what changed, per file. */
 export declare function formatEditResult(response: EnvelopeLike, theme?: PresentTheme): string;
 /** Model-visible text for a read envelope: the window contents themselves. */
 export declare function formatReadResult(response: EnvelopeLike, theme?: PresentTheme): string;
-export declare function formatCodemodeCall(code: string, theme?: PresentTheme): string;
+/**
+ * Model-facing result text is deliberately lean: the tool call already carries
+ * the query/mode, the TUI card renders timing and backend for the human, and
+ * every token here is re-sent with the whole transcript. The first line is the
+ * only chrome: "<command>: <payload summary>".
+ */
 export declare function formatSearchResult(response: EnvelopeLike, meta: {
     command: string;
-    query?: string;
-    mode?: string;
-    activationMs?: number;
-    backend?: string;
+    excerptLines?: number;
 }, theme?: PresentTheme): string;
 export declare function formatStatusResult(response: EnvelopeLike, theme?: PresentTheme): string;
 export declare function formatIndexResult(command: string, response: EnvelopeLike, theme?: PresentTheme): string;
+/**
+ * Strip terminal control sequences and C0/C1 controls from untrusted content
+ * (tool output, code windows, paths) before this extension paints it. Without
+ * this a stray ESC in a file would sit inside our own SGR span, leaving an
+ * unterminated color and mis-measuring the row's width.
+ */
+export declare function sanitizeContent(text: string): string;
+/**
+ * Conservative display width on pi's scale: never under-counts what pi measures.
+ *
+ * Pi expands tabs to three spaces and measures grapheme clusters with East Asian
+ * Width (CJK/fullwidth/emoji = 2); lone combining marks, variation selectors and
+ * joiners are zero there. Re-deriving that table here would be a second source of
+ * truth that can drift, so this counts only what the card itself draws exactly
+ * (one cell) and rounds every other non-ASCII code point UP to two. A line that
+ * measures `width` here is therefore at most `width` in the terminal: over-counting
+ * can only leave slack before the right border, while under-counting is what pi
+ * kills the process for ("Rendered line N exceeds terminal width").
+ */
+export declare function displayWidth(text: string): number;
 /** Local stand-in so we do not take a pi-tui dependency. Over-counts wide glyphs rather than under-count. */
 export declare function visibleWidth(text: string): number;
 export declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string): string;
+/**
+ * One summary line per interesting entry of a shaped value: known shapes get a
+ * sentence ("3 windows · path:1-340"), everything else `key: value` with the
+ * value compacted. Transport fields are dropped rather than rendered.
+ */
+export declare function summarizeValue(value: unknown, limit?: number): string[];
 export declare function formatCodemodeResult(value: unknown, meta?: {
     stats?: {
         calls: number;
@@ -77,12 +87,3 @@ export declare function formatCodemodeResult(value: unknown, meta?: {
     wallMs?: number;
     backend?: string;
 }, theme?: PresentTheme): string;
-/** Minimal pi-tui Text stand-in so we do not take a TUI package dependency. */
-export declare class AsgrepText {
-    #private;
-    constructor(text?: string);
-    setText(text: string): void;
-    invalidate(): void;
-    render(width: number): string[];
-}
-export declare function presentText(formatted: string, last: unknown): AsgrepText;