@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/src/workflows/structured-workflow-scripts.ts

@@ -0,0 +1,177 @@
+/**
+ * Package-owned workflow scripts for the data-only `tasks` and `chain` inputs.
+ * Callers supply only data; every caller string is embedded with JSON.stringify
+ * and never becomes code. Scripts run on the ordinary workflow runtime.
+ */
+
+export type StructuredWorkflowKind = "tasks" | "chain";
+
+const OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const PLACEHOLDER_PATTERN = /\{(?:task|previous|outputs\.([A-Za-z_][A-Za-z0-9_]*))\}/g;
+
+interface TemplateScope {
+	path: string;
+	/** Whether the script declares `originalTask` for {task}. */
+	hasOriginalTask: boolean;
+	/** Script variable holding the previous step's output, or the reason {previous} is unavailable. */
+	previous: { variable: string } | { unavailable: string };
+	/** Script variables for outputs named by earlier sequential steps; undefined when named outputs are unavailable. */
+	outputs?: ReadonlyMap<string, string>;
+	outputsUnavailable?: string;
+}
+
+interface StepChild {
+	key: string;
+	agent: string;
+	taskExpression: string;
+}
+
+export function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+function nonEmptyString(value: unknown, path: string): string {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${path} must be a non-empty string.`);
+	return value;
+}
+
+function exactFields(value: unknown, path: string, allowed: readonly string[], hint: string): Record<string, unknown> {
+	if (!isPlainRecord(value)) throw new Error(`${path} must be an object.`);
+	const unsupported = Object.keys(value).filter((key) => !allowed.includes(key));
+	if (unsupported.length > 0) throw new Error(`${path} contains unsupported fields: ${unsupported.join(", ")}. ${hint}`);
+	return value;
+}
+
+/** Single pass: text inserted for a placeholder is never scanned again. Unrecognized brace text stays literal. */
+function compileTemplate(template: string, scope: TemplateScope): string {
+	const parts: string[] = [];
+	let cursor = 0;
+	for (const match of template.matchAll(PLACEHOLDER_PATTERN)) {
+		const literal = template.slice(cursor, match.index);
+		cursor = match.index + match[0].length;
+		let variable: string;
+		if (match[0] === "{task}") {
+			if (!scope.hasOriginalTask) throw new Error(`${scope.path} references {task}, but no top-level task was provided.`);
+			variable = "originalTask";
+		} else if (match[0] === "{previous}") {
+			if ("unavailable" in scope.previous) throw new Error(`${scope.path} cannot use {previous}; ${scope.previous.unavailable}`);
+			variable = scope.previous.variable;
+		} else {
+			const name = match[1]!;
+			if (!scope.outputs) throw new Error(`${scope.path} cannot use {outputs.${name}}; ${scope.outputsUnavailable}`);
+			const named = scope.outputs.get(name);
+			if (!named) throw new Error(`${scope.path} references {outputs.${name}}, but no earlier sequential step sets as: "${name}".`);
+			variable = named;
+		}
+		if (literal) parts.push(JSON.stringify(literal));
+		parts.push(variable);
+	}
+	const literal = template.slice(cursor);
+	if (literal || parts.length === 0) parts.push(JSON.stringify(literal));
+	return parts.join(" + ");
+}
+
+function prelude(originalTask: string | undefined): string[] {
+	return originalTask === undefined ? [SETTLE_HELPER] : [SETTLE_HELPER, `const originalTask = ${JSON.stringify(originalTask)};`];
+}
+
+function runsAllCall(children: readonly StepChild[]): string {
+	return `await runs.all([${children.map((child) => `{ key: ${JSON.stringify(child.key)}, agent: ${JSON.stringify(child.agent)}, task: ${child.taskExpression} }`).join(", ")}])`;
+}
+
+const SETTLE_HELPER = [
+	"function settle(results, agents) {",
+	"  return results.map(function (result, index) {",
+	"    const child = { key: result.key, agent: agents[index], ok: result.ok === true, output: typeof result.output === \"string\" ? result.output : \"\" };",
+	"    if (!child.ok && typeof result.error === \"string\") child.error = result.error;",
+	"    return child;",
+	"  });",
+	"}",
+	// A failed child fails the workflow; the runtime keeps every settled child in the partial results.
+	"function failure(label, children) {",
+	"  return new Error(label + \": \" + children.filter(function (child) { return !child.ok; }).map(function (child) { return child.key + \" (\" + child.agent + \") failed\" + (child.error ? \": \" + child.error : \"\"); }).join(\"; \"));",
+	"}",
+].join("\n");
+
+function buildTasksScript(steps: unknown, originalTask: string | undefined): string {
+	if (!Array.isArray(steps) || steps.length === 0) throw new Error("tasks must be a non-empty array of { agent, task } items.");
+	const children = steps.map((item, index): StepChild => {
+		const path = `tasks[${index}]`;
+		const record = exactFields(item, path, ["agent", "task"], "Each tasks item accepts only agent and task.");
+		const agent = nonEmptyString(record.agent, `${path}.agent`);
+		const task = nonEmptyString(record.task, `${path}.task`);
+		const taskExpression = compileTemplate(task, {
+			path: `${path}.task`,
+			hasOriginalTask: originalTask !== undefined,
+			previous: { unavailable: "tasks items may only use {task}." },
+			outputsUnavailable: "tasks items may only use {task}.",
+		});
+		return { key: `task-${index + 1}`, agent, taskExpression };
+	});
+	return [
+		...prelude(originalTask),
+		`const run1 = ${runsAllCall(children)};`,
+		`const children = settle(run1, ${JSON.stringify(children.map((child) => child.agent))});`,
+		"if (!children.every(function (child) { return child.ok; })) throw failure(\"tasks failed\", children);",
+		"return { ok: true, children };",
+	].join("\n");
+}
+
+function buildChainScript(steps: unknown, originalTask: string | undefined): string {
+	if (!Array.isArray(steps) || steps.length === 0) throw new Error("chain must be a non-empty array of steps.");
+	const lines = [...prelude(originalTask), "const children = [];"];
+	const hasOriginalTask = originalTask !== undefined;
+	const outputs = new Map<string, string>();
+	for (const [index, step] of steps.entries()) {
+		const number = index + 1;
+		const path = `chain[${index}]`;
+		const previous: TemplateScope["previous"] = index === 0
+			? { unavailable: "the first chain step has no previous output." }
+			: { variable: `output${index}` };
+		let stepChildren: StepChild[];
+		let outputName: string | undefined;
+		if (isPlainRecord(step) && Object.hasOwn(step, "parallel")) {
+			const record = exactFields(step, path, ["parallel"], "A parallel step accepts only parallel; as is supported on sequential steps only.");
+			const items = record.parallel;
+			if (!Array.isArray(items) || items.length === 0) throw new Error(`${path}.parallel must be a non-empty array of { agent, task } items.`);
+			stepChildren = items.map((item, itemIndex): StepChild => {
+				const itemPath = `${path}.parallel[${itemIndex}]`;
+				const itemRecord = exactFields(item, itemPath, ["agent", "task"], "Each parallel item accepts only agent and task.");
+				const agent = nonEmptyString(itemRecord.agent, `${itemPath}.agent`);
+				const task = nonEmptyString(itemRecord.task, `${itemPath}.task`);
+				return { key: `step-${number}-${itemIndex + 1}`, agent, taskExpression: compileTemplate(task, { path: `${itemPath}.task`, hasOriginalTask, previous, outputs }) };
+			});
+		} else {
+			const record = exactFields(step, path, ["agent", "task", "as"], "A sequential step accepts only agent, task and as; a parallel step accepts only parallel.");
+			const agent = nonEmptyString(record.agent, `${path}.agent`);
+			let task: string;
+			if (record.task === undefined) {
+				if (index === 0) throw new Error(`${path}.task is required; the first chain step has no previous output.`);
+				task = "{previous}";
+			} else task = nonEmptyString(record.task, `${path}.task`);
+			if (record.as !== undefined) {
+				if (typeof record.as !== "string" || !OUTPUT_NAME_PATTERN.test(record.as)) throw new Error(`${path}.as must be an identifier matching ${OUTPUT_NAME_PATTERN}.`);
+				if (outputs.has(record.as)) throw new Error(`${path}.as '${record.as}' is already used by an earlier step.`);
+				outputName = record.as;
+			}
+			stepChildren = [{ key: `step-${number}`, agent, taskExpression: compileTemplate(task, { path: `${path}.task`, hasOriginalTask, previous, outputs }) }];
+		}
+		lines.push(
+			`const run${number} = ${runsAllCall(stepChildren)};`,
+			`const step${number} = settle(run${number}, ${JSON.stringify(stepChildren.map((child) => child.agent))});`,
+			`children.push(...step${number});`,
+			`if (!step${number}.every(function (child) { return child.ok; })) throw failure(${JSON.stringify(`chain stopped at step ${number}`)}, step${number});`,
+		);
+		if (index < steps.length - 1) lines.push(`const output${number} = step${number}.map(function (child) { return child.output; }).join("\\n\\n");`);
+		if (outputName !== undefined) outputs.set(outputName, `output${number}`);
+	}
+	lines.push("return { ok: true, children };");
+	return lines.join("\n");
+}
+
+/** Validate exact data shapes and expand them into a package-owned workflow script. */
+export function buildStructuredWorkflowScript(kind: StructuredWorkflowKind, steps: unknown, originalTask: string | undefined): string {
+	return kind === "tasks" ? buildTasksScript(steps, originalTask) : buildChainScript(steps, originalTask);
+}

package/dist/extensions/pi-subagents/src/workflows/workflow-checklist.ts

@@ -1,4 +1,5 @@
 import type { AsyncJobStep, HostStepNode, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowPreflightLane, WorkflowPreflight } from "../shared/types.ts";
+import { childThinkingLevel, type ThinkingLevel } from "../shared/model-info.ts";
 import { sanitizeDisplayText } from "../shared/display-text.ts";
 import { workflowPreflightLaneForRuntimeKey as laneFor } from "./workflow-preflight.ts";
 
@@ -6,6 +7,7 @@ export type WorkflowChecklistState = "complete" | "running" | "queued" | "blocke
 
 export interface WorkflowChecklistStep {
 	key?: string;
+	thinking?: string;
 	workflowKey?: string;
 	runId?: string;
 	label?: string;
@@ -53,6 +55,8 @@ export interface WorkflowChecklistItem {
 	phase: string;
 	state: WorkflowChecklistState;
 	agent?: string;
+	/** Thinking level of the child this item stands for. */
+	thinking?: ThinkingLevel;
 	context?: "fresh" | "fork";
 	startedAt?: number;
 	durationMs?: number;
@@ -186,7 +190,7 @@ function duration(step: Pick<WorkflowChecklistStep, "durationMs" | "startedAt" |
 	const startedAt = finite(step.startedAt);
 	if (explicit !== undefined) return Math.max(0, explicit);
 	if (startedAt === undefined) return undefined;
-	const end = state === "running" ? now : finite(step.endedAt) ?? now;
+	const end = state === "running" ? now : finite(step.endedAt);
 	return end === undefined ? undefined : Math.max(0, end - startedAt);
 }
 
@@ -196,12 +200,14 @@ function stepKey(step: WorkflowChecklistStep): string | undefined {
 
 function stepItem(step: WorkflowChecklistStep, index: number, phase: string, key = stepKey(step) ?? `step-${index + 1}`, label = step.label ?? step.description ?? stepKey(step) ?? step.agent ?? key, preflight?: WorkflowPreflightLane): WorkflowChecklistItem {
 	const state = checklistState(step);
+	const thinking = childThinkingLevel(step);
 	return {
 		key: keyText(key, `step-${index + 1}`),
 		label: keyText(label, key),
 		phase,
 		state,
 		...(text(step.agent) ? { agent: text(step.agent) } : {}),
+		...(thinking ? { thinking } : {}),
 		...(step.context ? { context: step.context } : {}),
 		...(finite(step.startedAt) !== undefined ? { startedAt: finite(step.startedAt) } : {}),
 		...(duration(step, undefined, state) !== undefined ? { durationMs: duration(step, undefined, state) } : {}),
@@ -296,7 +302,7 @@ function priority(item: WorkflowChecklistItem): number {
 }
 
 function applyNow(item: WorkflowChecklistItem, now: number | undefined): WorkflowChecklistItem {
-	return item.durationMs === undefined && item.startedAt !== undefined && now !== undefined ? { ...item, durationMs: Math.max(0, now - item.startedAt) } : item;
+	return item.state === "running" && item.startedAt !== undefined && now !== undefined ? { ...item, durationMs: Math.max(0, now - item.startedAt) } : item;
 }
 
 function finalize(phase: WorkflowChecklistPhase): void {

package/dist/extensions/pi-subagents/src/workflows/workflow-child-summary.ts

@@ -61,6 +61,7 @@ export function workflowChildSummary(input: {
 	progress?: ReadonlyMap<string, WorkflowChildLiveProgress>;
 }): WorkflowChildSummary {
 	const rows = new Map<string, WorkflowChildSummary["children"][number]>();
+	const runningAsyncKeys = new Set(input.children?.filter((child) => child.state === "running").map((child) => child.key));
 	for (const entry of input.trace ?? []) {
 		if (entry.operation !== "run" || !KEY_PATTERN.test(entry.key)) continue;
 		const previous = rows.get(entry.key);
@@ -82,6 +83,7 @@ export function workflowChildSummary(input: {
 	for (const step of input.steps ?? []) {
 		const key = step.workflowKey;
 		if (!key || !KEY_PATTERN.test(key)) continue;
+		if (step.async && step.runId && step.status === "running") runningAsyncKeys.add(key);
 		const state = step.status === "complete" || step.status === "completed" ? "completed"
 			: step.status === "failed" ? "failed"
 				: step.status === "paused" ? "paused"
@@ -102,7 +104,7 @@ export function workflowChildSummary(input: {
 	for (const child of input.children ?? []) {
 		if (!KEY_PATTERN.test(child.key)) continue;
 		const result = Array.isArray(child.results) ? child.results.find((value) => value && typeof value === "object") as Record<string, unknown> | undefined : undefined;
-		const state = child.detached ? "detached" : child.stopped ? "stopped" : child.interrupted ? "paused" : child.ok ? "completed" : result?.acceptance && typeof result.acceptance === "object" && (result.acceptance as { status?: unknown }).status === "rejected" ? "rejected" : "failed";
+		const state = child.state === "running" ? "running" : child.detached ? "detached" : child.stopped ? "stopped" : child.interrupted ? "paused" : child.ok ? "completed" : result?.acceptance && typeof result.acceptance === "object" && (result.acceptance as { status?: unknown }).status === "rejected" ? "rejected" : "failed";
 		rows.set(child.key, {
 			childId: child.key,
 			state,
@@ -115,7 +117,7 @@ export function workflowChildSummary(input: {
 	}
 	if (input.inventoryComplete) {
 		for (const [key, row] of rows) {
-			if (!TERMINAL_STATES.has(row.state)) rows.set(key, { ...row, state: input.workflowState === "stopped" ? "stopped" : "failed" });
+			if (!TERMINAL_STATES.has(row.state) && !runningAsyncKeys.has(key)) rows.set(key, { ...row, state: input.workflowState === "stopped" ? "stopped" : "failed" });
 		}
 	}
 	for (const [key, progress] of input.progress ?? []) {
@@ -167,4 +169,4 @@ export function parseWorkflowChildSummary(value: unknown): WorkflowChildSummary
 	if (typeof input.parentToolCallId !== "string") throw new Error("workflowChildren.parentToolCallId is invalid.");
 	if (typeof input.workflowRunId !== "string") throw new Error("workflowChildren.workflowRunId is invalid.");
 	return { version: 1, parentToolCallId: requiredId(input.parentToolCallId, "workflowChildren.parentToolCallId"), workflowRunId: requiredId(input.workflowRunId, "workflowChildren.workflowRunId"), inventoryComplete: input.inventoryComplete, workflowState, children };
-}
+}

package/dist/extensions/pi-subagents/src/workflows/workflow-receipt.ts

@@ -6,6 +6,7 @@ import type { WorkflowReceiptResumeReference, WorkflowScriptChildResult } from "
 import { parseWorkflowChildSummary } from "./workflow-child-summary.ts";
 import { HOST_STEP_MAX_COUNT, assertUniqueHostStepIds, parseHostStepNode } from "../runs/shared/host-step-status.ts";
 import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "../runs/shared/lane-metadata.ts";
+import { projectWorkflowKeyRevival } from "./workflow-revival.ts";
 
 export type { WorkflowReceipt, WorkflowReceiptEntry, WorkflowReceiptState } from "../shared/types.ts";
 
@@ -37,6 +38,7 @@ export function buildWorkflowReceipt(input: {
 	workflowRunId: string;
 	state: WorkflowReceiptState;
 	children: WorkflowScriptChildResult[];
+	argsDigest?: string;
 	hostSteps?: WorkflowReceipt["hostSteps"];
 	workflowChildren?: WorkflowReceipt["workflowChildren"];
 	resource?: WorkflowResourceProvenance;
@@ -44,6 +46,7 @@ export function buildWorkflowReceipt(input: {
 	createdAt?: number;
 }): WorkflowReceipt {
 	const workflowRunId = assertSafeRunId(input.workflowRunId, "workflowRunId");
+	if (input.argsDigest !== undefined && !/^[a-f0-9]{64}$/u.test(input.argsDigest)) throw new Error("workflow receipt argsDigest must be a lowercase SHA-256 digest.");
 	if (input.workflowChildren?.workflowRunId !== undefined && input.workflowChildren.workflowRunId !== workflowRunId) throw new Error("workflowChildren workflowRunId does not match its receipt.");
 	const entries: Record<string, WorkflowReceiptEntry> = Object.create(null) as Record<string, WorkflowReceiptEntry>;
 	for (const child of input.children) {
@@ -75,7 +78,7 @@ export function buildWorkflowReceipt(input: {
 	const hostSteps = input.hostSteps?.map((hostStep, index) => parseHostStepNode(hostStep, `workflow receipt hostSteps[${index}]`));
 	if (hostSteps) assertUniqueHostStepIds(hostSteps, "workflow receipt");
 	const resource = parseWorkflowResource(input.resource, "workflow receipt");
-	return { version: WORKFLOW_RECEIPT_VERSION, workflowRunId, state: input.state, createdAt: input.createdAt ?? Date.now(), entries, ...(resource ? { resource } : {}), ...(hostSteps?.length ? { hostSteps } : {}), ...(input.workflowChildren ? { workflowChildren: input.workflowChildren } : {}), ...(input.terminalOutcome ? { terminalOutcome: input.terminalOutcome } : {}) };
+	return { version: WORKFLOW_RECEIPT_VERSION, workflowRunId, state: input.state, createdAt: input.createdAt ?? Date.now(), entries, ...(input.argsDigest ? { argsDigest: input.argsDigest } : {}), ...(resource ? { resource } : {}), ...(hostSteps?.length ? { hostSteps } : {}), ...(input.workflowChildren ? { workflowChildren: input.workflowChildren } : {}), ...(input.terminalOutcome ? { terminalOutcome: input.terminalOutcome } : {}) };
 }
 
 export function writeWorkflowReceipt(asyncDir: string, receipt: WorkflowReceipt): string {
@@ -115,19 +118,33 @@ const EXTERNAL_CLI_CAPABILITIES = {
 	extensionBindings: false,
 } as const;
 
+function parseExternalCliMachine(value: unknown, label: string): void {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label}.machine must be an object.`);
+	const machine = value as Record<string, unknown>;
+	const unknownMachine = Object.keys(machine).filter((field) => !["provider", "id", "label", "target", "session", "cwd", "remoteGit"].includes(field));
+	if (unknownMachine.length > 0) throw new Error(`${label}.machine has unsupported fields: ${unknownMachine.join(", ")}.`);
+	if (machine.provider !== "herdr" || typeof machine.id !== "string" || !machine.id.trim() || typeof machine.target !== "string" || !machine.target.trim() || typeof machine.cwd !== "string" || !machine.cwd.trim()) throw new Error(`${label}.machine is invalid.`);
+	for (const field of ["label", "session"] as const) if (machine[field] !== undefined && (typeof machine[field] !== "string" || !machine[field].trim())) throw new Error(`${label}.machine.${field} is invalid.`);
+	if (machine.remoteGit === undefined) return;
+	if (!machine.remoteGit || typeof machine.remoteGit !== "object" || Array.isArray(machine.remoteGit)) throw new Error(`${label}.machine.remoteGit must be an object.`);
+	const remoteGit = machine.remoteGit as Record<string, unknown>;
+	const unknownRemoteGit = Object.keys(remoteGit).filter((field) => !["head", "branch", "dirty"].includes(field));
+	if (unknownRemoteGit.length > 0 || (remoteGit.head !== undefined && (typeof remoteGit.head !== "string" || !remoteGit.head.trim())) || (remoteGit.branch !== undefined && (typeof remoteGit.branch !== "string" || !remoteGit.branch.trim())) || (remoteGit.dirty !== undefined && typeof remoteGit.dirty !== "boolean")) throw new Error(`${label}.machine.remoteGit is invalid.`);
+}
+
 function parseExternalCliReceiptMetadata(value: unknown, key: string, source: string): ExternalCliReceiptMetadata | undefined {
 	if (value === undefined) return undefined;
 	const label = `Invalid workflow receipt '${source}': entry '${key}' externalAdapter`;
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object.`);
 	const metadata = value as Record<string, unknown>;
-	const unknownMetadata = Object.keys(metadata).filter((field) => !["adapter", "capabilities", "safety", "outputArtifacts", "handoff", "supervisor", "nonResumableReason"].includes(field));
+	const unknownMetadata = Object.keys(metadata).filter((field) => !["adapter", "capabilities", "machine", "safety", "outputArtifacts", "handoff", "supervisor", "nonResumableReason"].includes(field));
 	if (unknownMetadata.length > 0) throw new Error(`${label} has unsupported fields: ${unknownMetadata.join(", ")}.`);
 	const adapter = metadata.adapter;
 	if (!adapter || typeof adapter !== "object" || Array.isArray(adapter)) throw new Error(`${label}.adapter must be an object.`);
 	const adapterRecord = adapter as Record<string, unknown>;
 	const unknownAdapter = Object.keys(adapterRecord).filter((field) => !["id", "version", "executionMode"].includes(field));
 	if (unknownAdapter.length > 0) throw new Error(`${label}.adapter has unsupported fields: ${unknownAdapter.join(", ")}.`);
-	if ((adapterRecord.id !== "external-cli" && adapterRecord.id !== "grok-build") || adapterRecord.version !== 1 || adapterRecord.executionMode !== (adapterRecord.id === "grok-build" ? "one-shot-prompt-file" : "one-shot-stdin")) throw new Error(`${label}.adapter is invalid.`);
+	if ((adapterRecord.id !== "external-cli" && adapterRecord.id !== "codex-exec" && adapterRecord.id !== "codex-exec-writer" && adapterRecord.id !== "claude-code" && adapterRecord.id !== "claude-code-writer" && adapterRecord.id !== "cursor-agent" && adapterRecord.id !== "cursor-agent-writer" && adapterRecord.id !== "grok-build") || adapterRecord.version !== 1 || adapterRecord.executionMode !== (adapterRecord.id === "cursor-agent" || adapterRecord.id === "cursor-agent-writer" || adapterRecord.id === "grok-build" ? "one-shot-prompt-file" : "one-shot-stdin")) throw new Error(`${label}.adapter is invalid.`);
 	const capabilities = metadata.capabilities;
 	if (!capabilities || typeof capabilities !== "object" || Array.isArray(capabilities)) throw new Error(`${label}.capabilities must be an object.`);
 	const capabilityRecord = capabilities as Record<string, unknown>;
@@ -136,8 +153,45 @@ function parseExternalCliReceiptMetadata(value: unknown, key: string, source: st
 	for (const [capability, expected] of Object.entries(EXTERNAL_CLI_CAPABILITIES)) {
 		if (capabilityRecord[capability] !== expected) throw new Error(`${label}.capabilities.${capability} is invalid.`);
 	}
+	if (metadata.machine !== undefined) parseExternalCliMachine(metadata.machine, label);
 	const safety = metadata.safety;
-	if (adapterRecord.id === "grok-build") {
+	if (adapterRecord.id === "codex-exec") {
+		if (!safety || typeof safety !== "object" || Array.isArray(safety)) throw new Error(`${label}.safety is missing.`);
+		const safetyRecord = safety as Record<string, unknown>;
+		const unknownSafety = Object.keys(safetyRecord).filter((field) => !["sandbox", "approvalPolicy", "ephemeral"].includes(field));
+		if (unknownSafety.length > 0) throw new Error(`${label}.safety has unsupported fields: ${unknownSafety.join(", ")}.`);
+		if (safetyRecord.sandbox !== "read-only" || safetyRecord.approvalPolicy !== "never" || safetyRecord.ephemeral !== true) throw new Error(`${label}.safety is invalid.`);
+	} else if (adapterRecord.id === "codex-exec-writer") {
+		if (!safety || typeof safety !== "object" || Array.isArray(safety)) throw new Error(`${label}.safety is missing.`);
+		const safetyRecord = safety as Record<string, unknown>;
+		const unknownSafety = Object.keys(safetyRecord).filter((field) => !["access", "sandbox", "approvalPolicy", "ephemeral"].includes(field));
+		if (unknownSafety.length > 0) throw new Error(`${label}.safety has unsupported fields: ${unknownSafety.join(", ")}.`);
+		if (safetyRecord.access !== "workspace-write" || safetyRecord.sandbox !== "workspace-write" || safetyRecord.approvalPolicy !== "never" || safetyRecord.ephemeral !== true) throw new Error(`${label}.safety is invalid.`);
+	} else if (adapterRecord.id === "claude-code") {
+		if (!safety || typeof safety !== "object" || Array.isArray(safety)) throw new Error(`${label}.safety is missing.`);
+		const safetyRecord = safety as Record<string, unknown>;
+		const legacy = safetyRecord.authentication === undefined;
+		const unknownSafety = Object.keys(safetyRecord).filter((field) => !(legacy
+			? ["permissionMode", "tools", "mcp", "settingSources", "sessionPersistence"]
+			: ["access", "authentication", "permissionMode", "tools", "mcp", "settingSources", "userSettingsTrust", "sessionPersistence"]).includes(field));
+		if (unknownSafety.length > 0) throw new Error(`${label}.safety has unsupported fields: ${unknownSafety.join(", ")}.`);
+		if (legacy) {
+			if (safetyRecord.permissionMode !== "plan" || safetyRecord.tools !== "none" || safetyRecord.mcp !== "empty-strict" || safetyRecord.settingSources !== "none" || safetyRecord.sessionPersistence !== false) throw new Error(`${label}.safety is invalid.`);
+		} else if (safetyRecord.access !== "read-only" || safetyRecord.authentication !== "existing-cli-required" || safetyRecord.permissionMode !== "plan" || safetyRecord.tools !== "none" || safetyRecord.mcp !== "empty-strict" || safetyRecord.settingSources !== "user" || safetyRecord.userSettingsTrust !== "required" || safetyRecord.sessionPersistence !== false) throw new Error(`${label}.safety is invalid.`);
+	} else if (adapterRecord.id === "claude-code-writer") {
+		if (!safety || typeof safety !== "object" || Array.isArray(safety)) throw new Error(`${label}.safety is missing.`);
+		const safetyRecord = safety as Record<string, unknown>;
+		const unknownSafety = Object.keys(safetyRecord).filter((field) => !["access", "authentication", "permissionMode", "tools", "mcp", "settingSources", "userSettingsTrust", "sessionPersistence"].includes(field));
+		if (unknownSafety.length > 0) throw new Error(`${label}.safety has unsupported fields: ${unknownSafety.join(", ")}.`);
+		if (safetyRecord.access !== "workspace-write" || safetyRecord.authentication !== "existing-cli-required" || safetyRecord.permissionMode !== "acceptEdits" || safetyRecord.tools !== "Read,Write,Edit,Glob,Grep" || safetyRecord.mcp !== "empty-strict" || safetyRecord.settingSources !== "user" || safetyRecord.userSettingsTrust !== "required" || safetyRecord.sessionPersistence !== false) throw new Error(`${label}.safety is invalid.`);
+	} else if (adapterRecord.id === "cursor-agent" || adapterRecord.id === "cursor-agent-writer") {
+		if (!safety || typeof safety !== "object" || Array.isArray(safety)) throw new Error(`${label}.safety is missing.`);
+		const safetyRecord = safety as Record<string, unknown>;
+		const unknownSafety = Object.keys(safetyRecord).filter((field) => !["access", "authentication", "mode", "sandbox", "workspaceTrust", "sessionReuse"].includes(field));
+		if (unknownSafety.length > 0) throw new Error(`${label}.safety has unsupported fields: ${unknownSafety.join(", ")}.`);
+		const writer = adapterRecord.id === "cursor-agent-writer";
+		if (safetyRecord.access !== (writer ? "workspace-write" : "read-only") || safetyRecord.authentication !== "cursor-api-key-or-existing-login" || safetyRecord.mode !== (writer ? "print" : "ask") || safetyRecord.sandbox !== "enabled" || safetyRecord.workspaceTrust !== "existing-required" || safetyRecord.sessionReuse !== false) throw new Error(`${label}.safety is invalid.`);
+	} else if (adapterRecord.id === "grok-build") {
 		if (!safety || typeof safety !== "object" || Array.isArray(safety)) throw new Error(`${label}.safety is missing.`);
 		const safetyRecord = safety as Record<string, unknown>;
 		const unknownSafety = Object.keys(safetyRecord).filter((field) => !["access", "authentication", "permissionMode", "tools", "deniedTools", "sandbox", "webSearch", "subagents", "config", "updates", "sessionPersistence"].includes(field));
@@ -267,9 +321,9 @@ export function readWorkflowReceipt(asyncDirRoot: string, workflowRunId: string)
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
 			const workflowDir = path.dirname(receiptPath);
 			if (fs.existsSync(path.join(workflowDir, "status.json")) || fs.existsSync(path.join(workflowDir, "events.jsonl"))) {
-				throw new Error(`Workflow receipt '${workflowRunId}' is not available because the workflow may still be active or terminal receipt writing failed. Use direct child run IDs from status/events for direct resume after the normal retained-child checks.`);
+				throw new Error(`Workflow receipt '${workflowRunId}' is not available because the workflow may still be active or terminal receipt writing failed. Use direct child run IDs from status/events for direct resume after the normal retained-child checks.`, { cause: error });
 			}
-			throw new Error(`Workflow receipt '${workflowRunId}' was not found.`);
+			throw new Error(`Workflow receipt '${workflowRunId}' was not found.`, { cause: error });
 		}
 		throw new Error(`Workflow receipt '${workflowRunId}' could not be read: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : undefined });
 	}
