@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/support/result-publication-capacity-preload.mjs

@@ -0,0 +1,70 @@
+// Child-runner-only fault injection. Barriers are filesystem events, not elapsed waits.
+import fs from "node:fs";
+import path from "node:path";
+import { syncBuiltinESMExports } from "node:module";
+
+const root = process.env.RESULT_PUBLICATION_TEST_ROOT;
+if (root) {
+	const write = fs.writeFileSync;
+	const rename = fs.renameSync;
+	let resultAttempts = 0;
+	let runningWritten = false;
+	let statusDeferred = false;
+	let asyncDir;
+	let failedRecovery = false;
+	const earlyTerminal = fs.existsSync(path.join(root, "early-terminal"));
+	const barrier = (name, data) => {
+		write(path.join(root, `${name}.tmp`), JSON.stringify(data));
+		rename(path.join(root, `${name}.tmp`), path.join(root, name));
+	};
+	const full = () => Object.assign(new Error("injected result publication capacity failure"), { code: "ENOSPC" });
+	fs.writeFileSync = function (file, data, ...args) {
+		const target = String(file);
+		if (path.basename(target).startsWith(".status.json.") && typeof data === "string") {
+			const status = JSON.parse(data);
+			asyncDir = path.dirname(target);
+			if (!earlyTerminal && runningWritten && resultAttempts === 0) {
+				statusDeferred = true;
+				throw full();
+			}
+			if (status.state === "running") runningWritten = true;
+		}
+		if (target.includes(`${path.sep}result-pending${path.sep}`) && target.endsWith(".tmp")) {
+			resultAttempts++;
+			if (!fs.existsSync(path.join(root, "release"))) {
+				if (resultAttempts >= 2) {
+					const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8"));
+					barrier("blocked.json", {
+						state: status.state, statusDeferred,
+						active: fs.existsSync(path.join(path.dirname(asyncDir), ".active-runs", path.basename(asyncDir))),
+					});
+				}
+				throw full();
+			}
+			if (!failedRecovery && fs.existsSync(path.join(root, "fail-on-recovery"))) {
+				failedRecovery = true;
+				throw Object.assign(new Error("injected non-capacity publication failure"), { code: "EIO" });
+			}
+		}
+		return write.call(this, file, data, ...args);
+	};
+	fs.renameSync = function (source, target) {
+		const result = rename.call(this, source, target);
+		if (!earlyTerminal && path.basename(String(target)) === "steer-inbox-closed.json") {
+			// A request queued just before inbox closure is consumed during finalization.
+			const dir = path.join(path.dirname(String(target)), "steer-requests");
+			fs.mkdirSync(dir, { recursive: true });
+			write(path.join(dir, "publication-steer.json"), JSON.stringify({ type: "steer", id: "publication-steer", ts: 1, message: "Late queued request", targetIndex: 0 }));
+		}
+		if (path.basename(String(target)) === "status.json") {
+			const status = JSON.parse(fs.readFileSync(target, "utf8"));
+			if (status.state === "complete" || status.state === "failed") barrier("terminal.json", status);
+		}
+		if (earlyTerminal && path.basename(String(target)) === "process-terminal-candidate.json") {
+			const candidate = JSON.parse(fs.readFileSync(target, "utf8"));
+			if (candidate.expectedWriters) barrier("drained.json", candidate);
+		}
+		return result;
+	};
+	syncBuiltinESMExports();
+}

package/dist/extensions/pi-subagents/test/support/runner-child-session-factory.ts

@@ -0,0 +1,17 @@
+/**
+ * Scripted `ChildSessionFactory` for the detached async runner under test.
+ *
+ * The runner is a separate Node process, so it cannot share the parent's
+ * in-memory fake. `createMockPi().install()` names this module in the runner
+ * config; the runner imports it and replays the responses queued in the
+ * directory `MOCK_PI_QUEUE_DIR` points at.
+ */
+import { createFakeChildSessions } from "./fake-child-session.ts";
+
+export default function createRunnerChildSessionFactory() {
+	return createFakeChildSessions(() => {
+		const dir = process.env.MOCK_PI_QUEUE_DIR;
+		if (!dir) throw new Error("MOCK_PI_QUEUE_DIR is required for the scripted runner child session factory.");
+		return dir;
+	}).factory;
+}

