@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/test/unit/fork-context.test.ts

@@ -4,7 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { SessionManager } from "@selesai/code";
-import { createForkContextResolver, resolveSubagentContext } from "../../src/shared/fork-context.ts";
+import { createForkContextResolver, forkedChildRequiresThinkingOff, resolveSubagentContext } from "../../src/shared/fork-context.ts";
 
 function writeMinimalSessionFile(filePath: string, id = "session"): void {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -27,6 +27,33 @@ describe("resolveSubagentContext", () => {
 	});
 });
 
+describe("forkedChildRequiresThinkingOff", () => {
+	it("treats missing and unresolved models conservatively", () => {
+		assert.equal(forkedChildRequiresThinkingOff(undefined), true);
+		assert.equal(forkedChildRequiresThinkingOff("unknown/model", []), true);
+	});
+
+	it("classifies resolved models by provider and API instead of model names", () => {
+		const availableModels = [
+			{ provider: "anthropic", id: "renamed", fullId: "anthropic/renamed", api: "custom-proxy" },
+			{ provider: "gateway", id: "gpt-shaped", fullId: "gateway/gpt-shaped", api: "anthropic-messages" },
+			{ provider: "openai", id: "claude-shaped", fullId: "openai/claude-shaped", api: "openai-responses" },
+		];
+		assert.equal(forkedChildRequiresThinkingOff("anthropic/renamed", availableModels), true);
+		assert.equal(forkedChildRequiresThinkingOff("gateway/gpt-shaped", availableModels), true);
+		assert.equal(forkedChildRequiresThinkingOff("openai/claude-shaped", availableModels), false);
+	});
+
+	it("uses the preferred provider for ambiguous bare ids", () => {
+		const availableModels = [
+			{ provider: "anthropic", id: "shared", fullId: "anthropic/shared", api: "anthropic-messages" },
+			{ provider: "openai", id: "shared", fullId: "openai/shared", api: "openai-responses" },
+		];
+		assert.equal(forkedChildRequiresThinkingOff("shared", availableModels, "anthropic"), true);
+		assert.equal(forkedChildRequiresThinkingOff("shared", availableModels, "openai"), false);
+	});
+});
+
 describe("createForkContextResolver", () => {
 	it("fresh mode never calls createBranchedSession", () => {
 		let calls = 0;
@@ -280,6 +307,72 @@ describe("createForkContextResolver", () => {
 		}
 	});
 
+	it("keeps requested thinking for forked children when the force-off predicate declines", () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-fork-keep-thinking-"));
+		try {
+			const parentSessionFile = path.join(tempDir, "parent.jsonl");
+			const childSessionFile = path.join(tempDir, "child.jsonl");
+			writeMinimalSessionFile(parentSessionFile, "parent");
+			writeSessionJsonl(childSessionFile, [
+				{ type: "session", version: 1, id: "child", timestamp: "2026-04-16T00:00:00.000Z", cwd: "/tmp", parentSession: parentSessionFile },
+				{ type: "message", id: "user-1", parentId: null, timestamp: "2026-04-16T00:00:01.000Z", message: { role: "user", content: "prompt" } },
+				{ type: "message", id: "assistant-1", parentId: "user-1", timestamp: "2026-04-16T00:00:02.000Z", message: { role: "assistant", provider: "anthropic", api: "anthropic-messages", model: "anthropic/claude-sonnet-4", content: [{ type: "thinking", thinking: "private chain", thinkingSignature: "signed" }, { type: "text", text: "answer" }] } },
+			]);
+			const requestedIndexes: number[] = [];
+			const resolver = createForkContextResolver({
+				getSessionFile: () => parentSessionFile,
+				getLeafId: () => "assistant-1",
+			}, "fork", {
+				openSession: () => ({
+					createBranchedSession: () => childSessionFile,
+				}),
+				forceThinkingOffForIndex: (index) => {
+					requestedIndexes.push(index);
+					return false;
+				},
+			});
+
+			assert.equal(resolver.sessionFileForIndex(0), childSessionFile);
+			assert.equal(resolver.thinkingOverrideForIndex(0), undefined);
+			assert.deepEqual(requestedIndexes, [0]);
+			const entries = fs.readFileSync(childSessionFile, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+			assert.deepEqual(entries[2].message.content, [{ type: "text", text: "answer" }]);
+			assert.equal(entries.length, 3);
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("still forces thinking off when the predicate confirms an Anthropic child", () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-fork-confirm-off-"));
+		try {
+			const parentSessionFile = path.join(tempDir, "parent.jsonl");
+			const childSessionFile = path.join(tempDir, "child.jsonl");
+			writeMinimalSessionFile(parentSessionFile, "parent");
+			writeSessionJsonl(childSessionFile, [
+				{ type: "session", version: 1, id: "child", timestamp: "2026-04-16T00:00:00.000Z", cwd: "/tmp", parentSession: parentSessionFile },
+				{ type: "message", id: "user-1", parentId: null, timestamp: "2026-04-16T00:00:01.000Z", message: { role: "user", content: "prompt" } },
+				{ type: "message", id: "assistant-1", parentId: "user-1", timestamp: "2026-04-16T00:00:02.000Z", message: { role: "assistant", provider: "anthropic", api: "anthropic-messages", model: "anthropic/claude-sonnet-4", content: [{ type: "thinking", thinking: "private chain", thinkingSignature: "signed" }, { type: "text", text: "answer" }] } },
+			]);
+			const resolver = createForkContextResolver({
+				getSessionFile: () => parentSessionFile,
+				getLeafId: () => "assistant-1",
+			}, "fork", {
+				openSession: () => ({
+					createBranchedSession: () => childSessionFile,
+				}),
+				forceThinkingOffForIndex: () => true,
+			});
+
+			assert.equal(resolver.thinkingOverrideForIndex(0), "off");
+			const entries = fs.readFileSync(childSessionFile, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+			assert.equal(entries[3].type, "thinking_level_change");
+			assert.equal(entries[3].thinkingLevel, "off");
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
 	it("allows unsigned thinking blocks in forked sessions", () => {
 		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-fork-unsigned-thinking-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/get-final-output.test.ts

@@ -81,6 +81,29 @@ describe("getFinalOutput", () => {
 		assert.equal(getFinalOutput(messages), report);
 	});
 
+	it("preserves prose from a sibling text part when selecting an acceptance report", () => {
+		const report = "```acceptance-report\n{}\n```";
+		const messages = [assistantContent([
+			{ type: "text", text: "Human-readable answer." },
+			{ type: "text", text: report },
+		])];
+
+		assert.equal(getFinalOutput(messages), `Human-readable answer.\n${report}`);
+	});
+
+	it("recognizes underscore fences and snake_case generic report keys", () => {
+		for (const report of [
+			"```acceptance_report\n{}\n```",
+			`\`\`\`json\n${JSON.stringify({ criteria_satisfied: [], validation_output: ["passed"] })}\n\`\`\``,
+		]) {
+			const messages = [
+				assistantContent([{ type: "text", text: report }]),
+				assistantContent([{ type: "text", text: "Later summary." }]),
+			];
+			assert.equal(getFinalOutput(messages), report);
+		}
+	});
+
 	it("does not prefer provider-error acceptance reports", () => {
 		const messages = [
 			{

package/dist/extensions/pi-subagents/test/unit/host-peer-runtime-imports.test.ts

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import { resolveCompileFromPackageRoot, validateStructuredOutputValue } from "../../src/runs/shared/structured-output.ts";
+import type { JsonSchemaObject } from "../../src/shared/types.ts";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+const hostPeerPackages = [
+	"@earendil-works/pi-agent-core",
+	"@earendil-works/pi-ai",
+	"@selesai/code",
+	"@earendil-works/pi-tui",
+	"typebox",
+] as const;
+
+function matchingHostPeerPackage(specifier: string): string | undefined {
+	return hostPeerPackages.find((pkg) => specifier === pkg || specifier.startsWith(`${pkg}/`));
+}
+
+/** Extract specifiers from top-level static import/export-from statements, skipping type-only lines. */
+function extractStaticImportSpecifiers(source: string): string[] {
+	const specifiers: string[] = [];
+	const lines = source.split("\n");
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i]!.trim();
+		if (!/^(?:import|export)\b/.test(line)) {
+			i++;
+			continue;
+		}
+		// Multi-line statements (e.g. `import {\n\tFoo,\n} from "x";`) continue past this line: keep
+		// pulling lines into one logical statement until we see the `from "..."` clause or a `;`.
+		let statement = line;
+		while (!/from\s+["'][^"']+["']/.test(statement) && !statement.includes(";") && i + 1 < lines.length) {
+			i++;
+			statement += ` ${lines[i]!.trim()}`;
+		}
+		i++;
+
+		if (/^import\s+type\b/.test(statement) || /^export\s+type\b/.test(statement)) continue;
+		const fromMatch = statement.match(/from\s+["']([^"']+)["']/);
+		if (fromMatch) {
+			specifiers.push(fromMatch[1]!);
+			continue;
+		}
+		const sideEffectMatch = statement.match(/^import\s+["']([^"']+)["']/);
+		if (sideEffectMatch) specifiers.push(sideEffectMatch[1]!);
+	}
+	return specifiers;
+}
+
+function resolveRelativeImport(fromFile: string, specifier: string): string | undefined {
+	const base = path.dirname(fromFile);
+	const candidates = [path.resolve(base, specifier), path.resolve(base, `${specifier}.ts`), path.resolve(base, specifier, "index.ts")];
+	return candidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+}
+
+test("detached async runner's runtime import graph never reaches a host peer package (issues #334, #526)", () => {
+	const entryPoint = path.join(projectRoot, "src", "runs", "background", "subagent-runner.ts");
+	const visited = new Set<string>([entryPoint]);
+	const queue: string[] = [entryPoint];
+	const violations: string[] = [];
+
+	while (queue.length > 0) {
+		const file = queue.shift()!;
+		const source = fs.readFileSync(file, "utf-8");
+		for (const specifier of extractStaticImportSpecifiers(source)) {
+			const hostPeerMatch = matchingHostPeerPackage(specifier);
+			if (hostPeerMatch) {
+				violations.push(`${path.relative(projectRoot, file)} has a runtime import of '${specifier}' (host peer package '${hostPeerMatch}')`);
+				continue;
+			}
+			if (!specifier.startsWith(".")) continue;
+			const resolved = resolveRelativeImport(file, specifier);
+			if (!resolved) {
+				throw new Error(`Could not resolve relative import '${specifier}' from ${path.relative(projectRoot, file)}`);
+			}
+			if (!visited.has(resolved)) {
+				visited.add(resolved);
+				queue.push(resolved);
+			}
+		}
+	}
+
+	assert.equal(violations.length, 0, `runtime import graph reached host peer package(s):\n${violations.join("\n")}`);
+	assert.ok(visited.size > 20, `expected a non-trivial reachable file set (a broken resolver could undercount it), got ${visited.size}`);
+});
+
+function writeFakeTypeboxPackage(typeboxDir: string): void {
+	fs.mkdirSync(typeboxDir, { recursive: true });
+	fs.writeFileSync(
+		path.join(typeboxDir, "package.json"),
+		JSON.stringify({ name: "typebox", version: "0.0.0-test", exports: { "./compile": "./compile.mjs" } }),
+	);
+	fs.writeFileSync(path.join(typeboxDir, "compile.mjs"), "export function Compile() {\n\treturn { Check: () => true, Errors: () => [], fakeTypebox: true };\n}\n");
+}
+
+test("resolveCompileFromPackageRoot loads typebox/compile from a fake Pi host package root", async () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-host-root-"));
+	try {
+		fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fake-pi-coding-agent", version: "0.0.0" }));
+		writeFakeTypeboxPackage(path.join(root, "node_modules", "typebox"));
+
+		const compile = await resolveCompileFromPackageRoot(root);
+		assert.equal(typeof compile, "function");
+		const compiled = compile!({});
+		assert.equal(compiled.Check({}), true);
+		assert.deepEqual([...compiled.Errors({})], []);
+		assert.equal((compiled as { fakeTypebox?: boolean }).fakeTypebox, true);
+	} finally {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+
+	const emptyRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-empty-root-"));
+	try {
+		await assert.rejects(resolveCompileFromPackageRoot(emptyRoot));
+	} finally {
+		fs.rmSync(emptyRoot, { recursive: true, force: true });
+	}
+});
+
+test("resolveCompileFromPackageRoot resolves typebox hoisted to an ancestor node_modules", async () => {
+	const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-hoisted-root-"));
+	try {
+		writeFakeTypeboxPackage(path.join(tmp, "node_modules", "typebox"));
+		const packageRoot = path.join(tmp, "apps", "pi", "node_modules", "@earendil-works", "pi-coding-agent");
+		fs.mkdirSync(packageRoot, { recursive: true });
+		fs.writeFileSync(path.join(packageRoot, "package.json"), JSON.stringify({ name: "@selesai/code", version: "0.0.0" }));
+
+		const compile = await resolveCompileFromPackageRoot(packageRoot);
+		assert.equal(typeof compile, "function");
+		const compiled = compile!({});
+		assert.equal(compiled.Check({}), true);
+		assert.equal((compiled as { fakeTypebox?: boolean }).fakeTypebox, true);
+	} finally {
+		fs.rmSync(tmp, { recursive: true, force: true });
+	}
+});
+
+test("validateStructuredOutputValue validates values against a JSON Schema", async () => {
+	const valid = await validateStructuredOutputValue({ type: "object" }, {});
+	assert.deepEqual(valid, { status: "valid" });
+
+	const schema: JsonSchemaObject = {
+		type: "object",
+		properties: { a: { type: "number" } },
+		required: ["a"],
+		additionalProperties: false,
+	};
+	const invalid = await validateStructuredOutputValue(schema, {});
+	assert.equal(invalid.status, "invalid");
+	assert.ok(invalid.status === "invalid" && invalid.message.length > 0);
+});