@agimon-ai/doompi-workflow 0.0.1-alpha.97 → 0.0.1-alpha.99

package/dist/extensions/pi.mjs

@@ -1,204 +1,24 @@
-import { i as validateWorkflowLaunch, n as parseWorkflowLaunchCommand, r as resolveWorkflowEntry, t as isLaunchParseFailure } from "../workflowLaunchCommand-Bhr-PvdD.mjs";
-import { i as workflowSkillDirectory, n as registerRunProvider, t as createWorkflowTerminalService } from "../workflowTerminal-Bj4KKpoA.mjs";
+import { i as validateWorkflowLaunch, n as parseWorkflowLaunchCommand, r as resolveWorkflowEntry, t as isLaunchParseFailure } from "../workflowLaunchCommand-BLrxmzdd.mjs";
+import { A as LEADER_RECOVER_ACTION, C as LAUNCH_WORKFLOW_TOOL_NAME, D as LEADER_ENABLE_ACTION, E as LEADER_DISABLE_ACTION, M as PACKAGE_SOURCE, N as WORKFLOW_LAUNCH_ID_ENV, O as LEADER_LABEL, P as WORKFLOW_RUN_TOOL_NAME, S as resolveDispatcherParentSession, T as LEADER_DETAIL, _ as workflowSkillDirectory, a as createWorkflowLaunchExecutor, b as dispatcherTools, c as workflowToolRestriction, d as launchNotice, f as runsForSession, h as withOptions, i as appendGuidance, j as LIST_WORKFLOWS_TOOL_NAME, k as LEADER_MANAGE_ACTION, l as finishedRunSummary, m as toolResultText, n as registerRunProvider, o as launchFailureOptions, p as toAgentToolResult, r as actionGuidance, s as reportProgress, t as createWorkflowTerminalService, u as isSessionRun, v as createWorkflowFence, w as LEADER_CATALOG_ACTION, x as isWorkflowDispatcherProcess, y as dispatcherToolRestriction } from "../workflowTerminal-QzufjHCa.mjs";
 import { createRequire } from "node:module";
 import { defineMessageRenderer, definePiExtension, definePiTool, piToolContributions } from "@agimon-ai/doompi-core/piExtension";
 import { composeRootHooks, defineRoot, defineRoutedContribution } from "@agimon-ai/doompi-core/extensionFile";
 import { DOOM_SKILL_SOURCES_SERVICE, requireDoomSkillSourcesService } from "@agimon-ai/doompi-core/skills";
 import { DOOM_UI_HUB_SERVICE, requireDoomUiHub } from "@agimon-ai/doompi-core/uiHub";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { SUBAGENT_PARENT_SESSION_ENV, SUBAGENT_ROOT_SESSION_ENV, readChildProcessContext, resolveRootSessionId } from "@agimon-ai/doompi-core/childProcess";
+import { SUBAGENT_ROOT_SESSION_ENV, resolveRootSessionId } from "@agimon-ai/doompi-core/childProcess";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { basename, extname, resolve } from "node:path";
-import { WorkflowTerminalService, createEmbeddedWorkflowFeature, currentWorkflowPosition, readWorkflowProgress, summarizeWorkflowProgress } from "@agimon-ai/workflow-mcp";
+import { WorkflowTerminalService, compatibleCommands, createEmbeddedWorkflowFeature, currentWorkflowPosition, readWorkflowProgress, summarizeWorkflowProgress } from "@agimon-ai/workflow-mcp";
 import { z } from "zod";
