@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/runs/shared/pi-args.js

@@ -2,216 +2,159 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { encodeNestedPathEnv, parseNestedPathEnv } from "./nested-path.js";
 import { resolveMcpDirectToolNames } from "./mcp-direct-tool-allowlist.js";
-import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "./structured-output.js";
+import { childRouteEnv, SUBAGENT_EAGER_TOOL_ENV, SUBAGENT_INHERITED_EXTENSIONS_JSON_ENV, } from "./child-route-env.js";
+export * from "./child-route-env.js";
+import { isUnknownArray, isRecord as isObject } from "../../shared/unknown.js";
+import { nonempty } from "./child-presence.js";
 import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
-import { prepareChildExecutionCwd } from "./child-execution-cwd.js";
+import { piSessionLaunch } from "./pi-session-launch.js";
 import { loadConfig } from "../../extension/config.js";
 // Managed macOS environments can SIGKILL Node when one argv entry reaches ~930 UTF-8 bytes.
 // Measure the full entry (including the `Task: ` prefix), not just the task body.
 const TASK_ARG_LIMIT_BYTES = 900;
 // Resolve sibling extensions in both layouts: TypeScript sources (tests, jiti) and compiled dist output.
 const MODULE_EXTENSION = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
-const SESSION_CWD_PRELOAD_URL = new URL(`session-cwd-preload${MODULE_EXTENSION}`, import.meta.url).href;
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), `subagent-prompt-runtime${MODULE_EXTENSION}`);
 const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "extension", `fanout-child${MODULE_EXTENSION}`);
