@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.6

package/src/plan-mode/approved-plan-prompt.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { prompt } from "@oh-my-pi/pi-utils";
-import planModeApprovedPrompt from "../prompts/system/plan-mode-approved.md" with { type: "text" };
-import planModeCompactInstructionsPrompt from "../prompts/system/plan-mode-compact-instructions.md" with {
-	type: "text",
-};
-import planModeReferencePrompt from "../prompts/system/plan-mode-reference.md" with { type: "text" };
-
-const PLAN_FILE_PATH = "local://durable-plan.md";
-const PLAN_SENTINEL = "SENTINEL_HEADROOM_COMPRESSED_PLAN_CONTENT";
-
-describe("approved plan execution prompts", () => {
-	it("requires reading the durable plan file without inlining plan content", () => {
-		const approved = prompt.render(planModeApprovedPrompt, {
-			planContent: PLAN_SENTINEL,
-			planFilePath: PLAN_FILE_PATH,
-			contextPreserved: false,
-		});
-		const reference = prompt.render(planModeReferencePrompt, {
-			planContent: PLAN_SENTINEL,
-			planFilePath: PLAN_FILE_PATH,
-		});
-		const compact = prompt.render(planModeCompactInstructionsPrompt, {
-			planFilePath: PLAN_FILE_PATH,
-		});
-
-		for (const rendered of [approved, reference, compact]) {
-			expect(rendered).toContain(PLAN_FILE_PATH);
-		}
-		for (const rendered of [approved, reference, compact]) {
-			expect(rendered).not.toContain(PLAN_SENTINEL);
-		}
-		expect(approved).toContain("MUST read `local://durable-plan.md`");
-		expect(reference).toContain("MUST read `local://durable-plan.md`");
-	});
-});

package/src/plan-mode/model-transition.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
-import type { ResolvedModelRoleValue } from "../config/model-resolver";
-import { AUTO_THINKING } from "../thinking";
-import { resolvePlanModelTransition } from "./model-transition";
-
-/**
- * Plan-mode model transition policy (issue #5657). The active model in plan
- * mode IS the plan-role model, so reassigning that role mid-planning must move
- * the session onto the new model — or defer the switch when a turn is streaming.
- */
-const model = (provider: string, id: string): Model => ({ provider, id }) as unknown as Model;
-
-const resolved = (
-	m: Model | undefined,
-	thinking?: ResolvedModelRoleValue["thinkingLevel"],
-): ResolvedModelRoleValue => ({
-	model: m,
-	thinkingLevel: thinking,
-	explicitThinkingLevel: thinking !== undefined,
-	warning: undefined,
-});
-
-describe("resolvePlanModelTransition", () => {
-	it("switches to the resolved plan model when it differs from the active one", () => {
-		const plan = model("anthropic", "opus");
-		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(plan), false);
-		expect(transition).toEqual({ kind: "apply", model: plan, thinkingLevel: undefined, deferred: false });
-	});
-
-	it("defers the switch while the session is streaming", () => {
-		const plan = model("anthropic", "opus");
-		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(plan), true);
-		expect(transition).toEqual({ kind: "apply", model: plan, thinkingLevel: undefined, deferred: true });
-	});
-
-	it("carries the plan role's explicit thinking level into the switch", () => {
-		const plan = model("anthropic", "opus");
-		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(plan, ThinkingLevel.High), false);
-		expect(transition).toEqual({ kind: "apply", model: plan, thinkingLevel: ThinkingLevel.High, deferred: false });
-	});
-
-	it("only adjusts thinking when the model is unchanged but the level is explicit", () => {
-		const plan = model("anthropic", "opus");
-		const transition = resolvePlanModelTransition(plan, resolved(model("anthropic", "opus"), AUTO_THINKING), false);
-		expect(transition).toEqual({ kind: "thinking", thinkingLevel: AUTO_THINKING });
-	});
-
-	it("is a no-op when the model matches and no explicit thinking level is set", () => {
-		const plan = model("anthropic", "opus");
-		const transition = resolvePlanModelTransition(plan, resolved(model("anthropic", "opus")), false);
-		expect(transition).toEqual({ kind: "none" });
-	});
-
-	it("is a no-op when the plan role resolves to no model", () => {
-		const transition = resolvePlanModelTransition(model("openai", "gpt"), resolved(undefined), false);
-		expect(transition).toEqual({ kind: "none" });
-	});
-});