package/dist/extensions/pi-subagents/test/support/single-execution-fixture.ts

@@ -0,0 +1,390 @@
+/**
+ * Integration tests for single (sync) agent execution.
+ *
+ * Uses the local createMockPi() helper to simulate the pi CLI.
+ * Tests the full spawn→parse→result pipeline in runSync without a real LLM.
+ *
+ * These tests require pi packages to be importable (they run inside a pi
+ * environment or with pi packages installed). If unavailable, tests skip
+ * gracefully.
+ */
+
+import { before, after, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { MockPi } from "./helpers.ts";
+import {
+	createMockPi,
+	createTempDir,
+	createEventBus,
+	removeTempDir,
+	makeAgentConfigs,
+	makeAgent,
+	resolveMockPiCallArgs,
+	tryImport,
+} from "./helpers.ts";
+import type { ChildWatchdogProgress, SubagentState } from "../../src/shared/types.ts";
+import { CHILD_WATCHDOG_STATUS_EVENT } from "../../src/watchdog/child-status.ts";
+import type { ChildRuntimeConfig } from "../../src/runs/shared/child-runtime-config.ts";
+import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
+
+interface ModelAttempt {
+	success?: boolean;
+	exitCode?: number;
+	error?: string;
+}
+
+interface ProgressSummary {
+	agent: string;
+	index: number;
+	status: string;
+	task?: string;
+	activityState?: string;
+	lastActivityAt?: number;
+	currentTool?: string;
+	currentToolArgs?: string;
+	currentToolStartedAt?: number;
+	currentPath?: string;
+	turnCount?: number;
+	tokens?: number;
+	durationMs: number;
+	toolCount: number;
+}
+
+interface ArtifactPaths {
+	inputPath?: string;
+	outputPath: string;
+	transcriptPath?: string;
+	metadataPath?: string;
+}
+
+interface LaunchResolvedExtensions {
+	version?: number;
+	source?: string;
+	disableAmbientExtensions?: boolean;
+	runtime?: string[];
+	configured?: string[];
+	effective?: string[];
+}
+
+interface RuntimeAcknowledgedExtensions {
+	version?: number;
+	source?: string;
+	ids?: string[];
+	omitted?: number;
+}
+
+interface RunSyncResult {
+	exitCode: number;
+	agent: string;
+	task?: string;
+	messages: unknown[];
+	error?: string;
+	model?: string;
+	skills?: string[];
+	skillsWarning?: string;
+	attemptedModels?: string[];
+	modelAttempts?: ModelAttempt[];
+	contextOverflow?: boolean;
+	usage: { turns: number; input: number; output: number };
+	progress: ProgressSummary;
+	controlEvents?: Array<{ type?: string; message: string; reason?: string; turns?: number; tokens?: number; currentPath?: string; recentFailureSummary?: string }>;
+	artifactPaths?: ArtifactPaths;
+	transcriptPath?: string;
+	transcriptError?: string;
+	finalOutput?: string;
+	processSignal?: string | null;
+	interrupted?: boolean;
+	timedOut?: boolean;
+	timeoutRecovery?: { changedFiles?: string[]; message?: string; recoveryNeeded?: boolean; reason?: string; reportStatus?: string };
+	turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; exceededAtTurn?: number };
+	turnBudgetExceeded?: boolean;
+	wrapUpRequested?: boolean;
+	detached?: boolean;
+	detachedReason?: string;
+	savedOutputPath?: string;
+	outputMode?: "inline" | "file-only";
+	outputReference?: { path: string; bytes: number; lines: number; message: string };
+	outputSaveError?: string;
+	sessionFile?: string;
+	structuredOutput?: unknown;
+	agentContract?: { version: 1 };
+	execution?: { status?: string; success?: boolean; exitCode?: number; error?: string };
+	review?: { status?: string };
+	effects?: { fileMutation?: { status?: string; expected?: boolean; attempted?: boolean; message?: string } };
+	acceptance?: {
+		status?: string;
+		verifyRuns?: Array<{ status?: string }>;
+		runtimeChecks?: Array<{ id?: string; status?: string; message?: string }>;
+	};
+	watchdog?: ChildWatchdogProgress;
+	launchResolvedExtensions?: LaunchResolvedExtensions;
+	runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions;
+}
+
+interface MockPiCallRecord {
+	args?: string[];
+	effectiveArgs?: string[];
+	cwd?: string;
+	systemPrompts?: Array<{ mode?: string; path?: string; text?: string; error?: string }>;
+	/** In-process child session launch (foreground children). */
+	launch?: { cwd: string; storage: { kind: string; sessionFile?: string; sessionDir?: string }; model?: string; tools?: string[]; excludeTools?: string[]; extensionPaths: string[]; hooks: string[]; noSkills: boolean; noContextFiles: boolean };
+	/** Typed child runtime config the in-process hooks received. */
+	runtime?: Record<string, unknown> & { sessionName?: string; intercomSessionName?: string; orchestratorTarget?: string; runId?: string; agent?: string; childIndex?: number; fanoutChild?: boolean; nestedParent?: { parentRunId: string; parentChildIndex?: number; depth: number }; depth?: number; maxDepth?: number; waitTool?: { enabled: boolean }; inheritProjectContext?: boolean; inheritSkills?: boolean; toolBudget?: unknown };
+}
+
+function writeWatchdogSettings(projectDir: string, tailMs = 120_000): void {
+	const settingsPath = path.join(projectDir, ".selesai", "settings.json");
+	fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+	fs.writeFileSync(settingsPath, JSON.stringify({
+		subagents: {
+			watchdog: {
+				enabled: true,
+				children: {
+					enabled: true,
+					watchdogTailTimeoutMs: tailMs,
+				},
+			},
+		},
+	}, null, 2), "utf-8");
+}
+
+async function withIsolatedWatchdogSettings<T>(projectDir: string, run: () => Promise<T>): Promise<T> {
+	const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+	const previousHome = process.env.HOME;
+	const previousUserProfile = process.env.USERPROFILE;
+	const isolatedHome = path.join(projectDir, "isolated-home");
+	process.env.SELESAI_CODING_AGENT_DIR = path.join(isolatedHome, ".selesai", "agent");
+	process.env.HOME = isolatedHome;
+	process.env.USERPROFILE = isolatedHome;
+	try {
+		return await run();
+	} finally {
+		if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+		if (previousHome === undefined) delete process.env.HOME;
+		else process.env.HOME = previousHome;
+		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = previousUserProfile;
+	}
+}
+
+function childWatchdogStatus(phase: "idle" | "reviewing" | "stale" | "failed", seq: number) {
+	return {
+		type: CHILD_WATCHDOG_STATUS_EVENT,
+		runId: "watchdog-child-run",
+		agent: "echo",
+		childIndex: 0,
+		stepIndex: 0,
+		seq,
+		phase,
+		ts: Date.now() + seq,
+	};
+}
+
+function mockAssistantMessage(text: string, stopReason: "stop" | "tool_use" = "stop") {
+	return {
+		type: "message_end",
+		message: {
+			role: "assistant",
+			content: stopReason === "tool_use"
+				? [{ type: "text", text }, { type: "toolCall", name: "bash", arguments: { command: "echo test" } }]
+				: [{ type: "text", text }],
+			model: "mock/test-model",
+			stopReason,
+			usage: {
+				input: 10,
+				output: 5,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: { total: 0.001 },
+			},
+		},
+	};
+}
+
+interface ExecutionModule {
+	runSync(
+		runtimeCwd: string,
+		agents: ReturnType<typeof makeAgentConfigs>,
+		agentName: string,
+		task: string,
+		options: Record<string, unknown>,
+	): Promise<RunSyncResult>;
+}
+
+interface UtilsModule {
+	getFinalOutput(messages: unknown[]): string;
+}
+
+interface ExecutorToolResult {
+	content: Array<{ text?: string }>;
+	isError?: boolean;
+	details?: {
+		totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
+		controlEvents?: Array<{ type?: string }>;
+		asyncId?: string;
+		timeoutMs?: number;
+		turnBudget?: { maxTurns: number; graceTurns: number };
+		artifacts?: { dir: string; files: ArtifactPaths[] };
+	};
+}
+
+interface ExecutorModule {
+	createSubagentExecutor?: (...args: unknown[]) => {
+		execute: (...args: unknown[]) => Promise<ExecutorToolResult>;
+		executeDelegated: (...args: unknown[]) => Promise<ExecutorToolResult>;
+	};
+	DEFAULT_FOREGROUND_TIMEOUT_MS?: number;
+}
+
+const execution = await tryImport<ExecutionModule>("./src/runs/foreground/execution.ts");
+const utils = await tryImport<UtilsModule>("./src/shared/utils.ts");
+const executorMod = await tryImport<ExecutorModule>("./src/runs/foreground/subagent-executor.ts");
+const available = !!(execution && utils);
+
+const runSync = execution?.runSync;
+const getFinalOutput = utils?.getFinalOutput;
+const createSubagentExecutor = executorMod?.createSubagentExecutor;
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function pathContainsSegments(filePath: string, ...segments: string[]): boolean {
+	return segments.every((segment) => filePath.split(path.sep).includes(segment));
+}
+
+async function waitForFileContent(filePath: string, expected: string): Promise<string> {
+	for (let attempt = 0; attempt < 300; attempt++) {
+		if (fs.existsSync(filePath)) {
+			const content = fs.readFileSync(filePath, "utf-8");
+			if (content.includes(expected)) return content;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 50));
+	}
+	return fs.readFileSync(filePath, "utf-8");
+}
+
+function writePackageSkill(packageRoot: string, skillName: string): void {
+	const skillDir = path.join(packageRoot, "skills", skillName);
+	fs.mkdirSync(skillDir, { recursive: true });
+	fs.writeFileSync(
+		path.join(packageRoot, "package.json"),
+		JSON.stringify({ name: `${skillName}-pkg`, version: "1.0.0", pi: { skills: [`./skills/${skillName}`] } }, null, 2),
+		"utf-8",
+	);
+	fs.writeFileSync(
+		path.join(skillDir, "SKILL.md"),
+		`---\nname: ${skillName}\ndescription: test skill\n---\nbody\n`,
+		"utf-8",
+	);
+}
+
+let tempDir: string;
+let agentDir: string;
+let mockPi: MockPi;
+let previousAgentDir: string | undefined;
+
+export function installSingleExecutionHooks() {
+	before(() => {
+		mockPi = createMockPi();
+		mockPi.install();
+	});
+
+	after(() => {
+		mockPi.uninstall();
+	});
+
+	beforeEach(() => {
+		tempDir = createTempDir();
+		agentDir = createTempDir("pi-subagent-agent-");
+		previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		mockPi.reset();
+		clearExclusions();
+	});
+
+	afterEach(() => {
+		clearExclusions();
+		if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+		removeTempDir(agentDir);
+		removeTempDir(tempDir);
+	});
+}
+
+	function readCall(): { args: string[]; effectiveArgs?: string[]; cwd?: string; systemPrompts: NonNullable<MockPiCallRecord["systemPrompts"]>; launch: MockPiCallRecord["launch"]; runtime: MockPiCallRecord["runtime"] } {
+		const callFile = fs.readdirSync(mockPi.dir)
+			.filter((name) => name.startsWith("call-") && name.endsWith(".json"))
+			.sort()
+			.at(-1);
+		assert.ok(callFile, "expected a recorded mock pi call");
+		const payload = JSON.parse(fs.readFileSync(path.join(mockPi.dir, callFile), "utf-8")) as MockPiCallRecord;
+		assert.ok(Array.isArray(payload.args), "expected recorded args");
+		return { args: payload.args, effectiveArgs: payload.effectiveArgs, cwd: payload.cwd, systemPrompts: payload.systemPrompts ?? [], launch: payload.launch, runtime: payload.runtime };
+	}
+
+	function readCallArgs(): string[] {
+		const call = readCall();
+		return resolveMockPiCallArgs(call);
+	}
+
+	function readAllCallArgs(effective = false): string[][] {
+		return fs.readdirSync(mockPi.dir)
+			.filter((name) => name.startsWith("call-") && name.endsWith(".json"))
+			.sort()
+			.map((name) => {
+				const call = JSON.parse(fs.readFileSync(path.join(mockPi.dir, name), "utf-8")) as MockPiCallRecord;
+				return effective ? resolveMockPiCallArgs(call) : call.args ?? [];
+			});
+	}
+
+	function makeExecutor(
+		agents = [makeAgent("echo")],
+		config: Record<string, unknown> = {},
+		asyncByDefault = false,
+		initialSpawnState?: NonNullable<SubagentState["subagentSpawns"]>,
+		allowMutatingManagementActions = true,
+		initialAsyncJobs: SubagentState["asyncJobs"] = new Map(),
+		workflowControllers?: Map<string, AbortController>,
+		handleScheduledRunAction?: Parameters<typeof createSubagentExecutor>[0]["handleScheduledRunAction"],
+		piEvents = createEventBus(),
+		discoverAgentsForCwd?: (cwd: string) => typeof agents,
+		childRuntime?: ChildRuntimeConfig,
+	) {
+		return createSubagentExecutor!({
+			pi: { events: piEvents, getSessionName: () => undefined },
+			...(childRuntime ? { childRuntime } : {}),
+			state: {
+				baseCwd: tempDir,
+				currentSessionId: initialSpawnState?.sessionId ?? null,
+				...(initialSpawnState ? { subagentSpawns: initialSpawnState } : {}),
+				asyncJobs: initialAsyncJobs,
+				...(workflowControllers ? { workflowControllers } : {}),
+				foregroundControls: new Map(),
+				lastForegroundControlId: null,
+			},
+			config,
+			asyncByDefault,
+			tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => path.join(tempDir, ".pi-subagents", "sessions"),
+			expandTilde: (value: string) => value,
+			discoverAgents: (cwd: string) => ({ agents: discoverAgentsForCwd ? discoverAgentsForCwd(cwd) : agents }),
+			allowMutatingManagementActions,
+			...(handleScheduledRunAction ? { handleScheduledRunAction } : {}),
+		});
+	}
+
+export {
+	tempDir, agentDir, mockPi, available, runSync, getFinalOutput, utils,
+	createSubagentExecutor, executorMod, escapeRegExp, pathContainsSegments,
+	waitForFileContent, writePackageSkill, writeWatchdogSettings,
+	withIsolatedWatchdogSettings, childWatchdogStatus, mockAssistantMessage,
+	readCall, readCallArgs, readAllCallArgs, makeExecutor,
+};
+export type {
+	ProgressSummary, ArtifactPaths, LaunchResolvedExtensions,
+	RuntimeAcknowledgedExtensions, RunSyncResult, ExecutorToolResult,
+};

