@fitchmultz/pi-subagents 0.45.0 → 0.46.1

package/dist/pi-intercom/bridge-rpc-process.js

@@ -0,0 +1,264 @@
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { trySignalChildTree } from "../shared/post-exit-stdio-guard.js";
+import { isRecord } from "../shared/unknown.js";
+import { Fault, log, wait } from "./bridge-protocol.js";
+const FRAME_LIMIT = 4 * 1024 * 1024;
+function launchEnvironment(packageRoot) {
+    const environment = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("PI_SUBAGENT_")));
+    return { ...environment, PI_PACKAGE_DIR: packageRoot };
+}
+// Native RpcClient lacks public EOF/exit/UI control and retains/reprints unbounded stderr.
+// This owner implements only get_state and dialog cancellation, never a remote RPC proxy.
+export class RpcProcess {
+    child;
+    exited;
+    status = "starting";
+    failure;
+    decoder = new StringDecoder("utf8");
+    buffer = "";
+    discarding = false;
+    sequence = 0;
+    pending;
+    stopping;
+    stderrBytes = 0;
+    exitObserved = false;
+    constructor(policy, cwd, sessionFile) {
+        this.child = spawn(process.execPath, this.arguments(policy, sessionFile), {
+            cwd,
+            detached: true,
+            env: launchEnvironment(policy.packageRoot),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.exited = new Promise((resolveExit) => {
+            this.child.once("close", (code, signal) => {
+                this.exitObserved = true;
+                this.buffer = "";
+                this.discarding = false;
+                this.status = "exited";
+                this.fail(new Fault(503, "session_exited", "Launched Pi process exited."));
+                log("launch_exit", { pid: this.child.pid, code, signal, stderrBytes: this.stderrBytes });
+                resolveExit();
+            });
+        });
+        this.child.once("error", () => this.fail(new Fault(503, "launch_failed", "Pi process could not start.")));
+        this.child.stdin.on("error", () => {
+            this.fail(new Fault(503, "rpc_closed", "Pi RPC input closed."));
+            this.cleanup();
+        });
+        this.child.stdout.once("end", () => {
+            this.fail(new Fault(503, "rpc_closed", "Pi RPC output closed."));
+            this.cleanup();
+        });
+        for (const stream of [this.child.stdout, this.child.stderr]) {
+            stream.on("error", () => {
+                this.fail(new Fault(503, "rpc_closed", "Pi RPC output failed."));
+                this.cleanup();
+            });
+        }
+        this.child.stdout.on("data", (chunk) => this.read(this.decoder.write(chunk)));
+        this.child.stderr.on("data", (chunk) => {
+            // Drain without retaining or exposing diagnostics, including credential-bearing extension errors.
+            this.stderrBytes = Math.min(Number.MAX_SAFE_INTEGER, this.stderrBytes + chunk.length);
+        });
+    }
+    get pid() {
+        return this.child.pid;
+    }
+    arguments(policy, sessionFile) {
+        const args = [
+            policy.cli,
+            "--mode",
+            "rpc",
+            "--session",
+            sessionFile,
+            "--provider",
+            policy.provider,
+            "--model",
+            policy.model,
+            policy.trustProject ? "--approve" : "--no-approve",
+        ];
+        if (!policy.discoverResources) {
+            args.push("--no-extensions", "--no-skills", "--no-prompt-templates", "--no-themes", "--no-context-files");
+        }
+        if (policy.offline) {
+            args.push("--offline");
+        }
+        for (const extension of policy.extensions) {
+            args.push("--extension", extension);
+        }
+        return args;
+    }
+    fail(error) {
+        this.failure ??= error;
+        this.pending?.reject(this.failure);
+        this.pending = undefined;
+    }
+    retainedChunk(chunk) {
+        if (!this.discarding) {
+            return chunk;
+        }
+        const end = chunk.indexOf("\n");
+        if (end < 0) {
+            return "";
+        }
+        this.discarding = false;
+        return chunk.slice(end + 1);
+    }
+    read(chunk) {
+        this.buffer += this.retainedChunk(chunk);
+        let newline = this.buffer.indexOf("\n");
+        while (newline >= 0) {
+            const line = this.buffer.slice(0, newline);
+            this.buffer = this.buffer.slice(newline + 1);
+            if (Buffer.byteLength(line) > FRAME_LIMIT) {
+                this.oversize(line);
+            }
+            else {
+                this.record(line);
+            }
+            newline = this.buffer.indexOf("\n");
+        }
+        if (Buffer.byteLength(this.buffer) > FRAME_LIMIT) {
+            this.discarding = this.oversize(this.buffer);
+            this.buffer = "";
+        }
+    }
+    oversize(prefix) {
+        // Native event serializers put the discriminant first; responses may put their request ID first.
+        // ponytail: drain large native data events through LF; use token streaming if producer headers change.
+        const header = /^\{"type":"([a-z_]+)"[,}]/.exec(prefix.slice(0, 256));
+        const event = header?.[1];
+        if (event !== undefined &&
+            !["response", "extension_ui_request", "agent_start", "agent_settled"].includes(event)) {
+            log("rpc_event_discarded", { pid: this.pid, result: "oversized" });
+            return true;
+        }
+        this.protocolFailure();
+        return false;
+    }
+    protocolFailure() {
+        this.fail(new Fault(503, "rpc_invalid", "Pi RPC output violated its bounded JSONL contract."));
+        this.cleanup();
+    }
+    record(line) {
+        let data;
+        try {
+            data = JSON.parse(line);
+        }
+        catch {
+            this.protocolFailure();
+            return;
+        }
+        if (!isRecord(data)) {
+            this.protocolFailure();
+            return;
+        }
+        if (data.type === "response" && data.id === this.pending?.id) {
+            this.response(data);
+        }
+        else if (data.type === "extension_ui_request") {
+            this.dialog(data);
+        }
+        else if (!this.failure) {
+            this.event(data.type);
+        }
+    }
+    event(type) {
+        if (type === "agent_start") {
+            this.status = "running";
+        }
+        else if (type === "agent_settled") {
+            this.status = "idle";
+        }
+    }
+    response(data) {
+        const pending = this.pending;
+        this.pending = undefined;
+        if (data.success === true && data.command === "get_state" && isRecord(data.data)) {
+            pending?.resolve(data.data);
+        }
+        else {
+            pending?.reject(new Fault(503, "rpc_failed", "Pi RPC state request failed."));
+        }
+    }
+    dialog(data) {
+        if (typeof data.method !== "string" ||
+            !["confirm", "select", "input", "editor"].includes(data.method)) {
+            return;
+        }
+        if (typeof data.id === "string") {
+            this.write({ type: "extension_ui_response", id: data.id, cancelled: true });
+        }
+        this.fail(new Fault(409, "interaction_required", "Pi requested unsupported interactive input; dialog cancelled and session stopped."));
+        this.cleanup();
+    }
+    write(command) {
+        // Only one bounded state request can be in flight; no arbitrary input or growing write queue.
+        if (!this.child.stdin.write(`${JSON.stringify(command)}\n`)) {
+            this.fail(new Fault(503, "rpc_backpressure", "Pi RPC input is not being consumed."));
+            this.cleanup();
+        }
+    }
+    async state(signal) {
+        if (this.failure) {
+            throw this.failure;
+        }
+        const id = `state-${++this.sequence}`;
+        const result = new Promise((resolve, reject) => {
+            this.pending = { id, resolve, reject };
+            this.write({ type: "get_state", id });
+        });
+        try {
+            return await wait(result, signal);
+        }
+        finally {
+            this.pending = undefined;
+        }
+    }
+    ready() {
+        if (this.failure || this.exitObserved) {
+            throw this.failure ?? new Fault(503, "session_exited", "Pi exited during startup.");
+        }
+        if (this.status === "starting") {
+            this.status = "idle";
+        }
+    }
+    cleanup() {
+        this.stop().catch(() => log("launch_cleanup", { pid: this.child.pid, result: "failed" }));
+    }
+    stop() {
+        if (this.exitObserved) {
+            return this.exited;
+        }
+        this.stopping ??= this.shutdown().finally(() => {
+            this.stopping = undefined;
+        });
+        return this.stopping;
+    }
+    async shutdown() {
+        if (this.exitObserved) {
+            return;
+        }
+        this.status = "stopping";
+        this.fail(new Fault(410, "session_stopped", "Launched session is stopping."));
+        this.child.stdin.end();
+        const terminate = setTimeout(() => {
+            trySignalChildTree(this.child, "SIGTERM");
+        }, 1000);
+        const kill = setTimeout(() => {
+            trySignalChildTree(this.child, "SIGKILL");
+        }, 3000);
+        const deadline = AbortSignal.timeout(8000);
+        try {
+            await wait(this.exited, deadline);
+        }
+        catch {
+            throw new Fault(503, "stop_timeout", "Launched Pi did not close within the cleanup deadline; inspect sessions before retrying.");
+        }
+        finally {
+            clearTimeout(terminate);
+            clearTimeout(kill);
+        }
+    }
+}

package/dist/pi-intercom/bridge-session.js

@@ -246,6 +246,10 @@ export class Session {
         this.guard(signal);
         return peers;
     }
+    async connectedPeers(signal) {
+        await this.connect(signal);
+        return this.peers(signal);
+    }
     async target(to, signal) {
         const resolution = resolveSessionTarget(await this.peers(signal), to);
         if (resolution.status === "none") {

package/dist/pi-intercom/bridge.js

@@ -8,12 +8,14 @@ import { ASK_TIMEOUT, Fault, fingerprint, log } from "./bridge-protocol.js";
 import { Session } from "./bridge-session.js";
 import { operationFor, routeFor } from "./bridge-routes.js";
 import { reply } from "./bridge-http.js";
+import { Launcher, sameIdentity } from "./bridge-launch.js";
 const MAX_CONNECTIONS = 128;
 class Bridge {
     config;
     configPath;
     sessions = new Map();
     losses = new Map();
+    launcher = new Launcher();
     sockets = new Set();
     connections = new Map();
     server;
@@ -72,7 +74,7 @@ class Bridge {
     }
     allowed(identity) {
         const current = this.config.clients.get(identity.fingerprint256);
-        return !this.stopping && current?.name === identity.name && current.cwd === identity.cwd;
+        return !this.stopping && sameIdentity(identity, current);
     }
     lost(fp, count = 1) {
         if (count > 0 && this.config.clients.has(fp)) {
@@ -160,8 +162,9 @@ class Bridge {
             });
         });
         process.on("SIGHUP", () => this.reload());
-        process.once("SIGINT", () => this.stop());
-        process.once("SIGTERM", () => this.stop());
+        // Retain listeners during dispatch: selected SDK dependencies use signal-exit's listener check.
+        process.on("SIGINT", () => this.stop());
+        process.on("SIGTERM", () => this.stop());
     }
     reload() {
         if (this.stopping) {
@@ -174,10 +177,14 @@ class Bridge {
             }
             this.config = next;
             this.revokeRemoved();
+            this.launcher.revoke(next.clients).catch(() => log("launch_cleanup", { result: "failed" }));
             log("allowlist_reloaded", { result: "accepted", clients: next.clients.size });
         }
         catch {
             this.config = { ...this.config, clients: new Map() };
+            this.launcher
+                .revoke(this.config.clients)
+                .catch(() => log("launch_cleanup", { result: "failed" }));
             for (const session of this.sessions.values()) {
                 session.close(new Fault(503, "configuration_invalid", "Configuration reload failed; all identities denied."));
             }
@@ -224,7 +231,11 @@ class Bridge {
         for (const socket of this.sockets) {
             socket.destroy();
         }
-        await Promise.all([...this.handlers, ...sessions.map((session) => session.settled())]);
+        await Promise.all([
+            ...this.handlers,
+            ...sessions.map((session) => session.settled()),
+            this.launcher.shutdown(),
+        ]);
         log("shutdown", { result: "closed" });
     }
     admission(req) {
@@ -270,14 +281,16 @@ class Bridge {
             const signal = controller.signal;
             req.once("aborted", abort);
             res.once("close", onClose);
-            setDeadline(route === "POST /v1/ask" ? ASK_TIMEOUT + 15000 : 15000);
+            const duration = route === "POST /v1/ask" ? ASK_TIMEOUT + 15000 : 15000;
+            setDeadline(route === "POST /v1/start" ? 75000 : duration);
             const operation = await operationFor(req, route, signal);
             if (operation.route === "POST /v1/ask") {
                 setDeadline(operation.timeoutMs + 15000);
             }
-            const data = await session.execute(operation, {
+            const data = await this.execute(operation, session, {
                 signal,
                 requestId,
+                expires,
                 onPeer: (id) => {
                     peer = id;
                 },
@@ -305,6 +318,29 @@ class Bridge {
             }
         }
     }
+    async execute(operation, session, context) {
+        switch (operation.route) {
+            case "POST /v1/start":
+                return this.launcher.start(operation.name, {
+                    identity: session.identity,
+                    expires: context.expires,
+                    signal: context.signal,
+                    peers: (signal) => session.connectedPeers(signal),
+                });
+            case "GET /v1/sessions":
+                return this.launcher.list(session.identity);
+            case "POST /v1/stop":
+                return this.launcher.stop(session.identity, operation.sessionId);
+            case "GET /v1/list":
+            case "GET /v1/inbox":
+            case "POST /v1/register":
+            case "POST /v1/ask":
+            case "POST /v1/send":
+            case "POST /v1/reply":
+            case "POST /v1/ack":
+                return session.execute(operation, context);
+        }
+    }
 }
 function main() {
     const args = process.argv.slice(2);
@@ -322,7 +358,7 @@ function main() {
         new Bridge(loadConfig(path), path).start();
     }
     catch {
-        process.stderr.write("Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, and TLS credentials.\n");
+        process.stderr.write("Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, TLS credentials, and launch policy (0700 sessionDir, Pi packageRoot, extension paths).\n");
         process.exitCode = 1;
     }
 }

package/dist/runs/background/runner-step-output.js

@@ -59,9 +59,7 @@ export function publishStepOutput(step, ctx, state) {
         originalPath.length > 0 &&
         step.outputMode !== "file-only" &&
         step.outputPathFromAgentDefault === true;
-    const cleanup = shouldConsume
-        ? cleanupSingleOutputFile(originalPath, output, undefined)
-        : undefined;
+    const cleanup = shouldConsume ? cleanupSingleOutputFile(originalPath, output) : undefined;
     const savedPath = relocateOutput(ctx, originalPath, cleanup);
     const reference = outputReference(savedPath, state.resolvedOutput.fullOutput, cleanup);
     const displayOutput = finalizeSingleOutput({

package/dist/runs/shared/acceptance-finalization.js

@@ -287,7 +287,7 @@ export function formatAcceptanceFinalizationPrompt(input) {
     lines.push(...initialReviewEvidence(input.initialOutput, input.initialLedger, input.previousFailure), "", ...finalizationInstructions(input.nativeReport === true, input.outputSchema));
     return lines.join("\n");
 }
-export function createFinalizationTurn(input) {
+function createFinalizationTurn(input) {
     const failureMessage = acceptanceFailureMessage(input.ledger);
     return {
         turn: input.turn,
@@ -320,7 +320,7 @@ export function createFinalizationProcessFailureTurn(input) {
         failureMessage: `Acceptance rejected: ${input.message}`,
     };
 }
-export function attachFinalizationToLedger(input) {
+function attachFinalizationToLedger(input) {
     return {
         ...input.authoritativeLedger,
         ...(input.initialLedger.childReport

package/dist/runs/shared/acceptance.js

@@ -1,4 +1,4 @@
 export { acceptanceInputFromResolved, acceptanceSelfReviewConfig, formatAcceptancePrompt, resolveEffectiveAcceptance, shouldRunAcceptanceFinalization, validateAcceptanceInput, } from "./acceptance-contract.js";
 export { parseAcceptanceReport, validateAcceptanceReportShape, stripAcceptanceReport, } from "./acceptance-reports.js";
 export { acceptanceFailureMessage, acceptanceHumanAction, evaluateAcceptance, evaluateAcceptanceReport, } from "./acceptance-evaluation.js";
-export { attachFinalizationToLedger, buildFinalizationProcessFailureLedger, createFinalizationProcessFailureTurn, createFinalizationTurn, createFinalizationReportRuntime, readFinalizationReport, formatUnconfirmedFinalizationOutput, formatAcceptanceFinalizationPrompt, evaluateRunAcceptance, resolveExecutionOutcome, resolveFinalizationOutput, } from "./acceptance-finalization.js";
+export { buildFinalizationProcessFailureLedger, createFinalizationProcessFailureTurn, createFinalizationReportRuntime, readFinalizationReport, formatUnconfirmedFinalizationOutput, formatAcceptanceFinalizationPrompt, evaluateRunAcceptance, resolveExecutionOutcome, resolveFinalizationOutput, } from "./acceptance-finalization.js";

package/dist/runs/shared/model-fallback.js

@@ -115,6 +115,9 @@ const SAME_MODEL_RECOVERY_PATTERNS = [
     /socket/i,
     /connection/i,
     /fetch failed/i,
+    // Node fetch reports a response body cut off mid-stream as bare "terminated"; Pi retries it too.
+    // Match the whole message: process failures embed stderr and paths that can contain the word.
+    /^\s*terminated\s*$/i,
     /network/i,
     /http idle/i,
     /timed? out/i,

package/dist/runs/shared/parallel-utils.js

@@ -21,32 +21,12 @@ export function flattenSteps(steps) {
     }
     return flat;
 }
-export { mapConcurrent } from "../../shared/concurrency.js";
 function parallelResultStatus(result, hasOutput) {
     const error = result.error ?? "";
-    const suffix = error.length > 0 ? `: ${error}` : "";
-    if (result.exitCode === -1) {
-        return `SKIPPED${suffix}`;
-    }
-    if (result.exitCode !== 0 && result.exitCode !== null) {
-        return `FAILED (exit code ${result.exitCode})${suffix}`;
-    }
     if (error.length > 0) {
         return `WARNING: ${error}`;
     }
-    return emptyOutputStatus(result, hasOutput);
-}
-function emptyOutputStatus(result, hasOutput) {
-    if (hasOutput) {
-        return "";
-    }
-    const target = result.outputTargetPath ?? "";
-    if (target.length === 0) {
-        return "EMPTY OUTPUT (no textual response returned)";
-    }
-    return result.outputTargetExists === false
-        ? `EMPTY OUTPUT (expected output file missing: ${target})`
-        : "";
+    return hasOutput ? "" : "EMPTY OUTPUT (no textual response returned)";
 }
 export function aggregateParallelOutputs(results, headerFormat = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`) {
     return results

package/dist/runs/shared/single-output.js

@@ -228,7 +228,7 @@ function unchangedOutputIdentity(fd, outputPath, stat) {
         located.dev === current.dev &&
         located.ctimeMs === current.ctimeMs);
 }
-export function cleanupSingleOutputFile(outputPath, fullOutput, beforeRun) {
+export function cleanupSingleOutputFile(outputPath, fullOutput) {
     if (!nonempty(outputPath)) {
         return undefined;
     }
@@ -248,9 +248,6 @@ export function cleanupSingleOutputFile(outputPath, fullOutput, beforeRun) {
         if (!equal) {
             return { path: absolutePath, action: "skipped", reason: "file changed after capture" };
         }
-        if (matchesSnapshot(stat, beforeRun)) {
-            return { path: absolutePath, action: "skipped", reason: "file preexisted and was unchanged" };
-        }
         fs.unlinkSync(outputPath);
         return { path: absolutePath, action: "deleted" };
     }

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

@@ -16,14 +16,14 @@ const STRUCTURED_OUTPUT_INSTRUCTIONS = [
     "Your final action must be to call the `structured_output` tool with JSON matching the provided schema.",
     "Do not rely on prose-only completion; if you do not call `structured_output`, the parent will fail this step.",
 ].join("\n");
-export const CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS = [
+const CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS = [
     "You are a child subagent, not the parent orchestrator.",
     "The parent session owns delegation, orchestration, review fanout, and follow-up worker launches.",
     "Ignore prior parent-only orchestration instructions in inherited conversation history.",
     "Do not propose or run subagents. Complete only your assigned role-specific task with the tools available to you.",
     "If you need to edit files, call the actual edit/write tools. Do not print tool-call syntax, patches, or pseudo-tool calls as text.",
 ].join("\n");
-export const CHILD_FANOUT_BOUNDARY_INSTRUCTIONS = [
+const CHILD_FANOUT_BOUNDARY_INSTRUCTIONS = [
     "You are a child subagent with delegation enabled for your assigned task.",
     "You may delegate useful helper work within that task when it saves time or improves quality, using the available delegation tools.",
     "You remain responsible for your assigned result. The original parent owns integration, review synthesis, and final delivery.",

package/dist/runs/shared/workflow-policy.js

@@ -1,7 +1,8 @@
 import { errorMessage } from "../../shared/unknown.js";
+import { mapConcurrent } from "../../shared/concurrency.js";
 import { outputEntryFromResult } from "./chain-outputs.js";
 import { collectDynamicResults, validateDynamicCollection, } from "./dynamic-fanout.js";
-import { aggregateParallelOutputs, FAIL_FAST_REASON, mapConcurrent, } from "./parallel-utils.js";
+import { aggregateParallelOutputs, FAIL_FAST_REASON, } from "./parallel-utils.js";
 export function workflowChildSucceeded(result) {
     return (result.exitCode === 0 &&
         result.interrupted !== true &&

package/dist/shared/native-session-loader.js

@@ -0,0 +1,17 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+export async function loadNativeSession(packageRoot) {
+    // The trusted selected Pi package supplies this exact SDK declaration contract.
+    // A computed URL is required: Jiti rewrites literal SDK imports to its own host graph.
+    // oxlint-disable-next-line typescript/no-unsafe-assignment
+    const sessionModule = await import(__rewriteRelativeImportExtension(pathToFileURL(path.join(packageRoot, "dist/index.js")).href));
+    return sessionModule;
+}

package/dist/shared/native-session.js

@@ -1,18 +1,4 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
 import { requirePiPackageRoot } from "../runs/shared/pi-spawn.js";
+import { loadNativeSession } from "./native-session-loader.js";
 // Detached Node runners do not get Pi's extension-loader package aliases.
-const selectedSessionURL = pathToFileURL(path.join(requirePiPackageRoot(), "dist/index.js")).href;
-// The trusted selected Pi package supplies this exact SDK declaration contract.
-// A computed URL is required: Jiti rewrites literal SDK imports to its own host graph.
-// oxlint-disable-next-line typescript/no-unsafe-assignment
-const sessionModule = await import(__rewriteRelativeImportExtension(selectedSessionURL));
-export const { buildSessionContext, parseSessionEntries, migrateSessionEntries, SessionManager } = sessionModule;
+export const { buildSessionContext, parseSessionEntries, migrateSessionEntries, SessionManager } = await loadNativeSession(requirePiPackageRoot());

package/dist/shared/settings.js

@@ -73,16 +73,13 @@ export function resolveStepBehavior(agentConfig, stepOverrides, chainSkills) {
 function resolveChainPath(filePath, chainDir) {
     return path.isAbsolute(filePath) ? filePath : path.join(chainDir, filePath);
 }
-/** Prepend read/output paths so task prose cannot accidentally override the chosen destination. */
+/** Compose read paths and progress instructions for a chain child. */
 export function buildChainInstructions(behavior, chainDir, isFirstProgressAgent) {
     const prefixParts = [];
     const suffixParts = [];
     if (behavior.reads !== false && behavior.reads.length > 0) {
         prefixParts.push(`[Read from: ${behavior.reads.map((file) => resolveChainPath(file, chainDir)).join(", ")}]`);
     }
-    if (behavior.output !== false && behavior.output.length > 0) {
-        prefixParts.push(`[Write to: ${resolveChainPath(behavior.output, chainDir)}]`);
-    }
     if (behavior.progress) {
         const progressPath = path.join(chainDir, "progress.md");
         suffixParts.push(isFirstProgressAgent