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

package/dist/extensions/pi.cjs

@@ -2,207 +2,27 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_workflowTerminal = require("../workflowTerminal-WM_cpxIO.cjs");
-const require_workflowLaunchCommand = require("../workflowLaunchCommand-7y8xg5YF.cjs");
+const require_workflowTerminal = require("../workflowTerminal-Bb4bLtLu.cjs");
+const require_workflowLaunchCommand = require("../workflowLaunchCommand-DJyDB96d.cjs");
 let _agimon_ai_doompi_core_piExtension = require("@agimon-ai/doompi-core/piExtension");
 let _agimon_ai_doompi_core_extensionFile = require("@agimon-ai/doompi-core/extensionFile");
 let _agimon_ai_doompi_core_skills = require("@agimon-ai/doompi-core/skills");
 let _agimon_ai_doompi_core_uiHub = require("@agimon-ai/doompi-core/uiHub");
-let node_async_hooks = require("node:async_hooks");
 let _agimon_ai_doompi_core_childProcess = require("@agimon-ai/doompi-core/childProcess");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 let _agimon_ai_workflow_mcp = require("@agimon-ai/workflow-mcp");
 let zod = require("zod");
+let node_crypto = require("node:crypto");
 let _agimon_ai_doompi_ui_toolChrome = require("@agimon-ai/doompi-ui/toolChrome");
 let node_child_process = require("node:child_process");
