@agimon-ai/po-workflow 0.0.0-alpha.30 → 0.0.0-alpha.32

package/README.md

@@ -152,6 +152,6 @@ Business Source License 1.1: free for personal use, organisations under USD 1M r
 
 Agent steps require an effective `runConfig.majorMode`; delegated workflows require top-level `runConfig.majorMode` before their owner child is created. Selection projects major mode, minor modes, profile and domains, adding the workflow minor mode once. `subagentModel` and `subagentThinking` set Team preferences independently of the step model.
 
-The native host requires execution-state inspection before creating agent steps. After settlement it waits for idle, no pending messages and a known background snapshot without core holds or holding-provider errors before checking decisions. Unknown ownership waits closed without consuming reminders; stops interrupt reads and retry delays.
+The native host requires execution-state inspection before creating agent steps. After settlement it waits for idle, no pending messages and a known background snapshot without core holds or holding-provider errors before checking decisions. Unknown ownership waits closed without consuming reminders; stops interrupt reads and retry delays. Running commands stop holding an inline step after five idle minutes, but its decision gate still runs before session release.
 
 Delegated successes are informational. Errors wake the workflow owner through durable custom-message admission; the launcher gets an error notification, not an agent-waking failure completion. Diagnosis stays local. Recovery, pause, resume and stop are request-driven. User-requested stops do not trigger diagnosis or automatic restart.

package/dist/{RecoverWorkflowService-BAVHSWqr.cjs → RecoverWorkflowService-BLehH1qi.cjs}

@@ -1,10 +1,10 @@
 const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_workflowCommandTemplate = require("./workflowCommandTemplate-w6rOCJpw.cjs");
 let _agimon_ai_po_core_platform = require("@agimon-ai/po-core/platform");
 let zod = require("zod");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let js_yaml = require("js-yaml");
