gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1594b263e

package/packages/pi-coding-agent/src/core/model-registry-custom-caps.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Regression tests for #4563:
+ *   Bug 1 — custom/Anthropic-compatible models were hard-capped to 32 k output tokens
+ *   Bug 2 — custom models in models.json could not declare capabilities.supportsXhigh
+ */
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+let testDir: string;
+
+beforeEach(() => {
+	testDir = join(
+		tmpdir(),
+		`model-registry-custom-caps-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(testDir, { recursive: true });
+});
+
+afterEach(() => {
+	try {
+		rmSync(testDir, { recursive: true, force: true });
+	} catch {
+		// best-effort cleanup
+	}
+});
+
+function createRegistry(modelsJson: object): ModelRegistry {
+	const path = join(testDir, "models.json");
+	writeFileSync(path, JSON.stringify(modelsJson));
+	return new ModelRegistry(AuthStorage.inMemory(), path);
+}
+
+function writeModelsJson(obj: object): string {
+	const path = join(testDir, "models.json");
+	writeFileSync(path, JSON.stringify(obj));
+	return path;
+}
+
+// ─── Bug 1: 32 k cap must not apply to custom/OpenAI-compatible models ────────
+
+describe("Bug 1 — maxTokens cap (#4563)", () => {
+	it("custom openai-completions model with maxTokens > 32 k is not capped", () => {
+		const registry = createRegistry({
+			providers: {
+				"kimi-custom": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "kimi-k2.6-code-preview",
+							name: "Kimi K2.6 Code Preview",
+							maxTokens: 131072,
+							contextWindow: 262144,
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "kimi-k2.6-code-preview");
+		assert.ok(model, "model should be registered");
+		assert.equal(
+			model.maxTokens,
+			131072,
+			"maxTokens must be preserved as declared — not capped to 32 000",
+		);
+	});
+
+	it("custom model with maxTokens exactly 32 k is not affected", () => {
+		const registry = createRegistry({
+			providers: {
+				"custom-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [{ id: "model-32k", maxTokens: 32000, contextWindow: 128000 }],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "model-32k");
+		assert.ok(model);
+		assert.equal(model.maxTokens, 32000);
+	});
+
+	it("custom model with maxTokens 65 k is stored at full value", () => {
+		const registry = createRegistry({
+			providers: {
+				"dashscope-custom": {
+					baseUrl: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "qwen3.5-plus",
+							name: "Qwen3.5 Plus",
+							maxTokens: 65536,
+							contextWindow: 1000000,
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "qwen3.5-plus" && m.provider === "dashscope-custom");
+		assert.ok(model);
+		assert.equal(model.maxTokens, 65536);
+	});
+});
+
+// ─── Bug 2: capabilities.supportsXhigh must be declarable in models.json ──────
+
+describe("Bug 2 — capabilities.supportsXhigh in models.json (#4563)", () => {
+	it("model with capabilities.supportsXhigh: true surfaces the flag", () => {
+		const registry = createRegistry({
+			providers: {
+				"kimi-custom": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "anthropic-messages",
+					models: [
+						{
+							id: "kimi-k2.6-code-preview",
+							name: "Kimi K2.6 Code Preview",
+							maxTokens: 131072,
+							contextWindow: 262144,
+							capabilities: { supportsXhigh: true },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "kimi-k2.6-code-preview");
+		assert.ok(model, "model should be registered");
+		assert.equal(
+			model.capabilities?.supportsXhigh,
+			true,
+			"supportsXhigh must be true as declared in models.json",
+		);
+	});
+
+	it("model without capabilities declaration has no supportsXhigh", () => {
+		const registry = createRegistry({
+			providers: {
+				"plain-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [{ id: "plain-model", maxTokens: 16384, contextWindow: 128000 }],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "plain-model");
+		assert.ok(model);
+		// supportsXhigh should be absent or explicitly false — never implicitly true
+		assert.ok(
+			!model.capabilities?.supportsXhigh,
+			"supportsXhigh must not be set for models that don't declare it",
+		);
+	});
+
+	it("capabilities.supportsXhigh: false is respected", () => {
+		const registry = createRegistry({
+			providers: {
+				"explicit-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "no-xhigh-model",
+							capabilities: { supportsXhigh: false },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "no-xhigh-model");
+		assert.ok(model);
+		assert.equal(model.capabilities?.supportsXhigh, false);
+	});
+
+	it("supportsXhigh declared in models.json is not overwritten by capability patches", () => {
+		// The capability-patches system must not overwrite an explicit declaration in models.json.
+		// applyCapabilityPatches uses spread: { ...patch.caps, ...model.capabilities }
+		// so model.capabilities wins. This test verifies the precedence end-to-end.
+		const registry = createRegistry({
+			providers: {
+				"compat-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "custom-xhigh-model",
+							capabilities: { supportsXhigh: true },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "custom-xhigh-model");
+		assert.ok(model);
+		assert.equal(model.capabilities?.supportsXhigh, true);
+	});
+
+	it("modelOverrides can set capabilities.supportsXhigh on built-in models", () => {
+		// A user-facing override in models.json should be able to add supportsXhigh
+		// to a built-in model that doesn't declare it.
+		const path = writeModelsJson({
+			providers: {
+				anthropic: {
+					modelOverrides: {
+						"claude-3-5-haiku-20241022": {
+							capabilities: { supportsXhigh: true },
+						},
+					},
+				},
+			},
+		});
+
+		const registry = new ModelRegistry(AuthStorage.inMemory(), path);
+		const model = registry.getAll().find(
+			(m) => m.provider === "anthropic" && m.id === "claude-3-5-haiku-20241022",
+		);
+		assert.ok(model, "built-in model must still be present");
+		assert.equal(
+			model.capabilities?.supportsXhigh,
+			true,
+			"modelOverrides must be able to set capabilities.supportsXhigh",
+		);
+	});
+});

package/packages/pi-coding-agent/src/core/model-registry.ts

@@ -48,6 +48,14 @@ const VercelGatewayRoutingSchema = Type.Object({
 	order: Type.Optional(Type.Array(Type.String())),
 });
 
+// Schema for model capability declarations (mirrors ModelCapabilities in pi-ai types)
+const ModelCapabilitiesSchema = Type.Object({
+	supportsXhigh: Type.Optional(Type.Boolean()),
+	requiresToolCallId: Type.Optional(Type.Boolean()),
+	supportsServiceTier: Type.Optional(Type.Boolean()),
+	charsPerToken: Type.Optional(Type.Number()),
+});
+
 // Schema for OpenAI compatibility settings
 const OpenAICompletionsCompatSchema = Type.Object({
 	supportsStore: Type.Optional(Type.Boolean()),
@@ -91,6 +99,7 @@ const ModelDefinitionSchema = Type.Object({
 	maxTokens: Type.Optional(Type.Number()),
 	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
 	compat: Type.Optional(OpenAICompatSchema),
+	capabilities: Type.Optional(ModelCapabilitiesSchema),
 });
 
 // Schema for per-model overrides (all fields optional, merged with built-in model)
@@ -110,6 +119,7 @@ const ModelOverrideSchema = Type.Object({
 	maxTokens: Type.Optional(Type.Number()),
 	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
 	compat: Type.Optional(OpenAICompatSchema),
+	capabilities: Type.Optional(ModelCapabilitiesSchema),
 });
 
 type ModelOverride = Static<typeof ModelOverrideSchema>;
@@ -219,6 +229,11 @@ function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<A
 	// Deep merge compat
 	result.compat = mergeCompat(model.compat, override.compat);
 
+	// Merge capabilities (override wins per-field)
+	if (override.capabilities) {
+		result.capabilities = { ...model.capabilities, ...override.capabilities };
+	}
+
 	return result;
 }
 
@@ -514,6 +529,7 @@ export class ModelRegistry {
 					maxTokens: modelDef.maxTokens ?? 16384,
 					headers,
 					compat: modelDef.compat,
+					capabilities: modelDef.capabilities,
 				} as Model<Api>);
 			}
 		}

package/packages/pi-coding-agent/src/core/resource-loader-cache-reset.test.ts

@@ -1,42 +1,107 @@
-// GSD-2 — Regression test for #3616: reload() must reset jiti extension loader cache
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// Regression test for #3616: DefaultResourceLoader.reload() must invalidate
+// the jiti module cache before loading extensions, so that edits to
+// extension source on disk are picked up on the next reload (not served
+// stale from memory).
+//
+// Verified end-to-end behaviourally: we write a .ts extension that
+// registers a tool whose NAME is a module-scope constant, load it,
+// rewrite the source with a new constant value, reload(), and assert
+// the observable tool name reflects the NEW source. Without jiti cache
+// invalidation, the second reload would re-register the stale name.
 
-import test, { describe } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
 
-const source = readFileSync(
-	join(process.cwd(), "packages/pi-coding-agent/src/core/resource-loader.ts"),
-	"utf-8",
-);
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SettingsManager } from "./settings-manager.js";
+import { resetExtensionLoaderCache } from "./extensions/loader.js";
 
-describe("#3616 — reload() must invalidate jiti module cache", () => {
-	test("resource-loader imports resetExtensionLoaderCache from loader.js", () => {
-		assert.ok(
-			source.includes("resetExtensionLoaderCache"),
-			"resource-loader.ts should import resetExtensionLoaderCache",
-		);
-		assert.ok(
-			source.includes('from "./extensions/loader.js"'),
-			"resetExtensionLoaderCache should be imported from extensions/loader.js",
-		);
+let testDir: string;
+
+function writeExtensionWithToolName(extPath: string, toolName: string): void {
+	// Extension factory signature expected by the loader. Uses `any` so the
+	// test stays decoupled from the ExtensionAPI type shape.
+	writeFileSync(
+		extPath,
+		[
+			`const TOOL_NAME = "${toolName}";`,
+			`export default function activate(api: any) {`,
+			`  api.registerTool({`,
+			`    name: TOOL_NAME,`,
+			`    label: TOOL_NAME,`,
+			`    description: "test tool — source-generated name",`,
+			`    parameters: { type: "object", properties: {}, additionalProperties: false },`,
+			`    execute: async () => ({ content: [], details: undefined }),`,
+			`  });`,
+			`}`,
+			"",
+		].join("\n"),
+	);
+}
+
+describe("#3616 — DefaultResourceLoader.reload() invalidates extension module cache", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "resource-loader-cache-reset-"));
+		// Ensure a clean jiti singleton — prior tests in this process may
+		// have populated it with unrelated entries.
+		resetExtensionLoaderCache();
+	});
+
+	afterEach(() => {
+		resetExtensionLoaderCache();
+		rmSync(testDir, { recursive: true, force: true });
 	});
 
-	test("reload() calls resetExtensionLoaderCache before loadExtensions", () => {
-		const reloadStart = source.indexOf("async reload(): Promise<void>");
-		assert.ok(reloadStart >= 0, "should find reload() method");
-		const reloadBody = source.slice(reloadStart, reloadStart + 4000);
+	it("reload() picks up source edits after the extension has been loaded once", async () => {
+		const agentDir = join(testDir, "agent-home");
+		const extPath = join(testDir, "reload-probe.ts");
 
-		const resetIdx = reloadBody.indexOf("resetExtensionLoaderCache()");
-		assert.ok(resetIdx >= 0, "reload() should call resetExtensionLoaderCache()");
+		// v1 — initial content
+		writeExtensionWithToolName(extPath, "probe_v1");
 
-		const loadIdx = reloadBody.indexOf("loadExtensions(");
-		assert.ok(loadIdx >= 0, "reload() should call loadExtensions");
+		const loader = new DefaultResourceLoader({
+			cwd: testDir,
+			agentDir,
+			settingsManager: SettingsManager.inMemory(),
+			noExtensions: true,
+			noPromptTemplates: true,
+			noThemes: true,
+			additionalExtensionPaths: [extPath],
+		});
 
+		await loader.reload();
+
+		const toolsV1 = [...loader.getExtensions().extensions.flatMap((e) => [...e.tools.keys()])];
+		assert.ok(
+			toolsV1.includes("probe_v1"),
+			`first reload should register probe_v1; got=${JSON.stringify(toolsV1)}`,
+		);
+
+		// v2 — overwrite the source on disk with a different tool name.
+		writeExtensionWithToolName(extPath, "probe_v2");
+		// Bump mtime explicitly so file-stat–based cache strategies (jiti's
+		// moduleCache consults Node's require.cache, which some runtimes
+		// tiebreak on mtime) always see "newer than last seen". On Windows
+		// NTFS + node the default fs mtime resolution can silently collapse
+		// two writes in the same tick to an identical mtime — that fooled
+		// the Windows CI run on #3616.
+		const futureTime = new Date(Date.now() + 5000);
+		utimesSync(extPath, futureTime, futureTime);
+
+		await loader.reload();
+
+		const toolsV2 = [...loader.getExtensions().extensions.flatMap((e) => [...e.tools.keys()])];
+		assert.ok(
+			toolsV2.includes("probe_v2"),
+			`second reload must observe the edited source (probe_v2) — if reload() ` +
+				`fails to reset the jiti cache, the stale module returns probe_v1. got=${JSON.stringify(toolsV2)}`,
+		);
 		assert.ok(
-			resetIdx < loadIdx,
-			"resetExtensionLoaderCache() must be called BEFORE loadExtensions to ensure fresh modules",
+			!toolsV2.includes("probe_v1"),
+			`second reload must NOT still expose the stale probe_v1 name; got=${JSON.stringify(toolsV2)}`,
 		);
 	});
 });

package/packages/pi-coding-agent/src/core/resource-loader.ts

@@ -242,7 +242,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 		this.systemPromptOverride = options.systemPromptOverride;
 		this.appendSystemPromptOverride = options.appendSystemPromptOverride;
 
-		this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() };
+		this.extensionsResult = { extensions: [], errors: [], warnings: [], runtime: createExtensionRuntime() };
 		this.skills = [];
 		this.skillDiagnostics = [];
 		this.prompts = [];

package/packages/pi-coding-agent/src/core/retry-handler.test.ts

@@ -281,7 +281,11 @@ describe("RetryHandler — long-context entitlement 429 (#2803)", () => {
 			assert.equal(result, true, "retry should be initiated");
 
 			handler.abortRetry();
-			await new Promise((resolve) => setTimeout(resolve, 10));
+			// Yield the microtask queue so any synchronous continuation
+			// scheduled by abortRetry() settles before we assert. This is
+			// deterministic — no magic-sleep dependency (#4798 / #4784).
+			await Promise.resolve();
+			await Promise.resolve();
 
 			assert.equal(continueFn.mock.calls.length, 0, "cancelled retry must not continue after explicit abort");
 			const endEvents = emittedEvents.filter((e) => e.type === "auto_retry_end");

package/packages/pi-coding-agent/src/core/retry-handler.ts

@@ -18,6 +18,7 @@ import type { ModelRegistry } from "./model-registry.js";
 import type { SettingsManager } from "./settings-manager.js";
 import { sleep } from "../utils/sleep.js";
 import type { AgentSessionEvent } from "./agent-session.js";
+import { RETRYABLE_ERROR_RE } from "./retryable-error-regex.js";
 
 /** Dependencies injected from AgentSession into RetryHandler */
 export interface RetryHandlerDeps {
@@ -111,14 +112,7 @@ export class RetryHandler {
 		const contextWindow = this._deps.getModel()?.contextWindow ?? 0;
 		if (isContextOverflow(message, contextWindow)) return false;
 
-		const err = message.errorMessage;
-		// "temporarily backed off" is intentionally excluded: it is an internally-
-		// generated error from getApiKey() when credentials are in a backoff window.
-		// Re-entering the retry handler for that message creates a cascade of empty
-		// error entries in the session file, breaking resume (#3429).
-		return /overloaded|rate.?limit|too many requests|402|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|requires more credits|can only afford|insufficient credits|not enough credits|extra usage is required|(?:out of|no) extra usage|third.party.*draw from extra|third.party.*not.*available/i.test(
-			err,
-		);
+		return RETRYABLE_ERROR_RE.test(message.errorMessage);
 	}
 
 	/**

package/packages/pi-coding-agent/src/core/retryable-error-regex.ts

@@ -0,0 +1,18 @@
+/**
+ * Regex matching retryable provider errors — overloaded, rate limits, transient
+ * server/connection failures, credential-backoff, quota/credit issues.
+ *
+ * Kept in its own zero-import module so tests can consume the live pattern
+ * without pulling in the full RetryHandler dependency graph (Agent /
+ * FallbackResolver / ModelRegistry / @gsd/pi-ai …). The test in
+ * `src/resources/extensions/gsd/tests/provider-errors.test.ts` previously
+ * redefined this regex inline, which meant runtime and test could drift
+ * silently on every edit (see #4837).
+ *
+ * "temporarily backed off" is intentionally excluded: it is an internally-
+ * generated error from getApiKey() when credentials are in a backoff window.
+ * Re-entering the retry handler for that message creates a cascade of empty
+ * error entries in the session file, breaking resume (#3429).
+ */
+export const RETRYABLE_ERROR_RE =
+	/overloaded|rate.?limit|too many requests|402|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|requires more credits|can only afford|insufficient credits|not enough credits|extra usage is required|(?:out of|no) extra usage|third.party.*draw from extra|third.party.*not.*available/i;

package/packages/pi-coding-agent/src/core/sdk.test.ts

@@ -3,7 +3,8 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { CredentialCooldownError } from "./sdk.js";
+import { canRestoreSessionModel, CredentialCooldownError } from "./sdk.js";
+import type { Model } from "@gsd/pi-ai";
 
 // ─── CredentialCooldownError ──────────────────────────────────────────────────
 
@@ -87,3 +88,26 @@ describe("CredentialCooldownError", () => {
 		assert.equal(plain.retryAfterMs, 15_000);
 	});
 });
+
+describe("canRestoreSessionModel", () => {
+	const model = {
+		provider: "claude-code",
+		id: "claude-sonnet",
+	} as Model<any>;
+
+	it("allows keyless external providers when the provider is request-ready", () => {
+		const registry = {
+			isProviderRequestReady: (provider: string) => provider === "claude-code",
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), true);
+	});
+
+	it("blocks restore when the provider is not request-ready", () => {
+		const registry = {
+			isProviderRequestReady: () => false,
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), false);
+	});
+});

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -31,6 +31,13 @@ export class CredentialCooldownError extends Error {
 		this.retryAfterMs = retryAfterMs;
 	}
 }
+
+export function canRestoreSessionModel(
+	modelRegistry: Pick<ModelRegistry, "isProviderRequestReady">,
+	model: Model<any>,
+): boolean {
+	return modelRegistry.isProviderRequestReady(model.provider);
+}
 import { Agent, type AgentMessage, type ThinkingLevel } from "@gsd/pi-agent-core";
 import type { Message, Model } from "@gsd/pi-ai";
 import { getAgentDir, getDocsPath } from "../config.js";
@@ -262,9 +269,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// If session has data, try to restore model from it
 	if (!model && hasExistingSession && existingSession.model) {
 		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
+			if (restoredModel && canRestoreSessionModel(modelRegistry, restoredModel)) {
+				model = restoredModel;
+			}
 		if (!model) {
 			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
 		}

package/packages/pi-coding-agent/src/core/session-manager.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it, afterEach } from "node:test";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -97,4 +97,33 @@ describe("SessionManager secret redaction on persistence", () => {
 			"redaction placeholder must appear in persisted JSONL",
 		);
 	});
+
+	it("scrubs secrets from JSONL rewritten by _rewriteFile() during migration", () => {
+		// Write a v1 session file (no id/parentId on entries) containing a secret.
+		// setSessionFile() will detect version < 3, run migration, and call _rewriteFile()
+		// which previously serialised entries without passing them through redaction.
+		dir = mkdtempSync(join(tmpdir(), "gsd-session-rewrite-redact-test-"));
+		const leakedKey = "sk-ant-api03-abcDEF1234567890abcDEF1234567890xYz";
+		const v1Header = JSON.stringify({ type: "session", version: 1, id: "test-session-id", timestamp: new Date().toISOString(), cwd: dir });
+		const v1UserMsg = JSON.stringify({ type: "message", message: { role: "user", content: [{ type: "text", text: `secret: ${leakedKey}` }] } });
+		const v1AssistantMsg = JSON.stringify({ type: "message", message: { role: "assistant", content: [{ type: "text", text: "ok" }], usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, total: 2, cost: { total: 0 } } } });
+		const sessionFile = join(dir, "test-session.jsonl");
+		writeFileSync(sessionFile, [v1Header, v1UserMsg, v1AssistantMsg].join("\n") + "\n", "utf8");
+
+		// Loading this file triggers migrateToCurrentVersion() which returns true (v1 → v3),
+		// causing _rewriteFile() to rewrite the file. The bug: _rewriteFile() called
+		// JSON.stringify(e) without redaction, so the secret would survive on disk.
+		const manager = SessionManager.create(dir, dir);
+		manager.setSessionFile(sessionFile);
+
+		const contents = readFileSync(sessionFile, "utf8");
+		assert.ok(
+			!contents.includes(leakedKey),
+			"raw secret must not appear in JSONL rewritten by _rewriteFile()",
+		);
+		assert.ok(
+			contents.includes("[REDACTED:anthropic]"),
+			"redaction placeholder must appear in JSONL rewritten by _rewriteFile()",
+		);
+	});
 });

package/packages/pi-coding-agent/src/core/session-manager.ts

@@ -959,7 +959,7 @@ export class SessionManager {
 
 	private _rewriteFile(): void {
 		if (!this.persist || !this.sessionFile) return;
-		const content = `${this.fileEntries.map((e) => JSON.stringify(e)).join("\n")}\n`;
+		const content = `${this.fileEntries.map((e) => JSON.stringify(prepareForPersistence(e, this.blobStore))).join("\n")}\n`;
 		let release: (() => void) | undefined;
 		try {
 			release = tryAcquireLockSync(this.sessionFile);