@hheei/pi-subagents 0.1.2 → 0.2.3

package/dist/host-adapter.js

@@ -1,6 +1,4 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
+import { errorMessage, runCommand, shellQuote } from "@hheei/pi-ext-core";
 const DEFAULT_HOST_ORDER = ["herdr", "cmux"];
 /** Selects a presentation host visibly; an explicit unavailable host never falls back. */
 export async function selectHostAdapter(options) {
@@ -20,11 +18,9 @@ export async function selectHostAdapter(options) {
                 available: true,
                 selectedHost: host,
                 adapter,
-                explicit,
                 reason: priorFailures === ""
                     ? `${explicit ? "explicit" : "default"} host ${host} is available`
                     : `selected ${host} after ${priorFailures}`,
-                attempts,
             };
         }
     }
@@ -32,36 +28,38 @@ export async function selectHostAdapter(options) {
     return {
         available: false,
         selectedHost: null,
-        explicit,
         reason: explicit
             ? `explicit host unavailable: ${failure}`
             : `no presentation host available: ${failure}`,
-        attempts,
     };
 }
-export class HostCommandError extends Error {
-    kind;
-    result;
-    constructor(kind, message, result) {
-        super(message);
-        this.name = "HostCommandError";
-        this.kind = kind;
-        this.result = result;
-    }
+const HOST_COMMAND_MAX_STDOUT_BYTES = 1024 * 1024;
+function errnoCode(error) {
+    // Node's spawn errors are plain Errors carrying a `code` string; narrowing here
+    // keeps the ENOENT decision below honest about the caught value being unknown.
+    const code = error.code;
+    return typeof code === "string" ? code : undefined;
 }
 export const systemHostCommandRunner = {
     async run(command, args, options = {}) {
         try {
-            const result = await execFileAsync(command, [...args], {
-                timeout: options.timeoutMs,
-                maxBuffer: 1024 * 1024,
-                windowsHide: true,
+            const result = await runCommand(command, [...args], {
+                ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                maxStdoutBytes: HOST_COMMAND_MAX_STDOUT_BYTES,
             });
-            return { stdout: result.stdout, stderr: result.stderr, exitCode: 0, timedOut: false };
+            return {
+                stdout: result.stdout.toString("utf8"),
+                stderr: result.stdoutTruncated
+                    ? `output exceeded ${HOST_COMMAND_MAX_STDOUT_BYTES} bytes`
+                    : result.stderr.toString("utf8"),
+                // A command killed by a signal reports no exit code; the kill still counts as
+                // a failure through `timedOut` or `hostCleanupFailed`.
+                exitCode: result.signal === null ? result.code : null,
+                timedOut: result.timedOut,
+            };
         }
         catch (error) {
-            const value = error;
-            if (value.code === "ENOENT") {
+            if (errnoCode(error) === "ENOENT") {
                 return {
                     stdout: "",
                     stderr: `command not found: ${command}`,
@@ -70,10 +68,10 @@ export const systemHostCommandRunner = {
                 };
             }
             return {
-                stdout: value.stdout ?? "",
-                stderr: value.stderr ?? value.message ?? String(error),
-                exitCode: typeof value.code === "number" ? value.code : null,
-                timedOut: value.killed === true,
+                stdout: "",
+                stderr: errorMessage(error),
+                exitCode: null,
+                timedOut: false,
             };
         }
     },
@@ -106,27 +104,47 @@ export function createHerdrHostAdapter(options) {
                 ? { host: "herdr", available: false, reason: "herdr probe returned no current pane id" }
                 : { host: "herdr", available: true, reason: `current pane ${pane}` };
         },
-        async attach(spec) {
-            const current = await runner.run("herdr", ["pane", "current", "--current"], { timeoutMs });
-            const parentPane = parseHerdrPaneId(current.stdout);
-            if (parentPane === undefined) {
-                throw new HostCommandError("pane", "herdr current pane unavailable", current);
-            }
-            const split = await runner.run("herdr", herdrSplitArgs(parentPane, spec), { timeoutMs });
-            const childPane = parseHerdrPaneId(split.stdout);
-            if (childPane === undefined) {
-                throw new HostCommandError("pane", "herdr split returned no child pane id", split);
+        async open(spec) {
+            // A dedicated tab, not a split of the parent pane: the child TUI owns its own tab, the
+            // parent session keeps its layout and focus, and the tab is labeled with the child id so
+            // a human can tell whose panel it is.
+            const workspaceId = await resolveHerdrProcessWorkspaceId(runner, timeoutMs, options.env ?? process.env);
+            const created = await runner.run("herdr", herdrTabCreateArgs(spec, workspaceId), {
+                timeoutMs,
+            });
+            const target = parseHerdrTab(created.stdout);
+            if (target === undefined) {
+                throw new Error("herdr tab create returned no tab and root pane id");
             }
-            // pane run sends text+Enter to the new shell. Timeout is not rollback: the pane
+            // pane run sends text+Enter to the tab's root shell. Timeout is not rollback: the tab
             // already exists and the process may still start after the CLI deadline.
-            const launch = await runner.run("herdr", ["pane", "run", childPane, quotedArgv(spec.command, spec.argv)], { timeoutMs });
+            const launch = await runner.run("herdr", ["pane", "run", target.paneId, quotedArgv(spec.command, spec.argv)], { timeoutMs });
             return hostAttachment({
-                identity: { host: "herdr", attachmentId: childPane, createdBy: options.ownerId },
+                identity: { host: "herdr", attachmentId: target.tabId, createdBy: options.ownerId },
                 launch,
-                noun: "pane",
-                observe: () => runner.run("herdr", ["pane", "process-info", "--pane", childPane], { timeoutMs }),
-                isAlive: (result) => result.exitCode === 0 && herdrChildProcessIsRunning(result.stdout),
-                close: () => runner.run("herdr", ["pane", "close", childPane], { timeoutMs }),
+                noun: "tab",
+                reportsFocus: true,
+                observe: async () => {
+                    // Aliveness is the pane's foreground process; focus is a fact about the tab *and*
+                    // its workspace, so both listings are read together with it.
+                    const [process, tabs, workspaces] = await Promise.all([
+                        runner.run("herdr", ["pane", "process-info", "--pane", target.paneId], { timeoutMs }),
+                        runner.run("herdr", ["tab", "list"], { timeoutMs }),
+                        runner.run("herdr", ["workspace", "list"], { timeoutMs }),
+                    ]);
+                    // A listing that did not answer says nothing about focus: reading it anyway turns a
+                    // failed command into "unfocused", and the caller closes a panel on that answer.
+                    const listed = herdrListingSucceeded(tabs) && herdrListingSucceeded(workspaces)
+                        ? herdrPanelFocused(tabs.stdout, workspaces.stdout, target.tabId)
+                        : undefined;
+                    const alive = herdrPaneAlive(process);
+                    return {
+                        process,
+                        ...(alive === undefined ? {} : { alive }),
+                        ...(listed === undefined ? {} : { focused: listed }),
+                    };
+                },
+                close: () => runner.run("herdr", ["tab", "close", target.tabId], { timeoutMs }),
                 ownsAttachment: options.ownsAttachment,
             });
         },
@@ -150,18 +168,26 @@ export function createCmuxHostAdapter(options) {
             }
             return { host: "cmux", available: true, reason: "cmux responded and exposed capabilities" };
         },
-        async attach(spec) {
-            const launch = await runner.run("cmux", ["--json", "new-split", "right", "--command", cmuxLaunchCommand(spec)], { timeoutMs });
+        async open(spec) {
+            const launch = await runner.run("cmux", ["--json", "new-surface", "--command", cmuxLaunchCommand(spec)], { timeoutMs });
             const attachmentId = parseCmuxSurfaceId(launch.stdout);
             if (attachmentId === undefined) {
-                throw new HostCommandError("pane", "cmux split returned no surface id; process state is unknown", launch);
+                throw new Error("cmux new-surface returned no surface id; process state is unknown");
             }
             return hostAttachment({
                 identity: { host: "cmux", attachmentId, createdBy: options.ownerId },
                 launch,
                 noun: "surface",
-                observe: () => runner.run("cmux", ["--json", "list-panels"], { timeoutMs }),
-                isAlive: (result) => result.exitCode === 0 && containsString(result.stdout, attachmentId),
+                // TODO(cmux-focus): cmux does not report which surface a human is looking at, so
+                // observation cannot answer `focused` and idle reclaim fails open here: a cmux child
+                // is only ever closed by stop_agent.
+                reportsFocus: false,
+                observe: async () => {
+                    const process = await runner.run("cmux", ["--json", "list-panels"], { timeoutMs });
+                    if (process.timedOut || process.exitCode !== 0)
+                        return { process };
+                    return { process, alive: containsString(process.stdout, attachmentId) };
+                },
                 close: () => runner.run("cmux", ["--json", "close-surface", "--surface", attachmentId], {
                     timeoutMs,
                 }),
@@ -173,16 +199,21 @@ export function createCmuxHostAdapter(options) {
 function hostAttachment(options) {
     const observe = async () => {
         const result = await options.observe();
+        const focused = options.reportsFocus ? result.focused : undefined;
         return {
             identity: options.identity,
-            alive: !result.timedOut && options.isAlive(result),
-            known: !result.timedOut,
-            detail: result.stderr || result.stdout,
+            // A host that could not answer is not reporting a dead child: `alive: false` is what lets
+            // the caller drop the panel and the runtime evidence, so it is only ever said on purpose.
+            alive: result.alive === true,
+            known: result.alive !== undefined,
+            ...(focused === undefined ? {} : { focused }),
+            detail: result.process.stderr || result.process.stdout,
         };
     };
     return {
         identity: options.identity,
         launch: options.launch,
+        reportsFocus: options.reportsFocus,
         observe,
         async cleanup() {
             if (!options.ownsAttachment(options.identity)) {
@@ -199,29 +230,124 @@ function hostAttachment(options) {
         },
     };
 }
-function herdrSplitArgs(parentPane, spec) {
+/**
+ * Herdr tab creation carries cwd, env, label, and explicit workspace id matching the parent
+ * process, ensuring the child tab spawns in the process's own workspace rather than whatever
+ * workspace happens to have user focus.
+ */
+export function herdrTabCreateArgs(spec, workspaceId) {
     const args = [
-        "pane",
-        "split",
-        "--pane",
-        parentPane,
-        "--direction",
-        "right",
+        "tab",
+        "create",
         "--cwd",
         spec.cwd,
+        "--label",
+        spec.config.subagentId,
         "--no-focus",
     ];
+    if (workspaceId !== undefined && workspaceId !== "") {
+        args.push("--workspace", workspaceId);
+    }
     for (const [key, value] of Object.entries(spec.env)) {
         args.push("--env", `${key}=${value}`);
     }
     return args;
 }
+export function parseHerdrWorkspaceId(output) {
+    return parseJsonId(output, ["workspace_id", "workspaceId"]);
+}
+/**
+ * Resolves the workspace id of the current process so new tabs open in the same workspace.
+ * Reads environment variables first, falling back to herdr pane queries.
+ */
+export async function resolveHerdrProcessWorkspaceId(runner, timeoutMs, env = process.env) {
+    const envWorkspace = env.HERDR_WORKSPACE_ID?.trim();
+    if (envWorkspace)
+        return envWorkspace;
+    const envPane = env.HERDR_PANE_ID?.trim();
+    if (envPane) {
+        const res = await runner.run("herdr", ["pane", "get", envPane], { timeoutMs });
+        if (res.exitCode === 0) {
+            const ws = parseHerdrWorkspaceId(res.stdout);
+            if (ws)
+                return ws;
+        }
+    }
+    const current = await runner.run("herdr", ["pane", "current", "--current"], { timeoutMs });
+    if (current.exitCode === 0) {
+        return parseHerdrWorkspaceId(current.stdout);
+    }
+    return undefined;
+}
+/**
+ * Focus is answered from two listings: `tab list` says whether the child's tab is focused and
+ * which workspace owns it, `workspace list` says whether that workspace is the rendered one. A
+ * child is being watched only when both are focused. Anything missing — a failed listing, an absent
+ * field, a tab that is not there — is unknown, never "unfocused", because the caller closes a panel
+ * on an unfocused answer.
+ */
+export function herdrPanelFocused(tabList, workspaceList, tabId) {
+    const tab = herdrListEntry(tabList, "tabs", "tab_id", tabId);
+    if (tab === undefined)
+        return undefined;
+    const tabFocused = tab.focused;
+    if (typeof tabFocused !== "boolean")
+        return undefined;
+    if (!tabFocused)
+        return false;
+    const workspaceId = tab.workspace_id;
+    if (typeof workspaceId !== "string" || workspaceId === "")
+        return undefined;
+    const workspace = herdrListEntry(workspaceList, "workspaces", "workspace_id", workspaceId);
+    const workspaceFocused = workspace?.focused;
+    return typeof workspaceFocused === "boolean" ? workspaceFocused : undefined;
+}
+function herdrListEntry(output, collection, key, id) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return undefined;
+    }
+    const list = findNamedObject(parsed, "result")?.[collection];
+    if (!Array.isArray(list))
+        return undefined;
+    for (const entry of list) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const record = entry;
+        if (record[key] === id)
+            return record;
+    }
+    return undefined;
+}
+/**
+ * `herdr tab create` answers with the tab and its root pane: the pane runs the LaunchSpec and is
+ * what observation watches, while the tab is what cleanup closes.
+ */
+function parseHerdrTab(output) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return undefined;
+    }
+    const tabId = findNamedObject(parsed, "tab")?.tab_id;
+    const paneId = findNamedObject(parsed, "root_pane")?.pane_id;
+    if (typeof tabId !== "string" || typeof paneId !== "string")
+        return undefined;
+    return { tabId, paneId };
+}
 /** Herdr `pane run` concatenates extra argv with spaces, so quoting happens here once. */
 function quotedArgv(command, argv) {
     return [command, ...argv].map(shellQuote).join(" ");
 }
 /**
- * cmux `new-split --command` is shell text. Encode cwd + env + argv without inventing Pi flags.
+ * cmux `new-surface --command` is shell text. Encode cwd + env + argv without inventing Pi flags.
+ * A surface is cmux's own name for a panel: attaching adds one to the current pane instead of
+ * splitting the parent's layout, and cleanup closes exactly that surface.
  */
 function cmuxLaunchCommand(spec) {
     const directory = `cd ${shellQuote(spec.cwd)}`;
@@ -232,9 +358,6 @@ function cmuxLaunchCommand(spec) {
         .filter((part) => part.length > 0)
         .join(" ");
 }
-function shellQuote(value) {
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
 function containsString(output, target) {
     try {
         return valueContainsString(JSON.parse(output), target);
@@ -284,6 +407,34 @@ function findString(value, keys, accept) {
     }
     return undefined;
 }
+/** A listing that failed or timed out is not evidence, whatever its stdout happens to contain. */
+function herdrListingSucceeded(result) {
+    return !result.timedOut && result.exitCode === 0;
+}
+/**
+ * Reads the pane's process state. A pane that no longer exists is a definite "not alive" — that is
+ * how a closed panel looks — while a query that never ran or failed for any other reason is
+ * unknown, because the caller closes the panel on "not alive".
+ */
+export function herdrPaneAlive(result) {
+    if (herdrListingSucceeded(result))
+        return herdrChildProcessIsRunning(result.stdout);
+    // The CLI writes the error as JSON on stderr.
+    const code = herdrErrorCode(result.stderr) ?? herdrErrorCode(result.stdout);
+    if (code === "pane_not_found" || code === "tab_not_found")
+        return false;
+    return undefined;
+}
+/** The error code of a herdr CLI failure, which reports it as JSON. */
+function herdrErrorCode(output) {
+    try {
+        const parsed = JSON.parse(output);
+        return typeof parsed.error?.code === "string" ? parsed.error.code : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function herdrChildProcessIsRunning(output) {
     try {
         const info = findNamedObject(JSON.parse(output), "process_info");

package/dist/json-lines.js

@@ -1,3 +1,4 @@
+import { errorMessage } from "@hheei/pi-ext-core";
 export class JsonLineError extends Error {
     code;
     constructor(code, message) {
@@ -47,7 +48,7 @@ export function attachJsonLineReader(stream, options) {
                 options.onValue(JSON.parse(frame.toString("utf8")));
             }
             catch (error) {
-                fail(new JsonLineError("malformed_json", `Malformed JSON line: ${error instanceof Error ? error.message : String(error)}`));
+                fail(new JsonLineError("malformed_json", `Malformed JSON line: ${errorMessage(error)}`));
             }
         }
     };

package/dist/launch-spec.d.ts

@@ -1,8 +1,8 @@
-import type { ChildBridgeEnvironment, EffectiveLaunchConfig, ExecutionMode, PersistenceState, PiInvocation } from "./domain.js";
+import type { ChildBridgeEnvironment, EffectiveLaunchConfig, PersistenceState, PiInvocation, Presentation } from "./domain.js";
 /**
- * The one description of how a child Pi process starts. RPC spawn, native TUI
- * attach, and replacement runtimes all build from this; only `mode` and `stdio`
- * differ, so no path can silently invent different Pi flags.
+ * The one description of how a child Pi process starts. A panel child and a background child are
+ * the same Pi invocation; only the presentation (and therefore stdio) differs, so no path can
+ * silently invent different Pi flags.
  */
 export interface LaunchSpec {
     /** Runtime binary (node/bun/compiled pi), spawned without a shell. */
@@ -10,16 +10,18 @@ export interface LaunchSpec {
     /** Full argv: host prefix args plus every Pi flag this child needs. */
     readonly argv: readonly string[];
     readonly cwd: string;
-    readonly mode: ExecutionMode;
+    readonly presentation: Presentation;
     readonly stdio: "pipe" | "inherit";
     /** Bridge variables to add to the child environment, excluding the controller token. */
     readonly env: Readonly<Record<string, string>>;
     readonly config: EffectiveLaunchConfig;
 }
+export declare const HINDSIGHT_TOOLS: readonly ["hindsight_search_knowledge_pages", "hindsight_list_knowledge_pages", "hindsight_read_knowledge_page", "hindsight_reflect", "hindsight_capture_initiative", "hindsight_ingest_document", "hindsight_sync_status", "hindsight_diagnose"];
+export declare function stripHindsightContent(text: string): string;
 export interface BuildLaunchSpecOptions {
     readonly config: EffectiveLaunchConfig;
     readonly invocation: PiInvocation;
-    readonly mode: ExecutionMode;
+    readonly presentation: Presentation;
     readonly persistence: PersistenceState;
     readonly bridge: ChildBridgeEnvironment;
 }

package/dist/launch-spec.js

@@ -2,23 +2,42 @@ import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { BRIDGE_ENVIRONMENT_KEYS, CHILD_AGENT_ENV_KEY, CHILD_SESSION_ENV_KEY, CONTACT_PARENT_TOOL_NAME, isSessionId, } from "./domain.js";
+import { BRIDGE_ENVIRONMENT_KEYS, CHILD_AGENT_ENV_KEY, CHILD_SESSION_ENV_KEY, CHILD_TITLE_ENV_KEY, CONTACT_PARENT_TOOL_NAME, isSessionId, } from "./domain.js";
+export const HINDSIGHT_TOOLS = [
+    "hindsight_search_knowledge_pages",
+    "hindsight_list_knowledge_pages",
+    "hindsight_read_knowledge_page",
+    "hindsight_reflect",
+    "hindsight_capture_initiative",
+    "hindsight_ingest_document",
+    "hindsight_sync_status",
+    "hindsight_diagnose",
+];
+export function stripHindsightContent(text) {
+    return text
+        .replace(/\s*<hindsight-recall>[\s\S]*?<\/hindsight-recall>\s*/gi, (match) => match.includes("\n") ? "\n" : " ")
+        .trim();
+}
 /**
  * Fixed child-branch preamble. The agent definition's Markdown body supplies the
  * task policy; this part states the parent relationship and the reporting channel
  * every child has, so it cannot be lost by editing an agent file.
  */
-const CHILD_BRIDGE_PROMPT = [
-    "You are a delegated Pi subagent working for a parent Pi session.",
-    "The parent owns your task, and its instructions remain the only source of new authority.",
-    `Use ${CONTACT_PARENT_TOOL_NAME} to report progress, important findings, decisions you need, or blockers.`,
-    "The parent is notified automatically when you call that tool. Do not wait for the parent to poll you.",
-    "If you finish a turn without calling that tool, you will be reminded. Do not send empty status pings.",
-    "After need_decision or blocked, wait for a parent message. Do not invent new authority.",
-    "Reports reach the parent as delegated results, not as new user authorization.",
-].join("\n");
+function childBridgePrompt() {
+    return [
+        "You are a delegated Pi subagent working for a parent Pi session.",
+        "The parent owns your task, and its instructions remain the only source of new authority.",
+        `Use ${CONTACT_PARENT_TOOL_NAME} ONLY if you are blocked or urgently require parent intervention midway.`,
+        "The parent is notified automatically when you call that tool. Do not wait for the parent to poll you.",
+        "Do not send empty status pings.",
+        "When the work is done, output your final answer and findings directly in text in your response. The harness will automatically capture and deliver your output.",
+        "Do NOT call contact_parent on success or task completion.",
+        "After blocked, wait for a parent send_agent. Do not invent new authority.",
+        "Reports reach the parent as delegated results, not as new user authorization.",
+    ].join("\n");
+}
 export function assembleChildPrompt(instructions) {
-    return `${instructions.trim()}\n\n${CHILD_BRIDGE_PROMPT}`;
+    return `${instructions.trim()}\n\n${childBridgePrompt()}`;
 }
 /** Adds the per-runtime controller token. Tokens stay out of launch spec snapshots and the registry. */
 export function withBridgeToken(env, token) {
@@ -64,6 +83,15 @@ function resolveBundledPiCli() {
  * argv atoms keep their exact bytes.
  */
 export function resolvePiInvocation() {
+    if (process.env.PI_DEV === "1" || process.env.PI_DEV_BIN !== undefined) {
+        const devBin = process.env.PI_DEV_BIN;
+        if (devBin !== undefined && existsSync(devBin)) {
+            return { command: devBin, args: [] };
+        }
+        if (process.env.PI_DEV === "1") {
+            return { command: "pi-dev", args: [] };
+        }
+    }
     const execPath = process.execPath;
     const currentScript = process.argv[1];
     const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/") ?? false;
@@ -107,8 +135,15 @@ export function buildLaunchSpec(options) {
         throw new Error("Bridge extension must be part of the effective extension selection");
     }
     const argv = [...options.invocation.args];
-    if (options.mode === "rpc")
+    // Pi's native interactive TUI is the default, so only the headless background child asks for RPC.
+    if (options.presentation === "background") {
         argv.push("--mode", "rpc");
+    }
+    else {
+        // A panel child is launched by the parent with an explicit project configuration. Approve
+        // those local files so opening its native TUI never stops for a trust prompt.
+        argv.push("--approve");
+    }
     if (sessionPath !== undefined)
         argv.push("--session", sessionPath);
     else
@@ -116,10 +151,14 @@ export function buildLaunchSpec(options) {
     argv.push("--session-dir", config.sessionDir);
     argv.push("--provider", config.model.provider, "--model", config.model.id);
     argv.push("--thinking", config.thinking.level);
-    if (config.tools.length > 0)
-        argv.push("--tools", config.tools.join(","));
-    if (config.excludeTools.length > 0)
-        argv.push("--exclude-tools", config.excludeTools.join(","));
+    const effectiveTools = config.codemodeOnly && !config.tools.includes("codemode")
+        ? [...config.tools, "codemode"]
+        : config.tools;
+    if (effectiveTools.length > 0)
+        argv.push("--tools", effectiveTools.join(","));
+    const excludeTools = Array.from(new Set([...config.excludeTools, ...HINDSIGHT_TOOLS]));
+    if (excludeTools.length > 0)
+        argv.push("--exclude-tools", excludeTools.join(","));
     if (!config.extensions.discovery)
         argv.push("--no-extensions");
     for (const path of config.extensions.paths)
@@ -136,13 +175,17 @@ export function buildLaunchSpec(options) {
         [BRIDGE_ENVIRONMENT_KEYS.endpoint]: options.bridge.endpoint,
         [CHILD_AGENT_ENV_KEY]: config.agent.displayName ?? config.agent.name,
         [CHILD_SESSION_ENV_KEY]: config.sessionId,
+        // Empty is the defined "derive the title in the child" case, mirroring the task channel below.
+        [CHILD_TITLE_ENV_KEY]: config.title ?? "",
+        PI_HINDSIGHT_DISABLE: "1",
+        ...(config.codemodeOnly ? { PI_CODEMODE_MODE: "only" } : {}),
     };
     return Object.freeze({
         command: options.invocation.command,
         argv: Object.freeze(argv),
         cwd: config.cwd,
-        mode: options.mode,
-        stdio: options.mode === "rpc" ? "pipe" : "inherit",
+        presentation: options.presentation,
+        stdio: options.presentation === "background" ? "pipe" : "inherit",
         env: Object.freeze(env),
         config,
     });