pi-crew 0.1.46 → 0.1.49

package/src/runtime/pi-json-output.ts

@@ -1,111 +1,111 @@
-export interface ParsedPiUsage {
-	input?: number;
-	output?: number;
-	cacheRead?: number;
-	cacheWrite?: number;
-	cost?: number;
-	turns?: number;
-}
-
-export interface ParsedPiJsonOutput {
-	jsonEvents: number;
-	textEvents: string[];
-	finalText?: string;
-	usage?: ParsedPiUsage;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
-	for (const key of keys) {
-		const value = obj[key];
-		if (typeof value === "number" && Number.isFinite(value)) return value;
-	}
-	return undefined;
-}
-
-function mergeUsage(target: ParsedPiUsage, source: ParsedPiUsage): ParsedPiUsage {
-	return {
-		input: source.input ?? target.input,
-		output: source.output ?? target.output,
-		cacheRead: source.cacheRead ?? target.cacheRead,
-		cacheWrite: source.cacheWrite ?? target.cacheWrite,
-		cost: source.cost ?? target.cost,
-		turns: source.turns ?? target.turns,
-	};
-}
-
-function extractUsage(value: unknown): ParsedPiUsage | undefined {
-	const obj = asRecord(value);
-	if (!obj) return undefined;
-	const direct: ParsedPiUsage = {
-		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
-		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
-		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
-		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
-		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
-		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
-	};
-	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
-		const nested = extractUsage(obj[key]);
-		if (nested) return nested;
-	}
-	return undefined;
-}
-
-function textFromContent(content: unknown): string[] {
-	if (typeof content === "string") return [content];
-	if (!Array.isArray(content)) return [];
-	const text: string[] = [];
-	for (const part of content) {
-		const obj = asRecord(part);
-		if (!obj) continue;
-		if (obj.type === "text" && typeof obj.text === "string") text.push(obj.text);
-		else if (typeof obj.content === "string") text.push(obj.content);
-	}
-	return text;
-}
-
-function extractText(value: unknown): string[] {
-	const obj = asRecord(value);
-	if (!obj) return [];
-	const message = asRecord(obj.message);
-	if (message?.role !== undefined && message.role !== "assistant") return [];
-	const text: string[] = [];
-	if (typeof obj.text === "string") text.push(obj.text);
-	if (typeof obj.output === "string") text.push(obj.output);
-	if (typeof obj.finalOutput === "string") text.push(obj.finalOutput);
-	if (typeof obj.final_output === "string") text.push(obj.final_output);
-	if (!message) text.push(...textFromContent(obj.content));
-	if (message) text.push(...textFromContent(message.content));
-	return text.filter((entry) => entry.trim().length > 0);
-}
-
-export function parsePiJsonOutput(stdout: string): ParsedPiJsonOutput {
-	let jsonEvents = 0;
-	const textEvents: string[] = [];
-	let usage: ParsedPiUsage | undefined;
-	for (const line of stdout.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		let event: unknown;
-		try {
-			event = JSON.parse(trimmed) as unknown;
-		} catch {
-			continue;
-		}
-		jsonEvents++;
-		textEvents.push(...extractText(event));
-		const eventUsage = extractUsage(event);
-		if (eventUsage) usage = mergeUsage(usage ?? {}, eventUsage);
-	}
-	return {
-		jsonEvents,
-		textEvents,
-		finalText: textEvents.length > 0 ? textEvents[textEvents.length - 1] : undefined,
-		usage,
-	};
-}
+export interface ParsedPiUsage {
+	input?: number;
+	output?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	cost?: number;
+	turns?: number;
+}
+
+export interface ParsedPiJsonOutput {
+	jsonEvents: number;
+	textEvents: string[];
+	finalText?: string;
+	usage?: ParsedPiUsage;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
+	for (const key of keys) {
+		const value = obj[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+	return undefined;
+}
+
+function mergeUsage(target: ParsedPiUsage, source: ParsedPiUsage): ParsedPiUsage {
+	return {
+		input: source.input ?? target.input,
+		output: source.output ?? target.output,
+		cacheRead: source.cacheRead ?? target.cacheRead,
+		cacheWrite: source.cacheWrite ?? target.cacheWrite,
+		cost: source.cost ?? target.cost,
+		turns: source.turns ?? target.turns,
+	};
+}
+
+function extractUsage(value: unknown): ParsedPiUsage | undefined {
+	const obj = asRecord(value);
+	if (!obj) return undefined;
+	const direct: ParsedPiUsage = {
+		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
+		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
+		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
+		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
+		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
+		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
+	};
+	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
+	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
+		const nested = extractUsage(obj[key]);
+		if (nested) return nested;
+	}
+	return undefined;
+}
+
+function textFromContent(content: unknown): string[] {
+	if (typeof content === "string") return [content];
+	if (!Array.isArray(content)) return [];
+	const text: string[] = [];
+	for (const part of content) {
+		const obj = asRecord(part);
+		if (!obj) continue;
+		if (obj.type === "text" && typeof obj.text === "string") text.push(obj.text);
+		else if (typeof obj.content === "string") text.push(obj.content);
+	}
+	return text;
+}
+
+function extractText(value: unknown): string[] {
+	const obj = asRecord(value);
+	if (!obj) return [];
+	const message = asRecord(obj.message);
+	if (message?.role !== undefined && message.role !== "assistant") return [];
+	const text: string[] = [];
+	if (typeof obj.text === "string") text.push(obj.text);
+	if (typeof obj.output === "string") text.push(obj.output);
+	if (typeof obj.finalOutput === "string") text.push(obj.finalOutput);
+	if (typeof obj.final_output === "string") text.push(obj.final_output);
+	if (!message) text.push(...textFromContent(obj.content));
+	if (message) text.push(...textFromContent(message.content));
+	return text.filter((entry) => entry.trim().length > 0);
+}
+
+export function parsePiJsonOutput(stdout: string): ParsedPiJsonOutput {
+	let jsonEvents = 0;
+	const textEvents: string[] = [];
+	let usage: ParsedPiUsage | undefined;
+	for (const line of stdout.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		let event: unknown;
+		try {
+			event = JSON.parse(trimmed) as unknown;
+		} catch {
+			continue;
+		}
+		jsonEvents++;
+		textEvents.push(...extractText(event));
+		const eventUsage = extractUsage(event);
+		if (eventUsage) usage = mergeUsage(usage ?? {}, eventUsage);
+	}
+	return {
+		jsonEvents,
+		textEvents,
+		finalText: textEvents.length > 0 ? textEvents[textEvents.length - 1] : undefined,
+		usage,
+	};
+}

package/src/runtime/policy-engine.ts

@@ -1,79 +1,79 @@
-import type { CrewLimitsConfig } from "../config/config.ts";
-import type { PolicyDecision, PolicyDecisionAction, PolicyDecisionReason, TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { evaluateGreenContract } from "./green-contract.ts";
-import { isWorkerHeartbeatStale } from "./worker-heartbeat.ts";
-
-export interface PolicyEngineInput {
-	manifest: TeamRunManifest;
-	tasks: TeamTaskState[];
-	limits?: CrewLimitsConfig;
-	now?: Date;
-}
-
-function decision(action: PolicyDecisionAction, reason: PolicyDecisionReason, message: string, taskId?: string): PolicyDecision {
-	return {
-		action,
-		reason,
-		message,
-		taskId,
-		createdAt: new Date().toISOString(),
-	};
-}
-
-function taskDepth(task: TeamTaskState, tasksById: Map<string, TeamTaskState>): number {
-	let depth = 0;
-	let current = task.graph?.parentId;
-	const seen = new Set<string>();
-	while (current && !seen.has(current)) {
-		seen.add(current);
-		depth += 1;
-		current = tasksById.get(current)?.graph?.parentId;
-	}
-	return depth;
-}
-
-export function evaluateCrewPolicy(input: PolicyEngineInput): PolicyDecision[] {
-	const decisions: PolicyDecision[] = [];
-	const maxTasksPerRun = Number.isFinite(input.limits?.maxTasksPerRun) ? input.limits!.maxTasksPerRun : undefined;
-	if (maxTasksPerRun !== undefined && input.tasks.length > maxTasksPerRun) {
-		decisions.push(decision("block", "limit_exceeded", `Run has ${input.tasks.length} tasks, exceeding maxTasksPerRun=${maxTasksPerRun}.`));
-	}
-	const runningCount = input.tasks.filter((task) => task.status === "running").length;
-	const maxConcurrentWorkers = Number.isFinite(input.limits?.maxConcurrentWorkers) ? input.limits!.maxConcurrentWorkers : undefined;
-	if (maxConcurrentWorkers !== undefined && runningCount > maxConcurrentWorkers) {
-		decisions.push(decision("block", "limit_exceeded", `Run has ${runningCount} running workers, exceeding maxConcurrentWorkers=${maxConcurrentWorkers}.`));
-	}
-	const tasksById = new Map(input.tasks.map((task) => [task.id, task]));
-
-	for (const task of input.tasks) {
-		if (input.limits?.maxChildrenPerTask !== undefined && (task.graph?.children.length ?? 0) > input.limits.maxChildrenPerTask) {
-			decisions.push(decision("block", "limit_exceeded", `Task has ${task.graph?.children.length ?? 0} children, exceeding maxChildrenPerTask=${input.limits.maxChildrenPerTask}.`, task.id));
-		}
-		if (input.limits?.maxTaskDepth !== undefined && taskDepth(task, tasksById) > input.limits.maxTaskDepth) {
-			decisions.push(decision("block", "limit_exceeded", `Task graph depth exceeds maxTaskDepth=${input.limits.maxTaskDepth}.`, task.id));
-		}
-		if (task.status === "failed") {
-			const retryCount = task.policy?.retryCount ?? 0;
-			const maxRetries = input.limits?.maxRetriesPerTask ?? 0;
-			decisions.push(decision(retryCount < maxRetries ? "retry" : "escalate", "task_failed", task.error ? `Task failed: ${task.error}` : "Task failed.", task.id));
-		}
-		if ((task.status === "running" || task.status === "queued") && task.heartbeat && task.heartbeat.alive !== false && isWorkerHeartbeatStale(task.heartbeat, input.limits?.heartbeatStaleMs ?? 60_000, input.now)) {
-			decisions.push(decision("escalate", "worker_stale", "Worker heartbeat is stale.", task.id));
-		}
-		if (task.taskPacket?.verification) {
-			const outcome = evaluateGreenContract(task.taskPacket.verification, task.verification);
-			if (!outcome.satisfied && task.status === "completed") {
-				decisions.push(decision("block", "green_unsatisfied", `Green contract unsatisfied: required=${outcome.requiredGreenLevel}, observed=${outcome.observedGreenLevel}.`, task.id));
-			}
-		}
-	}
-
-	if (decisions.length === 0 && input.tasks.length > 0 && input.tasks.every((task) => task.status === "completed")) {
-		decisions.push(decision("closeout", "run_complete", "All tasks completed and no policy blockers were found."));
-	}
-	return decisions;
-}
-
-export function summarizePolicyDecisions(decisions: PolicyDecision[]): string[] {
-	return decisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`);
-}
+import type { CrewLimitsConfig } from "../config/config.ts";
+import type { PolicyDecision, PolicyDecisionAction, PolicyDecisionReason, TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { evaluateGreenContract } from "./green-contract.ts";
+import { isWorkerHeartbeatStale } from "./worker-heartbeat.ts";
+
+export interface PolicyEngineInput {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	limits?: CrewLimitsConfig;
+	now?: Date;
+}
+
+function decision(action: PolicyDecisionAction, reason: PolicyDecisionReason, message: string, taskId?: string): PolicyDecision {
+	return {
+		action,
+		reason,
+		message,
+		taskId,
+		createdAt: new Date().toISOString(),
+	};
+}
+
+function taskDepth(task: TeamTaskState, tasksById: Map<string, TeamTaskState>): number {
+	let depth = 0;
+	let current = task.graph?.parentId;
+	const seen = new Set<string>();
+	while (current && !seen.has(current)) {
+		seen.add(current);
+		depth += 1;
+		current = tasksById.get(current)?.graph?.parentId;
+	}
+	return depth;
+}
+
+export function evaluateCrewPolicy(input: PolicyEngineInput): PolicyDecision[] {
+	const decisions: PolicyDecision[] = [];
+	const maxTasksPerRun = Number.isFinite(input.limits?.maxTasksPerRun) ? input.limits!.maxTasksPerRun : undefined;
+	if (maxTasksPerRun !== undefined && input.tasks.length > maxTasksPerRun) {
+		decisions.push(decision("block", "limit_exceeded", `Run has ${input.tasks.length} tasks, exceeding maxTasksPerRun=${maxTasksPerRun}.`));
+	}
+	const runningCount = input.tasks.filter((task) => task.status === "running").length;
+	const maxConcurrentWorkers = Number.isFinite(input.limits?.maxConcurrentWorkers) ? input.limits!.maxConcurrentWorkers : undefined;
+	if (maxConcurrentWorkers !== undefined && runningCount > maxConcurrentWorkers) {
+		decisions.push(decision("block", "limit_exceeded", `Run has ${runningCount} running workers, exceeding maxConcurrentWorkers=${maxConcurrentWorkers}.`));
+	}
+	const tasksById = new Map(input.tasks.map((task) => [task.id, task]));
+
+	for (const task of input.tasks) {
+		if (input.limits?.maxChildrenPerTask !== undefined && (task.graph?.children.length ?? 0) > input.limits.maxChildrenPerTask) {
+			decisions.push(decision("block", "limit_exceeded", `Task has ${task.graph?.children.length ?? 0} children, exceeding maxChildrenPerTask=${input.limits.maxChildrenPerTask}.`, task.id));
+		}
+		if (input.limits?.maxTaskDepth !== undefined && taskDepth(task, tasksById) > input.limits.maxTaskDepth) {
+			decisions.push(decision("block", "limit_exceeded", `Task graph depth exceeds maxTaskDepth=${input.limits.maxTaskDepth}.`, task.id));
+		}
+		if (task.status === "failed") {
+			const retryCount = task.policy?.retryCount ?? 0;
+			const maxRetries = input.limits?.maxRetriesPerTask ?? 0;
+			decisions.push(decision(retryCount < maxRetries ? "retry" : "escalate", "task_failed", task.error ? `Task failed: ${task.error}` : "Task failed.", task.id));
+		}
+		if ((task.status === "running" || task.status === "queued") && task.heartbeat && task.heartbeat.alive !== false && isWorkerHeartbeatStale(task.heartbeat, input.limits?.heartbeatStaleMs ?? 60_000, input.now)) {
+			decisions.push(decision("escalate", "worker_stale", "Worker heartbeat is stale.", task.id));
+		}
+		if (task.taskPacket?.verification) {
+			const outcome = evaluateGreenContract(task.taskPacket.verification, task.verification);
+			if (!outcome.satisfied && task.status === "completed") {
+				decisions.push(decision("block", "green_unsatisfied", `Green contract unsatisfied: required=${outcome.requiredGreenLevel}, observed=${outcome.observedGreenLevel}.`, task.id));
+			}
+		}
+	}
+
+	if (decisions.length === 0 && input.tasks.length > 0 && input.tasks.every((task) => task.status === "completed")) {
+		decisions.push(decision("closeout", "run_complete", "All tasks completed and no policy blockers were found."));
+	}
+	return decisions;
+}
+
+export function summarizePolicyDecisions(decisions: PolicyDecision[]): string[] {
+	return decisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`);
+}

package/src/runtime/progress-event-coalescer.ts

@@ -1,43 +1,43 @@
-export interface ProgressEventSummary {
-	eventType: string;
-	currentTool?: string;
-	toolCount?: number;
-	tokens?: number;
-	turns?: number;
-	activityState?: string;
-	lastActivityAt?: string;
-}
-
-export interface ProgressEventCoalesceDecision {
-	shouldAppend: boolean;
-	reason: string;
-}
-
-export interface ProgressEventCoalesceInput {
-	previous?: ProgressEventSummary;
-	next: ProgressEventSummary;
-	nowMs: number;
-	lastAppendMs?: number;
-	minIntervalMs: number;
-	force?: boolean;
-	tokenThreshold?: number;
-}
-
-const DEFAULT_TOKEN_THRESHOLD = 256;
-
-function numericIncrease(previous: number | undefined, next: number | undefined): number {
-	return next !== undefined && previous !== undefined ? next - previous : next !== undefined ? next : 0;
-}
-
-export function shouldAppendProgressEventUpdate(input: ProgressEventCoalesceInput): ProgressEventCoalesceDecision {
-	if (input.force) return { shouldAppend: true, reason: "force" };
-	if (!input.previous) return { shouldAppend: true, reason: "first" };
-	if (input.previous.activityState !== input.next.activityState) return { shouldAppend: true, reason: "activity_changed" };
-	if (input.previous.currentTool !== input.next.currentTool) return { shouldAppend: true, reason: "tool_changed" };
-	if (numericIncrease(input.previous.toolCount, input.next.toolCount) > 0) return { shouldAppend: true, reason: "tool_count_increased" };
-	if (numericIncrease(input.previous.turns, input.next.turns) > 0) return { shouldAppend: true, reason: "turns_increased" };
-	const tokenIncrease = numericIncrease(input.previous.tokens, input.next.tokens);
-	if (tokenIncrease >= (input.tokenThreshold ?? DEFAULT_TOKEN_THRESHOLD)) return { shouldAppend: true, reason: "tokens_increased" };
-	if (input.lastAppendMs === undefined || input.nowMs - input.lastAppendMs >= input.minIntervalMs) return { shouldAppend: true, reason: "interval" };
-	return { shouldAppend: false, reason: "coalesced" };
-}
+export interface ProgressEventSummary {
+	eventType: string;
+	currentTool?: string;
+	toolCount?: number;
+	tokens?: number;
+	turns?: number;
+	activityState?: string;
+	lastActivityAt?: string;
+}
+
+export interface ProgressEventCoalesceDecision {
+	shouldAppend: boolean;
+	reason: string;
+}
+
+export interface ProgressEventCoalesceInput {
+	previous?: ProgressEventSummary;
+	next: ProgressEventSummary;
+	nowMs: number;
+	lastAppendMs?: number;
+	minIntervalMs: number;
+	force?: boolean;
+	tokenThreshold?: number;
+}
+
+const DEFAULT_TOKEN_THRESHOLD = 256;
+
+function numericIncrease(previous: number | undefined, next: number | undefined): number {
+	return next !== undefined && previous !== undefined ? next - previous : next !== undefined ? next : 0;
+}
+
+export function shouldAppendProgressEventUpdate(input: ProgressEventCoalesceInput): ProgressEventCoalesceDecision {
+	if (input.force) return { shouldAppend: true, reason: "force" };
+	if (!input.previous) return { shouldAppend: true, reason: "first" };
+	if (input.previous.activityState !== input.next.activityState) return { shouldAppend: true, reason: "activity_changed" };
+	if (input.previous.currentTool !== input.next.currentTool) return { shouldAppend: true, reason: "tool_changed" };
+	if (numericIncrease(input.previous.toolCount, input.next.toolCount) > 0) return { shouldAppend: true, reason: "tool_count_increased" };
+	if (numericIncrease(input.previous.turns, input.next.turns) > 0) return { shouldAppend: true, reason: "turns_increased" };
+	const tokenIncrease = numericIncrease(input.previous.tokens, input.next.tokens);
+	if (tokenIncrease >= (input.tokenThreshold ?? DEFAULT_TOKEN_THRESHOLD)) return { shouldAppend: true, reason: "tokens_increased" };
+	if (input.lastAppendMs === undefined || input.nowMs - input.lastAppendMs >= input.minIntervalMs) return { shouldAppend: true, reason: "interval" };
+	return { shouldAppend: false, reason: "coalesced" };
+}

package/src/runtime/prose-compressor.ts

@@ -0,0 +1,164 @@
+/**
+ * Pure TypeScript prose compression module.
+ *
+ * Inspired by caveman's compress.js — reduces tool descriptions and other
+ * prose by removing filler words, pleasantries, hedging, and articles while
+ * preserving code, URLs, paths, identifiers, and other protected segments
+ * byte-for-byte.
+ *
+ * No external dependencies. No `any` types. Regex-only pattern matching.
+ */
+
+// ---------------------------------------------------------------------------
+// Protected segment patterns (order matters — earlier patterns take priority)
+// ---------------------------------------------------------------------------
+
+const PROTECTED_PATTERNS: readonly RegExp[] = [
+	/```[\s\S]*?```/g,                                    // fenced code blocks
+	/`[^`\n]+`/g,                                         // inline code
+	/\bhttps?:\/\/\S+/gi,                                 // URLs
+	/\b[\w.-]*[\/\\][\w.\/\\\-]+/g,                       // paths with / or \
+	/\b[A-Z][A-Z0-9]*(?:_[A-Z][A-Z0-9]*)+\b/g,           // CONSTANT_CASE
+	/\b\w+(?:\.\w+)+\(\)/g,                               // dotted.method() calls
+	/[A-Za-z_][A-Za-z0-9_]*\s*\([^)]*\)/g,                // function calls: name(args)
+	/\b\d+\.\d+\.\d+\b/g,                                 // version numbers x.y.z
+];
+
+// ---------------------------------------------------------------------------
+// Compression patterns (applied to unprotected prose only)
+// ---------------------------------------------------------------------------
+
+const FILLERS = /\b(?:just|really|basically|actually|simply|quite|very|essentially|literally)\b/gi;
+
+const PLEASANTRIES = /\b(?:please|kindly|thank you|thanks|sure|certainly|of course|happy to)\b[,.]?\s*/gi;
+
+const HEDGES = /\b(?:perhaps|maybe|might|could potentially|would like to|i think|in my opinion)\b\s*/gi;
+
+const LEADERS = /^(?:i'?\s*ll|i will|i can|you can|we will|we can|let me|let'?\s*s)\s+/gim;
+
+const ARTICLES = /\b(?:a|an|the)\s+(?=[a-z])/gi;
+
+// ---------------------------------------------------------------------------
+// Sentinel helpers
+// ---------------------------------------------------------------------------
+
+const SENTINEL_OPEN = "\x00";
+const SENTINEL_CLOSE = "\x00";
+const SENTINEL_RE = /\x00(\d+)\x00/g;
+
+interface SegmentStore {
+	segments: string[];
+}
+
+function extractProtected(text: string, store: SegmentStore): string {
+	let working = text;
+	for (const re of PROTECTED_PATTERNS) {
+		// Reset lastIndex for reused RegExp objects
+		re.lastIndex = 0;
+		working = working.replace(re, (match: string): string => {
+			const index = store.segments.length;
+			store.segments.push(match);
+			return `${SENTINEL_OPEN}${index}${SENTINEL_CLOSE}`;
+		});
+	}
+	return working;
+}
+
+function restoreProtected(text: string, store: SegmentStore): string {
+	return text.replace(SENTINEL_RE, (_match: string, indexStr: string): string => {
+		const index = Number(indexStr);
+		return store.segments[index] ?? "";
+	});
+}
+
+// ---------------------------------------------------------------------------
+// Core prose compression
+// ---------------------------------------------------------------------------
+
+function compressProseText(text: string): string {
+	let s = text;
+
+	// Remove leading "I'll / I will / you can / ..." sentence openers
+	s = s.replace(LEADERS, "");
+
+	// Remove pleasantries
+	s = s.replace(PLEASANTRIES, "");
+
+	// Remove hedging phrases
+	s = s.replace(HEDGES, "");
+
+	// Remove filler adverbs
+	s = s.replace(FILLERS, "");
+
+	// Remove articles before lowercase words
+	s = s.replace(ARTICLES, "");
+
+	// Collapse whitespace introduced by removals
+	s = s.replace(/[ \t]{2,}/g, " ");
+
+	// Fix punctuation spacing (e.g. "word ," → "word,")
+	s = s.replace(/\s+([,.;:!?])/g, "$1");
+
+	// Collapse excessive newlines
+	s = s.replace(/\n{3,}/g, "\n\n");
+
+	// Re-capitalize first letter of each sentence after removals
+	s = s.replace(/(^|[.!?]\s+)([a-z])/g, (_match: string, pre: string, ch: string): string => {
+		return pre + ch.toUpperCase();
+	});
+
+	return s.trim();
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface CompressResult {
+	compressed: string;
+	originalLength: number;
+	compressedLength: number;
+	savingsPercent: number;
+}
+
+/**
+ * Compress prose text by removing filler, pleasantries, hedging, and articles
+ * while preserving code blocks, URLs, paths, identifiers, and other protected
+ * segments byte-for-byte.
+ */
+export function compressProse(text: string): CompressResult {
+	if (typeof text !== "string" || text.length === 0) {
+		return {
+			compressed: "",
+			originalLength: 0,
+			compressedLength: 0,
+			savingsPercent: 0,
+		};
+	}
+
+	const store: SegmentStore = { segments: [] };
+	const extracted = extractProtected(text, store);
+	const compressed = compressProseText(extracted);
+	const restored = restoreProtected(compressed, store);
+
+	const originalLength = text.length;
+	const compressedLength = restored.length;
+	const savingsPercent = originalLength > 0
+		? Math.round(((originalLength - compressedLength) / originalLength) * 100 * 100) / 100
+		: 0;
+
+	return {
+		compressed: restored,
+		originalLength,
+		compressedLength,
+		savingsPercent,
+	};
+}
+
+/**
+ * Convenience wrapper — returns just the compressed string for tool
+ * descriptions and other single-field use cases.
+ */
+export function compressToolDescription(description: string): string {
+	return compressProse(description).compressed;
+}