@oh-my-pi/pi-coding-agent 17.1.1 → 17.1.3

package/dist/types/web/search/query.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Structured web-search query parsing.
+ *
+ * Agents habitually embed Google-style directives in search queries —
+ * `site:`, `before:`/`after:`, `inurl:`, `filetype:`, quoted phrases, `OR`
+ * groups, `-exclusions` — regardless of whether the backing engine parses
+ * them. This module turns a raw query into a {@link StructuredQuery} so each
+ * provider can:
+ *
+ * 1. map constraints onto native API parameters where they exist (Perplexity
+ *    `search_domain_filter`, Tavily `include_domains`, Exa date bounds, …),
+ * 2. rebuild a query string containing only the syntax the target engine
+ *    understands ({@link formatQuery}), and
+ * 3. post-filter returned sources leniently ({@link applyQueryConstraints}):
+ *    a constraint dimension that would eliminate every result is dropped and
+ *    reported rather than returning nothing.
+ */
+import type { SearchSource } from "./types.js";
+/** One free-text token of the query (everything that is not a recognized directive). */
+export interface QueryTerm {
+    /** Term text without quotes or operator prefixes. */
+    text: string;
+    /** Quoted exact phrase (`"like this"`) or verbatim-required (`+term`). */
+    phrase?: boolean;
+    /** Excluded via `-term` or `NOT term`. */
+    negated?: boolean;
+    /**
+     * OR-group id. Terms sharing an id are alternatives (`a OR b`); terms
+     * without a group are implicitly AND-ed. Groups are always contiguous
+     * runs in {@link StructuredQuery.terms}.
+     */
+    group?: number;
+}
+/**
+ * A raw query decomposed into free text plus every recognized constraint.
+ *
+ * All list fields are always present (possibly empty) so consumers can map
+ * over them without null checks. Values are stored as typed by the user
+ * except for normalization noted per field.
+ */
+export interface StructuredQuery {
+    /** Original query string, verbatim. */
+    raw: string;
+    /**
+     * Free-text remainder with all recognized directives removed; phrases
+     * stay quoted, exclusions keep `-`, OR groups keep `OR`. Empty when the
+     * query was directives only — use {@link formatQuery} for a never-empty
+     * engine query.
+     */
+    text: string;
+    /** Ordered free-text terms (phrases, exclusions, OR groups). */
+    terms: QueryTerm[];
+    /** `site:`/`domain:`/`host:` includes — any-of. Lowercased, scheme stripped, may carry a path (`github.com/anthropics`). */
+    sites: string[];
+    /** `-site:` exclusions, same normalization as {@link sites}. */
+    excludedSites: string[];
+    /** `inurl:`/`url:`/`allinurl:` substrings — all must appear in the URL. */
+    inUrl: string[];
+    /** `-inurl:` substrings — none may appear in the URL. */
+    excludedInUrl: string[];
+    /** `intitle:`/`title:`/`allintitle:` substrings — all must appear in the title. */
+    inTitle: string[];
+    /** `-intitle:` substrings — none may appear in the title. */
+    excludedInTitle: string[];
+    /** `intext:`/`inbody:`/`inanchor:`/`allintext:` body substrings. Not post-filterable (snippets are partial); query-building only. */
+    inText: string[];
+    /** `-intext:` body exclusions. Query-building only. */
+    excludedInText: string[];
+    /** `filetype:`/`ext:` extensions — any-of. Lowercased, no leading dot. */
+    filetypes: string[];
+    /** `-filetype:`/`-ext:` extensions — none may match. */
+    excludedFiletypes: string[];
+    /** Inclusive lower publish-date bound from `after:`/`since:`, ISO `YYYY-MM-DD`. */
+    after?: string;
+    /** Exclusive upper publish-date bound from `before:`/`until:`, ISO `YYYY-MM-DD`. */
+    before?: string;
+    /** Language code from `lang:`/`language:`, lowercased (e.g. `en`, `en-us`). */
+    lang?: string;
+    /** True when any directive or boolean operator was recognized. */
+    hasDirectives: boolean;
+    /** True when any post-filterable constraint is set (sites, url/title terms, filetypes, date bounds). */
+    hasConstraints: boolean;
+}
+/**
+ * Query-syntax capabilities of a target engine, used by {@link formatQuery}
+ * to decide which parsed features are re-emitted as query text. Everything
+ * defaults to `false`: the zero-value produces plain keywords suitable for
+ * natural-language APIs.
+ */
+export interface QuerySyntax {
+    /** Emit `"quoted phrases"`. */
+    phrases?: boolean;
+    /** Emit `-term` exclusions (negated terms are dropped otherwise). */
+    negation?: boolean;
+    /** Emit `OR` between alternatives (groups are flattened to keywords otherwise). */
+    or?: boolean;
+    /** Emit `site:`/`-site:`. */
+    site?: boolean;
+    /** Emit `inurl:`/`-inurl:`. */
+    inUrl?: boolean;
+    /** Emit `intitle:`/`-intitle:`. */
+    inTitle?: boolean;
+    /** Emit `intext:`/`-intext:`. */
+    inText?: boolean;
+    /** Emit `filetype:`/`-filetype:`. */
+    filetype?: boolean;
+    /** Emit `before:`/`after:` ISO date bounds. */
+    dateRange?: boolean;
+}
+/** Full Google-style syntax: engines that parse the classic operator set (Google, Startpage, Ecosia, Brave, Kagi, Mojeek, SearXNG…). */
+export declare const GOOGLE_QUERY_SYNTAX: QuerySyntax;
+/** Result of {@link applyQueryConstraints}. */
+export interface ConstraintFilterResult {
+    /** Sources surviving the lenient filter — never empty when the input was non-empty. */
+    sources: SearchSource[];
+    /**
+     * Directive renderings (`site:arxiv.org`, `before:2024-01-01`, …) of the
+     * constraint dimensions that matched zero sources and were therefore
+     * relaxed instead of enforced.
+     */
+    dropped: string[];
+}
+/**
+ * Parse a `before:`/`after:` value into ISO `YYYY-MM-DD`.
+ * Accepts `YYYY`, `YYYY-MM`, `YYYY-MM-DD` (also `/` and `.` separators) and
+ * `MM/DD/YYYY` (day-first assumed when the first field exceeds 12).
+ * Bare years/months resolve to the first day of the period, matching
+ * Google's `after:2024` ≙ `after:2024-01-01` semantics.
+ */
+export declare function parseDateValue(value: string): string | undefined;
+/**
+ * Parse a raw query into a {@link StructuredQuery}.
+ *
+ * Lenient by construction: unknown `name:value` tokens (URLs, `C:\paths`,
+ * `TS2345:`, jargon) stay in the free text verbatim, and a directive with an
+ * unparseable value (`before:someday`) degrades to a plain term instead of
+ * being dropped.
+ */
+export declare function parseSearchQuery(raw: string): StructuredQuery;
+/**
+ * Rebuild a query string for an engine with the given {@link QuerySyntax}.
+ *
+ * Constraints whose syntax the engine lacks are omitted (the caller maps
+ * them onto API parameters or relies on {@link applyQueryConstraints}).
+ * Never returns an empty string for a non-empty input: a directives-only
+ * query falls back to the constraint values as keywords, then to `raw` — an
+ * engine searching *something* beats an empty-query error.
+ */
+export declare function formatQuery(q: StructuredQuery, syntax?: QuerySyntax): string;
+/**
+ * Build the engine query for a credential-free HTML engine (Google,
+ * Startpage, DuckDuckGo, Ecosia, Mojeek, SearXNG, and the Public Web
+ * fan-out over them).
+ *
+ * Canonicalizes directives via {@link formatQuery} with the engine's
+ * {@link QuerySyntax} (default: full Google syntax), after demoting the
+ * operators that zero-match across the scraper set: engines only match
+ * `site:` against a bare domain (a path yields zero results everywhere),
+ * and DuckDuckGo ignores `inurl:` entirely — so either operator silently
+ * empties the result set. The raw URL as a plain term matches fine, so
+ * bare-domain `site:` filters are kept while path-carrying `site:` and all
+ * `inurl:` values become plain keywords; the demotion is structural (before
+ * formatting), so OR-grouped and quoted directives are covered. Negated
+ * forms (`-site:`, `-inurl:`) pass through untouched — demoting them would
+ * invert an exclusion into a search term; the pipeline post-filter
+ * ({@link applyQueryConstraints}) enforces every demoted or unsupported
+ * constraint on the returned sources. Directive-free queries pass through
+ * byte-identical.
+ */
+export declare function formatScraperQuery(query: string, parsedQuery?: StructuredQuery, syntax?: QuerySyntax): string;
+/**
+ * `site:` matcher: exact host or subdomain of `site`; when `site` carries a
+ * path (`github.com/anthropics`), the URL path must start with it.
+ */
+export declare function matchesSite(url: string, site: string): boolean;
+/**
+ * Strict per-source constraint check: every filterable dimension of `q` must
+ * pass. Sources without a resolvable date pass date bounds (a missing date
+ * is not proof of violation). For custom provider flows; the standard path
+ * is {@link applyQueryConstraints}.
+ */
+export declare function matchesQueryConstraints(source: SearchSource, q: StructuredQuery): boolean;
+/**
+ * Lenient post-filter: applies each constraint dimension of `q` in turn,
+ * skipping (and reporting) any dimension that would eliminate every
+ * remaining source. Guarantees a non-empty result for a non-empty input, so
+ * a mis-scoped directive degrades to unfiltered results plus a note instead
+ * of a dead search.
+ */
+export declare function applyQueryConstraints(sources: readonly SearchSource[], q: StructuredQuery): ConstraintFilterResult;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.1.1",
+	"version": "17.1.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -53,17 +53,17 @@
 		"@babel/parser": "^7.29.7",
 		"@babel/traverse": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "17.1.1",
