@selesai/code 0.1.19 → 0.2.1

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

@@ -8,14 +8,15 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@selesai/code";
 import type { AgentConfig } from "../../agents/agents.ts";
 import { applyThinkingSuffix } from "../shared/pi-args.ts";
 import { injectOutputPathSystemPrompt, injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveStepBehavior, suppressProgressForReadOnlyTask, writeInitialProgressFile, type ChainStep, type ResolvedStepBehavior, type SequentialStep, type StepOverrides } from "../../shared/settings.ts";
 import type { RunnerStep } from "../shared/parallel-utils.ts";
-import { resolvePiPackageRoot } from "../shared/pi-spawn.ts";
+import { getSelesaiSpawnCommand, resolveSelesaiPackageRoot } from "../shared/pi-spawn.ts";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.ts";
+import { createSpawnTimingMarkers, emitSpawnTiming } from "../shared/spawn-timing.ts";
 import { resolveChildCwd } from "../../shared/utils.ts";
 import { buildModelCandidates, resolveModelCandidate, resolveSubagentModelOverride, type AvailableModelInfo, type ParentModel } from "../shared/model-fallback.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
@@ -43,7 +44,7 @@ import { nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedPar
 import type { ImportedAsyncRoot } from "./chain-root-attachment.ts";
 
 const require = createRequire(import.meta.url);
-const piPackageRoot = resolvePiPackageRoot();
+const piPackageRoot = resolveSelesaiPackageRoot();
 
 function resolveJitiCliFromPackageJson(packageJsonPath: string): string | undefined {
 	if (!fs.existsSync(packageJsonPath)) return undefined;
@@ -204,7 +205,7 @@ export function formatAsyncStartedMessage(headline: string): string {
  * Check if jiti is available for async execution
  */
 export function isAsyncAvailable(): boolean {
-	return jitiCliPath !== undefined;
+	return resolveRunnerScript() !== undefined || getSelesaiSpawnCommand(["--offline", "--mode", "json", "-p"], { ...(piPackageRoot ? { piPackageRoot } : {}) }).command !== "" || jitiCliPath !== undefined;
 }
 
 function resolveAsyncRunnerNodeCommand(): string {
@@ -215,14 +216,63 @@ function resolveAsyncRunnerNodeCommand(): string {
 	return process.platform === "win32" ? "node.exe" : "node";
 }
 
-/**
- * Spawn the async runner process
- */
-function spawnRunner(cfg: object, suffix: string, cwd: string): { pid?: number; error?: string } {
+function resolveRunnerScript(): string | undefined {
+	const localDir = path.dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		piPackageRoot ? path.join(piPackageRoot, "dist/runner/runs/background/subagent-runner.js") : undefined,
+		path.join(localDir, "../../../dist/runner/runs/background/subagent-runner.js"),
+		path.join(localDir, "subagent-runner.ts"),
+	].filter((candidate): candidate is string => Boolean(candidate));
+	for (const candidate of candidates) {
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return undefined;
+}
+
+type AsyncRunnerSpawnMode = "compiled" | "cli" | "jiti";
+
+function resolveAsyncRunnerSpawnMode(): AsyncRunnerSpawnMode {
+	if (process.env.SELESAI_SUBAGENT_RUNNER_USE_JITI === "1") return "jiti";
+	const runnerScript = resolveRunnerScript();
+	if (runnerScript?.endsWith(".js")) return "compiled";
+	return "cli";
+}
+
+interface SpawnCommandSpec {
+	command: string;
+	args: string[];
+	env?: Record<string, string | undefined>;
+}
+
+function buildAsyncRunnerSpawnSpec(cfgPath: string): SpawnCommandSpec | { error: string } {
+	const mode = resolveAsyncRunnerSpawnMode();
+	if (mode === "compiled") {
+		const runnerScript = resolveRunnerScript();
+		if (!runnerScript) return { error: "compiled async runner script could not be resolved" };
+		return { command: resolveAsyncRunnerNodeCommand(), args: [runnerScript, cfgPath] };
+	}
+	if (mode === "cli") {
+		const spawnSpec = getSelesaiSpawnCommand(["--offline", "--mode", "json", "-p"], {
+			...(piPackageRoot ? { piPackageRoot } : {}),
+		});
+		return {
+			command: spawnSpec.command,
+			args: spawnSpec.args,
+			env: { ...process.env, SELESAI_SUBAGENT_RUNNER_CONFIG: cfgPath },
+		};
+	}
 	if (!jitiCliPath) {
 		return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
 	}
+	const runnerScript = resolveRunnerScript();
+	if (!runnerScript) return { error: "async runner script could not be resolved" };
+	return { command: resolveAsyncRunnerNodeCommand(), args: [jitiCliPath, runnerScript, cfgPath] };
+}
 
+/**
+ * Spawn the async runner process
+ */
+function spawnRunner(cfg: object, suffix: string, cwd: string): { pid?: number; error?: string } {
 	try {
 		const cwdStats = fs.statSync(cwd);
 		if (!cwdStats.isDirectory()) {
@@ -235,14 +285,23 @@ function spawnRunner(cfg: object, suffix: string, cwd: string): { pid?: number;
 	fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true });
 	const cfgPath = getAsyncConfigPath(suffix);
 	fs.writeFileSync(cfgPath, JSON.stringify(cfg));
-	const runner = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner.ts");
-	const nodeCommand = resolveAsyncRunnerNodeCommand();
+	const asyncDir = (cfg as { asyncDir?: string }).asyncDir;
+	const eventsPath = asyncDir ? path.join(asyncDir, "events.jsonl") : undefined;
+	const markers = createSpawnTimingMarkers();
+	emitSpawnTiming({ eventsPath, marker: "spawn_start", markers, runId: suffix });
+
+	const spec = buildAsyncRunnerSpawnSpec(cfgPath);
+	if ("error" in spec) {
+		return { error: spec.error };
+	}
+	emitSpawnTiming({ eventsPath, marker: "spawn_command_resolved", markers, runId: suffix });
 
-	const proc = spawn(nodeCommand, [jitiCliPath, runner, cfgPath], {
+	const proc = spawn(spec.command, spec.args, {
 		cwd,
 		detached: true,
 		stdio: "ignore",
 		windowsHide: true,
+		...(spec.env ? { env: spec.env } : {}),
 	});
 	proc.on("error", (error) => {
 		console.error(`[pi-subagents] async spawn failed: ${error.message}`);
@@ -663,7 +722,7 @@ export function executeAsyncChain(
 						path: nestedAddress.path,
 						asyncDir,
 						pid: spawnResult.pid,
-						ownerIntercomTarget: process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME,
+						ownerIntercomTarget: process.env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME,
 						leafIntercomTarget: childIntercomTargets?.[0],
 						intercomTarget: childIntercomTargets?.[0],
 						ownerState: "live",
@@ -879,7 +938,7 @@ export function executeAsyncSingle(
 						path: nestedAddress.path,
 						asyncDir,
 						pid: spawnResult.pid,
-						ownerIntercomTarget: process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME,
+						ownerIntercomTarget: process.env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME,
 						leafIntercomTarget: childIntercomTarget?.(agent, 0),
 						intercomTarget: childIntercomTarget?.(agent, 0),
 						ownerState: "live",

package/dist/extensions/pi-subagents/src/runs/background/async-job-tracker.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { renderWidget, widgetRenderKey } from "../../tui/render.ts";

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

@@ -2,7 +2,7 @@
  * Subagent completion notifications.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@selesai/code";
 import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
 

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;