@agimon-ai/doompi-workflow 0.0.1-alpha.76 → 0.0.1-alpha.78

package/dist/src/tui/workflowRuntime.cjs

@@ -0,0 +1,1934 @@
+const require_index = require("../services/workflowLaunchCommand/index.cjs");
+const require_workflow = require("../constants/workflow.cjs");
+const require_index$1 = require("../services/workflowResource/index.cjs");
+const require_index$2 = require("../services/piToolBridge/index.cjs");
+const require_index$3 = require("../services/workflowExecution/index.cjs");
+const require_index$4 = require("../services/backgroundWork/index.cjs");
+const require_index$5 = require("../services/workflowLauncher/index.cjs");
+const require_index$6 = require("../services/workflowNarration/index.cjs");
+const require_index$7 = require("../services/workflowTerminal/index.cjs");
+const require_workflowCatalog = require("./workflow/workflowCatalog.cjs");
+const require_workflowFinishedMessage = require("./workflow/workflowFinishedMessage.cjs");
+const require_workflowInspector = require("./workflow/workflowInspector.cjs");
+const require_workflowOverlay = require("./workflow/workflowOverlay.cjs");
+const require_workflowPicker = require("./workflow/workflowPicker.cjs");
+const require_workflowProgressOverlay = require("./workflow/workflowProgressOverlay.cjs");
+const require_workflowPrompt = require("./workflow/workflowPrompt.cjs");
+const require_workflowRunPanel = require("./workflow/workflowRunPanel.cjs");
+const require_workflowStepMessage = require("./workflow/workflowStepMessage.cjs");
+let _agimon_ai_doompi_core_ui_hub = require("@agimon-ai/doompi-core/ui-hub");
+let _agimon_ai_doompi_core_child_process = require("@agimon-ai/doompi-core/child-process");
+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 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/tui/workflowRuntime.ts
+const DOOM_FULLSCREEN_UI_OPTIONS = {
+	overlay: true,
+	overlayOptions: {
+		anchor: "top-left",
+		width: "100%",
+		maxHeight: "100%",
+		margin: 0
+	}
+};
+/** Renderer retained for step cards already persisted by older package versions. */
+const LEGACY_WORKFLOW_STEP_MESSAGE = "workflow-step";
+const FOLLOW_WIDGET_KEY = "workflow-mcp-follow";
+const MODE_ID = "workflow";
+const MODE_LABEL = "Workflow";
+const MODE_LABEL_STYLE = "accent";
+const MODE_ORDER = 20;
+const MODE_ACTION_ACTIVATE = "activate";
+const MODE_ACTION_DEACTIVATE = "deactivate";
+function workflowModeState(active, runCount) {
+	return {
+		activation: active ? "active" : "inactive",
+		condition: "ready",
+		...active ? {
+			detail: runCount > 0 ? `${runCount} active runs` : "tools enabled",
+			color: MODE_LABEL_STYLE
+		} : {},
+		actions: [...active ? [{
+			id: MODE_ACTION_ACTIVATE,
+			enabled: false,
+			disabledReason: "Workflow mode is active."
+		}] : [{
+			id: MODE_ACTION_ACTIVATE,
+			enabled: true
+		}], ...active ? [{
+			id: MODE_ACTION_DEACTIVATE,
+			enabled: true
+		}] : [{
+			id: MODE_ACTION_DEACTIVATE,
+			enabled: false,
+			disabledReason: "Workflow mode is inactive."
+		}]]
+	};
+}
+const LEADER_MODE_BREADCRUMB = "SPC w e";
+const CATALOG_BREADCRUMB = "SPC › w / workflows › l / list";
+const MANAGE_BREADCRUMB = "SPC › w / workflows › r / runs";
+const RECOVER_BREADCRUMB = "SPC › w / workflows › c / recover";
+const RUN_PANEL_BREADCRUMB = "SPC › w / workflows › run";
+const PAUSED_EXECUTION_STATE = "paused";
+const UNFOLLOW_SHORTCUT = "ctrl+alt+w";
+/**
+* Dismisses the run panel.
+*
+* Separate from the focus toggle because a focused panel hands every key to the
+* run, Escape included, so a plain "Escape closes an overlay" is unavailable:
+* interrupting the agent inside a step is worth more than a close key. Folding
+* closing into the focus toggle instead would leave an unfocused panel with no
+* way back to typing into the run.
+*
+* Not the only way out. This chord relies on a modifier some terminals do not
+* transmit, so `DoubleEscapeDetector` backs it with a plain double-Escape that
+* every terminal can send.
+*/
+const CLOSE_OVERLAY_SHORTCUT = "ctrl+alt+q";
+/** Modifier glyphs macOS users read on their own keyboards and in every menu. */
+const MAC_MODIFIER_GLYPHS = {
+	alt: "⌥",
+	cmd: "⌘",
+	ctrl: "⌃",
+	meta: "⌘",
+	shift: "⇧"
+};
+/**
+* Render a binding the way the user's own platform writes it.
+*
+* The binding string Pi registers stays canonical (`ctrl+alt+w`) on every
+* platform; only the label changes. A macOS user reading "alt" has to translate
+* it to the Option key they actually press, and the modifier is not even
+* labelled "alt" on most Apple keyboards.
+*
+* Pi branches on `process.platform` for its own keybindings, so this follows a
+* convention already in the host rather than inventing one.
+*/
+function shortcutLabel(binding, platform = process.platform) {
+	const parts = binding.split("+");
+	if (platform === "darwin") return parts.map((part) => MAC_MODIFIER_GLYPHS[part] ?? part.toUpperCase()).join("");
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("+");
+}
+const DEFAULT_PAGE_SIZE = 100;
+/**
+* The reconcile sweep, which is a fallback rather than the mechanism.
+*
+* The observer reports a change as it happens, so this only bounds how long a
+* change nothing notified us about stays invisible. It was 5s when it was the
+* only way anything was noticed.
+*/
+const MONITOR_INTERVAL_MS = 3e4;
+/**
+* Coalescing window for event-driven status refreshes.
+*
+* A run emits several transitions at once, and each one would otherwise page
+* the registry for the authoritative lifecycle snapshot. One page per burst.
+*/
+const STATUS_REFRESH_DEBOUNCE_MS = 120;
+const PI_EXEC_TIMEOUT_MS = 1e4;
+const RUNNING_STATUS = "running";
+const COMPLETED_STATUS = "completed";
+const FAILED_STATUS = "failed";
+const ERROR_STAGE = "error";
+const ERROR_COLOUR = "error";
+/**
+* How long shutdown waits for an interrupted inline run to finalize its record.
+*
+* Long enough for a step that honours SIGTERM to unwind and for the registry
+* write that follows, short enough that a step ignoring it does not strand the
+* user in a session that will not close.
+*/
+const SHUTDOWN_FINALIZE_TIMEOUT_MS = 1e4;
+const FOLLOW_INTERVAL_MS = 2e3;
+const TAIL_LINES = 24;
+/** Below these a resized run has no room left to draw, so it keeps its own size and the panel clips. */
+/**
+* Overlay refresh cadence and size.
+*
+* Faster than the background widget's 2s: a foregrounded terminal that lags
+* behind your own typing reads as broken, and only the one run being watched
+* pays for it.
+*/
+const OVERLAY_REFRESH_MS = 200;
+/**
+* Slowest part of a refresh, given its own cadence.
+*
+* Reading a run's screen means forking `tmux capture-pane` or `cmux read-screen`,
+* measured at ~75ms. Repainting at 200ms is right for a panel; forking at 200ms
+* is not, so the two are decoupled and only the render keeps the fast tick. A
+* terminal tail is a rolling window of the last few seconds either way, so the
+* slower read costs the reader nothing they can perceive.
+*/
+const SCREEN_REFRESH_MS = 750;
+/**
+* How many recent run announcements the launch handshake can look back through.
+*
+* Only ever searched for a run that registered within the acknowledgement
+* window, so this needs to cover concurrent launches, not session history. The
+* per-session concurrency ceiling is five.
+*/
+const ANNOUNCED_RUN_HISTORY = 32;
+/**
+* Telemetry name for a launch being asked for.
+*
+* Named once because both launch paths, the wizard and the tool, report it and
+* a query that spans them only works while the two agree.
+*/
+const LAUNCH_REQUESTED_EVENT = "doom_workflow.launch_requested";
+/**
+* Recovery skill shipped by this package, offered to Pi at resource discovery.
+*
+* Recovery is the one path here complex enough to deserve a real skill rather
+* than a few tool guidelines, and this package owns that domain: it cannot
+* assume the host repository provides one. Discovery is cheap, since Pi puts
+* only the name, description, and location in the system prompt and reads the
+* body on demand.
+*
+* Resolved from the module directory, not the module file: `resolve` treats a
+* trailing filename as a path segment. Both `src/extensions` and
+* `dist/extensions` sit two levels below the package root.
+*/
+/**
+* Glyphs for widgets, panels, and notices.
+*
+* Deliberately restricted to characters that render in a default terminal font.
+* A box-drawing or emoji glyph that falls back to tofu is worse than no glyph.
+*/
+const GLYPH = {
+	running: "▸",
+	repair: "⚠",
+	completed: "✔",
+	failed: "✖",
+	separator: "·"
+};
+/**
+* The panel's footer: how to leave, in the order a stuck user needs it.
+*
+* Escape leads on an interactive panel because it is the key every terminal
+* transmits, and the one someone reaches for first when a view will not let go.
+* A view-only panel says so instead: a user who does not know the run is
+* unreachable reads the silence as the panel being broken.
+*/
+function panelHint(interactive, platform = process.platform) {
+	const close = shortcutLabel(CLOSE_OVERLAY_SHORTCUT, platform);
+	if (!interactive) return `view only ${GLYPH.separator} ${close} closes this view`;
+	return [
+		"Esc Esc closes this view",
+		`${shortcutLabel(UNFOLLOW_SHORTCUT, platform)} switches typing`,
+		`${close} closes`
+	].join(` ${GLYPH.separator} `);
+}
+/** The same hints as key caps, for the doom footer legend. */
+function panelHints(interactive, platform = process.platform) {
+	const close = [shortcutLabel(CLOSE_OVERLAY_SHORTCUT, platform), "close"];
+	if (!interactive) return [close];
+	return [
+		["Esc Esc", "close"],
+		[shortcutLabel(UNFOLLOW_SHORTCUT, platform), "switch typing"],
+		close
+	];
+}
+/**
+* Header and output lines for the follow widget, fitted to the terminal.
+*
+* Every line a component renders must fit the given width, so the header sheds
+* detail right to left as the terminal narrows: the dismissal hint goes first,
+* then the workspace/stage context, and the run key survives longest because it
+* is the identifier the user needs to name the run.
+*
+* Colour is applied after fitting. Measuring plain text and styling afterwards
+* keeps the arithmetic honest, since escape codes occupy no visible columns.
+*/
+function renderFollowLines(record, output, theme, width) {
+	const key = `${GLYPH.running} ${record.runKey}`;
+	const meta = [
+		record.workspace,
+		stageLabel(record),
+		record.runner
+	].filter(Boolean).join(` ${GLYPH.separator} `);
+	const hint = `${shortcutLabel(UNFOLLOW_SHORTCUT)} to background`;
+	const gap = "   ";
+	let header = theme.fg("accent", (0, _earendil_works_pi_tui.truncateToWidth)(key, width));
+	if ((0, _earendil_works_pi_tui.visibleWidth)(key) + 3 + (0, _earendil_works_pi_tui.visibleWidth)(meta) <= width) {
+		header += gap + theme.fg("muted", meta);
+		if ((0, _earendil_works_pi_tui.visibleWidth)(key) + 3 + (0, _earendil_works_pi_tui.visibleWidth)(meta) + 3 + (0, _earendil_works_pi_tui.visibleWidth)(hint) <= width) header += gap + theme.fg("dim", hint);
+	}
+	return [header, ...output.map((line) => (0, _earendil_works_pi_tui.truncateToWidth)(line, width))];
+}
+/**
+* Job tree for the follow widget, in the shape a CI run reads best.
+*
+* Finished jobs collapse to a single line so the eye lands on the one still
+* running, whose steps are listed. That is the whole reason this exists: a
+* scraped terminal shows whatever the runner last printed, which is not the
+* same as knowing which job of how many is in flight.
+*/
+function renderProgressLines(jobs, theme, width) {
+	const lines = [];
+	for (const job of jobs) {
+		const glyph = job.status === COMPLETED_STATUS ? GLYPH.completed : job.status === FAILED_STATUS ? GLYPH.failed : GLYPH.running;
+		const colour = job.status === COMPLETED_STATUS ? "success" : job.status === FAILED_STATUS ? ERROR_COLOUR : "accent";
+		const position = job.total ? ` ${GLYPH.separator} ${(job.index ?? 0) + 1}/${job.total}` : "";
+		lines.push((0, _earendil_works_pi_tui.truncateToWidth)(theme.fg(colour, `${glyph} ${job.name}`) + theme.fg("dim", position), width));
+		if (job.status !== RUNNING_STATUS) continue;
+		for (const step of job.steps) {
+			const stepGlyph = step.status === COMPLETED_STATUS ? GLYPH.completed : step.status === FAILED_STATUS ? GLYPH.failed : GLYPH.running;
+			const stepColour = step.status === RUNNING_STATUS ? "muted" : step.status === FAILED_STATUS ? ERROR_COLOUR : "dim";
+			lines.push((0, _earendil_works_pi_tui.truncateToWidth)(theme.fg(stepColour, `    ${stepGlyph} ${step.name}`), width));
+		}
+	}
+	return lines;
+}
+function progressEventsForRun(record, events) {
+	const startedAt = Date.parse(record.startedAt);
+	if (!Number.isFinite(startedAt)) return events;
+	return events.filter((event) => {
+		const eventAt = Date.parse(event.at);
+		return !Number.isFinite(eventAt) || eventAt >= startedAt;
+	});
+}
+/** Human-readable stage, rather than leaking the raw registry enum. */
+function stageLabel(record) {
+	if (record.stale) return "stale";
+	if (record.stage === ERROR_STAGE) return FAILED_STATUS;
+	return record.stage;
+}
+const LAUNCHER_ENVIRONMENT_STRIPPED = [
+	"CMUX_SURFACE_ID",
+	_agimon_ai_doompi_core_child_process.SUBAGENT_ROOT_SESSION_ENV,
+	"CMUX_WORKSPACE_ID",
+	"TMUX_PANE",
+	"WORKFLOW_LAUNCHER_TYPE",
+	"WORKFLOW_TMUX_SESSION_NAME",
+	"WORKFLOW_STATUS_FILE"
+];
+/**
+* Slack between this process's clock and the run record's timestamp.
+*
+* The record is written by another process, and a launch acknowledged a
+* fraction of a second "before" it began is a clock difference, not somebody
+* else's run.
+*/
+const LAUNCH_ACK_CLOCK_SKEW_MS = 2e3;
+const LAUNCHER_ENV = "WORKFLOW_LAUNCHER";
+const RECOVER_COMMAND = "recover-workflow";
+const LAUNCH_PROCESS_COMMAND = "launch-process";
+/**
+* How a run is hosted, which is also the name of the binary that addresses it.
+*
+* One token per launcher rather than two, because they are the same token: a
+* record's `launcher.type` is `tmux` precisely because tmux is what hosts it and
+* `tmux` is what reads it back. `native` has no binary, which is exactly why
+* every surface has to branch on it.
+*/
+const LAUNCHER_TMUX = "tmux";
+const LAUNCHER_CMUX = "cmux";
+const LAUNCHER_NATIVE = "native";
+/** The cmux socket method that answers with a styled render grid rather than plain text. */
+/** The verb the cockpit's launch dialog sends; the leader board does the same work. */
+const WORKFLOW_LAUNCH_COMMAND = "workflow-launch";
+const HOST_TERMINAL_OUTPUT_BLOCKED = "This run points at Pi's own terminal, so its launcher screen is hidden. Use workflow status instead.";
+/**
+* Whether stale or inherited launcher metadata addresses this Pi process.
+*
+* Reading such a target recursively captures the chat into its own widget;
+* opening or sending to it can foreground or type into Pi itself. New embedded
+* runs record `native`, but this guard also makes older records safe.
+*/
+/**
+* A run with no recorded launcher, which reading and foregrounding both hit.
+*
+* Older records predate launcher identity being persisted, so this is a real
+* state rather than a corrupt one, and both surfaces owe the user the same
+* explanation for it.
+*/
+const NO_LAUNCHER_RECORDED = "No durable launcher identity is recorded for this run.";
+/**
+* The identifier a run record carries for its definition.
+*
+* Derived the same way `RunWorkflowService` derives it, so the two agree: the
+* file name without its final extension, which keeps the `.workflow` part.
+*/
+function workflowIdFor(workflowPath) {
+	return (0, node_path.basename)(workflowPath, (0, node_path.extname)(workflowPath));
+}
+function launcherEnvironment(environment) {
+	const env = { ...environment };
+	for (const key of LAUNCHER_ENVIRONMENT_STRIPPED) delete env[key];
+	return env;
+}
+/** The launcher the workflow templates default to, when it is a known one. */
+function preferredLauncher(environment) {
+	const value = environment[LAUNCHER_ENV];
+	return value === LAUNCHER_TMUX || value === LAUNCHER_CMUX ? value : void 0;
+}
+/**
+* One shell word per argument.
+*
+* `launch-process` hands `--command` to the launcher as a shell string, so a
+* run key or a path with a space in it has to survive one more round of shell
+* parsing than the argv we spawn with.
+*/
+function shellCommand(argv) {
+	return argv.map((word) => `'${word.replaceAll("'", `'\\''`)}'`).join(" ");
+}
+/**
+* The workflow-mcp CLI this extension is built against.
+*
+* Resolved from the dependency rather than PATH: `pnpm exec workflow-mcp` finds
+* whatever the workspace root happens to install, which is not necessarily this
+* version, and it pays for a package-manager resolution on the launch path.
+*/
+function resolveWorkflowCli() {
+	try {
+		return (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve("@agimon-ai/workflow-mcp/cli");
+	} catch {
+		return;
+	}
+}
+const detachedSpawn = async (command, args, options) => {
+	await new Promise((resolveSpawn, rejectSpawn) => {
+		const child = (0, node_child_process.spawn)(command, [...args], {
+			...options,
+			detached: true,
+			stdio: "ignore"
+		});
+		child.once("error", rejectSpawn);
+		child.once("spawn", () => {
+			child.off("error", rejectSpawn);
+			child.unref();
+			resolveSpawn();
+		});
+	});
+};
+function collectRunnerMaps(value, maps) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectRunnerMaps(item, maps);
+		return;
+	}
+	if (!value || typeof value !== "object") return;
+	for (const [key, nested] of Object.entries(value)) if ((key === "interactiveRun" || key === "run") && nested && typeof nested === "object" && !Array.isArray(nested)) maps.push(Object.keys(nested));
+	else collectRunnerMaps(nested, maps);
+}
+function compatibleRunners(workflow) {
+	const maps = [];
+	collectRunnerMaps(workflow, maps);
+	if (maps.length === 0) return void 0;
+	return maps[0].filter((runner) => maps.every((available) => available.includes(runner))).sort();
+}
+async function listAllRuns(registry, workspace) {
+	const records = [];
+	let page = 1;
+	let hasNextPage = true;
+	while (hasNextPage) {
+		const result = await registry.listRunsPage({
+			page,
+			pageSize: DEFAULT_PAGE_SIZE,
+			workspace
+		});
+		records.push(...result.items);
+		hasNextPage = result.hasNextPage;
+		page += 1;
+	}
+	return records;
+}
+/**
+* One run, as a person reads it.
+*
+* Middle dots rather than pipes: pipes read as table borders in a terminal and
+* collide visually with the launcher output the widget sits above.
+*/
+function runLabel(record) {
+	return [
+		record.runKey,
+		record.workspace,
+		stageLabel(record),
+		record.runner
+	].filter(Boolean).join(` ${GLYPH.separator} `);
+}
+function createWorkflowPiRuntime(pi, options) {
+	const services = [];
+	const feature = options.featureFactory?.() ?? (0, _agimon_ai_workflow_mcp.createEmbeddedWorkflowFeature)();
+	const runtimeGeneration = (0, node_crypto.randomUUID)();
+	let runtimeActive = true;
+	let sessionGeneration = 0;
+	let readinessAbort;
+	let readinessHandle;
+	let standaloneReadiness;
+	const invocationActive = options.isActive ?? (() => true);
+	const isRuntimeActive = () => runtimeActive && invocationActive();
+	const notifyStandaloneReadiness = (notification) => {
+		const diagnostics = notification.diagnostics.join("; ");
+		const detail = (notification.error?.message ?? diagnostics) || "Initialization did not complete.";
+		const message = `${notification.packageId} initialization ${notification.state}: ${detail}`;
+		if (sessionCtx?.hasUI) sessionCtx.ui.notify(message, "warning");
+		else process.emitWarning(message);
+	};
+	const readinessCoordinator = (_ctx) => {
+		const shared = options.cordis ? (0, _agimon_ai_doompi_core_readiness.readDoomReadinessCoordinator)(options.cordis) : void 0;
+		if (shared) return shared;
+		standaloneReadiness ??= (0, _agimon_ai_doompi_core_readiness.createDoomReadinessCoordinator)({ notify: notifyStandaloneReadiness });
+		return standaloneReadiness;
+	};
+	const waitForReadiness = async (signal) => {
+		signal?.throwIfAborted();
+		const pending = readinessHandle;
+		if (!pending) throw new Error("Workflow session initialization has not started.");
+		const handle = await pending;
+		signal?.throwIfAborted();
+		await handle.wait(signal ? { signal } : void 0);
+		if (!isRuntimeActive() || pending !== readinessHandle) throw new Error("Workflow readiness belongs to a stale extension generation.");
+	};
+	const { parser, recoverService, registry, runService, runTool } = feature;
+	const spawnDetached = options.spawnDetached ?? detachedSpawn;
+	const monitorIntervalMs = options.monitorIntervalMs ?? MONITOR_INTERVAL_MS;
+	const followIntervalMs = options.followIntervalMs ?? FOLLOW_INTERVAL_MS;
+	let monitorTimer;
+	let monitorRefreshGeneration;
+	let followTimer;
+	let followRefreshActive = false;
+	let followedRun;
+	let previousStages = /* @__PURE__ */ new Map();
+	const pendingTerminalRuns = /* @__PURE__ */ new Map();
+	const deliveredTerminalRuns = /* @__PURE__ */ new Set();
+	let sessionStartedAt = 0;
+	let runProvider;
+	services.push((context) => {
+		runProvider = require_index$4.registerRunProvider(context);
+	});
+	let lifecycleNarrationReady = false;
+	let sessionRunCount = 0;
+	let workflowMode = false;
+	let publishedWorkflowState;
+	const restrictionListeners = /* @__PURE__ */ new Set();
+	const modeContribution = (0, _agimon_ai_doompi_minor_mode.defineMinorMode)({
+		descriptor: {
+			source: require_workflow.PACKAGE_SOURCE,
+			id: MODE_ID,
+			label: MODE_LABEL,
+			description: "Workflow discovery, launch, inspection, control, and recovery tools.",
+			order: MODE_ORDER,
+			actions: [{
+				id: MODE_ACTION_ACTIVATE,
+				label: "Activate",
+				description: "Enable workflow tools for this session.",
+				contexts: ["tui", "headless"],
+				parameters: []
+			}, {
+				id: MODE_ACTION_DEACTIVATE,
+				label: "Deactivate",
+				description: "Disable workflow tools without stopping active runs.",
+				contexts: ["tui", "headless"],
+				parameters: []
+			}]
+		},
+		state: () => workflowModeState(workflowMode, sessionRunCount),
+		async handleAction(_runtime, actionId, _argumentsValue, execution) {
+			await waitForReadiness();
+			if (actionId === MODE_ACTION_ACTIVATE) {
+				await applyWorkflowMode(true, execution.context);
+				return { message: "Workflow mode activated." };
+			}
+			if (actionId === MODE_ACTION_DEACTIVATE) {
+				await applyWorkflowMode(false, execution.context);
+				return { message: "Workflow mode deactivated." };
+			}
+			throw new Error(`Unknown workflow mode action: ${actionId}`);
+		}
+	}).createOwner(void 0);
+	/** Kept so callers outside a handler can still resolve the session id. */
+	let sessionCtx;
+	let activeOverlay;
+	let inspectorHandle;
+	let inspectorOpen = false;
+	/** The runs the inspector last listed, keyed the way its items are. */
+	let inspectorRecords = /* @__PURE__ */ new Map();
+	/**
+	* The pushed view of runs this session owns.
+	*
+	* A delegated run executes in a launcher's process, so nothing in here ever
+	* observes it directly. What it observes is the registry the run writes to,
+	* which is why this replaces polling rather than instrumenting anything.
+	*/
+	let runControl;
+	const disposeRunControl = /* @__PURE__ */ new Set();
+	/**
+	* Job and step transitions per run, accumulated from pushed events.
+	*
+	* The live list derives its current position from this stream and a failed
+	* run reuses the same events for its terminal summary. Released after that
+	* summary is delivered.
+	*/
+	const runEvents = /* @__PURE__ */ new Map();
+	/**
+	* Runs the observer has announced, newest first, for the launch handshake.
+	*
+	* A launch needs the run key of the run it just started, and the launcher
+	* process never learns it. Bounded, because a session that launches all day
+	* must not accumulate a record per launch for the sake of a lookup that
+	* only ever cares about the last few seconds.
+	*/
+	const announcedRuns = [];
+	/** Active records are the authoritative membership of the task-like progress widget. */
+	const activeRunRecords = /* @__PURE__ */ new Map();
+	/** Invalidates a registry snapshot when a newer pushed lifecycle event lands mid-read. */
+	let activeRunRevision = 0;
+	const progressOverlay = new require_workflowProgressOverlay.WorkflowProgressOverlay();
+	/**
+	* The session that owns this extension's runs.
+	*
+	* Taken from whatever context Pi hands us, and deliberately the SAME value
+	* `launch_workflow` stamps onto a run: reading the stamp from one place and
+	* the filter from another is how a run goes invisible to the session that
+	* just started it. `session_start` fills this in for a session that has
+	* launched nothing yet; before either, it is undefined and every ownership
+	* check fails closed, which is correct because such a session owns no runs.
+	*/
+	let knownSessionId;
+	let telemetry;
+	const getTelemetry = (ctx) => {
+		telemetry ??= (0, _agimon_ai_doompi_telemetry.createDoomTelemetry)({
+			serviceName: "doom-workflow",
+			packageName: "@agimon-ai/doompi-workflow",
+			cwd: ctx?.cwd,
+			env: options.environment,
+			enableLogs: true,
+			enableTraces: true
+		});
+		return telemetry;
+	};
+	let narrationService;
+	const reportNarrationFailure = (error) => {
+		getTelemetry(sessionCtx).recordWarning("doom_workflow.narration_failed", error).catch((telemetryError) => {
+			process.emitWarning(`Doom-workflow could not record a narration failure: ${String(telemetryError)}`);
+		});
+	};
+	const narrationSink = { narrate(text) {
+		const service = narrationService;
+		const request = (0, _agimon_ai_doompi_core_narration.createNarrationRequest)(text);
+		if (!service || !request) return;
+		try {
+			Promise.resolve(service.request(request)).catch(reportNarrationFailure);
+		} catch (error) {
+			reportNarrationFailure(error);
+		}
+	} };
+	services.push((cordis) => {
+		cordis.inject([_agimon_ai_doompi_core_narration.DOOM_NARRATION_SERVICE], (serviceContext) => {
+			const service = (0, _agimon_ai_doompi_core_narration.requireDoomNarrationService)(serviceContext);
+			narrationService = service;
+			return () => {
+				if (narrationService === service) narrationService = void 0;
+			};
+		});
+	});
+	const observeSession = (sessionId) => {
+		if (sessionId && isRuntimeActive()) knownSessionId = (0, _agimon_ai_doompi_core_child_process.resolveRootSessionId)(sessionId, options.environment);
+	};
+	const currentSessionId = () => {
+		const sessionId = knownSessionId ?? sessionCtx?.sessionManager.getSessionId();
+		return sessionId ? (0, _agimon_ai_doompi_core_child_process.resolveRootSessionId)(sessionId, options.environment) : void 0;
+	};
+	const isRootProcess = (ctx, rootSessionId) => ctx.sessionManager.getSessionId().trim() === rootSessionId;
+	/**
+	* The registry is one directory under $HOME shared by every repository and
+	* every Pi session on the machine, so an unscoped tool would let any session
+	* list, foreground, stop, or recover any other session's runs. Scoping is a
+	* host-level filter on the tool instance, not a caller input: the agent
+	* cannot opt out of it, and the CLI (which is how orphaned runs are managed)
+	* keeps the global view.
+	*/
+	const recoverTool = feature.createRecoverTool({ ownerSessionId: currentSessionId });
+	const controlTool = feature.createControlTool();
+	/**
+	* Inline executions still in flight, so shutdown can finalize them.
+	*
+	* A workflow declaring `launch-command` hands off to tmux or cmux and its
+	* promise settles almost immediately; one without runs its whole engine in
+	* this process. Only the latter lingers here, so the set needs no launcher
+	* check of its own.
+	*/
+	const pendingInlineRuns = /* @__PURE__ */ new Set();
+	const trackPendingRun = (run) => {
+		const startedAt = Date.now();
+		const runTelemetry = getTelemetry();
+		pendingInlineRuns.add(run);
+		runTelemetry.recordEvent("doom_workflow.run_started", { outcome: "started" });
+		run.then(() => {
+			pendingInlineRuns.delete(run);
+			return runTelemetry.recordEvent("doom_workflow.run_finished", {
+				duration_ms: Date.now() - startedAt,
+				outcome: "completed"
+			});
+		}, (error) => {
+			pendingInlineRuns.delete(run);
+			return runTelemetry.recordError("doom_workflow.run_failed", error, { duration_ms: Date.now() - startedAt });
+		});
+		return run;
+	};
+	const rejectRunner = (workflowPath, runner) => {
+		const compatible = compatibleRunners(parser.parseWorkflowFile(workflowPath));
+		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 = require_index$3.createWorkflowLaunchExecutor({
+		environment: options.environment,
+		activeRunCount: async () => sessionRunCount,
+		observeSession,
+		rejectRunner,
+		runTool,
+		trackPendingRun,
+		...options.launchAckPollMs === void 0 ? {} : { launchAckPollMs: options.launchAckPollMs },
+		...options.launchAckTimeoutMs === void 0 ? {} : { launchAckTimeoutMs: options.launchAckTimeoutMs },
+		findLaunchedRun: async ({ sessionId, since, workflowPath }) => {
+			const expectedId = workflowIdFor(workflowPath);
+			const matches = (record) => {
+				if (!require_index$2.isSessionRun(record, sessionId) || record.stale) return false;
+				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;
+			};
+			if (!runControl) return (await listAllRuns(registry)).find(matches);
+			await runControl.refresh();
+			return announcedRuns.find(matches);
+		},
+		onLateFailure: (error, ctx) => {
+			const detail = error instanceof Error ? error.message : String(error);
+			ctx.ui.notify(require_index$2.launchNotice(`Workflow launch failed after it was reported started.\n${detail}`), "warning");
+		},
+		onLaunch: async (ctx) => {
+			await getTelemetry(ctx).recordEvent(LAUNCH_REQUESTED_EVENT, { outcome: "requested" });
+			return refreshStatus(ctx, false);
+		}
+	});
+	/** Repaint the live list from pushed state without writing progress into chat. */
+	const publishProgressOverlay = () => {
+		const records = [...activeRunRecords.values()].sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt) || runIdentity(left).localeCompare(runIdentity(right)));
+		progressOverlay.update(records.map((record) => require_workflowProgressOverlay.workflowProgressRow(record, runEvents.get(runIdentity(record)) ?? [])));
+	};
+	/** Add, refresh, or remove one run from the live list. */
+	const noteActiveRecord = (record) => {
+		activeRunRevision += 1;
+		const identity = runIdentity(record);
+		if (record.stage === RUNNING_STATUS && !record.stale) activeRunRecords.set(identity, record);
+		else activeRunRecords.delete(identity);
+		publishProgressOverlay();
+	};
+	/** Replace widget membership from an authoritative registry snapshot. */
+	const replaceActiveRecords = (records) => {
+		activeRunRecords.clear();
+		for (const record of records) activeRunRecords.set(runIdentity(record), record);
+		publishProgressOverlay();
+	};
+	/** Keep every pushed progress event for both the live row and terminal summary. */
+	const noteProgressEvent = (identity, event) => {
+		const events = runEvents.get(identity) ?? [];
+		events.push(event);
+		runEvents.set(identity, events);
+	};
+	/**
+	* Ask for a status refresh, collapsing a burst of events into one.
+	*
+	* The live list updates from the event itself, but terminal detection still
+	* needs the session's authoritative record set, and that costs a registry
+	* page. A run emitting six transitions at once must not buy six.
+	*/
+	let statusRefreshTimer;
+	const scheduleStatusRefresh = (ctx) => {
+		if (!isRuntimeActive() || ctx !== sessionCtx || statusRefreshTimer) return;
+		statusRefreshTimer = setTimeout(() => {
+			statusRefreshTimer = void 0;
+			if (isRuntimeActive() && ctx === sessionCtx) refreshStatus(ctx, true);
+		}, STATUS_REFRESH_DEBOUNCE_MS);
+		statusRefreshTimer.unref?.();
+	};
+	/** Everything remembered about a run, released once it can produce no more. */
+	const forgetRun = (identity) => {
+		runEvents.delete(identity);
+	};
+	/**
+	* Subscribe to the registry instead of asking it what changed.
+	*
+	* A run this session launched executes in a launcher's own process, so the
+	* only thing connecting it to this one is the session stamp on its record.
+	* The filter is that stamp, and it is applied inside the observer so a
+	* shared registry never leaks another session's runs into this UI.
+	*/
+	const startRunControl = async (ctx) => {
+		const sessionId = (0, _agimon_ai_doompi_core_child_process.resolveRootSessionId)(ctx.sessionManager.getSessionId(), options.environment);
+		const control = feature.createRunControl({ recordFilter: (candidate) => require_index$2.isSessionRun(candidate, sessionId) });
+		runControl = control;
+		const controlIsCurrent = () => isRuntimeActive() && ctx === sessionCtx && runControl === control;
+		const controlDisposers = [
+			control.on("step", (event) => {
+				if (!controlIsCurrent()) return;
+				const identity = runIdentity(event.record);
+				noteProgressEvent(identity, {
+					at: event.at,
+					job: event.job,
+					status: event.status,
+					step: event.step,
+					type: "step",
+					...event.reason === void 0 ? {} : { reason: event.reason }
+				});
+				noteActiveRecord(event.record);
+				scheduleStatusRefresh(ctx);
+			}),
+			control.on("job", (event) => {
+				if (!controlIsCurrent()) return;
+				const identity = runIdentity(event.record);
+				noteProgressEvent(identity, {
+					at: event.at,
+					job: event.job,
+					status: event.status,
+					type: "job",
+					...event.index === void 0 ? {} : { index: event.index },
+					...event.reason === void 0 ? {} : { reason: event.reason },
+					...event.total === void 0 ? {} : { total: event.total }
+				});
+				noteActiveRecord(event.record);
+				scheduleStatusRefresh(ctx);
+			}),
+			control.on("runStarted", (event) => {
+				if (!controlIsCurrent()) return;
+				announcedRuns.unshift(event.record);
+				if (announcedRuns.length > ANNOUNCED_RUN_HISTORY) announcedRuns.length = ANNOUNCED_RUN_HISTORY;
+				noteActiveRecord(event.record);
+				scheduleStatusRefresh(ctx);
+			}),
+			control.on("runUpdated", (event) => {
+				if (!controlIsCurrent()) return;
+				noteActiveRecord(event.record);
+				refreshStatus(ctx, true);
+			}),
+			control.on("runFinished", (event) => {
+				if (!controlIsCurrent()) return;
+				noteActiveRecord(event.record);
+				refreshStatus(ctx, true);
+			})
+		];
+		for (const dispose of controlDisposers) disposeRunControl.add(dispose);
+		try {
+			await control.start();
+		} catch (error) {
+			for (const dispose of controlDisposers) {
+				disposeRunControl.delete(dispose);
+				dispose();
+			}
+			control.dispose();
+			if (runControl === control) runControl = void 0;
+			throw error;
+		}
+		if (!isRuntimeActive() || ctx !== sessionCtx || runControl !== control) {
+			for (const dispose of controlDisposers) {
+				disposeRunControl.delete(dispose);
+				dispose();
+			}
+			control.dispose();
+			if (runControl === control) runControl = void 0;
+		}
+	};
+	const stopRunControl = () => {
+		if (statusRefreshTimer) clearTimeout(statusRefreshTimer);
+		statusRefreshTimer = void 0;
+		for (const dispose of disposeRunControl) dispose();
+		disposeRunControl.clear();
+		runControl?.dispose();
+		runControl = void 0;
+		runEvents.clear();
+		activeRunRevision += 1;
+		activeRunRecords.clear();
+		publishProgressOverlay();
+	};
+	/** Dismiss the run panel entirely, leaving the run itself alone. */
+	const closeOverlay = () => {
+		activeOverlay?.teardown();
+		activeOverlay?.handle?.hide();
+		activeOverlay = void 0;
+	};
+	const runIdentity = (record) => record.runId ?? `${record.workspace}/${record.runKey}`;
+	const publishModeWidget = () => {
+		const contribution = modeContribution;
+		if (!contribution) return;
+		const next = workflowModeState(workflowMode, sessionRunCount);
+		const serialized = JSON.stringify(next);
+		if (serialized === publishedWorkflowState) return;
+		publishedWorkflowState = serialized;
+		contribution.publish();
+	};
+	const refreshStatus = async (ctx, notifyChanges) => {
+		const refreshGeneration = sessionGeneration;
+		const refreshIsCurrent = () => isRuntimeActive() && refreshGeneration === sessionGeneration && ctx === sessionCtx;
+		if (!refreshIsCurrent()) return;
+		const activeTelemetry = getTelemetry(ctx);
+		if (monitorRefreshGeneration === refreshGeneration) {
+			activeTelemetry.recordEvent("doom_workflow.monitor_skipped", { outcome: "already_running" });
+			return;
+		}
+		const startedAt = Date.now();
+		const activeRevisionAtRead = activeRunRevision;
+		monitorRefreshGeneration = refreshGeneration;
+		try {
+			const records = await listAllRuns(registry);
+			if (!refreshIsCurrent()) return;
+			const sessionId = (0, _agimon_ai_doompi_core_child_process.resolveRootSessionId)(ctx.sessionManager.getSessionId(), options.environment);
+			const rootProcess = isRootProcess(ctx, sessionId);
+			const sessionRecords = records.filter((record) => require_index$2.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);
+			activeTelemetry.recordEvent("doom_workflow.monitor_counts", {
+				"workflow.run_count": sessionRecords.length,
+				"workflow.running_count": running.length,
+				"workflow.failed_count": failed.length,
+				mode: workflowMode ? "on" : "off"
+			});
+			const mine = require_index$2.runsForSession(records, sessionId).filter((record) => !record.stale);
+			sessionRunCount = mine.length;
+			publishModeWidget();
+			forgetLauncherScreens(new Set(sessionRecords.map((record) => runIdentity(record))));
+			const nextStages = new Map(sessionRecords.map((record) => [runIdentity(record), record.stage]));
+			for (const record of sessionRecords) {
+				const identity = runIdentity(record);
+				const previous = previousStages.get(identity);
+				const startedAt = Date.parse(record.startedAt);
+				const startedDuringSession = previous === void 0 && (sessionStartedAt === 0 || !Number.isFinite(startedAt) || startedAt >= sessionStartedAt);
+				if (lifecycleNarrationReady) require_index$6.narrateWorkflowTransition(narrationSink, record, previous === RUNNING_STATUS || previous === COMPLETED_STATUS || previous === ERROR_STAGE ? previous : void 0, startedDuringSession);
+				if (!notifyChanges || !rootProcess || record.stage === RUNNING_STATUS) continue;
+				if (!deliveredTerminalRuns.has(identity) && (previous === RUNNING_STATUS || startedDuringSession)) pendingTerminalRuns.set(identity, record);
+			}
+			const retainedWork = new Map(mine.map((record) => [runIdentity(record), record]));
+			for (const [identity, record] of pendingTerminalRuns) retainedWork.set(identity, record);
+			if (!refreshIsCurrent()) return;
+			runProvider?.update([...retainedWork.values()].map((record) => ({
+				id: record.runId ?? record.runKey,
+				sessionId
+			})));
+			const retainedEventIdentities = /* @__PURE__ */ new Set([...sessionRecords.filter((record) => record.stage === RUNNING_STATUS && !record.stale).map((record) => runIdentity(record)), ...pendingTerminalRuns.keys()]);
+			for (const identity of runEvents.keys()) if (!retainedEventIdentities.has(identity)) forgetRun(identity);
+			if (notifyChanges) for (const record of sessionRecords) {
+				if (previousStages.get(runIdentity(record)) !== RUNNING_STATUS || record.stage === RUNNING_STATUS) continue;
+				const completed = record.stage === COMPLETED_STATUS;
+				const detail = record.failedJob ? ` at ${record.failedJob}` : "";
+				ctx.ui.notify(completed ? `${GLYPH.completed} ${record.runKey} completed` : `${GLYPH.failed} ${record.runKey} ${stageLabel(record)}${detail}`, completed ? "info" : "warning");
+				activeTelemetry.recordEvent("doom_workflow.run_transition", { outcome: completed ? "completed" : stageLabel(record) });
+			}
+			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 require_index$2.finishedRunSummary(record, []);
+					const identity = runIdentity(record);
+					const events = runEvents.get(identity) ?? progressEventsForRun(record, await (0, _agimon_ai_workflow_mcp.readWorkflowProgress)(registry.runDirectoryFor(record)));
+					return require_index$2.finishedRunSummary(record, (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(events));
+				}));
+				if (!refreshIsCurrent()) return;
+				pi.sendMessage({
+					customType: require_workflowFinishedMessage.WORKFLOW_FINISHED_MESSAGE,
+					content: summaries.join("\n\n"),
+					display: true,
+					details: {
+						runIds: terminalRecords.map((record) => record.runId ?? runIdentity(record)),
+						runs: terminalRecords.map((record) => ({
+							runKey: record.runKey,
+							workspace: record.workspace,
+							stage: record.stage,
+							...record.workflowId ? { workflowId: record.workflowId } : {},
+							...record.failedJob ? { failedJob: record.failedJob } : {},
+							...record.errorMessage ? { error: record.errorMessage } : {}
+						}))
+					}
+				}, {
+					triggerTurn: true,
+					deliverAs: "steer"
+				});
+				if (!refreshIsCurrent()) return;
+				for (const record of terminalRecords) {
+					const identity = runIdentity(record);
+					deliveredTerminalRuns.add(identity);
+					pendingTerminalRuns.delete(identity);
+					forgetRun(identity);
+				}
+				runProvider?.update(mine.map((record) => ({
+					id: record.runId ?? record.runKey,
+					sessionId
+				})));
+			} catch (error) {
+				await activeTelemetry.recordError("doom_workflow.terminal_delivery_failed", error, { "workflow.pending_terminal_count": pendingTerminalRuns.size });
+			}
+			if (!refreshIsCurrent()) return;
+			previousStages = nextStages;
+			activeTelemetry.recordEvent("doom_workflow.monitor_finished", {
+				duration_ms: Date.now() - startedAt,
+				outcome: "completed"
+			});
+		} catch (error) {
+			await activeTelemetry.recordError("doom_workflow.monitor_failed", error, { duration_ms: Date.now() - startedAt });
+			if (refreshIsCurrent()) ctx.ui.notify(`Workflow status refresh failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
+		} finally {
+			if (monitorRefreshGeneration === refreshGeneration) monitorRefreshGeneration = void 0;
+		}
+	};
+	const clearFollow = (ctx) => {
+		if (followTimer) clearInterval(followTimer);
+		followTimer = void 0;
+		followedRun = void 0;
+		ctx.ui.setWidget(FOLLOW_WIDGET_KEY, void 0);
+	};
+	/**
+	* This session's view of the terminals its runs were launched into.
+	*
+	* The engine owns how a launcher is read and driven; this owns how often,
+	* which is a property of the surface rather than of the run. Every panel
+	* here repaints five times a second and a scrape forks a CLI, so the two
+	* concerns stayed separate when the reads moved down into the engine.
+	*/
+	const terminalFacade = new _agimon_ai_workflow_mcp.WorkflowTerminalService({
+		run: async (command, args, options) => {
+			const result = await pi.exec(command, [...args], { timeout: options.timeoutMs });
+			return {
+				code: result.code,
+				stdout: result.stdout,
+				stderr: result.stderr
+			};
+		},
+		lines: TAIL_LINES,
+		timeoutMs: PI_EXEC_TIMEOUT_MS
+	});
+	const terminals = require_index$7.createWorkflowTerminalService({
+		terminal: terminalFacade,
+		now: () => Date.now(),
+		refreshMs: SCREEN_REFRESH_MS
+	});
+	/**
+	* Geometry last asked of each run, so a repaint that changes nothing costs
+	* no exec. Keyed by run identity, like every other per-run cache here.
+	*/
+	const launcherGeometry = /* @__PURE__ */ new Map();
+	/**
+	* Match the run's own terminal to the panel showing it.
+	*
+	* A run draws at whatever geometry its launcher gave it, so a panel
+	* narrower than that shows a clipped window onto a wider screen rather than
+	* a smaller rendering of it. Which launchers can be told a size is the
+	* engine's business; not asking twice for the same size is this one's.
+	*
+	* The size is NOT restored when the panel closes: the window belongs to this
+	* run, and a run that is watched at panel size should stay readable at panel
+	* size for whoever attaches to it next.
+	*/
+	const resizeLauncherViewport = (record, columns, rows) => {
+		const identity = runIdentity(record);
+		const geometry = `${columns}x${rows}`;
+		if (launcherGeometry.get(identity) === geometry) return;
+		launcherGeometry.set(identity, geometry);
+		terminalFacade.resize(record, columns, rows);
+	};
+	/**
+	* A run's recent output, reusing a recent read rather than forking again.
+	*
+	* Rendering stays as fast as it ever was: the caller gets the cached lines
+	* immediately and the next repaint picks up whatever the refresh found.
+	*/
+	const cachedLauncherScreen = (record) => {
+		if (terminalFacade.targetsCurrentTerminal(record)) return Promise.resolve([HOST_TERMINAL_OUTPUT_BLOCKED]);
+		return terminals.screen(runIdentity(record), record, TAIL_LINES);
+	};
+	/** Runs whose screens can never change again cannot earn their memory back. */
+	const forgetLauncherScreens = (live) => {
+		terminals.forget(live);
+		for (const identity of launcherGeometry.keys()) if (!live.has(identity)) launcherGeometry.delete(identity);
+	};
+	/**
+	* Bring a run's launcher to the foreground.
+	*
+	* Returns a status line rather than notifying, because its only caller is now
+	* the `workflow_run` tool's `open` action and the agent needs to read the outcome.
+	*/
+	const openLauncher = async (record) => {
+		const launcher = record.launcher;
+		if (!launcher) return NO_LAUNCHER_RECORDED;
+		if (terminalFacade.targetsCurrentTerminal(record)) return HOST_TERMINAL_OUTPUT_BLOCKED;
+		if (launcher.type === LAUNCHER_NATIVE) return "This run is hosted natively rather than in a multiplexer, so there is no separate window to bring forward.";
+		if (launcher.type === LAUNCHER_CMUX) {
+			await pi.exec(LAUNCHER_CMUX, [
+				"select-workspace",
+				"--workspace",
+				launcher.workspaceId
+			], { timeout: PI_EXEC_TIMEOUT_MS });
+			return `Opened ${record.runKey} in cmux.`;
+		}
+		if (!options.environment.TMUX) return "Pi is not attached to tmux. Follow the output instead, or attach to the recorded tmux session manually.";
+		const target = launcher.sessionId ?? launcher.sessionName;
+		const result = await pi.exec(LAUNCHER_TMUX, [
+			"switch-client",
+			"-t",
+			target
+		], { timeout: PI_EXEC_TIMEOUT_MS });
+		if (result.code !== 0) return result.stderr.trim() || `Unable to open tmux session ${target}.`;
+		if (launcher.paneId) await pi.exec(LAUNCHER_TMUX, [
+			"select-pane",
+			"-t",
+			launcher.paneId
+		], { timeout: PI_EXEC_TIMEOUT_MS });
+		return `Opened ${record.runKey} in tmux.`;
+	};
+	const renderFollow = async (record, ctx) => {
+		if (followRefreshActive) return;
+		followRefreshActive = true;
+		try {
+			const jobs = (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(progressEventsForRun(record, await (0, _agimon_ai_workflow_mcp.readWorkflowProgress)(registry.runDirectoryFor(record))));
+			const lines = jobs.length > 0 ? void 0 : await cachedLauncherScreen(record);
+			ctx.ui.setWidget(FOLLOW_WIDGET_KEY, (_tui, theme) => ({
+				render: (width) => renderFollowLines(record, lines ?? renderProgressLines(jobs, theme, width), theme, width),
+				invalidate: () => {}
+			}), { placement: "aboveEditor" });
+		} finally {
+			followRefreshActive = false;
+		}
+	};
+	const followRun = async (record, ctx) => {
+		clearFollow(ctx);
+		followedRun = record;
+		await renderFollow(record, ctx);
+		followTimer = setInterval(() => {
+			if (followedRun) renderFollow(followedRun, ctx);
+		}, followIntervalMs);
+		followTimer.unref?.();
+	};
+	/**
+	* Forward literal text to a run's terminal.
+	*
+	* `tmux send-keys -l` and `cmux send` both take text verbatim, which keeps
+	* escape sequences intact: an arrow key must arrive as one sequence, not as
+	* a bracket and a letter. A natively hosted run has no multiplexer to
+	* address, so it reports rather than silently dropping the keystrokes.
+	*/
+	const sendToRun = async (record, text) => {
+		if (!terminalFacade.capabilities(record).writable) return;
+		await terminalFacade.write(record, text);
+	};
+	/**
+	* Show a run over Pi: job tree, live output, and a keyboard that reaches it.
+	*
+	* Blocks until the user closes it, which is what makes it feel like the run
+	* rather than a report about the run. The refresh runs faster than the
+	* background widget because a foregrounded terminal that lags behind your
+	* own typing reads as broken.
+	*/
+	/**
+	* Show a run over Pi as a persistent panel, not a modal.
+	*
+	* Returns as soon as the panel is up rather than awaiting its close. An
+	* awaited overlay would hold the tool call open, which freezes the agent
+	* mid-turn and makes "switch back to the main agent" impossible: there is
+	* nothing to switch back to while it is still waiting for a tool result.
+	*
+	* Focus, not lifetime, is what the user toggles. The panel stays on screen
+	* while typing goes back to Pi, so Escape stays free for the run's own
+	* agent, which uses it to interrupt.
+	*/
+	const openOverlay = async (record, ctx) => {
+		closeOverlay();
+		const interactive = terminalFacade.capabilities(record).writable;
+		const input = new require_workflowOverlay.TerminalInputBatcher((text) => sendToRun(record, text));
+		let jobs = [];
+		let output = [];
+		let refresh;
+		let polling = false;
+		const poll = async () => {
+			jobs = (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(progressEventsForRun(record, await (0, _agimon_ai_workflow_mcp.readWorkflowProgress)(registry.runDirectoryFor(record))));
+			output = await cachedLauncherScreen(record);
+		};
+		await poll();
+		const teardown = () => {
+			if (refresh) clearInterval(refresh);
+			refresh = void 0;
+			input.dispose();
+		};
+		const entry = {
+			interactive,
+			runKey: record.runKey,
+			teardown
+		};
+		activeOverlay = entry;
+		/** Shared by the panel footer, the close chord, and the double-Escape failsafe. */
+		const closeWithNotice = () => {
+			closeOverlay();
+			ctx.ui.notify(`Closed the ${record.runKey} view. The run keeps going.`, "info");
+		};
+		ctx.ui.custom((tui, theme, _keybindings, done) => {
+			refresh = setInterval(() => {
+				if (polling) return;
+				polling = true;
+				poll().finally(() => {
+					polling = false;
+					tui.requestRender();
+				});
+			}, OVERLAY_REFRESH_MS);
+			refresh.unref?.();
+			return new require_workflowRunPanel.WorkflowRunPanelComponent(tui, theme, {
+				runKey: record.runKey,
+				label: `${GLYPH.running} ${runLabel(record)}`,
+				breadcrumb: RUN_PANEL_BREADCRUMB,
+				interactive,
+				footer: panelHint(interactive),
+				hints: panelHints(interactive),
+				snapshot: (width) => ({
+					progress: renderProgressLines(jobs, theme, width),
+					output
+				}),
+				onViewport: (columns, rows) => resizeLauncherViewport(record, columns, rows),
+				onUnfollow: () => {
+					entry.handle?.unfocus();
+					ctx.ui.notify("Typing goes to this session. The run keeps going.", "info");
+				},
+				onClose: closeWithNotice,
+				sendInput: (data) => input.write(data),
+				flushInput: () => void input.flush(),
+				unfollowShortcut: UNFOLLOW_SHORTCUT,
+				closeShortcut: CLOSE_OVERLAY_SHORTCUT,
+				onDispose: () => {
+					teardown();
+					if (activeOverlay === entry) activeOverlay = void 0;
+					done();
+				}
+			});
+		}, {
+			...require_workflowRunPanel.runPanelUiOptions(interactive),
+			onHandle: (handle) => {
+				entry.handle = handle;
+			}
+		});
+		ctx.ui.notify(interactive ? `${record.runKey}: typing goes to the run. Press Esc twice to close, ${shortcutLabel(UNFOLLOW_SHORTCUT)} to type here instead.` : `${record.runKey}: view only, because this run is hosted natively. ${shortcutLabel(CLOSE_OVERLAY_SHORTCUT)} closes it.`, "info");
+		if (!interactive) return [
+			`Showing ${record.runKey} over Pi, as a view only:`,
+			"the run is hosted natively rather than in a multiplexer, so there is no terminal to type into.",
+			`Typing stays with this session, and ${shortcutLabel(CLOSE_OVERLAY_SHORTCUT)} closes the view.`
+		].join(" ");
+		return [
+			`Showing ${record.runKey} over Pi. Typing goes to the run.`,
+			"Pressing Escape twice quickly closes the view, and a single Escape still reaches the run.",
+			`${shortcutLabel(UNFOLLOW_SHORTCUT)} moves typing between the run and this session,`,
+			`and ${shortcutLabel(CLOSE_OVERLAY_SHORTCUT)} closes the view. The run keeps going either way.`
+		].join(" ");
+	};
+	const openInspector = async (ctx, manage = false) => {
+		if (inspectorOpen || activeOverlay || followedRun) return;
+		inspectorOpen = true;
+		try {
+			const selection = await ctx.ui.custom((tui, theme, _keybindings, done) => new require_workflowInspector.WorkflowInspectorComponent(tui, theme, {
+				list: async () => {
+					const sessionId = currentSessionId();
+					const records = (await listAllRuns(registry)).filter((record) => record.stage === RUNNING_STATUS && !record.stale && require_index$2.isSessionRun(record, sessionId));
+					inspectorRecords = new Map(records.map((record) => [runIdentity(record), record]));
+					return Promise.all(records.map(async (record) => ({
+						displayName: record.displayName,
+						executionState: record.executionState,
+						jobs: (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(progressEventsForRun(record, await (0, _agimon_ai_workflow_mcp.readWorkflowProgress)(registry.runDirectoryFor(record)))),
+						key: runIdentity(record),
+						output: [],
+						runKey: record.runKey,
+						startedAt: record.startedAt,
+						workspace: record.workspace
+					})));
+				},
+				output: async (item) => {
+					const record = inspectorRecords.get(item.key);
+					return record ? cachedLauncherScreen(record) : ["Workflow is no longer active."];
+				}
+			}, done), {
+				...DOOM_FULLSCREEN_UI_OPTIONS,
+				onHandle: (handle) => {
+					inspectorHandle = handle;
+				}
+			});
+			if (selection) {
+				const record = await requireRun(selection);
+				if (manage) await manageWorkflow(record, ctx);
+				else await openOverlay(record, ctx);
+			}
+		} finally {
+			inspectorHandle = void 0;
+			inspectorOpen = false;
+			inspectorRecords.clear();
+		}
+	};
+	/**
+	* Resolve a run this session owns, erroring rather than picking blindly.
+	*
+	* A run another session launched is reported exactly like one that does not
+	* exist. Distinguishing them would leak the shared registry's contents into
+	* a session that has no way to act on them anyway, and would invite the
+	* agent to keep trying keys it can never use.
+	*/
+	const requireRun = async (input, sessionId = currentSessionId()) => {
+		observeSession(sessionId);
+		const matches = (await listAllRuns(registry, input.workspace)).filter((candidate) => candidate.runKey === input.runKey && require_index$2.isSessionRun(candidate, sessionId));
+		if (matches.length > 1) throw new Error(require_index$2.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(require_index$2.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;
+	};
+	/**
+	* Resolve a failed run that this session may adopt through recovery.
+	*
+	* Failed runs are terminal and have no live owner to conflict with. This is
+	* intentionally the only cross-session lookup. Recovery-specific status
+	* and durable evidence reads may use it; live output, lifecycle controls,
+	* and running-run UI stay scoped to the launching session.
+	*/
+	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(require_index$2.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(require_index$2.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) => {
+		const runDir = registry.runDirectoryFor(record);
+		const paths = [
+			(0, node_path.resolve)(runDir, "changelog.md"),
+			(0, node_path.resolve)(runDir, "context.md"),
+			(0, node_path.resolve)(runDir, "progress.ndjson")
+		];
+		const sections = [];
+		for (const path of paths) try {
+			const content = await (0, node_fs_promises.readFile)(path, "utf-8");
+			sections.push(`--- ${(0, node_path.basename)(path)} ---`, content.slice(-65536).trimEnd());
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		return sections.length > 0 ? sections : ["No durable recovery evidence files are recorded for this run."];
+	};
+	/** Read-only evidence access for the one globally adoptable record class. */
+	const readRecoverableRunEvidence = async (input, ctx) => {
+		const record = await requireRecoverableRun(input);
+		await getTelemetry(ctx).recordEvent("doom_workflow.recovery_evidence_requested", { outcome: "requested" });
+		return [
+			`Workflow: ${runLabel(record)}`,
+			"--- run.json ---",
+			JSON.stringify(record, null, 2),
+			...await readRecoveryEvidenceTail(record)
+		].join("\n");
+	};
+	/**
+	* Recover a run in a launcher of its own instead of replaying it here.
+	*
+	* `RecoverWorkflowService` replays with the launch step skipped, so an
+	* in-process recovery runs every job inside this process. A workflow whose
+	* steps are `interactiveRun` then has its agent spawned with inherited
+	* stdio, because that agent needs a real TTY to draw. Inside Pi that TTY is
+	* the TUI: the agent draws over it, and the reset sequence written when the
+	* step ends is one Pi never issued and cannot repaint from. Delegating
+	* costs a process and keeps the screen.
+	*
+	* Undefined leaves the caller on the in-process path: a workflow that
+	* declares no `launch-command` has no launcher to delegate to, and a
+	* definition that cannot be read is better diagnosed by the replay itself.
+	*/
+	const delegateRecovery = async (input, ctx) => {
+		const cli = resolveWorkflowCli();
+		if (!cli) return void 0;
+		const record = await requireRecoverableRun(input);
+		let workflow;
+		try {
+			workflow = parser.parseWorkflowFile(record.workflowPath);
+		} catch {
+			return;
+		}
+		if (!workflow["launch-command"]) return void 0;
+		const sessionId = (0, _agimon_ai_doompi_core_child_process.resolveRootSessionId)(ctx.sessionManager.getSessionId(), options.environment);
+		const claim = await registry.claimRunRecovery(record.workspace, record.runKey, sessionId);
+		const cwd = record.originalRepoPath ?? ctx.cwd;
+		const recoverCommand = shellCommand([
+			process.execPath,
+			cli,
+			RECOVER_COMMAND,
+			record.runKey,
+			"--workspace",
+			record.workspace,
+			"--recovery-claim",
+			claim.claimId,
+			...input.runner ? ["--runner", input.runner] : []
+		]);
+		const launcher = preferredLauncher(options.environment);
+		try {
+			await spawnDetached(process.execPath, [
+				cli,
+				LAUNCH_PROCESS_COMMAND,
+				...launcher ? ["--launcher", launcher] : [],
+				"--name",
+				`${record.displayName} recover`,
+				"--cwd",
+				cwd,
+				"--command",
+				recoverCommand
+			], {
+				cwd,
+				env: launcherEnvironment(options.environment)
+			});
+		} catch (error) {
+			await registry.releaseRunRecoveryClaim(record.workspace, record.runKey, claim.claimId);
+			throw error;
+		}
+		await getTelemetry(ctx).recordEvent("doom_workflow.recover_delegated", {
+			launcher: launcher ?? "auto",
+			outcome: "delegated"
+		});
+		return `Recovering ${record.runKey} in a launcher of its own, so this session keeps its terminal. It reports back here when it ends.`;
+	};
+	const manageWorkflow = async (selected, ctx) => {
+		let record = selected;
+		while (true) {
+			const actions = ["Open output"];
+			const state = record.executionState ?? RUNNING_STATUS;
+			if (state === RUNNING_STATUS) actions.push("Pause");
+			if (state === PAUSED_EXECUTION_STATE) actions.push("Resume");
+			if (record.stage === RUNNING_STATUS) actions.push("Stop");
+			actions.push("Back");
+			const action = await require_workflowPrompt.openWorkflowChoice(ctx, {
+				title: `Manage ${record.runKey}`,
+				breadcrumb: MANAGE_BREADCRUMB,
+				choices: actions
+			});
+			if (!action || action === "Back") return;
+			record = await requireRun(record);
+			if (record.stage !== RUNNING_STATUS) {
+				ctx.ui.notify(`${record.runKey} is no longer running.`, "warning");
+				return;
+			}
+			if (action === "Open output") {
+				await openOverlay(record, ctx);
+				return;
+			}
+			if (action === "Stop") {
+				if (!await ctx.ui.confirm(`Stop ${record.runKey}?`, "The workflow will be interrupted and will not be restarted automatically.")) continue;
+				record = await requireRun(record);
+				if (record.stage !== RUNNING_STATUS) {
+					ctx.ui.notify(`${record.runKey} is no longer running.`, "warning");
+					return;
+				}
+			}
+			if (action !== "Pause" && action !== "Resume" && action !== "Stop") continue;
+			if (!record.runId) throw new Error(`${record.runKey} has no controllable run generation.`);
+			const result = await controlTool.execute({
+				action: action.toLowerCase(),
+				expectedRunId: record.runId,
+				...action === "Stop" ? { reason: "Stopped from the workflow manager." } : {},
+				runKey: record.runKey,
+				workspace: record.workspace
+			});
+			if (result.isError) throw new Error(require_index$2.toolResultText(result) || `Unable to ${action.toLowerCase()} workflow.`);
+			ctx.ui.notify(require_index$2.toolResultText(result) || `${action} requested for ${record.runKey}.`, "info");
+			await refreshStatus(ctx, false);
+			record = await requireRun(record);
+		}
+	};
+	/**
+	* The wizard's prompts, backed by doom overlays instead of Pi's native
+	* widgets, so a launch reads as one framed sequence rather than three styles.
+	*
+	* `editor` stays with Pi: the workflow prompt is multi-line authoring, and
+	* reimplementing a text editor to match a frame would be a poor trade.
+	*/
+	const doomLauncherUi = (ctx, breadcrumb) => ({
+		editor: (title, prefill) => ctx.ui.editor(title, prefill),
+		input: (title, placeholder) => require_workflowPrompt.openWorkflowInput(ctx, {
+			title,
+			breadcrumb,
+			...placeholder ? { fallback: placeholder } : {}
+		}),
+		notify: (message, type) => ctx.ui.notify(message, type),
+		select: (title, options) => require_workflowPrompt.openWorkflowChoice(ctx, {
+			title,
+			breadcrumb,
+			choices: options
+		})
+	});
+	/**
+	* `SPC w l`: the repository's workflows, the cursor workflow's parsed
+	* detail beside it, and `r` to launch that one. Launching closes the board
+	* first - the launch prompts are host dialogs, and a fullscreen overlay
+	* would sit over them.
+	*/
+	const openWorkflowCatalog = async (ctx) => {
+		if (!ctx.hasUI) {
+			ctx.ui.notify("The workflow list needs an interactive Pi session.", "warning");
+			return;
+		}
+		const entries = await require_index$5.loadWorkflowCatalog(feature.listWorkflowsTool, ctx.cwd);
+		const byPath = new Map(entries.map((entry) => [entry.path, entry]));
+		const launchOptions = {
+			compatibleRunners,
+			launch: (input, launchContext) => launchExecutor.execute(input, launchContext),
+			parseWorkflow: (workflowPath) => parser.parseWorkflowFile(workflowPath),
+			ui: doomLauncherUi(ctx, CATALOG_BREADCRUMB)
+		};
+		await require_workflowCatalog.openWorkflowCatalogOverlay(ctx, entries.map((entry) => ({
+			key: entry.path,
+			name: entry.name,
+			relativePath: entry.relativePath,
+			description: entry.description,
+			tags: entry.tags
+		})), {
+			loadDetail: (row) => require_index$5.summarizeWorkflowFile(row.key, launchOptions),
+			launchWorkflow: (row) => {
+				const entry = byPath.get(row.key);
+				if (!entry) return;
+				require_index$5.launchWorkflowEntry(launchOptions, entry, ctx).then((result) => {
+					if (result) ctx.ui.notify(require_index$2.launchNotice(require_index$2.toolResultText(result)), "info");
+				}, (error) => {
+					ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+				});
+			}
+		});
+	};
+	/**
+	* `/workflow-launch`: the same launch the catalog board performs, as a line.
+	*
+	* The cockpit can only send a session a prompt frame, so this is how a
+	* browser starts a workflow; typing it by hand does the same thing. Every
+	* value the board would have asked for in a dialog arrives on the line, and
+	* what the workflow requires is checked before anything is started, because
+	* a run missing its prompt starts and then waits for terminal input that is
+	* never coming.
+	*/
+	const launchFromCommand = async (args, ctx) => {
+		const parsed = require_index.parseWorkflowLaunchCommand(args);
+		if (require_index.isLaunchParseFailure(parsed)) {
+			ctx.ui.notify(parsed.error, "error");
+			return;
+		}
+		const entries = await require_index$5.loadWorkflowCatalog(feature.listWorkflowsTool, ctx.cwd);
+		const entry = require_index.resolveWorkflowEntry(entries, parsed.workflow);
+		if (!entry) {
+			ctx.ui.notify(`No workflow matches '${parsed.workflow}' under ${ctx.cwd}.`, "error");
+			return;
+		}
+		const detail = require_index$5.summarizeWorkflowFile(entry.path, {
+			compatibleRunners,
+			parseWorkflow: (workflowPath) => parser.parseWorkflowFile(workflowPath)
+		});
+		if (detail.error !== void 0) {
+			ctx.ui.notify(`${entry.name} could not be read: ${detail.error}`, "error");
+			return;
+		}
+		const problems = require_index.validateWorkflowLaunch(detail, parsed);
+		if (problems.length > 0) {
+			ctx.ui.notify(problems.join(" "), "error");
+			return;
+		}
+		const workflow = parser.parseWorkflowFile(entry.path);
+		const input = {
+			workflowPath: entry.path,
+			...parsed.runner === void 0 ? {} : { runner: parsed.runner },
+			...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(require_index$2.launchNotice(require_index$2.toolResultText(result)), "info");
+	};
+	const commands = [[WORKFLOW_LAUNCH_COMMAND, {
+		description: "Launch a workflow: /workflow-launch <workflow> [runner=x] [key=value …] [prompt]",
+		handler: async (args, ctx) => {
+			await waitForReadiness();
+			try {
+				await launchFromCommand(args, ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		}
+	}]];
+	const openRecoveryHandoff = async (ctx) => {
+		const records = (await listAllRuns(registry)).filter((record) => record.stage === ERROR_STAGE);
+		if (records.length === 0) {
+			ctx.ui.notify("No failed workflows are available to recover.", "info");
+			return;
+		}
+		const chosen = await require_workflowPicker.openWorkflowPickerOverlay(ctx, {
+			title: "WORKFLOW RECOVERY",
+			breadcrumb: RECOVER_BREADCRUMB,
+			unit: "failed runs",
+			action: "recover",
+			filterPlaceholder: "type to filter by name, run key or failed job",
+			emptyMessage: "No failed workflows are available to recover."
+		}, records.map((record) => ({
+			key: `${record.workspace}/${record.runKey}`,
+			name: record.displayName,
+			detail: `${record.workspace}/${record.runKey}${record.failedJob ? ` · ${record.failedJob}` : ""}`,
+			...record.failedJob ? { search: record.failedJob } : {},
+			value: record
+		})));
+		if (!chosen) return;
+		const record = await requireRecoverableRun(chosen);
+		if (record.stage !== ERROR_STAGE) throw new Error(`${record.runKey} is no longer failed.`);
+		const skillFile = (0, node_path.resolve)(require_index$1.workflowSkillDirectory(), "workflow-recovery", "SKILL.md");
+		if (!(0, node_fs.existsSync)(skillFile)) throw new Error(`Workflow recovery skill is unavailable at ${skillFile}.`);
+		setWorkflowMode(true);
+		ctx.ui.notify("Workflow tools enabled. The agent will investigate this failure and choose the safe next step.", "info");
+		pi.sendUserMessage([
+			"Investigate recovery for this failed workflow run. This selection is permission to investigate, not permission to recover blindly.",
+			`Run identity: ${JSON.stringify({
+				runKey: record.runKey,
+				workspace: record.workspace
+			})}`,
+			`Read the package-owned recovery skill with the read tool at ${JSON.stringify(skillFile)} before acting.`,
+			"Inspect status, every relevant log source, process state, the staged run.json, and only the repair referenced by activeRepairId.",
+			"Choose exactly one outcome: recover, launch fresh, or defer. Never edit issue.md or repair.json, never scan historical repairs, and never pass recovery dryRun or a job override.",
+			"Do not recover terminal, approval-pending, blocked, or otherwise unsafe work. If evidence is incomplete, defer and explain what is missing.",
+			"If recovery is justified, preserve the recorded worktree and repair metadata, then verify real process and registry progress before reporting success."
+		].join("\n"), { deliverAs: "followUp" });
+	};
+	/**
+	* Turn workflow mode on or off.
+	*
+	* The tools are registered for the whole session, so the mode is a tool
+	* surface restriction rather than a registration: dropping it is what makes
+	* them visible again, and no other owner's tools are touched either way.
+	*
+	* Activating also injects each tool's `promptSnippet` and `promptGuidelines`
+	* into the system prompt, and deactivating strips them: in Pi, tool gating
+	* and instruction injection are the same lever.
+	*/
+	const setWorkflowMode = (enabled) => {
+		if (!isRuntimeActive()) return;
+		workflowMode = enabled;
+		restrictionListeners.forEach((listener) => listener());
+		publishModeWidget();
+		options.onModeChange?.(enabled);
+	};
+	/**
+	* What the user sees on every mode change.
+	*
+	* Leads with the state, then the one thing they can do next. Turning the
+	* mode on is useless without knowing that you now just ask in plain
+	* language, so that sentence earns its place; the tool count does not, and
+	* is left to the README.
+	*/
+	const modeSummary = () => workflowMode ? [
+		`${GLYPH.completed} Workflow mode on`,
+		"Ask for workflows in plain language: the agent can list, launch, inspect, pause, resume, stop, and recover runs.",
+		`${shortcutLabel(UNFOLLOW_SHORTCUT)} stops following a run without stopping it.`
+	].join("\n") : ["Workflow mode off", `Press ${LEADER_MODE_BREADCRUMB} to give the agent its workflow tools. Runs already going are unaffected.`].join("\n");
+	/**
+	* Toggle the mode from the leader menu.
+	*
+	* Replaces the `/workflow [on|off|status]` command: the mode line already
+	* answers `status` at a glance, and the other two arguments were a keyboard
+	* path to a switch the leader menu spells out. Plan mode is reached the same
+	* way, so the two modes are no longer toggled through different surfaces.
+	*/
+	const applyWorkflowMode = async (enabled, ctx) => {
+		setWorkflowMode(enabled);
+		if (!workflowMode) clearFollow(ctx);
+		ctx.ui.notify(modeSummary(), "info");
+		await refreshStatus(ctx, false);
+	};
+	const onResourcesDiscover = () => {
+		if (!workflowMode) return { skillPaths: [] };
+		const skillPath = require_index$1.workflowSkillDirectory();
+		return { skillPaths: (0, node_fs.existsSync)(skillPath) ? [skillPath] : [] };
+	};
+	const messageRenderers = [require_workflowFinishedMessage.createWorkflowFinishedRenderer(), [LEGACY_WORKFLOW_STEP_MESSAGE, (message, { outputPad }, theme) => {
+		const details = require_workflowStepMessage.isWorkflowStepMessageDetails(message.details) ? message.details : void 0;
+		const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+		return require_workflowStepMessage.renderWorkflowStepMessage(details, content, outputPad, theme);
+	}]];
+	const toolDependencies = {
+		environment: options.environment,
+		runTool,
+		recoverTool,
+		launchExecutor,
+		controlTool,
+		requireSessionRun: requireRun,
+		requireRecoverableRun,
+		readRecoveryEvidence: readRecoverableRunEvidence,
+		delegateRecovery,
+		trackPendingRun,
+		observeSession,
+		activeRunCount: async () => sessionRunCount,
+		onLaunch: async (ctx) => {
+			await getTelemetry(ctx).recordEvent(LAUNCH_REQUESTED_EVENT, { outcome: "requested" });
+			return refreshStatus(ctx, false);
+		},
+		followRun: async (input, ctx) => {
+			const record = await requireRun(input, ctx.sessionManager.getSessionId());
+			await getTelemetry(ctx).recordEvent("doom_workflow.follow_started", { outcome: "started" });
+			await followRun(record, ctx);
+			return `Following ${runLabel(record)}. Press ${shortcutLabel(UNFOLLOW_SHORTCUT)} to stop following; the run keeps going.`;
+		},
+		tailRun: async (input, ctx) => {
+			const record = await requireRun(input, ctx.sessionManager.getSessionId());
+			await getTelemetry(ctx).recordEvent("doom_workflow.tail_requested", { outcome: "requested" });
+			return [
+				`Workflow: ${runLabel(record)}`,
+				`Stage: ${stageLabel(record)}`,
+				"Raw launcher output is hidden from chat. Use action follow or open to view it."
+			].join("\n");
+		},
+		openRun: async (input, ctx) => {
+			const record = await requireRun(input, ctx.sessionManager.getSessionId());
+			await getTelemetry(ctx).recordEvent("doom_workflow.open_requested", { outcome: "requested" });
+			if (!ctx.hasUI) return openLauncher(record);
+			return openOverlay(record, ctx);
+		},
+		rejectRunner
+	};
+	let disposeLeaderActions;
+	services.push((cordis) => {
+		cordis.inject([_agimon_ai_doompi_core_ui_hub.DOOM_UI_HUB_SERVICE], (uiContext) => {
+			const dispose = (0, _agimon_ai_doompi_core_ui_hub.requireDoomUiHub)(uiContext).registerLeaderActions({
+				source: require_workflow.PACKAGE_SOURCE,
+				handlers: {
+					[require_workflow.LEADER_ENABLE_ACTION]: async (ctx) => {
+						await waitForReadiness();
+						return applyWorkflowMode(true, ctx);
+					},
+					[require_workflow.LEADER_DISABLE_ACTION]: async (ctx) => {
+						await waitForReadiness();
+						return applyWorkflowMode(false, ctx);
+					},
+					[require_workflow.LEADER_MANAGE_ACTION]: async (ctx) => {
+						await waitForReadiness();
+						return openInspector(ctx, true);
+					},
+					[require_workflow.LEADER_CATALOG_ACTION]: async (ctx) => {
+						await waitForReadiness();
+						return openWorkflowCatalog(ctx);
+					},
+					[require_workflow.LEADER_RECOVER_ACTION]: async (ctx) => {
+						await waitForReadiness();
+						return openRecoveryHandoff(ctx);
+					}
+				},
+				onError: (error, _actionName, ctx) => {
+					ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+				}
+			});
+			disposeLeaderActions = dispose;
+			return () => {
+				dispose();
+				if (disposeLeaderActions === dispose) disposeLeaderActions = void 0;
+			};
+		});
+	});
+	const onSessionStart = (_event, ctx) => {
+		if (!runtimeActive || !invocationActive()) return;
+		const generation = ++sessionGeneration;
+		const previousReadiness = readinessHandle;
+		readinessAbort?.abort();
+		const ownReadinessAbort = new AbortController();
+		readinessAbort = ownReadinessAbort;
+		sessionCtx = ctx;
+		const ownsSession = () => runtimeActive && generation === sessionGeneration && sessionCtx === ctx && invocationActive();
+		const retireSessionResources = () => {
+			stopRunControl();
+			if (monitorTimer) clearInterval(monitorTimer);
+			monitorTimer = void 0;
+			runProvider?.update([]);
+			clearFollow(ctx);
+			inspectorHandle?.hide();
+			inspectorHandle = void 0;
+			inspectorOpen = false;
+			inspectorRecords.clear();
+			closeOverlay();
+			terminals.forget(/* @__PURE__ */ new Set());
+			progressOverlay.setUICtx(ctx.ui);
+		};
+		if (options.runCleanup) options.runCleanup(retireSessionResources);
+		else retireSessionResources();
+		getTelemetry(ctx).recordEvent("doom_workflow.session_started", {
+			mode: options.environment.WORKFLOW_MCP_MODE === "on" ? "on" : "off",
+			outcome: "started"
+		});
+		const sessionId = ctx.sessionManager.getSessionId();
+		const rootSessionId = (0, _agimon_ai_doompi_core_child_process.resolveRootSessionId)(sessionId, options.environment);
+		observeSession(rootSessionId);
+		sessionStartedAt = Date.now();
+		lifecycleNarrationReady = false;
+		previousStages = /* @__PURE__ */ new Map();
+		pendingTerminalRuns.clear();
+		deliveredTerminalRuns.clear();
+		setWorkflowMode(options.initialMode ?? options.environment.WORKFLOW_MCP_MODE === "on");
+		const coordinator = readinessCoordinator(ctx);
+		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(require_workflow.PACKAGE_SOURCE, `${runtimeGeneration}:${generation}`, async (signal) => {
+				const retired = () => ownReadinessAbort.signal.aborted || !ownsSession();
+				signal.throwIfAborted();
+				if (retired()) return { value: void 0 };
+				await startRunControl(ctx);
+				signal.throwIfAborted();
+				if (retired()) return { value: void 0 };
+				await refreshStatus(ctx, false);
+				signal.throwIfAborted();
+				if (retired()) return { value: void 0 };
+				lifecycleNarrationReady = true;
+				monitorTimer = setInterval(() => {
+					if (ownsSession()) refreshStatus(ctx, true);
+				}, monitorIntervalMs);
+				monitorTimer.unref?.();
+				return { value: void 0 };
+			});
+		})();
+		Promise.allSettled([readinessHandle.then((handle) => handle.wait())]);
+	};
+	const runCleanup = async (label, cleanup) => {
+		try {
+			await cleanup();
+		} catch (error) {
+			process.emitWarning(`Doom-workflow cleanup could not ${label}: ${String(error)}`);
+		}
+	};
+	let disposal;
+	const dispose = (context = sessionCtx) => {
+		disposal ??= (async () => {
+			if (!runtimeActive) return;
+			runtimeActive = false;
+			sessionGeneration += 1;
+			const pendingReadiness = readinessHandle;
+			readinessHandle = void 0;
+			readinessAbort?.abort();
+			readinessAbort = void 0;
+			await runCleanup("stop the workflow observer", stopRunControl);
+			const ownedReadiness = standaloneReadiness;
+			standaloneReadiness = void 0;
+			if (ownedReadiness) await runCleanup("dispose standalone workflow readiness", () => ownedReadiness.dispose());
+			else if (pendingReadiness) await Promise.allSettled([pendingReadiness.then((handle) => handle.wait())]);
+			if (pendingInlineRuns.size > 0) {
+				for (const service of [runService, recoverService]) await runCleanup("interrupt an inline workflow", () => service.interrupt("SIGTERM", {
+					phase: "workflow",
+					source: "pi-session-shutdown"
+				}));
+				await Promise.race([Promise.allSettled(pendingInlineRuns), new Promise((settle) => setTimeout(settle, SHUTDOWN_FINALIZE_TIMEOUT_MS).unref?.())]);
+			}
+			if (monitorTimer) clearInterval(monitorTimer);
+			monitorTimer = void 0;
+			if (statusRefreshTimer) clearTimeout(statusRefreshTimer);
+			statusRefreshTimer = void 0;
+			const provider = runProvider;
+			runProvider = void 0;
+			if (provider) await runCleanup("unregister the background-work provider", () => provider.dispose());
+			lifecycleNarrationReady = false;
+			inspectorHandle?.hide();
+			inspectorHandle = void 0;
+			inspectorOpen = false;
+			inspectorRecords.clear();
+			terminals.forget(/* @__PURE__ */ new Set());
+			closeOverlay();
+			sessionRunCount = 0;
+			if (context) clearFollow(context);
+			else if (followTimer) clearInterval(followTimer);
+			followTimer = void 0;
+			followedRun = void 0;
+			progressOverlay.dispose();
+			workflowMode = false;
+			publishedWorkflowState = void 0;
+			const mode = modeContribution;
+			if (mode) {
+				await runCleanup("publish the inactive workflow mode", () => mode.publish());
+				await runCleanup("dispose the workflow mode owner", () => mode.detach());
+			}
+			const leaderActions = disposeLeaderActions;
+			disposeLeaderActions = void 0;
+			if (leaderActions) await runCleanup("dispose workflow leader actions", leaderActions);
+			const pendingCount = pendingInlineRuns.size;
+			const activeTelemetry = telemetry;
+			telemetry = void 0;
+			if (activeTelemetry) {
+				await runCleanup("record the workflow session finish", () => activeTelemetry.recordEvent("doom_workflow.session_finished", {
+					"workflow.pending_count": pendingCount,
+					outcome: pendingCount === 0 ? "completed" : "interrupted"
+				}));
+				await runCleanup("stop workflow telemetry", () => activeTelemetry.shutdown());
+			}
+			pendingInlineRuns.clear();
+			pendingTerminalRuns.clear();
+			deliveredTerminalRuns.clear();
+			announcedRuns.length = 0;
+			knownSessionId = void 0;
+			sessionCtx = void 0;
+		})();
+		return disposal;
+	};
+	return {
+		dispose,
+		commands,
+		messageRenderers,
+		toolDependencies,
+		waitForReadiness,
+		services: [...services ?? [], (0, _agimon_ai_doompi_minor_mode.piMinorModes)([modeContribution])],
+		shortcuts: [[UNFOLLOW_SHORTCUT, {
+			description: "Open workflows or move typing between a workflow run and this session",
+			handler: async (ctx) => {
+				await waitForReadiness();
+				const handle = activeOverlay?.handle;
+				if (handle) {
+					if (!activeOverlay?.interactive) {
+						ctx.ui.notify("This run is hosted natively, so the view takes no typing. Your keys stay here.", "info");
+						return;
+					}
+					if (handle.isFocused()) {
+						handle.unfocus();
+						ctx.ui.notify("Typing goes to this session. The run keeps going.", "info");
+					} else {
+						handle.focus();
+						ctx.ui.notify(`Typing goes to ${activeOverlay?.runKey}.`, "info");
+					}
+					return;
+				}
+				if (followedRun) {
+					clearFollow(ctx);
+					ctx.ui.notify("Workflow continues in the background.", "info");
+					return;
+				}
+				await openInspector(ctx);
+			}
+		}], [CLOSE_OVERLAY_SHORTCUT, {
+			description: "Close the workflow run view",
+			handler: async (ctx) => {
+				await waitForReadiness();
+				if (!activeOverlay) return;
+				const runKey = activeOverlay.runKey;
+				closeOverlay();
+				ctx.ui.notify(`Closed the ${runKey} view. The run keeps going.`, "info");
+			}
+		}]],
+		events: {
+			session_start: onSessionStart,
+			resources_discover: onResourcesDiscover
+		},
+		toolRestrictions: [{
+			source: require_workflow.PACKAGE_SOURCE,
+			get restrict() {
+				return require_index$3.workflowToolRestriction(workflowMode);
+			},
+			subscribe(listener) {
+				restrictionListeners.add(listener);
+				return () => {
+					restrictionListeners.delete(listener);
+				};
+			}
+		}]
+	};
+}
+//#endregion
+exports.compatibleRunners = compatibleRunners;
+exports.createWorkflowPiRuntime = createWorkflowPiRuntime;
+exports.panelHint = panelHint;
+exports.panelHints = panelHints;
+exports.shortcutLabel = shortcutLabel;
+
+//# sourceMappingURL=workflowRuntime.cjs.map