@@ -294,10 +348,11 @@ export function readWorkflowReceipt(asyncDirRoot: string, workflowRunId: string)
 		assertUniqueHostStepIds(hostSteps, receiptPath);
 	}
 	const workflowResolution = parseWorkflowResolution(receipt.workflowResolution, receiptPath);
+	if (receipt.argsDigest !== undefined && (typeof receipt.argsDigest !== "string" || !/^[a-f0-9]{64}$/u.test(receipt.argsDigest))) throw new Error(`Invalid workflow receipt '${receiptPath}': argsDigest is invalid.`);
 	const resource = parseWorkflowResource(receipt.resource, receiptPath);
 	const terminalOutcome = parseTerminalOutcome(receipt.terminalOutcome, `Invalid workflow receipt '${receiptPath}': terminalOutcome`);
 	const recovery = parseRecovery(receipt.recovery, workflowRunId, entries, receiptPath);
-	return { version: 1, workflowRunId, state: receipt.state, createdAt: receipt.createdAt, entries, ...(resource ? { resource } : {}), ...(hostSteps?.length ? { hostSteps } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(workflowResolution ? { workflowResolution } : {}), ...(terminalOutcome ? { terminalOutcome } : {}), ...(recovery ? { recovery } : {}) };
+	return { version: 1, workflowRunId, state: receipt.state, createdAt: receipt.createdAt, entries, ...(receipt.argsDigest ? { argsDigest: receipt.argsDigest } : {}), ...(resource ? { resource } : {}), ...(hostSteps?.length ? { hostSteps } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(workflowResolution ? { workflowResolution } : {}), ...(terminalOutcome ? { terminalOutcome } : {}), ...(recovery ? { recovery } : {}) };
 }
 
 export function resolveWorkflowReceiptResumeEntry(input: {
@@ -308,8 +363,13 @@ export function resolveWorkflowReceiptResumeEntry(input: {
 	if (input.reference.latest !== true) throw new Error("Keyed workflow receipt resume requires latest: true.");
 	const key = assertKey(input.reference.key, "keyed resume key");
 	const receipt = readWorkflowReceipt(input.asyncDirRoot, input.reference.workflowRunId.trim());
-	const entry = receipt.entries[key];
-	if (!entry) throw new Error(`Workflow receipt '${receipt.workflowRunId}' has no child key '${key}'.`);
+	const recorded = receipt.entries[key];
+	if (!recorded) throw new Error(`Workflow receipt '${receipt.workflowRunId}' has no child key '${key}'.`);
+	// A detached top-level revival after the receipt was written continues this key's lineage.
+	const revival = recorded.latestRunId ? projectWorkflowKeyRevival(input.asyncDirRoot, receipt.workflowRunId, key, recorded.latestRunId) : undefined;
+	const entry = revival
+		? { ...recorded, latestRunId: revival.latestRunId, continuation: { runIds: [...recorded.continuation.runIds, ...revival.revivedRunIds] } }
+		: recorded;
 	assertResumableEntry(entry, receipt.workflowRunId, key);
 	input.assertResumable?.(entry.latestRunId);
 	return entry;
@@ -327,4 +387,4 @@ export function resolveWorkflowReceiptResume(input: {
 }): string {
 	const entry = resolveWorkflowReceiptResumeEntry(input);
 	return entry.latestRunId;
-}
+}

package/dist/extensions/pi-subagents/src/workflows/workflow-resources.ts

@@ -6,9 +6,13 @@ import {
 	type WorkflowResourcePermit,
 } from "../shared/workflow-child-permit.ts";
 import type { WorkflowResourceProvenance } from "../shared/types.ts";
+import { buildStructuredWorkflowScript, isPlainRecord } from "./structured-workflow-scripts.ts";
 
 const RESOURCE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-const MAX_ARGS_BYTES = 16 * 1024;
+export const MAX_ARGS_BYTES = 16 * 1024;
+export const MAX_ARGS_FIELDS = 16;
+export const MAX_ARGS_ITEMS = 64;
+export const MAX_ARGS_DEPTH = 8;
 const MAX_STRING_BYTES = 16 * 1024;
 
 export interface ResolvedWorkflowResource {
@@ -65,7 +69,7 @@ export function registerWorkflowResource(input: RegisterWorkflowResourceInput):
 	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.`);
+	if (findWorkflowResource(name) || STRUCTURED_WORKFLOW_RESOURCE_NAMES.includes(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.");
@@ -84,12 +88,6 @@ export function registerWorkflowResource(input: RegisterWorkflowResourceInput):
 	};
 }
 
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-
 function jsonByteLength(value: unknown): number {
 	try {
 		const encoded = JSON.stringify(value);
@@ -101,7 +99,7 @@ function jsonByteLength(value: unknown): number {
 }
 
 function validatePlainJson(value: unknown, path: string, depth = 0): void {
-	if (depth > 8) throw new Error(`${path} is too deeply nested.`);
+	if (depth > MAX_ARGS_DEPTH) throw new Error(`${path} is too deeply nested.`);
 	if (value === null || typeof value === "boolean") return;
 	if (typeof value === "string") {
 		if (!value.trim()) throw new Error(`${path} must not be empty.`);
@@ -113,19 +111,19 @@ function validatePlainJson(value: unknown, path: string, depth = 0): void {
 		return;
 	}
 	if (Array.isArray(value)) {
-		if (value.length > 64) throw new Error(`${path} contains too many items.`);
+		if (value.length > MAX_ARGS_ITEMS) throw new Error(`${path} contains too many items.`);
 		for (const [index, entry] of value.entries()) validatePlainJson(entry, `${path}[${index}]`, depth + 1);
 		return;
 	}
 	if (!isPlainRecord(value)) throw new Error(`${path} must contain plain JSON data.`);
-	if (Object.keys(value).length > 16) throw new Error(`${path} contains too many fields.`);
+	if (Object.keys(value).length > MAX_ARGS_FIELDS) throw new Error(`${path} contains too many fields.`);
 	for (const [key, entry] of Object.entries(value)) {
 		if (!key.trim()) throw new Error(`${path} contains an empty field name.`);
 		validatePlainJson(entry, `${path}.${key}`, depth + 1);
 	}
 }
 
-function normalizeArgs(value: unknown): { args: Record<string, unknown> } | { error: string } {
+export function normalizeWorkflowArgs(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 {
@@ -137,6 +135,17 @@ function normalizeArgs(value: unknown): { args: Record<string, unknown> } | { er
 	}
 }
 
+export function deepFreezeWorkflowArgs<T extends Record<string, unknown>>(args: T): Readonly<T> {
+	deepFreezeWorkflowValue(args);
+	return args;
+}
+
+function deepFreezeWorkflowValue(value: unknown): void {
+	if (!Array.isArray(value) && !isPlainRecord(value)) return;
+	for (const entry of Object.values(value)) deepFreezeWorkflowValue(entry);
+	Object.freeze(value);
+}
+
 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));
@@ -175,6 +184,32 @@ function listWorkflowResourceNames(): string[] {
 	return WORKFLOW_RESOURCES.map((resource) => resource.name);
 }
 
+/** Internal resources for the data-only tasks/chain inputs: reserved against registration, never resolvable or listed by name. */
+const STRUCTURED_WORKFLOW_RESOURCE_NAMES: readonly string[] = ["tasks", "chain"];
+const STRUCTURED_WORKFLOW_RESOURCE_VERSION = 1;
+
+/**
+ * Expand data-only `tasks` or `chain` input into a package-owned workflow script with a one-use permit.
+ * Only the executor calls this, after its own feature and input checks; public named lookup cannot reach it.
+ */
+export function resolveStructuredWorkflowResource(input: { kind: "tasks" | "chain"; steps: unknown; task?: unknown }): WorkflowResourceResolution {
+	try {
+		if (!isPlainRecord(input) || (input.kind !== "tasks" && input.kind !== "chain")) return { ok: false, error: "Structured workflow kind must be 'tasks' or 'chain'." };
+		const { kind, steps, task } = input;
+		if (!Array.isArray(steps) || steps.length === 0) return { ok: false, error: `${kind} must be a non-empty array.` };
+		validatePlainJson(steps, kind);
+		if (task !== undefined) {
+			if (typeof task !== "string" || !task.trim()) return { ok: false, error: "task must be a non-empty string when provided." };
+			validatePlainJson(task, "task");
+		}
+		if (jsonByteLength({ [kind]: steps, task }) > MAX_ARGS_BYTES) return { ok: false, error: `${kind} input exceeds ${MAX_ARGS_BYTES} bytes.` };
+		const script = buildStructuredWorkflowScript(kind, JSON.parse(JSON.stringify(steps)), task);
+		return { ok: true, resource: issueWorkflowResource(kind, STRUCTURED_WORKFLOW_RESOURCE_VERSION, script) };
+	} catch (error) {
+		return { ok: false, error: error instanceof Error ? error.message.slice(0, 4096) : "Structured workflow resolution failed." };
+	}
+}
+
 /** 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, sessionId?: string): WorkflowResourceResolution {
 	try {
@@ -191,7 +226,7 @@ function resolveResource(nameValue: unknown, argsValue?: unknown, sessionId?: st
 	if (!RESOURCE_NAME_PATTERN.test(name)) return { ok: false, error: "workflow must use a safe resource 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);
+	const normalizedArgs = normalizeWorkflowArgs(argsValue);
 	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") {
@@ -205,21 +240,25 @@ function resolveResource(nameValue: unknown, argsValue?: unknown, sessionId?: st
 	}
 	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.");
+	return { ok: true, resource: issueWorkflowResource(resource.name, resource.version, script, hostCommands) };
+}
+
+function issueWorkflowResource(name: string, version: number, script: string, hostCommands?: readonly WorkflowResourceHostAuthority[]): ResolvedWorkflowResource {
 	const resourceId = randomUUID();
 	const permit = createWorkflowResourcePermit({
-		resourceName: resource.name,
-		resourceVersion: resource.version,
+		resourceName: name,
+		resourceVersion: version,
 		resourceId,
 		scriptDigest: stableJsonDigest(script),
 		authority: { host: hostCommands },
 	});
 	const provenance: WorkflowResourceProvenance = Object.freeze({
 		kind: "workflow",
-		name: resource.name,
-		version: resource.version,
+		name,
+		version,
 		invocation: "named",
 		expansion: "resolved",
 		id: resourceId,
 	});
-	return { ok: true, resource: { script, permit, provenance } };
+	return { script, permit, provenance };
 }