-let liquidjs = require("liquidjs");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
@@ -320,12 +320,16 @@ const RunnerSchema = zod.z.object({ runConfig: RunConfigSchema.optional().descri
 /**
 * A command a step can run through, as a Liquid template rendered into its
 * shell command. `inProcess` tells a host that runs agent sessions itself that
-* it may run the step in-process from the structured values instead.
+* it may run the step in-process from the structured values instead; such a
+* command may leave out `run`, and then no other host can run it.
 */
 const CommandTemplateSchema = zod.z.union([zod.z.string().min(1), zod.z.object({
-	run: zod.z.string().min(1).describe("Liquid template rendered into the shell command."),
+	run: zod.z.string().min(1).optional().describe("Liquid template rendered into the shell command. An inProcess command may leave it out."),
 	inProcess: zod.z.boolean().optional().describe("A host that runs agent sessions may run this command in-process instead of the shell.")
-}).strict()]);
+}).strict().refine((command) => command.run !== void 0 || command.inProcess === true, {
+	message: "A command without run must set inProcess: true.",
+	path: ["run"]
+})]);
 const ChoiceSettingsSchema = zod.z.object({
 	model: zod.z.string().min(1).optional(),
 	thinking: zod.z.string().min(1).optional(),
@@ -866,65 +870,6 @@ async function workflowShellOutput(runtime, command, options = {}) {
 	return output;
 }
 //#endregion
-//#region src/services/workflowShell/index.ts
-/**
-* Shell-quoting helpers for safely interpolating values into shell command strings.
-*
-* DESIGN PATTERNS:
-* - Pure functions with no side effects
-* - Context-aware escaping driven by the surrounding quote character
-*
-* AVOID:
-* - String.prototype.replace with a value as the replacement string: its replacement
-*   patterns ($&, $1, $$, ...) would corrupt any value containing `$`. Build the result
-*   with slice/concat or a function replacer instead.
-*/
-/**
-* Escape a string for safe use as a single-quoted shell argument.
-*
-* Wraps the value in single quotes and neutralises embedded single quotes via the
-* quote-break-escape-requote pattern (`'\''`).
-*/
-function escapeShellArg(value) {
-	return `'${value.replace(/'/g, "'\\''")}'`;
-}
-/**
-* Escape a value for safe insertion inside a double-quoted shell string (`"..."`).
-*
-* Inside double quotes only `\`, `$`, `` ` `` and `"` retain special meaning, so each is
-* backslash-escaped in a single pass. A function replacer is used so a `$` in the value is
-* never interpreted as a replacement pattern.
-*/
-function escapeForDoubleQuotes(value) {
-	return value.replace(/[\\$`"]/g, (char) => `\\${char}`);
-}
-/**
-* Replace every occurrence of `placeholder` in `template` with `value`, escaping the value
-* for the shell-quoting context of the character immediately preceding the placeholder:
-*
-* - preceded by `"`  -> escape for a double-quoted slot (`\ $ ` ` " `)
-* - preceded by `'`  -> escape embedded single quotes (the template supplies the surrounding quotes)
-* - otherwise (bare) -> wrap the value as a single safe single-quoted token
-*
-* The result is assembled with slice/concat so `value` is never treated as a
-* String.prototype.replace replacement pattern.
-*/
-function substituteShellPlaceholder(template, placeholder, value) {
-	let result = "";
-	let searchFrom = 0;
-	for (;;) {
-		const index = template.indexOf(placeholder, searchFrom);
-		if (index === -1) return result + template.slice(searchFrom);
-		result += template.slice(searchFrom, index) + escapeForPrecedingQuote(value, template[index - 1]);
-		searchFrom = index + placeholder.length;
-	}
-}
-function escapeForPrecedingQuote(value, precedingChar) {
-	if (precedingChar === "\"") return escapeForDoubleQuotes(value);
-	if (precedingChar === "'") return value.replace(/'/g, "'\\''");
-	return escapeShellArg(value);
-}
-//#endregion
 //#region src/services/WorkflowParserService/index.ts
 /**
 * WorkflowParserService
@@ -951,17 +896,9 @@ const CHOICE_SETTING_KEYS = new Set(Object.keys(ChoiceSettingsSchema.shape));
 const UNQUOTED_PROMPT_PATTERN = /\{\{-?\s*(prompt|systemPrompt)\s*-?\}\}/;
 const LEGACY_INTERPOLATION_MARKER = "${{";
 /**
-* Renders command templates. Strict, so a variable a launch does not provide
-* fails the step instead of rendering an empty flag; lenient in `if` and
-* `default`, so optional values such as the system prompt can be tested.
+* A declared command's template and host options, whichever form it was written
+* in. `run` is undefined for an in-process command with no shell form.
 */
-const commandTemplates = new liquidjs.Liquid({
-	strictVariables: true,
-	strictFilters: true,
-	lenientIf: true
-});
-commandTemplates.registerFilter("shell", (value) => escapeShellArg(Array.isArray(value) ? value.join(",") : String(value ?? "")));
-/** A declared command's template and host options, whichever form it was written in. */
 function commandTemplateOf(command) {
 	return typeof command === "string" ? {
 		run: command,
@@ -1082,6 +1019,22 @@ var WorkflowParserService = class {
 		return parsed;
 	}
 	/**
+	* Read and import-merge a partial workflow definition without concrete schema
+	* validation or extends resolution. This is intentionally for inspection only.
+	*/
+	async parseWorkflowTemplateFile(workflowPath) {
+		const resolved = (0, node_path.resolve)(this.runtime.cwd, workflowPath);
+		if (!await (0, _agimon_ai_po_core_platform.pathExists)(this.runtime.fs, resolved, this.runtime.ioContext)) throw new Error(`Workflow file not found: ${resolved}`);
+		const content = (0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.readTextFile(resolved, this.runtime.ioContext));
+		const parsed = (0, js_yaml.load)(content);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Workflow template must be a YAML object: ${resolved}`);
+		const workflow = parsed;
+		workflow.jobs ??= {};
+		if (workflow.imports) await this.resolveImports(workflow, resolved);
+		workflow.jobs ??= {};
+		return workflow;
+	}
+	/**
 	* Render a command template into the shell command a step runs.
 	*
 	* Values enter as data and are never rendered again, so `${{ }}` text a
@@ -1089,15 +1042,15 @@ var WorkflowParserService = class {
 	* is. Use the `shell` filter to quote a value as one shell word.
 	*/
 	renderCommandTemplate(template, values) {
-		return commandTemplates.parseAndRenderSync(template, values).trim();
+		return require_workflowCommandTemplate.renderWorkflowCommandTemplate(template, values);
 	}
 	/** The top-level values a command template reads. */
 	templateVariables(template) {
-		return commandTemplates.globalVariablesSync(template);
+		return require_workflowCommandTemplate.workflowCommandTemplateVariables(template);
 	}
 	/** Whether a template passes the system prompt itself; when not, it is folded into the prompt. */
 	templateUsesSystemPrompt(template) {
-		return commandTemplates.globalVariablesSync(template).includes(SYSTEM_PROMPT_VARIABLE);
+		return require_workflowCommandTemplate.workflowCommandTemplateVariables(template).includes(SYSTEM_PROMPT_VARIABLE);
 	}
 	/**
 	* Check what the schema cannot see once imports and templates are merged:
@@ -1112,12 +1065,13 @@ var WorkflowParserService = class {
 		const jobNames = new Set(Object.keys(workflow.jobs));
 		for (const [name, command] of Object.entries(commands)) {
 			const { run } = commandTemplateOf(command);
+			if (run === void 0) continue;
 			if (run.includes(LEGACY_INTERPOLATION_MARKER)) problems.push(`Command "${name}" uses \${{ }}; command templates are Liquid, use {{ }} instead.`);
 			if (UNQUOTED_PROMPT_PATTERN.test(run)) problems.push(`Command "${name}" prints a prompt unquoted; write {{ prompt | shell }}.`);
 			try {
-				if (!commandTemplates.globalVariablesSync(run).includes(PROMPT_VARIABLE)) problems.push(`Command "${name}" never passes {{ prompt | shell }} to the agent.`);
+				if (!require_workflowCommandTemplate.workflowCommandTemplateVariables(run).includes(PROMPT_VARIABLE)) problems.push(`Command "${name}" never passes {{ prompt | shell }} to the agent.`);
 			} catch (error) {
-				problems.push(`Command "${name}" is not a valid Liquid template: ${error.message}`);
+				problems.push(`Command "${name}" is not a valid Liquid template: ${error instanceof Error ? error.message : String(error)}`);
 			}
 		}
 		for (const [name, choice] of Object.entries(choices)) for (const key of Object.keys(choice)) if (!CHOICE_SETTING_KEYS.has(key) && !(key in commands)) problems.push(`Choice "${name}" overrides "${key}", which is not a declared command.`);
@@ -1534,7 +1488,9 @@ async function diagnoseWorkflow(workflowPath, options) {
 	const hostKeys = options.runConfigKeys === void 0 ? void 0 : new Set(options.runConfigKeys);
 	const reads = (command) => {
 		const declared = workflow.commands?.[command];
-		return declared === void 0 ? void 0 : new Set(parser.templateVariables(commandTemplateOf(declared).run));
+		if (declared === void 0) return void 0;
+		const { run } = commandTemplateOf(declared);
+		return new Set(run === void 0 ? [] : parser.templateVariables(run));
 	};
 	const unknownKeys = (keys, known) => [...new Set(keys)].filter((key) => !known.has(key));
 	for (const { step, location } of collectSteps(workflow)) {
@@ -5903,7 +5859,7 @@ var BackgroundServiceManager = class {
 		while (Date.now() - start < timeout) {
 			if (shouldAbort?.()) return false;
 			try {
-				await workflowShellOutput(this.runtime, `/bin/zsh -c ${escapeShellArg(checkCmd)}`, {
+				await workflowShellOutput(this.runtime, `/bin/zsh -c ${require_workflowCommandTemplate.escapeShellArg(checkCmd)}`, {
 					cwd: workDir,
 					environment: readyEnv,
 					timeoutMs: 5e3
@@ -6663,6 +6619,7 @@ const RUN_KEY = "run";
 const INTERACTIVE_RUN_KEY = "interactiveRun";
 const CUSTOM_RUN_KEY = "customRun";
 const CUSTOM_RUN_UNSUPPORTED_MESSAGE = "customRun needs a host step executor and no run or interactiveRun fallback exists for step";
+const IN_PROCESS_ONLY_UNSUPPORTED_MESSAGE = "has no run template, and this host cannot run it in-process";
 const WORKFLOW_RUN_CONFIG_ENV_KEY = "WORKFLOW_RUN_CONFIG";
 const DEFAULT_CHOICE = "default";
 const OUTPUT_TAIL_LINES = 50;
@@ -6972,7 +6929,7 @@ var StepRunnerService = class StepRunnerService {
 			this.logger.error(`    ${RED$2}${STATUS_FAIL}${RESET$3}  ${stepName}\n`);
 			return false;
 		}
-		const { command, custom, interactive, template } = resolvedStepCommand;
+		const { command, custom, inProcessOnly, interactive, template } = resolvedStepCommand;
 		const isCodexCommand = this.quotaService.isCodexCommand(command, resolvedStepCommand.agentKey);
 		const shouldContinue = step["continue-on-error"] || options.continueOnError;
 		let timeoutMs;
@@ -7120,6 +7077,7 @@ var StepRunnerService = class StepRunnerService {
 			}, (trace) => this.startStepExecution({
 				traceparent: trace?.traceparent,
 				command,
+				inProcessOnly: inProcessOnly === true,
 				custom,
 				interactive,
 				onExecutionStarted: options.onExecutionStarted,
@@ -7547,7 +7505,7 @@ var StepRunnerService = class StepRunnerService {
 	* Start a step through the host executor when it offers one, else spawn it.
 	*/
 	startStepExecution(request) {
-		const { command, custom, interactive, stepEnv, stepName, template, timeoutMs, workDir } = request;
+		const { command, custom, inProcessOnly, interactive, stepEnv, stepName, template, timeoutMs, workDir } = request;
 		const executor = this.stepExecutor;
 		const base = {
 			traceparent: request.traceparent,
@@ -7566,8 +7524,21 @@ var StepRunnerService = class StepRunnerService {
 			...base,
 			customRun: custom
 		}), stepName, workDir, command, timeoutMs, request.onExecutionStarted);
-		const executionCommand = interactive ? this.withInteractiveTerminalTitle(command, stepEnv) : command;
 		const executeCommand = executor?.command?.bind(executor);
+		if (inProcessOnly) {
+			const notInProcess = () => Promise.resolve({
+				status: RESULT_STATUS_COMPLETED,
+				exitCode: UNKNOWN_EXIT_CODE,
+				failure: `command "${template?.name}" ${IN_PROCESS_ONLY_UNSUPPORTED_MESSAGE}`
+			});
+			if (!executeCommand) return notInProcess();
+			return this.executeExternal(() => executeCommand.call(executor, {
+				...base,
+				interactive,
+				...template === void 0 ? {} : { template }
+			}), stepName, workDir, command, timeoutMs, request.onExecutionStarted, notInProcess);
+		}
+		const executionCommand = interactive ? this.withInteractiveTerminalTitle(command, stepEnv) : command;
 		const spawnHere = () => interactive ? this.withTerminal(() => this.interruptedSignal ? Promise.resolve({
 			status: RESULT_STATUS_SIGNALED,
 			signal: this.interruptedSignal
@@ -7850,7 +7821,7 @@ var StepRunnerService = class StepRunnerService {
 		const systemPromptSource = entry.systemPrompt ?? step.systemPrompt;
 		const systemPrompt = [systemPromptSource === void 0 ? void 0 : this.parser.interpolate(systemPromptSource, promptContext), this.decisionInstructions(context, decisionFile)].filter((part) => part !== void 0 && part.length > 0).join("\n\n") || void 0;
 		const { run, inProcess } = commandTemplateOf(declared);
-		const passesSystemPrompt = this.parser.templateUsesSystemPrompt(run);
+		const passesSystemPrompt = run !== void 0 && this.parser.templateUsesSystemPrompt(run);
 		const values = {
 			...runConfig,
 			command: entry.command,
@@ -7858,8 +7829,8 @@ var StepRunnerService = class StepRunnerService {
 			...choiceName === void 0 ? {} : { choice: choiceName },
 			...systemPrompt === void 0 || !passesSystemPrompt ? {} : { systemPrompt }
 		};
-		let command;
-		try {
+		let command = `${entry.command}: ${prompt.split(COMMAND_LINE_BREAK)[0]}`;
+		if (run !== void 0) try {
 			command = this.parser.renderCommandTemplate(run, values);
 		} catch (error) {
 			return failed(`command "${entry.command}" did not render: ${error instanceof Error ? error.message : String(error)}`);
@@ -7867,6 +7838,7 @@ var StepRunnerService = class StepRunnerService {
 		return {
 			agentKey: entry.command,
 			command,
+			...run === void 0 ? { inProcessOnly: true } : {},
 			interactive: true,
 			runConfig,
 			template: {
@@ -7875,7 +7847,8 @@ var StepRunnerService = class StepRunnerService {
 				prompt,
 				reads: [...new Set(offered.flatMap((candidate) => {
 					const offeredTemplate = selection.commands?.[candidate.command];
-					return offeredTemplate === void 0 ? [] : this.parser.templateVariables(commandTemplateOf(offeredTemplate).run);
+					const offeredRun = offeredTemplate === void 0 ? void 0 : commandTemplateOf(offeredTemplate).run;
+					return offeredRun === void 0 ? [] : this.parser.templateVariables(offeredRun);
 				}))],
 				...choiceName === void 0 ? {} : { choice: choiceName },
 				...systemPrompt === void 0 ? {} : { systemPrompt }
@@ -9889,7 +9862,8 @@ var RunWorkflowService = class {
 				const innerCommand = await this.createLaunchScriptCommand(input, workflowPath, workflow);
 				const launchBaseName = input.name || workflow.name || (0, node_path.basename)(workflowPath);
 				const launchDisplayName = input.name ? launchBaseName : `${launchBaseName}-${this.parser.generateHumanReadableId()}`;
-				const shell = substituteShellPlaceholder(substituteShellPlaceholder(launchCommand, LAUNCH_NAME_PLACEHOLDER, launchDisplayName), LAUNCH_COMMAND_PLACEHOLDER, innerCommand);
+				const namedLaunchCommand = require_workflowCommandTemplate.substituteShellPlaceholder(launchCommand, LAUNCH_NAME_PLACEHOLDER, launchDisplayName);
+				const shell = require_workflowCommandTemplate.substituteShellPlaceholder(namedLaunchCommand, LAUNCH_COMMAND_PLACEHOLDER, innerCommand);
 				this.logger.info(`${DIM}Delegating via launch-command: ${shell}${RESET}`);
 				delegated = true;
 				const launched = await this.spawnLaunchCommand(shell, {
@@ -10795,7 +10769,7 @@ var RunWorkflowService = class {
 		const launcher = (0, node_path.resolve)(binDir, STEP_CLI_NAME);
 		const runAsNode = this.runtime.workflowHost.isElectron ? "ELECTRON_RUN_AS_NODE=1 " : "";
 		(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.createDir(binDir, { recursive: true }, this.runtime.ioContext));
-		(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.writeFile(launcher, `#!/bin/sh\n${runAsNode}exec ${escapeShellArg(this.runtime.workflowHost.executablePath)} ${escapeShellArg(cliPath)} "$@"\n`, this.runtime.ioContext));
+		(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.writeFile(launcher, `#!/bin/sh\n${runAsNode}exec ${require_workflowCommandTemplate.escapeShellArg(this.runtime.workflowHost.executablePath)} ${require_workflowCommandTemplate.escapeShellArg(cliPath)} "$@"\n`, this.runtime.ioContext));
 		await this.runtime.workflowHost.setMode(launcher, 493);
 		workflowEnv.PATH = `${binDir}:${workflowEnv.PATH ?? this.runtime.baseEnvironment.PATH ?? ""}`;
 	}
@@ -10835,17 +10809,17 @@ var RunWorkflowService = class {
 			""
 		].join("\n");
 		await this.runtime.workflowHost.writeExclusive(scriptPath, script);
-		return `sh ${escapeShellArg(scriptPath)}`;
+		return `sh ${require_workflowCommandTemplate.escapeShellArg(scriptPath)}`;
 	}
 	async buildLauncherOriginExports() {
 		const exports = [];
-		if (this.runtime.baseEnvironment[CMUX_WORKSPACE_ID_ENV]) exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_WORKSPACE_ID_ENV}=${escapeShellArg(this.runtime.baseEnvironment[CMUX_WORKSPACE_ID_ENV])}`);
-		if (this.runtime.baseEnvironment[CMUX_SURFACE_ID_ENV]) exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_SURFACE_ID_ENV}=${escapeShellArg(this.runtime.baseEnvironment[CMUX_SURFACE_ID_ENV])}`);
+		if (this.runtime.baseEnvironment[CMUX_WORKSPACE_ID_ENV]) exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_WORKSPACE_ID_ENV}=${require_workflowCommandTemplate.escapeShellArg(this.runtime.baseEnvironment[CMUX_WORKSPACE_ID_ENV])}`);
+		if (this.runtime.baseEnvironment[CMUX_SURFACE_ID_ENV]) exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_SURFACE_ID_ENV}=${require_workflowCommandTemplate.escapeShellArg(this.runtime.baseEnvironment[CMUX_SURFACE_ID_ENV])}`);
 		const paneId = this.runtime.baseEnvironment[TMUX_PANE_ENV];
 		if (paneId) {
-			exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_PANE_ID_ENV}=${escapeShellArg(paneId)}`);
+			exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_PANE_ID_ENV}=${require_workflowCommandTemplate.escapeShellArg(paneId)}`);
 			const identity = await this.readTmuxIdentity(paneId);
-			if (identity?.sessionId) exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_SESSION_ID_ENV}=${escapeShellArg(identity.sessionId)}`);
+			if (identity?.sessionId) exports.push(`export ${WORKFLOW_LAUNCHER_ORIGIN_SESSION_ID_ENV}=${require_workflowCommandTemplate.escapeShellArg(identity.sessionId)}`);
 		}
 		return exports;
 	}
@@ -10883,7 +10857,7 @@ var RunWorkflowService = class {
 	}
 	async readTmuxIdentity(paneId) {
 		try {
-			const [sessionId, sessionName, windowId, resolvedPaneId] = (await workflowShellOutput(this.runtime, `tmux display-message -p -t ${escapeShellArg(paneId)} ${escapeShellArg("#{session_id}	#{session_name}	#{window_id}	#{pane_id}")}`)).trim().split("	");
+			const [sessionId, sessionName, windowId, resolvedPaneId] = (await workflowShellOutput(this.runtime, `tmux display-message -p -t ${require_workflowCommandTemplate.escapeShellArg(paneId)} ${require_workflowCommandTemplate.escapeShellArg("#{session_id}	#{session_name}	#{window_id}	#{pane_id}")}`)).trim().split("	");
 			if (!sessionId || !sessionName || !windowId || !resolvedPaneId) return void 0;
 			return {
 				paneId: resolvedPaneId,
@@ -10901,28 +10875,29 @@ var RunWorkflowService = class {
 	* adding --skip-launch to prevent infinite recursion.
 	*/
 	buildLaunchCliCommand(input, workflowPath, workflow) {
+		const cliPath = this.resolveCliPath();
 		const parts = [
 			"node",
-			escapeShellArg(this.resolveCliPath()),
+			require_workflowCommandTemplate.escapeShellArg(cliPath),
 			"run-workflow",
-			escapeShellArg(workflowPath),
+			require_workflowCommandTemplate.escapeShellArg(workflowPath),
 			"--skip-launch"
 		];
 		const runner = this.resolveRunner(input, workflow);
-		if (input.job) parts.push("--job", escapeShellArg(input.job));
-		if (runner) parts.push("--runner", escapeShellArg(runner));
-		if (input.command) parts.push("--command", escapeShellArg(input.command));
-		if (input.choice) parts.push("--choice", escapeShellArg(input.choice));
+		if (input.job) parts.push("--job", require_workflowCommandTemplate.escapeShellArg(input.job));
+		if (runner) parts.push("--runner", require_workflowCommandTemplate.escapeShellArg(runner));
+		if (input.command) parts.push("--command", require_workflowCommandTemplate.escapeShellArg(input.command));
+		if (input.choice) parts.push("--choice", require_workflowCommandTemplate.escapeShellArg(input.choice));
 		if (input.dryRun) parts.push("--dry-run");
 		if (input.continueOnError) parts.push("--continue-on-error");
 		if (input.keepWorktree) parts.push("--keep-worktree");
-		if (input.prompt) parts.push("--prompt", escapeShellArg(input.prompt));
-		if (input.name) parts.push("--name", escapeShellArg(input.name));
-		if (input.workspace) parts.push("--workspace", escapeShellArg(input.workspace));
-		if (input.secretFile) parts.push("--secret-file", escapeShellArg(input.secretFile));
-		if (input.statusFile) parts.push("--status-file", escapeShellArg(input.statusFile));
-		if (input.inputs) for (const [key, val] of Object.entries(input.inputs)) parts.push("--input", escapeShellArg(`${key}=${val}`));
-		if (input.env) for (const [key, val] of Object.entries(input.env)) parts.push("--env", escapeShellArg(`${key}=${val}`));
+		if (input.prompt) parts.push("--prompt", require_workflowCommandTemplate.escapeShellArg(input.prompt));
+		if (input.name) parts.push("--name", require_workflowCommandTemplate.escapeShellArg(input.name));
+		if (input.workspace) parts.push("--workspace", require_workflowCommandTemplate.escapeShellArg(input.workspace));
+		if (input.secretFile) parts.push("--secret-file", require_workflowCommandTemplate.escapeShellArg(input.secretFile));
+		if (input.statusFile) parts.push("--status-file", require_workflowCommandTemplate.escapeShellArg(input.statusFile));
+		if (input.inputs) for (const [key, val] of Object.entries(input.inputs)) parts.push("--input", require_workflowCommandTemplate.escapeShellArg(`${key}=${val}`));
+		if (input.env) for (const [key, val] of Object.entries(input.env)) parts.push("--env", require_workflowCommandTemplate.escapeShellArg(`${key}=${val}`));
 		return parts.join(" ");
 	}
 	/**
@@ -11384,12 +11359,6 @@ Object.defineProperty(exports, "diagnoseWorkflows", {
 		return diagnoseWorkflows;
 	}
 });
-Object.defineProperty(exports, "escapeShellArg", {
-	enumerable: true,
-	get: function() {
-		return escapeShellArg;
-	}
-});
 Object.defineProperty(exports, "formatArtifactWarning", {
 	enumerable: true,
 	get: function() {
@@ -11487,4 +11456,4 @@ Object.defineProperty(exports, "workflowShellOutput", {
 	}
 });
 
-//# sourceMappingURL=RecoverWorkflowService-BAVHSWqr.cjs.map
+//# sourceMappingURL=RecoverWorkflowService-BLehH1qi.cjs.map