@selesai/code 0.1.18 → 0.2.0

package/dist/extensions/pi-subagents/src/runs/background/subagent-runner.ts

@@ -6,7 +6,7 @@ import type { Message } from "@earendil-works/pi-ai";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { consumeInterruptRequest, watchAsyncControlInbox } from "./control-channel.ts";
 import { appendJsonl as appendRawJsonl, getArtifactPaths } from "../../shared/artifacts.ts";
-import { PI_CODING_AGENT_PACKAGE, getPiSpawnCommand, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.ts";
+import { SELESAI_PACKAGE, getSelesaiSpawnCommand, resolveInstalledSelesaiPackageRoot } from "../shared/pi-spawn.ts";
 import { captureSingleOutputSnapshot, finalizeSingleOutput, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
 	type ActivityState,
@@ -81,6 +81,7 @@ import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts
 import { acceptanceFailureMessage, aggregateAcceptanceReport, evaluateAcceptance, formatAcceptancePrompt, stripAcceptanceReport } from "../shared/acceptance.ts";
 import { waitForImportedAsyncRoot } from "./chain-root-attachment.ts";
 import { appendRunnerStepsToStatus, consumeChainAppendRequests, countPendingChainAppendRequests } from "./chain-append.ts";
+import { createSpawnTimingMarkers, emitSpawnTiming, type SpawnTimingMarkers } from "../shared/spawn-timing.ts";
 
 interface SubagentRunConfig {
 	id: string;
@@ -133,7 +134,7 @@ interface StepResult {
 
 const ASYNC_INTERRUPT_SIGNAL: NodeJS.Signals = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
 const DEFAULT_MAX_ASYNC_EVENTS_BYTES = 50 * 1024 * 1024;
-const ASYNC_EVENTS_MAX_BYTES_ENV = "PI_SUBAGENT_ASYNC_EVENTS_MAX_BYTES";
+const ASYNC_EVENTS_MAX_BYTES_ENV = "SELESAI_SUBAGENT_ASYNC_EVENTS_MAX_BYTES";
 const TRUNCATED_EVENT_TYPE = "subagent.events.truncated";
 const TRUNCATION_MARKER_RESERVE_BYTES = 512;
 
@@ -261,6 +262,7 @@ interface ChildEventContext {
 	runId: string;
 	stepIndex: number;
 	agent: string;
+	markers?: SpawnTimingMarkers;
 }
 
 interface ChildUsage {
@@ -313,10 +315,17 @@ function runPiStreaming(
 	return new Promise((resolve) => {
 		const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
 		const spawnEnv = { ...process.env, ...(env ?? {}), ...getSubagentDepthEnv(maxSubagentDepth) };
-		const spawnSpec = getPiSpawnCommand(args, {
+		const markers = childEventContext ? createSpawnTimingMarkers() : undefined;
+		if (markers) {
+			emitSpawnTiming({ eventsPath: childEventContext.eventsPath, marker: "spawn_start", markers, runId: childEventContext.runId, stepIndex: childEventContext.stepIndex, agent: childEventContext.agent });
+		}
+		const spawnSpec = getSelesaiSpawnCommand(args, {
 			...(piPackageRoot ? { piPackageRoot } : {}),
 			...(piArgv1 ? { argv1: piArgv1 } : {}),
 		});
+		if (markers) {
+			emitSpawnTiming({ eventsPath: childEventContext.eventsPath, marker: "spawn_command_resolved", markers, runId: childEventContext.runId, stepIndex: childEventContext.stepIndex, agent: childEventContext.agent });
+		}
 		const child = spawn(spawnSpec.command, spawnSpec.args, {
 			cwd,
 			stdio: ["ignore", "pipe", "pipe"],
@@ -333,8 +342,22 @@ function runPiStreaming(
 		let assistantError: string | undefined;
 		let interrupted = false;
 		let observedMutationAttempt = false;
+		let firstEventEmitted = false;
+		let firstJsonlEventEmitted = false;
 		const rawStdoutLines: string[] = [];
 
+		const emitChildTiming = (marker: import("../shared/spawn-timing.ts").SpawnTimingMarker) => {
+			if (!markers || !childEventContext) return;
+			emitSpawnTiming({
+				eventsPath: childEventContext.eventsPath,
+				marker,
+				markers,
+				runId: childEventContext.runId,
+				stepIndex: childEventContext.stepIndex,
+				agent: childEventContext.agent,
+			});
+		};
+
 		const writeOutputLine = (line: string) => {
 			if (!line.trim()) return;
 			outputStream.write(`${line}\n`);
@@ -368,6 +391,10 @@ function runPiStreaming(
 			let event: ChildEvent;
 			try {
 				event = JSON.parse(line) as ChildEvent;
+				if (!firstJsonlEventEmitted) {
+					firstJsonlEventEmitted = true;
+					emitChildTiming("child_first_jsonl_event");
+				}
 			} catch {
 				rawStdoutLines.push(line);
 				writeOutputLine(line);
@@ -438,6 +465,10 @@ function runPiStreaming(
 		let settled = false;
 		const clearStdioGuard = attachPostExitStdioGuard(child, { idleMs: 2000, hardMs: 8000 });
 		child.stdout.on("data", (chunk: Buffer) => {
+			if (!firstEventEmitted) {
+				firstEventEmitted = true;
+				emitChildTiming("child_first_event");
+			}
 			const text = chunk.toString();
 			stdoutBuf += text;
 			const lines = stdoutBuf.split("\n");
@@ -446,6 +477,10 @@ function runPiStreaming(
 		});
 
 		child.stderr.on("data", (chunk: Buffer) => {
+			if (!firstEventEmitted) {
+				firstEventEmitted = true;
+				emitChildTiming("child_first_event");
+			}
 			processStderrText(chunk.toString());
 		});
 		registerInterrupt?.(() => {
@@ -526,14 +561,14 @@ function runPiStreaming(
 	});
 }
 
-function resolvePiPackageRootFallback(): string {
-	const root = resolveInstalledPiPackageRoot();
+function resolveSelesaiPackageRootFallback(): string {
+	const root = resolveInstalledSelesaiPackageRoot();
 	if (root) return root;
-	throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
+	throw new Error(`Could not resolve ${SELESAI_PACKAGE} package root`);
 }
 
 async function exportSessionHtml(sessionFile: string, outputDir: string, piPackageRoot?: string): Promise<string> {
-	const pkgRoot = piPackageRoot ?? resolvePiPackageRootFallback();
+	const pkgRoot = piPackageRoot ?? resolveSelesaiPackageRootFallback();
 	const exportModulePath = path.join(pkgRoot, "dist", "core", "export-html", "index.js");
 	const moduleUrl = pathToFileURL(exportModulePath).href;
 	const mod = await import(moduleUrl);
@@ -752,7 +787,7 @@ async function runSingleStep(
 		}
 		const { args, env, tempDir } = buildPiArgs({
 			parentSessionId: step.parentSessionId,
-			baseArgs: ["--mode", "json", "-p"],
+			baseArgs: ["--offline", "--mode", "json", "-p"],
 			task,
 			sessionEnabled,
 			sessionDir,
@@ -1056,7 +1091,7 @@ function ensureParallelProgressFile(cwd: string, group: Extract<RunnerStep, { pa
 	writeInitialProgressFile(cwd);
 }
 
-async function runSubagent(config: SubagentRunConfig): Promise<void> {
+export async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	const { id, steps, resultPath, cwd, placeholder, taskIndex, totalTasks, maxOutput, artifactsDir, artifactConfig } =
 		config;
 	let previousOutput = "";
@@ -2419,40 +2454,49 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	}
 }
 
-const configArg = process.argv[2];
-if (configArg) {
+export async function runSubagentFromConfigFile(cfgPath: string): Promise<void> {
+	const configJson = fs.readFileSync(cfgPath, "utf-8");
+	const config = JSON.parse(configJson) as SubagentRunConfig;
 	try {
-		const configJson = fs.readFileSync(configArg, "utf-8");
-		const config = JSON.parse(configJson) as SubagentRunConfig;
-		try {
-			fs.unlinkSync(configArg);
-		} catch {
-			// Temp config cleanup is best effort.
-		}
-		runSubagent(config).catch((runErr) => {
-			console.error("Subagent runner error:", runErr);
-			process.exit(1);
-		});
-	} catch (err) {
-		console.error("Subagent runner error:", err);
-		process.exit(1);
+		fs.unlinkSync(cfgPath);
+	} catch {
+		// Temp config cleanup is best effort.
 	}
-} else {
-	let input = "";
-	process.stdin.setEncoding("utf-8");
-	process.stdin.on("data", (chunk) => {
-		input += chunk;
-	});
-	process.stdin.on("end", () => {
-		try {
-			const config = JSON.parse(input) as SubagentRunConfig;
-			runSubagent(config).catch((runErr) => {
-				console.error("Subagent runner error:", runErr);
-				process.exit(1);
-			});
-		} catch (err) {
+	await runSubagent(config);
+}
+
+function isRunnerMainModule(): boolean {
+	try {
+		return import.meta.url === pathToFileURL(process.argv[1] ?? "").href;
+	} catch {
+		return false;
+	}
+}
+
+if (!runnerConfigPath && isRunnerMainModule()) {
+	const configArg = process.argv[2];
+	if (configArg) {
+		runSubagentFromConfigFile(configArg).catch((err) => {
 			console.error("Subagent runner error:", err);
 			process.exit(1);
-		}
-	});
+		});
+	} else {
+		let input = "";
+		process.stdin.setEncoding("utf-8");
+		process.stdin.on("data", (chunk) => {
+			input += chunk;
+		});
+		process.stdin.on("end", () => {
+			try {
+				const config = JSON.parse(input) as SubagentRunConfig;
+				runSubagent(config).catch((err) => {
+					console.error("Subagent runner error:", err);
+					process.exit(1);
+				});
+			} catch (err) {
+				console.error("Subagent runner error:", err);
+				process.exit(1);
+			}
+		});
+	}
 }

package/dist/extensions/pi-subagents/src/runs/foreground/chain-clarify.ts

@@ -5,7 +5,7 @@
  * Supports runtime editing of templates, output paths, reads lists, and progress toggle.
  */
 
-import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@selesai/code";
 import type { Component, TUI } from "@earendil-works/pi-tui";
 import { matchesKey, visibleWidth, truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentConfig } from "../../agents/agents.ts";

package/dist/extensions/pi-subagents/src/runs/foreground/chain-execution.ts

@@ -5,7 +5,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@selesai/code";
 import type { AgentConfig } from "../../agents/agents.ts";
 import { ChainClarifyComponent, type ChainClarifyResult, type BehaviorOverride } from "./chain-clarify.ts";
 import { toModelInfo, type ModelInfo } from "../../shared/model-info.ts";

package/dist/extensions/pi-subagents/src/runs/foreground/execution.ts

@@ -44,10 +44,11 @@ import {
 } from "../../shared/utils.ts";
 import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
 import { evaluateCompletionMutationGuard } from "../shared/completion-guard.ts";
-import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
+import { getSelesaiSpawnCommand } from "../shared/pi-spawn.ts";
 import { createJsonlWriter } from "../../shared/jsonl-writer.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
 import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
+import { createSpawnTimingMarkers, emitSpawnTiming } from "../shared/spawn-timing.ts";
 import { readStructuredOutput } from "../shared/structured-output.ts";
 import { captureSingleOutputSnapshot, formatSavedOutputReference, injectOutputPathSystemPrompt, resolveSingleOutput, validateFileOnlyOutputMode, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
@@ -182,7 +183,7 @@ async function runSingleAttempt(
 ): Promise<SingleResult> {
 	const modelArg = applyThinkingSuffix(model, agent.thinking);
 		const { args, env: sharedEnv, tempDir } = buildPiArgs({
-		baseArgs: ["--mode", "json", "-p"],
+		baseArgs: ["--offline", "--mode", "json", "-p"],
 		task,
 		sessionEnabled: shared.sessionEnabled,
 		sessionDir: options.sessionDir,
@@ -278,7 +279,24 @@ async function runSingleAttempt(
 	let observedMutationAttempt = false;
 
 	const exitCode = await new Promise<number>((resolve) => {
-		const spawnSpec = getPiSpawnCommand(args);
+		const markers = createSpawnTimingMarkers();
+		const spawnSpec = getSelesaiSpawnCommand(args);
+		emitSpawnTiming({
+			eventsPath: shared.jsonlPath,
+			marker: "spawn_start",
+			markers,
+			runId: options.runId,
+			stepIndex: options.index ?? 0,
+			agent: agent.name,
+		});
+		emitSpawnTiming({
+			eventsPath: shared.jsonlPath,
+			marker: "spawn_command_resolved",
+			markers,
+			runId: options.runId,
+			stepIndex: options.index ?? 0,
+			agent: agent.name,
+		});
 		const proc = spawn(spawnSpec.command, spawnSpec.args, {
 			cwd: options.cwd ?? runtimeCwd,
 			env: spawnEnv,
@@ -286,6 +304,8 @@ async function runSingleAttempt(
 			windowsHide: true,
 		});
 		const jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout);
+		let firstEventEmitted = false;
+		let firstJsonlEventEmitted = false;
 		let buf = "";
 		let processClosed = false;
 		let settled = false;
@@ -498,12 +518,27 @@ async function runSingleAttempt(
 			emitUpdateSnapshot(output || "(running...)");
 		};
 
+		const emitTiming = (marker: import("../shared/spawn-timing.ts").SpawnTimingMarker) => {
+			emitSpawnTiming({
+				eventsPath: shared.jsonlPath,
+				marker,
+				markers,
+				runId: options.runId,
+				stepIndex: options.index ?? 0,
+				agent: agent.name,
+			});
+		};
+
 		const processLine = (line: string) => {
 			if (!line.trim()) return;
 			jsonlWriter.writeLine(line);
 			let evt: { type?: string; message?: Message; toolName?: string; args?: unknown };
 			try {
 				evt = JSON.parse(line) as { type?: string; message?: Message; toolName?: string; args?: unknown };
+				if (!firstJsonlEventEmitted) {
+					firstJsonlEventEmitted = true;
+					emitTiming("child_first_jsonl_event");
+				}
 			} catch {
 				// Non-JSON stdout lines are expected; only structured events are parsed.
 				return;
@@ -650,12 +685,20 @@ async function runSingleAttempt(
 
 		const clearStdioGuard = attachPostExitStdioGuard(proc, { idleMs: 2000, hardMs: 8000 });
 		proc.stdout.on("data", (d) => {
+			if (!firstEventEmitted) {
+				firstEventEmitted = true;
+				emitTiming("child_first_event");
+			}
 			buf += d.toString();
 			const lines = buf.split("\n");
 			buf = lines.pop() || "";
 			lines.forEach(processLine);
 		});
 		proc.stderr.on("data", (d) => {
+			if (!firstEventEmitted) {
+				firstEventEmitted = true;
+				emitTiming("child_first_event");
+			}
 			stderrBuf += d.toString();
 		});
 		proc.on("exit", () => {

package/dist/extensions/pi-subagents/src/runs/foreground/subagent-executor.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
 import { type AgentConfig, type AgentScope } from "../../agents/agents.ts";
 import { getArtifactsDir } from "../../shared/artifacts.ts";
 import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
@@ -3035,7 +3035,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 						parentStepIndex: nestedParentAddress.parentStepIndex,
 						depth: nestedParentAddress.depth,
 						path: nestedParentAddress.path,
-						ownerIntercomTarget: process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME,
+						ownerIntercomTarget: process.env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME,
 						leafIntercomTarget,
 						intercomTarget: leafIntercomTarget,
 						ownerState: state === "running" ? "live" : "gone",

package/dist/extensions/pi-subagents/src/runs/shared/completion-guard.ts

@@ -59,9 +59,7 @@ const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"grep",
 	"find",
 	"ls",
-	"web_search",
-	"fetch_content",
-	"get_search_content",
+	"web_explore",
 	"intercom",
 	"contact_supervisor",
 ]);

package/dist/extensions/pi-subagents/src/runs/shared/nested-events.ts

@@ -802,8 +802,8 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 
 export function nestedArtifactEnv(rootRunId: string, parentRunId: string): Record<string, string> {
 	return {
-		PI_SUBAGENT_NESTED_ROOT_RUN_ID: rootRunId,
-		PI_SUBAGENT_NESTED_PARENT_RUN_ID: parentRunId,
+		SELESAI_SUBAGENT_NESTED_ROOT_RUN_ID: rootRunId,
+		SELESAI_SUBAGENT_NESTED_PARENT_RUN_ID: parentRunId,
 	};
 }
 

package/dist/extensions/pi-subagents/src/runs/shared/pi-args.ts

@@ -11,21 +11,21 @@ const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const TASK_ARG_LIMIT = 8000;
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-prompt-runtime.ts");
 const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "extension", "fanout-child.ts");
-export const SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD";
-export const SUBAGENT_ORCHESTRATOR_TARGET_ENV = "PI_SUBAGENT_ORCHESTRATOR_TARGET";
-export const SUBAGENT_RUN_ID_ENV = "PI_SUBAGENT_RUN_ID";
-export const SUBAGENT_CHILD_AGENT_ENV = "PI_SUBAGENT_CHILD_AGENT";
-export const SUBAGENT_CHILD_INDEX_ENV = "PI_SUBAGENT_CHILD_INDEX";
-export const SUBAGENT_FANOUT_CHILD_ENV = "PI_SUBAGENT_FANOUT_CHILD";
-export const SUBAGENT_PARENT_EVENT_SINK_ENV = "PI_SUBAGENT_PARENT_EVENT_SINK";
-export const SUBAGENT_PARENT_CONTROL_INBOX_ENV = "PI_SUBAGENT_PARENT_CONTROL_INBOX";
-export const SUBAGENT_PARENT_ROOT_RUN_ID_ENV = "PI_SUBAGENT_PARENT_ROOT_RUN_ID";
-export const SUBAGENT_PARENT_RUN_ID_ENV = "PI_SUBAGENT_PARENT_RUN_ID";
-export const SUBAGENT_PARENT_CHILD_INDEX_ENV = "PI_SUBAGENT_PARENT_CHILD_INDEX";
-export const SUBAGENT_PARENT_DEPTH_ENV = "PI_SUBAGENT_PARENT_DEPTH";
-export const SUBAGENT_PARENT_PATH_ENV = "PI_SUBAGENT_PARENT_PATH";
-export const SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV = "PI_SUBAGENT_PARENT_CAPABILITY_TOKEN";
-export const SUBAGENT_PARENT_SESSION_ENV = "PI_SUBAGENT_PARENT_SESSION";
+export const SUBAGENT_CHILD_ENV = "SELESAI_SUBAGENT_CHILD";
+export const SUBAGENT_ORCHESTRATOR_TARGET_ENV = "SELESAI_SUBAGENT_ORCHESTRATOR_TARGET";
+export const SUBAGENT_RUN_ID_ENV = "SELESAI_SUBAGENT_RUN_ID";
+export const SUBAGENT_CHILD_AGENT_ENV = "SELESAI_SUBAGENT_CHILD_AGENT";
+export const SUBAGENT_CHILD_INDEX_ENV = "SELESAI_SUBAGENT_CHILD_INDEX";
+export const SUBAGENT_FANOUT_CHILD_ENV = "SELESAI_SUBAGENT_FANOUT_CHILD";
+export const SUBAGENT_PARENT_EVENT_SINK_ENV = "SELESAI_SUBAGENT_PARENT_EVENT_SINK";
+export const SUBAGENT_PARENT_CONTROL_INBOX_ENV = "SELESAI_SUBAGENT_PARENT_CONTROL_INBOX";
+export const SUBAGENT_PARENT_ROOT_RUN_ID_ENV = "SELESAI_SUBAGENT_PARENT_ROOT_RUN_ID";
+export const SUBAGENT_PARENT_RUN_ID_ENV = "SELESAI_SUBAGENT_PARENT_RUN_ID";
+export const SUBAGENT_PARENT_CHILD_INDEX_ENV = "SELESAI_SUBAGENT_PARENT_CHILD_INDEX";
+export const SUBAGENT_PARENT_DEPTH_ENV = "SELESAI_SUBAGENT_PARENT_DEPTH";
+export const SUBAGENT_PARENT_PATH_ENV = "SELESAI_SUBAGENT_PARENT_PATH";
+export const SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV = "SELESAI_SUBAGENT_PARENT_CAPABILITY_TOKEN";
+export const SUBAGENT_PARENT_SESSION_ENV = "SELESAI_SUBAGENT_PARENT_SESSION";
 
 interface BuildPiArgsInput {
 	parentSessionId?: string;
@@ -196,10 +196,10 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] = fanoutAuthorized
 		? input.parentCapabilityToken ?? process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] ?? ""
 		: "";
-	env.PI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0";
-	env.PI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0";
+	env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0";
+	env.SELESAI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0";
 	if (input.intercomSessionName) {
-		env.PI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName;
+		env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName;
 	}
 	if (input.orchestratorIntercomTarget) {
 		env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = input.orchestratorIntercomTarget;

package/dist/extensions/pi-subagents/src/runs/shared/pi-spawn.ts

@@ -2,36 +2,36 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 
-export const PI_CODING_AGENT_PACKAGE = "@earendil-works/pi-coding-agent";
+export const SELESAI_PACKAGE = "@selesai/code";
 
-export function findPiPackageRootFromEntry(entryPoint: string): string | undefined {
+export function findSelesaiPackageRootFromEntry(entryPoint: string): string | undefined {
 	let dir = path.dirname(entryPoint);
 	while (dir !== path.dirname(dir)) {
 		const packageJsonPath = path.join(dir, "package.json");
 		if (fs.existsSync(packageJsonPath)) {
 			const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as { name?: unknown };
-			if (pkg.name === PI_CODING_AGENT_PACKAGE) return dir;
+			if (pkg.name === SELESAI_PACKAGE) return dir;
 		}
 		dir = path.dirname(dir);
 	}
 	return undefined;
 }
 
-export function resolveInstalledPiPackageRoot(): string | undefined {
-	return findPiPackageRootFromEntry(fileURLToPath(import.meta.resolve(PI_CODING_AGENT_PACKAGE)));
+export function resolveInstalledSelesaiPackageRoot(): string | undefined {
+	return findSelesaiPackageRootFromEntry(fileURLToPath(import.meta.resolve(SELESAI_PACKAGE)));
 }
 
-export function resolvePiPackageRoot(): string | undefined {
+export function resolveSelesaiPackageRoot(): string | undefined {
 	try {
 		const entry = process.argv[1];
-		return entry ? findPiPackageRootFromEntry(fs.realpathSync(entry)) : undefined;
+		return entry ? findSelesaiPackageRootFromEntry(fs.realpathSync(entry)) : undefined;
 	} catch {
 		// process.argv[1] probing is best-effort; callers can fall back to PATH/package resolution.
 		return undefined;
 	}
 }
 
-export interface PiSpawnDeps {
+export interface SelesaiSpawnDeps {
 	platform?: NodeJS.Platform;
 	execPath?: string;
 	argv1?: string;
@@ -42,7 +42,7 @@ export interface PiSpawnDeps {
 	piPackageRoot?: string;
 }
 
-interface PiSpawnCommand {
+interface SelesaiSpawnCommand {
 	command: string;
 	args: string[];
 }
@@ -56,7 +56,7 @@ function normalizePath(filePath: string): string {
 	return path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
 }
 
-export function resolveWindowsPiCliScript(deps: PiSpawnDeps = {}): string | undefined {
+export function resolveWindowsSelesaiCliScript(deps: SelesaiSpawnDeps = {}): string | undefined {
 	const existsSync = deps.existsSync ?? fs.existsSync;
 	const readFileSync = deps.readFileSync ?? ((filePath, encoding) => fs.readFileSync(filePath, encoding));
 	const argv1 = deps.argv1 ?? process.argv[1];
@@ -82,12 +82,12 @@ export function resolveWindowsPiCliScript(deps: PiSpawnDeps = {}): string | unde
 
 	try {
 		const resolvePackageJson = deps.resolvePackageJson ?? (() => {
-			const root = deps.piPackageRoot ?? resolvePiPackageRoot();
+			const root = deps.piPackageRoot ?? resolveSelesaiPackageRoot();
 			if (root) return path.join(root, "package.json");
 			const packageRoot = deps.resolvePackageEntry
-				? findPiPackageRootFromEntry(deps.resolvePackageEntry())
-				: resolveInstalledPiPackageRoot();
-			if (!packageRoot) throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
+				? findSelesaiPackageRootFromEntry(deps.resolvePackageEntry())
+				: resolveInstalledSelesaiPackageRoot();
+			if (!packageRoot) throw new Error(`Could not resolve ${SELESAI_PACKAGE} package root`);
 			return path.join(packageRoot, "package.json");
 		});
 		const packageJsonPath = resolvePackageJson();
@@ -97,33 +97,33 @@ export function resolveWindowsPiCliScript(deps: PiSpawnDeps = {}): string | unde
 		const binField = packageJson.bin;
 		const binPath = typeof binField === "string"
 			? binField
-			: binField?.pi ?? Object.values(binField ?? {})[0];
+			: binField?.selesai ?? Object.values(binField ?? {})[0];
 		if (!binPath) return undefined;
 		const candidate = path.resolve(path.dirname(packageJsonPath), binPath);
 		if (isRunnableNodeScript(candidate, existsSync)) {
 			return candidate;
 		}
 	} catch {
-		// Windows CLI resolution is optional; falling back to `pi` lets PATH handle execution.
+		// Windows CLI resolution is optional; falling back to `selesai` lets PATH handle execution.
 		return undefined;
 	}
 
 	return undefined;
 }
 
-export function getPiSpawnCommand(args: string[], deps: PiSpawnDeps = {}): PiSpawnCommand {
+export function getSelesaiSpawnCommand(args: string[], deps: SelesaiSpawnDeps = {}): SelesaiSpawnCommand {
 	// On all platforms, prefer the running CLI script (process.argv[1]) so a
 	// renamed fork like "selesai" spawns its own binary instead of the upstream
-	// "pi" from PATH (which has a different agent dir / providers / auth).
-	const piCliPath = resolveWindowsPiCliScript(deps);
-	if (piCliPath) {
+	// "selesai" from PATH (which has a different agent dir / providers / auth).
+	const selesaiCliPath = resolveWindowsSelesaiCliScript(deps);
+	if (selesaiCliPath) {
 		return {
 			command: deps.execPath ?? process.execPath,
-			args: [piCliPath, ...args],
+			args: [selesaiCliPath, ...args],
 		};
 	}
 
 	// Fall back to the upstream binary name only if the CLI script could not be
-	// resolved. "pi" remains the historical default for stock pi installs.
-	return { command: "pi", args };
-}
+	// resolved. "selesai" is the default for selesai installs.
+	return { command: "selesai", args };
+}

package/dist/extensions/pi-subagents/src/runs/shared/spawn-timing.ts

@@ -0,0 +1,46 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { performance } from "node:perf_hooks";
+import { appendJsonl } from "../../shared/artifacts.ts";
+
+export type SpawnTimingMarker =
+	| "spawn_start"
+	| "spawn_command_resolved"
+	| "child_first_event"
+	| "child_first_jsonl_event";
+
+export interface SpawnTimingMarkers {
+	spawnStart: number;
+}
+
+export function createSpawnTimingMarkers(): SpawnTimingMarkers {
+	return { spawnStart: performance.now() };
+}
+
+export function emitSpawnTiming(options: {
+	eventsPath: string | undefined;
+	marker: SpawnTimingMarker;
+	markers: SpawnTimingMarkers;
+	runId?: string;
+	stepIndex?: number;
+	agent?: string;
+}): void {
+	if (!options.eventsPath) return;
+	try {
+		fs.mkdirSync(path.dirname(options.eventsPath), { recursive: true });
+		appendJsonl(
+			options.eventsPath,
+			JSON.stringify({
+				type: "subagent.spawn.timing",
+				ts: Date.now(),
+				runId: options.runId ?? "",
+				stepIndex: options.stepIndex ?? 0,
+				agent: options.agent ?? "runner",
+				marker: options.marker,
+				elapsedMs: Math.round(performance.now() - options.markers.spawnStart),
+			}),
+		);
+	} catch {
+		// Timing diagnostics must never fail the run.
+	}
+}

package/dist/extensions/pi-subagents/src/runs/shared/structured-output.ts

@@ -4,8 +4,8 @@ import * as path from "node:path";
 import { Compile } from "typebox/compile";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 
-export const STRUCTURED_OUTPUT_SCHEMA_ENV = "PI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA";
-export const STRUCTURED_OUTPUT_CAPTURE_ENV = "PI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";
+export const STRUCTURED_OUTPUT_SCHEMA_ENV = "SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA";
+export const STRUCTURED_OUTPUT_CAPTURE_ENV = "SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";
 
 export interface StructuredOutputRuntime {
 	schema: JsonSchemaObject;

package/dist/extensions/pi-subagents/src/runs/shared/subagent-prompt-runtime.ts

@@ -1,13 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@selesai/code";
 import { SUBAGENT_FANOUT_CHILD_ENV } from "./pi-args.ts";
 import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.ts";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 
-const SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV = "PI_SUBAGENT_INHERIT_PROJECT_CONTEXT";
-const SUBAGENT_INHERIT_SKILLS_ENV = "PI_SUBAGENT_INHERIT_SKILLS";
-export const SUBAGENT_INTERCOM_SESSION_NAME_ENV = "PI_SUBAGENT_INTERCOM_SESSION_NAME";
+const SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV = "SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT";
+const SUBAGENT_INHERIT_SKILLS_ENV = "SELESAI_SUBAGENT_INHERIT_SKILLS";
+export const SUBAGENT_INTERCOM_SESSION_NAME_ENV = "SELESAI_SUBAGENT_INTERCOM_SESSION_NAME";
 
 const STRUCTURED_OUTPUT_INSTRUCTIONS = [
 	"This subagent step has a strict structured output contract.",

package/dist/extensions/pi-subagents/src/shared/fork-context.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { SessionManager } from "@selesai/code";
 
 type SubagentExecutionContext = "fresh" | "fork";