package/src/plan-mode/reentry-prompt.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { prompt } from "@oh-my-pi/pi-utils";
-import planModeActivePrompt from "../prompts/system/plan-mode-active.md" with { type: "text" };
-
-const BASE = {
-	planFilePath: "local://old-feature-plan.md",
-	askToolName: "ask",
-	writeToolName: "write",
-	editToolName: "edit",
-	isHashlineEditMode: false,
-	iterative: false,
-} as const;
-
-function render(overrides: { reentry: boolean; planExists: boolean }): string {
-	return prompt.render(planModeActivePrompt, { ...BASE, ...overrides });
-}
-
-describe("plan-mode re-entry prompt", () => {
-	it("only emits the Re-entry section when re-entering", () => {
-		expect(render({ reentry: false, planExists: true })).not.toContain("## Re-entry");
-		expect(render({ reentry: true, planExists: true })).toContain("## Re-entry");
-	});
-
-	it("anchors the turn on the new request, not the old plan", () => {
-		const rendered = render({ reentry: true, planExists: true });
-		const reentry = rendered.slice(rendered.indexOf("## Re-entry"));
-		// The new request is the primary input; the old plan is reference only.
-		expect(reentry).toMatch(/NEW request[\s\S]*primary input/);
-		// Corrections to an incomplete old plan must be folded into the new plan,
-		// never substituted for it (the reported failure: dropping the new request).
-		expect(reentry).toMatch(/combine, never substitute/);
-	});
-
-	it("does not contradict the planExists guidance on a different task", () => {
-		const rendered = render({ reentry: true, planExists: true });
-		// planExists branch: different task -> leave old plan, write a fresh file.
-		expect(rendered).toContain("leave that plan in place and start a fresh");
-		// Re-entry must agree; the old "Different task -> overwrite it" directive is gone.
-		expect(rendered).not.toMatch(/[Dd]ifferent task → overwrite/);
-	});
-});

package/src/session/agent-session-error-log.test.ts

@@ -1,59 +0,0 @@
-/**
- * Contract: a turn ending in a provider error surfaces one warn-level log
- * carrying `provider`/`model`/`errorMessage`/`errorStatus`/`errorId`, so
- * recurring provider stream failures are diagnosable from the main log alone
- * (issue #6177). Non-error stops must not emit it.
- */
-import { afterAll, afterEach, describe, expect, it } from "bun:test";
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import { logger } from "@oh-my-pi/pi-utils";
-import { logProviderTurnError } from "./messages";
-
-function makeMessage(overrides: Partial<AssistantMessage>): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [],
-		api: "cursor",
-		provider: "cursor",
-		model: "composer-2.5",
-		usage: {} as AssistantMessage["usage"],
-		stopReason: "error",
-		timestamp: 1,
-		...overrides,
-	};
-}
-
-describe("logProviderTurnError", () => {
-	const events: logger.LogEvent[] = [];
-	const dispose = logger.registerLogSink(event => events.push(event));
-
-	afterEach(() => {
-		events.length = 0;
-	});
-	afterAll(() => dispose());
-
-	it("emits a warn log with the provider error fields for stopReason:error", () => {
-		logProviderTurnError(
-			makeMessage({
-				errorMessage: "stream stall: idle watchdog fired",
-				errorStatus: 500,
-				errorId: 42,
-			}),
-		);
-
-		const warn = events.find(e => e.level === "warn" && e.message === "agent turn ended with provider error");
-		expect(warn).toBeDefined();
-		expect(warn?.context).toMatchObject({
-			provider: "cursor",
-			model: "composer-2.5",
-			errorMessage: "stream stall: idle watchdog fired",
-			errorStatus: 500,
-			errorId: 42,
-		});
-	});
-
-	it("does not emit for a successful stop", () => {
-		logProviderTurnError(makeMessage({ stopReason: "stop", errorMessage: undefined }));
-		expect(events.some(e => e.message === "agent turn ended with provider error")).toBe(false);
-	});
-});

package/src/session/blob-store.test.ts