-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_EAGER_TOOL_ENV = "PI_SUBAGENT_EAGER_TOOL";
-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_INHERITED_EXTENSIONS_JSON_ENV = "PI_SUBAGENT_INHERITED_EXTENSIONS_JSON";
 export function applyThinkingSuffix(model, thinking) {
-    if (!model || !thinking)
+    if (!nonempty(model) || !nonempty(thinking)) {
         return model;
-    if (splitKnownThinkingSuffix(model).thinkingSuffix)
+    }
+    if (nonempty(splitKnownThinkingSuffix(model).thinkingSuffix)) {
         return model;
+    }
     return `${model}:${thinking}`;
 }
 export function normalizeChildProjectTrustPolicy(input) {
-    if (input === "approve" || input === "no-approve" || input === "inherit")
+    if (input === "approve" || input === "no-approve" || input === "inherit") {
         return input;
-    if (typeof input === "object" && input !== null && "childRuns" in input) {
+    }
+    if (isObject(input) && "childRuns" in input) {
         return normalizeChildProjectTrustPolicy(input.childRuns);
     }
     return input === undefined ? "inherit" : "no-approve";
 }
 export function resolveConfiguredChildProjectTrustPolicy(input, argv = process.argv) {
     const inherited = findInheritedProjectTrustFlag(argv);
-    const explicitInherit = input === "inherit" || (typeof input === "object" && input !== null && input.childRuns === "inherit");
-    if (explicitInherit)
+    const configured = isObject(input) ? input.childRuns : input;
+    const explicitInherit = configured === "inherit";
+    if (explicitInherit) {
         return inherited ?? "inherit";
-    if (inherited === "no-approve")
+    }
+    if (inherited === "no-approve") {
         return "no-approve";
-    if (input === undefined || (typeof input === "object" && input !== null && !("childRuns" in input)))
+    }
+    if (input === undefined || (isObject(input) && !("childRuns" in input))) {
         return "approve";
+    }
     const normalized = normalizeChildProjectTrustPolicy(input);
     return normalized === "inherit" ? "approve" : normalized;
 }
 function findInheritedProjectTrustFlag(argv) {
     let inherited;
     for (const arg of argv) {
-        if (arg === "--approve" || arg === "-a")
+        if (arg === "--approve" || arg === "-a") {
             inherited = "approve";
-        if (arg === "--no-approve" || arg === "-na")
+        }
+        if (arg === "--no-approve" || arg === "-na") {
             inherited = "no-approve";
+        }
     }
     return inherited;
 }
 export function resolveChildProjectTrustArgs(policy = "inherit", argv = process.argv) {
     const inherited = findInheritedProjectTrustFlag(argv);
-    if (policy === "approve")
+    if (policy === "approve") {
         return inherited === "no-approve" ? ["--no-approve"] : ["--approve"];
-    if (policy === "no-approve")
+    }
+    if (policy === "no-approve") {
         return ["--no-approve"];
-    return inherited === "approve" ? ["--approve"] : inherited === "no-approve" ? ["--no-approve"] : [];
+    }
+    if (inherited === undefined) {
+        return [];
+    }
+    return [`--${inherited}`];
 }
 function inheritedRuntimeExtensionPaths(env = process.env) {
     const raw = env[SUBAGENT_INHERITED_EXTENSIONS_JSON_ENV]?.trim();
-    if (!raw)
+    if (!nonempty(raw)) {
         return [];
+    }
     try {
         const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
+        if (!isUnknownArray(parsed)) {
             return [];
+        }
         return parsed.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
     }
     catch {
         return [];
     }
 }
-// Read only through the header, not the potentially large transcript. Decode after
-// joining chunks so a UTF-8 character split across reads is preserved.
-function readSessionHeaderLine(file) {
-    let fd;
-    try {
-        fd = fs.openSync(file, "r");
-    }
-    catch (error) {
-        if (error.code === "ENOENT" && !fs.lstatSync(file, { throwIfNoEntry: false }))
-            return undefined;
-        throw error;
-    }
-    try {
-        const chunks = [];
-        const buffer = Buffer.alloc(4096);
-        while (true) {
-            const length = fs.readSync(fd, buffer, 0, buffer.length, null);
-            if (!length)
-                break;
-            const chunk = buffer.subarray(0, length);
-            const newline = chunk.indexOf(10);
-            chunks.push(Buffer.from(newline < 0 ? chunk : chunk.subarray(0, newline)));
-            if (newline >= 0)
-                break;
-        }
-        return Buffer.concat(chunks).toString("utf8");
-    }
-    finally {
-        fs.closeSync(fd);
-    }
+function isExtensionTool(tool) {
+    return tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js");
 }
-export function buildPiArgs(input) {
-    const args = [...input.baseArgs];
-    const env = {};
-    args.push(...resolveChildProjectTrustArgs(input.projectTrust));
-    if (input.sessionFile) {
-        prepareChildExecutionCwd(input.sessionFile, input.cwd);
-        fs.mkdirSync(path.dirname(input.sessionFile), { recursive: true });
-        args.push("--session", input.sessionFile);
-        if (input.cwd) {
-            let needsOverride = true;
-            try {
-                const line = readSessionHeaderLine(input.sessionFile);
-                if (line === undefined) {
-                    // Preassigned new sessions (including acceptance) inherit the actual spawn cwd.
-                    needsOverride = false;
-                }
-                else {
-                    const header = JSON.parse(line);
-                    if (header && typeof header === "object" && "type" in header && header.type === "session"
-                        && "cwd" in header && typeof header.cwd === "string" && path.isAbsolute(header.cwd)) {
-                        needsOverride = fs.realpathSync.native(header.cwd) !== fs.realpathSync.native(input.cwd);
-                    }
-                }
-            }
-            catch { /* Unknown headers or unavailable directories still need the native override. */ }
-            // Pi's SDK supports cwdOverride; its CLI has no --session-cwd flag.
-            // Keep normal resumes untouched and supply only a needed override before startup.
-            if (needsOverride) {
-                env.PI_SUBAGENT_SESSION_CWD = JSON.stringify({
-                    sessionFile: path.resolve(input.cwd, input.sessionFile), cwd: input.cwd, nodeOptions: process.env.NODE_OPTIONS,
-                });
-                env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ""} --import=${SESSION_CWD_PRELOAD_URL}`.trim();
-            }
-        }
+function builtinLoadout(input, declared, fanoutAuthorized, compact) {
+    const builtin = [...declared];
+    if (builtin.length === 0) {
+        return builtin;
     }
-    else {
-        if (!input.sessionEnabled) {
-            args.push("--no-session");
-        }
-        if (input.sessionDir) {
-            fs.mkdirSync(input.sessionDir, { recursive: true });
-            args.push("--session-dir", input.sessionDir);
-        }
+    if (fanoutAuthorized) {
+        const additions = compact
+            ? ["subagent", "delegate", "agent_runs", "load_subagent"]
+            : ["subagent"];
+        builtin.push(...additions.filter((tool) => !builtin.includes(tool)));
     }
-    const modelArg = applyThinkingSuffix(input.model, input.thinking);
-    if (modelArg) {
-        args.push("--model", modelArg);
+    if (input.structuredOutput && !builtin.includes("structured_output")) {
+        builtin.push("structured_output");
     }
-    const declaredBuiltinTools = input.tools?.filter((tool) => !(tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js"))) ?? [];
-    const fanoutAuthorized = input.allowSubagents === true || declaredBuiltinTools.includes("subagent");
-    const compactChildTools = fanoutAuthorized && loadConfig().compactChildTools !== false;
-    // Preserve an explicit advanced-tool policy, but never inherit it into another profile.
-    env[SUBAGENT_EAGER_TOOL_ENV] = declaredBuiltinTools.includes("subagent") ? "1" : undefined;
-    const toolExtensionPaths = [];
-    if (input.tools?.length) {
-        const builtinTools = [...declaredBuiltinTools];
-        if (fanoutAuthorized && declaredBuiltinTools.length > 0) {
-            for (const tool of compactChildTools ? ["subagent", "delegate", "agent_runs", "load_subagent"] : ["subagent"]) {
-                if (!builtinTools.includes(tool))
-                    builtinTools.push(tool);
-            }
-        }
-        if (input.structuredOutput && builtinTools.length > 0 && !builtinTools.includes("structured_output"))
-            builtinTools.push("structured_output");
-        for (const tool of input.tools) {
-            if (!declaredBuiltinTools.includes(tool) && (tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js"))) {
-                toolExtensionPaths.push(tool);
-            }
-        }
-        if (builtinTools.length > 0) {
-            if (input.mcpDirectTools?.length) {
-                builtinTools.push(...resolveMcpDirectToolNames(input.mcpDirectTools, input.cwd));
-            }
-            args.push("--tools", builtinTools.join(","));
-        }
+    if (input.mcpDirectTools !== undefined && input.mcpDirectTools.length > 0) {
+        builtin.push(...resolveMcpDirectToolNames(input.mcpDirectTools, input.cwd));
     }
+    return builtin;
+}
+function buildToolLoadout(input) {
+    const declared = input.tools?.filter((tool) => !isExtensionTool(tool)) ?? [];
+    const fanoutAuthorized = input.allowSubagents === true || declared.includes("subagent");
+    const compact = fanoutAuthorized && loadConfig().compactChildTools !== false;
+    const tools = builtinLoadout(input, declared, fanoutAuthorized, compact);
+    return {
+        args: tools.length > 0 ? ["--tools", tools.join(",")] : [],
+        toolExtensionPaths: input.tools?.filter(isExtensionTool) ?? [],
+        fanoutAuthorized,
+        // Preserve explicit advanced tools, never inherit them into another profile.
+        eager: declared.includes("subagent"),
+    };
+}
+function buildExtensionArgs(input, fanoutAuthorized, toolExtensionPaths) {
+    const args = [];
     const runtimeExtensions = fanoutAuthorized
-        ? [PROMPT_RUNTIME_EXTENSION_PATH, FANOUT_CHILD_EXTENSION_PATH, ...inheritedRuntimeExtensionPaths()]
+        ? [
+            PROMPT_RUNTIME_EXTENSION_PATH,
+            FANOUT_CHILD_EXTENSION_PATH,
+            ...inheritedRuntimeExtensionPaths(),
+        ]
         : [PROMPT_RUNTIME_EXTENSION_PATH, ...inheritedRuntimeExtensionPaths()];
     if (input.extensions !== undefined) {
         args.push("--no-extensions");
-        for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths, ...input.extensions])]) {
+        for (const extPath of new Set([
+            ...runtimeExtensions,
+            ...toolExtensionPaths,
+            ...input.extensions,
+        ])) {
             args.push("--extension", extPath);
         }
     }
     else {
-        for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths])]) {
+        for (const extPath of new Set([...runtimeExtensions, ...toolExtensionPaths])) {
             args.push("--extension", extPath);
         }
     }
+    return args;
+}
+function buildPromptArgs(input) {
+    const args = [];
     if (!input.inheritSkills) {
         args.push("--no-skills");
     }
@@ -227,7 +170,7 @@ export function buildPiArgs(input) {
     }
     const taskArg = `Task: ${input.task}`;
     if (Buffer.byteLength(taskArg) > TASK_ARG_LIMIT_BYTES) {
-        if (!tempDir) {
+        if (!nonempty(tempDir)) {
             tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
         }
         const taskFilePath = path.join(tempDir, "task.md");
@@ -237,70 +180,34 @@ export function buildPiArgs(input) {
     else {
         args.push(taskArg);
     }
-    env[SUBAGENT_CHILD_ENV] = "1";
-    env.PI_SUBAGENT_ROOT_SESSION_ID = input.rootSessionId ?? (process.env[SUBAGENT_CHILD_ENV] === "1" ? process.env.PI_SUBAGENT_ROOT_SESSION_ID : undefined);
-    env[SUBAGENT_FANOUT_CHILD_ENV] = fanoutAuthorized ? "1" : "0";
-    const inheritedNestedRoute = Boolean(process.env[SUBAGENT_PARENT_EVENT_SINK_ENV] && process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] && process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]);
-    const parentRunId = input.parentRunId ?? input.runId ?? (inheritedNestedRoute ? process.env[SUBAGENT_RUN_ID_ENV] : undefined) ?? process.env[SUBAGENT_PARENT_RUN_ID_ENV] ?? "";
-    const parentChildIndex = input.parentChildIndex !== undefined
-        ? String(input.parentChildIndex)
-        : input.childIndex !== undefined
-            ? String(input.childIndex)
-            : process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV] ?? "";
-    const inheritedDepth = Number(process.env[SUBAGENT_PARENT_DEPTH_ENV]);
-    const parentDepth = input.parentDepth ?? (inheritedNestedRoute && Number.isFinite(inheritedDepth) ? inheritedDepth + 1 : 1);
-    const parentPath = input.parentPath ?? [
-        ...parseNestedPathEnv(process.env[SUBAGENT_PARENT_PATH_ENV]),
-        ...(parentRunId ? [{
-                runId: parentRunId,
-                ...(parentChildIndex && /^\d+$/.test(parentChildIndex) ? { stepIndex: Number(parentChildIndex) } : {}),
-                ...(input.childAgentName ? { agent: input.childAgentName } : {}),
-            }] : []),
-    ];
-    env[SUBAGENT_PARENT_EVENT_SINK_ENV] = fanoutAuthorized
-        ? input.parentEventSink ?? process.env[SUBAGENT_PARENT_EVENT_SINK_ENV] ?? ""
-        : "";
-    env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] = fanoutAuthorized
-        ? input.parentControlInbox ?? process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] ?? ""
-        : "";
-    env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] = fanoutAuthorized
-        ? input.parentRootRunId ?? process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] ?? input.runId ?? ""
-        : "";
-    env[SUBAGENT_PARENT_RUN_ID_ENV] = fanoutAuthorized ? parentRunId : "";
-    env[SUBAGENT_PARENT_CHILD_INDEX_ENV] = fanoutAuthorized ? parentChildIndex : "";
-    env[SUBAGENT_PARENT_DEPTH_ENV] = fanoutAuthorized ? String(parentDepth) : "";
-    env[SUBAGENT_PARENT_PATH_ENV] = fanoutAuthorized ? encodeNestedPathEnv(parentPath) : "";
-    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";
-    if (input.intercomSessionName) {
-        env.PI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName;
-    }
-    if (input.orchestratorIntercomTarget) {
-        env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = input.orchestratorIntercomTarget;
-    }
-    if (input.runId) {
-        env[SUBAGENT_RUN_ID_ENV] = input.runId;
-    }
-    if (input.childAgentName) {
-        env[SUBAGENT_CHILD_AGENT_ENV] = input.childAgentName;
-    }
-    if (input.childIndex !== undefined) {
-        env[SUBAGENT_CHILD_INDEX_ENV] = String(input.childIndex);
-    }
-    if (input.mcpDirectTools?.length) {
-        env.MCP_DIRECT_TOOLS = input.mcpDirectTools.join(",");
+    return { args, tempDir };
+}
+export function buildPiArgs(input) {
+    const args = [...input.baseArgs, ...resolveChildProjectTrustArgs(input.projectTrust)];
+    const session = piSessionLaunch(input);
+    args.push(...session.args);
+    const modelArg = applyThinkingSuffix(input.model, input.thinking);
+    if (nonempty(modelArg)) {
+        args.push("--model", modelArg);
     }
-    // A nested helper must never submit into its parent's capture.
-    env[STRUCTURED_OUTPUT_CAPTURE_ENV] = input.structuredOutput?.outputPath ?? "";
-    env[STRUCTURED_OUTPUT_SCHEMA_ENV] = input.structuredOutput?.schemaPath ?? "";
-    return { args, env, tempDir };
+    const tools = buildToolLoadout(input);
+    args.push(...tools.args, ...buildExtensionArgs(input, tools.fanoutAuthorized, tools.toolExtensionPaths));
+    const prompt = buildPromptArgs(input);
+    args.push(...prompt.args);
+    return {
+        args,
+        env: {
+            ...session.env,
+            [SUBAGENT_EAGER_TOOL_ENV]: tools.eager ? "1" : undefined,
+            ...childRouteEnv(input, tools.fanoutAuthorized),
+        },
+        tempDir: prompt.tempDir,
+    };
 }
 export function cleanupTempDir(tempDir) {
-    if (!tempDir)
+    if (!nonempty(tempDir)) {
         return;
+    }
     try {
         fs.rmSync(tempDir, { recursive: true, force: true });
     }

package/dist/runs/shared/pi-launch-input.js

@@ -0,0 +1 @@
+export {};

package/dist/runs/shared/pi-session-launch.js

@@ -0,0 +1,86 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { prepareChildExecutionCwd } from "./child-execution-cwd.js";
+import { hasErrorCode, isRecord as isObject } from "../../shared/unknown.js";
+import { nonempty } from "./child-presence.js";
+const SESSION_CWD_PRELOAD_URL = new URL(`session-cwd-preload${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url).href;
+// Read only the header; joining chunks before decoding preserves split UTF-8.
+function readSessionHeaderLine(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT") && !fs.lstatSync(file, { throwIfNoEntry: false })) {
+            return;
+        }
+        throw error;
+    }
+    try {
+        const chunks = [];
+        const buffer = Buffer.alloc(4096);
+        while (true) {
+            const length = fs.readSync(fd, buffer, 0, buffer.length, null);
+            if (length === 0) {
+                break;
+            }
+            const chunk = buffer.subarray(0, length);
+            const newline = chunk.indexOf(10);
+            chunks.push(Buffer.from(newline < 0 ? chunk : chunk.subarray(0, newline)));
+            if (newline >= 0) {
+                break;
+            }
+        }
+        return Buffer.concat(chunks).toString("utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function needsCwdOverride(file, cwd) {
+    try {
+        const line = readSessionHeaderLine(file);
+        if (line === undefined) {
+            return false; // A new session inherits the spawn cwd natively.
+        }
+        const header = JSON.parse(line);
+        if (isObject(header) &&
+            header.type === "session" &&
+            typeof header.cwd === "string" &&
+            path.isAbsolute(header.cwd)) {
+            return fs.realpathSync.native(header.cwd) !== fs.realpathSync.native(cwd);
+        }
+    }
+    catch {
+        // Unknown headers or unavailable directories still need the SDK override.
+    }
+    return true;
+}
+/** Prepare persistence before spawn without modifying an existing session header or identity. */
+export function piSessionLaunch(input) {
+    const args = [];
+    const env = {};
+    if (!nonempty(input.sessionFile)) {
+        if (!input.sessionEnabled) {
+            args.push("--no-session");
+        }
+        if (nonempty(input.sessionDir)) {
+            fs.mkdirSync(input.sessionDir, { recursive: true });
+            args.push("--session-dir", input.sessionDir);
+        }
+        return { args, env };
+    }
+    prepareChildExecutionCwd(input.sessionFile, input.cwd);
+    fs.mkdirSync(path.dirname(input.sessionFile), { recursive: true });
+    args.push("--session", input.sessionFile);
+    if (nonempty(input.cwd) && needsCwdOverride(input.sessionFile, input.cwd)) {
+        env.PI_SUBAGENT_SESSION_CWD = JSON.stringify({
+            sessionFile: path.resolve(input.cwd, input.sessionFile),
+            cwd: input.cwd,
+            nodeOptions: process.env.NODE_OPTIONS,
+        });
+        env.NODE_OPTIONS =
+            `${process.env.NODE_OPTIONS ?? ""} --import=${SESSION_CWD_PRELOAD_URL}`.trim();
+    }
+    return { args, env };
+}

package/dist/runs/shared/pi-spawn.js

@@ -2,51 +2,65 @@ 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";
+function isPiPackage(file) {
+    if (!fs.existsSync(file)) {
+        return false;
+    }
+    const pkg = JSON.parse(fs.readFileSync(file, "utf-8"));
+    return (typeof pkg === "object" && pkg !== null && "name" in pkg && pkg.name === PI_CODING_AGENT_PACKAGE);
+}
 export function findPiPackageRootFromEntry(entryPoint) {
     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"));
-            if (pkg.name === PI_CODING_AGENT_PACKAGE)
-                return dir;
+        if (isPiPackage(path.join(dir, "package.json"))) {
+            return dir;
         }
         dir = path.dirname(dir);
     }
-    return undefined;
+    return;
+}
+function findPathPiPackage() {
+    for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+        try {
+            const root = findPiPackageRootFromEntry(fs.realpathSync(path.join(dir, "pi")));
+            if (root !== undefined) {
+                return root;
+            }
+        }
+        catch {
+            // PATH entries can disappear or be wrappers rather than Pi.
+        }
+    }
+    return;
 }
 export function resolveInstalledPiPackageRoot() {
     try {
         return findPiPackageRootFromEntry(fileURLToPath(import.meta.resolve(PI_CODING_AGENT_PACKAGE)));
     }
     catch {
-        for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
-            try {
-                const root = findPiPackageRootFromEntry(fs.realpathSync(path.join(dir, "pi")));
-                if (root)
-                    return root;
-            }
-            catch { /* PATH entries can disappear or be wrappers rather than Pi. */ }
-        }
-        return undefined;
+        return findPathPiPackage();
     }
 }
 export function resolvePiPackageRoot() {
     try {
-        const entry = process.argv[1];
-        return entry ? findPiPackageRootFromEntry(fs.realpathSync(entry)) : undefined;
+        const entry = process.argv.at(1);
+        return entry !== undefined ? findPiPackageRootFromEntry(fs.realpathSync(entry)) : undefined;
     }
     catch {
         // process.argv[1] probing is best-effort; callers can fall back to PATH/package resolution.
-        return undefined;
+        return;
     }
 }
 export function requirePiPackageRoot() {
-    const root = process.env.PI_PACKAGE_DIR || resolvePiPackageRoot() || resolveInstalledPiPackageRoot();
-    if (!root)
+    const configured = process.env.PI_PACKAGE_DIR;
+    const root = configured !== undefined && configured.length > 0
+        ? configured
+        : (resolvePiPackageRoot() ?? resolveInstalledPiPackageRoot());
+    if (root === undefined) {
         throw new Error("Could not locate Pi runtime APIs; Pi must be installed and available on PATH.");
+    }
     return root;
 }
 export function getPiSpawnCommand(args) {
-    return { command: "pi", args };
+    return { command: "pi", args: [...args] };
 }