@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/support/mock-pi-script.mjs

@@ -1,447 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-const queueDir = process.env.MOCK_PI_QUEUE_DIR;
-
-function exitAfterFlush(code) {
-	// process.exit() can truncate buffered stdout/stderr on slow runners (e.g.
-	// GitHub Actions), dropping the final lines the parent executor needs to see
-	// the run as successful. Drain the writable streams first, then exit.
-	// A hard timeout (ref'd, not unref'd) guards against stream.end() callbacks
-	// that never fire on some platforms (notably Windows pipe-backed stdout).
-	const streams = [process.stdout, process.stderr].filter((s) => !s.destroyed && !s.writableEnded);
-	if (streams.length === 0) {
-		process.exit(code);
-		return;
-	}
-	let exited = false;
-	const forceExit = () => {
-		if (exited) return;
-		exited = true;
-		process.exit(code);
-	};
-	let pending = streams.length;
-	for (const stream of streams) {
-		stream.end(() => {
-			if (--pending === 0) forceExit();
-		});
-	}
-	setTimeout(forceExit, 500);
-}
-
-function fail(message, exitCode = 1) {
-	process.stderr.write(`${message}\n`);
-	exitAfterFlush(exitCode);
-}
-
-function listPendingFiles(dir) {
-	return fs.readdirSync(dir)
-		.filter((name) => name.startsWith("pending-") && name.endsWith(".json"))
-		.sort();
-}
-
-function readPendingResponse(filePath) {
-	try {
-		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-	} catch (error) {
-		if (error && typeof error === "object" && "code" in error) {
-			const code = error.code;
-			if (code === "ENOENT") return undefined;
-		}
-		throw error;
-	}
-}
-
-function hasArgMatcher(response) {
-	return Object.prototype.hasOwnProperty.call(response ?? {}, "matchArgIncludes");
-}
-
-function resolveTaskFileArg(arg) {
-	if (typeof arg !== "string" || !arg.startsWith("@") || !arg.endsWith("task.md")) return arg;
-	try {
-		return fs.readFileSync(arg.slice(1), "utf-8");
-	} catch {
-		return arg;
-	}
-}
-
-function resolveTaskFileArgs(args) {
-	return args.map(resolveTaskFileArg);
-}
-
-function responseMatchesArgs(response, args) {
-	const matcher = response?.matchArgIncludes;
-	if (matcher === undefined) return true;
-	const needles = Array.isArray(matcher) ? matcher : [matcher];
-	if (needles.length === 0) return true;
-	const effectiveArgs = resolveTaskFileArgs(args);
-	const haystack = `${args.join("\n")}\n${effectiveArgs.join("\n")}`;
-	return needles.every((needle) => typeof needle === "string" && haystack.includes(needle));
-}
-
-function claimResponseFile(dir, fileName) {
-	const sourcePath = path.join(dir, fileName);
-	const targetPath = path.join(dir, fileName.replace(/^pending-/, "consumed-"));
-	try {
-		fs.renameSync(sourcePath, targetPath);
-		return JSON.parse(fs.readFileSync(targetPath, "utf-8"));
-	} catch (error) {
-		if (error && typeof error === "object" && "code" in error) {
-			const code = error.code;
-			if (code === "ENOENT" || code === "EEXIST" || code === "EPERM") return undefined;
-		}
-		throw error;
-	}
-}
-
-function claimNextResponse(dir, args) {
-	for (const fileName of listPendingFiles(dir)) {
-		const sourcePath = path.join(dir, fileName);
-		const response = readPendingResponse(sourcePath);
-		if (!response || !hasArgMatcher(response) || !responseMatchesArgs(response, args)) continue;
-		const claimed = claimResponseFile(dir, fileName);
-		if (claimed) return claimed;
-	}
-
-	for (const fileName of listPendingFiles(dir)) {
-		const sourcePath = path.join(dir, fileName);
-		const response = readPendingResponse(sourcePath);
-		if (!response || hasArgMatcher(response)) continue;
-		const claimed = claimResponseFile(dir, fileName);
-		if (claimed) return claimed;
-	}
-
-	const defaultPath = path.join(dir, "default-response.json");
-	if (!fs.existsSync(defaultPath)) return undefined;
-	const fallback = JSON.parse(fs.readFileSync(defaultPath, "utf-8"));
-	return responseMatchesArgs(fallback, args) ? fallback : undefined;
-}
-
-function requestedModelArg(args) {
-	for (let i = 0; i < args.length; i++) {
-		if (args[i] === "--model" && typeof args[i + 1] === "string") return args[i + 1];
-	}
-	return "mock/test-model";
-}
-
-function defaultAssistantMessage(output, args) {
-	return {
-		type: "message_end",
-		message: {
-			role: "assistant",
-			content: [{ type: "text", text: output }],
-			model: requestedModelArg(args),
-			stopReason: "stop",
-			usage: {
-				input: 100,
-				output: 50,
-				cacheRead: 0,
-				cacheWrite: 0,
-				cost: { total: 0.001 },
-			},
-		},
-	};
-}
-
-function taskRequestsAcceptance(args) {
-	for (const arg of args) {
-		if (typeof arg !== "string") continue;
-		if (arg.includes("## Acceptance Contract")) return true;
-		if (!arg.startsWith("@")) continue;
-		try {
-			if (fs.readFileSync(arg.slice(1), "utf-8").includes("## Acceptance Contract")) return true;
-		} catch {
-			// Ignore unreadable temp prompt references in the mock harness.
-		}
-	}
-	return false;
-}
-
-function defaultAcceptanceReport() {
-	return [
-		"```acceptance-report",
-		JSON.stringify({
-			criteriaSatisfied: [
-				{ id: "criterion-1", status: "satisfied", evidence: "mock acceptance evidence" },
-				{ id: "criterion-2", status: "satisfied", evidence: "mock acceptance evidence" },
-			],
-			changedFiles: ["mock-file.ts"],
-			testsAddedOrUpdated: ["mock-file.test.ts"],
-			commandsRun: [{ command: "mock validation", result: "passed", summary: "passed" }],
-			validationOutput: ["mock validation passed"],
-			residualRisks: [],
-			noStagedFiles: true,
-			reviewFindings: [],
-			manualNotes: "mock run completed",
-			notes: "mock run completed",
-		}),
-		"```",
-	].join("\n");
-}
-
-function withAcceptanceReport(output, args) {
-	if (!taskRequestsAcceptance(args) || output.includes("```acceptance-report")) return output;
-	return `${output}\n${defaultAcceptanceReport()}`;
-}
-
-function defaultResponse() {
-	return { output: "ok", exitCode: 0 };
-}
-
-function writeDeclaredFiles(response) {
-	if (!Array.isArray(response.writeFiles)) return;
-	for (const file of response.writeFiles) {
-		if (!file || typeof file.path !== "string" || typeof file.content !== "string") continue;
-		const target = path.resolve(process.cwd(), file.path);
-		fs.mkdirSync(path.dirname(target), { recursive: true });
-		fs.writeFileSync(target, file.content, "utf-8");
-	}
-}
-
-function writeStructuredOutputCapture(response) {
-	if (!Object.prototype.hasOwnProperty.call(response, "structuredOutputCapture")) return;
-	const outputPath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE;
-	if (!outputPath) return;
-	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-	fs.writeFileSync(outputPath, JSON.stringify(response.structuredOutputCapture), "utf-8");
-	if (Object.prototype.hasOwnProperty.call(response, "structuredOutputAcceptanceReport")) {
-		const acceptancePath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE;
-		if (acceptancePath) fs.writeFileSync(acceptancePath, JSON.stringify(response.structuredOutputAcceptanceReport), "utf-8");
-	}
-	if (Object.prototype.hasOwnProperty.call(response, "structuredOutputAcceptanceReportRaw")) {
-		const acceptancePath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE;
-		if (acceptancePath) fs.writeFileSync(acceptancePath, response.structuredOutputAcceptanceReportRaw, "utf-8");
-	}
-}
-
-function writeRuntimeAcknowledgedExtensions(response) {
-	if (!Object.prototype.hasOwnProperty.call(response, "runtimeAcknowledgedExtensions")) return;
-	const outputPath = process.env.SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS;
-	if (!outputPath) return;
-	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-	fs.writeFileSync(outputPath, JSON.stringify(response.runtimeAcknowledgedExtensions), "utf-8");
-}
-
-function writeToolDiagnostic(response) {
-	if (!Array.isArray(response.missingTools) || response.missingTools.length === 0) return;
-	const diagnosticPath = process.env.SELESAI_SUBAGENT_TOOL_DIAGNOSTIC_PATH;
-	const required = JSON.parse(process.env.SELESAI_SUBAGENT_REQUIRED_TOOLS ?? "[]");
-	if (!diagnosticPath || !Array.isArray(required)) return;
-	const missing = response.missingTools.filter((name) => typeof name === "string" && required.includes(name));
-	const available = required.filter((name) => !missing.includes(name));
-	fs.mkdirSync(path.dirname(diagnosticPath), { recursive: true });
-	fs.writeFileSync(diagnosticPath, JSON.stringify({
-		agent: process.env.SELESAI_SUBAGENT_CHILD_AGENT,
-		required,
-		available,
-		missing,
-	}), "utf-8");
-}
-
-function readRequiredToolsEnv() {
-	try {
-		const encoded = process.env.SELESAI_SUBAGENT_REQUIRED_TOOLS;
-		const parsed = encoded === undefined ? [] : JSON.parse(encoded);
-		return Array.isArray(parsed) ? parsed : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function isJsonMode(args) {
-	for (let i = 0; i < args.length; i++) {
-		if (args[i] === "--mode") {
-			return args[i + 1] === "json";
-		}
-	}
-	return false;
-}
-
-function writeSessionFile(args) {
-	for (let i = 0; i < args.length; i++) {
-		if (args[i] !== "--session") continue;
-		const sessionFile = args[i + 1];
-		if (!sessionFile) return;
-		fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
-		fs.writeFileSync(sessionFile, "", { flag: "a" });
-		return;
-	}
-}
-
-function readSystemPromptRecords(args) {
-	const records = [];
-	for (let i = 0; i < args.length; i++) {
-		if (args[i] !== "--system-prompt" && args[i] !== "--append-system-prompt") continue;
-		const promptPath = args[i + 1];
-		if (!promptPath) continue;
-		try {
-			records.push({
-				mode: args[i],
-				path: promptPath,
-				text: fs.readFileSync(promptPath, "utf-8"),
-			});
-		} catch (error) {
-			records.push({
-				mode: args[i],
-				path: promptPath,
-				error: error instanceof Error ? error.message : String(error),
-			});
-		}
-	}
-	return records;
-}
-
-async function writeStdout(text) {
-	if (process.stdout.write(text)) return;
-	await new Promise((resolve) => process.stdout.once("drain", resolve));
-}
-
-async function writeJsonlLine(entry) {
-	const line = typeof entry === "string" ? entry : JSON.stringify(entry);
-	await writeStdout(`${line}\n`);
-}
-
-async function writeRawStdout(entry) {
-	if (Array.isArray(entry?.stdoutBase64Chunks)) {
-		for (const chunk of entry.stdoutBase64Chunks) {
-			if (typeof chunk === "string") await writeStdout(Buffer.from(chunk, "base64"));
-		}
-	}
-	if (typeof entry?.stdoutRaw === "string") await writeStdout(entry.stdoutRaw);
-}
-
-function extractPlainText(entry) {
-	if (!entry || typeof entry !== "object") return "";
-	if (entry.type === "message_end") {
-		const text = entry.message?.content?.find?.((part) => part?.type === "text")?.text;
-		return typeof text === "string" ? text : "";
-	}
-	if (entry.type === "tool_result_end") {
-		const text = entry.message?.content?.find?.((part) => part?.type === "text")?.text;
-		return typeof text === "string" ? text : "";
-	}
-	return "";
-}
-
-async function writeResponseEntries(entries, jsonMode, args) {
-	let sawProviderError = false;
-	for (const entry of entries) {
-		if (entry?.type === "message_end") {
-			const textPart = entry.message?.content?.find?.((part) => part?.type === "text");
-			const isProviderError = Boolean(entry.message?.errorMessage || entry.message?.stopReason === "error");
-			if (isProviderError) sawProviderError = true;
-			if (!isProviderError && textPart && typeof textPart.text === "string" && (!sawProviderError || textPart.text.trim())) {
-				textPart.text = withAcceptanceReport(textPart.text, args);
-			}
-		}
-		if (jsonMode) {
-			await writeJsonlLine(entry);
-			continue;
-		}
-		const text = extractPlainText(entry);
-		if (text) await writeStdout(`${text}\n`);
-	}
-}
-
-async function maybeWriteStructuredOutput(response, jsonMode) {
-	if (!Object.prototype.hasOwnProperty.call(response, "structuredOutput")) return;
-	const outputPath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE;
-	if (!outputPath) return;
-	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-	fs.writeFileSync(outputPath, JSON.stringify(response.structuredOutput), "utf-8");
-	if (!jsonMode) return;
-	await writeJsonlLine({ type: "tool_execution_start", toolName: "structured_output", args: { value: response.structuredOutput } });
-	await writeJsonlLine({
-		type: "tool_result_end",
-		message: {
-			role: "toolResult",
-			toolName: "structured_output",
-			content: [{ type: "text", text: "Structured output captured." }],
-		},
-	});
-	await writeJsonlLine({ type: "tool_execution_end", toolName: "structured_output" });
-}
-
-async function main() {
-	if (!queueDir) fail("MOCK_PI_QUEUE_DIR is required.");
-	if (!fs.existsSync(queueDir)) fail(`Mock queue dir does not exist: ${queueDir}`);
-
-	const args = process.argv.slice(2);
-	const jsonMode = isJsonMode(args);
-	const response = claimNextResponse(queueDir, args) ?? defaultResponse();
-	if (response.ignoreSigterm === true) {
-		process.on("SIGTERM", () => {});
-	}
-	writeSessionFile(args);
-	writeToolDiagnostic(response);
-	const effectiveArgs = resolveTaskFileArgs(args);
-	const callPath = path.join(queueDir, `call-${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.json`);
-	const callTempPath = `${callPath}.tmp-${process.pid}-${Date.now()}`;
-	fs.writeFileSync(callTempPath, JSON.stringify({ args, effectiveArgs, cwd: process.cwd(), systemPrompts: readSystemPromptRecords(args), requiredChildTools: readRequiredToolsEnv() }), "utf-8");
-	fs.renameSync(callTempPath, callPath);
-
-	if (typeof response.delay === "number" && response.delay > 0) {
-		await new Promise((resolve) => setTimeout(resolve, response.delay));
-	}
-	async function waitForReleasePath(waitForPath) {
-		if (typeof waitForPath !== "string") return;
-		const deadline = Date.now() + 30_000;
-		while (!fs.existsSync(waitForPath)) {
-			if (Date.now() >= deadline) fail(`Timed out waiting for mock release path: ${waitForPath}`);
-			await new Promise((resolve) => setTimeout(resolve, 20));
-		}
-	}
-	await waitForReleasePath(response.waitForPath);
-
-	writeDeclaredFiles(response);
-	writeStructuredOutputCapture(response);
-	writeRuntimeAcknowledgedExtensions(response);
-
-	if (Array.isArray(response.steps) && response.steps.length > 0) {
-		for (const step of response.steps) {
-			if (typeof step?.delay === "number" && step.delay > 0) {
-				await new Promise((resolve) => setTimeout(resolve, step.delay));
-			}
-			await waitForReleasePath(step?.waitForPath);
-			if (Array.isArray(step?.jsonl) && step.jsonl.length > 0) {
-					await writeResponseEntries(step.jsonl, jsonMode, args);
-				}
-				await writeRawStdout(step);
-				if (typeof step?.stderr === "string" && step.stderr.length > 0) {
-					process.stderr.write(step.stderr);
-				}
-			}
-		} else if (Array.isArray(response.jsonl) && response.jsonl.length > 0) {
-			await writeResponseEntries(response.jsonl, jsonMode, args);
-		} else if (Array.isArray(response.stdoutBase64Chunks) || typeof response.stdoutRaw === "string") {
-			await writeRawStdout(response);
-		} else if (Array.isArray(response.echoEnv) && response.echoEnv.length > 0) {
-			const envSnapshot = Object.fromEntries(response.echoEnv.map((key) => [key, process.env[key] ?? null]));
-				const output = withAcceptanceReport(JSON.stringify(envSnapshot), args);
-				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output, args));
-				else await writeStdout(`${output}\n`);
-			} else if (typeof response.output === "string") {
-				const output = withAcceptanceReport(response.output, args);
-				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output, args));
-				else await writeStdout(`${output}\n`);
-			}
-		await maybeWriteStructuredOutput(response, jsonMode);
-
-	if (typeof response.stderr === "string" && response.stderr.length > 0) {
-		process.stderr.write(response.stderr);
-	}
-
-	if (typeof response.keepAliveAfterFinalMessageMs === "number" && response.keepAliveAfterFinalMessageMs > 0) {
-		await new Promise((resolve) => setTimeout(resolve, response.keepAliveAfterFinalMessageMs));
-	}
-
-	if (typeof response.signal === "string") {
-		process.kill(process.pid, response.signal);
-		return;
-	}
-	exitAfterFlush(typeof response.exitCode === "number" ? response.exitCode : 0);
-}
-
-main().catch((error) => {
-	fail(error instanceof Error ? error.message : String(error));
-});