-		"@oh-my-pi/omp-stats": "17.1.1",
-		"@oh-my-pi/pi-agent-core": "17.1.1",
-		"@oh-my-pi/pi-ai": "17.1.1",
-		"@oh-my-pi/pi-catalog": "17.1.1",
-		"@oh-my-pi/pi-mnemopi": "17.1.1",
-		"@oh-my-pi/pi-natives": "17.1.1",
-		"@oh-my-pi/pi-tui": "17.1.1",
-		"@oh-my-pi/pi-utils": "17.1.1",
-		"@oh-my-pi/pi-wire": "17.1.1",
-		"@oh-my-pi/snapcompact": "17.1.1",
+		"@oh-my-pi/hashline": "17.1.3",
+		"@oh-my-pi/omp-stats": "17.1.3",
+		"@oh-my-pi/pi-agent-core": "17.1.3",
+		"@oh-my-pi/pi-ai": "17.1.3",
+		"@oh-my-pi/pi-catalog": "17.1.3",
+		"@oh-my-pi/pi-mnemopi": "17.1.3",
+		"@oh-my-pi/pi-natives": "17.1.3",
+		"@oh-my-pi/pi-tui": "17.1.3",
+		"@oh-my-pi/pi-utils": "17.1.3",
+		"@oh-my-pi/pi-wire": "17.1.3",
+		"@oh-my-pi/snapcompact": "17.1.3",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/cli/bench-cli.ts

