@oh-my-pi/pi-coding-agent 15.9.0 → 15.9.3

package/src/cli/session-picker.ts

@@ -64,6 +64,7 @@ export async function selectSession(
 				loadAllSessions: () => SessionManager.listAll(storage),
 				allSessions: options?.allSessions,
 				startInAllScope: options?.startInAllScope,
+				getTerminalRows: () => ui.terminal.rows,
 			},
 		);
 		return selector;

package/src/cli/update-cli.ts

@@ -27,6 +27,33 @@ const PACKAGE = "@oh-my-pi/pi-coding-agent";
  */
 const NPM_REGISTRY = "https://registry.npmjs.org/";
 
+/**
+ * Core native addon package. Bumped in lock-step with {@link PACKAGE} so the
+ * version sentinel the loader looks up at runtime matches the `.node` on
+ * disk; see {@link buildBunInstallArgs} for why this must be installed
+ * explicitly rather than inherited as a transitive dependency.
+ */
+const NATIVES_PACKAGE = "@oh-my-pi/pi-natives";
+
+/**
+ * Platform tags the release pipeline publishes as
+ * `@oh-my-pi/pi-natives-<tag>` leaves. Mirrors `SUPPORTED_PLATFORMS` in
+ * `packages/natives/native/loader-state.js` and `LEAF_TARGETS` in
+ * `packages/natives/scripts/gen-npm-packages.ts`; kept here as the local
+ * source of truth so the update path stays free of cross-package imports.
+ */
+const SUPPORTED_NATIVE_TAGS: ReadonlySet<string> = new Set([
+	"linux-x64",
+	"linux-arm64",
+	"darwin-x64",
+	"darwin-arm64",
+	"win32-x64",
+]);
+
+function currentNativeTag(): string {
+	return `${process.platform}-${process.arch}`;
+}
+
 interface ReleaseInfo {
 	tag: string;
 	version: string;
@@ -319,9 +346,34 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
  *
  * Together these two flags make `omp update` produce exactly the registry
  * lookup the version check just performed. See #1686.
+ *
+ * Also pins {@link NATIVES_PACKAGE} and the platform-specific
+ * `@oh-my-pi/pi-natives-<tag>` leaf to `expectedVersion`. `bun install -g`
+ * does not reliably refresh transitive `optionalDependencies` when the
+ * top-level package is the only one bumped, so the native addon and its
+ * version sentinel can drift out of sync with the freshly installed
+ * `@oh-my-pi/pi-coding-agent` and the loader aborts at
+ * `validateLoadedBindings` on the next launch
+ * (`The .node file on disk is from a different release than this loader`).
+ * Listing the natives explicitly forces bun to replace them in lock-step.
+ * The leaf is added only on tags the release pipeline actually publishes
+ * ({@link SUPPORTED_NATIVE_TAGS}) so unsupported platforms still fail with
+ * the original "no matching version" message instead of `EBADPLATFORM`.
+ * See #1824.
  */
-export function buildBunInstallArgs(expectedVersion: string): string[] {
-	return ["install", "-g", "--no-cache", `--registry=${NPM_REGISTRY}`, `${PACKAGE}@${expectedVersion}`];
+export function buildBunInstallArgs(expectedVersion: string, nativeTag: string = currentNativeTag()): string[] {
+	const args = [
+		"install",
+		"-g",
+		"--no-cache",
+		`--registry=${NPM_REGISTRY}`,
+		`${PACKAGE}@${expectedVersion}`,
+		`${NATIVES_PACKAGE}@${expectedVersion}`,
+	];
+	if (SUPPORTED_NATIVE_TAGS.has(nativeTag)) {
+		args.push(`${NATIVES_PACKAGE}-${nativeTag}@${expectedVersion}`);
+	}
+	return args;
 }
 
 /**

package/src/cli-commands.ts

@@ -20,6 +20,7 @@ export const commands: CommandEntry[] = [
 	{ name: "completions", load: () => import("./commands/completions").then(m => m.default) },
 	{ name: "__complete", load: () => import("./commands/complete").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ name: "dry-balance", load: () => import("./commands/dry-balance").then(m => m.default) },
 	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
 	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
 	{ name: "install", load: () => import("./commands/install").then(m => m.default) },

package/src/commands/completions.ts

@@ -51,7 +51,7 @@ export default class Completions extends Command {
 
 		const config: CliConfig = { bin: APP_NAME, version: VERSION, commands: map };
 		const spec = buildSpec(config, ROOT_COMMAND, aliasMap);
-		process.stdout.write(generateCompletion(shell, spec));
+		await Bun.write(Bun.stdout, generateCompletion(shell, spec));
 	}
 }
 

package/src/commands/dry-balance.ts

@@ -0,0 +1,43 @@
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runDryBalanceCommand } from "../cli/dry-balance-cli";
+
+export default class DryBalance extends Command {
+	static description = "Dry-run OAuth account balancing across random session ids";
+
+	static args = {
+		model: Args.string({
+			description: "Model selector (provider/model or fuzzy id). Defaults to the configured default model.",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		model: Flags.string({ description: "Model selector (same syntax as --model on omp)" }),
+		count: Flags.integer({ description: "Number of random session ids to try", default: 100 }),
+		concurrency: Flags.integer({ description: "Maximum concurrent credential resolutions", default: 32 }),
+		json: Flags.boolean({ description: "Output JSON" }),
+		bench: Flags.boolean({ description: "Send one live benchmark request per OAuth account" }),
+	};
+
+	static examples = [
+		"# Dry-run the configured default model with 100 random session ids\n  omp dry-balance",
+		"# Dry-run a specific model\n  omp dry-balance anthropic/claude-sonnet-4-5",
+		"# Larger run with bounded concurrency\n  omp dry-balance --model openai-codex/gpt-5-codex --count 1000 --concurrency 64",
+		"# Benchmark every OAuth account in parallel\n  omp dry-balance --bench",
+		"# Machine-readable output\n  omp dry-balance --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(DryBalance);
+		await runDryBalanceCommand({
+			model: args.model,
+			flags: {
+				model: flags.model,
+				count: flags.count,
+				concurrency: flags.concurrency,
+				json: flags.json,
+				bench: flags.bench,
+			},
+		});
+	}
+}

package/src/config/append-only-context-mode.ts

@@ -0,0 +1,37 @@
+/** Provider metadata needed to resolve append-only context mode. */
+export interface AppendOnlyContextModel {
+	provider: string;
+	baseUrl: string;
+	compat?: object;
+}
+
+function isXiaomiHost(baseUrl: string): boolean {
+	try {
+		const host = new URL(baseUrl).hostname;
+		return host === "xiaomimimo.com" || host.endsWith(".xiaomimimo.com");
+	} catch {
+		return false;
+	}
+}
+
+function shouldAutoEnableAppendOnlyContext(model: AppendOnlyContextModel | null | undefined): boolean {
+	if (!model) return false;
+	if (model.provider === "deepseek") return true;
+	if (isXiaomiHost(model.baseUrl)) return true;
+	return !!model.compat && "supportsStore" in model.compat && model.compat.supportsStore === true;
+}
+
+/** Resolves whether append-only context should be active for a model and setting. */
+export function shouldEnableAppendOnlyContext(
+	setting: "auto" | "on" | "off" | undefined,
+	model: AppendOnlyContextModel | null | undefined,
+): boolean {
+	switch (setting ?? "auto") {
+		case "on":
+			return true;
+		case "off":
+			return false;
+		default:
+			return shouldAutoEnableAppendOnlyContext(model);
+	}
+}

package/src/config/model-registry.ts

@@ -547,6 +547,7 @@ function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<A
 	if (override.input !== undefined) result.input = override.input as ("text" | "image")[];
 	if (override.contextWindow !== undefined) result.contextWindow = override.contextWindow;
 	if (override.maxTokens !== undefined) result.maxTokens = override.maxTokens;
+	if (override.omitMaxOutputTokens !== undefined) result.omitMaxOutputTokens = override.omitMaxOutputTokens;
 	if (override.contextPromotionTarget !== undefined) result.contextPromotionTarget = override.contextPromotionTarget;
 	if (override.premiumMultiplier !== undefined) result.premiumMultiplier = override.premiumMultiplier;
 	if (override.cost) {
@@ -575,6 +576,7 @@ interface CustomModelDefinitionLike {
 	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
 	contextWindow?: number;
 	maxTokens?: number;
+	omitMaxOutputTokens?: boolean;
 	headers?: Record<string, string>;
 	compat?: Model<Api>["compat"];
 	contextPromotionTarget?: string;
@@ -597,6 +599,7 @@ type CustomModelOverlay = {
 	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
 	contextWindow?: number;
 	maxTokens?: number;
+	omitMaxOutputTokens?: boolean;
 	headers?: Record<string, string>;
 	compat?: Model<Api>["compat"];
 	contextPromotionTarget?: string;
@@ -667,6 +670,7 @@ function buildCustomModelOverlay(
 		cost: modelDef.cost,
 		contextWindow: modelDef.contextWindow,
 		maxTokens: modelDef.maxTokens,
+		omitMaxOutputTokens: modelDef.omitMaxOutputTokens,
 		headers: mergeCustomModelHeaders(providerHeaders, modelDef.headers, authHeader, providerApiKey),
 		compat: mergeCompat(providerCompat, modelDef.compat),
 		contextPromotionTarget: modelDef.contextPromotionTarget,
@@ -823,6 +827,7 @@ function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuil
 			resolvedModel.contextWindow ?? reference?.contextWindow ?? (options.useDefaults ? 128000 : undefined),
 		maxTokens: resolvedModel.maxTokens ?? reference?.maxTokens ?? (options.useDefaults ? 16384 : undefined),
 		headers: resolvedModel.headers,
+		omitMaxOutputTokens: resolvedModel.omitMaxOutputTokens ?? reference?.omitMaxOutputTokens,
 		compat: mergeCompat(reference?.compat, resolvedModel.compat),
 		contextPromotionTarget: resolvedModel.contextPromotionTarget,
 		premiumMultiplier: resolvedModel.premiumMultiplier,
@@ -1124,6 +1129,7 @@ export class ModelRegistry {
 					cost: customModel.cost ?? existingModel.cost,
 					contextWindow: customModel.contextWindow ?? existingModel.contextWindow,
 					maxTokens: customModel.maxTokens ?? existingModel.maxTokens,
+					omitMaxOutputTokens: customModel.omitMaxOutputTokens ?? existingModel.omitMaxOutputTokens,
 					// Same-id custom definitions replace bundled transport behavior. Provider-level
 					// headers/compat were already folded into customModel during parsing; do not
 					// re-merge bundled transport metadata here.

package/src/config/models-config-schema.ts

@@ -41,6 +41,7 @@ export const OpenAICompatSchema = z.object({
 	openRouterRouting: OpenRouterRoutingSchema.optional(),
 	vercelGatewayRouting: VercelGatewayRoutingSchema.optional(),
 	extraBody: z.record(z.string(), z.unknown()).optional(),
+	cacheControlFormat: z.enum(["anthropic"]).optional(),
 	supportsStrictMode: z.boolean().optional(),
 	toolStrictMode: z.enum(["all_strict", "none"]).optional(),
 });
@@ -92,6 +93,7 @@ const ModelDefinitionSchema = z.object({
 	premiumMultiplier: z.number().optional(),
 	contextWindow: z.number().optional(),
 	maxTokens: z.number().optional(),
+	omitMaxOutputTokens: z.boolean().optional(),
 	headers: z.record(z.string(), z.string()).optional(),
 	compat: OpenAICompatSchema.optional(),
 	contextPromotionTarget: z.string().min(1).optional(),
@@ -113,6 +115,7 @@ export const ModelOverrideSchema = z.object({
 	premiumMultiplier: z.number().optional(),
 	contextWindow: z.number().optional(),
 	maxTokens: z.number().optional(),
+	omitMaxOutputTokens: z.boolean().optional(),
 	headers: z.record(z.string(), z.string()).optional(),
 	compat: OpenAICompatSchema.optional(),
 	contextPromotionTarget: z.string().min(1).optional(),

package/src/config/settings-schema.ts

@@ -3057,9 +3057,9 @@ export const SETTINGS_SCHEMA = {
 			tab: "providers",
 			label: "Append-Only Context",
 			description:
-				"Cache system prompt + tool specs and keep an append-only message log so provider prefix caches (DeepSeek, Anthropic) hit at maximum rate. Auto enables for DeepSeek.",
+				"Cache system prompt + tool specs and keep an append-only message log so provider prefix caches (DeepSeek, Xiaomi/SGLang, Anthropic) hit at maximum rate. Auto enables for known prefix-cache providers.",
 			options: [
-				{ value: "auto", label: "Auto", description: "Enable for DeepSeek (recommended)" },
+				{ value: "auto", label: "Auto", description: "Enable for known prefix-cache providers (recommended)" },
 				{ value: "on", label: "On", description: "Always enable append-only context" },
 				{ value: "off", label: "Off", description: "Disable append-only context" },
 			],

package/src/config/settings.ts

@@ -907,6 +907,9 @@ const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook<any>>> = {
 			for (const cb of appendOnlyModeCallbacks) cb(value);
 		}
 	},
+	"hindsight.bankId": () => fireHindsightScopeChanged(),
+	"hindsight.bankIdPrefix": () => fireHindsightScopeChanged(),
+	"hindsight.scoping": () => fireHindsightScopeChanged(),
 };
 /** Callbacks invoked when `provider.appendOnlyContext` changes at runtime. */
 const appendOnlyModeCallbacks = new Set<(value: string) => void>();
@@ -923,6 +926,41 @@ export function onAppendOnlyModeChanged(cb: (value: string) => void): () => void
 	};
 }
 
+/** Callbacks fired when any `hindsight.bankId` / `bankIdPrefix` / `scoping` value changes. */
+const hindsightScopeCallbacks = new Set<() => void>();
+
+function fireHindsightScopeChanged(): void {
+	// Snapshot the callback set before invoking — a callback's body is allowed
+	// to subscribe a NEW callback (the Hindsight backend re-registers the
+	// fresh state's listener on every rebuild). Iterating the live Set would
+	// re-invoke those just-added callbacks within the same fire, which spins
+	// in place: subscribe → invoke → subscribe → invoke → …
+	for (const cb of [...hindsightScopeCallbacks]) {
+		try {
+			cb();
+		} catch (err) {
+			logger.warn("Settings: hindsight scope hook failed", { error: String(err) });
+		}
+	}
+}
+
+/**
+ * Subscribe to changes in the Hindsight bank-scoping settings. Lets the
+ * Hindsight backend rebuild the active `HindsightSessionState` when the
+ * operator switches `hindsight.bankId`, `hindsight.bankIdPrefix`, or
+ * `hindsight.scoping` mid-session so subsequent retain/recall calls land in
+ * the new bank instead of the one selected at session start.
+ *
+ * Returns an unsubscribe function. The callback receives no arguments — the
+ * caller is expected to re-read the relevant settings via `Settings.get`.
+ */
+export function onHindsightScopeChanged(cb: () => void): () => void {
+	hindsightScopeCallbacks.add(cb);
+	return () => {
+		hindsightScopeCallbacks.delete(cb);
+	};
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Global Singleton
 // ═══════════════════════════════════════════════════════════════════════════

package/src/discovery/builtin-rules/ts-no-tiny-functions.md

@@ -46,5 +46,6 @@ const doubled = value * 2;
 - Callback identity matters.
 - Type guard preserves narrowing.
 - Public API, test seam, or DI boundary needs indirection.
+- Names a non-obvious formula or magic-constant computation that the inlined expression would not explain on its own.
 
 If none apply, inline it.

package/src/discovery/github.ts

@@ -10,6 +10,7 @@
  * Capabilities:
  * - context-files: copilot-instructions.md in .github/
  * - instructions: *.instructions.md in .github/instructions/ with applyTo frontmatter
+ * - skills: <name>/SKILL.md in .github/skills/ (GitHub Agent Skills layout)
  */
 import * as path from "node:path";
 import { parseFrontmatter } from "@oh-my-pi/pi-utils";
@@ -17,9 +18,10 @@ import { registerProvider } from "../capability";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
 import { readFile } from "../capability/fs";
 import { type Instruction, instructionCapability } from "../capability/instruction";
+import { type Skill, skillCapability } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
-import { calculateDepth, createSourceMeta, getProjectPath, loadFilesFromDir } from "./helpers";
+import { calculateDepth, createSourceMeta, getProjectPath, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
 
 const PROVIDER_ID = "github";
 const DISPLAY_NAME = "GitHub Copilot";
@@ -97,6 +99,32 @@ function transformInstruction(name: string, content: string, filePath: string, s
 	};
 }
 
+// =============================================================================
+// Skills
+// =============================================================================
+
+/**
+ * Load skills from `.github/skills/<name>/SKILL.md`.
+ *
+ * GitHub documents this layout for Copilot Agent Skills and matches the
+ * non-recursive shape `scanSkillsFromDir` already expects. `requireDescription`
+ * is on to match the Agent Skills spec (name + description are mandatory) and
+ * the sibling `native`/`omp-plugins` providers.
+ *
+ * @see https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/add-skills
+ */
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const skillsDir = getProjectPath(ctx, "github", "skills");
+	if (!skillsDir) return { items: [], warnings: [] };
+
+	return scanSkillsFromDir(ctx, {
+		dir: skillsDir,
+		providerId: PROVIDER_ID,
+		level: "project",
+		requireDescription: true,
+	});
+}
+
 // =============================================================================
 // Provider Registration
 // =============================================================================
@@ -116,3 +144,11 @@ registerProvider(instructionCapability.id, {
 	priority: PRIORITY,
 	load: loadInstructions,
 });
+
+registerProvider<Skill>(skillCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load skills from .github/skills/*/SKILL.md",
+	priority: PRIORITY,
+	load: loadSkills,
+});

package/src/discovery/helpers.ts

@@ -212,6 +212,7 @@ export interface ParsedAgentFields {
 	output?: unknown;
 	thinkingLevel?: ThinkingLevel;
 	autoloadSkills?: string[];
+	readSummarize?: boolean;
 	blocking?: boolean;
 }
 
@@ -265,10 +266,11 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 	const thinkingLevel = parseThinkingLevel(rawThinkingLevel);
 	const model = parseModelList(frontmatter.model);
 	const blocking = parseBoolean(frontmatter.blocking);
+	const readSummarize = parseBoolean(frontmatter.readSummarize);
 	const autoloadSkills = parseArrayOrCSV(frontmatter.autoloadSkills)
 		?.map(s => s.trim())
 		.filter(Boolean);
-	return { name, description, tools, spawns, model, output, thinkingLevel, blocking, autoloadSkills };
+	return { name, description, tools, spawns, model, output, thinkingLevel, blocking, autoloadSkills, readSummarize };
 }
 
 async function globIf(

package/src/exa/mcp-client.ts

@@ -1,7 +1,7 @@
 import type { TSchema } from "@oh-my-pi/pi-ai";
 import { $env, logger } from "@oh-my-pi/pi-utils";
 import type { CustomTool, CustomToolResult } from "../extensibility/custom-tools/types";
-import { callMCP } from "../mcp/json-rpc";
+import { type CallMcpOptions, callMCP } from "../mcp/json-rpc";
 import type {
 	ExaRenderDetails,
 	ExaSearchResponse,
@@ -105,15 +105,21 @@ export async function callExaTool(
 	toolName: string,
 	args: Record<string, unknown>,
 	apiKey: string | null,
+	options?: CallMcpOptions,
 ): Promise<unknown> {
 	const params = new URLSearchParams();
 	if (apiKey) params.set("exaApiKey", apiKey);
 	params.set("tools", toolName);
 	const url = `https://mcp.exa.ai/mcp?${params.toString()}`;
-	const response = (await callMCP(url, "tools/call", {
-		name: toolName,
-		arguments: args,
-	})) as MCPCallResponse;
+	const response = (await callMCP(
+		url,
+		"tools/call",
+		{
+			name: toolName,
+			arguments: args,
+		},
+		options,
+	)) as MCPCallResponse;
 
 	if (response.error) {
 		logger.error("MCP tools/call error", { toolName, args, error: response.error });