ashlr-plugin 1.36.4 → 1.37.1

package/servers/_pro-token-keychain.ts

@@ -0,0 +1,149 @@
+/**
+ * OS keychain storage for ASHLR_PRO_TOKEN, with the old plaintext
+ * ~/.ashlr/env line as the fallback.
+ *
+ * macOS: `security -i` (login keychain, token on stdin). Linux: `secret-tool` (libsecret), which
+ * reads the secret from stdin. Anything else, or a backend that fails, falls
+ * back to the 0600 `export ASHLR_PRO_TOKEN=` line in ~/.ashlr/env.
+ * ASHLR_KEYCHAIN=0 turns the keychain off entirely.
+ *
+ * Token values are never logged or put in error messages.
+ */
+
+import { spawnSync } from "child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+export const KEYCHAIN_SERVICE = "ashlr-plugin";
+export const KEYCHAIN_ACCOUNT = "ASHLR_PRO_TOKEN";
+const ENV_LINE_PREFIX = "export ASHLR_PRO_TOKEN=";
+/** The one-line warning shown when the token had to go to the plaintext file. */
+export const PLAINTEXT_FALLBACK_WARNING =
+  "No usable OS keychain; ASHLR_PRO_TOKEN saved in plain text to ~/.ashlr/env (mode 0600).";
+const SAFE_TOKEN = /^[A-Za-z0-9._~+\/=:-]+$/;
+
+export interface RunResult {
+  status: number | null;
+  stdout: string;
+}
+export type Runner = (cmd: string, args: string[], input?: string) => RunResult;
+
+export interface KeychainDeps {
+  platform?: NodeJS.Platform;
+  env?: NodeJS.ProcessEnv;
+  run?: Runner;
+}
+
+const defaultRunner: Runner = (cmd, args, input) => {
+  try {
+    const r = spawnSync(cmd, args, {
+      input,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "ignore"],
+    });
+    return { status: r.error ? null : r.status, stdout: r.stdout ?? "" };
+  } catch {
+    return { status: null, stdout: "" };
+  }
+};
+
+function backend(deps: KeychainDeps): "darwin" | "linux" | null {
+  const env = deps.env ?? process.env;
+  if (env["ASHLR_KEYCHAIN"] === "0") return null;
+  const platform = deps.platform ?? process.platform;
+  if (platform === "darwin") return "darwin";
+  if (platform === "linux") return "linux";
+  return null;
+}
+
+/** Store the token in the OS keychain. True only when the backend succeeded. */
+export function keychainStore(token: string, deps: KeychainDeps = {}): boolean {
+  const run = deps.run ?? defaultRunner;
+  const b = backend(deps);
+  if (!b || !token) return false;
+  if (b === "darwin") {
+    // `security -i` reads the command from stdin, so the token never sits on
+    // argv (visible to `ps`). Its parser splits on whitespace and quotes, so
+    // only tokens of plain token characters go this way; anything else is
+    // left to the file fallback rather than risk a mangled value.
+    if (!SAFE_TOKEN.test(token)) return false;
+    return run(
+      "security",
+      ["-i"],
+      `add-generic-password -U -s ${KEYCHAIN_SERVICE} -a ${KEYCHAIN_ACCOUNT} -w ${token}\n`,
+    ).status === 0;
+  }
+  return run(
+    "secret-tool",
+    ["store", "--label=ashlr-plugin pro token", "service", KEYCHAIN_SERVICE, "account", KEYCHAIN_ACCOUNT],
+    token,
+  ).status === 0;
+}
+
+/** Read the token from the OS keychain, or null. */
+export function keychainLoad(deps: KeychainDeps = {}): string | null {
+  const run = deps.run ?? defaultRunner;
+  const b = backend(deps);
+  if (!b) return null;
+  const r = b === "darwin"
+    ? run("security", ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", KEYCHAIN_ACCOUNT, "-w"])
+    : run("secret-tool", ["lookup", "service", KEYCHAIN_SERVICE, "account", KEYCHAIN_ACCOUNT]);
+  if (r.status !== 0) return null;
+  const t = r.stdout.trim();
+  return t || null;
+}
+
+function readEnv(envFile: string): string {
+  try { return readFileSync(envFile, "utf8"); } catch { return ""; }
+}
+
+function writeEnv(envFile: string, lines: string[]): void {
+  mkdirSync(dirname(envFile), { recursive: true, mode: 0o700 });
+  const body = lines.join("\n").trim();
+  writeFileSync(envFile, body ? body + "\n" : "", { encoding: "utf8", mode: 0o600 });
+  try { chmodSync(envFile, 0o600); } catch { /* best-effort */ }
+}
+
+/** The token on the env file's `export ASHLR_PRO_TOKEN=` line, or null. */
+export function envFileToken(envFile: string): string | null {
+  for (const line of readEnv(envFile).split("\n")) {
+    if (!line.startsWith(ENV_LINE_PREFIX)) continue;
+    let v = line.slice(ENV_LINE_PREFIX.length).trim();
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+    return v || null;
+  }
+  return null;
+}
+
+function withoutTokenLine(envFile: string): string[] {
+  return readEnv(envFile).split("\n").filter((l) => !l.startsWith(ENV_LINE_PREFIX));
+}
+
+/**
+ * Save the token: keychain first (and drop any plaintext line), otherwise the
+ * plaintext env line. Returns where it went.
+ */
+export function storeProToken(token: string, envFile: string, deps: KeychainDeps = {}): "keychain" | "file" {
+  if (keychainStore(token, deps) && keychainLoad(deps) === token) {
+    if (existsSync(envFile)) writeEnv(envFile, withoutTokenLine(envFile));
+    return "keychain";
+  }
+  const lines = withoutTokenLine(envFile);
+  lines.push(`${ENV_LINE_PREFIX}${token}`);
+  writeEnv(envFile, lines);
+  return "file";
+}
+
+/**
+ * One-time migration: move a plaintext env-file token into the keychain. The
+ * line is removed only after the keychain reads the same value back, so a
+ * failed or partial store never loses the token.
+ */
+export function migrateEnvFileToken(envFile: string, deps: KeychainDeps = {}): "migrated" | "none" | "kept" {
+  const token = envFileToken(envFile);
+  if (!token) return "none";
+  if (!keychainStore(token, deps) || keychainLoad(deps) !== token) return "kept";
+  writeEnv(envFile, withoutTokenLine(envFile));
+  return "migrated";
+}

package/servers/_redact-keys.ts

@@ -0,0 +1,75 @@
+/**
+ * Strip key material from text that came back from a model endpoint before it
+ * reaches an error message, a log line or stderr.
+ *
+ * A gateway that rejects a credential may quote it back in its error body,
+ * whole or in part. Any run of 8 or more characters that also appears inside
+ * a configured key is replaced with "[redacted]".
+ */
+
+/** Environment variables that can hold key material for a model endpoint. */
+export const KEY_ENV_VARS = [
+	"ASHLR_LLM_KEY",
+	"ANTHROPIC_API_KEY",
+	"OPENAI_API_KEY",
+	"ASHLR_EMBED_KEY",
+	"ASHLR_PRO_TOKEN",
+	"PHANTOM_PROXY_TOKEN",
+] as const;
+
+const WINDOW = 8;
+
+/**
+ * Redact every run of `WINDOW` or more characters of `text` that also occurs
+ * inside one of the configured key values or one of `extra`.
+ */
+export function redactKnownKeys(
+	text: string,
+	extra: Array<string | null | undefined> = [],
+	env: NodeJS.ProcessEnv = process.env,
+): string {
+	const secrets = [...KEY_ENV_VARS.map((v) => env[v]), ...extra].filter(
+		(s): s is string => typeof s === "string" && s.trim().length >= WINDOW,
+	);
+	if (secrets.length === 0 || text.length < WINDOW) return text;
+
+	const windows = new Set<string>();
+	for (const s of secrets) {
+		for (let i = 0; i + WINDOW <= s.length; i++)
+			windows.add(s.slice(i, i + WINDOW));
+	}
+
+	const covered = new Uint8Array(text.length);
+	let any = false;
+	for (let i = 0; i + WINDOW <= text.length; i++) {
+		if (windows.has(text.slice(i, i + WINDOW))) {
+			covered.fill(1, i, i + WINDOW);
+			any = true;
+		}
+	}
+	if (!any) return text;
+
+	let out = "";
+	for (let i = 0; i < text.length; ) {
+		if (covered[i]) {
+			while (i < text.length && covered[i]) i++;
+			out += "[redacted]";
+		} else {
+			out += text[i++];
+		}
+	}
+	return out;
+}
+
+/**
+ * Read a failed response's body for an error message: bounded, redacted, then
+ * cut to `max` characters.
+ */
+export async function redactedBody(
+	res: Response,
+	extra: Array<string | null | undefined> = [],
+	max = 200,
+): Promise<string> {
+	const raw = await res.text().catch(() => "");
+	return redactKnownKeys(raw.slice(0, 4096), extra).slice(0, max);
+}

package/servers/_rg-text.ts

@@ -0,0 +1,111 @@
+/**
+ * _rg-text.ts — the ripgrep fallback for ashlr__grep, as plain text.
+ *
+ * The fallback used to run `rg --json` and cut the JSON stream to its first
+ * 2000 and last 1000 characters. JSON event lines are roughly three times the
+ * size of `path:line:text`, so the cut kept only a handful of matches (often
+ * as a half-open JSON object), and savings were counted against the JSON size
+ * rather than what a plain grep would have returned.
+ *
+ * Here ripgrep prints `path:line:text`; if that exceeds the budget, whole
+ * lines are kept from the head and tail and the omitted count is stated.
+ */
+
+/** ripgrep arguments for compact `path:line:text` output. */
+export function rgTextArgs(pattern: string, searchRoot: string): string[] {
+  return [
+    "-n",
+    "--no-heading",
+    "--color",
+    "never",
+    // Minified bundles and lockfiles can put megabytes on one line.
+    "--max-columns",
+    "300",
+    "--max-columns-preview",
+    "--",
+    pattern,
+    searchRoot,
+  ];
+}
+
+export const RG_TEXT_BUDGET = 4000;
+const HEAD_BUDGET = 2600;
+const TAIL_BUDGET = 1000;
+
+/**
+ * Why ripgrep stopped before finishing, or null when it ran to completion.
+ *
+ * A killed search still leaves its partial stdout behind: spawnSync keeps what
+ * it buffered on ENOBUFS and on its timeout, and runWithTimeout keeps the
+ * first 10 MB. Counting that as the whole result made the header state a
+ * total that was only how far ripgrep got, and the last line was usually cut
+ * mid-path.
+ */
+export function rgStopReason(res: {
+  error?: unknown;
+  signal?: string | null;
+  timedOut?: boolean;
+  stderr?: string | null;
+}): string | null {
+  const code = (res.error as { code?: unknown } | undefined)?.code;
+  if (res.timedOut || code === "ETIMEDOUT") return "it timed out";
+  if (code === "ENOBUFS" || /stdout capped at/.test(res.stderr ?? "")) return "its output passed the size cap";
+  if (res.signal) return `it was killed (${res.signal})`;
+  return null;
+}
+
+/**
+ * Keep `raw` whole when it fits the budget; otherwise keep whole lines from
+ * the head and tail and say how many matching lines were omitted.
+ *
+ * `stoppedEarly` (from `rgStopReason`) marks `raw` as a prefix of the real
+ * result: the cut-off last line is dropped and the counts are stated as lower
+ * bounds, even when what is left fits the budget.
+ */
+export function truncateRgText(raw: string, stoppedEarly: string | null = null): string {
+  if (stoppedEarly) {
+    const complete = raw.endsWith("\n") ? raw : raw.slice(0, raw.lastIndexOf("\n") + 1);
+    const lines = complete.replace(/\n$/, "").split("\n").filter((l) => l.length > 0);
+    const note = `[ashlr__grep] ripgrep stopped early because ${stoppedEarly}; at least ${lines.length} matching lines in ${countFiles(lines)} files. Narrow the pattern or cwd.`;
+    if (complete.length <= RG_TEXT_BUDGET) return lines.length > 0 ? `${note}\n${lines.join("\n")}` : note;
+    return cut(lines, note);
+  }
+  if (raw.length <= RG_TEXT_BUDGET) return raw;
+  const lines = raw.replace(/\n$/, "").split("\n");
+  return cut(
+    lines,
+    `[ashlr__grep] ${lines.length} matching lines in ${countFiles(lines)} files; showing {shown}. Narrow the pattern or cwd to see the rest.`,
+  );
+}
+
+function countFiles(lines: readonly string[]): number {
+  const files = new Set<string>();
+  for (const line of lines) {
+    const m = /^(.*?):\d+:/.exec(line);
+    if (m) files.add(m[1]!);
+  }
+  return files.size;
+}
+
+function cut(lines: readonly string[], header: string): string {
+  const head: string[] = [];
+  let used = 0;
+  for (const line of lines) {
+    if (used + line.length + 1 > HEAD_BUDGET && head.length > 0) break;
+    head.push(line);
+    used += line.length + 1;
+  }
+  const tail: string[] = [];
+  used = 0;
+  for (let i = lines.length - 1; i >= head.length; i--) {
+    const line = lines[i]!;
+    if (used + line.length + 1 > TAIL_BUDGET) break;
+    tail.unshift(line);
+    used += line.length + 1;
+  }
+  const omitted = lines.length - head.length - tail.length;
+  const parts = [header.replace("{shown}", String(head.length + tail.length)), ...head];
+  if (omitted > 0) parts.push(`[... ${omitted} matching lines omitted ...]`);
+  parts.push(...tail);
+  return parts.join("\n");
+}

package/servers/_router.ts

@@ -24,7 +24,24 @@
 
 import { listTools, runStandalone } from "./_tool-base";
 import { detectMcpHost } from "./_mcp-host";
+import { adoptLaunchCwd } from "./_cwd-clamp";
 import "./_router-handlers";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+/** Reported in MCP `serverInfo` and the startup banner; ASHLR_VERSION overrides. */
+function pluginVersion(): string {
+  if (process.env.ASHLR_VERSION) return process.env.ASHLR_VERSION;
+  try {
+    const pkg = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")) as { version?: unknown };
+    if (typeof pkg.version === "string" && pkg.version) return pkg.version;
+  } catch {
+    // A partial copy of the plugin without package.json: report "dev".
+  }
+  return "dev";
+}
+
+const VERSION = pluginVersion();
 
 // ---------------------------------------------------------------------------
 // Entry point
@@ -38,13 +55,14 @@ async function main(): Promise<void> {
     process.exit(0);
   }
 
+  adoptLaunchCwd();
   const toolCount = listTools().length;
   const host = detectMcpHost();
   process.stderr.write(
-    `[ashlr-router] starting · ${toolCount} tools registered · version=${process.env.ASHLR_VERSION ?? "dev"} · host=${host}\n`,
+    `[ashlr-router] starting · ${toolCount} tools registered · version=${VERSION} · host=${host}\n`,
   );
 
-  await runStandalone("ashlr-router", process.env.ASHLR_VERSION ?? "dev");
+  await runStandalone("ashlr-router", VERSION);
 }
 
 if (import.meta.main) {

package/servers/_run-with-timeout.ts

@@ -12,6 +12,12 @@
  *   - SIGTERM first, 250 ms grace, then SIGKILL.
  *   - Never throws on subprocess error — returns `exitCode: -1` with the error
  *     surfaced in `stderr`.
+ *   - Always settles. `close` is the normal path, but it waits for every stdio
+ *     pipe to end and has been seen not to fire at all (ashlr-plugin main run
+ *     39195707592, macOS: a `echo` call outlived its own 5 s timeout and hit the
+ *     15 s test timeout). So `exit` starts a short drain window after which we
+ *     resolve with what was collected, and a hard deadline slightly past the
+ *     kill grace resolves a run that never reports `exit` or `close`.
  *   - Stdout and stderr are each capped at 10 MB to prevent OOM on runaway
  *     output; excess bytes are silently dropped (the cap notice appears in
  *     stderr so callers can detect truncation).
@@ -19,6 +25,11 @@
 
 import { spawn } from "child_process";
 
+/** After `exit`, how long to wait for `close` (pipes drained) before settling. */
+const EXIT_DRAIN_MS = 1_000;
+/** Past the timeout and the 250 ms SIGKILL grace, how long before we give up. */
+const HARD_DEADLINE_SLACK_MS = 2_000;
+
 /** Maximum bytes buffered per stream before we stop accumulating. */
 const STREAM_CAP = 10 * 1024 * 1024; // 10 MB
 
@@ -30,6 +41,13 @@ export interface RunWithTimeoutOptions {
   timeoutMs: number;
   /** Optional stdin to feed the child process (UTF-8 string). */
   input?: string;
+  /**
+   * Optional abort signal. Aborting kills the process group exactly like a
+   * timeout does (and reports `timedOut: true`). Callers that stop waiting
+   * early, such as a total cap racing several probes, use this so the child
+   * and its descendants do not outlive the caller.
+   */
+  signal?: AbortSignal;
 }
 
 export interface RunWithTimeoutResult {
@@ -115,7 +133,10 @@ export function runWithTimeout(opts: RunWithTimeoutOptions): Promise<RunWithTime
     }
 
     /** Kill the process tree and set timedOut flag. */
+    let killed = false;
     function killTree(): void {
+      if (killed) return;
+      killed = true;
       timedOut = true;
       if (isWin) {
         // taskkill /T cascades through child processes on Windows.
@@ -148,26 +169,49 @@ export function runWithTimeout(opts: RunWithTimeoutOptions): Promise<RunWithTime
       }
     }
 
+    let settled = false;
+    let drainTimer: ReturnType<typeof setTimeout> | undefined;
+    let exitCode: number | null = null;
+
     const timer = setTimeout(killTree, opts.timeoutMs);
+    const onAbort = (): void => killTree();
+    if (opts.signal) {
+      if (opts.signal.aborted) killTree();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const deadline = setTimeout(
+      () => settle(exitCode, "hard deadline"),
+      opts.timeoutMs + 250 + HARD_DEADLINE_SLACK_MS,
+    );
 
-    child.on("close", (code) => {
+    /** Resolve exactly once and clear every timer. */
+    function settle(code: number | null, note?: string, spawnErr?: Error): void {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
+      clearTimeout(deadline);
+      opts.signal?.removeEventListener("abort", onAbort);
+      if (drainTimer) clearTimeout(drainTimer);
+      let err = stderr;
+      if (spawnErr) err += `\n[spawn error: ${spawnErr.message}]`;
+      else if (note && code === null) err += `\n[_run-with-timeout: settled by ${note}]`;
       resolveP({
         stdout,
-        stderr,
-        exitCode: code ?? (timedOut ? -1 : -1),
+        stderr: err,
+        exitCode: spawnErr ? -1 : (code ?? -1),
         timedOut,
       });
-    });
+    }
 
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      resolveP({
-        stdout,
-        stderr: stderr + `\n[spawn error: ${err.message}]`,
-        exitCode: -1,
-        timedOut,
-      });
+    child.on("exit", (code) => {
+      exitCode = code;
+      // `close` normally follows within milliseconds. If it does not (a pipe
+      // held open, or a lost event), settle with what we have.
+      drainTimer = setTimeout(() => settle(code, "exit drain"), EXIT_DRAIN_MS);
     });
+
+    child.on("close", (code) => settle(code ?? exitCode));
+
+    child.on("error", (err) => settle(null, undefined, err));
   });
 }

