@oh-my-pi/pi-coding-agent 14.5.8 → 14.5.10

package/src/session/compaction/compaction.ts

@@ -26,6 +26,7 @@ import {
 	getOpenAIResponsesHistoryPayload,
 	normalizeResponsesToolCallId,
 } from "@oh-my-pi/pi-ai/utils";
+import { countTokens } from "@oh-my-pi/pi-natives";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import compactionShortSummaryPrompt from "../../prompts/compaction/compaction-short-summary.md" with { type: "text" };
 import compactionSummaryPrompt from "../../prompts/compaction/compaction-summary.md" with { type: "text" };
@@ -218,7 +219,7 @@ export function shouldCompact(contextTokens: number, contextWindow: number, sett
 	return contextTokens > thresholdTokens;
 }
 
-function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
+export function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
 	// Fixed token limit takes priority over percentage
 	const thresholdTokens = settings.thresholdTokens;
 	if (typeof thresholdTokens === "number" && Number.isFinite(thresholdTokens) && thresholdTokens > 0) {
@@ -240,67 +241,79 @@ function resolveThresholdTokens(contextWindow: number, settings: CompactionSetti
 // ============================================================================
 
 /**
- * Estimate token count for a message using chars/4 heuristic.
- * This is conservative (overestimates tokens).
+ * Image content has no tokenizer representation; charge a fixed estimate
+ * matching what providers typically bill for inline images.
+ */
+const IMAGE_TOKEN_ESTIMATE = 1200;
+
+/**
+ * Estimate token count for a message using cl100k_base via the native
+ * tokenizer. This is not Claude's first-party tokenizer (Anthropic doesn't
+ * publish one) but is within ~5–10% across English/code text.
  */
 export function estimateTokens(message: AgentMessage): number {
-	let chars = 0;
+	const fragments: string[] = [];
+	let extra = 0;
 
 	switch (message.role) {
 		case "user": {
 			const content = (message as { content: string | Array<{ type: string; text?: string }> }).content;
 			if (typeof content === "string") {
-				chars = content.length;
+				fragments.push(content);
 			} else if (Array.isArray(content)) {
 				for (const block of content) {
 					if (block.type === "text" && block.text) {
-						chars += block.text.length;
+						fragments.push(block.text);
 					}
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "assistant": {
 			const assistant = message as AssistantMessage;
 			for (const block of assistant.content) {
 				if (block.type === "text") {
-					chars += block.text.length;
+					fragments.push(block.text);
 				} else if (block.type === "thinking") {
-					chars += block.thinking.length;
+					fragments.push(block.thinking);
 				} else if (block.type === "toolCall") {
-					chars += block.name.length + JSON.stringify(block.arguments).length;
+					fragments.push(block.name);
+					fragments.push(JSON.stringify(block.arguments));
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "hookMessage":
 		case "toolResult": {
 			if (typeof message.content === "string") {
-				chars = message.content.length;
+				fragments.push(message.content);
 			} else {
 				for (const block of message.content) {
 					if (block.type === "text" && block.text) {
-						chars += block.text.length;
-					}
-					if (block.type === "image") {
-						chars += 4800; // Estimate images as 4000 chars, or 1200 tokens
+						fragments.push(block.text);
+					} else if (block.type === "image") {
+						extra += IMAGE_TOKEN_ESTIMATE;
 					}
 				}
 			}
-			return Math.ceil(chars / 4);
+			break;
 		}
 		case "bashExecution": {
-			chars = message.command.length + message.output.length;
-			return Math.ceil(chars / 4);
+			fragments.push(message.command);
+			fragments.push(message.output);
+			break;
 		}
 		case "branchSummary":
 		case "compactionSummary": {
-			chars = message.summary.length;
-			return Math.ceil(chars / 4);
+			fragments.push(message.summary);
+			break;
 		}
+		default:
+			return 0;
 	}
 
-	return 0;
+	if (fragments.length === 0) return extra;
+	return extra + countTokens(fragments);
 }
 
 function estimateEntriesTokens(entries: SessionEntry[], startIndex: number, endIndex: number): number {

package/src/session/session-dump-format.ts

@@ -114,6 +114,7 @@ export function formatSessionDumpText(options: FormatSessionDumpTextOptions): st
 				if (c.type === "text") {
 					lines.push(c.text);
 				} else if (c.type === "thinking") {
+					if (c.thinking.trim().length === 0) continue;
 					lines.push("<thinking>");
 					lines.push(c.thinking);
 					lines.push("</thinking>\n");

package/src/session/session-manager.ts

@@ -566,6 +566,14 @@ export function buildSessionContext(
 	let hasPersistedMCPToolSelection = false;
 	let mode = "none";
 	let modeData: Record<string, unknown> | undefined;
+	// Track whether an explicit `model_change` with role="default" has been
+	// seen on this path. Once a user (or the agent itself) records an
+	// explicit default, later assistant-message inference must NOT overwrite
+	// it: temporary fallbacks (retry fallback, context promotion) and
+	// server-side model downgrades both produce assistant messages tagged
+	// with the wrong model id, which previously clobbered the user's pick on
+	// resume (issue #849).
+	let hasExplicitDefaultModel = false;
 
 	for (const entry of path) {
 		if (entry.type === "thinking_level_change") {
@@ -575,12 +583,21 @@ export function buildSessionContext(
 			if (entry.model) {
 				const role = entry.role ?? "default";
 				models[role] = entry.model;
+				if (role === "default") {
+					hasExplicitDefaultModel = true;
+				}
 			}
 		} else if (entry.type === "service_tier_change") {
 			serviceTier = entry.serviceTier ?? undefined;
 		} else if (entry.type === "message" && entry.message.role === "assistant") {
-			// Infer default model from assistant messages
-			models.default = `${entry.message.provider}/${entry.message.model}`;
+			// Legacy fallback: infer default model from assistant messages only
+			// when no explicit `model_change` (role=default) entry has been
+			// recorded yet. Newer sessions always record an explicit default
+			// model_change at the start of the conversation, so this branch is
+			// only used to keep pre-model_change sessions working.
+			if (!hasExplicitDefaultModel) {
+				models.default = `${entry.message.provider}/${entry.message.model}`;
+			}
 		} else if (entry.type === "compaction") {
 			compaction = entry;
 		} else if (entry.type === "ttsr_injection") {

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

@@ -123,11 +123,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 	},
 	{
 		name: "loop",
-		description: "Loop the agent: re-submit the same prompt every time it yields (Esc to stop)",
-		inlineHint: "<prompt>",
-		allowArgs: true,
-		handle: async (command, runtime) => {
-			await runtime.ctx.handleLoopCommand(command.args || undefined);
+		description:
+			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleLoopCommand();
 			runtime.ctx.editor.setText("");
 		},
 	},
@@ -356,6 +355,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "context",
+		description: "Show estimated context usage breakdown",
+		handle: (_command, runtime) => {
+			runtime.ctx.handleContextCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "extensions",
 		aliases: ["status"],

package/src/tools/bash.ts

@@ -508,12 +508,17 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		const headLines = head;
 		const tailLines = tail;
 
-		// Check interception if enabled and available tools are known
+		// Check both the original command and the cwd-normalized command so
+		// leading `cd ... &&` wrappers do not hide either shell-navigation rules
+		// or the dedicated-tool command that follows the directory change.
 		if (this.session.settings.get("bashInterceptor.enabled")) {
 			const rules = this.session.settings.getBashInterceptorRules();
-			const interception = checkBashInterception(command, ctx?.toolNames ?? [], rules);
-			if (interception.block) {
-				throw new ToolError(interception.message ?? "Command blocked");
+			const commandsToCheck = rawCommand === command ? [command] : [rawCommand, command];
+			for (const commandToCheck of commandsToCheck) {
+				const interception = checkBashInterception(commandToCheck, ctx?.toolNames ?? [], rules);
+				if (interception.block) {
+					throw new ToolError(interception.message ?? "Command blocked");
+				}
 			}
 		}
 

package/src/tools/debug.ts

@@ -52,85 +52,72 @@ import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
 const debugSchema = Type.Object({
-	action: StringEnum(
-		[
-			"launch",
-			"attach",
-			"set_breakpoint",
-			"remove_breakpoint",
-			"set_instruction_breakpoint",
-			"remove_instruction_breakpoint",
-			"data_breakpoint_info",
-			"set_data_breakpoint",
-			"remove_data_breakpoint",
-			"continue",
-			"step_over",
-			"step_in",
-			"step_out",
-			"pause",
-			"evaluate",
-			"stack_trace",
-			"threads",
-			"scopes",
-			"variables",
-			"disassemble",
-			"read_memory",
-			"write_memory",
-			"modules",
-			"loaded_sources",
-			"custom_request",
-			"output",
-			"terminate",
-			"sessions",
-		],
-		{ description: "dap debugger action" },
-	),
-	program: Type.Optional(Type.String({ description: "program path", examples: ["./my_app", "src/main.py"] })),
-	args: Type.Optional(Type.Array(Type.String(), { description: "program arguments", examples: [["--verbose"]] })),
-	adapter: Type.Optional(
-		Type.String({ description: "debugger adapter", examples: ["gdb", "lldb-dap", "debugpy", "dlv"] }),
-	),
-	cwd: Type.Optional(Type.String({ description: "working directory", examples: ["src/"] })),
-	file: Type.Optional(Type.String({ description: "source file", examples: ["src/main.c"] })),
-	line: Type.Optional(Type.Number({ description: "source line", examples: [42] })),
-	function: Type.Optional(Type.String({ description: "function name", examples: ["main", "handle_request"] })),
-	name: Type.Optional(Type.String({ description: "variable or data name", examples: ["counter", "buffer"] })),
-	condition: Type.Optional(Type.String({ description: "breakpoint condition", examples: ["i == 10", "x > 0"] })),
-	hit_condition: Type.Optional(Type.String({ description: "hit condition" })),
-	expression: Type.Optional(Type.String({ description: "expression to evaluate", examples: ["x + 1", "obj.field"] })),
+	action: StringEnum([
+		"launch",
+		"attach",
+		"set_breakpoint",
+		"remove_breakpoint",
+		"set_instruction_breakpoint",
+		"remove_instruction_breakpoint",
+		"data_breakpoint_info",
+		"set_data_breakpoint",
+		"remove_data_breakpoint",
+		"continue",
+		"step_over",
+		"step_in",
+		"step_out",
+		"pause",
+		"evaluate",
+		"stack_trace",
+		"threads",
+		"scopes",
+		"variables",
+		"disassemble",
+		"read_memory",
+		"write_memory",
+		"modules",
+		"loaded_sources",
+		"custom_request",
+		"output",
+		"terminate",
+		"sessions",
+	]),
+	program: Type.Optional(Type.String({ description: "program path" })),
+	args: Type.Optional(Type.Array(Type.String(), { description: "program arguments" })),
+	adapter: Type.Optional(Type.String({ description: "debugger adapter (gdb, lldb-dap, debugpy, dlv)" })),
+	cwd: Type.Optional(Type.String()),
+	file: Type.Optional(Type.String({ description: "source file" })),
+	line: Type.Optional(Type.Number({ description: "source line" })),
+	function: Type.Optional(Type.String({ description: "function name" })),
+	name: Type.Optional(Type.String({ description: "variable or data name" })),
+	condition: Type.Optional(Type.String({ description: "breakpoint condition" })),
+	hit_condition: Type.Optional(Type.String()),
+	expression: Type.Optional(Type.String({ description: "expression to evaluate" })),
 	context: Type.Optional(
-		Type.String({ description: "evaluate context", examples: ["watch", "repl", "hover", "variables", "clipboard"] }),
+		Type.String({ description: "evaluate context: watch | repl | hover | variables | clipboard" }),
 	),
-	frame_id: Type.Optional(Type.Number({ description: "stack frame id" })),
+	frame_id: Type.Optional(Type.Number()),
 	scope_id: Type.Optional(Type.Number({ description: "scope variables reference" })),
 	variable_ref: Type.Optional(Type.Number({ description: "variable reference" })),
-	pid: Type.Optional(Type.Number({ description: "process id for attach", examples: [12345] })),
-	port: Type.Optional(Type.Number({ description: "remote attach port", examples: [4711] })),
-	host: Type.Optional(Type.String({ description: "remote attach host", examples: ["127.0.0.1"] })),
+	pid: Type.Optional(Type.Number({ description: "process id for attach" })),
+	port: Type.Optional(Type.Number({ description: "remote attach port" })),
+	host: Type.Optional(Type.String({ description: "remote attach host" })),
 	levels: Type.Optional(Type.Number({ description: "max stack frames" })),
-	memory_reference: Type.Optional(
-		Type.String({ description: "memory reference or address", examples: ["0x7ffd1234"] }),
-	),
-	instruction_reference: Type.Optional(Type.String({ description: "instruction address or reference" })),
-	instruction_count: Type.Optional(Type.Number({ description: "instructions to disassemble" })),
-	instruction_offset: Type.Optional(Type.Number({ description: "instruction offset" })),
+	memory_reference: Type.Optional(Type.String({ description: "memory reference or address" })),
+	instruction_reference: Type.Optional(Type.String()),
+	instruction_count: Type.Optional(Type.Number()),
+	instruction_offset: Type.Optional(Type.Number()),
 	count: Type.Optional(Type.Number({ description: "bytes to read" })),
 	data: Type.Optional(Type.String({ description: "base64 memory payload" })),
 	data_id: Type.Optional(Type.String({ description: "data breakpoint id" })),
-	access_type: Type.Optional(
-		StringEnum(["read", "write", "readWrite"], { description: "data breakpoint access type" }),
-	),
+	access_type: Type.Optional(StringEnum(["read", "write", "readWrite"])),
 	command: Type.Optional(Type.String({ description: "custom dap request command" })),
-	arguments: Type.Optional(
-		Type.Record(Type.String(), Type.Any(), {
-			description: "custom request arguments",
-		}),
-	),
-	offset: Type.Optional(Type.Number({ description: "memory or instruction offset" })),
-	resolve_symbols: Type.Optional(Type.Boolean({ description: "resolve symbols during disassembly" })),
-	allow_partial: Type.Optional(Type.Boolean({ description: "allow partial writes" })),
-	start_module: Type.Optional(Type.Number({ description: "modules start index" })),
-	module_count: Type.Optional(Type.Number({ description: "max modules to fetch" })),
+	arguments: Type.Optional(Type.Record(Type.String(), Type.Any(), { description: "custom request arguments" })),
+	offset: Type.Optional(Type.Number()),
+	resolve_symbols: Type.Optional(Type.Boolean()),
+	allow_partial: Type.Optional(Type.Boolean()),
+	start_module: Type.Optional(Type.Number()),
+	module_count: Type.Optional(Type.Number()),
 	timeout: Type.Optional(Type.Number({ description: "per-request timeout seconds" })),
 });