pi-subagents 0.82.1 → 0.83.0

package/src/runs/background/run-child-session.js

@@ -69,6 +69,8 @@ export function runChildSession(input) {
         let queuedDrainHold = false;
         let compactionStartedReceived = false;
         let afterCompactionSettlement = false;
+        let terminalAgentEndReceived = false;
+        let compactionAfterFinalOpen = false;
         let finalDrainTimer;
         let finalHardFinishTimer;
         let watchdogTailTimer;
@@ -216,7 +218,8 @@ export function runChildSession(input) {
             finalDrainTimer = setTimeout(() => {
                 if (settled || promptSettled)
                     return;
-                if (input.launch.capture.finalDrainHeld() || observeQueuedDrainHold()) {
+                // Pi runs auto-compaction after the final agent_end and only then emits agent_settled.
+                if (input.launch.capture.finalDrainHeld() || observeQueuedDrainHold() || compactionAfterFinalOpen) {
                     finalDrainTimer = undefined;
                     armFinalDrainTimer();
                     return;
@@ -231,16 +234,22 @@ export function runChildSession(input) {
                         return;
                     settle(undefined, true);
                 }, HARD_FINISH_MS);
-                finalHardFinishTimer.unref?.();
             }, FINAL_STOP_GRACE_MS);
-            finalDrainTimer.unref?.();
         }
-        const applyChildLifecycle = (action) => {
+        const applyChildLifecycle = (action, event) => {
             if (action === "cancel-drain") {
-                cleanTerminalAssistantStopReceived = false;
+                // After a clean final stop, a non-retrying agent_end may be the child's last event
+                // (Pi may not emit agent_settled), so it re-arms the drain instead of cancelling it.
+                terminalAgentEndReceived = event?.type === "agent_end" && event.willRetry !== true && cleanTerminalAssistantStopReceived;
                 agentSettledReceived = false;
                 clearFinalDrainTimers();
                 clearWatchdogTailTimer();
+                if (terminalAgentEndReceived) {
+                    startFinalDrain();
+                    return;
+                }
+                cleanTerminalAssistantStopReceived = false;
+                compactionAfterFinalOpen = false;
                 return;
             }
             if (action === "start-drain")
@@ -314,11 +323,18 @@ export function runChildSession(input) {
                 compactionStartedReceived = true;
                 if (agentSettledReceived)
                     afterCompactionSettlement = true;
+                if (terminalAgentEndReceived)
+                    compactionAfterFinalOpen = true;
             }
             if (event.type === "compaction_end" && event.willRetry === true) {
                 compactionStartedReceived = false;
                 afterCompactionSettlement = false;
             }
+            if (event.type === "compaction_end" && event.willRetry !== true && compactionAfterFinalOpen) {
+                compactionAfterFinalOpen = false;
+                clearFinalDrainTimers();
+                startFinalDrain();
+            }
             if (event.type === "turn_start" || event.type === "agent_start" || event.type === "auto_retry_start") {
                 queuedDrainHold = false;
             }
@@ -331,7 +347,7 @@ export function runChildSession(input) {
                 agentSettledReceived = true;
                 afterCompactionSettlement = compactionStartedReceived;
             }
-            applyChildLifecycle(lifecycleAction);
+            applyChildLifecycle(lifecycleAction, event);
             if (isChildWatchdogStatusEvent(event)) {
                 if (!input.childWatchdog)
                     return;

package/src/runs/background/subagent-wait.d.ts

@@ -100,7 +100,7 @@ export interface SubagentWaitDeps {
     };
     /** Injectable provider protocol surfaces for deterministic tests. */
     backgroundWork?: {
-        snapshot(sessionId: string, nowMs: number): BackgroundWorkSnapshot;
+        snapshot(sessionIds: readonly string[], nowMs: number): BackgroundWorkSnapshot;
         wakeChannels(): readonly string[];
     };
     /**
@@ -111,6 +111,7 @@ export interface SubagentWaitDeps {
      */
     events?: WaitEventBus;
 }
+export declare function backgroundWorkForSession(deps: Pick<SubagentWaitDeps, "state" | "backgroundWork">, nowMs: number): BackgroundWorkSnapshot;
 export declare function waitRunScopes(deps: Pick<SubagentWaitDeps, "asyncDirRoot" | "resultsDir" | "nestedRootRunId">): Array<{
     asyncDirRoot: string;
     resultsDir: string;

package/src/runs/background/subagent-wait.js

@@ -181,11 +181,14 @@ function hasSupervisorTool(run) {
 function backgroundWorkIdentity(item) {
     return `${item.provider}\0${item.sessionId}\0${item.id}`;
 }
-function backgroundWorkForSession(deps, nowMs) {
+export function backgroundWorkForSession(deps, nowMs) {
     const sessionId = deps.state.currentSessionId;
     if (!sessionId)
         throw new Error("bg_wait requires an active session identity to scope background work safely.");
-    return deps.backgroundWork?.snapshot(sessionId, nowMs) ?? snapshotBackgroundWork(sessionId, nowMs);
+    // Providers may key items by the session file path or by getSessionId(); accept both.
+    const piSessionId = deps.state.supervisorOwnerSessionId;
+    const sessionIds = piSessionId ? [sessionId, piSessionId] : [sessionId];
+    return deps.backgroundWork?.snapshot(sessionIds, nowMs) ?? snapshotBackgroundWork(sessionIds, nowMs);
 }
 export function waitRunScopes(deps) {
     return [

package/src/runs/foreground/execution.js

@@ -561,6 +561,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         let agentSettledReceived = false;
         let queuedDrainHold = false;
         let compactionStartedReceived = false;
+        let terminalAgentEndReceived = false;
+        let compactionAfterFinalOpen = false;
         let finalDrainTimer;
         let finalHardFinishTimer;
         let watchdogTailTimer;
@@ -608,7 +610,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             finalDrainTimer = setTimeout(() => {
                 if (lifecycleFinished || sessionSettled)
                     return;
-                if (capture.finalDrainHeld() || observeQueuedDrainHold()) {
+                // Pi runs auto-compaction after the final agent_end and only then emits agent_settled.
+                if (capture.finalDrainHeld() || observeQueuedDrainHold() || compactionAfterFinalOpen) {
                     finalDrainTimer = undefined;
                     armFinalDrainTimer();
                     return;
@@ -623,9 +626,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                         return;
                     settle(undefined, true);
                 }, HARD_FINISH_MS);
-                finalHardFinishTimer.unref?.();
             }, FINAL_STOP_GRACE_MS);
-            finalDrainTimer.unref?.();
         };
         function armWatchdogTail() {
             if ((!cleanTerminalAssistantStopReceived && !agentSettledReceived) || watchdogTailTimer || lifecycleFinished || sessionSettled)
@@ -644,12 +645,20 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             }, childWatchdog?.watchdogTailTimeoutMs ?? 120_000);
             watchdogTailTimer.unref?.();
         }
-        const applyChildLifecycle = (action) => {
+        const applyChildLifecycle = (action, event) => {
             if (action === "cancel-drain") {
-                cleanTerminalAssistantStopReceived = false;
+                // After a clean final stop, a non-retrying agent_end may be the child's last event
+                // (Pi may not emit agent_settled), so it re-arms the drain instead of cancelling it.
+                terminalAgentEndReceived = event?.type === "agent_end" && event.willRetry !== true && cleanTerminalAssistantStopReceived;
                 agentSettledReceived = false;
                 clearFinalDrainTimers();
                 clearWatchdogTailTimer();
+                if (terminalAgentEndReceived) {
+                    startFinalDrain();
+                    return;
+                }
+                cleanTerminalAssistantStopReceived = false;
+                compactionAfterFinalOpen = false;
                 return;
             }
             if (action === "start-drain")
@@ -925,11 +934,18 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 compactionStartedReceived = true;
                 if (agentSettledReceived)
                     afterCompactionSettlement = true;
+                if (terminalAgentEndReceived)
+                    compactionAfterFinalOpen = true;
             }
             if (evt.type === "compaction_end" && evt.willRetry === true) {
                 compactionStartedReceived = false;
                 afterCompactionSettlement = false;
             }
+            if (evt.type === "compaction_end" && evt.willRetry !== true && compactionAfterFinalOpen) {
+                compactionAfterFinalOpen = false;
+                clearFinalDrainTimers();
+                startFinalDrain();
+            }
             if (evt.type === "turn_start" || evt.type === "agent_start" || evt.type === "auto_retry_start") {
                 queuedDrainHold = false;
             }
@@ -956,7 +972,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 agentSettledReceived = true;
                 afterCompactionSettlement = compactionStartedReceived;
             }
-            applyChildLifecycle(lifecycleAction);
+            applyChildLifecycle(lifecycleAction, evt);
             if (isChildWatchdogStatusEvent(evt)) {
                 if (!childWatchdog)
                     return;

package/src/runs/foreground/subagent-executor.js

@@ -17,7 +17,7 @@ import { buildDoctorReport } from "../../extension/doctor.js";
 import { readSubagentGuide } from "../../extension/subagent-guide.js";
 import { isWorkflowScriptPath, normalizePublicSubagentExecution, validateWorkflowCapacityOverrides } from "../../extension/public-execution.js";
 import { readReplyWorkflowScript } from "../../extension/reply-workflow-script.js";
-import { disabledFeatureNotice, disabledFeatureUseError, resolveDisabledFeatureSurface } from "../../shared/disabled-features.js";
+import { disabledFeatureNotice, disabledFeatureSectionNotice, disabledFeatureUseError, resolveDisabledFeatureSurface } from "../../shared/disabled-features.js";
 import { runSync } from "./execution.js";
 import { commandAction } from "./command-action.js";
 import { handleWatchdogToolAction, WATCHDOG_TOOL_ACTIONS } from "../../watchdog/tool-actions.js";
@@ -6689,10 +6689,7 @@ export function createSubagentExecutor(deps) {
             if (action === "guide") {
                 try {
                     const guide = readSubagentGuide(paramsWithResolvedCwd.topic);
-                    const [topic, section] = paramsWithResolvedCwd.topic?.split("/") ?? [];
-                    const fullNotice = topic === "tool-reference" ? disabledFeatureNotice(disabledFeatures) : undefined;
-                    // Sections are capped at 8,000 chars, so they get a one-line pointer instead of the full list.
-                    const notice = fullNotice && section !== undefined ? "Some options and actions documented here are disabled by config in this session; guide topic tool-reference lists them." : fullNotice;
+                    const notice = paramsWithResolvedCwd.topic?.includes("/") ? disabledFeatureSectionNotice(disabledFeatures) : disabledFeatureNotice(disabledFeatures);
                     return {
                         content: [{ type: "text", text: notice ? `${notice}\n\n${guide}` : guide }],
                         details: { mode: "management", results: [] },

package/src/runs/shared/child-launch.js

@@ -45,7 +45,7 @@ function escapeXmlAttr(value) {
 function inheritedCapabilityCeiling(inherited) {
     return inherited?.capabilityCeiling;
 }
-/** Environment values external child extensions read; only the runner applies them. */
+/** Environment values external child extensions read in the runner, which hosts only children. */
 function childProcessEnv(input, toolPlan) {
     const env = {};
     env[PI_SUBAGENT_EXTENSION_BINDINGS_ENV] = encodeExtensionBindings(input.extensionBindings);
@@ -222,7 +222,10 @@ export function buildInProcessChildLaunch(input) {
         requiredExtensions: toolPlan.requiredExtensions,
         ambientExtensions,
         hooks: capturedHooks.hooks,
-        ...(input.host === "runner" ? { processEnv: childProcessEnv(input, toolPlan) } : {}),
+        // A foreground child gets only its own bindings, so it never sees those of the session that launched it.
+        ...(input.host === "runner"
+            ? { processEnv: childProcessEnv(input, toolPlan) }
+            : { processEnv: { [PI_SUBAGENT_EXTENSION_BINDINGS_ENV]: encodeExtensionBindings(input.extensionBindings) }, restoreProcessEnv: true }),
         runtime: config,
         noSkills: !input.inheritSkills,
         noContextFiles: !input.inheritProjectContext,

package/src/runs/shared/child-session.d.ts

@@ -80,6 +80,12 @@ export interface ChildSessionLaunch {
      * window one at a time. An undefined value removes the variable.
      */
     processEnv?: Record<string, string | undefined>;
+    /**
+     * Restore the hosting process's previous values of `processEnv` once that
+     * window ends, so a child hosted in the parent's own process leaves the
+     * parent's environment as it found it.
+     */
+    restoreProcessEnv?: boolean;
     /** The typed runtime config the hooks were built from; informational for factories. */
     runtime: ChildRuntimeConfig;
     onExtensionError?: (error: ChildSessionExtensionError) => void;

package/src/runs/shared/child-session.js

@@ -153,15 +153,18 @@ function resetExtensionCacheOnReload(loader) {
     loader.loaded = true;
     return true;
 }
+/** Applies `values` to `process.env` and returns a function that puts back the values they replaced. */
 function applyProcessEnv(values) {
     if (!values)
-        return;
+        return () => { };
+    const previous = Object.fromEntries(Object.keys(values).map((name) => [name, process.env[name]]));
     for (const [name, value] of Object.entries(values)) {
         if (value === undefined)
             delete process.env[name];
         else
             process.env[name] = value;
     }
+    return () => applyProcessEnv(previous);
 }
 /**
  * Pi's built-in MCP extension registers server tools with the configured exposure, `codemode` by
@@ -458,7 +461,11 @@ export function createDefaultChildSessionFactory(options = {}) {
                     await commands?.shutdown();
                     const runner = session.extensionRunner;
                     if (runner.hasHandlers("session_shutdown")) {
-                        await Promise.race([runner.emit({ type: "session_shutdown", reason: "quit" }), new Promise((resolve) => setTimeout(resolve, shutdownTimeoutMs).unref?.())]);
+                        // Ref'd so a detached runner with nothing else pending stays alive until the bound
+                        // ends and still publishes its result; cleared as soon as the handlers finish.
+                        let bound;
+                        await Promise.race([runner.emit({ type: "session_shutdown", reason: "quit" }), new Promise((resolve) => { bound = setTimeout(resolve, shutdownTimeoutMs); })])
+                            .finally(() => clearTimeout(bound));
                     }
                 }
                 catch (error) {
@@ -469,8 +476,7 @@ export function createDefaultChildSessionFactory(options = {}) {
                 }
             };
             let inheritedProviders = new Set();
-            const open = async () => {
-                applyProcessEnv(launch.processEnv);
+            const openSession = async () => {
                 if (!resetExtensionCacheOnReload(loader) && (launch.ambientExtensions || launch.extensionPaths.length))
                     launch.onExtensionError?.({ extensionPath: "<loader>", event: "load", error: new Error("pi's extension cache reset is unavailable; extensions loaded into this child share module state with other sessions in this process.") });
                 await loader.reload();
@@ -559,6 +565,16 @@ export function createDefaultChildSessionFactory(options = {}) {
                 }
                 return session;
             };
+            const open = async () => {
+                const restoreEnv = applyProcessEnv(launch.processEnv);
+                try {
+                    return await openSession();
+                }
+                finally {
+                    if (launch.restoreProcessEnv)
+                        restoreEnv();
+                }
+            };
             const opened = loading.catch(() => { }).then(open);
             loading = opened;
             const session = await opened;

package/src/runs/shared/herdr-machine.d.ts

@@ -42,6 +42,8 @@ export interface PreparedHerdrMachineExternalCliRun {
 export declare function resolveHerdrMachinePlacement(input: ResolveHerdrMachinePlacementInput): HerdrMachinePlacement;
 /** `local` resolves to a Rex pane on this machine; a name with a `rex` entry in user settings to a Rex pane on that SSH host; any other value to a Herdr saved machine. */
 export declare function resolveMachinePlacement(input: ResolveHerdrMachinePlacementInput): MachinePlacement;
+/** A placed Pi keeps its transcript on the pane's machine, so it can't start from a local one. */
+export declare const PLACED_RESTORE_UNSUPPORTED = "Pane-native remote Pi does not support fork, resume, or revival; use fresh context.";
 export declare function formatHerdrMachineRunnerUnsupported(input: {
     machine?: string;
     agentName: string;

package/src/runs/shared/herdr-machine.js

@@ -233,6 +233,8 @@ export function resolveMachinePlacement(input) {
         return { machine: { provider: "rex", id: requested, target: settings.rex.ssh, cwd: validateRemoteCwd(remoteMachineCwd(input.stepCwd, settings.cwd, requested), requested) } };
     return resolveHerdrMachinePlacement(input);
 }
+/** A placed Pi keeps its transcript on the pane's machine, so it can't start from a local one. */
+export const PLACED_RESTORE_UNSUPPORTED = "Pane-native remote Pi does not support fork, resume, or revival; use fresh context.";
 export function formatHerdrMachineRunnerUnsupported(input) {
     if (input.machine === undefined)
         return undefined;

package/src/runs/shared/herdr-placed-run.js

@@ -8,6 +8,7 @@ import { encodeHerdrPiFrame, HERDR_PI_MODE_ENV, HERDR_PI_PROTOCOL, HERDR_PI_RUN_
 import { discoverPlacedBridgeManifest } from "./placed-run-owner.js";
 import { RexPlacedRunOwner } from "./rex-pane-host.js";
 import { isRexLocalMachine } from "./rex-machine.js";
+import { PLACED_RESTORE_UNSUPPORTED } from "./herdr-machine.js";
 /** The pane half comes from the host; the bridge half (run, package, protocol, native session, evidence cursor) is host-neutral. */
 export function reconcileHerdrReconnect(identity, candidate, lastEvidenceCursor, host = herdrPaneHost) {
     return host.reconcile(identity, candidate, () => { const bridge = candidate.bridge; if (bridge.runId !== identity.runId || bridge.nativeSessionId !== identity.nativeSessionId || bridge.packageVersion !== packageJson.version || bridge.protocol !== HERDR_PI_PROTOCOL)
@@ -35,16 +36,18 @@ export async function boundedHerdrReconnect(identity, lastEvidenceCursor, attemp
 }
 function safeRunId(value) { const prefix = value?.replace(/[^A-Za-z0-9_-]/gu, "_").slice(0, 48) ?? "run"; return validateHerdrPiRunId(`${prefix}_${randomBytes(8).toString("hex")}`); }
 export function serializeHerdrPiLaunch(launch) {
-    if (launch.storage.kind === "file")
-        throw new Error("Pane-native remote Pi does not support fork, resume, or revival; use fresh context.");
+    // Every child is handed a local session file path; only one that already exists (a fork or a
+    // resumed transcript) asks the pane to restore history. A fresh child's path is never written.
+    if (launch.storage.kind === "file" && fs.existsSync(launch.storage.sessionFile))
+        throw new Error(PLACED_RESTORE_UNSUPPORTED);
     if (launch.extensionPaths.length || launch.requiredExtensions?.length)
         throw new Error("Pane-native remote Pi cannot transfer local extension paths; install/configure pi-subagents on the remote machine.");
     if (launch.processEnv && Object.values(launch.processEnv).some((value) => value !== undefined && value !== "__none__"))
         throw new Error("Pane-native remote Pi cannot transfer local bindings, MCP selections, or process environment.");
     if (launch.runtime.nestedRoute || launch.runtime.fanoutChild || launch.runtime.depth > 1)
         throw new Error("Nested delegation from a pane-native remote Pi is not supported.");
-    if (launch.excludeTools?.length || launch.runtime.permissions || launch.runtime.toolBudget || launch.runtime.requiredExtensions || launch.runtime.requiredTools?.length || launch.runtime.mcpDirectTools?.length)
-        throw new Error("Pane-native remote Pi cannot yet represent exclusions, permission rules, tool budgets, MCP direct tools, or required-tool/extension contracts; remove machine placement.");
+    if (launch.excludeTools?.length || launch.runtime.permissions || launch.runtime.toolBudget || launch.runtime.requiredExtensions || launch.runtime.mcpDirectTools?.length)
+        throw new Error("Pane-native remote Pi cannot yet represent exclusions, permission rules, tool budgets, MCP direct tools, or required-extension contracts; remove machine placement.");
     const resources = launch.remoteResources;
     if (!resources || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(resources.agent) || resources.skills?.some((name) => !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(name)) || resources.toolCeiling?.some((name) => !/^[A-Za-z0-9_-]{1,64}$/u.test(name)) || (resources.reads !== undefined && resources.reads !== false && resources.reads.some((read) => typeof read !== "string" || Buffer.byteLength(read) > 4096)))
         throw new Error("Pane-native remote resources require bounded logical agent, skill, tool, and read names.");
@@ -350,6 +353,10 @@ async function startPlacedPiSession(launch, owner, policy) {
             throw new Error("Remote Pi resource resolution identity mismatch.");
         if (!Array.isArray(configured.tools) || (policy.resources.toolCeiling && configured.tools.some((tool) => !policy.resources.toolCeiling.includes(String(tool)))))
             throw new Error("Remote Pi active-tool ceiling acknowledgement mismatch.");
+        // The remote Pi never receives the runtime contract, so required tools are checked here, against what it activated.
+        const missingRequired = (launch.runtime.requiredTools ?? []).filter((tool) => !configured.tools.includes(tool));
+        if (missingRequired.length)
+            throw new Error(`Remote Pi agent '${policy.resources.agent}' did not activate required tools: ${missingRequired.join(", ")}.`);
         if (launch.model && configured.model !== launch.model.split(":")[0])
             throw new Error(`Remote Pi model '${launch.model}' did not resolve to the requested provider/model.`);
         const identity = { runId, machineId: machine.id, target: isRexLocalMachine(machine) ? machine.id : machine.target, session: owner.host.sessionOf(connection), workspaceId: owned.workspaceId, tabId: owned.tabId, paneId: owned.paneId, terminalId, agentName, nativeSessionId: manifest.nativeSessionId, cwd: machine.cwd, runtimeDir };

package/src/runs/shared/subagent-prompt-runtime.js

@@ -669,6 +669,7 @@ export default function registerSubagentPromptRuntime(pi, config, drainObservati
     onRuntimeEvent("session_start", (_event, ctx) => {
         const sessionManager = ctx?.sessionManager;
         waitState.currentSessionId = sessionManager ? resolveCurrentSessionId(sessionManager) : null;
+        waitState.supervisorOwnerSessionId = sessionManager?.getSessionId() || null;
         registerNativeSupervisorClientOnce();
     });
     onRuntimeEvent("agent_start", () => {
@@ -724,30 +725,23 @@ export default function registerSubagentPromptRuntime(pi, config, drainObservati
         onRuntimeEvent("before_provider_headers", (event, ctx) => {
             applyForkSessionAffinity(event?.headers, ctx?.model, config.parentSessionId, readInherited(ctx)?.model);
         });
-    if (config.forkCacheKey)
-        onRuntimeEvent("context_with_system", (event, ctx) => {
-            if (!event || typeof event !== "object" || !("messages" in event) || !Array.isArray(event.messages))
-                return undefined;
-            const fork = readInherited(ctx);
-            if (!fork)
-                return undefined;
-            const messages = projectForkRequest(event.messages, fork.system, fork.forkedAt, { boundary });
-            return messages === event.messages ? undefined : { messages };
-        });
-    onRuntimeEvent("context", (event, ctx) => {
+    // The strip runs on context_with_system, not context: Pi treats any change a context handler
+    // makes to the message list as a rewritten conversation and folds every mid-conversation system
+    // message into the leading one, so every later request would miss the prompt cache. The strip
+    // passes system messages through unchanged.
+    onRuntimeEvent("context_with_system", (event, ctx) => {
         if (!event || typeof event !== "object" || !("messages" in event) || !Array.isArray(event.messages))
             return undefined;
-        const forkedAt = config.forkCacheKey ? Date.parse(ctx?.sessionManager?.getHeader()?.timestamp ?? "") : Number.NaN;
-        const messages = stripParentOnlySubagentMessages(event.messages, {
+        const fork = config.forkCacheKey ? readInherited(ctx) : undefined;
+        const stripped = stripParentOnlySubagentMessages(event.messages, {
             sanitizeToolIds: !COMPOSITE_TOOL_ID_APIS.has(ctx?.model?.api ?? ""),
             // Providers that reuse the Codex Responses wire under their own api id (e.g. cliproxyapi-codex-responses) split call_id|item_id the same way.
             preserveBoundedCompositeToolIds: ctx?.model?.api?.endsWith("-codex-responses") === true,
             preserveFanoutToolHistory: config.fanoutChild,
-            ...(Number.isFinite(forkedAt) ? { inheritedBefore: forkedAt } : {}),
+            ...(fork ? { inheritedBefore: fork.forkedAt } : {}),
         });
-        if (messages === event.messages)
-            return undefined;
-        return { messages };
+        const messages = fork ? projectForkRequest(stripped, fork.system, fork.forkedAt, { boundary }) : stripped;
+        return messages === event.messages ? undefined : { messages };
     });
     // pi-intercom asks at session start for this session's intercom ID. Claiming
     // the route there frees the session name for the readable label. An older

package/src/shared/disabled-features.d.ts

@@ -86,6 +86,8 @@ interface FeatureConfig {
 export declare function resolveDisabledFeatureSurface(config: FeatureConfig): DisabledFeatureSurface;
 /** Returns why a request uses a disabled feature, or undefined when every requested field is enabled. */
 export declare function disabledFeatureUseError(request: object, surface: DisabledFeatureSurface, label?: string): string | undefined;
-/** Lists what config disabled, for prepending to static reference docs that describe the full tool. */
+/** Lists what config disabled, for prepending to static guide docs that describe the full tool. */
 export declare function disabledFeatureNotice(surface: DisabledFeatureSurface): string | undefined;
+/** One-line form for guide sections, which are capped at 8,000 chars. */
+export declare function disabledFeatureSectionNotice(surface: DisabledFeatureSurface): string | undefined;
 export {};

package/src/shared/disabled-features.js

@@ -99,14 +99,22 @@ export function disabledFeatureUseError(request, surface, label = "subagent") {
     }
     return undefined;
 }
-/** Lists what config disabled, for prepending to static reference docs that describe the full tool. */
+const WORKFLOW_SCRIPTS_REPLACEMENT = "Instead of workflow scripts, use the top-level tasks or chain fields.";
+/** Lists what config disabled, for prepending to static guide docs that describe the full tool. */
 export function disabledFeatureNotice(surface) {
     if (surface.features.size === 0)
         return undefined;
     const lines = [...surface.features].map((feature) => {
         const { actions, params, disabledBy } = featureSurface(feature);
         const parts = [`options ${params.join(", ")}`, ...(actions.length > 0 ? [`actions ${actions.join(", ")}`] : [])];
-        return `- ${disabledBy}: ${parts.join("; ")}`;
+        return `- ${disabledBy}: ${parts.join("; ")}${feature === "workflow-scripts" ? `. ${WORKFLOW_SCRIPTS_REPLACEMENT}` : ""}`;
     });
-    return `Disabled by config in this session. The reference below still lists these, but calls that use them are rejected:\n${lines.join("\n")}`;
+    return `Disabled by config in this session. The guide below may still describe these, but calls that use them are rejected:\n${lines.join("\n")}`;
+}
+/** One-line form for guide sections, which are capped at 8,000 chars. */
+export function disabledFeatureSectionNotice(surface) {
+    if (surface.features.size === 0)
+        return undefined;
+    const replacement = surface.features.has("workflow-scripts") ? ` ${WORKFLOW_SCRIPTS_REPLACEMENT}` : "";
+    return `Some options and actions are disabled by config in this session; guide topic tool-reference lists them.${replacement}`;
 }

package/src/shared/types.d.ts

@@ -2278,7 +2278,7 @@ export interface ActiveAsyncCapacitySnapshot {
 export interface SubagentState {
     baseCwd: string;
     currentSessionId: string | null;
-    /** Exact SDK runtime session ID for supervisor ownership; never a session file path. */
+    /** Exact SDK runtime session ID (`getSessionId()`) for supervisor ownership and background-work matching; never a session file path. */
     supervisorOwnerSessionId?: string | null;
     /** Session for which active status projections were restored successfully. */
     statusProjectionSessionId?: string | null;
@@ -2410,6 +2410,8 @@ export declare const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
 export declare const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 export declare const SUBAGENT_STEERING_NOTICE_EVENT = "subagent:steering-notice";
 export declare const SUBAGENT_CHILD_STATUS_EVENT = "subagent:child-status";
+/** Payload is only `{ version: 1 }`: a hint for hosts to read `status` again, not a description of the change. */
+export declare const SUBAGENT_JOBS_CHANGED_EVENT = "subagent:jobs-changed";
 export declare const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 export declare const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
 export interface SubagentChildStatusEvent {

package/src/shared/types.js

@@ -19,6 +19,8 @@ export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
 export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 export const SUBAGENT_STEERING_NOTICE_EVENT = "subagent:steering-notice";
 export const SUBAGENT_CHILD_STATUS_EVENT = "subagent:child-status";
+/** Payload is only `{ version: 1 }`: a hint for hosts to read `status` again, not a description of the change. */
+export const SUBAGENT_JOBS_CHANGED_EVENT = "subagent:jobs-changed";
 export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
 export const FLEET_KEYBINDING_ACTIONS = [