@bastani/atomic 0.8.28 → 0.8.29-alpha.2

package/dist/builtin/subagents/src/runs/shared/structured-output.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { APP_NAME } from "@bastani/atomic";
+import { APP_NAME, STRUCTURED_OUTPUT_TOOL_NAME, getStructuredOutputMetadataPath } from "@bastani/atomic";
 import { Compile } from "typebox/compile";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 
@@ -9,10 +9,43 @@ const ENV_PREFIX = APP_NAME.toUpperCase();
 export const STRUCTURED_OUTPUT_SCHEMA_ENV = `${ENV_PREFIX}_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA`;
 export const STRUCTURED_OUTPUT_CAPTURE_ENV = `${ENV_PREFIX}_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE`;
 
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = readonly JsonValue[];
+type JsonRecord = { readonly [key: string]: JsonValue };
+type JsonValue = JsonPrimitive | JsonArray | JsonRecord;
+
 export interface StructuredOutputRuntime {
 	schema: JsonSchemaObject;
 	schemaPath: string;
 	outputPath: string;
+	metadataPath: string;
+}
+
+export interface StructuredOutputCaptureMetadata {
+	toolName: string;
+	toolCallId: string;
+	success: true;
+	terminate: true;
+	capturedAt?: string;
+}
+
+export interface StructuredOutputTranscriptContent {
+	readonly type?: string;
+	readonly id?: string;
+	readonly name?: string;
+}
+
+export interface StructuredOutputTranscriptMessage {
+	readonly role: string;
+	readonly content?: string | readonly StructuredOutputTranscriptContent[];
+	readonly toolCallId?: string;
+	readonly toolName?: string;
+	readonly isError?: boolean;
+}
+
+export interface ReadStructuredOutputOptions {
+	messages?: readonly StructuredOutputTranscriptMessage[];
+	toolName?: string;
 }
 
 interface CompiledJsonSchema {
@@ -20,21 +53,223 @@ interface CompiledJsonSchema {
 	Errors(value: unknown): Iterable<{ instancePath?: string; message?: string }>;
 }
 
-export function assertJsonSchemaObject(schema: unknown, label = "outputSchema"): asserts schema is JsonSchemaObject {
+type JsonSchemaRootDescriptor = {
+	readonly type?: string | readonly string[];
+	readonly anyOf?: readonly JsonSchemaObject[];
+	readonly oneOf?: readonly JsonSchemaObject[];
+	readonly allOf?: readonly JsonSchemaObject[];
+};
+
+type ToolCallBlock = {
+	readonly type: "toolCall";
+	readonly id?: string;
+	readonly name?: string;
+};
+
+function schemaTypeIsObjectOnly(type: JsonSchemaRootDescriptor["type"]): boolean {
+	if (type === "object") return true;
+	return Array.isArray(type) && type.length === 1 && type[0] === "object";
+}
+
+function isTopLevelObjectOutputSchema(schema: JsonSchemaObject): boolean {
+	const descriptor = schema as JsonSchemaRootDescriptor;
+	if (schemaTypeIsObjectOnly(descriptor.type)) return true;
+	if (descriptor.type !== undefined) return false;
+	if (Array.isArray(descriptor.anyOf) || Array.isArray(descriptor.oneOf)) return false;
+	if (Array.isArray(descriptor.allOf)) {
+		return descriptor.allOf.length > 0 && descriptor.allOf.every((member) => isTopLevelObjectOutputSchema(member));
+	}
+	return false;
+}
+
+function isJsonRecord(value: JsonValue): value is JsonRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringField(record: JsonRecord, key: string): string | undefined {
+	const value = record[key];
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function booleanField(record: JsonRecord, key: string): boolean | undefined {
+	const value = record[key];
+	return typeof value === "boolean" ? value : undefined;
+}
+
+function roleOf(message: StructuredOutputTranscriptMessage): string {
+	return message.role;
+}
+
+function toolCallBlocks(message: StructuredOutputTranscriptMessage): ToolCallBlock[] {
+	if (roleOf(message) !== "assistant" || !Array.isArray(message.content)) return [];
+	return message.content
+		.filter((block): block is ToolCallBlock => block.type === "toolCall")
+		.map((block) => ({ type: "toolCall", id: block.id, name: block.name }));
+}
+
+function isFinalityRelevantMessage(message: StructuredOutputTranscriptMessage): boolean {
+	const role = roleOf(message);
+	// `custom` entries are host/runtime annotations (for example display/status
+	// messages) rather than additional child model output, so they should not make
+	// an otherwise-final structured_output capture look stale.
+	return role === "assistant" || role === "toolResult";
+}
+
+function finalityInvalid(message: string): { status: "invalid"; message: string } {
+	return { status: "invalid", message };
+}
+
+function parseCaptureMetadata(value: JsonValue): { metadata?: StructuredOutputCaptureMetadata; error?: string } {
+	if (!isJsonRecord(value)) {
+		return { error: "Structured output metadata sidecar must contain an object with call metadata." };
+	}
+	const toolName = stringField(value, "toolName");
+	const toolCallId = stringField(value, "toolCallId");
+	if (!toolName || !toolCallId) {
+		return { error: "Structured output metadata sidecar is missing toolName or toolCallId metadata." };
+	}
+	if (booleanField(value, "success") !== true) {
+		return { error: "Structured output capture was not marked successful." };
+	}
+	if (booleanField(value, "terminate") !== true) {
+		return { error: "Structured output capture was not marked as a terminating action." };
+	}
+	return {
+		metadata: {
+			toolName,
+			toolCallId,
+			success: true,
+			terminate: true,
+			...(typeof value.capturedAt === "string" ? { capturedAt: value.capturedAt } : {}),
+		},
+	};
+}
+
+function verifyStructuredOutputFinality(
+	messages: readonly StructuredOutputTranscriptMessage[],
+	metadata: StructuredOutputCaptureMetadata,
+	expectedToolName: string,
+): { status: "valid" } | { status: "invalid"; message: string } {
+	if (metadata.toolName !== expectedToolName) {
+		return finalityInvalid(
+			`Captured structured output tool name ${JSON.stringify(metadata.toolName)} did not match expected ${JSON.stringify(expectedToolName)}.`,
+		);
+	}
+	if (messages.length === 0) {
+		return finalityInvalid("Structured output finality could not be verified because the child transcript is empty.");
+	}
+
+	let structuredOutputCallCount = 0;
+	let assistantIndex = -1;
+	let matchingAssistantToolCalls: ToolCallBlock[] = [];
+	for (let index = 0; index < messages.length; index++) {
+		const calls = toolCallBlocks(messages[index]);
+		if (calls.length === 0) continue;
+		for (const call of calls) {
+			if (call.name === metadata.toolName) {
+				structuredOutputCallCount += 1;
+			}
+		}
+		const idMatch = calls.find((call) => call.id === metadata.toolCallId);
+		if (!idMatch) continue;
+		if (idMatch.name !== metadata.toolName) {
+			return finalityInvalid(
+				`Captured structured output tool call ${JSON.stringify(metadata.toolCallId)} used tool name ${JSON.stringify(idMatch.name)} instead of ${JSON.stringify(metadata.toolName)}.`,
+			);
+		}
+		assistantIndex = index;
+		matchingAssistantToolCalls = calls;
+	}
+
+	if (structuredOutputCallCount > 1) {
+		return finalityInvalid(
+			`Captured structured output call ${JSON.stringify(metadata.toolCallId)} was not exactly once; another ${metadata.toolName} tool call appeared in the child transcript.`,
+		);
+	}
+	if (assistantIndex === -1) {
+		return finalityInvalid(
+			`No assistant tool call matched captured structured output toolCallId ${JSON.stringify(metadata.toolCallId)}.`,
+		);
+	}
+	if (matchingAssistantToolCalls.length !== 1) {
+		return finalityInvalid(
+			`Captured structured output call ${JSON.stringify(metadata.toolCallId)} was accompanied by sibling tool calls in the same assistant message.`,
+		);
+	}
+
+	let resultIndex = -1;
+	let resultMessage: StructuredOutputTranscriptMessage | undefined;
+	for (let index = assistantIndex + 1; index < messages.length; index++) {
+		const message = messages[index];
+		if (roleOf(message) !== "toolResult") continue;
+		if (message.toolCallId !== metadata.toolCallId) continue;
+		resultIndex = index;
+		resultMessage = message;
+		break;
+	}
+
+	if (!resultMessage) {
+		return finalityInvalid(
+			`No tool result matched captured structured output toolCallId ${JSON.stringify(metadata.toolCallId)}.`,
+		);
+	}
+	if (resultMessage.toolName !== metadata.toolName) {
+		return finalityInvalid(
+			`Structured output tool result for ${JSON.stringify(metadata.toolCallId)} used tool name ${JSON.stringify(resultMessage.toolName)} instead of ${JSON.stringify(metadata.toolName)}.`,
+		);
+	}
+	if (resultMessage.isError !== false) {
+		return finalityInvalid(
+			`Structured output tool result for ${JSON.stringify(metadata.toolCallId)} was an error or did not prove success.`,
+		);
+	}
+
+	for (let index = assistantIndex + 1; index < resultIndex; index++) {
+		const message = messages[index];
+		if (isFinalityRelevantMessage(message)) {
+			return finalityInvalid(
+				`Structured output call ${JSON.stringify(metadata.toolCallId)} was not final; another ${roleOf(message)} message appeared before its matching tool result.`,
+			);
+		}
+	}
+	for (let index = resultIndex + 1; index < messages.length; index++) {
+		const message = messages[index];
+		if (isFinalityRelevantMessage(message)) {
+			return finalityInvalid(
+				`Structured output call ${JSON.stringify(metadata.toolCallId)} was not final; a later ${roleOf(message)} message followed the successful tool result.`,
+			);
+		}
+	}
+
+	return { status: "valid" };
+}
+
+export function assertJsonSchemaDescriptor(schema: unknown, label = "outputSchema"): asserts schema is JsonSchemaObject {
 	if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-		throw new Error(`${label} must be a JSON Schema object.`);
+		throw new Error(`${label} must be a JSON Schema object descriptor.`);
+	}
+}
+
+export function assertStructuredOutputParameterSchema(schema: unknown, label = "outputSchema"): asserts schema is JsonSchemaObject {
+	assertJsonSchemaDescriptor(schema, label);
+	if (!isTopLevelObjectOutputSchema(schema)) {
+		throw new Error(
+			`${label} must be a top-level object tool-argument schema. `
+			+ "Wrap array or primitive outputs in an object field, for example `{ items: [...] }` or `{ value: ... }`.",
+		);
 	}
 }
 
 export function createStructuredOutputRuntime(schema: JsonSchemaObject, baseDir?: string): StructuredOutputRuntime {
-	assertJsonSchemaObject(schema);
+	assertStructuredOutputParameterSchema(schema);
 	const rootDir = baseDir ?? os.tmpdir();
 	fs.mkdirSync(rootDir, { recursive: true });
 	const dir = fs.mkdtempSync(path.join(rootDir, "pi-subagent-structured-"));
 	const schemaPath = path.join(dir, "schema.json");
 	const outputPath = path.join(dir, "output.json");
+	const metadataPath = path.join(dir, "output.meta.json");
 	fs.writeFileSync(schemaPath, JSON.stringify(schema), { mode: 0o600 });
-	return { schema, schemaPath, outputPath };
+	return { schema, schemaPath, outputPath, metadataPath };
 }
 
 export function validateStructuredOutputValue(schema: JsonSchemaObject, value: unknown): { status: "valid" } | { status: "invalid"; message: string } {
@@ -54,19 +289,45 @@ export function validateStructuredOutputValue(schema: JsonSchemaObject, value: u
 	return { status: "invalid", message: errors.join("; ") || "schema validation failed" };
 }
 
-export function readStructuredOutput(runtime: StructuredOutputRuntime): { value?: unknown; error?: string } {
+export function readStructuredOutput(
+	runtime: StructuredOutputRuntime,
+	options: ReadStructuredOutputOptions = {},
+): { value?: unknown; error?: string } {
 	if (!fs.existsSync(runtime.outputPath)) {
 		return { error: "Missing structured_output call; this step has outputSchema and must finish by calling structured_output." };
 	}
-	let value: unknown;
+	const metadataPath = runtime.metadataPath ?? getStructuredOutputMetadataPath(runtime.outputPath);
+	if (!fs.existsSync(metadataPath)) {
+		return { error: "Missing structured_output metadata sidecar; this step must finish with a verified structured_output call." };
+	}
+	let payload: JsonValue;
 	try {
-		value = JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8"));
+		payload = JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8")) as JsonValue;
 	} catch (error) {
 		return { error: `Failed to read structured output: ${error instanceof Error ? error.message : String(error)}` };
 	}
-	const validation = validateStructuredOutputValue(runtime.schema, value);
+	let rawMetadata: JsonValue;
+	try {
+		rawMetadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8")) as JsonValue;
+	} catch (error) {
+		return { error: `Failed to read structured output metadata: ${error instanceof Error ? error.message : String(error)}` };
+	}
+	const parsed = parseCaptureMetadata(rawMetadata);
+	if (parsed.error || !parsed.metadata) {
+		return { error: parsed.error ?? "Structured output metadata sidecar is invalid." };
+	}
+	const validation = validateStructuredOutputValue(runtime.schema, payload);
 	if (validation.status === "invalid") return { error: `Structured output validation failed: ${validation.message}` };
-	return { value };
+	const expectedToolName = options.toolName ?? STRUCTURED_OUTPUT_TOOL_NAME;
+	if (options.messages) {
+		const finality = verifyStructuredOutputFinality(options.messages, parsed.metadata, expectedToolName);
+		if (finality.status === "invalid") return { error: finality.message };
+	} else if (parsed.metadata.toolName !== expectedToolName) {
+		return {
+			error: `Captured structured output tool name ${JSON.stringify(parsed.metadata.toolName)} did not match expected ${JSON.stringify(expectedToolName)}.`,
+		};
+	}
+	return { value: payload };
 }
 
 export function cleanupStructuredOutputRuntime(runtime: StructuredOutputRuntime | undefined): void {

package/dist/builtin/subagents/src/runs/shared/subagent-prompt-runtime.ts

@@ -1,14 +1,12 @@
 import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ExtensionAPI } from "@bastani/atomic";
-import { getEnvValue } from "@bastani/atomic";
+import { createStructuredOutputTool, getEnvValue, type ExtensionAPI } from "@bastani/atomic";
 import {
 	SUBAGENT_FANOUT_CHILD_ENV,
 	SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV,
 	SUBAGENT_INHERIT_SKILLS_ENV,
 	SUBAGENT_INTERCOM_SESSION_NAME_ENV,
 } from "./pi-args.ts";
-import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.ts";
+import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "./structured-output.ts";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 
 export { SUBAGENT_INTERCOM_SESSION_NAME_ENV } from "./pi-args.ts";
@@ -16,6 +14,7 @@ export { SUBAGENT_INTERCOM_SESSION_NAME_ENV } from "./pi-args.ts";
 const STRUCTURED_OUTPUT_INSTRUCTIONS = [
 	"This subagent step has a strict structured output contract.",
 	"Your final action must be to call the `structured_output` tool with JSON matching the provided schema.",
+	"Pass the schema fields directly as the tool arguments; do not wrap them in `{ value: ... }` unless the schema explicitly defines a top-level `value` field.",
 	"Do not rely on prose-only completion; if you do not call `structured_output`, the parent will fail this step.",
 ].join("\n");
 
@@ -162,44 +161,18 @@ export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 	const structuredSchemaPath = process.env[STRUCTURED_OUTPUT_SCHEMA_ENV];
 	if (structuredOutputPath && structuredSchemaPath) {
 		const schema = JSON.parse(fs.readFileSync(structuredSchemaPath, "utf-8")) as JsonSchemaObject;
-		const parameters = {
-			type: "object",
-			properties: { value: schema },
-			required: ["value"],
-			additionalProperties: false,
-		};
-		const registerTool = pi.registerTool as unknown as (tool: {
-			name: string;
-			label: string;
-			description: string;
-			parameters: unknown;
-			execute: (_id: string, params: { value: unknown }) => Promise<unknown>;
-		}) => void;
-		registerTool({
-			name: "structured_output",
-			label: "Structured Output",
-			description: "Submit the required final structured output for this subagent step. This terminates the step.",
-			parameters: parameters as never,
-			async execute(_id: string, params: { value: unknown }) {
-				const validation = validateStructuredOutputValue(schema, params.value);
-				if (validation.status === "invalid") {
-					throw new Error(`Structured output validation failed: ${validation.message}`);
-				}
-				fs.mkdirSync(path.dirname(structuredOutputPath), { recursive: true });
-				fs.writeFileSync(structuredOutputPath, JSON.stringify(params.value), { mode: 0o600 });
-				return {
-					content: [{ type: "text", text: "Structured output captured." }],
-					details: { path: structuredOutputPath },
-					terminate: true,
-				};
-			},
-		});
+		pi.registerTool(createStructuredOutputTool({
+			schema,
+			output: { outputPath: structuredOutputPath },
+		}));
 	}
 
 	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: unknown) => unknown) => void;
-	onRuntimeEvent("context", (event: { messages: unknown[] }) => {
-		const messages = stripParentOnlySubagentMessages(event.messages);
-		if (messages === event.messages) return undefined;
+	onRuntimeEvent("context", (event) => {
+		const contextEvent = event as { messages?: unknown[] };
+		if (!Array.isArray(contextEvent.messages)) return undefined;
+		const messages = stripParentOnlySubagentMessages(contextEvent.messages);
+		if (messages === contextEvent.messages) return undefined;
 		return { messages };
 	});
 

package/dist/builtin/subagents/src/shared/types.ts

@@ -803,6 +803,7 @@ export interface RunSyncOptions {
 		schema: JsonSchemaObject;
 		schemaPath: string;
 		outputPath: string;
+		metadataPath: string;
 	};
 	acceptance?: AcceptanceInput;
 	acceptanceContext?: {

package/dist/builtin/subagents/src/shared/utils.ts

@@ -122,21 +122,61 @@ export function findLatestSessionFile(sessionDir: string): string | null {
 // Message Parsing Utilities
 // ============================================================================
 
+const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+
+type TextContentCandidate = {
+	type: string;
+	text?: string;
+};
+
+function getLastNonEmptyTextContent(content: readonly TextContentCandidate[]): string | undefined {
+	for (let index = content.length - 1; index >= 0; index--) {
+		const part = content[index];
+		if (part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0) {
+			return part.text;
+		}
+	}
+	return undefined;
+}
+
+function getCombinedNonEmptyTextContent(content: readonly TextContentCandidate[]): string | undefined {
+	let text = "";
+	for (const part of content) {
+		if (part.type === "text" && typeof part.text === "string") {
+			text += part.text;
+		}
+	}
+	return text.trim().length > 0 ? text : undefined;
+}
+
+function getStructuredOutputToolResultText(message: Message): string | undefined {
+	if (message.role !== "toolResult") return undefined;
+	if (message.toolName !== STRUCTURED_OUTPUT_TOOL_NAME) return undefined;
+	if (message.isError === true) return undefined;
+	return getCombinedNonEmptyTextContent(message.content);
+}
+
+function getAssistantOutputText(message: Message): string | undefined {
+	if (message.role !== "assistant") return undefined;
+	const hasAssistantError = ("errorMessage" in message && typeof message.errorMessage === "string" && message.errorMessage.length > 0)
+		|| ("stopReason" in message && message.stopReason === "error");
+	if (hasAssistantError) return undefined;
+	return getLastNonEmptyTextContent(message.content);
+}
+
 /**
  * Get the final text output from a list of messages
  */
 export function getFinalOutput(messages: Message[]): string {
+	const finalMessage = messages[messages.length - 1];
+	if (finalMessage) {
+		const finalStructuredOutput = getStructuredOutputToolResultText(finalMessage);
+		if (finalStructuredOutput !== undefined) return finalStructuredOutput;
+	}
+
 	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		if (msg.role === "assistant") {
-			const hasAssistantError = ("errorMessage" in msg && typeof msg.errorMessage === "string" && msg.errorMessage.length > 0)
-				|| ("stopReason" in msg && msg.stopReason === "error");
-			if (hasAssistantError) continue;
-			for (let j = msg.content.length - 1; j >= 0; j--) {
-				const part = msg.content[j];
-				if (part.type === "text" && part.text.trim().length > 0) return part.text;
-			}
-		}
+		const assistantOutput = getAssistantOutputText(messages[i]);
+		if (assistantOutput !== undefined) return assistantOutput;
 	}
 	return "";
 }

package/dist/builtin/subagents/src/slash/saved-chain-mapping.ts

@@ -0,0 +1,77 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ChainConfig } from "../agents/agents.ts";
+import { assertJsonSchemaDescriptor, assertStructuredOutputParameterSchema } from "../runs/shared/structured-output.ts";
+import { isDynamicParallelStep, isParallelStep, type ChainStep } from "../shared/settings.ts";
+import type { JsonSchemaObject } from "../shared/types.ts";
+
+function loadSavedOutputSchema(
+	chain: ChainConfig,
+	stepAgent: string,
+	outputSchema: unknown,
+	options: { schemaRole: "tool-parameters" | "collection" } = { schemaRole: "tool-parameters" },
+): JsonSchemaObject | undefined {
+	if (outputSchema === undefined) return undefined;
+	const labelForSchema = (schemaPath?: string): string => schemaPath
+		? `outputSchema for chain '${chain.name}' step '${stepAgent}' (${schemaPath})`
+		: `outputSchema for chain '${chain.name}' step '${stepAgent}'`;
+	const validateSavedSchema = (schema: unknown, label: string): JsonSchemaObject => {
+		if (options.schemaRole === "collection") {
+			assertJsonSchemaDescriptor(schema, label);
+		} else {
+			assertStructuredOutputParameterSchema(schema, label);
+		}
+		return schema;
+	};
+	if (typeof outputSchema === "string") {
+		const schemaPath = path.isAbsolute(outputSchema)
+			? outputSchema
+			: path.join(path.dirname(chain.filePath), outputSchema);
+		const parsed = JSON.parse(fs.readFileSync(schemaPath, "utf-8")) as unknown;
+		return validateSavedSchema(parsed, labelForSchema(schemaPath));
+	}
+	return validateSavedSchema(outputSchema, labelForSchema());
+}
+
+export function mapSavedChainSteps(chain: ChainConfig, worktree = false): ChainStep[] {
+	return (chain.steps as unknown as Array<ChainStep & { skills?: string[] | false }>).map((step) => {
+		if (isParallelStep(step)) {
+			const parallel = step.parallel.map((task) => {
+				const { outputSchema: rawOutputSchema, ...rest } = task as typeof task & { outputSchema?: unknown };
+				const outputSchema = loadSavedOutputSchema(chain, task.agent, rawOutputSchema);
+				return { ...rest, ...(outputSchema ? { outputSchema } : {}) };
+			});
+			return { ...step, parallel, ...(worktree ? { worktree: true } : {}) };
+		}
+		if (isDynamicParallelStep(step)) {
+			const { outputSchema: rawOutputSchema, ...parallelRest } = step.parallel as typeof step.parallel & { outputSchema?: unknown };
+			const outputSchema = loadSavedOutputSchema(chain, step.parallel.agent, rawOutputSchema);
+			const collectSchema = loadSavedOutputSchema(
+				chain,
+				`${step.collect.as} collection`,
+				step.collect.outputSchema,
+				{ schemaRole: "collection" },
+			);
+			return {
+				...step,
+				parallel: { ...parallelRest, ...(outputSchema ? { outputSchema } : {}) },
+				collect: { ...step.collect, ...(collectSchema ? { outputSchema: collectSchema } : {}) },
+			};
+		}
+		const outputSchema = loadSavedOutputSchema(chain, step.agent, (step as { outputSchema?: unknown }).outputSchema);
+		return {
+			agent: step.agent,
+			task: step.task || undefined,
+			...(step.phase ? { phase: step.phase } : {}),
+			...(step.label ? { label: step.label } : {}),
+			...(step.as ? { as: step.as } : {}),
+			...(outputSchema ? { outputSchema } : {}),
+			output: step.output,
+			outputMode: step.outputMode,
+			reads: step.reads,
+			progress: step.progress,
+			skill: step.skill ?? step.skills,
+			model: step.model,
+		};
+	});
+}

package/dist/builtin/subagents/src/slash/slash-commands.ts

@@ -5,8 +5,7 @@ import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import { Key, matchesKey } from "@earendil-works/pi-tui";
 import { discoverAgents, discoverAgentsAll, type ChainConfig } from "../agents/agents.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import { isDynamicParallelStep, isParallelStep, type ChainStep } from "../shared/settings.ts";
-import { assertJsonSchemaObject } from "../runs/shared/structured-output.ts";
+import { mapSavedChainSteps } from "./saved-chain-mapping.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import {
 	applySlashUpdate,
@@ -21,7 +20,6 @@ import {
 	SLASH_SUBAGENT_RESPONSE_EVENT,
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
-	type JsonSchemaObject,
 	type SingleResult,
 	type SubagentState,
 } from "../shared/types.ts";
@@ -125,58 +123,6 @@ const makeChainCompletions = (state: SubagentState) => (prefix: string) => {
 		.map((chain) => ({ value: chain.name, label: chain.name }));
 };
 
-function loadSavedOutputSchema(chain: ChainConfig, stepAgent: string, outputSchema: unknown): JsonSchemaObject | undefined {
-	if (outputSchema === undefined) return undefined;
-	if (typeof outputSchema === "string") {
-		const schemaPath = path.isAbsolute(outputSchema)
-			? outputSchema
-			: path.join(path.dirname(chain.filePath), outputSchema);
-		const parsed = JSON.parse(fs.readFileSync(schemaPath, "utf-8")) as unknown;
-		assertJsonSchemaObject(parsed, `outputSchema for chain '${chain.name}' step '${stepAgent}' (${schemaPath})`);
-		return parsed;
-	}
-	assertJsonSchemaObject(outputSchema, `outputSchema for chain '${chain.name}' step '${stepAgent}'`);
-	return outputSchema;
-}
-
-const mapSavedChainSteps = (chain: ChainConfig, worktree = false): ChainStep[] => {
-	return (chain.steps as unknown as Array<ChainStep & { skills?: string[] | false }>).map((step) => {
-		if (isParallelStep(step)) {
-			const parallel = step.parallel.map((task) => {
-				const { outputSchema: rawOutputSchema, ...rest } = task as typeof task & { outputSchema?: unknown };
-				const outputSchema = loadSavedOutputSchema(chain, task.agent, rawOutputSchema);
-				return { ...rest, ...(outputSchema ? { outputSchema } : {}) };
-			});
-			return { ...step, parallel, ...(worktree ? { worktree: true } : {}) };
-		}
-		if (isDynamicParallelStep(step)) {
-			const { outputSchema: rawOutputSchema, ...parallelRest } = step.parallel as typeof step.parallel & { outputSchema?: unknown };
-			const outputSchema = loadSavedOutputSchema(chain, step.parallel.agent, rawOutputSchema);
-			const collectSchema = loadSavedOutputSchema(chain, `${step.collect.as} collection`, step.collect.outputSchema);
-			return {
-				...step,
-				parallel: { ...parallelRest, ...(outputSchema ? { outputSchema } : {}) },
-				collect: { ...step.collect, ...(collectSchema ? { outputSchema: collectSchema } : {}) },
-			};
-		}
-		const outputSchema = loadSavedOutputSchema(chain, step.agent, (step as { outputSchema?: unknown }).outputSchema);
-		return {
-			agent: step.agent,
-			task: step.task || undefined,
-			...(step.phase ? { phase: step.phase } : {}),
-			...(step.label ? { label: step.label } : {}),
-			...(step.as ? { as: step.as } : {}),
-			...(outputSchema ? { outputSchema } : {}),
-			output: step.output,
-			outputMode: step.outputMode,
-			reads: step.reads,
-			progress: step.progress,
-			skill: step.skill ?? step.skills,
-			model: step.model,
-		};
-	});
-};
-
 async function requestSlashRun(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,

package/dist/builtin/web-access/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### Changed
+
+- Published a synchronized Atomic 0.8.29-alpha.1 prerelease with the upstream pi TUI dependency aligned to `^0.79.3`; no functional changes were made in the web-access extension.
+
 ## [0.8.28] - 2026-06-11
 
 ### Changed
@@ -434,7 +438,7 @@ All notable changes to this project will be documented in this file.
 ## [0.5.0] - 2026-02-01
 
 ### Added
-- GitHub repository clone extraction for `fetch_content` -- detects GitHub code URLs, clones repos to `/tmp/pi-github-repos/`, and returns actual file contents plus local path for further exploration with `read` and `bash`
+- GitHub repository clone extraction for `fetch_content` -- detects GitHub code URLs, clones repos to `/tmp/atomic-github-repos/`, and returns actual file contents plus local path for further exploration with `read` and `bash`
 - Lightweight API fallback for oversized repos (>350MB) and commit SHA URLs via `gh api`
 - Clone cache with concurrent request deduplication (second request awaits first's clone)
 - `forceClone` parameter on `fetch_content` to override the size threshold

package/dist/builtin/web-access/README.md

@@ -265,7 +265,7 @@ All config lives in `~/.pi/web-search.json`. Every field is optional.
     "enabled": true,
     "maxRepoSizeMB": 350,
     "cloneTimeoutSeconds": 30,
-    "clonePath": "/tmp/pi-github-repos"
+    "clonePath": "/tmp/atomic-github-repos"
   },
   "youtube": {
     "enabled": true,