pi-subagents 0.65.1 → 0.67.0

package/src/workflows/workflow-child-summary.ts

@@ -1,9 +1,42 @@
-import type { AsyncStatus, WorkflowChildSummaryV1 } from "../shared/types.ts";
+import type { AgentProgress, AsyncStatus, WorkflowChildActivity, WorkflowChildSummary } from "../shared/types.ts";
 import type { WorkflowScriptChildResult, WorkflowScriptTraceEntry } from "./scripted-workflow.ts";
 
 const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const TERMINAL_STATES = new Set(["completed", "failed", "paused", "stopped", "rejected", "detached"]);
 const MAX_REQUIRED_ID_BYTES = 4_096;
+const ACTIVITY_COUNTERS = ["currentToolStartedAt", "lastActivityAt", "durationMs", "toolCount", "turnCount", "tokens", "inputTokens", "outputTokens"] as const;
+type WorkflowChildLiveProgress = WorkflowChildActivity & Pick<AgentProgress, "agent" | "sessionName" | "model" | "thinking">;
+
+export function workflowChildProgress(progress: AgentProgress): WorkflowChildLiveProgress {
+	return {
+		...workflowChildActivity(progress),
+		agent: bounded(progress.agent, 256) ?? "",
+		...(bounded(progress.sessionName, 256) ? { sessionName: progress.sessionName } : {}),
+		...(bounded(progress.model, 256) ? { model: progress.model } : {}),
+		...(bounded(progress.thinking, 32) ? { thinking: progress.thinking } : {}),
+	};
+}
+
+/** Fixed field count and a 256 UTF-8 byte tool name keep JSON activity below 2 KiB, including escaping. */
+export function workflowChildActivity(progress: WorkflowChildActivity): WorkflowChildActivity {
+	const activity: WorkflowChildActivity = {};
+	if (bounded(progress.currentTool, 256)) activity.currentTool = progress.currentTool;
+	for (const field of ACTIVITY_COUNTERS) {
+		const value = progress[field];
+		if (typeof value === "number" && Number.isFinite(value) && value >= 0) activity[field] = value;
+	}
+	return activity;
+}
+
+function parseActivity(value: unknown): WorkflowChildActivity | undefined {
+	if (value === undefined) return undefined;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("workflowChildren child activity is invalid.");
+	const input = value as Record<string, unknown>;
+	for (const [key, value] of Object.entries(input)) {
+		if (key === "currentTool" ? !bounded(value, 256) : !ACTIVITY_COUNTERS.includes(key as typeof ACTIVITY_COUNTERS[number]) || typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error("workflowChildren child activity is invalid.");
+	}
+	return { ...input } as WorkflowChildActivity;
+}
 
 function bounded(value: unknown, maxBytes: number): string | undefined {
 	if (typeof value !== "string" || !value.trim() || Buffer.byteLength(value, "utf8") > maxBytes) return undefined;
@@ -19,13 +52,15 @@ function requiredId(value: string, label: string): string {
 export function workflowChildSummary(input: {
 	parentToolCallId: string;
 	workflowRunId: string;
-	workflowState: WorkflowChildSummaryV1["workflowState"];
+	workflowState: WorkflowChildSummary["workflowState"];
 	inventoryComplete: boolean;
 	trace?: WorkflowScriptTraceEntry[];
 	children?: WorkflowScriptChildResult[];
 	steps?: NonNullable<AsyncStatus["steps"]>;
-}): WorkflowChildSummaryV1 {
-	const rows = new Map<string, WorkflowChildSummaryV1["children"][number]>();
+	/** In-memory snapshots from synchronous child callbacks, keyed by workflow key. */
+	progress?: ReadonlyMap<string, WorkflowChildLiveProgress>;
+}): WorkflowChildSummary {
+	const rows = new Map<string, WorkflowChildSummary["children"][number]>();
 	for (const entry of input.trace ?? []) {
 		if (entry.operation !== "run" || !KEY_PATTERN.test(entry.key)) continue;
 		const previous = rows.get(entry.key);
@@ -83,6 +118,18 @@ export function workflowChildSummary(input: {
 			if (!TERMINAL_STATES.has(row.state)) rows.set(key, { ...row, state: input.workflowState === "stopped" ? "stopped" : "failed" });
 		}
 	}
+	for (const [key, progress] of input.progress ?? []) {
+		const row = rows.get(key);
+		if (!row || row.state !== "running") continue;
+		rows.set(key, {
+			...row,
+			...(bounded(progress.agent, 256) ? { agent: progress.agent } : {}),
+			...(bounded(progress.sessionName, 256) ? { sessionName: progress.sessionName } : {}),
+			...(bounded(progress.model, 256) ? { model: progress.model } : {}),
+			...(bounded(progress.thinking, 32) ? { thinking: progress.thinking } : {}),
+			activity: workflowChildActivity(progress),
+		});
+	}
 	return {
 		version: 1,
 		parentToolCallId: requiredId(input.parentToolCallId, "parentToolCallId"),
@@ -93,7 +140,7 @@ export function workflowChildSummary(input: {
 	};
 }
 
-export function parseWorkflowChildSummary(value: unknown): WorkflowChildSummaryV1 | undefined {
+export function parseWorkflowChildSummary(value: unknown): WorkflowChildSummary | undefined {
 	if (value === undefined) return undefined;
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("workflowChildren must be an object.");
 	const input = value as Record<string, unknown>;
@@ -102,17 +149,19 @@ export function parseWorkflowChildSummary(value: unknown): WorkflowChildSummaryV
 	if (input.version !== 1 || typeof input.inventoryComplete !== "boolean" || !Array.isArray(input.children)) throw new Error("workflowChildren is invalid.");
 	const workflowState = input.workflowState;
 	if (workflowState !== "queued" && workflowState !== "running" && workflowState !== "completed" && workflowState !== "failed" && workflowState !== "paused" && workflowState !== "stopped") throw new Error("workflowChildren.workflowState is invalid.");
-	const children = input.children.map((row): WorkflowChildSummaryV1["children"][number] => {
+	const children = input.children.map((row): WorkflowChildSummary["children"][number] => {
 		if (!row || typeof row !== "object" || Array.isArray(row)) throw new Error("workflowChildren child row is invalid.");
 		const child = row as Record<string, unknown>;
-		if (Object.keys(child).some((key) => !["childId", "runId", "agent", "sessionName", "model", "thinking", "state"].includes(key))) throw new Error("workflowChildren child row has unsupported fields.");
+		if (Object.keys(child).some((key) => !["childId", "runId", "agent", "sessionName", "model", "thinking", "state", "activity"].includes(key))) throw new Error("workflowChildren child row has unsupported fields.");
 		if (typeof child.childId !== "string" || !KEY_PATTERN.test(child.childId)) throw new Error("workflowChildren childId is invalid.");
 		const state = child.state;
 		if (state !== "pending" && state !== "running" && state !== "completed" && state !== "failed" && state !== "paused" && state !== "stopped" && state !== "rejected" && state !== "detached") throw new Error("workflowChildren child state is invalid.");
 		for (const [field, maxBytes] of [["runId", 256], ["agent", 256], ["sessionName", 256], ["model", 256], ["thinking", 32]] as const) {
 			if (child[field] !== undefined && bounded(child[field], maxBytes) === undefined) throw new Error(`workflowChildren child ${field} is invalid.`);
 		}
-		return { childId: child.childId, state, ...(child.runId ? { runId: child.runId as string } : {}), ...(child.agent ? { agent: child.agent as string } : {}), ...(child.sessionName ? { sessionName: child.sessionName as string } : {}), ...(child.model ? { model: child.model as string } : {}), ...(child.thinking ? { thinking: child.thinking as string } : {}) };
+		const activity = parseActivity(child.activity);
+		if (activity && state !== "running") throw new Error("workflowChildren child activity requires running state.");
+		return { childId: child.childId, state, ...(activity ? { activity } : {}), ...(child.runId ? { runId: child.runId as string } : {}), ...(child.agent ? { agent: child.agent as string } : {}), ...(child.sessionName ? { sessionName: child.sessionName as string } : {}), ...(child.model ? { model: child.model as string } : {}), ...(child.thinking ? { thinking: child.thinking as string } : {}) };
 	});
 	if (new Set(children.map((child) => child.childId)).size !== children.length) throw new Error("workflowChildren has duplicate childId values.");
 	if (typeof input.parentToolCallId !== "string") throw new Error("workflowChildren.parentToolCallId is invalid.");

package/src/workflows/workflow-preflight.ts

@@ -1,4 +1,4 @@
-import type { WorkflowPreflightLaneV1, WorkflowPreflightV1 } from "../shared/types.ts";
+import type { WorkflowPreflightLane, WorkflowPreflight } from "../shared/types.ts";
 
 export const WORKFLOW_PREFLIGHT_VERSION = 1 as const;
 export const WORKFLOW_PREFLIGHT_MAX_LANES = 64;
@@ -11,7 +11,7 @@ export const WORKFLOW_PREFLIGHT_MAX_WARNINGS = 16;
 const WORKFLOW_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const PREFLIGHT_FIELDS = new Set(["version", "coverage", "lanes"]);
 const LANE_FIELDS = new Set(["key", "mode", "decision", "claims", "expectedOutput", "independence"]);
-const PREFLIGHT_MODES = new Set<WorkflowPreflightLaneV1["mode"]>(["mutation", "review", "scout", "gate"]);
+const PREFLIGHT_MODES = new Set<WorkflowPreflightLane["mode"]>(["mutation", "review", "scout", "gate"]);
 
 type WorkflowTraceLike = {
 	operation: string;
@@ -23,7 +23,7 @@ type WorkflowTraceLike = {
 
 export interface WorkflowPreflightValidationResult {
 	ok: boolean;
-	preflight?: WorkflowPreflightV1;
+	preflight?: WorkflowPreflight;
 	error?: string;
 }
 
@@ -60,18 +60,18 @@ function normalizeDisplayString(value: unknown, path: string): string {
 	return normalized;
 }
 
-function normalizeLane(value: unknown, index: number): WorkflowPreflightLaneV1 {
+function normalizeLane(value: unknown, index: number): WorkflowPreflightLane {
 	const path = `preflight.lanes[${index}]`;
 	assertPlainObject(value, path);
 	assertKnownFields(value, LANE_FIELDS, path);
 	const key = normalizeDisplayString(value.key, `${path}.key`);
 	if (!WORKFLOW_KEY_PATTERN.test(key)) throw new Error(`${path}.key must be 1-128 characters using letters, numbers, '.', '_' or '-', and start with a letter or number.`);
-	let mode: WorkflowPreflightLaneV1["mode"];
+	let mode: WorkflowPreflightLane["mode"];
 	if (value.mode !== undefined) {
-		if (typeof value.mode !== "string" || !PREFLIGHT_MODES.has(value.mode as WorkflowPreflightLaneV1["mode"])) {
+		if (typeof value.mode !== "string" || !PREFLIGHT_MODES.has(value.mode as WorkflowPreflightLane["mode"])) {
 			throw new Error(`${path}.mode must be one of: mutation, review, scout, gate.`);
 		}
-		mode = value.mode as WorkflowPreflightLaneV1["mode"];
+		mode = value.mode as WorkflowPreflightLane["mode"];
 	}
 	let claims: string[] | undefined;
 	if (value.claims !== undefined) {
@@ -97,7 +97,7 @@ function normalizeLane(value: unknown, index: number): WorkflowPreflightLaneV1 {
  * independent of workflowScript parsing: callers may describe dynamic fanout
  * without making the metadata a second execution graph.
  */
-export function normalizeWorkflowPreflight(input: unknown): WorkflowPreflightV1 | undefined {
+export function normalizeWorkflowPreflight(input: unknown): WorkflowPreflight | undefined {
 	if (input === undefined) return undefined;
 	assertPlainObject(input, "preflight");
 	assertKnownFields(input, PREFLIGHT_FIELDS, "preflight");
@@ -115,7 +115,7 @@ export function normalizeWorkflowPreflight(input: unknown): WorkflowPreflightV1
 		if (seenKeys.has(lane.key)) throw new Error(`preflight.lanes contains duplicate key '${lane.key}'.`);
 		seenKeys.add(lane.key);
 	}
-	const normalized = { version: WORKFLOW_PREFLIGHT_VERSION, coverage, lanes } satisfies WorkflowPreflightV1;
+	const normalized = { version: WORKFLOW_PREFLIGHT_VERSION, coverage, lanes } satisfies WorkflowPreflight;
 	const depth = 1 + (lanes.length > 0 ? 1 : 0) + (lanes.some((lane) => lane.claims !== undefined) ? 1 : 0);
 	if (depth > WORKFLOW_PREFLIGHT_MAX_DEPTH) throw new Error(`preflight exceeds the maximum nesting depth of ${WORKFLOW_PREFLIGHT_MAX_DEPTH}.`);
 	const bytes = Buffer.byteLength(JSON.stringify(normalized), "utf8");
@@ -138,7 +138,7 @@ function warningLimit(messages: string[]): string[] {
 	return [...messages.slice(0, WORKFLOW_PREFLIGHT_MAX_WARNINGS - 1), `Preflight advisory: ${omitted} additional mismatch warning(s) omitted.`];
 }
 
-function declaredKeys(preflight: WorkflowPreflightV1): Set<string> {
+function declaredKeys(preflight: WorkflowPreflight): Set<string> {
 	return new Set(preflight.lanes.map((lane) => lane.key));
 }
 
@@ -152,15 +152,15 @@ export function workflowKeyMatchesPreflightLane(key: string, laneKey: string, ge
 
 /** Select the most specific advisory lane without allowing declaration order to override an exact runtime key. */
 export function workflowPreflightLaneForRuntimeKey(
-	preflight: WorkflowPreflightV1 | undefined,
+	preflight: WorkflowPreflight | undefined,
 	key: string,
 	preferredKeys: readonly (string | undefined)[] = [],
-): WorkflowPreflightLaneV1 | undefined {
+): WorkflowPreflightLane | undefined {
 	const lanes = preflight?.lanes;
 	if (!lanes) return undefined;
 	const exact = lanes.find((lane) => lane.key === key);
 	if (exact) return exact;
-	let closestRoot: WorkflowPreflightLaneV1 | undefined;
+	let closestRoot: WorkflowPreflightLane | undefined;
 	for (const lane of lanes) {
 		if (key.startsWith(`${lane.key}.`) && (!closestRoot || lane.key.length > closestRoot.key.length)) closestRoot = lane;
 	}
@@ -203,7 +203,7 @@ function unlaunchedWarning(key: string): string {
 
 /** Return bounded advisory mismatch warnings; these never reject a child launch. */
 export function workflowPreflightWarnings(
-	preflight: WorkflowPreflightV1 | undefined,
+	preflight: WorkflowPreflight | undefined,
 	trace: readonly WorkflowTraceLike[],
 	options: { settled?: boolean } = {},
 ): string[] {
@@ -218,7 +218,7 @@ export function workflowPreflightWarnings(
 }
 
 /** Attach the first undeclared-key warning to its first trace row for status/debug views. */
-export function annotateWorkflowPreflightTrace<T extends WorkflowTraceLike>(trace: readonly T[], preflight: WorkflowPreflightV1 | undefined): T[] {
+export function annotateWorkflowPreflightTrace<T extends WorkflowTraceLike>(trace: readonly T[], preflight: WorkflowPreflight | undefined): T[] {
 	if (!preflight) return [...trace];
 	const declared = declaredKeys(preflight);
 	const warned = new Set<string>();
@@ -235,14 +235,14 @@ function laneCell(value: string | undefined): string {
 
 const WORKFLOW_PREFLIGHT_PLAN_LABEL_LENGTH = 96;
 
-function planLaneLabel(lane: WorkflowPreflightLaneV1): string {
+function planLaneLabel(lane: WorkflowPreflightLane): string {
 	const value = lane.decision?.trim() || lane.key;
 	if (value.length <= WORKFLOW_PREFLIGHT_PLAN_LABEL_LENGTH) return value;
 	return `${value.slice(0, WORKFLOW_PREFLIGHT_PLAN_LABEL_LENGTH - 1).trimEnd()}…`;
 }
 
 /** Render the detailed bounded table reserved for tool output and expanded/debug views. */
-export function formatWorkflowPreflight(preflight: WorkflowPreflightV1 | undefined, options: { indent?: string } = {}): string {
+export function formatWorkflowPreflight(preflight: WorkflowPreflight | undefined, options: { indent?: string } = {}): string {
 	if (!preflight) return "";
 	const indent = options.indent ?? "";
 	const count = preflight.lanes.length;
@@ -263,7 +263,7 @@ export function formatWorkflowPreflight(preflight: WorkflowPreflightV1 | undefin
 	return lines.join("\n");
 }
 
-export function formatWorkflowPreflightSummary(preflight: WorkflowPreflightV1 | undefined): string {
+export function formatWorkflowPreflightSummary(preflight: WorkflowPreflight | undefined): string {
 	if (!preflight) return "";
 	const keys = preflight.lanes.slice(0, 4).map((lane) => lane.key).join(", ");
 	const remainder = preflight.lanes.length > 4 ? `, +${preflight.lanes.length - 4}` : "";
@@ -271,7 +271,7 @@ export function formatWorkflowPreflightSummary(preflight: WorkflowPreflightV1 |
 }
 
 /** Render the operator-facing one-line plan shown in routine status views. */
-export function formatWorkflowPreflightPlanSummary(preflight: WorkflowPreflightV1 | undefined, options: { indent?: string } = {}): string {
+export function formatWorkflowPreflightPlanSummary(preflight: WorkflowPreflight | undefined, options: { indent?: string } = {}): string {
 	if (!preflight) return "";
 	const indent = options.indent ?? "";
 	const count = preflight.lanes.length;

package/src/workflows/workflow-receipt.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { writePrivateAtomicJson } from "../shared/atomic-json.ts";
-import type { AcceptanceRecoveryMetadata, ExternalCliReceiptMetadata, WorkflowReceipt, WorkflowReceiptEntry, WorkflowReceiptState, WorkflowRecoveryAction, WorkflowResourceProvenanceV1, WorkflowTerminalOutcome, WorkflowTerminalResolution } from "../shared/types.ts";
+import type { AcceptanceRecoveryMetadata, ExternalCliReceiptMetadata, WorkflowReceipt, WorkflowReceiptEntry, WorkflowReceiptState, WorkflowRecoveryAction, WorkflowResourceProvenance, WorkflowTerminalOutcome, WorkflowTerminalResolution } from "../shared/types.ts";
 import type { WorkflowReceiptResumeReference, WorkflowScriptChildResult } from "./scripted-workflow.ts";
 import { parseWorkflowChildSummary } from "./workflow-child-summary.ts";
 import { HOST_STEP_MAX_COUNT, assertUniqueHostStepIds, parseHostStepNode } from "../runs/shared/host-step-status.ts";
@@ -39,7 +39,7 @@ export function buildWorkflowReceipt(input: {
 	children: WorkflowScriptChildResult[];
 	hostSteps?: WorkflowReceipt["hostSteps"];
 	workflowChildren?: WorkflowReceipt["workflowChildren"];
-	resource?: WorkflowResourceProvenanceV1;
+	resource?: WorkflowResourceProvenance;
 	terminalOutcome?: WorkflowTerminalOutcome;
 	createdAt?: number;
 }): WorkflowReceipt {
@@ -262,7 +262,7 @@ function parseWorkflowResolution(value: unknown, source: string): WorkflowTermin
 	return value;
 }
 
-function parseWorkflowResource(value: unknown, source: string): WorkflowResourceProvenanceV1 | undefined {
+function parseWorkflowResource(value: unknown, source: string): WorkflowResourceProvenance | undefined {
 	if (value === undefined) return undefined;
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid workflow receipt '${source}': resource must be an object.`);
 	const resource = value as Record<string, unknown>;

package/src/workflows/workflow-resources.ts

@@ -2,10 +2,10 @@ import { randomUUID } from "node:crypto";
 import { stableJsonDigest } from "../shared/launch-contract.ts";
 import {
 	createWorkflowResourcePermit,
-	type WorkflowResourceAuthority,
+	type WorkflowResourceHostAuthority,
 	type WorkflowResourcePermit,
 } from "../shared/workflow-child-permit.ts";
-import type { WorkflowResourceProvenanceV1 } from "../shared/types.ts";
+import type { WorkflowResourceProvenance } from "../shared/types.ts";
 
 const RESOURCE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const MAX_ARGS_BYTES = 16 * 1024;
@@ -14,18 +14,75 @@ const MAX_STRING_BYTES = 16 * 1024;
 export interface ResolvedWorkflowResource {
 	script: string;
 	permit: WorkflowResourcePermit;
-	provenance: WorkflowResourceProvenanceV1;
+	provenance: WorkflowResourceProvenance;
 }
 
 export type WorkflowResourceResolution =
 	| { ok: true; resource: ResolvedWorkflowResource }
 	| { ok: false; error: string };
 
-type WorkflowResourceDefinition = {
+export interface WorkflowResourceDefinition {
 	name: string;
 	version: number;
-	resolve: (args: Record<string, unknown>) => { script: string; authority: WorkflowResourceAuthority } | { error: string };
-};
+	/** Trusted synchronous validation/expansion. The extension owns semantic command binding. */
+	resolve: (args: Readonly<Record<string, unknown>>) => { script: string; hostCommands?: readonly WorkflowResourceHostAuthority[] } | { error: string };
+}
+
+export interface WorkflowResourceRegistration {
+	dispose(): void;
+}
+
+export interface RegisterWorkflowResourceInput {
+	sessionId: string;
+	definition: WorkflowResourceDefinition;
+}
+
+interface WorkflowResourceRegistry {
+	version: 1;
+	bySession: Map<string, Map<string, WorkflowResourceDefinition>>;
+}
+
+function registry(): WorkflowResourceRegistry {
+	const key = Symbol.for("pi-subagents.workflow-resources.v1");
+	const globalObject = globalThis as Record<PropertyKey, unknown>;
+	const existing = globalObject[key];
+	if (existing === undefined) {
+		const created: WorkflowResourceRegistry = { version: 1, bySession: new Map() };
+		globalObject[key] = created;
+		return created;
+	}
+	if (!isPlainRecord(existing) || existing.version !== 1 || !(existing.bySession instanceof Map)) throw new Error("Malformed or unsupported workflow resource registry.");
+	return existing as unknown as WorkflowResourceRegistry;
+}
+
+/** Session ID scopes lookup, not authentication. Dispose on session_shutdown; issued permits remain valid. */
+export function registerWorkflowResource(input: RegisterWorkflowResourceInput): WorkflowResourceRegistration {
+	if (!isPlainRecord(input) || Object.keys(input).some((key) => key !== "sessionId" && key !== "definition")) throw new Error("Workflow registration requires only sessionId and definition.");
+	const { sessionId, definition } = input;
+	if (typeof sessionId !== "string" || !sessionId || sessionId.trim() !== sessionId || sessionId.length > 256 || sessionId.includes("\0")) throw new Error("Workflow registration requires a non-empty trimmed sessionId of at most 256 characters without NUL.");
+	if (!isPlainRecord(definition) || Object.keys(definition).some((key) => !["name", "version", "resolve"].includes(key))) throw new Error("Workflow definition requires only name, version and resolve.");
+	const { name, version, resolve } = definition;
+	if (typeof name !== "string" || !RESOURCE_NAME_PATTERN.test(name)) throw new Error("Workflow definition requires a safe resource name.");
+	if (!Number.isSafeInteger(version) || version < 1) throw new Error("Workflow definition version must be a positive safe integer.");
+	if (typeof resolve !== "function") throw new Error("Workflow definition requires a synchronous resolve function.");
+	if (findWorkflowResource(name)) throw new Error(`Workflow resource '${name}' is a protected builtin.`);
+	const current = registry();
+	const bucket = current.bySession.get(sessionId) ?? new Map<string, WorkflowResourceDefinition>();
+	if (!(bucket instanceof Map)) throw new Error("Malformed workflow resource session registry.");
+	if (bucket.has(name)) throw new Error(`Workflow resource '${name}' is already registered in this session; dispose it first.`);
+	const snapshot = Object.freeze({ name, version, resolve });
+	bucket.set(name, snapshot);
+	current.bySession.set(sessionId, bucket);
+	let disposed = false;
+	return {
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			if (bucket.get(name) === snapshot) bucket.delete(name);
+			if (bucket.size === 0 && current.bySession.get(sessionId) === bucket) current.bySession.delete(sessionId);
+		},
+	};
+}
 
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -68,19 +125,19 @@ function validatePlainJson(value: unknown, path: string, depth = 0): void {
 	}
 }
 
-function normalizeArgs(value: unknown): { args?: Record<string, unknown>; error?: string } {
+function normalizeArgs(value: unknown): { args: Record<string, unknown> } | { error: string } {
 	if (value === undefined) return { args: {} };
 	if (!isPlainRecord(value)) return { error: "workflow args must be a plain JSON object." };
 	try {
 		validatePlainJson(value, "workflow args");
 		if (jsonByteLength(value) > MAX_ARGS_BYTES) return { error: `workflow args exceed ${MAX_ARGS_BYTES} bytes.` };
-		return { args: { ...value } };
+		return { args: JSON.parse(JSON.stringify(value)) };
 	} catch (error) {
 		return { error: error instanceof Error ? error.message : String(error) };
 	}
 }
 
-function resolveRunCi(args: Record<string, unknown>): { script: string; authority: WorkflowResourceAuthority } | { error: string } {
+function resolveRunCi(args: Readonly<Record<string, unknown>>): ReturnType<WorkflowResourceDefinition["resolve"]> {
 	const allowed = new Set(["command", "timeoutMs"]);
 	const unsupported = Object.keys(args).filter((key) => !allowed.has(key));
 	if (unsupported.length > 0) return { error: `workflow 'run-ci' args contain unsupported fields: ${unsupported.join(", ")}.` };
@@ -91,18 +148,17 @@ function resolveRunCi(args: Record<string, unknown>): { script: string; authorit
 	const params = { kind: "command", command, timeoutMs, role: "ci" };
 	return {
 		script: `return await runs.host("ci", ${JSON.stringify(params)});`,
-		authority: { host: { keys: ["ci"], commands: [command] } },
+		hostCommands: [{ key: "ci", command }],
 	};
 }
 
-function resolveReview(args: Record<string, unknown>): { script: string; authority: WorkflowResourceAuthority } | { error: string } {
+function resolveReview(args: Readonly<Record<string, unknown>>): ReturnType<WorkflowResourceDefinition["resolve"]> {
 	const unsupported = Object.keys(args).filter((key) => key !== "task");
 	if (unsupported.length > 0) return { error: `workflow 'review' args contain unsupported fields: ${unsupported.join(", ")}.` };
 	const task = args.task;
 	if (typeof task !== "string" || !task.trim()) return { error: "workflow 'review' requires a non-empty string args.task." };
 	return {
 		script: `return (await runs.run("review", { agent: "reviewer", task: ${JSON.stringify(task.trim())} })).output;`,
-		authority: {},
 	};
 }
 
@@ -120,25 +176,44 @@ function listWorkflowResourceNames(): string[] {
 }
 
 /** Resolve only extension-owned resources so policy can distinguish them from raw scripts; caller-provided script text is never consulted. */
-export function resolveWorkflowResource(nameValue: unknown, argsValue?: unknown): WorkflowResourceResolution {
+export function resolveWorkflowResource(nameValue: unknown, argsValue?: unknown, sessionId?: string): WorkflowResourceResolution {
+	try {
+		const result = resolveResource(nameValue, argsValue, sessionId);
+		return result.ok ? result : { ok: false, error: result.error.slice(0, 4096) };
+	} catch (error) {
+		return { ok: false, error: error instanceof Error ? error.message.slice(0, 4096) : "Workflow resource resolution failed." };
+	}
+}
+
+function resolveResource(nameValue: unknown, argsValue?: unknown, sessionId?: string): WorkflowResourceResolution {
 	if (typeof nameValue !== "string" || !nameValue.trim()) return { ok: false, error: "workflow must be a non-empty resource name." };
 	const name = nameValue.trim();
 	if (!RESOURCE_NAME_PATTERN.test(name)) return { ok: false, error: "workflow must use a safe resource name." };
-	const resource = findWorkflowResource(name);
+	const resource = findWorkflowResource(name) ?? (sessionId ? registry().bySession.get(sessionId)?.get(name) : undefined);
 	if (!resource) return { ok: false, error: `Unknown workflow resource '${name}'. Available resources: ${listWorkflowResourceNames().join(", ")}.` };
 	const normalizedArgs = normalizeArgs(argsValue);
-	if (normalizedArgs.error) return { ok: false, error: normalizedArgs.error };
-	const resolved = resource.resolve(normalizedArgs.args!);
-	if ("error" in resolved) return { ok: false, error: resolved.error };
+	if ("error" in normalizedArgs) return { ok: false, error: normalizedArgs.error };
+	const resolved = resource.resolve(normalizedArgs.args);
+	if (resolved && typeof (resolved as unknown as { then?: unknown }).then === "function") {
+		void Promise.resolve(resolved).catch(() => {});
+		throw new Error("Workflow resource resolve must be synchronous.");
+	}
+	if (!isPlainRecord(resolved)) throw new Error("Workflow resource resolve must return an expansion or error object.");
+	if ("error" in resolved) {
+		if (Object.keys(resolved).some((key) => key !== "error") || typeof resolved.error !== "string" || !resolved.error.trim()) throw new Error("Workflow resource returned an invalid error.");
+		return { ok: false, error: resolved.error };
+	}
+	const { script, hostCommands } = resolved;
+	if (Object.keys(resolved).some((key) => key !== "script" && key !== "hostCommands") || typeof script !== "string" || !script.trim()) throw new Error("Workflow resource returned an invalid expansion.");
 	const resourceId = randomUUID();
 	const permit = createWorkflowResourcePermit({
 		resourceName: resource.name,
 		resourceVersion: resource.version,
 		resourceId,
-		scriptDigest: stableJsonDigest(resolved.script),
-		authority: resolved.authority,
+		scriptDigest: stableJsonDigest(script),
+		authority: { host: hostCommands },
 	});
-	const provenance: WorkflowResourceProvenanceV1 = Object.freeze({
+	const provenance: WorkflowResourceProvenance = Object.freeze({
 		kind: "workflow",
 		name: resource.name,
 		version: resource.version,
@@ -146,5 +221,5 @@ export function resolveWorkflowResource(nameValue: unknown, argsValue?: unknown)
 		expansion: "resolved",
 		id: resourceId,
 	});
-	return { ok: true, resource: { script: resolved.script, permit, provenance } };
+	return { ok: true, resource: { script, permit, provenance } };
 }

package/src/workflows/workflow-settlement.ts

@@ -209,6 +209,8 @@ export function planWorkflowSettlement(input: {
 		if (!resolution) resolution = classifyWorkflowSettlement(status);
 	}
 	const recovery = workflowRecoveryActions(receipt);
+	delete status.workflowReceiptPath;
+	if (receipt && input.receiptPath) status.workflowReceiptPath = input.receiptPath;
 	if (receipt) {
 		receipt = {
 			...receipt,
@@ -233,6 +235,7 @@ export function planWorkflowSettlement(input: {
 		timestamp: now,
 	};
 	const terminal = status.state === "complete" || status.state === "failed" || status.state === "partial" || status.state === "stopped";
+	if (!status.workflowReceiptPath) delete publicResult.workflowReceipt;
 	const completionEvent = terminal ? {
 		type: "subagent.workflow.completed",
 		state: status.state,