+import { randomUUID } from "node:crypto";
 import { DoomToolCall, DoomToolResult, renderToolHeading } from "@agimon-ai/doompi-ui/toolChrome";
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
 import { DOOM_NARRATION_SERVICE, createNarrationRequest, requireDoomNarrationService } from "@agimon-ai/doompi-core/narration";
 import { createDoomReadinessCoordinator, readDoomReadinessCoordinator } from "@agimon-ai/doompi-core/readiness";
 import { defineMinorMode, piMinorModes } from "@agimon-ai/doompi-minor-mode";
 import { createDoomTelemetry } from "@agimon-ai/doompi-telemetry";
 import { Box, Key, Text, isKeyRelease, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-//#region src/constants/workflow.ts
-const PACKAGE_SOURCE = "@agimon-ai/doompi-workflow";
-const LEADER_LABEL = "workflows";
-const LEADER_ENABLE_ACTION = "workflow.enable";
-const LEADER_DISABLE_ACTION = "workflow.disable";
-const LEADER_MANAGE_ACTION = "workflow.manage";
-const LEADER_RECOVER_ACTION = "workflow.recover";
-const LEADER_CATALOG_ACTION = "workflow.catalog";
-const LEADER_DETAIL = "multi-step agent runs";
-const LIST_WORKFLOWS_TOOL_NAME = "list_workflows";
-const LAUNCH_WORKFLOW_TOOL_NAME = "launch_workflow";
-const WORKFLOW_RUN_TOOL_NAME$1 = "workflow_run";
-const WORKFLOW_PI_TOOL_NAMES = [
-	LIST_WORKFLOWS_TOOL_NAME,
-	LAUNCH_WORKFLOW_TOOL_NAME,
-	WORKFLOW_RUN_TOOL_NAME$1
-];
-//#endregion
-//#region src/services/workflowFence/index.ts
-const DISPATCHER_AGENT_NAME = "agiflow-dispatcher";
-const SESSION_START_EVENT = "session_start";
-const INACTIVE_RUNTIME_MESSAGE = "The workflow runtime is no longer active.";
-const CLEANUP_SCOPE = Symbol("doom-workflow-cleanup");
-const DISPATCHER_TOOL_NAMES = /* @__PURE__ */ new Set(["list_workflows", "launch_workflow"]);
-const ROOT_SCOPED_TOOL_NAMES = /* @__PURE__ */ new Set(["launch_workflow"]);
-const WORKFLOW_RUN_TOOL_NAME = "workflow_run";
-function boundValue(target, property) {
-	const value = Reflect.get(target, property, target);
-	return typeof value === "function" ? value.bind(target) : value;
-}
-function withParentSession(ctx, parentSessionId) {
-	const sessionManager = new Proxy(ctx.sessionManager, { get(target, property) {
-		if (property === "getSessionId") return () => parentSessionId;
-		return boundValue(target, property);
-	} });
-	return new Proxy(ctx, { get(target, property) {
-		if (property === "sessionManager") return sessionManager;
-		return boundValue(target, property);
-	} });
-}
-/**
-* A dispatcher child launches workflows for its root session and never runs one
-* itself, so `workflow_run` stays off its surface even if something registers it.
-*/
-function dispatcherToolRestriction() {
-	return (incoming) => incoming.filter((name) => name !== WORKFLOW_RUN_TOOL_NAME);
-}
-/** Restrict a dispatcher child to discovery and root-owned launch. */
-function dispatcherTools(tools, parentSessionId, environment) {
-	const rootSessionId = parentSessionId ? resolveRootSessionId(parentSessionId, environment) : void 0;
-	return tools.filter((tool) => DISPATCHER_TOOL_NAMES.has(tool.name)).map((tool) => {
-		if (!rootSessionId || !ROOT_SCOPED_TOOL_NAMES.has(tool.name)) return tool;
-		return {
-			...tool,
-			execute: (toolCallId, params, signal, onUpdate, ctx) => tool.execute(toolCallId, params, signal, onUpdate, withParentSession(ctx, rootSessionId))
-		};
-	});
-}
-function resolveDispatcherParentSession(environment) {
-	return readChildProcessContext(environment)?.parentSessionId ?? (environment[SUBAGENT_PARENT_SESSION_ENV]?.trim() || void 0);
-}
-function isWorkflowDispatcherProcess(environment) {
-	if (readChildProcessContext(environment)?.mode === DISPATCHER_AGENT_NAME) return true;
-	return environment.PI_SUBAGENT_CHILD_AGENT === DISPATCHER_AGENT_NAME && Boolean(environment[SUBAGENT_PARENT_SESSION_ENV]?.trim());
-}
-/** Fence every callback retained by Pi after this package root is replaced. */
-function createWorkflowFence(host, signal) {
-	const scope = new AsyncLocalStorage();
-	let active = true;
-	let disposing = false;
-	let generation = 0;
-	let lastSessionStartEvent;
-	let lastSessionStartContext;
-	const isCurrentInvocation = () => {
-		const currentScope = scope.getStore();
-		if (!active || signal?.aborted && currentScope !== CLEANUP_SCOPE) return false;
-		return currentScope === void 0 || currentScope === CLEANUP_SCOPE || currentScope === generation;
-	};
-	const ownsContext = (contextGeneration) => {
-		const currentScope = scope.getStore();
-		if (!active || signal?.aborted && currentScope !== CLEANUP_SCOPE) return false;
-		return currentScope === CLEANUP_SCOPE || contextGeneration === generation && (currentScope === void 0 || currentScope === contextGeneration);
-	};
-	const guardContext = (context, contextGeneration) => {
-		const guardedUi = new Proxy(context.ui, { get(target, property) {
-			const value = Reflect.get(target, property, target);
-			if (typeof value !== "function") return value;
-			return (...args) => {
-				if (ownsContext(contextGeneration)) return Reflect.apply(value, target, args);
-				if (property === "confirm") return Promise.resolve(false);
-				if (property === "custom" || property === "editor" || property === "input" || property === "select") return Promise.resolve(void 0);
-			};
-		} });
-		return new Proxy(context, { get(target, property) {
-			if (property === "ui") return guardedUi;
-			return boundValue(target, property);
-		} });
-	};
-	const tool = (definition) => {
-		return {
-			...definition,
-			execute: async (toolCallId, params, signal, onUpdate, context) => {
-				const executionGeneration = generation;
-				if (!active || disposing || signal?.aborted) throw new Error(INACTIVE_RUNTIME_MESSAGE);
-				const guardedContext = guardContext(context, executionGeneration);
-				const guardedUpdate = onUpdate ? (update) => {
-					if (active && executionGeneration === generation && !signal?.aborted) onUpdate(update);
-				} : void 0;
-				const result = await scope.run(executionGeneration, () => definition.execute(toolCallId, params, signal, guardedUpdate, guardedContext));
-				if (!active || disposing || executionGeneration !== generation) throw new Error(INACTIVE_RUNTIME_MESSAGE);
-				return result;
-			}
-		};
-	};
-	const command = (name, options) => {
-		return [name, {
-			...options,
-			handler: async (args, context) => {
-				const executionGeneration = generation;
-				if (!active || disposing) return;
-				await scope.run(executionGeneration, () => options.handler(args, guardContext(context, executionGeneration)));
-			}
-		}];
-	};
-	const shortcut = (key, options) => {
-		return [key, {
-			...options,
-			handler: (context) => {
-				const executionGeneration = generation;
-				if (!active || disposing) return;
-				return scope.run(executionGeneration, () => options.handler(guardContext(context, executionGeneration)));
-			}
-		}];
-	};
-	const events = (handlers) => Object.fromEntries(Object.entries(handlers).map(([eventName, handler]) => [eventName, (event, context) => {
-		if (!active || disposing) return void 0;
-		if (eventName === SESSION_START_EVENT && (event !== lastSessionStartEvent || context !== lastSessionStartContext)) {
-			generation += 1;
-			lastSessionStartEvent = event;
-			lastSessionStartContext = context;
-		}
-		const eventGeneration = generation;
-		return scope.run(eventGeneration, () => handler(event, guardContext(context, eventGeneration)));
-	}]));
-	return {
-		pi: new Proxy(host, { get(target, property) {
-			if (property === "sendMessage") return (...args) => {
-				if (isCurrentInvocation()) target.sendMessage(...args);
-			};
-			if (property === "sendUserMessage") return (...args) => {
-				if (isCurrentInvocation()) target.sendUserMessage(...args);
-			};
-			if (property === "exec") return (...args) => isCurrentInvocation() ? target.exec(...args) : Promise.resolve({
-				code: 1,
-				killed: false,
-				stderr: INACTIVE_RUNTIME_MESSAGE,
-				stdout: ""
-			});
-			return boundValue(target, property);
-		} }),
-		tool,
-		command,
-		shortcut,
-		events,
-		beginDisposal() {
-			if (disposing || !active) return;
-			disposing = true;
-			generation += 1;
-		},
-		finishDisposal() {
-			active = false;
-			disposing = false;
-			generation += 1;
-		},
-		isCurrentInvocation,
-		runCleanup: (operation) => scope.run(CLEANUP_SCOPE, operation)
-	};
-}
-//#endregion
 //#region src/schemas/workflowPi.ts
 const RUN_SELECTOR_FIELDS = {
 	runKey: z.string().min(1).describe("Run key of the workflow run."),
@@ -269,392 +89,6 @@ const workflowCatalogPageSchema = z.object({
 	}).passthrough()).describe("Workflow definitions on this page.")
 }).passthrough();
 //#endregion