@@ -76,6 +76,7 @@ export interface BenchCommandArgs {
 
 export interface BenchModelRegistry {
 	getAll(): Model<Api>[];
+	getAvailable(): Model<Api>[];
 	getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
 	resolver(model: ApiKeyResolverModel, sessionId?: string): ApiKeyResolver;
 	hasConfiguredAuth?(model: Model<Api>): boolean;
@@ -693,7 +694,17 @@ function resolveBenchModels(
 	const resolved: BenchTarget[] = [];
 	const errors: string[] = [];
 	for (const selector of selectors) {
-		const result = resolveCliModel({ cliModel: selector, modelRegistry, settings, preferences });
+		// Bench intentionally resolves against the full catalog first, then applies
+		// its own exact-id credential fallback below. Using the CLI resolver's
+		// authenticated default here would silently redirect non-equivalent bare
+		// ids and suppress the warning for equivalent cross-provider models.
+		const result = resolveCliModel({
+			cliModel: selector,
+			modelRegistry,
+			availableModels: modelRegistry.getAll(),
+			settings,
+			preferences,
+		});
 		if (result.error) {
 			errors.push(`${selector}: ${result.error}`);
 			continue;

package/src/cli/web-search-cli.ts

@@ -130,8 +130,15 @@ ${chalk.bold("Options:")}
   --compact           Render condensed output
   -h, --help          Show this help
 
+${chalk.bold("Query directives:")}
+  site:/-site:  after:/before: (YYYY-MM-DD)  inurl:  intitle:  filetype:
+  "exact phrase"  -term  OR
+  Mapped to native provider filters where available, otherwise applied as a
+  lenient post-filter (a constraint matching nothing is relaxed, not fatal).
+
 ${chalk.bold("Examples:")}
   ${APP_NAME} q --provider=exa "what's the color of the sky"
   ${APP_NAME} q --provider=brave --recency=week "latest TypeScript 5.7 changes"
+  ${APP_NAME} q 'transformer scaling site:arxiv.org after:2024 -site:reddit.com'
 `);
 }

package/src/config/model-resolver.ts

@@ -466,7 +466,7 @@ export interface ModelMatchPreferences {
 }
 
 export type ModelLookupRegistry = Pick<ModelRegistry, "getAvailable">;
-type CliModelRegistry = Pick<ModelRegistry, "getAll">;
+type CliModelRegistry = Pick<ModelRegistry, "getAll" | "getAvailable">;
 type InitialModelRegistry = Pick<ModelRegistry, "getAvailable" | "find">;
 type RestorableModelRegistry = Pick<ModelRegistry, "getAvailable" | "find" | "getApiKey">;
 
@@ -1601,6 +1601,7 @@ function findExactCliModel(
 	selector: string,
 	allModels: Model<Api>[],
 	availableModels: Model<Api>[],
+	options?: { catalogFallback?: boolean },
 ): Model<Api> | undefined {
 	// Explicit provider/id references stay authoritative against the full catalog.
 	const referenced = findExactModelReferenceMatch(selector, allModels);
@@ -1615,6 +1616,13 @@ function findExactCliModel(
 		model.id.toLowerCase() === lower || formatModelString(model).toLowerCase() === lower;
 	const preferred = availableModels.find(isFlatMatch);
 	if (preferred) return preferred;
+	// The unauthenticated catalog fallback is a weak match: a bare id like
+	// `default` collides with the bundled `cursor/default` model, which must not
+	// shadow a configured `modelRoles.default` role the user can actually run.
+	// Callers resolving a possible role name pass `catalogFallback: false` so the
+	// role gets a chance first; the deferred fuzzy fallback below still recovers
+	// the catalog id when no role matches.
+	if (options?.catalogFallback === false) return undefined;
 	return availableModels === allModels ? undefined : allModels.find(isFlatMatch);
 }
 
@@ -1635,13 +1643,16 @@ export interface ResolveCliModelResult {
 /**
  * Resolve a single model from CLI flags.
  *
- * Exact model names take precedence over configured role names.
+ * Explicit `provider/id` references and authenticated bare ids take precedence
+ * over configured role names, which in turn take precedence over an
+ * unauthenticated catalog-only id (so a bundled `cursor/default` never shadows a
+ * configured `modelRoles.default`).
  */
 export function resolveCliModel(options: {
 	cliProvider?: string;
 	cliModel?: string;
 	modelRegistry: CliModelRegistry;
-	/** Authenticated models to prefer for unqualified selectors; omit to preserve catalog-order behavior. */
+	/** Authenticated models to prefer for unqualified selectors; defaults to the registry's authenticated set. */
 	availableModels?: Model<Api>[];
 	settings?: Settings;
 	preferences?: ModelMatchPreferences;
@@ -1662,7 +1673,7 @@ export function resolveCliModel(options: {
 		};
 	}
 
-	const availableModels = preferredModels ?? allModels;
+	const availableModels = preferredModels ?? modelRegistry.getAvailable();
 	const providerMap = new Map<string, string>();
 	for (const model of allModels) {
 		providerMap.set(model.provider.toLowerCase(), model.provider);
@@ -1680,7 +1691,7 @@ export function resolveCliModel(options: {
 
 	const trimmedModel = cliModel.trim();
 	if (!provider) {
-		const exact = findExactCliModel(trimmedModel, allModels, availableModels);
+		const exact = findExactCliModel(trimmedModel, allModels, availableModels, { catalogFallback: false });
 		if (exact) {
 			return {
 				model: exact,
@@ -1696,7 +1707,7 @@ export function resolveCliModel(options: {
 			MAX_THINKING_SUFFIX_OPTIONS,
 		);
 		if (exactThinkingLevel) {
-			const exactSuffixed = findExactCliModel(exactBase, allModels, availableModels);
+			const exactSuffixed = findExactCliModel(exactBase, allModels, availableModels, { catalogFallback: false });
 			if (exactSuffixed) {
 				return {
 					model: exactSuffixed,

package/src/config/settings-schema.ts

@@ -5266,6 +5266,11 @@ export const SETTINGS_SCHEMA = {
 		default: undefined,
 	},
 
+	"searxng.engines": {
+		type: "string",
+		default: undefined,
+	},
+
 	"searxng.language": {
 		type: "string",
 		default: undefined,

package/src/debug/raw-sse-buffer.ts

@@ -3,6 +3,13 @@ import type { Model, ProviderResponseMetadata, RawSseEvent } from "@oh-my-pi/pi-
 const MAX_RAW_SSE_EVENTS = 1_000;
 const MAX_RAW_SSE_CHARS = 512_000;
 const MAX_RAW_SSE_EVENT_CHARS = 64_000;
+// Reserve room for the `: omp-debug-truncated` / `: omp-debug-elided` marker
+// lines so a trimmed event stays within MAX_RAW_SSE_EVENT_CHARS overall.
+const TRIM_MARKER_RESERVE = 200;
+// Caps applied to individual tool entries when compacting a `tools` array
+// inside an oversized `data:` payload.
+const MAX_TOOL_SCHEMA_CHARS = 200;
+const MAX_TOOL_DESCRIPTION_CHARS = 200;
 
 export type RawSseDebugRecord =
 	| {
@@ -45,42 +52,162 @@ export interface RawSseDebugSnapshot {
 // path. The parallel array keeps records as plain monomorphic objects.
 type TrimResult = { raw: string[]; truncated: boolean; originalChars: number; chars: number };
 
-// Single-pass trim. Returns the final `chars` count using the historical
-// formula `reduce(line.length + 1, init = 1)` so the new accounting matches
-// the previous `countRecordChars` byte-for-byte (the trailing +1 covers the
-// record-level newline that `rawRecordText` appends in `toRawText`).
-//
-// When the event fits within budget the input `raw` array is returned
-// **by reference** — see the ownership contract documented at
-// `RawSseDebugBuffer.recordEvent` below.
-function trimRawLines(raw: string[]): TrimResult {
-	let originalChars = 0;
-	for (let i = 0; i < raw.length; i++) originalChars += raw[i].length + 1;
+// `chars` uses the historical formula `reduce(line.length + 1, init = 1)` so
+// the accounting matches the previous `countRecordChars` byte-for-byte (the
+// trailing +1 covers the record-level newline that `rawRecordText` appends in
+// `toRawText`).
+function countLines(lines: readonly string[]): number {
+	let chars = 0;
+	for (let i = 0; i < lines.length; i++) chars += lines[i].length + 1;
+	return chars;
+}
+
+function elideText(text: string, max: number): string {
+	if (text.length <= max) return text;
+	return `${text.slice(0, max)}… (+${text.length - max} chars)`;
+}
+
+// Shrinks one tool definition in place: schemas (`parameters` for OpenAI
+// shapes, `input_schema` for Anthropic) become elided JSON strings and long
+// descriptions are cut, while `name`/`type` survive untouched. Chat-completions
+// nests the payload under `function`.
+function compactToolEntry(tool: unknown): boolean {
+	if (typeof tool !== "object" || tool === null) return false;
+	const obj = tool as Record<string, unknown>;
+	let changed = false;
+	if (typeof obj.function === "object" && obj.function !== null) {
+		changed = compactToolEntry(obj.function);
+	}
+	for (const key of ["parameters", "input_schema"]) {
+		const schema = obj[key];
+		if (schema === undefined || schema === null) continue;
+		const text = typeof schema === "string" ? schema : JSON.stringify(schema);
+		if (text.length <= MAX_TOOL_SCHEMA_CHARS) continue;
+		obj[key] = elideText(text, MAX_TOOL_SCHEMA_CHARS);
+		changed = true;
+	}
+	if (typeof obj.description === "string" && obj.description.length > MAX_TOOL_DESCRIPTION_CHARS) {
+		obj.description = elideText(obj.description, MAX_TOOL_DESCRIPTION_CHARS);
+		changed = true;
+	}
+	return changed;
+}
+
+// Walks a parsed SSE payload and compacts every `tools` array it finds
+// (e.g. `response.tools` echoed back by the Responses API). Mutates `node`.
+function compactToolsDeep(node: unknown): boolean {
+	if (Array.isArray(node)) {
+		let changed = false;
+		for (const item of node) changed = compactToolsDeep(item) || changed;
+		return changed;
+	}
+	if (typeof node !== "object" || node === null) return false;
+	let changed = false;
+	const obj = node as Record<string, unknown>;
+	for (const key in obj) {
+		const value = obj[key];
+		if (key === "tools" && Array.isArray(value)) {
+			for (const tool of value) changed = compactToolEntry(tool) || changed;
+		} else {
+			changed = compactToolsDeep(value) || changed;
+		}
+	}
+	return changed;
+}
 
+// Rewrites oversized `data:` lines with tool schemas compacted. Returns null
+// when nothing changed (unparseable payloads or no tools to shrink). Only
+// invoked on events that already blew the budget, so the JSON round-trip is
+// off the streaming hot path.
+function compactToolLines(raw: readonly string[]): string[] | null {
+	let changed = false;
+	const out = raw.map(line => {
+		if (!line.startsWith("data:") || line.length <= MAX_TOOL_SCHEMA_CHARS) return line;
+		const start = line.charCodeAt(5) === 32 ? 6 : 5;
+		try {
+			const parsed = JSON.parse(line.slice(start));
+			if (!compactToolsDeep(parsed)) return line;
+			changed = true;
+			return `data: ${JSON.stringify(parsed)}`;
+		} catch {
+			return line;
+		}
+	});
+	return changed ? out : null;
+}
+
+// Keeps the first and last portions of an over-budget event and drops the
+// middle, so leading fields (id/model/status) AND trailing fields
+// (usage/finish_reason) both stay visible. A `: omp-debug-elided` comment
+// marks the cut; split lines carry `…` at the cut edge.
+function headTailTrim(lines: string[], budget: number, elidedTotal: number): string[] {
+	const headBudget = budget >> 1;
+	const tailBudget = budget - headBudget;
+
+	let i = 0;
+	let headRemaining = headBudget;
+	const out: string[] = [];
+	while (i < lines.length && lines[i].length + 1 <= headRemaining) {
+		headRemaining -= lines[i].length + 1;
+		out.push(lines[i]);
+		i++;
+	}
+
+	let j = lines.length - 1;
+	let tailRemaining = tailBudget;
+	const tail: string[] = [];
+	while (j >= i && lines[j].length + 1 <= tailRemaining) {
+		tailRemaining -= lines[j].length + 1;
+		tail.push(lines[j]);
+		j--;
+	}
+	tail.reverse();
+
+	let elided = elidedTotal - countLines(out) - countLines(tail);
+	if (i <= j) {
+		// lines[i..j] straddle the cut: keep a head slice of the first and a
+		// tail slice of the last (the same line when i === j).
+		const headSlice = lines[i].slice(0, Math.max(0, headRemaining - 2));
+		const tailStart =
+			i === j
+				? Math.max(headSlice.length, lines[j].length - tailRemaining + 2)
+				: Math.max(0, lines[j].length - tailRemaining + 2);
+		const tailSlice = lines[j].slice(tailStart);
+		elided -= headSlice.length + tailSlice.length;
+		if (headSlice.length > 0) out.push(`${headSlice}…`);
+		out.push(`: omp-debug-elided chars=${Math.max(0, elided)}`);
+		if (tailSlice.length > 0) out.push(`…${tailSlice}`);
+	} else if (elided > 0) {
+		out.push(`: omp-debug-elided chars=${elided}`);
+	}
+	out.push(...tail);
+	return out;
+}
+
+// Trim pipeline for one SSE event:
+//   1. fits → return `raw` **by reference** (ownership contract at
+//      `RawSseDebugBuffer.recordEvent` below).
+//   2. over budget → compact tool schemas inside `data:` JSON payloads;
+//      if that alone fits, the payload stays parseable JSON.
+//   3. still over → head+tail trim (middle elided).
+// Any trimmed result ends with the `: omp-debug-truncated` marker carrying
+// the original size.
+function trimRawLines(raw: string[]): TrimResult {
+	const originalChars = countLines(raw);
 	if (originalChars <= MAX_RAW_SSE_EVENT_CHARS) {
 		return { raw, truncated: false, originalChars, chars: originalChars + 1 };
 	}
 
-	const trimmed: string[] = [];
-	let remaining = MAX_RAW_SSE_EVENT_CHARS;
-	let chars = 1; // matches reduce(.., init = 1)
-	for (const line of raw) {
-		if (remaining <= 0) break;
-		if (line.length + 1 <= remaining) {
-			trimmed.push(line);
-			chars += line.length + 1;
-			remaining -= line.length + 1;
-			continue;
-		}
-		const slice = line.slice(0, Math.max(0, remaining));
-		trimmed.push(slice);
-		chars += slice.length + 1;
-		remaining = 0;
+	const budget = MAX_RAW_SSE_EVENT_CHARS - TRIM_MARKER_RESERVE;
+	let lines = compactToolLines(raw) ?? raw;
+	const compactedChars = lines === raw ? originalChars : countLines(lines);
+	if (compactedChars > budget) {
+		lines = headTailTrim(lines, budget, compactedChars);
+	} else if (lines === raw) {
+		lines = raw.slice();
 	}
-	const tail = `: omp-debug-truncated originalChars=${originalChars}`;
-	trimmed.push(tail);
-	chars += tail.length + 1;
-	return { raw: trimmed, truncated: true, originalChars, chars };
+	lines.push(`: omp-debug-truncated originalChars=${originalChars}`);
+	return { raw: lines, truncated: true, originalChars, chars: countLines(lines) + 1 };
 }
 
 export function formatRawSseIsoTime(timestamp: number): string {

package/src/edit/hashline/filesystem.ts

@@ -121,7 +121,7 @@ export class HashlineFilesystem extends Filesystem {
 			throw error;
 		}
 		// Refuse edits against generated files (lockfiles, models.json, …).
-		assertEditableFileContent(content, relativePath);
+		assertEditableFileContent(content, relativePath, this.session.settings);
 		return content;
 	}
 

package/src/edit/modes/patch.ts

@@ -1816,7 +1816,7 @@ export async function executePatchSingle(
 	const resolvedPath = resolvePlanPath(session, path);
 	const resolvedRename = rename ? resolvePlanPath(session, rename) : undefined;
 
-	await assertEditableFile(resolvedPath, path);
+	await assertEditableFile(resolvedPath, path, session.settings);
 
 	// Capture pre-edit content so we can verify the write actually hit disk.
 	// `LspFileSystem.writeFile` delegates to a writethrough callback that, in

package/src/export/share.ts

@@ -400,8 +400,9 @@ function redactShareMessage(
 			};
 		case "assistant":
 			// Drop opaque provider-replay state (encrypted reasoning / native history) the viewer
-			// never reads and we cannot redact field-by-field: `providerPayload` and any
-			// `redactedThinking` blocks.
+			// never reads and we cannot redact field-by-field: `providerPayload`, any
+			// `redactedThinking` blocks, and native Anthropic server-tool blocks
+			// (`server_tool_use` input / `web_search_tool_result` encrypted_content).
 			return {
 				...message,
 				providerPayload: undefined,
@@ -410,7 +411,7 @@ function redactShareMessage(
 						? undefined
 						: o.obfuscate(message.errorMessage, sharedRegexSecretValues),
 				content: message.content.flatMap((block): AssistantMessage["content"] => {
-					if (block.type === "redactedThinking") return [];
+					if (block.type === "redactedThinking" || block.type === "anthropicServerTool") return [];
 					if (block.type === "text") return [{ ...block, text: o.obfuscate(block.text, sharedRegexSecretValues) }];
 					if (block.type === "thinking") {
 						return [{ ...block, thinking: o.obfuscate(block.thinking, sharedRegexSecretValues) }];