pi-subagents 0.65.0 → 0.66.0

package/src/runs/foreground/workflow-detach-reconcile.ts

@@ -94,7 +94,7 @@ function workflowResultChildren(status: AsyncStatus, childRunId: string, result:
 	}));
 }
 
-function reconcileWorkflowReceipt(status: AsyncStatus, childRunId: string, result: SingleResult, asyncDir: string, resolution: WorkflowTerminalResolution | undefined): WorkflowReceipt | undefined {
+function reconcileWorkflowReceipt(status: AsyncStatus, childRunId: string, result: SingleResult, asyncDir: string, resolution: WorkflowTerminalResolution | undefined): { receipt: WorkflowReceipt; path: string } | undefined {
 	const receiptRoot = path.dirname(asyncDir);
 	const receiptPath = workflowReceiptPath(receiptRoot, status.runId);
 	if (!fs.existsSync(receiptPath)) return undefined;
@@ -155,8 +155,7 @@ function reconcileWorkflowReceipt(status: AsyncStatus, childRunId: string, resul
 		delete next.workflowResolution;
 		delete next.recovery;
 	}
-	writeWorkflowReceipt(asyncDir, next);
-	return next;
+	return { receipt: next, path: writeWorkflowReceipt(asyncDir, next) };
 }
 
 function appendDetachedWorkflowEvent(asyncDir: string, event: Record<string, unknown>): void {
@@ -209,10 +208,13 @@ export function reconcileDetachedWorkflowChildCompletion(input: {
 		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
 	}
 	let receipt: WorkflowReceipt | undefined;
+	let receiptPath: string | undefined;
 	let receiptError: string | undefined;
 	const resolution = classifyWorkflowSettlement(next, input.result.interrupted);
 	try {
-		receipt = reconcileWorkflowReceipt(next, input.childRunId, input.result, asyncDir, resolution);
+		const publication = reconcileWorkflowReceipt(next, input.childRunId, input.result, asyncDir, resolution);
+		receipt = publication?.receipt;
+		receiptPath = publication?.path;
 	} catch (error) {
 		receiptError = `Failed to reconcile async workflow receipt: ${error instanceof Error ? error.message : String(error)}`;
 	}
@@ -243,7 +245,7 @@ export function reconcileDetachedWorkflowChildCompletion(input: {
 			completionOwnerId: next.completionOwnerId,
 		},
 		receipt,
-		receiptPath: path.join(asyncDir, "workflow-receipt.json"),
+		receiptPath,
 		receiptPersistenceError: receiptError,
 		resolution,
 		terminalOutcome: receipt?.terminalOutcome,
@@ -283,6 +285,7 @@ export function reconcileDetachedWorkflowChildCompletion(input: {
 			agent: "workflow",
 			success: plan.status.state === "complete",
 			state: plan.status.state,
+			...(plan.publicResult.workflowReceipt ? { workflowReceipt: plan.publicResult.workflowReceipt } : {}),
 			...(resolution ? { workflowResolution: resolution } : {}),
 			...(plan.receipt?.terminalOutcome ? { terminalOutcome: plan.receipt.terminalOutcome } : {}),
 			recovery: plan.recovery,

package/src/runs/foreground/workflow-foreground-steering.ts

@@ -3,8 +3,9 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Details, ForegroundRunControl, SubagentState } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { steeringReceipt } from "../background/steering.ts";
-import type { SteerDeliveryMode } from "../background/control-channel.ts";
+import { steeringReceipt, waitForSteeringAction } from "../background/steering.ts";
+import { requestAsyncSteer, type SteerDeliveryMode } from "../background/control-channel.ts";
+import { currentCompletionOwnerId } from "../../shared/completion-owner.ts";
 
 export interface WorkflowForegroundSteeringTarget {
 	control: ForegroundRunControl;
@@ -66,6 +67,58 @@ function managementError(message: string): AgentToolResult<Details> {
 	return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
 }
 
+/** Local controllers remain authoritative; recorded foreign ownership permits enqueue, not takeover or proof of liveness. */
+export async function steerWorkflowRun(input: {
+	state: SubagentState;
+	runId: string;
+	asyncDir: string;
+	message: string;
+	mode?: SteerDeliveryMode;
+	index?: number;
+	signal?: AbortSignal;
+	ackTimeoutMs?: number;
+}): Promise<AgentToolResult<Details>> {
+	const { state, runId, asyncDir } = input;
+	const status = readStatus(asyncDir);
+	if (!status || status.mode !== "workflow" || status.runId !== runId || path.basename(asyncDir) !== runId) {
+		return managementError(`Workflow '${runId}' does not match its resolved run directory.`);
+	}
+	if (state.workflowControllers?.has(runId)) {
+		const route = resolveWorkflowForegroundSteeringTarget({ state, workflowRunId: runId, asyncDirRoot: path.dirname(asyncDir) });
+		if (!route.ok) return managementError(route.message);
+		return steerWorkflowForegroundTarget({ target: route.target, message: input.message, mode: input.mode, index: input.index });
+	}
+	if (!state.currentSessionId) return managementError("Workflow steering requires an active parent session.");
+	if (status.sessionId !== state.currentSessionId) return managementError(`Workflow '${runId}' was not found in the active session.`);
+	if (status.state !== "running" && status.state !== "queued") return managementError(`Workflow '${runId}' is not running or queued and cannot be steered.`);
+	if (typeof status.completionOwnerId !== "string" || !status.completionOwnerId.trim()
+		|| status.completionOwnerId === (state.completionOwnerId ?? currentCompletionOwnerId())
+		|| [...state.foregroundControls.values()].some((control) => control.parentWorkflowRunId === runId)) {
+		return managementError(`Workflow '${runId}' has no live foreground child and is not a recorded foreign workflow.`);
+	}
+	if (input.index !== undefined) {
+		const step = status.steps?.[input.index];
+		if (!Number.isInteger(input.index) || input.index < 0 || !step) return managementError(`Workflow '${runId}' index ${input.index} is out of range or invalid.`);
+		if (step.status !== "running" && step.status !== "pending") return managementError(`Workflow '${runId}' child ${input.index} is ${step.status} and cannot be steered.`);
+		if (typeof step.workflowKey !== "string" || !step.workflowKey.trim()) return managementError(`Workflow '${runId}' child ${input.index} has no projected workflow key.`);
+	}
+	const requestId = randomUUID();
+	try {
+		requestAsyncSteer(asyncDir, { id: requestId, message: input.message, mode: input.mode, ...(input.index !== undefined ? { targetIndex: input.index } : {}), source: "steer-action" });
+	} catch (error) {
+		return managementError(`Failed to queue steering for workflow ${runId}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	// Only the owner writes the ledger. No acknowledgment leaves an honest, unaddressed queued receipt.
+	const steering = await waitForSteeringAction({ asyncDir, sourceRunId: runId, requestId, timeoutMs: input.ackTimeoutMs ?? 3_000, signal: input.signal })
+		?? { requestId, state: "pending" as const, deliveryStatus: "queued" as const, sourceRunId: runId, targets: input.index === undefined ? [] : [{ index: input.index, state: "pending" as const }] };
+	const failed = steering.state === "failed" || steering.state === "partial";
+	return {
+		content: [{ type: "text", text: steeringReceipt(input.message, `Steering ${failed ? steering.state : steering.deliveryStatus === "delivered" ? "delivered" : "queued"} for workflow ${runId} (request ${requestId}).`) }],
+		...(failed ? { isError: true } : {}),
+		details: { mode: "management", results: [], steering },
+	};
+}
+
 /**
  * Steer a live workflow-owned foreground child through its in-process session.
  * `steer` (and `auto`) interrupt the child at its next safe point; `follow_up`
@@ -91,6 +144,7 @@ export async function steerWorkflowForegroundTarget(input: {
 
 	const message = input.message.trim();
 	const requestId = randomUUID();
+
 	const outcome = await child.steer({ message, ...(input.mode && input.mode !== "steer" ? { mode: input.mode } : {}) });
 	const target = outcome.state === "delivered"
 		? { index, state: "delivered" as const, deliveredAt: Date.now() }

package/src/runs/shared/acceptance.ts

@@ -24,7 +24,7 @@ import type {
 	ChildWatchdogProgress,
 } from "../../shared/types.ts";
 import { unresolvedChildWatchdogBlockers } from "../../watchdog/child-status.ts";
-import { isAgentContractV1 } from "./agent-contract.ts";
+import { isAgentContract } from "./agent-contract.ts";
 import { classifyTaskMutationIntent, stripSeverityCompounds, taskMayMutate } from "./task-intent.ts";
 
 const LEVEL_RANK: Record<Exclude<AcceptanceLevel, "auto">, number> = {
@@ -202,10 +202,23 @@ export function normalizeGateAcceptance(gate: unknown, acceptance: AcceptanceInp
 		return normalized.error ? { ok: false, error: normalized.error } : { ok: true, acceptance: normalized.value as AcceptanceInput };
 	}
 	if (typeof gate !== "string" || !gate.trim()) return { ok: false, error: "gate must be a non-empty command string." };
-	if (acceptance !== undefined) return { ok: false, error: "gate cannot be combined with acceptance; use one gate command or acceptance.verify." };
+	if (acceptance !== undefined && acceptance !== false) return { ok: false, error: "gate cannot be combined with acceptance; use one gate command or acceptance.verify." + describeGateAcceptanceConflict(gate, acceptance) };
 	return { ok: true, acceptance: { level: "verified", verify: [{ id: "gate", command: gate.trim() }] } };
 }
 
+export function describeGateAcceptanceConflict(gate: unknown, acceptance: unknown): string {
+	const render = (value: unknown): string => {
+		let encoded: string;
+		try {
+			encoded = JSON.stringify(value) ?? String(value);
+		} catch {
+			encoded = String(value);
+		}
+		return encoded.length > 120 ? `${encoded.slice(0, 120)}...` : encoded;
+	};
+	return ` Both fields were present: gate=${render(gate)} acceptance=${render(acceptance)}.`;
+}
+
 function explicitAcceptanceCanDisable(explicit: AcceptanceConfig): boolean {
 	return explicit.level === "none" && typeof explicit.reason === "string" && explicit.reason.trim().length > 0;
 }
@@ -422,7 +435,7 @@ export function resolveEffectiveAcceptance(input: {
 }): ResolvedAcceptanceConfig {
 	const explicit = normalizeAcceptanceInput(input.explicit);
 	const explicitLevel = normalizeLevel(explicit.level);
-	if (isAgentContractV1(input.agentContract)) {
+	if (isAgentContract(input.agentContract)) {
 		const level = explicitAcceptanceCanDisable(explicit) || explicitLevel === "auto"
 			? "none"
 			: explicitLevel;

package/src/runs/shared/agent-contract.ts

@@ -1,6 +1,6 @@
 import type { AgentContract, EffectsProjection, ExecutionProjection, ReviewProjection, SingleResult } from "../../shared/types.ts";
 
-export function isAgentContractV1(contract: AgentContract | undefined): boolean {
+export function isAgentContract(contract: AgentContract | undefined): boolean {
 	return contract?.version === 1;
 }
 

package/src/runs/shared/async-status-projection.ts

@@ -1,6 +1,6 @@
 import { sanitizeDisplayText, truncateDisplayText } from "../../shared/display-text.ts";
 import { formatModelThinking } from "../../shared/formatters.ts";
-import type { AsyncJobState, AsyncJobStep, HostStepFreshnessV1, HostStepMonitorKind, HostStepNodeV1, HostStepState, HostStepVerdict, NestedRunSummary, NestedStepSummary, SubagentRunMode, WorkflowGraphSnapshot, WorkflowPreflightLaneV1, WorkflowPreflightV1 } from "../../shared/types.ts";
+import type { AsyncJobState, AsyncJobStep, HostStepFreshness, HostStepMonitorKind, HostStepNode, HostStepState, HostStepVerdict, NestedRunSummary, NestedStepSummary, SubagentRunMode, WorkflowGraphSnapshot, WorkflowPreflightLane, WorkflowPreflight } from "../../shared/types.ts";
 import { HOST_STEP_MAX_COUNT, HOST_STEP_MAX_DETAIL_CHARS, HOST_STEP_MAX_LABEL_CHARS, HOST_STEP_MAX_PROVIDER_CHARS, HOST_STEP_MAX_REASON_CHARS, HOST_STEP_MAX_REF_CHARS, HOST_STEP_MAX_ROLE_CHARS, HOST_STEP_MAX_TARGET_CHARS, hostStepReportName, parseHostStepNode, validHostStepNodes } from "./host-step-status.ts";
 import { workflowPreflightLaneForRuntimeKey } from "../../workflows/workflow-preflight.ts";
 import { workflowGraphStageNodes } from "./workflow-graph.ts";
@@ -32,7 +32,7 @@ function isAsyncStatusSnapshotState(value: string): value is AsyncStatusSnapshot
 	return Object.hasOwn(ASYNC_STATUS_SNAPSHOT_STATES, value);
 }
 
-export interface AsyncStatusSnapshotActivityV1 {
+export interface AsyncStatusSnapshotActivity {
 	state?: string;
 	currentTool?: string;
 	lastActivityAt?: number;
@@ -41,7 +41,7 @@ export interface AsyncStatusSnapshotActivityV1 {
 	toolCount?: number;
 }
 
-export interface AsyncStatusSnapshotHostStepV1 {
+export interface AsyncStatusSnapshotHostStep {
 	kind: HostStepMonitorKind;
 	provider?: string;
 	role?: string;
@@ -54,7 +54,7 @@ export interface AsyncStatusSnapshotHostStepV1 {
 	report?: string;
 }
 
-export interface AsyncStatusSnapshotNodeV1 {
+export interface AsyncStatusSnapshotNode {
 	id: string;
 	kind: AsyncStatusSnapshotKind | "host-step";
 	label: string;
@@ -62,12 +62,12 @@ export interface AsyncStatusSnapshotNodeV1 {
 	startedAt?: number;
 	updatedAt?: number;
 	endedAt?: number;
-	activity?: AsyncStatusSnapshotActivityV1;
-	hostStep?: AsyncStatusSnapshotHostStepV1;
-	children?: AsyncStatusSnapshotNodeV1[];
+	activity?: AsyncStatusSnapshotActivity;
+	hostStep?: AsyncStatusSnapshotHostStep;
+	children?: AsyncStatusSnapshotNode[];
 }
 
-export interface AsyncStatusSnapshotCapsV1 {
+export interface AsyncStatusSnapshotCaps {
 	maxRuns: number;
 	maxChildrenPerNode: number;
 	maxDepth: number;
@@ -75,19 +75,19 @@ export interface AsyncStatusSnapshotCapsV1 {
 	maxSerializedBytes: number;
 }
 
-export interface AsyncStatusSnapshotOmittedV1 {
+export interface AsyncStatusSnapshotOmitted {
 	runs: number;
 	children: number;
 	byteLimitExceeded: boolean;
 }
 
-export interface AsyncStatusSnapshotV1 {
+export interface AsyncStatusSnapshot {
 	kind: typeof ASYNC_STATUS_SNAPSHOT_KIND;
 	version: typeof ASYNC_STATUS_SNAPSHOT_VERSION;
 	generatedAt: number;
-	caps: AsyncStatusSnapshotCapsV1;
-	omitted: AsyncStatusSnapshotOmittedV1;
-	runs: AsyncStatusSnapshotNodeV1[];
+	caps: AsyncStatusSnapshotCaps;
+	omitted: AsyncStatusSnapshotOmitted;
+	runs: AsyncStatusSnapshotNode[];
 }
 
 export interface AsyncStatusSnapshotOptions {
@@ -117,19 +117,19 @@ export interface AsyncStatusWorkflowRow {
 	reasonCode?: string;
 	detail?: string;
 	target?: string;
-	freshness?: HostStepFreshnessV1;
+	freshness?: HostStepFreshness;
 	reportPath?: string;
-	preflight?: WorkflowPreflightLaneV1;
+	preflight?: WorkflowPreflightLane;
 }
 
 interface ProjectionContext {
-	caps: AsyncStatusSnapshotCapsV1;
-	omitted: AsyncStatusSnapshotOmittedV1;
+	caps: AsyncStatusSnapshotCaps;
+	omitted: AsyncStatusSnapshotOmitted;
 }
 
-function validHostStepList(source: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | undefined): HostStepNodeV1[] {
+function validHostStepList(source: readonly HostStepNode[] | WorkflowGraphSnapshot | undefined): HostStepNode[] {
 	if (source && "nodes" in source) return validHostStepNodes(source);
-	const hostSteps: HostStepNodeV1[] = [];
+	const hostSteps: HostStepNode[] = [];
 	for (const [index, value] of (source ?? []).slice(0, HOST_STEP_MAX_COUNT).entries()) {
 		try {
 			hostSteps.push(parseHostStepNode(value, `hostSteps[${index}]`));
@@ -140,7 +140,7 @@ function validHostStepList(source: readonly HostStepNodeV1[] | WorkflowGraphSnap
 	return hostSteps;
 }
 
-function resolveCaps(options: AsyncStatusSnapshotOptions): AsyncStatusSnapshotCapsV1 {
+function resolveCaps(options: AsyncStatusSnapshotOptions): AsyncStatusSnapshotCaps {
 	return {
 		maxRuns: Math.max(0, Math.floor(options.maxRuns ?? DEFAULT_MAX_RUNS)),
 		maxChildrenPerNode: Math.max(0, Math.floor(options.maxChildrenPerNode ?? DEFAULT_MAX_CHILDREN_PER_NODE)),
@@ -199,13 +199,13 @@ function activityFor(source: {
 	currentToolStartedAt?: unknown;
 	turnCount?: unknown;
 	toolCount?: unknown;
-}, ctx: ProjectionContext): AsyncStatusSnapshotActivityV1 | undefined {
+}, ctx: ProjectionContext): AsyncStatusSnapshotActivity | undefined {
 	const currentTool = publicOptionalText(source.currentTool, ctx.caps.maxStringLength);
 	const lastActivityAt = publicTime(source.lastActivityAt);
 	const currentToolStartedAt = publicTime(source.currentToolStartedAt);
 	const turnCount = publicCount(source.turnCount);
 	const toolCount = publicCount(source.toolCount);
-	const activity: AsyncStatusSnapshotActivityV1 = {
+	const activity: AsyncStatusSnapshotActivity = {
 		...(typeof source.activityState === "string" ? { state: publicText(source.activityState, "unknown", ctx.caps.maxStringLength) } : {}),
 		...(currentTool ? { currentTool } : {}),
 		...(lastActivityAt !== undefined ? { lastActivityAt } : {}),
@@ -216,19 +216,19 @@ function activityFor(source: {
 	return Object.keys(activity).length ? activity : undefined;
 }
 
-function appendBoundedChildren(children: AsyncStatusSnapshotNodeV1[], source: readonly AsyncStatusSnapshotNodeV1[], ctx: ProjectionContext): void {
+function appendBoundedChildren(children: AsyncStatusSnapshotNode[], source: readonly AsyncStatusSnapshotNode[], ctx: ProjectionContext): void {
 	const remaining = Math.max(0, ctx.caps.maxChildrenPerNode - children.length);
 	children.push(...source.slice(0, remaining));
 	ctx.omitted.children += Math.max(0, source.length - remaining);
 }
 
-function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = normalizeState(step.status);
 	const startedAt = publicTime(step.startedAt);
 	const endedAt = publicTime(step.endedAt);
 	const updatedAt = endedAt ?? publicTime(step.lastActivityAt) ?? startedAt;
 	const activity = activityFor(step, ctx);
-	const node: AsyncStatusSnapshotNodeV1 = {
+	const node: AsyncStatusSnapshotNode = {
 		id: publicText("workflowKey" in step && step.workflowKey ? step.workflowKey : "runId" in step && step.runId ? step.runId : `step:${index}`, `step:${index}`, ctx.caps.maxStringLength),
 		kind: "step",
 		label: publicText("label" in step && step.label ? step.label : step.agent, "step", ctx.caps.maxStringLength),
@@ -240,7 +240,7 @@ function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, dept
 	};
 	if (depth < ctx.caps.maxDepth && step.children?.length) {
 		const nested = step.children.map((child, childIndex) => projectNestedRun(child, childIndex, depth + 1, ctx));
-		const bounded: AsyncStatusSnapshotNodeV1[] = [];
+		const bounded: AsyncStatusSnapshotNode[] = [];
 		appendBoundedChildren(bounded, nested, ctx);
 		if (bounded.length) node.children = bounded;
 	} else if (step.children?.length) {
@@ -249,7 +249,7 @@ function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, dept
 	return node;
 }
 
-function projectWorkflowGraphNode(node: WorkflowGraphSnapshot["nodes"][number], index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectWorkflowGraphNode(node: WorkflowGraphSnapshot["nodes"][number], index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const step: AsyncJobStep = {
 		agent: node.agent ?? node.label,
 		status: workflowGraphStepStatus(node.status),
@@ -259,13 +259,13 @@ function projectWorkflowGraphNode(node: WorkflowGraphSnapshot["nodes"][number],
 	return projectStep(step, node.flatIndex ?? index, depth, ctx);
 }
 
-function projectNestedRun(child: NestedRunSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectNestedRun(child: NestedRunSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = normalizeState(child.state);
 	const startedAt = publicTime(child.startedAt);
 	const endedAt = publicTime(child.endedAt);
 	const updatedAt = publicTime(child.lastUpdate) ?? endedAt ?? publicTime(child.lastActivityAt) ?? startedAt;
 	const activity = activityFor(child, ctx);
-	const node: AsyncStatusSnapshotNodeV1 = {
+	const node: AsyncStatusSnapshotNode = {
 		id: publicText(child.id, `nested:${index}`, ctx.caps.maxStringLength),
 		kind: kindForMode(child.mode),
 		label: child.agent ? publicText(child.agent, "subagent", ctx.caps.maxStringLength) : labelForAgents(child.agents, child.mode ?? "subagent", ctx.caps.maxStringLength),
@@ -278,7 +278,7 @@ function projectNestedRun(child: NestedRunSummary, index: number, depth: number,
 	if (depth < ctx.caps.maxDepth) {
 		const nestedSteps = child.steps?.map((step, stepIndex) => projectStep(step, stepIndex, depth + 1, ctx)) ?? [];
 		const nestedChildren = child.children?.map((nested, childIndex) => projectNestedRun(nested, childIndex, depth + 1, ctx)) ?? [];
-		const bounded: AsyncStatusSnapshotNodeV1[] = [];
+		const bounded: AsyncStatusSnapshotNode[] = [];
 		appendBoundedChildren(bounded, [...nestedSteps, ...nestedChildren], ctx);
 		if (bounded.length) node.children = bounded;
 	} else {
@@ -295,11 +295,11 @@ function hostStepSnapshotState(state: HostStepState, verdict: HostStepVerdict |
 	return verdict === undefined || verdict === "inconclusive" ? "partial" : "complete";
 }
 
-function projectHostStep(hostStep: HostStepNodeV1, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectHostStep(hostStep: HostStepNode, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = hostStepSnapshotState(hostStep.state, hostStep.verdict);
 	const detail = publicOptionalText(hostStep.detail, ctx.caps.maxStringLength);
 	const report = publicOptionalText(hostStepReportName(hostStep.reportPath), ctx.caps.maxStringLength);
-	const hostMetadata: AsyncStatusSnapshotHostStepV1 = {
+	const hostMetadata: AsyncStatusSnapshotHostStep = {
 		kind: hostStep.monitorKind,
 		state: hostStep.state,
 		...(hostStep.provider ? { provider: publicText(hostStep.provider, "provider", ctx.caps.maxStringLength) } : {}),
@@ -322,12 +322,12 @@ function projectHostStep(hostStep: HostStepNodeV1, ctx: ProjectionContext): Asyn
 	};
 }
 
-function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = normalizeState(job.status);
 	const startedAt = publicTime(job.startedAt);
 	const updatedAt = publicTime(job.updatedAt) ?? startedAt;
 	const activity = activityFor(job, ctx);
-	const node: AsyncStatusSnapshotNodeV1 = {
+	const node: AsyncStatusSnapshotNode = {
 		id: publicText(job.asyncId, "async", ctx.caps.maxStringLength),
 		kind: kindForMode(job.mode),
 		label: labelForAgents(job.agents, job.mode ?? "subagent", ctx.caps.maxStringLength),
@@ -349,7 +349,7 @@ function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnap
 		const ordinaryChildren = [...stepChildren, ...graphChildren, ...nestedChildren];
 		const retainedHostSteps = hostStepChildren.slice(0, ctx.caps.maxChildrenPerNode);
 		const retainedOrdinaryChildren = ordinaryChildren.slice(0, ctx.caps.maxChildrenPerNode - retainedHostSteps.length);
-		const bounded: AsyncStatusSnapshotNodeV1[] = [];
+		const bounded: AsyncStatusSnapshotNode[] = [];
 		bounded.push(...retainedOrdinaryChildren, ...retainedHostSteps);
 		ctx.omitted.children += ordinaryChildren.length - retainedOrdinaryChildren.length + hostStepChildren.length - retainedHostSteps.length;
 		if (bounded.length) node.children = bounded;
@@ -362,11 +362,11 @@ function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnap
 	return node;
 }
 
-function snapshotBytes(snapshot: AsyncStatusSnapshotV1): number {
+function snapshotBytes(snapshot: AsyncStatusSnapshot): number {
 	return Buffer.byteLength(JSON.stringify(snapshot), "utf8");
 }
 
-function enforceByteLimit(snapshot: AsyncStatusSnapshotV1): void {
+function enforceByteLimit(snapshot: AsyncStatusSnapshot): void {
 	if (snapshotBytes(snapshot) <= snapshot.caps.maxSerializedBytes) return;
 	snapshot.omitted.byteLimitExceeded = true;
 	const runs = snapshot.runs;
@@ -401,7 +401,7 @@ function workflowStepName(step: AsyncJobStep, index: number): string {
 	return `${phase}${key}${label} (${step.agent})`;
 }
 
-function hostStepRow(hostStep: HostStepNodeV1): AsyncStatusWorkflowRow {
+function hostStepRow(hostStep: HostStepNode): AsyncStatusWorkflowRow {
 	const freshness = hostStep.freshness
 		? {
 			expectedRef: publicText(hostStep.freshness.expectedRef, "ref", HOST_STEP_MAX_REF_CHARS),
@@ -425,11 +425,11 @@ function hostStepRow(hostStep: HostStepNodeV1): AsyncStatusWorkflowRow {
 }
 
 
-function isWorkflowPreflight(value: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | WorkflowPreflightV1 | undefined): value is WorkflowPreflightV1 {
+function isWorkflowPreflight(value: readonly HostStepNode[] | WorkflowGraphSnapshot | WorkflowPreflight | undefined): value is WorkflowPreflight {
 	return value !== undefined && !Array.isArray(value) && "lanes" in value;
 }
 
-function isWorkflowGraph(value: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | WorkflowPreflightV1 | undefined): value is WorkflowGraphSnapshot {
+function isWorkflowGraph(value: readonly HostStepNode[] | WorkflowGraphSnapshot | WorkflowPreflight | undefined): value is WorkflowGraphSnapshot {
 	return value !== undefined && !Array.isArray(value) && "nodes" in value;
 }
 
@@ -465,7 +465,7 @@ function workflowGraphRowName(node: WorkflowGraphSnapshot["nodes"][number]): str
 	return `${phase ? `${phase}: ` : ""}${key}${label && label !== node.id ? ` · ${label}` : ""}${agent ? ` (${agent})` : ""}`;
 }
 
-function projectWorkflowGraphRow(node: WorkflowGraphSnapshot["nodes"][number], preflight?: WorkflowPreflightLaneV1): AsyncStatusWorkflowRow {
+function projectWorkflowGraphRow(node: WorkflowGraphSnapshot["nodes"][number], preflight?: WorkflowPreflightLane): AsyncStatusWorkflowRow {
 	return {
 		name: workflowGraphRowName(node),
 		state: workflowGraphRowState(node.status),
@@ -476,14 +476,14 @@ function projectWorkflowGraphRow(node: WorkflowGraphSnapshot["nodes"][number], p
 /** Project authoritative workflow facts into compact rows, annotated by preflight hints. */
 export function projectAsyncWorkflowRows(
 	steps: readonly AsyncJobStep[] | undefined,
-	hostStepsOrPreflight?: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | WorkflowPreflightV1,
-	preflightOverride?: WorkflowPreflightV1,
+	hostStepsOrPreflight?: readonly HostStepNode[] | WorkflowGraphSnapshot | WorkflowPreflight,
+	preflightOverride?: WorkflowPreflight,
 ): AsyncStatusWorkflowRow[] {
 	const preflight = preflightOverride ?? (isWorkflowPreflight(hostStepsOrPreflight) ? hostStepsOrPreflight : undefined);
 	const graph = isWorkflowGraph(hostStepsOrPreflight) ? hostStepsOrPreflight : undefined;
 	const hostSteps = isWorkflowPreflight(hostStepsOrPreflight) || graph ? undefined : hostStepsOrPreflight;
 	const loaded = steps ?? [];
-	const preflightForKey = (key: string, groupKeys: readonly (string | undefined)[] = []): WorkflowPreflightLaneV1 | undefined =>
+	const preflightForKey = (key: string, groupKeys: readonly (string | undefined)[] = []): WorkflowPreflightLane | undefined =>
 		workflowPreflightLaneForRuntimeKey(preflight, key, groupKeys);
 	if (graph) {
 		const loadedIndexesByKey = new Map<string, number[]>();
@@ -526,7 +526,7 @@ export function projectAsyncWorkflowRows(
 	];
 }
 
-function projectLoadedWorkflowRow(step: AsyncJobStep, index: number, preflight?: WorkflowPreflightLaneV1): AsyncStatusWorkflowRow {
+function projectLoadedWorkflowRow(step: AsyncJobStep, index: number, preflight?: WorkflowPreflightLane): AsyncStatusWorkflowRow {
 	const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
 	const activity = workflowStepActivity(step);
 	return {
@@ -543,7 +543,7 @@ function projectLoadedWorkflowRow(step: AsyncJobStep, index: number, preflight?:
 }
 
 /** Project already-loaded async status facts into the bounded public snapshot shape. */
-export function projectAsyncStatusSnapshot(jobs: Iterable<AsyncJobState>, options: AsyncStatusSnapshotOptions = {}): AsyncStatusSnapshotV1 {
+export function projectAsyncStatusSnapshot(jobs: Iterable<AsyncJobState>, options: AsyncStatusSnapshotOptions = {}): AsyncStatusSnapshot {
 	const caps = resolveCaps(options);
 	const ctx: ProjectionContext = { caps, omitted: { runs: 0, children: 0, byteLimitExceeded: false } };
 	const sorted = [...jobs].sort((left, right) => {
@@ -552,7 +552,7 @@ export function projectAsyncStatusSnapshot(jobs: Iterable<AsyncJobState>, option
 		return rightUpdated - leftUpdated || left.asyncId.localeCompare(right.asyncId);
 	});
 	ctx.omitted.runs += Math.max(0, sorted.length - caps.maxRuns);
-	const snapshot: AsyncStatusSnapshotV1 = {
+	const snapshot: AsyncStatusSnapshot = {
 		kind: ASYNC_STATUS_SNAPSHOT_KIND,
 		version: ASYNC_STATUS_SNAPSHOT_VERSION,
 		generatedAt: options.generatedAt ?? Date.now(),