-let node_crypto = require("node:crypto");
 let node_module = require("node:module");
 let _agimon_ai_doompi_core_narration = require("@agimon-ai/doompi-core/narration");
 let _agimon_ai_doompi_core_readiness = require("@agimon-ai/doompi-core/readiness");
 let _agimon_ai_doompi_minor_mode = require("@agimon-ai/doompi-minor-mode");
 let _agimon_ai_doompi_telemetry = require("@agimon-ai/doompi-telemetry");
 let _earendil_works_pi_tui = require("@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 ? (0, _agimon_ai_doompi_core_childProcess.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 (0, _agimon_ai_doompi_core_childProcess.readChildProcessContext)(environment)?.parentSessionId ?? (environment[_agimon_ai_doompi_core_childProcess.SUBAGENT_PARENT_SESSION_ENV]?.trim() || void 0);
-}
-function isWorkflowDispatcherProcess(environment) {
-	if ((0, _agimon_ai_doompi_core_childProcess.readChildProcessContext)(environment)?.mode === DISPATCHER_AGENT_NAME) return true;
-	return environment.PI_SUBAGENT_CHILD_AGENT === DISPATCHER_AGENT_NAME && Boolean(environment[_agimon_ai_doompi_core_childProcess.SUBAGENT_PARENT_SESSION_ENV]?.trim());
-}
-/** Fence every callback retained by Pi after this package root is replaced. */
-function createWorkflowFence(host, signal) {
-	const scope = new node_async_hooks.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: zod.z.string().min(1).describe("Run key of the workflow run."),
@@ -273,392 +93,6 @@ const workflowCatalogPageSchema = zod.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 = (0, _agimon_ai_doompi_core_childProcess.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,
@@ -677,7 +111,7 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 	const recoverTool = dependencies.recoverTool ?? feature.createRecoverTool();
 	const controlTool = dependencies.controlTool ?? feature.createControlTool();
 	const trackPendingRun = dependencies.trackPendingRun ?? ((run) => run);
-	const launchExecutor = dependencies.launchExecutor ?? createWorkflowLaunchExecutor({
+	const launchExecutor = dependencies.launchExecutor ?? require_workflowTerminal.createWorkflowLaunchExecutor({
 		environment: dependencies.environment,
 		activeRunCount: dependencies.activeRunCount,
 		onLaunch: dependencies.onLaunch,
@@ -688,23 +122,23 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 	});
 	return [
 		{
-			name: LIST_WORKFLOWS_TOOL_NAME,
+			name: require_workflowTerminal.LIST_WORKFLOWS_TOOL_NAME,
 			label: "List Workflows",
 			description: "List the workflow definitions available in this repository.",
 			promptSnippet: "List available workflow definitions",
 			parameters: zod.z.toJSONSchema(listWorkflowsTool.getInputSchema()),
 			renderShell: "self",
-			...renderers(LIST_WORKFLOWS_TOOL_NAME),
+			...renderers(require_workflowTerminal.LIST_WORKFLOWS_TOOL_NAME),
 			async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 				const input = params;
-				return toAgentToolResult(LIST_WORKFLOWS_TOOL_NAME, await listWorkflowsTool.execute({
+				return require_workflowTerminal.toAgentToolResult(require_workflowTerminal.LIST_WORKFLOWS_TOOL_NAME, await listWorkflowsTool.execute({
 					...input,
 					directory: input?.directory === void 0 ? ctx.cwd : typeof input.directory === "string" ? (0, node_path.resolve)(ctx.cwd, input.directory) : input.directory
 				}));
 			}
 		},
 		{
-			name: LAUNCH_WORKFLOW_TOOL_NAME,
+			name: require_workflowTerminal.LAUNCH_WORKFLOW_TOOL_NAME,
 			label: "Launch Workflow",
 			description: "Start a workflow run. Returns once the run has started, not once it finishes; use workflow_run with action status or wait for the completion notice.",
 			promptSnippet: "Start a workflow run and return its identifier",
@@ -719,15 +153,16 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 			],
 			parameters: zod.z.toJSONSchema(runTool.getInputSchema().pick(PI_LAUNCH_FIELDS)),
 			renderShell: "self",
-			...renderers(LAUNCH_WORKFLOW_TOOL_NAME),
+			...renderers(require_workflowTerminal.LAUNCH_WORKFLOW_TOOL_NAME),
 			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 = require_workflowTerminal.toAgentToolResult(require_workflowTerminal.LAUNCH_WORKFLOW_TOOL_NAME, result, require_workflowTerminal.launchFailureOptions);
+				return require_workflowTerminal.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: require_workflowTerminal.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",
@@ -742,7 +177,7 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 			],
 			parameters: zod.z.toJSONSchema(workflowRunInputSchema),
 			renderShell: "self",
-			...renderers(WORKFLOW_RUN_TOOL_NAME$1),
+			...renderers(require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME),
 			async execute(_toolCallId, rawParams, _signal, onUpdate, ctx) {
 				const input = workflowRunInputSchema.parse(rawParams);
 				const sessionId = (0, _agimon_ai_doompi_core_childProcess.resolveRootSessionId)(ctx.sessionManager.getSessionId(), dependencies.environment);
@@ -762,13 +197,13 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 							type: "text",
 							text: JSON.stringify(record, null, 2)
 						}],
-						details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+						details: { tool: require_workflowTerminal.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}...`);
+					require_workflowTerminal.reportProgress(onUpdate, require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME, `Reading output for workflow ${input.runKey}...`);
 					await dependencies.tailRun(selector, ctx);
 					return {
 						content: [{
@@ -779,42 +214,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: require_workflowTerminal.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}...`);
+					require_workflowTerminal.reportProgress(onUpdate, require_workflowTerminal.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: require_workflowTerminal.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}...`);
+					require_workflowTerminal.reportProgress(onUpdate, require_workflowTerminal.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: require_workflowTerminal.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}...`);
+					require_workflowTerminal.reportProgress(onUpdate, require_workflowTerminal.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: require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME }
 					};
 				}
 				if (input.action === "recover") {
@@ -824,21 +259,21 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 						runKey: recoverable.runKey,
 						workspace: recoverable.workspace
 					};
-					reportProgress(onUpdate, WORKFLOW_RUN_TOOL_NAME$1, `Recovering workflow ${input.runKey}...`);
+					require_workflowTerminal.reportProgress(onUpdate, require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME, `Recovering workflow ${input.runKey}...`);
 					if (!input.dryRun) {
 						const delegated = await dependencies.delegateRecovery?.({
 							...recoverySelector,
 							runner: input.runner
 						}, ctx);
 						if (delegated) {
-							const guidance = actionGuidance(input.action, input.runKey);
+							const guidance = require_workflowTerminal.actionGuidance(input.action, input.runKey);
 							await dependencies.onLaunch?.(ctx);
 							return {
 								content: [{
 									type: "text",
 									text: [delegated, guidance[0]].join("\n\n")
 								}],
-								details: { tool: WORKFLOW_RUN_TOOL_NAME$1 }
+								details: { tool: require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME }
 							};
 						}
 					}
@@ -850,14 +285,14 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 						workspace: recoverySelector.workspace
 					};
 					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 guidance = require_workflowTerminal.actionGuidance(input.action, input.runKey);