-//#region src/services/piToolBridge/index.ts
-/**
-* Environment variable stamped onto every run launched from a Pi session.
-*
-* `RunWorkflowService` forwards `env` to the inner CLI invocation across the
-* `launch-command` delegation boundary and persists it on the run record, so
-* this survives backgrounding and identifies the launching session afterwards.
-*/
-const PI_SESSION_ENV = "PI_SESSION_ID";
-/** Operator override for the per-session launch ceiling. */
-const MAX_CONCURRENT_ENV = "WORKFLOW_MCP_MAX_CONCURRENT";
-const DEFAULT_MAX_CONCURRENT = 5;
-/** Resolve the per-session launch ceiling from the environment. */
-function resolveMaxConcurrent(env = process.env) {
-	const parsed = Number(env[MAX_CONCURRENT_ENV]);
-	return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CONCURRENT;
-}
-/**
-* True when this session launched the run.
-*
-* Fails closed on a missing session id: an unstamped record (a CLI launch) and
-* a call arriving before the session id is known both match nothing, so no run
-* ever leaks across sessions through an undefined-equals-undefined comparison.
-*/
-function isSessionRun(record, sessionId) {
-	return sessionId !== void 0 && record.env?.["PI_SESSION_ID"] === sessionId;
-}
-/** Runs launched by one Pi session that are still running. */
-function runsForSession(records, sessionId) {
-	return records.filter((record) => isSessionRun(record, sessionId) && record.stage === "running");
-}
-/**
-* What the caller is told when the registry, not the launcher, acknowledged a
-* launch.
-*
-* Leads with the run key because it is the handle every other workflow action
-* takes, and it is no longer available any other way: the launcher's own output
-* is not waited for, so nothing else in this result carries it.
-*/
-function launchedRunSummary(record) {
-	return [
-		`Started ${record.displayName} in workspace ${record.workspace}.`,
-		`Run key: ${record.runKey}`,
-		"The run is registered and going. This call returned at that point rather than waiting for the launcher process to exit."
-	].join("\n");
-}
-/**
-* What the caller is told when the launch was handed off but no run has
-* registered inside the acknowledgement budget.
-*
-* Deliberately not an error: the launcher is slow rather than broken often
-* enough that failing here would strand runs that go on to start normally.
-* There is no run key to offer yet, so it points at the surfaces that do not
-* need one.
-*/
-function launchHandoffSummary(workflowPath) {
-	return [
-		`Launch handed off for ${workflowPath}, but no run has registered yet.`,
-		"Nothing was cancelled: the launcher is still starting, and a run that registers later still reports back here when it finishes.",
-		"Do not launch it again. Ask the user to check the active workflow list if they need to see it sooner."
-	].join("\n");
-}
-/**
-* Escape sequences a terminal consumes rather than prints.
-*
-* Built from a string with the rule silenced, the way `doom-runner`'s own
-* scrubber does it, because matching the escape byte is the entire job. Not
-* imported from there: that package's published build is a stale artifact
-* missing the export, and a launch notice should not need another package's
-* build to be current.
-*/
-const ESCAPE_SEQUENCE = new RegExp([
-	"\\u001B\\[[0-9;?]*[ -/]*[@-~]",
-	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
-	"\\u001B[@-Z\\\\-_]"
-].join("|"), "g");
-/** Rows made only of box-drawing: separators that carry nothing once trimmed. */
-const RULE_ROW = /^[\s─-╿]*$/u;
-const NOTICE_LINE_LIMIT = 3;
-/**
-* Widest a notice row may be before it is clipped.
-*
-* A three-line cap does not bound a toast on its own: the engine announces its
-* delegation by echoing the whole shell command, temp script path included, and
-* one line of that wraps across three rows of a narrow terminal and shoves the
-* transcript around. Clipped at a width every terminal can hold instead.
-*/
-const NOTICE_WIDTH_LIMIT = 100;
-/**
-* Cut a tool result down to something a toast can hold.
-*
-* The launch result used to reach `ui.notify` whole, and for a workflow that
-* executes in this process that result is the engine's entire console log:
-* banner, run directory, job tree, rules, colour. Pi rendered every line of it
-* over the transcript, which reads as a broken screen rather than as output.
-* Escape sequences go first: the log carries colour the notification would
-* render as literal text, and a stray clear or cursor-move would do to the
-* screen exactly what this function exists to prevent.
-*/
-function launchNotice(text, limit = NOTICE_LINE_LIMIT) {
-	const lines = text.replace(ESCAPE_SEQUENCE, "").split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0 && !RULE_ROW.test(line)).map((line) => line.length > NOTICE_WIDTH_LIMIT ? `${line.slice(0, 99)}…` : line);
-	if (lines.length === 0) return "Workflow started.";
-	if (lines.length <= limit) return lines.join("\n");
-	return [...lines.slice(0, limit), `… ${lines.length - limit} more lines, in the run's own output.`].join("\n");
-}
-/** Flatten MCP tool content to text for Pi. */
-function toolResultText(result) {
-	return result.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n").trim();
-}
-/**
-* Convert an MCP tool result into a Pi tool result.
-*
-* Pi signals tool failure by throwing: the agent loop catches it and builds the
-* error result. So an `isError` MCP result becomes a thrown error rather than a
-* successful result carrying a flag Pi would ignore.
-*/
-function toAgentToolResult(tool, result, errorOptions = []) {
-	const text = toolResultText(result) || "No output.";
-	if (result.isError) throw new Error(withOptions(text, errorOptions));
-	return {
-		content: [{
-			type: "text",
-			text
-		}],
-		details: { tool }
-	};
-}
-/**
-* Attach a short menu of next steps to a problem.
-*
-* An error with no route forward is where an agent invents one: retrying a
-* capacity limit, relaunching a run that should be recovered, or silently
-* giving up on work the user is waiting for. Naming two or three real options
-* turns an error into a decision, and the decision belongs to the user.
-*/
-function withOptions(problem, options) {
-	if (options.length === 0) return problem;
-	return [
-		problem,
-		"",
-		"Options, put these to the user rather than picking one yourself:",
-		...options.map(bullet)
-	].join("\n");
-}
-function bullet(option) {
-	return `- ${option}`;
-}
-/** The job and step a run died on, preferring the progress log to the record. */
-function failurePosition(record, jobs) {
-	const failedJob = jobs.find((job) => job.status === "failed");
-	const failedStep = failedJob?.steps.find((step) => step.status === "failed");
-	return {
-		job: failedJob?.name ?? record.failedJob,
-		step: failedStep?.name,
-		reason: failedStep?.reason ?? failedJob?.reason
-	};
-}
-/**
-* Describe a finished run for the agent that launched it.
-*
-* Carries the job identifiers back so a dispatching agent can match the run to
-* the work item it launched it for without another lookup. When the run failed,
-* carries the failing step and a set of options too: the agent is being told
-* about this out of band, with no user question in flight, so without them it
-* has to guess whether to recover, relaunch, or report.
-*/
-function finishedRunSummary(record, jobs = []) {
-	const outcome = record.stage === "completed" ? "completed" : `ended in ${record.stage}`;
-	const failure = failurePosition(record, jobs);
-	const lines = [
-		`Workflow run ${record.runKey} in workspace ${record.workspace} ${outcome}.`,
-		record.workflowId ? `Workflow: ${record.workflowId}` : void 0,
-		failure.job ? `Failed job: ${failure.job}${failure.step ? ` (step: ${failure.step})` : ""}` : void 0,
-		record.errorMessage ? `Error: ${record.errorMessage}` : void 0,
-		failure.reason && failure.reason !== record.errorMessage ? `Step reported: ${failure.reason}` : void 0
-	];
-	const jobId = record.env?.AGIFLOW_JOB_ID;
-	if (jobId) lines.push(`Agiflow job: ${record.env?.AGIFLOW_JOB_KIND ?? "unknown"} ${jobId}`);
-	const summary = lines.filter((line) => Boolean(line)).join("\n");
-	if (record.stage === "completed") return summary;
-	if (record.outcome === "interrupted") return withOptions(summary, [`workflow_run {"action":"recover","runKey":${JSON.stringify(record.runKey)}}: pick it up where it stopped.`, "Leave it stopped and move on."]);
-	const diagnosticText = [record.errorMessage, failure.reason].filter(Boolean).join("\n");
-	if (diagnosticText.includes("JOB_ALREADY_CLAIMED")) return withOptions(summary, ["Report contention: another worker owns this job. Do not unlock, release, or retry the claim automatically."]);
-	if (diagnosticText.includes("WORKFLOW_NOT_OWNED") || /release failed/i.test(diagnosticText)) return withOptions(summary, ["Inspect the current workflow ownership and ask the user before any release or unlock. Never force another worker’s lock."]);
-	if (/running workflow not found/i.test(diagnosticText)) return withOptions(summary, [`workflow_run {"action":"status","runKey":${JSON.stringify(record.runKey)}}: re-check current state before retrying.`, "Report the recorded terminal state when no running owner remains."]);
-	return withOptions(summary, [
-		`workflow_run {"action":"tail","runKey":${JSON.stringify(record.runKey)}}: read the run's own output first, when the error above does not explain the failure.`,
-		`workflow_run {"action":"recover","runKey":${JSON.stringify(record.runKey)}}: resume from the failed job, keeping the work already done. Fits a transient or external cause.`,
-		"Report the failure and stop, when it needs a code change or a decision you cannot make."
-	]);
-}
-//#endregion
-//#region src/services/workflowExecution/index.ts
-const AGIFLOW_JOB_ID_ENV = "AGIFLOW_JOB_ID";
-const AGIFLOW_JOB_KIND_ENV = "AGIFLOW_JOB_KIND";
-const AGIFLOW_PROJECT_ID_ENV = "AGIFLOW_PROJECT_ID";
-/**
-* What workflow mode does to the tool surface: nothing but hide its own tools.
-*
-* The tools are registered for the whole session because Pi has no other way to
-* add one later, so the mode is expressed as a restriction rather than as a
-* registration.
-*/
-function workflowToolRestriction(enabled) {
-	const hidden = new Set(WORKFLOW_PI_TOOL_NAMES);
-	return (incoming) => enabled ? incoming : incoming.filter((name) => !hidden.has(name));
-}
-/** How often the registry is asked whether the launch has produced a run. */
-const LAUNCH_ACK_POLL_MS = 500;
-/**
-* How long to wait for that before answering without a run key.
-*
-* Long enough to cover a launcher that is merely slow, short enough that a
-* caller is never left holding a turn open for a launcher that will not answer.
-*/
-const LAUNCH_ACK_TIMEOUT_MS = 15e3;
-function reportProgress(onUpdate, tool, message) {
-	onUpdate?.({
-		content: [{
-			type: "text",
-			text: message
-		}],
-		details: { tool }
-	});
-}
-function appendGuidance(result, guidance) {
-	return {
-		...result,
-		content: [...result.content, {
-			type: "text",
-			text: guidance
-		}]
-	};
-}
-function statusAction(runKey) {
-	return `workflow_run {"action":"status","runKey":${JSON.stringify(runKey)}}`;
-}
-function actionGuidance(action, runKey) {
-	const status = statusAction(runKey);
-	if (action === "stop") return [`Next: call ${status} to confirm the run reached a terminal stage.`];
-	if (action === "recover") return [`Report the recovery failure and do not retry it blindly: call ${status} first.`, "Ask the user before launching fresh work when the recorded recovery is no longer valid."];
-	return [`Next: call ${status} to verify the recorded execution state.`];
-}
-const launchFailureOptions = [
-	"Report the failure to the user with the error above. A launch failure is usually a bad workflow path, a missing launcher, or a workflow whose own pre-conditions refused.",
-	"list_workflows: confirm the workflow path exists and its description matches the work, if the path may be wrong.",
-	"workflow_run with action status: check whether an earlier attempt is already running before launching again."
-];
-/**
-* An Error, whatever the launch rejected with.
-*
-* A rejection reaches here as `unknown` because it crossed a promise boundary,
-* and rethrowing that as-is hands Pi's tool layer something it cannot read a
-* message or a stack off. The original is kept as the cause rather than
-* flattened into a string.
-*/
-function asError(value) {
-	return value instanceof Error ? value : new Error(String(value), { cause: value });
-}
-/** Resolves to undefined, so a race against it reads as "nothing settled yet". */
-function sleep(ms) {
-	return new Promise((settle) => {
-		setTimeout(() => settle(void 0), ms).unref?.();
-	});
-}
-/**
-* Wait for whichever answer arrives first: the launch settling, the run
-* appearing in the registry, or the budget running out.
-*
-* A launch that delegates to a terminal launcher settles when that launcher's
-* whole process chain closes, which on a loaded machine has been measured
-* minutes after the run itself was registered and working. The registry is the
-* earlier and more truthful signal: a run recorded there is a run that started.
-*/
-async function awaitLaunchAck(settled, dependencies, query) {
-	const findLaunchedRun = dependencies.findLaunchedRun;
-	if (!findLaunchedRun) return {
-		kind: "settled",
-		outcome: await settled
-	};
-	const pollMs = dependencies.launchAckPollMs ?? LAUNCH_ACK_POLL_MS;
-	const deadline = Date.now() + (dependencies.launchAckTimeoutMs ?? LAUNCH_ACK_TIMEOUT_MS);
-	for (;;) {
-		const outcome = await Promise.race([settled, sleep(pollMs)]);
-		if (outcome) return {
-			kind: "settled",
-			outcome
-		};
-		const record = await findLaunchedRun(query).catch(() => void 0);
-		if (record) return {
-			kind: "record",
-			record
-		};
-		if (Date.now() >= deadline) return { kind: "handoff" };
-	}
-}
-/**
-* Carry a failure that lands after the caller was told the run started.
-*
-* Answering early trades the launcher's exit code for timeliness. Dropping that
-* code entirely is not part of the trade: a launch that fails a minute later
-* would otherwise leave a user waiting on a run that never existed.
-*/
-function reportLateFailure(settled, dependencies, ctx) {
-	settled.then((outcome) => {
-		if (outcome.kind === "error") {
-			dependencies.onLateFailure?.(asError(outcome.error), ctx);
-			return;
-		}
-		if (outcome.result.isError) dependencies.onLateFailure?.(new Error(toolResultText(outcome.result) || "Workflow launch failed."), ctx);
-	});
-}
-function createWorkflowLaunchExecutor(dependencies) {
-	return { async execute(input, ctx, onUpdate) {
-		const sessionId = resolveRootSessionId(ctx.sessionManager.getSessionId(), dependencies.environment);
-		dependencies.observeSession?.(sessionId);
-		const agiflowJobKind = input.env?.[AGIFLOW_JOB_KIND_ENV]?.trim();
-		const agiflowJobId = input.env?.[AGIFLOW_JOB_ID_ENV]?.trim();
-		const explicitProjectId = input.env?.[AGIFLOW_PROJECT_ID_ENV]?.trim();
-		if (Boolean(agiflowJobKind) !== Boolean(agiflowJobId)) throw new Error("Agiflow workflow launches require AGIFLOW_JOB_KIND and AGIFLOW_JOB_ID together.");
-		if (agiflowJobKind && agiflowJobKind !== "task" && agiflowJobKind !== "work-unit") throw new Error("Agiflow workflow launches require AGIFLOW_JOB_KIND to be task or work-unit.");
-		if (agiflowJobKind && !explicitProjectId) throw new Error("Agiflow workflow launches require AGIFLOW_PROJECT_ID with the job identity.");
-		if (agiflowJobKind && !input.prompt?.trim()) throw new Error("Agiflow workflow launches require a non-empty prompt so user_prompt runs do not wait for terminal input.");
-		reportProgress(onUpdate, LAUNCH_WORKFLOW_TOOL_NAME, "Checking workflow capacity...");
-		const maxConcurrent = resolveMaxConcurrent(dependencies.environment);
-		const active = await dependencies.activeRunCount?.() ?? 0;
-		if (active >= maxConcurrent) throw new Error(withOptions(`This session is at capacity: ${active}/${maxConcurrent} workflows running.`, [
-			"Wait for a running workflow to finish, then launch again. The extension reports each one as it ends.",
-			"workflow_run with action status: show what is running, so the user can judge whether something is stuck.",
-			"workflow_run with action stop: free a slot by stopping a run the user no longer wants."
-		]));
-		if (input.runner) {
-			const rejection = dependencies.rejectRunner?.(input.workflowPath, input.runner);
-			if (rejection) throw new Error(rejection);
-		}
-		reportProgress(onUpdate, LAUNCH_WORKFLOW_TOOL_NAME, `Launching workflow ${input.workflowPath}...`);
-		const workflowEnv = { ...input.env };
-		const dispatcherContextFile = dependencies.environment.AGIFLOW_DISPATCH_CONTEXT_FILE;
-		const dispatcherProjectId = dependencies.environment[AGIFLOW_PROJECT_ID_ENV]?.trim();
-		if (dispatcherContextFile && agiflowJobKind && dispatcherProjectId && explicitProjectId && dispatcherProjectId !== explicitProjectId) throw new Error(`Agiflow workflow project identity conflicts with the dispatcher context (${explicitProjectId} versus ${dispatcherProjectId}).`);
-		if (dispatcherContextFile) for (const key of [
-			"AGIFLOW_ORGANIZATION_ID",
-			"AGIFLOW_PROJECT_ID",
-			"AGIFLOW_DEVICE_ID",
-			"BACKEND_AGIFLOW_API_ENDPOINT",
-			"AGIFLOW_DISPATCH_SECRET_FILE"
-		]) {
-			const hostValue = dependencies.environment[key];
-			if (hostValue) workflowEnv[key] = hostValue;
-		}
-		const since = Date.now();
-		const settled = dependencies.trackPendingRun(dependencies.runTool.execute({
-			...input,
-			env: {
-				...workflowEnv,
-				[PI_SESSION_ENV]: sessionId
-			}
-		})).then((value) => ({
-			kind: "value",
-			result: value
-		}), (error) => ({
-			kind: "error",
-			error
-		}));
-		const ack = await awaitLaunchAck(settled, dependencies, {
-			sessionId,
-			since,
-			workflowPath: input.workflowPath
-		});
-		if (ack.kind === "settled") {
-			const outcome = ack.outcome;
-			if (outcome.kind === "error") throw asError(outcome.error);
-			const result = outcome.result;
-			if (result.isError) throw new Error(withOptions(toolResultText(result) || "Workflow launch failed.", launchFailureOptions));
-			await dependencies.onLaunch?.(ctx);
-			return result;
-		}
-		reportLateFailure(settled, dependencies, ctx);
-		await dependencies.onLaunch?.(ctx);
-		return { content: [{
-			type: "text",
-			text: ack.kind === "record" ? launchedRunSummary(ack.record) : launchHandoffSummary(input.workflowPath)
-		}] };
-	} };
-}
-//#endregion
 //#region src/services/workflowTools/index.ts
 const PI_LAUNCH_FIELDS = {
 	workflowPath: true,
@@ -719,11 +153,12 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 			async execute(_toolCallId, params, _signal, onUpdate, ctx) {
 				const input = params;
 				const result = await launchExecutor.execute(input, ctx, onUpdate);
-				return appendGuidance(toAgentToolResult(LAUNCH_WORKFLOW_TOOL_NAME, result, launchFailureOptions), "Next: call workflow_run with action status and verify the recorded stage before reporting the workflow outcome.");
+				const adapted = toAgentToolResult(LAUNCH_WORKFLOW_TOOL_NAME, result, launchFailureOptions);
+				return appendGuidance(adapted, "Next: call workflow_run with action status and verify the recorded stage before reporting the workflow outcome.");
 			}
 		},
 		{
-			name: WORKFLOW_RUN_TOOL_NAME$1,
+			name: WORKFLOW_RUN_TOOL_NAME,
 			label: "Workflow Run",
 			description: "Inspect or control one workflow run. Use action status, tail, recovery-evidence, follow, open, pause, resume, stop, or recover. Every action requires an exact run key.",
 			promptSnippet: "Inspect or control a workflow run",
@@ -738,7 +173,7 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 			],
 			parameters: z.toJSONSchema(workflowRunInputSchema),
 			renderShell: "self",
