@bastani/atomic 0.9.11-alpha.9 → 0.9.11

package/dist/builtin/workflows/src/runs/foreground/stage-runner-context.ts

@@ -2,7 +2,12 @@ import { createStructuredOutputCapture, runCallback } from "@bastani/atomic";
 import type { StageExecutionMeta } from "../../shared/types.js";
 import { StageSessionController } from "./stage-runner-controller.js";
 import { assistantMessage } from "./stage-runner-messages.js";
-import { finalizePromptOutput, splitPromptOptions, validatePromptOutputOptions } from "./stage-runner-output.js";
+import {
+	finalizePromptOutput,
+	splitPromptOptions,
+	stageOutputInstruction,
+	validatePromptOutputOptions,
+} from "./stage-runner-output.js";
 import {
 	formatStructuredOutputCorrectionPrompt,
 	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
@@ -27,18 +32,31 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
 	};
 	const controller = new StageSessionController(opts, meta, effectiveStageOptions, structuredOutputCapture);
 	let lastAssistantText: string | undefined;
+	let lastFinalizedOutput: string | undefined;
+	let lastFinalizedMessageCount: number | undefined;
 	let adapterMessages = [] as InternalStageContext["messages"];
 
 	function runtimeCwd(): string {
 		return typeof effectiveStageOptions?.cwd === "string" ? effectiveStageOptions.cwd : process.cwd();
 	}
 