@@ -1,56 +0,0 @@
-import { afterAll, describe, expect, it } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { BlobStore, parseBlobRef, resolveImageData, resolveImageDataSync, resolveImageDataUrl } from "./blob-store";
-
-const base = fs.mkdtempSync(path.join(os.tmpdir(), "blob-store-test-"));
-const blobDir = path.join(base, "agent", "blobs", "data");
-fs.mkdirSync(blobDir, { recursive: true });
-fs.writeFileSync(path.join(base, "secret.txt"), "TOP-SECRET-CONTENTS");
-const store = new BlobStore(blobDir);
-
-afterAll(() => {
-	fs.rmSync(base, { recursive: true, force: true });
-});
-
-describe("parseBlobRef validation", () => {
-	it("accepts a canonical 64-char lowercase hex suffix", () => {
-		const hash = "a".repeat(64);
-		expect(parseBlobRef(`blob:sha256:${hash}`)).toBe(hash);
-	});
-
-	it("returns null for non-blob strings", () => {
-		expect(parseBlobRef("data:image/png;base64,AAAA")).toBeNull();
-	});
-
-	it.each([
-		"../../../secret.txt",
-		`${"../".repeat(6)}etc/passwd`,
-		"A".repeat(64), // uppercase hex is not the canonical shape
-		"a".repeat(63), // too short
-		"a".repeat(65), // too long
-		"", // empty
-	])("rejects malformed suffix %p", suffix => {
-		expect(parseBlobRef(`blob:sha256:${suffix}`)).toBeNull();
-	});
-});
-
-describe("blob resolution path confinement", () => {
-	const traversalRef = "blob:sha256:../../../secret.txt";
-
-	it("leaves a traversal ref unresolved instead of reading outside the blob dir (base64 path)", async () => {
-		expect(await resolveImageData(store, traversalRef)).toBe(traversalRef);
-		expect(resolveImageDataSync(store, traversalRef)).toBe(traversalRef);
-	});
-
-	it("leaves a traversal ref unresolved instead of reading outside the blob dir (data-url path)", async () => {
-		expect(await resolveImageDataUrl(store, traversalRef)).toBe(traversalRef);
-	});
-
-	it("still resolves a valid stored blob", async () => {
-		const put = store.putSync(Buffer.from("hello"));
-		expect(Buffer.from(resolveImageDataSync(store, put.ref), "base64").toString("utf8")).toBe("hello");
-		expect(Buffer.from(await resolveImageData(store, put.ref), "base64").toString("utf8")).toBe("hello");
-	});
-});

package/src/session/messages.test.ts