-			...renderers(WORKFLOW_RUN_TOOL_NAME$1),
+			...renderers(WORKFLOW_RUN_TOOL_NAME),
 			async execute(_toolCallId, rawParams, _signal, onUpdate, ctx) {
 				const input = workflowRunInputSchema.parse(rawParams);
 				const sessionId = resolveRootSessionId(ctx.sessionManager.getSessionId(), dependencies.environment);
@@ -758,13 +193,13 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 							type: "text",
 							text: JSON.stringify(record, null, 2)
 						}],
-						details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+						details: { tool: WORKFLOW_RUN_TOOL_NAME }
 					};
 				}
 				if (input.action === "tail") {
 					if (!dependencies.tailRun) throw new Error("Reading workflow output is not available in this session.");
 					const record = await requireOwnedRun();
-					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME$1, `Reading output for workflow ${input.runKey}...`);
+					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME, `Reading output for workflow ${input.runKey}...`);
 					await dependencies.tailRun(selector, ctx);
 					return {
 						content: [{
@@ -775,42 +210,42 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 								"Raw launcher output is hidden from chat. Use action follow or open to view it."
 							].join("\n")
 						}],
-						details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+						details: { tool: WORKFLOW_RUN_TOOL_NAME }
 					};
 				}
 				if (input.action === "recovery-evidence") {
 					if (!dependencies.readRecoveryEvidence) throw new Error("Reading workflow recovery evidence is not available in this session.");
-					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME$1, `Reading recovery evidence for workflow ${input.runKey}...`);
+					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME, `Reading recovery evidence for workflow ${input.runKey}...`);
 					return {
 						content: [{
 							type: "text",
 							text: await dependencies.readRecoveryEvidence(selector, ctx)
 						}],
-						details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+						details: { tool: WORKFLOW_RUN_TOOL_NAME }
 					};
 				}
 				if (input.action === "follow") {
 					if (!dependencies.followRun) throw new Error("Following workflow output is not available in this session.");
 					await requireOwnedRun();
-					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME$1, `Following workflow ${input.runKey}...`);
+					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME, `Following workflow ${input.runKey}...`);
 					return {
 						content: [{
 							type: "text",
 							text: await dependencies.followRun(selector, ctx)
 						}],
-						details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+						details: { tool: WORKFLOW_RUN_TOOL_NAME }
 					};
 				}
 				if (input.action === "open") {
 					if (!dependencies.openRun) throw new Error("Opening a workflow launcher is not available in this session.");
 					await requireOwnedRun();
-					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME$1, `Opening workflow ${input.runKey}...`);
+					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME, `Opening workflow ${input.runKey}...`);
 					return {
 						content: [{
 							type: "text",
 							text: await dependencies.openRun(selector, ctx)
 						}],
-						details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+						details: { tool: WORKFLOW_RUN_TOOL_NAME }
 					};
 				}
 				if (input.action === "recover") {
@@ -820,7 +255,7 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 						runKey: recoverable.runKey,
 						workspace: recoverable.workspace
 					};