+	function finalizedOutputIsCurrent(): boolean {
+		return (
+			lastFinalizedOutput !== undefined &&
+			(lastFinalizedMessageCount === undefined ||
+				controller.currentSession?.messages.length === lastFinalizedMessageCount)
+		);
+	}
+
 	return {
 		name: stageName,
 
 		async prompt(text, options) {
 			const { sdkOptions, outputOptions } = splitPromptOptions(options);
 			validatePromptOutputOptions(outputOptions);
+			// The runtime owns the artifact write, so it states that contract itself
+			// rather than relying on every workflow definition to describe it.
+			const promptText = `${text}${stageOutputInstruction(outputOptions)}`;
 			if (structuredOutputCapture?.called) {
 				throw new Error(
 					"atomic-workflows: stage schema supports one prompt() call per stage context because structured_output may be called exactly once. Create a new ctx.stage(...) for each additional schema-backed prompt.",
@@ -52,14 +70,22 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
 				}
 				const rawText = await runCallback(
 					{ kind: "workflow.stage_adapter", name: `prompt:${stageName}`, runId, stageId },
-					() => adapters.prompt!.prompt(text, meta),
+					() => adapters.prompt!.prompt(promptText, meta),
 				);
-				lastAssistantText = await finalizePromptOutput(rawText, outputOptions, runtimeCwd());
-				adapterMessages = assistantMessage(lastAssistantText);
+				adapterMessages = assistantMessage(rawText);
+				lastAssistantText = await finalizePromptOutput(
+					rawText,
+					outputOptions,
+					runtimeCwd(),
+					runId,
+					adapterMessages,
+				);
+				lastFinalizedOutput = lastAssistantText;
+				lastFinalizedMessageCount = controller.currentSession?.messages.length;
 				return lastAssistantText;
 			}
 			if (structuredOutputCapture) {
-				let nextPrompt = text;
+				let nextPrompt = promptText;
 				let correctiveAttempts = 0;
 				let structuredOutputError = STRUCTURED_OUTPUT_MISSING_ERROR;
 				while (!structuredOutputCapture.called) {
@@ -74,17 +100,35 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
 					nextPrompt = formatStructuredOutputCorrectionPrompt(structuredOutputError, correctiveAttempts);
 				}
 				const rawStructuredText = stringifyStructuredOutputValue(structuredOutputCapture.value);
-				lastAssistantText = await finalizePromptOutput(rawStructuredText, outputOptions, runtimeCwd());
+				lastAssistantText = await finalizePromptOutput(
+					rawStructuredText,
+					outputOptions,
+					runtimeCwd(),
+					runId,
+					controller.currentSession?.messages,
+				);
+				lastFinalizedOutput = lastAssistantText;
+				lastFinalizedMessageCount = controller.currentSession?.messages.length;
 				return structuredOutputCapture.value as never;
 			}
-			await controller.promptWithFallback(text, sdkOptions);
+			await controller.promptWithFallback(promptText, sdkOptions);
 			const rawText = controller.lastAssistantText(lastAssistantText) ?? "";
-			lastAssistantText = await finalizePromptOutput(rawText, outputOptions, runtimeCwd());
+			lastAssistantText = await finalizePromptOutput(
+				rawText,
+				outputOptions,
+				runtimeCwd(),
+				runId,
+				controller.currentSession?.messages,
+			);
+			lastFinalizedOutput = lastAssistantText;
+			lastFinalizedMessageCount = controller.currentSession?.messages.length;
 			return lastAssistantText;
 		},
 
 		async complete(text, completeOpts) {
 			if (adapters.complete) {
+				lastFinalizedOutput = undefined;
+				lastFinalizedMessageCount = undefined;
 				lastAssistantText = await runCallback(
 					{ kind: "workflow.stage_adapter", name: `complete:${stageName}`, runId, stageId },
 					() => adapters.complete!.complete(text, completeOpts, meta),
@@ -102,6 +146,8 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
 				);
 			}
 			await controller.promptWithFallback(text, undefined, "complete");
+			lastFinalizedOutput = undefined;
+			lastFinalizedMessageCount = undefined;
 			lastAssistantText = controller.lastAssistantText(lastAssistantText) ?? "";
 			return lastAssistantText;
 		},
@@ -195,11 +241,11 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
 		},
 
 		__getLastAssistantText() {
-			return controller.lastAssistantText(lastAssistantText);
+			return finalizedOutputIsCurrent() ? lastFinalizedOutput : controller.lastAssistantText(lastAssistantText);
 		},
 
 		getLastAssistantText() {
-			return controller.lastAssistantText(lastAssistantText);
+			return finalizedOutputIsCurrent() ? lastFinalizedOutput : controller.lastAssistantText(lastAssistantText);
 		},
 
 		async __ensureSession() {

package/dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts

@@ -65,6 +65,7 @@ export class StageSessionController {
 	private activeCreation: Promise<StageSessionRuntime> | undefined;
 	private sessionPromise: Promise<StageSessionRuntime> | undefined;
 	private reattachSessionFile: string | undefined;
+	private lastPromptStartIndex: number | undefined;
 	private readonly terminatingToolCallIds = new Set<string>();
 	private latestStructuredOutputToolErrorValue: string | undefined;
 	private unsubscribeTerminateWatcher: (() => void) | undefined;
@@ -116,6 +117,10 @@ export class StageSessionController {
 		return this.session;
 	}
 
+	get currentPromptStartIndex(): number | undefined {
+		return this.lastPromptStartIndex;
+	}
+
 	get latestStructuredOutputToolError(): string | undefined {
 		return this.latestStructuredOutputToolErrorValue;
 	}
@@ -478,6 +483,7 @@ export class StageSessionController {
 				continue;
 			}
 			const promptStartIndex = activeSession.messages.length;
+			this.lastPromptStartIndex = promptStartIndex;
 			this.unresolvedContextOverflowMessage = undefined;
 			try {
 				await activeSession.prompt(nextText, sdkOptions);

package/dist/builtin/workflows/src/runs/foreground/stage-runner-output.ts

@@ -1,11 +1,29 @@
+import { createHash } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, resolve } from "node:path";
-import type { PromptOptions } from "@bastani/atomic";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import type { AgentSession, PromptOptions } from "@bastani/atomic";
 import type { StageOutputOptions, StagePromptOptions, WorkflowMaxOutput } from "../../shared/types.js";
+import { ensureWorkflowArtifactRunDirectory, workflowArtifactRunPath } from "../../shared/workflow-artifacts.js";
 
 const DEFAULT_MAX_OUTPUT_BYTES = 200 * 1024;
 const DEFAULT_MAX_OUTPUT_LINES = 5000;
 
+type TranscriptContentBlock = {
+	readonly type?: string;
+	readonly text?: string;
+	readonly name?: string;
+	readonly id?: string;
+};
+
+type TranscriptMessage = {
+	readonly role?: string;
+	readonly content?: string | readonly TranscriptContentBlock[];
+	readonly customType?: string;
+	readonly stageAdmissionKey?: string;
+	readonly toolCallId?: string;
+	readonly toolName?: string;
+};
+
 function normalizeMaxOutput(maxOutput: WorkflowMaxOutput | undefined): Required<WorkflowMaxOutput> {
 	return {
 		bytes: maxOutput?.bytes ?? DEFAULT_MAX_OUTPUT_BYTES,
@@ -45,7 +63,7 @@ function truncateOutput(text: string, maxOutput: WorkflowMaxOutput | undefined):
 function countLines(text: string): number {
 	if (!text) return 0;
 	const newlineMatches = text.match(/\r\n|\r|\n/g);
-	return (newlineMatches?.length ?? 0) + (/[\r\n]$/.test(text) ? 0 : 1);
+	return (newlineMatches?.length ?? 0) + (text.endsWith("\n") || text.endsWith("\r") ? 0 : 1);
 }
 
 function formatByteSize(bytes: number): string {
@@ -60,11 +78,68 @@ function formatByteSize(bytes: number): string {
 	return `${value.toFixed(1)} ${units[unitIndex]}`;
 }
 
-function savedOutputReference(outputPath: string, fullOutput: string): string {
+function transcriptPath(runId: string, outputPath: string): string {
+	const digest = createHash("sha256").update(outputPath).digest("hex").slice(0, 16);
+	return join(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename(outputPath)}.transcript.md`);
+}
+
+function appendContent(lines: string[], content: TranscriptMessage["content"]): void {
+	if (typeof content === "string") {
+		lines.push(content);
+		return;
+	}
+	if (!Array.isArray(content)) return;
+	for (const block of content) {
+		if (block.type === "text" && typeof block.text === "string") {
+			lines.push(block.text);
+			continue;
+		}
+		const serialized = JSON.stringify(block);
+		if (serialized !== undefined) lines.push(serialized);
+	}
+}
+
+function renderTranscript(messages: AgentSession["messages"] | undefined, fallbackOutput: string): string {
+	const lines = ["# Workflow stage transcript", ""];
+	for (const [index, message] of (messages ?? []).entries()) {
+		const record = message as TranscriptMessage;
+		const role = typeof record.role === "string" ? record.role : "message";
+		lines.push(`## ${index + 1} ${role}`);
+		if (typeof record.customType === "string") lines.push(`customType: ${record.customType}`);
+		if (typeof record.stageAdmissionKey === "string") lines.push(`stageAdmissionKey: ${record.stageAdmissionKey}`);
+		if (typeof record.toolName === "string") lines.push(`toolName: ${record.toolName}`);
+		if (typeof record.toolCallId === "string") lines.push(`toolCallId: ${record.toolCallId}`);
+		appendContent(lines, record.content);
+		lines.push("");
+	}
+	if ((messages?.length ?? 0) === 0) {
+		lines.push("## 1 assistant");
+		lines.push(fallbackOutput);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+
+function savedOutputReference(
+	outputPath: string,
+	fullOutput: string,
+	transcriptPathValue: string,
+	transcriptText: string,
+	transcriptAvailable: boolean,
+	warning?: string,
+): string {
 	const absolutePath = resolve(outputPath);
 	const bytes = Buffer.byteLength(fullOutput, "utf8");
 	const lines = countLines(fullOutput);
-	return `Output saved to: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}). Read this file if needed.`;
+	const transcriptBytes = Buffer.byteLength(transcriptText, "utf8");
+	const transcriptLines = countLines(transcriptText);
+	const outputReference = `Output saved to: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}). Read this file if needed.`;
+	const transcriptReference = transcriptAvailable
+		? `Transcript saved to: ${transcriptPathValue} (${formatByteSize(transcriptBytes)}, ${transcriptLines} ${transcriptLines === 1 ? "line" : "lines"}). Search it with rg, read narrow line ranges, and do not read it whole.`
+		: `Transcript unavailable at: ${transcriptPathValue}. Search it with rg when it becomes available, read narrow line ranges, and do not read it whole.`;
+	return [outputReference, transcriptReference, warning]
+		.filter((line): line is string => line !== undefined)
+		.join("\n");
 }
 
 function resolveOutputPath(
@@ -83,6 +158,19 @@ function resolveOutputPath(
 	return resolve(baseCwd, output);
 }
 
+/**
+ * Report only what can be observed, never what the text appears to mean.
+ *
+ * An empty artifact is a fact. Whether a non-empty artifact is "really" a
+ * pointer, an acknowledgement, or a deliverable is an inference this code
+ * cannot make, so it does not try: the companion transcript named in every
+ * receipt is the recovery path for anything that looks wrong to a reader.
+ */
+function degenerateWarning(fullOutput: string): string | undefined {
+	return fullOutput.trim().length === 0
+		? "WARNING: the stage artifact is empty; search the companion transcript for this stage's work."
+		: undefined;
+}
 export function splitPromptOptions(options: StagePromptOptions | undefined): {
 	sdkOptions: PromptOptions | undefined;
 	outputOptions: StageOutputOptions;
@@ -122,23 +210,66 @@ export function validatePromptOutputOptions(outputOptions: StageOutputOptions):
 	}
 }
 
+/**
+ * Instruction appended to any prompt whose stage configures `output:`.
+ *
+ * The runtime owns the artifact write, so the prompt author should not have to
+ * describe that plumbing — or remember to. Without this, a stage can end with
+ * "done, see the file" and persist that sentence as its deliverable, which is a
+ * foot-gun the workflow definition cannot see.
+ */
+export function stageOutputInstruction(outputOptions: StageOutputOptions): string {
+	if (typeof outputOptions.output !== "string" || outputOptions.output.length === 0) return "";
+	return "\n\n[This stage's final message is saved verbatim as its artifact and is what later stages read. Return the complete result in that message rather than a pointer to it. Files you write yourself are not the artifact.]";
+}
+
 export async function finalizePromptOutput(
 	fullOutput: string,
 	outputOptions: StageOutputOptions,
 	runtimeCwd: string,
+	runId: string,
+	messages?: AgentSession["messages"],
 ): Promise<string> {
 	const outputPath = resolveOutputPath(outputOptions.output, runtimeCwd, outputOptions.cwd);
 	validatePromptOutputOptions(outputOptions);
 	const displayOutput = truncateOutput(fullOutput, outputOptions.maxOutput);
 	if (outputPath === undefined) return displayOutput;
 
+	const transcriptFile = transcriptPath(runId, outputPath);
+	const transcript = renderTranscript(messages, fullOutput);
 	try {
 		await mkdir(dirname(outputPath), { recursive: true });
 		await writeFile(outputPath, fullOutput, "utf8");
 	} catch (err) {
 		return `${displayOutput}\n\nOutput file error: ${outputPath}\n${err instanceof Error ? err.message : String(err)}`;
 	}
+	let transcriptAvailable = false;
+	let transcriptError: string | undefined;
+	try {
+		await ensureWorkflowArtifactRunDirectory(runId);
+		await mkdir(dirname(transcriptFile), { recursive: true });
+		await writeFile(transcriptFile, transcript, "utf8");
+		transcriptAvailable = true;
+	} catch (err) {
+		transcriptError = err instanceof Error ? err.message : String(err);
+	}
 
-	const reference = savedOutputReference(outputPath, fullOutput);
+	const warning =
+		[
+			transcriptError === undefined
+				? undefined
+				: `WARNING: companion transcript unavailable at ${transcriptFile}: ${transcriptError}`,
+			degenerateWarning(fullOutput),
+		]
+			.filter((line): line is string => line !== undefined)
+			.join("\n") || undefined;
+	const reference = savedOutputReference(
+		outputPath,
+		fullOutput,
+		transcriptFile,
+		transcript,
+		transcriptAvailable,
+		warning,
+	);
 	return outputOptions.outputMode === "file-only" ? reference : `${displayOutput}\n\n${reference}`;
 }

package/dist/builtin/workflows/src/shared/authoring-contract-ui.d.ts

@@ -46,6 +46,8 @@ export interface WorkflowUIAdapter {
 }
 export interface WorkflowRunContext<TInputs extends WorkflowInputValues = WorkflowInputValues, TDefinitionBrand extends object = Record<never, never>, TOutputs extends WorkflowOutputValues = WorkflowOutputValues> {
     readonly inputs: Readonly<TInputs>;
+    /** Stable owning workflow-run id for durable run-scoped artifacts. */
+    readonly runId?: string;
     readonly cwd?: string;
     exit(options?: WorkflowExitOptions<TOutputs>): never;
     stage<TSchemaDef extends TSchema>(name: string, options: StageOptions<TSchemaDef> & {

package/dist/builtin/workflows/src/shared/authoring-contract-ui.ts

@@ -88,6 +88,8 @@ export interface WorkflowRunContext<
 	TOutputs extends WorkflowOutputValues = WorkflowOutputValues,
 > {
 	readonly inputs: Readonly<TInputs>;
+	/** Stable owning workflow-run id for durable run-scoped artifacts. */
+	readonly runId?: string;
 	readonly cwd?: string;
 	exit(options?: WorkflowExitOptions<TOutputs>): never;
 	stage<TSchemaDef extends TSchema>(

package/dist/builtin/workflows/src/shared/expanded-workflow-graph.ts

@@ -255,6 +255,157 @@ export function expandWorkflowGraph(snapshot: StoreSnapshot, rootRunId: string):
 	};
 }
 
+function sameIds(left: readonly string[], right: readonly string[]): boolean {
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) {
+		if (left[index] !== right[index]) return false;
+	}
+	return true;
+}
+
+interface RefreshRunSources {
+	readonly run: RunSnapshot;
+	readonly stages: ReadonlyMap<string, StageSnapshot>;
+	readonly tools: ReadonlyMap<string, ToolNodeSnapshot>;
+}
+
+function refreshRunSources(snapshot: StoreSnapshot): Map<string, RefreshRunSources> {
+	return new Map(
+		snapshot.runs.map((run) => [
+			run.id,
+			{
+				run,
+				stages: new Map(run.stages.map((stage) => [stage.id, stage])),
+				tools: new Map((run.toolNodes ?? []).map((tool) => [tool.id, tool])),
+			},
+		]),
+	);
+}
+
+export function sameExpandedWorkflowTopology(left: StoreSnapshot, right: StoreSnapshot): boolean {
+	if (left.runs.length !== right.runs.length) return false;
+	for (let runIndex = 0; runIndex < left.runs.length; runIndex++) {
+		const a = left.runs[runIndex]!;
+		const b = right.runs[runIndex]!;
+		if (
+			a.id !== b.id ||
+			a.parentRunId !== b.parentRunId ||
+			a.parentStageId !== b.parentStageId ||
+			a.rootRunId !== b.rootRunId ||
+			a.stages.length !== b.stages.length ||
+			(a.toolNodes?.length ?? 0) !== (b.toolNodes?.length ?? 0)
+		)
+			return false;
+		for (let stageIndex = 0; stageIndex < a.stages.length; stageIndex++) {
+			const x = a.stages[stageIndex]!;
+			const y = b.stages[stageIndex]!;
+			const xChildRunId = authoritativeWorkflowChildRunId(x);
+			const yChildRunId = authoritativeWorkflowChildRunId(y);
+			if (
+				x.id !== y.id ||
+				x.executionOrder !== y.executionOrder ||
+				x.nodeKind !== y.nodeKind ||
+				// The authoritative id becomes undefined at failed/skipped boundaries,
+				// so this comparison also catches a terminal-boundary flip.
+				xChildRunId !== yChildRunId ||
+				!sameIds(x.parentIds, y.parentIds)
+			)
+				return false;
+		}
+		const aTools = a.toolNodes ?? [];
+		const bTools = b.toolNodes ?? [];
+		for (let toolIndex = 0; toolIndex < aTools.length; toolIndex++) {
+			const x = aTools[toolIndex]!;
+			const y = bTools[toolIndex]!;
+			if (x.id !== y.id || x.executionOrder !== y.executionOrder || !sameIds(x.parentIds, y.parentIds)) return false;
+		}
+	}
+	return true;
+}
+
+export function refreshExpandedWorkflowGraph(
+	graph: ExpandedWorkflowGraph,
+	snapshot: StoreSnapshot,
+): ExpandedWorkflowGraph | undefined {
+	const sourcesByRunId = refreshRunSources(snapshot);
+	const refreshedStages = new Map<string, ExpandedWorkflowStage>();
+	const refreshedTools = new Map<string, ExpandedWorkflowTool>();
+	const renderStages: ExpandedWorkflowStage[] = [];
+
+	for (const cached of graph.renderStages) {
+		const target = graph.targets.get(cached.id);
+		const sources = target ? sourcesByRunId.get(target.runId) : undefined;
+		if (!target || !sources) return undefined;
+		if (cached.nodeKind === "tool") {
+			const source = sources.tools.get(target.stageId);
+			if (!source) return undefined;
+			const stage: ExpandedWorkflowStage = {
+				id: cached.id,
+				name: source.name,
+				status: projectedToolStatus(source),
+				parentIds: cached.parentIds,
+				executionOrder: source.executionOrder,
+				nodeKind: "tool",
+				toolStatus: source.status,
+				startedAt: source.startedAt,
+				endedAt: source.endedAt,
+				result: source.resultSummary,
+				error: source.error,
+				toolEvents: [],
+				attachable: false,
+				workflowGraphTarget: target,
+			};
+			renderStages.push(stage);
+			refreshedStages.set(stage.id, stage);
+			continue;
+		}
+		const source = sources.stages.get(target.stageId);
+		if (!source) return undefined;
+		const stage: ExpandedWorkflowStage = {
+			...source,
+			id: cached.id,
+			parentIds: cached.parentIds,
+			workflowGraphTarget: target,
+		};
+		renderStages.push(stage);
+		refreshedStages.set(stage.id, stage);
+	}
+
+	const stages = renderStages.filter((stage) => stage.nodeKind !== "tool");
+	const tools: ExpandedWorkflowTool[] = [];
+
+	for (const cached of graph.tools) {
+		const target = graph.targets.get(cached.id);
+		const sources = target ? sourcesByRunId.get(target.runId) : undefined;
+		const source = target ? sources?.tools.get(target.stageId) : undefined;
+		if (!target || !sources || !source) return undefined;
+		const tool: ExpandedWorkflowTool = {
+			...source,
+			id: cached.id,
+			parentIds: cached.parentIds,
+			runId: sources.run.id,
+			runName: sources.run.name,
+			depth: target.depth,
+		};
+		tools.push(tool);
+		refreshedTools.set(tool.id, tool);
+	}
+
+	const nodes: ExpandedWorkflowNode[] = [];
+	for (const node of graph.nodes) {
+		if (node.kind === "stage") {
+			const stage = refreshedStages.get(node.stage.id);
+			if (!stage) return undefined;
+			nodes.push({ kind: "stage", stage });
+			continue;
+		}
+		const tool = refreshedTools.get(node.tool.id);
+		if (!tool) return undefined;
+		nodes.push({ kind: "tool", tool });
+	}
+	return { stages, tools, nodes, renderStages, targets: graph.targets };
+}
+
 export function expandedStageTarget(
 	graph: ExpandedWorkflowGraph,
 	virtualStageIdValue: string,
@@ -262,24 +413,22 @@ export function expandedStageTarget(
 	return graph.targets.get(virtualStageIdValue);
 }
 
+/**
+ * Exact-match only. A stage id is never truncated to address a stage: at the
+ * root that id is a bare UUID, nested it is the `runId:nodeId` composite built
+ * by `virtualNodeId`, and a tool node carries `tool:<argsHash>`. Names match
+ * whole, so `build` never selects `build-check`.
+ */
 export function stageMatchesExpandedIdentifier(stage: ExpandedWorkflowStage, target: string): boolean {
 	const graphTarget = stage.workflowGraphTarget;
 	return (
-		stage.id === target ||
-		stage.name === target ||
-		stage.id.startsWith(target) ||
-		graphTarget.stageId === target ||
-		graphTarget.stageId.startsWith(target) ||
-		graphTarget.runId === target ||
-		graphTarget.runId.startsWith(target)
+		stage.id === target || stage.name === target || graphTarget.stageId === target || graphTarget.runId === target
 	);
 }
 
 export function expandedStageLabel(stage: ExpandedWorkflowStage): string {
 	const target = stage.workflowGraphTarget;
 	if (stage.nodeKind === "tool") return `${stage.name} (tool)`;
-	const runPrefix = target.runId.slice(0, 8);
-	const stagePrefix = target.stageId.slice(0, 8);
 	const depthPrefix = target.depth > 0 ? `${childAliasFor(stage) ?? target.runName}:` : "";
-	return `${depthPrefix}${stage.name} (${runPrefix}/${stagePrefix})`;
+	return `${depthPrefix}${stage.name} (${target.runId}/${target.stageId})`;
 }

package/dist/builtin/workflows/src/shared/flat-string.ts

@@ -0,0 +1,33 @@
+/**
+ * Truncation that actually releases the untruncated source.
+ *
+ * V8 does not copy characters for `String.prototype.slice`. For a flat parent of
+ * 13 characters or more it allocates a **SlicedString**, which is a length, an
+ * offset, and a pointer to the parent. Template interpolation then wraps that in
+ * a **ConsString**, which keeps the same pointer. So the obvious way to bound a
+ * value for storage:
+ *
+ * ```ts
+ * `${JSON.stringify(value).slice(0, 237)}...`
+ * ```
+ *
+ * produces a 240-character string that reports `length === 240` while holding
+ * the entire serialized payload alive. The bound is on what you can read, not on
+ * what you retain. An 8 MiB tool result summarized to 240 characters still costs
+ * 8 MiB for as long as anything keeps the summary.
+ *
+ * That is invisible in every ordinary test: the value is correct, its length is
+ * correct, and equality holds. It only shows up as heap that never comes back.
+ *
+ * `split("").join("")` copies the code units into a fresh flat string with no
+ * parent pointer. It is code-unit exact, including lone surrogates, because
+ * `split("")` splits on UTF-16 code units rather than code points.
+ *
+ * Use this at any truncation whose result outlives the value it came from —
+ * memoized projections, durable checkpoints, catalogs, persisted summaries.
+ * A truncation that is consumed and dropped within the same turn does not need
+ * it, and paying for a copy there is waste.
+ */
+export function flattenTruncatedString(value: string): string {
+	return value.split("").join("");
+}