@oh-my-pi/pi-coding-agent 15.7.3 → 15.7.5

package/src/session/agent-session.ts

@@ -51,11 +51,8 @@ import {
 	prepareCompaction,
 	type ShakeConfig,
 	type ShakeRegion,
-	type ShakeSummaryComplete,
-	type ShakeSummaryItem,
 	type SummaryOptions,
 	shouldCompact,
-	summarizeShakeRegions,
 } from "@oh-my-pi/pi-agent-core/compaction";
 import { DEFAULT_PRUNE_CONFIG, pruneToolOutputs } from "@oh-my-pi/pi-agent-core/compaction/pruning";
 import type {
@@ -185,8 +182,7 @@ import {
 	resolveThinkingLevelForModel,
 	toReasoningEffort,
 } from "../thinking";
-import { isTinyMemoryLocalModelKey } from "../tiny/models";
-import { shutdownTinyTitleClient, tinyModelClient } from "../tiny/title-client";
+import { shutdownTinyTitleClient } from "../tiny/title-client";
 import {
 	buildDiscoverableToolSearchIndex,
 	collectDiscoverableTools,
@@ -241,11 +237,11 @@ export type AgentSessionEvent =
 	| {
 			type: "auto_compaction_start";
 			reason: "threshold" | "overflow" | "idle" | "incomplete";
-			action: "context-full" | "handoff" | "shake" | "shake-summary";
+			action: "context-full" | "handoff" | "shake";
 	  }
 	| {
 			type: "auto_compaction_end";
-			action: "context-full" | "handoff" | "shake" | "shake-summary";
+			action: "context-full" | "handoff" | "shake";
 			result: CompactionResult | undefined;
 			aborted: boolean;
 			willRetry: boolean;
@@ -5659,10 +5655,6 @@ export class AgentSession {
 	 * - `images` delegates to {@link dropImages}.
 	 * - `elide` replaces whole tool-call results and large fenced/XML blocks
 	 *   with short placeholders that embed an `artifact://` recovery link.
-	 * - `summary` extractively compresses the same regions with the configured
-	 *   local on-device model (`providers.shakeSummaryModel`), falling back to
-	 *   the elide placeholder per region (or wholesale when the local model is
-	 *   unavailable). Never calls a remote/cloud LLM.
 	 *
 	 * Mutates the branch in place, persists via `rewriteEntries`, replays the
 	 * rebuilt context through the agent, and tears down provider sessions that
@@ -5683,29 +5675,7 @@ export class AgentSession {
 		}
 
 		const artifactId = await this.#saveShakeArtifact(regions);
-		let replacements: string[];
-		if (mode === "summary") {
-			// Manual `/shake summary` installs the compaction controller so Esc /
-			// `abortCompaction()` can cancel the local-model pass; the auto-shake path
-			// passes its own signal and manages `#autoCompactionAbortController`.
-			let controller: AbortController | undefined;
-			let signal = opts.signal;
-			if (!signal) {
-				if (this.#compactionAbortController) throw new Error("Compaction already in progress");
-				controller = new AbortController();
-				this.#compactionAbortController = controller;
-				signal = controller.signal;
-			}
-			try {
-				replacements = await this.#buildShakeSummaryReplacements(regions, artifactId, signal);
-			} finally {
-				if (controller && this.#compactionAbortController === controller) {
-					this.#compactionAbortController = undefined;
-				}
-			}
-		} else {
-			replacements = regions.map((region, index) => this.#shakeElidePlaceholder(region, index, artifactId));
-		}
+		const replacements = regions.map((region, index) => this.#shakeElidePlaceholder(region, index, artifactId));
 
 		let toolResultsDropped = 0;
 		let blocksDropped = 0;
@@ -5762,56 +5732,6 @@ export class AgentSession {
 		}
 	}
 
-	/**
-	 * Build per-region replacements for summary mode using the configured local
-	 * on-device model (`providers.shakeSummaryModel`) via {@link tinyModelClient}.
-	 * Shake summary never calls a remote/cloud LLM. When the configured model is
-	 * not a known local key, every region falls back to the elide placeholder.
-	 * Otherwise compresses via {@link summarizeShakeRegions}; per region, uses
-	 * the parsed summary (with a recovery footer) or the elide placeholder when
-	 * the local model omitted it / was unavailable. Any thrown failure degrades
-	 * the whole batch to elide so the reduction still happens.
-	 */
-	async #buildShakeSummaryReplacements(
-		regions: ShakeRegion[],
-		artifactId: string | undefined,
-		signal: AbortSignal | undefined,
-	): Promise<string[]> {
-		const elide = (): string[] =>
-			regions.map((region, index) => this.#shakeElidePlaceholder(region, index, artifactId));
-
-		const modelKey = this.settings.get("providers.shakeSummaryModel");
-		if (!isTinyMemoryLocalModelKey(modelKey)) return elide();
-
-		const items: ShakeSummaryItem[] = regions.map((region, index) => ({
-			index,
-			label: region.label,
-			text: region.originalText,
-		}));
-
-		const complete: ShakeSummaryComplete = (promptText, opts) =>
-			tinyModelClient.complete(modelKey, promptText, { maxTokens: opts.maxTokens, signal: opts.signal });
-
-		let summaries: Map<number, string>;
-		try {
-			summaries = await summarizeShakeRegions(items, complete, { signal });
-		} catch (error) {
-			logger.warn("Shake summary compression failed; falling back to elide", {
-				error: error instanceof Error ? error.message : String(error),
-			});
-			return elide();
-		}
-
-		return regions.map((region, index) => {
-			const summary = summaries.get(index);
-			if (!summary) return this.#shakeElidePlaceholder(region, index, artifactId);
-			if (artifactId) {
-				return `${summary}\n\n[recover full: artifact://${artifactId} (region ${index + 1})]`;
-			}
-			return summary;
-		});
-	}
-
 	/**
 	 * Manually compact the session context.
 	 * Aborts current agent operation first.
@@ -7025,11 +6945,11 @@ export class AgentSession {
 		if (reason !== "idle" && !compactionSettings.enabled) return false;
 		const generation = this.#promptGeneration;
 
-		// Shake strategies run inline (cheap, no remote LLM). On overflow recovery,
-		// if shake reclaims nothing we fall through to the summary-compaction body
-		// below so the oversized input still gets resolved.
-		if (compactionSettings.strategy === "shake" || compactionSettings.strategy === "shake-summary") {
-			const outcome = await this.#runAutoShake(reason, compactionSettings.strategy, willRetry, generation);
+		// Shake runs inline (cheap, no remote LLM). On overflow recovery, if shake
+		// reclaims nothing we fall through to the summary-compaction body below so
+		// the oversized input still gets resolved.
+		if (compactionSettings.strategy === "shake") {
+			const outcome = await this.#runAutoShake(reason, willRetry, generation);
 			if (outcome !== "fallback") return false;
 		}
 		// "overflow" and "incomplete" force inline execution because they are recovery
@@ -7426,12 +7346,10 @@ export class AgentSession {
 	 */
 	async #runAutoShake(
 		reason: "overflow" | "threshold" | "idle" | "incomplete",
-		strategy: "shake" | "shake-summary",
 		willRetry: boolean,
 		generation: number,
 	): Promise<"handled" | "fallback"> {
-		const action = strategy === "shake-summary" ? "shake-summary" : "shake";
-		const mode = strategy === "shake-summary" ? "summary" : "elide";
+		const action = "shake";
 		await this.#emitSessionEvent({ type: "auto_compaction_start", reason, action });
 		this.#autoCompactionAbortController?.abort();
 		const controller = new AbortController();
@@ -7439,7 +7357,7 @@ export class AgentSession {
 		const signal = controller.signal;
 		const compactionSettings = this.settings.getGroup("compaction");
 		try {
-			const result = await this.shake(mode, { config: DEFAULT_SHAKE_CONFIG, signal });
+			const result = await this.shake("elide", { config: DEFAULT_SHAKE_CONFIG, signal });
 			if (signal.aborted) {
 				await this.#emitSessionEvent({
 					type: "auto_compaction_end",

package/src/session/shake-types.ts

@@ -6,14 +6,14 @@
  */
 
 /** Mode selector for `AgentSession.shake`. */
-export type ShakeMode = "elide" | "summary" | "images";
+export type ShakeMode = "elide" | "images";
 
 /** Outcome of an `AgentSession.shake` run. */
 export interface ShakeResult {
 	mode: ShakeMode;
-	/** Whole tool-call results dropped/compressed. */
+	/** Whole tool-call results dropped. */
 	toolResultsDropped: number;
-	/** Large fenced/XML blocks dropped/compressed. */
+	/** Large fenced/XML blocks dropped. */
 	blocksDropped: number;
 	/** Image blocks removed (images mode only). */
 	imagesDropped?: number;
@@ -39,6 +39,5 @@ export function formatShakeSummary(result: ShakeResult): string {
 		parts.push(`${result.blocksDropped} block${result.blocksDropped === 1 ? "" : "s"}`);
 	}
 	if (parts.length === 0) return "Nothing to shake.";
-	const verb = result.mode === "summary" ? "Compressed" : "Shook";
-	return `${verb} ${parts.join(" + ")} (~${result.tokensFreed} tokens freed).`;
+	return `Shook ${parts.join(" + ")} (~${result.tokensFreed} tokens freed).`;
 }

package/src/slash-commands/builtin-registry.ts

@@ -62,9 +62,8 @@ const shutdownHandlerTui = (_command: ParsedSlashCommand, runtime: TuiSlashComma
 function parseShakeMode(args: string): ShakeMode | { error: string } {
 	const verb = args.trim().toLowerCase();
 	if (verb === "" || verb === "elide") return "elide";
-	if (verb === "summary") return "summary";
 	if (verb === "images") return "images";
-	return { error: `Unknown /shake mode "${verb}". Use elide, summary, or images.` };
+	return { error: `Unknown /shake mode "${verb}". Use elide or images.` };
 }
 
 const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
@@ -826,10 +825,9 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		acpDescription: "Shake heavy content out of the conversation context",
 		subcommands: [
 			{ name: "elide", description: "Strip tool results + large blocks (default)" },
-			{ name: "summary", description: "Compress heavy regions with a local on-device model" },
 			{ name: "images", description: "Strip image blocks" },
 		],
-		acpInputHint: "[elide|summary|images]",
+		acpInputHint: "[elide|images]",
 		allowArgs: true,
 		handle: async (command, runtime) => {
 			const mode = parseShakeMode(command.args);

package/src/task/executor.ts

@@ -633,7 +633,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	if (atMaxDepth && toolNames?.includes("task")) {
 		toolNames = toolNames.filter(name => name !== "task");
 	}
-	// IRC is always available; the [COOP] prompt advertises it, so a restricted
+	// IRC is always available; the COOP prompt section advertises it, so a restricted
 	// whitelist must still carry `irc` for the subagent to actually use it.
 	if (toolNames && !toolNames.includes("irc")) {
 		toolNames = [...toolNames, "irc"];
@@ -1446,9 +1446,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					);
 					await awaitAbortable(session.waitForIdle());
 				} catch (err) {
-					logger.error("Subagent prompt failed", {
-						error: err instanceof Error ? err.message : String(err),
-					});
+					if (abortSignal.aborted || err instanceof ToolAbortError) {
+						// Benign control-flow exit — user cancel (^C) or compaction aborting
+						// pending operations both surface here as ToolAbortError. The outer
+						// catch and finally already mark the run aborted; logging at ERROR
+						// would spam operator dashboards with non-failures.
+						logger.debug("Subagent prompt aborted", {
+							reason: abortReason ?? "signal",
+						});
+					} else {
+						logger.error("Subagent prompt failed", {
+							error: err instanceof Error ? err.message : String(err),
+						});
+					}
 				}
 			}
 

package/src/task/index.ts

@@ -48,6 +48,7 @@ import { runSubprocess } from "./executor";
 import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit, Semaphore } from "./parallel";
 import { renderResult, renderCall as renderTaskCall } from "./render";
+import { repairTaskParams } from "./repair-args";
 import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import {
 	applyNestedPatches,
@@ -247,7 +248,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	}
 
 	renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme) {
-		return renderTaskCall(args as TaskParams, options, theme);
+		return renderTaskCall(repairTaskParams(args as TaskParams), options, theme);
 	}
 
 	/** Dynamic description that reflects current disabled-agent settings */
@@ -292,7 +293,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TaskToolDetails>,
 	): Promise<AgentToolResult<TaskToolDetails>> {
-		const params = rawParams as TaskParams;
+		const params = repairTaskParams(rawParams as TaskParams);
 		const simpleMode = this.#getTaskSimpleMode();
 		const validationError = validateTaskModeParams(simpleMode, params);
 		if (validationError) {

package/src/task/repair-args.ts

@@ -0,0 +1,117 @@
+/**
+ * Repair double-encoded JSON string arguments for the task tool.
+ *
+ * Models occasionally JSON-escape a string value twice when emitting a
+ * `task` tool call, so a `context`/`assignment` that should read
+ *
+ *     # Role
+ *     You are a judge … "describe this" … return —
+ *
+ * arrives — after the one JSON decode the provider already applied — as the
+ * literal text
+ *
+ *     # Role\nYou are a judge … \"describe this\" … return \u2014
+ *
+ * i.e. every newline, quote, and unicode character is still backslash-escaped.
+ * The subagent then receives that garbled prompt, and the call preview renders
+ * one long blob with visible `\n` / `\"` / `\uXXXX`.
+ *
+ * The *whole-arguments* form of this quirk (the entire `arguments` blob is a
+ * JSON string) is already auto-corrected by the validator's JSON-string
+ * coercion. This module handles the *per-field* form, where the object parses
+ * fine but an individual string value is double-encoded — the validator never
+ * fires there because a double-encoded string is still a structurally valid
+ * string.
+ *
+ * This is deliberately scoped to the task tool's natural-language fields
+ * (`context`, `assignment`, `description`). It is NOT applied to code-bearing
+ * tools (write/edit/bash/search), where a backslash or quote is load-bearing
+ * and a false-positive unescape would silently corrupt a file or command.
+ */
+import type { TaskItem, TaskParams } from "./types";
+
+/** A backslash that escapes a structural char — `\"`, `\\`, `\/`, or `\uXXXX`. */
+const STRUCTURAL_ESCAPE = /\\(?:["\\/]|u[0-9a-fA-F]{4})/;
+
+/**
+ * Whether `value` carries the signature of whole-string double-encoding rather
+ * than an incidental escape mention. A lone `\n`/`\t` in an instruction (e.g.
+ * "split lines on \n") is far more likely a literal mention than a
+ * double-encoded document, so it is left alone; a structural escape (`\"`,
+ * `\\`, `\uXXXX`) or two-plus escape sequences indicates a re-escaped payload.
+ */
+function hasDoubleEncodeSignature(value: string): boolean {
+	if (STRUCTURAL_ESCAPE.test(value)) return true;
+	let count = 0;
+	for (let i = 0; i < value.length; i++) {
+		if (value.charCodeAt(i) === 0x5c /* \ */) {
+			count += 1;
+			if (count >= 2) return true;
+			i += 1; // skip the escaped char so `\\` counts once
+		}
+	}
+	return false;
+}
+
+/**
+ * Return the once-unescaped string when `value` is uniformly double-encoded
+ * JSON (a well-formed JSON string body that decodes to a different string);
+ * otherwise return `value` unchanged.
+ *
+ * The `JSON.parse(\`"${value}"\`)` round-trip is the safety net: it only
+ * succeeds when *every* backslash begins a valid JSON escape and no bare
+ * double-quote exists — exactly the signature of double-encoding. Genuine
+ * prose with a Windows path (`C:\Users`), a regex (`\d+`), an embedded quote,
+ * or a real (already-decoded) newline makes the parse throw, so the value is
+ * returned untouched.
+ */
+export function repairDoubleEncodedJsonString(value: string): string {
+	// Fast path: no backslash → nothing was escaped → the parse can never differ.
+	if (!value.includes("\\")) return value;
+	if (!hasDoubleEncodeSignature(value)) return value;
+	let decoded: unknown;
+	try {
+		decoded = JSON.parse(`"${value}"`);
+	} catch {
+		return value;
+	}
+	return typeof decoded === "string" && decoded !== value ? decoded : value;
+}
+
+/** Repair a single (possibly partial) task item's prose fields. */
+function repairTaskItem(task: TaskItem): TaskItem {
+	if (task === null || typeof task !== "object") return task;
+	const assignment =
+		typeof task.assignment === "string" ? repairDoubleEncodedJsonString(task.assignment) : task.assignment;
+	const description =
+		typeof task.description === "string" ? repairDoubleEncodedJsonString(task.description) : task.description;
+	if (assignment === task.assignment && description === task.description) return task;
+	return { ...task, assignment, description };
+}
+
+/**
+ * Repair double-encoded prose in task-tool params (`context` and each task's
+ * `assignment`/`description`). Returns the same reference when nothing changed
+ * so callers can cheaply skip work. Defensive against partially-streamed args
+ * (missing/undefined fields, partial task arrays) so it is safe on the render
+ * path as well as on execution.
+ */
+export function repairTaskParams(params: TaskParams): TaskParams {
+	if (params === null || typeof params !== "object") return params;
+
+	const context = typeof params.context === "string" ? repairDoubleEncodedJsonString(params.context) : params.context;
+
+	let tasks = params.tasks;
+	if (Array.isArray(params.tasks)) {
+		let changed = false;
+		const repaired = params.tasks.map(task => {
+			const next = repairTaskItem(task);
+			if (next !== task) changed = true;
+			return next;
+		});
+		if (changed) tasks = repaired;
+	}
+
+	if (context === params.context && tasks === params.tasks) return params;
+	return { ...params, context, tasks };
+}

package/src/tiny/models.ts

@@ -196,34 +196,6 @@ export function getTinyMemoryModelSpec(key: TinyMemoryLocalModelKey): (typeof TI
 	return spec;
 }
 
-/**
- * Shake-summary models. Shake's `summary` mode (and the `shake-summary`
- * compaction strategy) compress heavy regions strictly on-device — there is no
- * online/remote option, so this registry reuses the local memory models only.
- */
-export const SHAKE_SUMMARY_MODEL_VALUES = [
-	"qwen3-1.7b",
-	"gemma-3-1b",
-	"qwen2.5-1.5b",
-	"lfm2-1.2b",
-] as const satisfies readonly TinyMemoryLocalModelKey[];
-
-export type ShakeSummaryModelKey = (typeof SHAKE_SUMMARY_MODEL_VALUES)[number];
-
-// Guard: every local memory model is offered for shake summary (catches drift).
-type MissingShakeSummaryValue = Exclude<TinyMemoryLocalModelKey, ShakeSummaryModelKey>;
-const SHAKE_SUMMARY_MODEL_VALUES_MATCH_REGISTRY: MissingShakeSummaryValue extends never ? true : never = true;
-void SHAKE_SUMMARY_MODEL_VALUES_MATCH_REGISTRY;
-
-export const SHAKE_SUMMARY_MODEL_OPTIONS = TINY_MEMORY_LOCAL_MODELS.map(model => ({
-	value: model.key,
-	label: model.label,
-	description: model.description,
-})) satisfies ReadonlyArray<{ value: ShakeSummaryModelKey; label: string; description: string }>;
-
-/** Default shake-summary local model when none is named. */
-export const DEFAULT_SHAKE_SUMMARY_MODEL_KEY: ShakeSummaryModelKey = DEFAULT_MEMORY_LOCAL_MODEL_KEY;
-
 /** Any local model key (title or memory), used by the shared inference worker. */
 export type TinyLocalModelKey = TinyTitleLocalModelKey | TinyMemoryLocalModelKey;