-					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME$1, `Recovering workflow ${input.runKey}...`);
+					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME, `Recovering workflow ${input.runKey}...`);
 					if (!input.dryRun) {
 						const delegated = await dependencies.delegateRecovery?.({
 							...recoverySelector,
@@ -834,7 +269,7 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 									type: "text",
 									text: [delegated, guidance[0]].join("\n\n")
 								}],
-								details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+								details: { tool: WORKFLOW_RUN_TOOL_NAME }
 							};
 						}
 					}
@@ -847,13 +282,13 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 					};
 					const result = await trackPendingRun(recoverTool.execute(recoverInput));
 					const guidance = actionGuidance(input.action, input.runKey);
-					const adapted = toAgentToolResult(WORKFLOW_RUN_TOOL_NAME$1, result, guidance);
+					const adapted = toAgentToolResult(WORKFLOW_RUN_TOOL_NAME, result, guidance);
 					await dependencies.onLaunch?.(ctx);
 					return appendGuidance(adapted, guidance[0]);
 				}
 				const ownedRun = await requireOwnedRun();
 				if (!ownedRun.runId) throw new Error(`Workflow ${input.runKey} has no controllable run generation.`);
-				reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME$1, `Requesting ${input.action} for workflow ${input.runKey}...`);
+				reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME, `Requesting ${input.action} for workflow ${input.runKey}...`);
 				const result = await controlTool.execute({
 					action: input.action,
 					expectedRunId: ownedRun.runId,
@@ -862,7 +297,8 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 					workspace: input.workspace
 				});
 				const guidance = actionGuidance(input.action, input.runKey);