@@ -1,282 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import {
-	type CustomMessage,
-	convertToLlm,
-	INTERRUPTED_THINKING_MESSAGE_TYPE,
-	replaceLlmImagesWithText,
-	SKILL_PROMPT_MESSAGE_TYPE,
-	type SkillPromptDetails,
-	stripImagesFromMessage,
-} from "./messages";
-
-function customMessage(customType: string, attribution: "agent" | "user"): CustomMessage<SkillPromptDetails> {
-	return {
-		role: "custom",
-		customType,
-		content: "Use this skill.",
-		display: true,
-		details: { name: "atomic-commit", path: "/tmp/SKILL.md", lineCount: 1 },
-		attribution,
-		timestamp: 1,
-	};
-}
-
-const interruptedUsage: AssistantMessage["usage"] = {
-	input: 0,
-	output: 0,
-	cacheRead: 0,
-	cacheWrite: 0,
-	totalTokens: 0,
-	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-};
-
-function abortedAssistant(content: AssistantMessage["content"]): AssistantMessage {
-	return {
-		role: "assistant",
-		content,
-		api: "anthropic-messages",
-		provider: "anthropic",
-		model: "claude-sonnet-4-5",
-		usage: interruptedUsage,
-		stopReason: "aborted",
-		timestamp: 1,
-	};
-}
-
-function interruptedThinkingContinuity(): CustomMessage {
-	return {
-		role: "custom",
-		customType: INTERRUPTED_THINKING_MESSAGE_TYPE,
-		content: "preserved reasoning",
-		display: false,
-		attribution: "agent",
-		timestamp: 2,
-	};
-}
-
-describe("convertToLlm", () => {
-	it("presents user-invoked skill prompts as user turns", () => {
-		const [message] = convertToLlm([customMessage(SKILL_PROMPT_MESSAGE_TYPE, "user")]);
-
-		expect(message?.role).toBe("user");
-		if (message?.role !== "user") {
-			throw new Error(`Expected user role, received ${message?.role ?? "none"}`);
-		}
-		expect(message.attribution).toBe("user");
-	});
-
-	it("keeps auto-applied skill prompts and other custom messages as developer turns", () => {
-		const [autoSkill, otherCustom] = convertToLlm([
-			customMessage(SKILL_PROMPT_MESSAGE_TYPE, "agent"),
-			customMessage("extension-note", "user"),
-		]);
-
-		expect(autoSkill?.role).toBe("developer");
-		expect(otherCustom?.role).toBe("developer");
-	});
-
-	it("strips the demoted trailing thinking run from the assistant LLM view when its continuity message follows", () => {
-		const messages: AgentMessage[] = [
-			abortedAssistant([
-				{ type: "text", text: "partial answer" },
-				{ type: "thinking", thinking: "interrupted reasoning" },
-			]),
-			interruptedThinkingContinuity(),
-		];
-
-		const llm = convertToLlm(messages);
-		const assistant = llm.find(entry => entry.role === "assistant");
-		expect(Array.isArray(assistant?.content) && assistant.content.map(block => block.type)).toEqual(["text"]);
-		expect(llm.some(entry => entry.role === "developer")).toBe(true);
-	});
-
-	it("keeps trailing thinking on the assistant LLM view when no continuity message follows", () => {
-		const messages: AgentMessage[] = [
-			abortedAssistant([
-				{ type: "text", text: "partial answer" },
-				{ type: "thinking", thinking: "interrupted reasoning" },
-			]),
-		];
-
-		const llm = convertToLlm(messages);
-		const assistant = llm.find(entry => entry.role === "assistant");
-		expect(Array.isArray(assistant?.content) && assistant.content.map(block => block.type)).toEqual([
-			"text",
-			"thinking",
-		]);
-	});
-
-	it("keeps a signed (complete) trailing thinking block in the assistant LLM view even with a continuity message", () => {
-		const messages: AgentMessage[] = [
-			abortedAssistant([
-				{ type: "text", text: "partial answer" },
-				{ type: "thinking", thinking: "complete reasoning", thinkingSignature: "sig" },
-			]),
-			interruptedThinkingContinuity(),
-		];
-
-		const llm = convertToLlm(messages);
-		const assistant = llm.find(entry => entry.role === "assistant");
-		expect(Array.isArray(assistant?.content) && assistant.content.map(block => block.type)).toEqual([
-			"text",
-			"thinking",
-		]);
-	});
-});
-
-function settledAssistant(text: string): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [{ type: "text", text }],
-		api: "anthropic-messages",
-		provider: "anthropic",
-		model: "claude-sonnet-4-5",
-		usage: {
-			input: 100,
-			output: 20,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 120,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-		},
-		stopReason: "stop",
-		timestamp: 1,
-	};
-}
-
-function userMessage(text: string, timestamp: number): AgentMessage {
-	return { role: "user", content: text, attribution: "user", timestamp } as AgentMessage;
-}
-
-describe("convertToLlm caching", () => {
-	it("reuses the outer array on an exact repeat of the same history", () => {
-		const messages: AgentMessage[] = [userMessage("hello", 1), settledAssistant("hi")];
-		const first = convertToLlm(messages);
-		const second = convertToLlm(messages);
-		expect(second).toBe(first);
-	});
-
-	it("reuses the unchanged prefix output on append-only growth", () => {
-		const messages: AgentMessage[] = [userMessage("one", 1), settledAssistant("reply one")];
-		const first = convertToLlm(messages);
-		messages.push(userMessage("two", 2));
-		const grown = convertToLlm(messages);
-		// New outer array (no held-result aliasing), but the converted prefix is
-		// byte-identical and the appended turn is present.
-		expect(grown).not.toBe(first);
-		expect(grown.length).toBe(first.length + 1);
-		expect(grown.slice(0, first.length)).toEqual(first);
-		expect(grown[grown.length - 1]?.role).toBe("user");
-	});
-
-	it("recomputes the boundary assistant when a following interrupted-thinking marker appears on growth", () => {
-		const messages: AgentMessage[] = [
-			abortedAssistant([
-				{ type: "text", text: "partial answer" },
-				{ type: "thinking", thinking: "interrupted reasoning" },
-			]),
-		];
-		const before = convertToLlm(messages);
-		const beforeAssistant = before.find(entry => entry.role === "assistant");
-		expect(Array.isArray(beforeAssistant?.content) && beforeAssistant.content.map(b => b.type)).toEqual([
-			"text",
-			"thinking",
-		]);
-
-		// Append the continuity marker on the same array: the assistant is now the
-		// boundary message and its LLM view must drop the trailing thinking run.
-		messages.push(interruptedThinkingContinuity());
-		const after = convertToLlm(messages);
-		const afterAssistant = after.find(entry => entry.role === "assistant");
-		expect(Array.isArray(afterAssistant?.content) && afterAssistant.content.map(b => b.type)).toEqual(["text"]);
-	});
-
-	it("recomputes a message after strip-images invalidates its cache", () => {
-		const withImage: AgentMessage = {
-			role: "user",
-			content: [
-				{ type: "text", text: "look" },
-				{ type: "image", data: "aaaa", mimeType: "image/png" },
-			],
-			attribution: "user",
-			timestamp: 1,
-		};
-		const messages: AgentMessage[] = [withImage];
-		const before = convertToLlm(messages);
-		const beforeUser = before.find(entry => entry.role === "user");
-		expect(Array.isArray(beforeUser?.content) && beforeUser.content.some(b => b.type === "image")).toBe(true);
-
-		// Mutate in place through the owner seam, which must invalidate the cache.
-		stripImagesFromMessage(withImage);
-		const after = convertToLlm(messages);
-		const afterUser = after.find(entry => entry.role === "user");
-		expect(Array.isArray(afterUser?.content) && afterUser.content.some(b => b.type === "image")).toBe(false);
-	});
-});
-
-describe("replaceLlmImagesWithText", () => {
-	it("replaces image blocks in user, developer, and tool-result messages with the placeholder", () => {
-		const converted = convertToLlm([
-			{
-				role: "user",
-				content: [
-					{ type: "text", text: "look" },
-					{ type: "image", data: "aaaa", mimeType: "image/png" },
-				],
-				attribution: "user",
-				timestamp: 1,
-			},
-			{
-				role: "toolResult",
-				toolCallId: "c1",
-				toolName: "inspect_image",
-				content: [{ type: "image", data: "bbbb", mimeType: "image/png" }],
-				isError: false,
-				timestamp: 2,
-			},
-		]);
-
-		const scrubbed = replaceLlmImagesWithText(converted, "[image omitted]");
-
-		expect(scrubbed).not.toBe(converted);
-		const types = scrubbed.flatMap(m => (Array.isArray(m.content) ? m.content.map(b => b.type) : []));
-		expect(types).not.toContain("image");
-		const user = scrubbed.find(m => m.role === "user");
-		expect(Array.isArray(user?.content) && user.content.map(b => (b.type === "text" ? b.text : b.type))).toEqual([
-			"look",
-			"[image omitted]",
-		]);
-		const toolResult = scrubbed.find(m => m.role === "toolResult");
-		expect(Array.isArray(toolResult?.content) && toolResult.content).toEqual([
-			{ type: "text", text: "[image omitted]" },
-		]);
-	});
-
-	it("collapses consecutive image blocks into a single placeholder", () => {
-		const converted = convertToLlm([
-			{
-				role: "user",
-				content: [
-					{ type: "image", data: "aaaa", mimeType: "image/png" },
-					{ type: "image", data: "bbbb", mimeType: "image/png" },
-				],
-				attribution: "user",
-				timestamp: 1,
-			},
-		]);
-
-		const scrubbed = replaceLlmImagesWithText(converted, "[image omitted]");
-		const user = scrubbed.find(m => m.role === "user");
-		expect(Array.isArray(user?.content) && user.content).toEqual([{ type: "text", text: "[image omitted]" }]);
-	});
-
-	it("returns the same array reference when there are no image blocks", () => {
-		const converted = convertToLlm([
-			{ role: "user", content: [{ type: "text", text: "hi" }], attribution: "user", timestamp: 1 },
-		]);
-
-		expect(replaceLlmImagesWithText(converted, "[image omitted]")).toBe(converted);
-	});
-});