package/servers/_test-watch.ts

@@ -34,6 +34,7 @@ import { homedir } from "os";
 import { join, sep } from "path";
 import { randomBytes } from "crypto";
 import { registerExternalSessions, type ExternalSession } from "./bash-server";
+import { pidAlive } from "./_pid-alive";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -180,16 +181,6 @@ export async function reloadWatchSessions(): Promise<void> {
   }
 }
 
-function pidAlive(pid: number): boolean {
-  if (!pid || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // ---------------------------------------------------------------------------
 // File watching
 // ---------------------------------------------------------------------------

package/servers/_token-measure.ts

@@ -16,7 +16,9 @@ import { createHash } from "crypto";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+import { anthropicBaseUrl } from "./_base-urls.ts";
 import { estimateTokensFromString } from "@ashlr/core-efficiency";
+import { safeKeyedFetch } from "./_gateway-target.ts";
 
 export type MeasurementMode = "estimate" | "measured";
 
@@ -126,7 +128,7 @@ export async function measureTokens(text: string): Promise<number | null> {
   }
 
   try {
-    const res = await fetch("https://api.anthropic.com/v1/messages", {
+    const res = await safeKeyedFetch(`${anthropicBaseUrl()}/v1/messages`, {
       method: "POST",
       signal: AbortSignal.timeout(5_000),
       headers: {

package/servers/_tool-base.ts

@@ -27,6 +27,7 @@ import { writeCrashDump } from "./_crash-dump";
 import { openContextDb, type ContextDb } from "./_embedding-cache";
 import { recordTelemetryEvent, isTelemetryEnabled } from "./_telemetry";
 import { detectMcpHost, type McpHost } from "./_mcp-host";
+import { isPathRefusal } from "./_cwd-clamp";
 
 /** Protocol-native guidance applies to every MCP host without host-specific hooks. */
 export const MCP_EFFICIENCY_INSTRUCTIONS = [
@@ -218,6 +219,11 @@ export async function runStandalone(
         });
       }
 
+      // Path refusals come back from many handlers as plain text; flag them so
+      // hosts and agents see a failed call, not a successful read of a message.
+      const first = (result as { content?: Array<{ text?: unknown }> })?.content?.[0];
+      if (first && isPathRefusal(first.text)) (result as { isError?: boolean }).isError = true;
+
       return result as { content: unknown[] };
     } catch (err) {
       // Per-handler crash isolation: one handler's throw must not take the

package/servers/bash-server.ts

@@ -60,6 +60,7 @@ import { summarizeIfLarge, PROMPTS, confidenceBadge, confidenceTier } from "./_s
 import { recordSaving as recordSavingCore } from "./_stats";
 import { logEvent } from "./_events";
 import { clampToCwd } from "./_cwd-clamp";
+import { pidAlive } from "./_pid-alive";
 
 // Bash always records under the "ashlr__bash" tool bucket.
 async function recordSaving(rawBytes: number, compactBytes: number): Promise<number> {
@@ -587,16 +588,6 @@ interface PersistedSession {
   cumulativeBytes: number;
 }
 
-function pidAlive(pid: number): boolean {
-  if (!pid || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 async function persistSessions(): Promise<void> {
   await mkdir(dirname(SESSIONS_PATH), { recursive: true });
   const payload: PersistedSession[] = [];

package/servers/edit-server.ts

@@ -37,14 +37,27 @@ export interface EditResult {
 
 const FUZZY_SIZE_LIMIT = 2 * 1024 * 1024; // 2 MB
 
+const TINY_EDIT_CHARS = 120;
+
 function summarizeEdit(
   relPath: string,
   search: string,
   replace: string,
   matchCount: number,
   strict: boolean,
+  /** Echo the first line of what was removed and added. Only worth its tokens when the match was not exact. */
+  echo = false,
 ): string {
   const first = (s: string) => s.split("\n")[0]?.slice(0, 72) ?? "";
+  // Tiny edits: the removed/added detail lines cost more than the edit itself,
+  // and the caller already knows what it sent. Return the header only.
+  // Same for an exact, unique match: the hunk applied exactly as sent, so the
+  // echo is the caller's own text played back. Fuzzy matches and replace-all
+  // edits keep the detail lines.
+  // `echo` (fuzzy) always keeps them: the caller cannot know what was replaced.
+  if (!echo && (search.length + replace.length < TINY_EDIT_CHARS || (strict && matchCount === 1))) {
+    return `[ashlr__edit] ${relPath}  ·  ${strict ? "1 of " + matchCount : matchCount + " of " + matchCount} hunks applied`;
+  }
   return [
     `[ashlr__edit] ${relPath}  ·  ${strict ? "1 of " + matchCount : matchCount + " of " + matchCount} hunks applied`,
     `  - removed (${estimateTokensFromString(search)} tok):  ${first(search)}${search.length > 72 ? "…" : ""}`,
@@ -105,7 +118,9 @@ export async function ashlrEdit(input: EditArgs): Promise<EditResult> {
         refreshGenomeAfterEdit(abs, original, updated).catch(() => {});
 
         const baseBytes = search.length + replace.length;
-        const compactSummary = summarizeEdit(relPath, search, replace, 1, true);
+        // Echo the file text the fuzzy match actually replaced, not the caller's search.
+        const matched = original.slice(fuzzyMatch.start, fuzzyMatch.end);
+        const compactSummary = summarizeEdit(relPath, matched, replace, 1, true, true);
         await recordSaving(baseBytes, compactSummary.length, "ashlr__edit");
 
         appendEdit({ relPath, hunksApplied: 1 });
@@ -135,6 +150,14 @@ export async function ashlrEdit(input: EditArgs): Promise<EditResult> {
     throw new Error(`ashlr__edit: search string not found in ${relPath}`);
   }
 
+  // Strict uniqueness must count overlapping occurrences too: "}\n}" occurs
+  // twice in "}\n}\n}" even though a non-overlapping scan finds it once.
+  if (strict && count === 1 && original.indexOf(search, original.indexOf(search) + 1) !== -1) {
+    let overlapping = 0;
+    for (let i = original.indexOf(search); i !== -1; i = original.indexOf(search, i + 1)) overlapping++;
+    count = overlapping;
+  }
+
   if (strict && count > 1) {
     throw new Error(
       `ashlr__edit: search string matched ${count} times in ${relPath}; pass strict:false to replace all, or widen the context to a unique span.`,

package/servers/efficiency-server.ts

@@ -46,6 +46,7 @@ import {
   type SessionBucket,
 } from "./_stats";
 import { clampToCwd } from "./_cwd-clamp";
+import { rgStopReason, rgTextArgs, truncateRgText } from "./_rg-text";
 import { getEmbeddingCache } from "./_tool-base";
 import { embed, upsertCorpus } from "./_embedding-model";
 import { populateGenomeEmbeddings } from "./_genome-embed-populator";
@@ -809,11 +810,13 @@ export async function ashlrGrep(input: { pattern: string; cwd?: string; bypassSu
 
   const res = await runWithTimeout({
     command: rgBin,
-    args: ["--json", "-n", input.pattern, cwd],
+    args: rgTextArgs(input.pattern, cwd),
     timeoutMs: 15_000,
   });
+  // `raw` is what a plain grep would have returned, so savings are counted
+  // against that, not against a verbose wire format.
   const raw = res.stdout ?? "";
-  const truncated = raw.length > 4000 ? raw.slice(0, 2000) + "\n\n[... truncated ...]\n\n" + raw.slice(-1000) : raw;
+  const truncated = truncateRgText(raw, rgStopReason(res));
   const summarized = await summarizeIfLarge(truncated, {
     toolName: "ashlr__grep",
     systemPrompt: PROMPTS.grep,
@@ -1006,6 +1009,8 @@ export async function ashlrEdit(input: EditArgs): Promise<EditResult> {
   return { text: compactSummary, hunksApplied };
 }
 
+const TINY_EDIT_CHARS = 120;
+
 function summarizeEdit(
   relPath: string,
   search: string,
@@ -1014,6 +1019,11 @@ function summarizeEdit(
   strict: boolean,
 ): string {
   const first = (s: string) => s.split("\n")[0]?.slice(0, 72) ?? "";
+  // Tiny edits: the removed/added detail lines cost more than the edit itself,
+  // and the caller already knows what it sent. Return the header only.
+  if (search.length + replace.length < TINY_EDIT_CHARS) {
+    return `[ashlr__edit] ${relPath}  ·  ${strict ? "1 of " + matchCount : matchCount + " of " + matchCount} hunks applied`;
+  }
   return [
     `[ashlr__edit] ${relPath}  ·  ${strict ? "1 of " + matchCount : matchCount + " of " + matchCount} hunks applied`,
     `  - removed (${estimateTokensFromString(search)} tok):  ${first(search)}${search.length > 72 ? "…" : ""}`,