-				return appendGuidance(toAgentToolResult(WORKFLOW_RUN_TOOL_NAME$1, result, guidance), guidance[0]);
+				const adapted = toAgentToolResult(WORKFLOW_RUN_TOOL_NAME, result, guidance);
+				return appendGuidance(adapted, guidance[0]);
 			}
 		}
 	];
@@ -1569,11 +1005,15 @@ function summarizeWorkflowFile(workflowPath, options) {
 	try {
 		const workflow = options.parseWorkflow(workflowPath);
 		const runners = options.compatibleRunners(workflow);
+		const commands = compatibleCommands(workflow);
+		const choices = Object.keys(workflow.choices ?? {});
 		return {
 			triggers: Object.keys(workflowTriggerBlock(workflow)),
 			inputs: catalogInputs(workflow),
 			jobs: catalogJobs(workflow),
-			...runners ? { runners } : {}
+			...runners ? { runners } : {},
+			...commands ? { commands } : {},
+			...choices.length > 0 ? { choices } : {}
 		};
 	} catch (cause) {
 		return {
@@ -1593,11 +1033,25 @@ async function launchWorkflowEntry(options, selected, ctx) {
 		runner = await options.ui.select("Select a workflow runner", runners);
 		if (runner === void 0) return void 0;
 	}
+	const commands = compatibleCommands(workflow) ?? [];
+	let command;
+	if (commands.length > 1) {
+		command = await options.ui.select("Select the command agent steps run through", commands);
+		if (command === void 0) return void 0;
+	}
+	const choices = Object.keys(workflow.choices ?? {});
+	let choice;
+	if (choices.length > 1) {
+		choice = await options.ui.select("Select a model choice", choices);
+		if (choice === void 0) return void 0;
+	}
 	const triggerInputs = await collectWorkflowInputs(workflow, options.ui);
 	if (triggerInputs === void 0) return void 0;
 	const launchInput = {
 		workflowPath: selected.path,
 		...runner === void 0 ? {} : { runner },
+		...command === void 0 ? {} : { command },
+		...choice === void 0 ? {} : { choice },
 		...typeof workflow.workspace === "string" ? { workspace: workflow.workspace } : {},
 		...triggerInputs
 	};
@@ -3879,10 +3333,12 @@ function createWorkflowPiRuntime(pi, options) {
 		trackPendingRun,
 		...options.launchAckPollMs === void 0 ? {} : { launchAckPollMs: options.launchAckPollMs },
 		...options.launchAckTimeoutMs === void 0 ? {} : { launchAckTimeoutMs: options.launchAckTimeoutMs },
-		findLaunchedRun: async ({ sessionId, since, workflowPath }) => {
+		findLaunchedRun: async ({ launchId, sessionId, since, workflowPath }) => {
 			const expectedId = workflowIdFor(workflowPath);
 			const matches = (record) => {
 				if (!isSessionRun(record, sessionId) || record.stale) return false;
+				const carried = record.env?.[WORKFLOW_LAUNCH_ID_ENV];
+				if (carried !== void 0) return carried === launchId;
 				if (record.workflowId && record.workflowId !== expectedId) return false;
 				const startedAt = Date.parse(record.startedAt);
 				return Number.isFinite(startedAt) && startedAt >= since - LAUNCH_ACK_CLOCK_SKEW_MS;
@@ -4721,6 +4177,8 @@ function createWorkflowPiRuntime(pi, options) {
 		const input = {
 			workflowPath: entry.path,
 			...parsed.runner === void 0 ? {} : { runner: parsed.runner },
+			...parsed.command === void 0 ? {} : { command: parsed.command },
+			...parsed.choice === void 0 ? {} : { choice: parsed.choice },
 			...typeof workflow.workspace === "string" ? { workspace: workflow.workspace } : {},
 			...parsed.prompt === void 0 ? {} : { prompt: parsed.prompt },
 			...Object.keys(parsed.inputs).length === 0 ? {} : { inputs: parsed.inputs }
@@ -4729,7 +4187,7 @@ function createWorkflowPiRuntime(pi, options) {
 		ctx.ui.notify(launchNotice(toolResultText(result)), "info");
 	};
 	const commands = [[WORKFLOW_LAUNCH_COMMAND, {
-		description: "Launch a workflow: /workflow-launch <workflow> [runner=x] [key=value …] [prompt]",
+		description: "Launch a workflow: /workflow-launch <workflow> [runner=x] [command=x] [choice=x] [key=value …] [prompt]",
 		handler: async (args, ctx) => {
 			await waitForReadiness();
 			try {