package/dist/extensions/pi-subagents/test/support/real-session-child-cli.mjs

@@ -1,185 +0,0 @@
-#!/usr/bin/env node
-import { mkdtempSync, rmSync } from "node:fs";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fauxAssistantMessage, fauxProvider, fauxText, fauxToolCall } from "@earendil-works/pi-ai/providers/faux";
-import {
-	createAgentSession,
-	DefaultResourceLoader,
-	ModelRuntime,
-	SessionManager,
-	SettingsManager,
-} from "@selesai/code";
-
-function readText(filePath) {
-	return fs.readFileSync(filePath, "utf-8");
-}
-
-function parseArgs(argv) {
-	const parsed = {
-		mode: "text",
-		extensions: [],
-		appendSystemPrompts: [],
-		noSession: false,
-		noSkills: false,
-	};
-
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (arg === "--mode") {
-			parsed.mode = argv[++i] ?? "text";
-			continue;
-		}
-		if (arg === "-p" || arg === "--print") continue;
-		if (arg === "--no-session") {
-			parsed.noSession = true;
-			continue;
-		}
-		if (arg === "--session") {
-			parsed.sessionFile = argv[++i];
-			continue;
-		}
-		if (arg === "--session-dir") {
-			parsed.sessionDir = argv[++i];
-			continue;
-		}
-		if (arg === "--model") {
-			parsed.model = argv[++i];
-			continue;
-		}
-		if (arg === "--tools") {
-			parsed.tools = (argv[++i] ?? "").split(",").map((tool) => tool.trim()).filter(Boolean);
-			continue;
-		}
-		if (arg === "--extension") {
-			const extensionPath = argv[++i];
-			if (extensionPath) parsed.extensions.push(extensionPath);
-			continue;
-		}
-		if (arg === "--no-extensions") continue;
-		if (arg === "--no-skills") {
-			parsed.noSkills = true;
-			continue;
-		}
-		if (arg === "--system-prompt") {
-			const promptPath = argv[++i];
-			if (promptPath) parsed.systemPrompt = readText(promptPath);
-			continue;
-		}
-		if (arg === "--append-system-prompt") {
-			const promptPath = argv[++i];
-			if (promptPath) parsed.appendSystemPrompts.push(readText(promptPath));
-			continue;
-		}
-		if (arg?.startsWith("--")) continue;
-		parsed.prompt = arg;
-	}
-
-	if (parsed.prompt?.startsWith("@")) {
-		parsed.prompt = readText(parsed.prompt.slice(1));
-	}
-	return parsed;
-}
-
-function createSessionManager(parsed, cwd) {
-	if (parsed.sessionFile) {
-		const sessionDir = parsed.sessionDir ?? path.dirname(parsed.sessionFile);
-		const manager = SessionManager.create(cwd, sessionDir);
-		manager.setSessionFile(parsed.sessionFile);
-		return manager;
-	}
-	if (parsed.noSession) return SessionManager.inMemory(cwd);
-	return SessionManager.create(cwd, parsed.sessionDir);
-}
-
-async function main() {
-	const parsed = parseArgs(process.argv.slice(2));
-	const responseText = process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT ?? "CHILD_REAL_SESSION_OK";
-	const reportChildTools = process.env.SELESAI_SUBAGENTS_E2E_REPORT_CHILD_TOOLS === "1";
-	const cwd = process.cwd();
-	const ownedAgentDir = process.env.SELESAI_CODING_AGENT_DIR
-		? undefined
-		: mkdtempSync(path.join(os.tmpdir(), "pi-e2e-agent-dir-"));
-	const agentDir = process.env.SELESAI_CODING_AGENT_DIR ?? ownedAgentDir;
-
-	const faux = fauxProvider({
-		provider: "faux-e2e-child",
-		models: [{ id: "child", contextWindow: 200_000 }],
-	});
-	const modelRuntime = await ModelRuntime.create({
-		authPath: path.join(agentDir, "auth.json"),
-		modelsPath: null,
-		allowModelNetwork: false,
-	});
-	modelRuntime.registerProvider(faux.provider.id, {
-		name: faux.provider.name,
-		api: faux.api,
-		apiKey: "faux",
-		streamSimple: faux.provider.streamSimple,
-		models: [...faux.models],
-	});
-	const model = modelRuntime.getModel(faux.provider.id, "child");
-	if (!model) throw new Error("faux child model was not registered");
-	let session;
-	faux.setResponses([
-		() => process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE
-			? fauxAssistantMessage(fauxToolCall("structured_output", { value: { marker: "STRUCTURED_OUTPUT_OK" } }), { stopReason: "toolUse" })
-			: fauxAssistantMessage(fauxText(reportChildTools ? `ACTIVE_TOOLS:${session?.getActiveToolNames().sort().join(",") ?? ""}` : responseText), { stopReason: "stop" }),
-	]);
-
-	const settingsManager = SettingsManager.inMemory({
-		compaction: { enabled: false },
-		retry: { enabled: false },
-	});
-	const loader = new DefaultResourceLoader({
-		cwd,
-		agentDir,
-		settingsManager,
-		additionalExtensionPaths: parsed.extensions,
-		noSkills: parsed.noSkills,
-		noPromptTemplates: true,
-		noThemes: true,
-		noContextFiles: true,
-		systemPrompt: parsed.systemPrompt,
-		appendSystemPrompt: parsed.appendSystemPrompts,
-	});
-
-	try {
-		await loader.reload();
-		const created = await createAgentSession({
-			cwd,
-			agentDir,
-			model,
-			modelRuntime,
-			resourceLoader: loader,
-			sessionManager: createSessionManager(parsed, cwd),
-			settingsManager,
-			tools: parsed.tools,
-		});
-		session = created.session;
-
-		session.subscribe((event) => {
-			if (
-				event.type === "message_end"
-				|| event.type === "tool_execution_start"
-				|| event.type === "tool_execution_end"
-				|| event.type === "tool_result_end"
-			) {
-				process.stdout.write(`${JSON.stringify(event)}\n`);
-			}
-		});
-
-		await session.bindExtensions({});
-		await session.prompt(parsed.prompt ?? "", { expandPromptTemplates: false });
-		await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
-		session.dispose();
-	} finally {
-		if (ownedAgentDir) rmSync(ownedAgentDir, { recursive: true, force: true });
-	}
-}
-
-main().catch((error) => {
-	process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
-	process.exit(1);
-});