package/dist/extensions/pi-subagents/test/unit/acceptance-compaction.test.ts

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { it } from "node:test";
+import type { AgentSessionEvent, SessionBeforeCompactEvent } from "@selesai/code";
+import { createDefaultChildSessionFactory, type PiCodingAgentModule } from "../../src/runs/shared/child-session.ts";
+import { runSync } from "../../src/runs/foreground/execution.ts";
+import { runSingleStepInner } from "../../src/runs/background/subagent-runner.ts";
+import { formatAcceptancePrompt, resolveEffectiveAcceptance } from "../../src/runs/shared/acceptance.ts";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import { createStructuredOutputRuntime } from "../../src/runs/shared/structured-output.ts";
+
+// Uses the existing isolated SDK fixture; never install dependencies or call a provider.
+const sdkRoot = process.env.SELESAI_SUBAGENTS_NATIVE_SDK;
+for (const host of ["foreground", "runner"] as const) {
+	for (const [systemPromptMode, structured] of [["append", false], ["replace", false], ["append", true], ["replace", true]] as const) {
+		it(`exact acceptance survives actual SDK split-turn compaction: ${host}/${systemPromptMode}/${structured ? "structured" : "fenced"}`, { skip: !sdkRoot && "Set SELESAI_SUBAGENTS_NATIVE_SDK to the isolated 0.85.1 SDK root" }, async () => {
+			const entry = execFileSync(process.execPath, ["--input-type=module", "-e", "console.log(import.meta.resolve('@selesai/code'))"], { cwd: sdkRoot, encoding: "utf8" }).trim();
+			const pi: PiCodingAgentModule = await import(entry);
+			assert.equal(pi.VERSION, "0.85.1");
+			const cwd = mkdtempSync(join(tmpdir(), "acceptance-compaction-"));
+			const agentDir = join(cwd, "agent"); mkdirSync(agentDir);
+			const oldDir = process.env.SELESAI_CODING_AGENT_DIR;
+			const oldFetch = globalThis.fetch;
+			process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+			writeFileSync(join(agentDir, "settings.json"), JSON.stringify({ retry: { enabled: false, provider: { maxRetries: 0 } }, compaction: { enabled: true, reserveTokens: 2048, keepRecentTokens: 32 } }));
+			writeFileSync(join(agentDir, "models.json"), JSON.stringify({ providers: { baseten: { baseUrl: "https://synthetic.invalid/v1", apiKey: "fixture-key", models: [{ id: "acceptance", name: "acceptance", api: "openai-completions", reasoning: false, input: ["text"], contextWindow: 128000, maxTokens: 512, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } }] } } }));
+			writeFileSync(join(cwd, "marker.txt"), "WORK_EVIDENCE");
+			const task = "UNIQUE_TASK read marker.txt once and report evidence.";
+			const explicit = { level: "checked" as const, criteria: [{ id: "read-marker", must: "Read the marker exactly once" }], evidence: ["commands-run" as const, "no-staged-files" as const] };
+			const acceptance = resolveEffectiveAcceptance({ explicit, task, agentName: "reader", mode: "single" });
+			const structuredOutput = structured ? createStructuredOutputRuntime({ type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"] }, cwd, { acceptanceReport: "optional" }) : undefined;
+			const protocol = formatAcceptancePrompt(acceptance, { structuredOutput: structured });
+			const report = { criteriaSatisfied: [{ id: "read-marker", status: "satisfied", evidence: "WORK_EVIDENCE" }], changedFiles: [], testsAddedOrUpdated: [], residualRisks: ["none"], commandsRun: [{ command: "read marker.txt", result: "passed", summary: "WORK_EVIDENCE" }], noStagedFiles: true };
+			const requests: any[] = [];
+			const preparations: SessionBeforeCompactEvent["preparation"][] = [];
+			const events: AgentSessionEvent[] = [];
+			let prompts = 0;
+			let creates = 0;
+			let reads = 0;
+			let summaries = 0;
+			globalThis.fetch = async (input, init) => {
+				assert.equal(input instanceof Request ? input.url : String(input), "https://synthetic.invalid/v1/chat/completions");
+				const body = JSON.parse(String(init?.body)); requests.push(body);
+				assert.ok(requests.length <= 3, "no extra request or correction turn");
+				const summary = !body.tools?.length;
+				let delta: unknown;
+				let finish = "stop";
+				let tokens = 10;
+				if (summary) {
+					summaries++;
+					// Deliberately lossy model output: real SDK summary generation/rebuild remains intact.
+					delta = { content: "The marker was read. Finish the work." };
+				} else if (reads++ === 0) {
+					delta = { content: "Inspecting the marker for evidence. ".repeat(12), tool_calls: [{ index: 0, id: "read-once", type: "function", function: { name: "read", arguments: JSON.stringify({ path: "marker.txt" }) } }] };
+					finish = "tool_calls"; tokens = 127000;
+				} else {
+					const system = body.messages.filter((m: any) => m.role === "system" || m.role === "developer").map((m: any) => m.content).join("\n");
+					delta = { content: system.includes(protocol) ? `Completed.\n\`\`\`acceptance-report\n${JSON.stringify(report)}\n\`\`\`` : "Completed the read. Validation passed; no staged files." };
+					if (structured) {
+						delta = { tool_calls: [{ index: 0, id: "final-output", type: "function", function: { name: "structured_output", arguments: JSON.stringify({ value: { ok: true }, ...(system.includes(protocol) ? { acceptanceReport: report } : {}) }) } }] };
+						finish = "tool_calls";
+					}
+				}
+				const chunk = { id: "synthetic", object: "chat.completion.chunk", created: 1, model: "acceptance", choices: [{ index: 0, delta, finish_reason: finish }], usage: { prompt_tokens: tokens, completion_tokens: 1, total_tokens: tokens + 1 } };
+				return new Response(`data: ${JSON.stringify(chunk)}\n\ndata: [DONE]\n\n`, { headers: { "content-type": "text/event-stream" } });
+			};
+			const factory = createDefaultChildSessionFactory({ loadPiCodingAgent: async () => ({ ...pi, createAgentSession: async (options) => {
+				const result = await pi.createAgentSession(options);
+				assert.deepEqual(result.session.settingsManager.getCompactionSettings(), { enabled: true, reserveTokens: 2048, keepRecentTokens: 32 });
+				result.session.subscribe((event) => events.push(event));
+				return result;
+			} }) });
+			const observedFactory = { ...factory, async create(launch: Parameters<typeof factory.create>[0]) {
+				creates++;
+				const child = await factory.create({ ...launch, hooks: [...launch.hooks, (api) => {
+					api.on("session_before_compact", (event) => { preparations.push(event.preparation); });
+				}] });
+				const prompt = child.prompt.bind(child);
+				child.prompt = (text) => { prompts++; return prompt(text); };
+				return child;
+			} };
+			const agent: AgentConfig = { name: "reader", description: "Read marker", source: "project", filePath: join(cwd, "reader.md"), model: "baseten/acceptance", systemPrompt: "Read only.", systemPromptMode, inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false, tools: ["read"], extensions: [], allowNestedSubagents: false };
+			try {
+				const result = host === "foreground"
+					? await runSync(cwd, [agent], agent.name, task, { acceptance: explicit, structuredOutput, waitToolEnabled: false, childSessionFactory: observedFactory })
+					: await runSingleStepInner({ ...agent, agent: agent.name, task, context: "fresh", effectiveAcceptance: acceptance, structuredOutput, modelCandidates: [agent.model!], waitToolEnabled: false }, { cwd, id: "compact-runner", flatIndex: 0, flatStepCount: 1, previousOutput: "", placeholder: "{previous}", outputFile: join(cwd, "output.log"), sessionEnabled: false, childSessions: observedFactory });
+				assert.equal(result.exitCode, 0, `${result.error}; ${JSON.stringify(events.filter((e) => e.type.includes("compact") || (e.type === "message_end" && e.message.role === "assistant" && e.message.stopReason === "error")))}`);
+				assert.equal(result.acceptance?.status, "checked");
+				if (structured) assert.deepEqual(result.structuredOutput, { ok: true });
+				assert.equal(creates, 1); assert.equal(prompts, 1, "no replay or correction prompt");
+				assert.equal(summaries, 1);
+				assert.equal(preparations.length, 1);
+				assert.ok(preparations[0]);
+				assert.equal(preparations[0].isSplitTurn, true);
+				assert.ok(JSON.stringify(preparations[0].turnPrefixMessages).includes("UNIQUE_TASK"));
+				assert.equal(events.filter((e) => e.type === "tool_execution_end" && e.toolName === "read").length, 1);
+				assert.equal(events.filter((e) => e.type === "compaction_end" && e.result).length, 1);
+				assert.ok(events.some((e) => e.type === "compaction_end" && e.reason === "threshold" && e.willRetry === false));
+				const normal = requests.filter((r) => r.tools?.length);
+				assert.equal(normal.length, 2, "one tool request and one terminal request");
+				assert.ok(!JSON.stringify(normal[0].messages.filter((m: any) => m.role === "user")).includes("Acceptance Contract"), "protocol is moved, not duplicated into user history");
+				for (const request of normal) {
+					const system = request.messages.filter((m: any) => m.role === "system" || m.role === "developer").map((m: any) => m.content).join("\n");
+					assert.equal(system.split(protocol).length - 1, 1, "verbatim contract exactly once in durable resources");
+				}
+				const retained = JSON.stringify(normal[1].messages.filter((m: any) => m.role !== "system" && m.role !== "developer"));
+				assert.ok(!retained.includes("UNIQUE_TASK"), "actual SDK removed original user task");
+				assert.ok(!retained.includes("acceptance-report"), "lossy conversation no longer contains envelope");
+				assert.ok(retained.includes("WORK_EVIDENCE"), "tool evidence survives");
+			} finally {
+				await factory.dispose(); globalThis.fetch = oldFetch;
+				if (oldDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR; else process.env.SELESAI_CODING_AGENT_DIR = oldDir;
+				rmSync(cwd, { recursive: true, force: true });
+			}
+		});
+	}
+}

package/dist/extensions/pi-subagents/test/unit/acceptance.test.ts

@@ -190,7 +190,7 @@ describe("acceptance gates", () => {
 		assert.equal(resolved.verify[0]?.id, "ok");
 	});
 
-	it("agent contract v1 disables inferred acceptance without changing current defaults", () => {
+	it("agent contract disables inferred acceptance without changing current defaults", () => {
 		const current = resolveEffectiveAcceptance({ agentName: "worker", acceptanceRole: "writer", task: "Implement the fix", mode: "single", async: true });
 		assert.equal(current.level, "checked");
 		assert.equal(current.review && current.review !== false ? current.review.required : undefined, true);
@@ -204,7 +204,7 @@ describe("acceptance gates", () => {
 		}
 	});
 
-	it("agent contract v1 keeps explicit acceptance report-optional and verify-only", async () => {
+	it("agent contract keeps explicit acceptance report-optional and verify-only", async () => {
 		const checked = resolveEffectiveAcceptance({
 			agentName: "worker",
 			task: "Implement the fix",
@@ -1220,6 +1220,17 @@ describe("acceptance gates", () => {
 		assert.match(errors.join("\n"), /acceptance\.review\.required/);
 	});
 
+	it("rejects transport-permitted true acceptance before execution, including nested inputs", () => {
+		const errors = validateExecutionAcceptance({
+			acceptance: true,
+			tasks: [{ acceptance: true }],
+			chain: [{ acceptance: true }, { parallel: [{ acceptance: true }] }, { parallel: { acceptance: true } }],
+		});
+		const paths = ["acceptance", "tasks[0].acceptance", "chain[0].acceptance", "chain[1].parallel[0].acceptance", "chain[2].parallel.acceptance"];
+		assert.equal(errors.length, paths.length);
+		paths.forEach((path, index) => assert.ok(errors[index]?.startsWith(`${path} must be a string level, false, or an object.`)));
+	});
+
 	it("requires outputSchema for explicit structured acceptance report mode", () => {
 		const schema = { type: "object" as const };
 		const errors = validateExecutionAcceptance({
@@ -1312,6 +1323,16 @@ describe("acceptance gates", () => {
 		const conflictingGate = normalizeGateAcceptance("npm test", "checked");
 		assert.equal(conflictingGate.ok, false);
 		assert.match(conflictingGate.error, /cannot be combined with acceptance/);
+		assert.match(conflictingGate.error, /Both fields were present: gate="npm test" acceptance="checked"/);
+		const oversizedAcceptance = normalizeGateAcceptance("npm test", { level: "checked", evidence: ["a".repeat(200)] });
+		assert.equal(oversizedAcceptance.ok, false);
+		assert.match(oversizedAcceptance.error || "", /Both fields were present/);
+		assert.ok(!(oversizedAcceptance.error || "").includes("a".repeat(200)));
+		const disabledAcceptance = normalizeGateAcceptance("npm test", false);
+		assert.deepEqual(disabledAcceptance, {
+			ok: true,
+			acceptance: { level: "verified", verify: [{ id: "gate", command: "npm test" }] },
+		});
 	});
 
 	it("keeps explicit acceptance.verify arrays as existing verified acceptance", async () => {
@@ -1553,4 +1574,4 @@ describe("quoteExecutableForShell", () => {
 			assert.equal(quoteExecutableForShell(command, "win32"), command);
 		}
 	});
-});
+});