+					const adapted = require_workflowTerminal.toAgentToolResult(require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME, result, guidance);
 					await dependencies.onLaunch?.(ctx);
-					return appendGuidance(adapted, guidance[0]);
+					return require_workflowTerminal.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}...`);
+				require_workflowTerminal.reportProgress(onUpdate, require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME, `Requesting ${input.action} for workflow ${input.runKey}...`);
 				const result = await controlTool.execute({
 					action: input.action,
 					expectedRunId: ownedRun.runId,
@@ -865,8 +300,9 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 					runKey: input.runKey,
 					workspace: input.workspace
 				});
-				const guidance = actionGuidance(input.action, input.runKey);
-				return appendGuidance(toAgentToolResult(WORKFLOW_RUN_TOOL_NAME$1, result, guidance), guidance[0]);
+				const guidance = require_workflowTerminal.actionGuidance(input.action, input.runKey);
+				const adapted = require_workflowTerminal.toAgentToolResult(require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME, result, guidance);
+				return require_workflowTerminal.appendGuidance(adapted, guidance[0]);
 			}
 		}
 	];
@@ -876,8 +312,8 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 const LEADER_BINDING_PREFIX = "doom-workflow";
 const GROUP_SEGMENT = {
 	key: "w",
-	label: LEADER_LABEL,
-	detail: LEADER_DETAIL,
+	label: require_workflowTerminal.LEADER_LABEL,
+	detail: require_workflowTerminal.LEADER_DETAIL,
 	order: 50
 };
 /**
@@ -896,7 +332,7 @@ function workflowLeaderBindings(mode) {
 				label: "list",
 				detail: "browse and launch workflows"
 			}],
-			action: { name: LEADER_CATALOG_ACTION }
+			action: { name: require_workflowTerminal.LEADER_CATALOG_ACTION }
 		},
 		{
 			id: `${LEADER_BINDING_PREFIX}.manage`,
@@ -905,7 +341,7 @@ function workflowLeaderBindings(mode) {
 				label: "runs",
 				detail: "runs in this session"
 			}],
-			action: { name: LEADER_MANAGE_ACTION }
+			action: { name: require_workflowTerminal.LEADER_MANAGE_ACTION }
 		},
 		mode ? {
 			id: `${LEADER_BINDING_PREFIX}.disable`,
@@ -915,7 +351,7 @@ function workflowLeaderBindings(mode) {
 				detail: "take back workflow tools",
 				tone: "exit"
 			}],
-			action: { name: LEADER_DISABLE_ACTION }
+			action: { name: require_workflowTerminal.LEADER_DISABLE_ACTION }
 		} : {
 			id: `${LEADER_BINDING_PREFIX}.enable`,
 			path: [GROUP_SEGMENT, {
@@ -923,7 +359,7 @@ function workflowLeaderBindings(mode) {
 				label: "enter",
 				detail: "give the agent workflow tools"
 			}],
-			action: { name: LEADER_ENABLE_ACTION }
+			action: { name: require_workflowTerminal.LEADER_ENABLE_ACTION }
 		},
 		{
 			id: `${LEADER_BINDING_PREFIX}.recover`,
@@ -932,13 +368,13 @@ function workflowLeaderBindings(mode) {
 				label: "recover",
 				detail: "adopt a failed run"
 			}],
-			action: { name: LEADER_RECOVER_ACTION }
+			action: { name: require_workflowTerminal.LEADER_RECOVER_ACTION }
 		}
 	];
 }
 function registerLeaderContribution(hub, enabled = false) {
 	const contribution = hub.registerLeader({
-		source: PACKAGE_SOURCE,
+		source: require_workflowTerminal.PACKAGE_SOURCE,
 		bindings: workflowLeaderBindings(enabled)
 	});
 	return {
@@ -1456,13 +892,13 @@ function dispatchInputs(workflow) {
 	return parsed.data.inputs ?? {};
 }
 function launchResultError(result) {
-	return new Error(toolResultText(result) || "Workflow launch failed.");
+	return new Error(require_workflowTerminal.toolResultText(result) || "Workflow launch failed.");
 }
 function parseWorkflowCatalogPage(result) {
 	if (result.isError) throw launchResultError(result);
 	let value;
 	try {
-		value = JSON.parse(toolResultText(result));
+		value = JSON.parse(require_workflowTerminal.toolResultText(result));
 	} catch (cause) {
 		throw new Error("Workflow catalog returned invalid JSON.", { cause });
 	}
@@ -1573,11 +1009,15 @@ function summarizeWorkflowFile(workflowPath, options) {
 	try {
 		const workflow = options.parseWorkflow(workflowPath);
 		const runners = options.compatibleRunners(workflow);
+		const commands = (0, _agimon_ai_workflow_mcp.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 {
@@ -1597,11 +1037,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 = (0, _agimon_ai_workflow_mcp.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
 	};
@@ -3706,7 +3160,7 @@ function createWorkflowPiRuntime(pi, options) {
 	const restrictionListeners = /* @__PURE__ */ new Set();
 	const modeContribution = (0, _agimon_ai_doompi_minor_mode.defineMinorMode)({
 		descriptor: {
-			source: PACKAGE_SOURCE,
+			source: require_workflowTerminal.PACKAGE_SOURCE,
 			id: MODE_ID,
 			label: MODE_LABEL,
 			description: "Workflow discovery, launch, inspection, control, and recovery tools.",
@@ -3874,7 +3328,7 @@ function createWorkflowPiRuntime(pi, options) {
 		if (!compatible || compatible.includes(runner)) return void 0;
 		return `Runner ${JSON.stringify(runner)} is not available across this workflow. Compatible runners: ${compatible.join(", ") || "none"}.`;
 	};
-	const launchExecutor = createWorkflowLaunchExecutor({
+	const launchExecutor = require_workflowTerminal.createWorkflowLaunchExecutor({
 		environment: options.environment,
 		activeRunCount: async () => sessionRunCount,
 		observeSession,
@@ -3883,10 +3337,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;
+				if (!require_workflowTerminal.isSessionRun(record, sessionId) || record.stale) return false;
+				const carried = record.env?.[require_workflowTerminal.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;
@@ -3897,7 +3353,7 @@ function createWorkflowPiRuntime(pi, options) {
 		},
 		onLateFailure: (error, ctx) => {
 			const detail = error instanceof Error ? error.message : String(error);
-			ctx.ui.notify(launchNotice(`Workflow launch failed after it was reported started.\n${detail}`), "warning");
+			ctx.ui.notify(require_workflowTerminal.launchNotice(`Workflow launch failed after it was reported started.\n${detail}`), "warning");
 		},
 		onLaunch: async (ctx) => {
 			await getTelemetry(ctx).recordEvent(LAUNCH_REQUESTED_EVENT, { outcome: "requested" });
@@ -3959,7 +3415,7 @@ function createWorkflowPiRuntime(pi, options) {
 	*/
 	const startRunControl = async (ctx) => {
 		const sessionId = (0, _agimon_ai_doompi_core_childProcess.resolveRootSessionId)(ctx.sessionManager.getSessionId(), options.environment);
-		const control = feature.createRunControl({ recordFilter: (candidate) => isSessionRun(candidate, sessionId) });
+		const control = feature.createRunControl({ recordFilter: (candidate) => require_workflowTerminal.isSessionRun(candidate, sessionId) });
 		runControl = control;
 		const controlIsCurrent = () => isRuntimeActive() && ctx === sessionCtx && runControl === control;
 		const controlDisposers = [
@@ -4076,7 +3532,7 @@ function createWorkflowPiRuntime(pi, options) {
 			if (!refreshIsCurrent()) return;
 			const sessionId = (0, _agimon_ai_doompi_core_childProcess.resolveRootSessionId)(ctx.sessionManager.getSessionId(), options.environment);
 			const rootProcess = isRootProcess(ctx, sessionId);
-			const sessionRecords = records.filter((record) => isSessionRun(record, sessionId));
+			const sessionRecords = records.filter((record) => require_workflowTerminal.isSessionRun(record, sessionId));
 			const running = sessionRecords.filter((record) => record.stage === RUNNING_STATUS && !record.stale);
 			const failed = sessionRecords.filter((record) => record.stage === ERROR_STAGE);
 			if (activeRevisionAtRead === activeRunRevision) replaceActiveRecords(running);
@@ -4086,7 +3542,7 @@ function createWorkflowPiRuntime(pi, options) {
 				"workflow.failed_count": failed.length,
 				mode: workflowMode ? "on" : "off"
 			});
-			const mine = runsForSession(records, sessionId).filter((record) => !record.stale);
+			const mine = require_workflowTerminal.runsForSession(records, sessionId).filter((record) => !record.stale);
 			sessionRunCount = mine.length;
 			publishModeWidget();
 			forgetLauncherScreens(new Set(sessionRecords.map((record) => runIdentity(record))));
@@ -4119,10 +3575,10 @@ function createWorkflowPiRuntime(pi, options) {
 			if (rootProcess && pendingTerminalRuns.size > 0) try {
 				const terminalRecords = [...pendingTerminalRuns.values()];
 				const summaries = await Promise.all(terminalRecords.map(async (record) => {
-					if (record.stage === COMPLETED_STATUS) return finishedRunSummary(record, []);
+					if (record.stage === COMPLETED_STATUS) return require_workflowTerminal.finishedRunSummary(record, []);
 					const identity = runIdentity(record);
 					const events = runEvents.get(identity) ?? progressEventsForRun(record, await (0, _agimon_ai_workflow_mcp.readWorkflowProgress)(registry.runDirectoryFor(record)));
-					return finishedRunSummary(record, (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(events));
+					return require_workflowTerminal.finishedRunSummary(record, (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(events));
 				}));
 				if (!refreshIsCurrent()) return;
 				pi.sendMessage({
@@ -4422,7 +3878,7 @@ function createWorkflowPiRuntime(pi, options) {
 			const selection = await ctx.ui.custom((tui, theme, _keybindings, done) => new WorkflowInspectorComponent(tui, theme, {
 				list: async () => {
 					const sessionId = currentSessionId();
-					const records = (await listAllRuns(registry)).filter((record) => record.stage === RUNNING_STATUS && !record.stale && isSessionRun(record, sessionId));
+					const records = (await listAllRuns(registry)).filter((record) => record.stage === RUNNING_STATUS && !record.stale && require_workflowTerminal.isSessionRun(record, sessionId));
 					inspectorRecords = new Map(records.map((record) => [runIdentity(record), record]));
 					return Promise.all(records.map(async (record) => ({
 						displayName: record.displayName,
@@ -4466,10 +3922,10 @@ function createWorkflowPiRuntime(pi, options) {
 	*/
 	const requireRun = async (input, sessionId = currentSessionId()) => {
 		observeSession(sessionId);
-		const matches = (await listAllRuns(registry, input.workspace)).filter((candidate) => candidate.runKey === input.runKey && isSessionRun(candidate, sessionId));
-		if (matches.length > 1) throw new Error(withOptions(`Workflow run key ${JSON.stringify(input.runKey)} exists in more than one workspace in this session.`, ["Retry with the workspace from the run identity."]));
+		const matches = (await listAllRuns(registry, input.workspace)).filter((candidate) => candidate.runKey === input.runKey && require_workflowTerminal.isSessionRun(candidate, sessionId));
+		if (matches.length > 1) throw new Error(require_workflowTerminal.withOptions(`Workflow run key ${JSON.stringify(input.runKey)} exists in more than one workspace in this session.`, ["Retry with the workspace from the run identity."]));
 		const record = matches[0];
-		if (!record) throw new Error(withOptions(`No workflow run matches ${JSON.stringify(input.runKey)} in this session.`, ["workflow_run with action status: use a run key from this session before retrying.", "Tell the user this session did not launch that run rather than guessing a similar key. A run launched by another Pi session, or from the command line, is managed there or with the workflow-mcp CLI."]));
+		if (!record) throw new Error(require_workflowTerminal.withOptions(`No workflow run matches ${JSON.stringify(input.runKey)} in this session.`, ["workflow_run with action status: use a run key from this session before retrying.", "Tell the user this session did not launch that run rather than guessing a similar key. A run launched by another Pi session, or from the command line, is managed there or with the workflow-mcp CLI."]));
 		return record;
 	};
 	/**
@@ -4482,9 +3938,9 @@ function createWorkflowPiRuntime(pi, options) {
 	*/
 	const requireRecoverableRun = async (input) => {
 		const matches = (await listAllRuns(registry, input.workspace)).filter((candidate) => candidate.runKey === input.runKey && candidate.stage === ERROR_STAGE);
-		if (matches.length > 1) throw new Error(withOptions(`Failed workflow run key ${JSON.stringify(input.runKey)} exists in more than one workspace.`, ["Retry with the workspace from the recovery picker or run identity."]));
+		if (matches.length > 1) throw new Error(require_workflowTerminal.withOptions(`Failed workflow run key ${JSON.stringify(input.runKey)} exists in more than one workspace.`, ["Retry with the workspace from the recovery picker or run identity."]));
 		const record = matches[0];
-		if (!record) throw new Error(withOptions(`No failed workflow run matches ${JSON.stringify(input.runKey)}.`, ["Use the recovery picker to select an interrupted or failed run, or retry with its workspace.", "Do not recover a running or completed workflow."]));
+		if (!record) throw new Error(require_workflowTerminal.withOptions(`No failed workflow run matches ${JSON.stringify(input.runKey)}.`, ["Use the recovery picker to select an interrupted or failed run, or retry with its workspace.", "Do not recover a running or completed workflow."]));
 		return record;
 	};
 	const readRecoveryEvidenceTail = async (record) => {
@@ -4621,8 +4077,8 @@ function createWorkflowPiRuntime(pi, options) {
 				runKey: record.runKey,
 				workspace: record.workspace
 			});
-			if (result.isError) throw new Error(toolResultText(result) || `Unable to ${action.toLowerCase()} workflow.`);
-			ctx.ui.notify(toolResultText(result) || `${action} requested for ${record.runKey}.`, "info");
+			if (result.isError) throw new Error(require_workflowTerminal.toolResultText(result) || `Unable to ${action.toLowerCase()} workflow.`);
+			ctx.ui.notify(require_workflowTerminal.toolResultText(result) || `${action} requested for ${record.runKey}.`, "info");
 			await refreshStatus(ctx, false);
 			record = await requireRun(record);
 		}
@@ -4679,7 +4135,7 @@ function createWorkflowPiRuntime(pi, options) {
 				const entry = byPath.get(row.key);
 				if (!entry) return;
 				launchWorkflowEntry(launchOptions, entry, ctx).then((result) => {
-					if (result) ctx.ui.notify(launchNotice(toolResultText(result)), "info");
+					if (result) ctx.ui.notify(require_workflowTerminal.launchNotice(require_workflowTerminal.toolResultText(result)), "info");
 				}, (error) => {
 					ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
 				});
@@ -4725,15 +4181,17 @@ 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 }
 		};
 		const result = await launchExecutor.execute(input, ctx);
-		ctx.ui.notify(launchNotice(toolResultText(result)), "info");
+		ctx.ui.notify(require_workflowTerminal.launchNotice(require_workflowTerminal.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 {
@@ -4880,25 +4338,25 @@ function createWorkflowPiRuntime(pi, options) {
 	services.push((cordis) => {
 		cordis.inject([_agimon_ai_doompi_core_uiHub.DOOM_UI_HUB_SERVICE], (uiContext) => {
 			const dispose = (0, _agimon_ai_doompi_core_uiHub.requireDoomUiHub)(uiContext).registerLeaderActions({
-				source: PACKAGE_SOURCE,
+				source: require_workflowTerminal.PACKAGE_SOURCE,
 				handlers: {
-					[LEADER_ENABLE_ACTION]: async (ctx) => {
+					[require_workflowTerminal.LEADER_ENABLE_ACTION]: async (ctx) => {
 						await waitForReadiness();
 						return applyWorkflowMode(true, ctx);
 					},
-					[LEADER_DISABLE_ACTION]: async (ctx) => {
+					[require_workflowTerminal.LEADER_DISABLE_ACTION]: async (ctx) => {
 						await waitForReadiness();
 						return applyWorkflowMode(false, ctx);
 					},
-					[LEADER_MANAGE_ACTION]: async (ctx) => {
+					[require_workflowTerminal.LEADER_MANAGE_ACTION]: async (ctx) => {
 						await waitForReadiness();
 						return openInspector(ctx, true);
 					},
-					[LEADER_CATALOG_ACTION]: async (ctx) => {
+					[require_workflowTerminal.LEADER_CATALOG_ACTION]: async (ctx) => {
 						await waitForReadiness();
 						return openWorkflowCatalog(ctx);
 					},
-					[LEADER_RECOVER_ACTION]: async (ctx) => {
+					[require_workflowTerminal.LEADER_RECOVER_ACTION]: async (ctx) => {
 						await waitForReadiness();
 						return openRecoveryHandoff(ctx);
 					}
@@ -4956,7 +4414,7 @@ function createWorkflowPiRuntime(pi, options) {
 		readinessHandle = (async () => {
 			if (previousReadiness) await Promise.allSettled([previousReadiness.then((handle) => handle.wait())]);
 			if (!ownsSession()) throw new Error("Workflow session initialization was superseded.");
-			return coordinator.start(PACKAGE_SOURCE, `${runtimeGeneration}:${generation}`, async (signal) => {
+			return coordinator.start(require_workflowTerminal.PACKAGE_SOURCE, `${runtimeGeneration}:${generation}`, async (signal) => {
 				const retired = () => ownReadinessAbort.signal.aborted || !ownsSession();
 				signal.throwIfAborted();
 				if (retired()) return { value: void 0 };
@@ -5102,9 +4560,9 @@ function createWorkflowPiRuntime(pi, options) {
 			resources_discover: onResourcesDiscover
 		},
 		toolRestrictions: [{
-			source: PACKAGE_SOURCE,
+			source: require_workflowTerminal.PACKAGE_SOURCE,
 			get restrict() {
-				return workflowToolRestriction(workflowMode);
+				return require_workflowTerminal.workflowToolRestriction(workflowMode);
 			},
 			subscribe(listener) {
 				restrictionListeners.add(listener);
@@ -5119,8 +4577,8 @@ function createWorkflowPiRuntime(pi, options) {
 //#region src/extensions/workspaces/sessions/(backend)/_lib/index.cli.ts
 var index_cli_default = (({ pi, context, options, signal }) => {
 	const environment = options?.environment ?? Object.freeze({ ...process.env });
-	const dispatcher = isWorkflowDispatcherProcess(environment);
-	const fence = createWorkflowFence(pi, signal);
+	const dispatcher = require_workflowTerminal.isWorkflowDispatcherProcess(environment);
+	const fence = require_workflowTerminal.createWorkflowFence(pi, signal);
 	let workflowMode = false;
 	let leader;
 	const runtime = createWorkflowPiRuntime(fence.pi, {
@@ -5143,13 +4601,13 @@ var index_cli_default = (({ pi, context, options, signal }) => {
 			isError: renderContext.isError
 		}, theme)
 	}));
-	const selectedTools = dispatcher ? dispatcherTools(nativeTools, resolveDispatcherParentSession(environment), environment) : nativeTools;
+	const selectedTools = dispatcher ? require_workflowTerminal.dispatcherTools(nativeTools, require_workflowTerminal.resolveDispatcherParentSession(environment), environment) : nativeTools;
 	return {
 		services: [...runtime.services ?? [], (cordis) => {
 			cordis.inject([_agimon_ai_doompi_core_skills.DOOM_SKILL_SOURCES_SERVICE], (skillContext) => {
 				const directory = require_workflowTerminal.workflowSkillDirectory();
 				const contribution = (0, _agimon_ai_doompi_core_skills.requireDoomSkillSourcesService)(skillContext).register({
-					source: PACKAGE_SOURCE,
+					source: require_workflowTerminal.PACKAGE_SOURCE,
 					directories: [directory]
 				});
 				return () => contribution.dispose();
@@ -5174,11 +4632,11 @@ var index_cli_default = (({ pi, context, options, signal }) => {
 		shortcuts: runtime.shortcuts?.map(([key, shortcut]) => fence.shortcut(key, shortcut)),
 		events: fence.events(runtime.events ?? {}),
 		toolRestrictions: [...runtime.toolRestrictions ?? [], ...dispatcher ? [{
-			source: `${PACKAGE_SOURCE}/dispatcher`,
-			restrict: dispatcherToolRestriction()
+			source: `${require_workflowTerminal.PACKAGE_SOURCE}/dispatcher`,
+			restrict: require_workflowTerminal.dispatcherToolRestriction()
 		}] : []],
 		resources: dispatcher ? [] : [{
-			source: PACKAGE_SOURCE,
+			source: require_workflowTerminal.PACKAGE_SOURCE,
 			moduleUrl: require("url").pathToFileURL(__filename).href,
 			skills: [{
 				name: "doompi-author-workflow",