@agimon-ai/po-workflow 0.0.0-alpha.0

package/dist/extensions/server.mjs

@@ -0,0 +1,4259 @@
+import { n as resolveWorkflowEntry, r as validateWorkflowLaunch, t as parseWorkflowLaunchCommand } from "../workflowLaunchCommand-GGqimmTC.mjs";
+import { composeServerProviderOverrides, defineServerPlugin } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineChannel, defineRoot, defineRoutedContribution } from "@agimon-ai/po-core/extensionFile";
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path, { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { BACKGROUND_WORK_HOLDING_PROVIDERS, DOOM_BACKGROUND_WORK_SERVICE, holdsSettledSession, readDoomBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
+import { SUBAGENT_PARENT_SESSION_ENV, readChildProcessContext, resolveRootSessionId } from "@agimon-ai/po-core/childProcess";
+import { DOOM_NARRATION_SERVICE, createNarrationRequest, requireDoomNarrationService } from "@agimon-ai/po-core/narration";
+import { DOOM_NOTIFICATION_ENTRY_TYPE, createDoomNotificationEntryData } from "@agimon-ai/po-core/notification";
+import { createDoomReadinessCoordinator, readDoomReadinessCoordinator } from "@agimon-ai/po-core/readiness";
+import { defineMinorMode, serverMinorModes } from "@agimon-ai/po-minor-mode";
+import { createDoomTelemetry } from "@agimon-ai/po-telemetry";
+import { NativeTerminalService, WORKFLOW_DECISION_FILE_ENV, WORKFLOW_DECISION_STEERING_ENV, WORKFLOW_DECISION_STEERING_HOST, WorkflowRegistryService, WorkflowTerminalService, connectNativeTerminal, createEmbeddedWorkflowFeature, diagnoseWorkflow, gateStepDecision, readStepDecision, readWorkflowCatalog, readWorkflowProgress, serveNativeTerminal, summarizeWorkflow, summarizeWorkflowProgress, terminalSocketPath } from "@agimon-ai/workflow-mcp";
+import { z } from "zod";
+import fs, { existsSync, statSync } from "node:fs";
+import { WORKFLOW_STEP_SESSION_PROVENANCE } from "@agimon-ai/po-core/hubChannel";
+import { execFile } from "node:child_process";
+import { Readable } from "node:stream";
+import { doomApiCallerFrom } from "@agimon-ai/po-core/packageApi";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { apiResponse, defineApiRoutes } from "@agimon-ai/po-core/web";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
+//#region src/constants/workflow.ts
+const LAUNCH_WORKFLOW_TOOL_NAME = "launch_workflow";
+const WORKFLOW_TOOLS_TOOL_NAME = "workflow_tools";
+/**
+* One launch's own id, carried in the run's environment.
+*
+* A launch answers once its run registers; matching on this id, rather than on
+* the workflow and the time, keeps two launches of one workflow apart.
+*/
+const WORKFLOW_LAUNCH_ID_ENV = "PO_WORKFLOW_LAUNCH_ID";
+/**
+* Provenance of the child session a launch creates to own and run one workflow.
+* Not 'workflow', which marks a step's session and keeps it out of the rail.
+*/
+const WORKFLOW_SESSION_PROVENANCE = "workflow-session";
+/**
+* Run env key naming the session that launched a run into its own workflow
+* session. PI_SESSION_ID names the owner; this names the launcher, which lists
+* the run, is told when it ends, and releases the workflow session after success.
+*/
+const WORKFLOW_LAUNCHER_SESSION_ENV = "PO_WORKFLOW_LAUNCHER_SESSION_ID";
+/** Message a workflow session sends its launcher to be released once its run succeeded. */
+const WORKFLOW_SESSION_RELEASE_TYPE = "po-workflow.session-release";
+//#endregion
+//#region src/schemas/runConfig.ts
+/** A YAML list, or one comma-separated string, as `--domains a,b` accepts. */
+const nameList = z.union([z.string(), z.array(z.string())]).transform((value) => (Array.isArray(value) ? value : value.split(",")).map((name) => name.trim()).filter((name) => name.length > 0));
+const singleName = z.string().trim().min(1);
+/**
+* The Po keys of a workflow step's `runConfig`.
+*
+* The engine treats `runConfig` as an opaque map, so this is where a typo such
+* as `majormode` is caught instead of silently running on workspace defaults.
+*/
+const poRunConfigSchema = z.object({
+	majorMode: singleName.optional().describe("Major mode the step session runs in."),
+	minorModes: nameList.optional().describe("Minor modes activated in the step session."),
+	profile: singleName.optional().describe("Profile the step session runs as."),
+	domains: nameList.optional().describe("Domains selected for the step session. An empty list selects none."),
+	model: singleName.optional().describe("Model selector, provider/id."),
+	thinking: singleName.optional().describe("Thinking level for the model."),
+	subagentModel: singleName.optional().describe("Preferred Team subagent model, independent of the step model."),
+	subagentThinking: singleName.optional().describe("Preferred Team subagent thinking level.")
+}).strict();
+/**
+* The same keys for a templated step, whose `runConfig` is also the data its
+* command template reads: keys Po does not use are left to the template.
+*/
+const poTemplateRunConfigSchema = poRunConfigSchema.strip();
+/** The runConfig keys Po reads itself, the host keys `workflow-mcp doctor` checks steps against. */
+const PO_RUN_CONFIG_KEYS = poRunConfigSchema.keyof().options;
+//#endregion
+//#region src/schemas/workflowPi.ts
+const RUN_SELECTOR_FIELDS = {
+	runKey: z.string().min(1).describe("Run key of the workflow run."),
+	workspace: z.string().optional().describe("Workspace the run belongs to.")
+};
+z.discriminatedUnion("action", [
+	z.object({
+		action: z.literal("status"),
+		...RUN_SELECTOR_FIELDS
+	}).strict(),
+	z.object({
+		action: z.literal("tail"),
+		...RUN_SELECTOR_FIELDS
+	}).strict(),
+	z.object({
+		action: z.literal("recovery-evidence"),
+		...RUN_SELECTOR_FIELDS
+	}).strict(),
+	z.object({
+		action: z.literal("follow"),
+		...RUN_SELECTOR_FIELDS
+	}).strict(),
+	z.object({
+		action: z.literal("open"),
+		...RUN_SELECTOR_FIELDS
+	}).strict(),
+	z.object({
+		action: z.literal("pause"),
+		...RUN_SELECTOR_FIELDS,
+		reason: z.string().optional()
+	}).strict(),
+	z.object({
+		action: z.literal("resume"),
+		...RUN_SELECTOR_FIELDS,
+		reason: z.string().optional()
+	}).strict(),
+	z.object({
+		action: z.literal("stop"),
+		...RUN_SELECTOR_FIELDS,
+		reason: z.string().optional()
+	}).strict(),
+	z.object({
+		action: z.literal("recover"),
+		...RUN_SELECTOR_FIELDS,
+		dryRun: z.boolean().optional(),
+		job: z.string().optional(),
+		runner: z.string().optional()
+	}).strict()
+]);
+const dispatchInputSchema = z.object({
+	description: z.string().optional().describe("Description shown for the workflow input."),
+	required: z.boolean().optional().describe("Whether the workflow input must be provided."),
+	default: z.string().optional().describe("Default value for the workflow input."),
+	type: z.string().optional().describe("Declared workflow input type."),
+	options: z.array(z.string()).optional().describe("Allowed values for the workflow input.")
+}).passthrough();
+z.object({ inputs: z.record(z.string(), dispatchInputSchema).optional().describe("Workflow dispatch input definitions.") }).passthrough();
+z.object({
+	directory: z.string().min(1).describe("Directory searched for workflow definitions."),
+	hasNextPage: z.boolean().describe("Whether another catalog page exists."),
+	page: z.number().int().positive().describe("One-based catalog page number."),
+	pageSize: z.number().int().positive().describe("Catalog page size."),
+	workflows: z.array(z.object({
+		path: z.string().min(1).describe("Workflow path relative to the catalog directory."),
+		name: z.string().describe("Workflow display name."),
+		description: z.string().describe("Workflow description."),
+		tags: z.array(z.string()).describe("Workflow tags.")
+	}).passthrough()).describe("Workflow definitions on this page.")
+}).passthrough();
+const workflowToolsInputSchema = z.object({
+	action: z.enum(["recovery-evidence", "recover"]),
+	...RUN_SELECTOR_FIELDS,
+	dryRun: z.boolean().optional().describe("recover only: print the replay without running it."),
+	runner: z.string().optional().describe("recover only: override the recorded runner.")
+}).strict();
+//#endregion
+//#region src/services/backgroundWork/index.ts
+/**
+* Background-work registration for workflow runs.
+*
+* DESIGN PATTERNS:
+* - Hard dependency binding through Cordis injection
+* - Snapshot pattern: the extension pushes the current run set, the provider
+*   only reads it
+*
+* CODING STANDARDS:
+* - Named exports only
+* - Explicit return types on exported functions
+*
+* AVOID:
+* - Process-global symbols or dynamic imports for extension communication
+* - Reporting runs owned by another Pi session
+*/
+const PROVIDER_NAME = "workflow-mcp";
+/**
+* Register a background-work provider for this session's workflow runs.
+*
+* The runtime pins all announcements to the active Pi session and validates
+* each snapshot before it reaches another extension.
+*/
+function registerRunProvider(ctx) {
+	let items = [];
+	let provider;
+	let disposed = false;
+	ctx.inject([DOOM_BACKGROUND_WORK_SERVICE], (serviceContext) => {
+		if (disposed) return void 0;
+		const service = readDoomBackgroundWorkService(serviceContext);
+		if (!service) return void 0;
+		const registration = service.register({
+			provider: PROVIDER_NAME,
+			listActiveWork: () => items
+		});
+		provider = registration;
+		return () => {
+			registration.dispose();
+			if (provider === registration) provider = void 0;
+		};
+	});
+	return {
+		update(next) {
+			items = next;
+			provider?.update();
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			items = [];
+			provider?.dispose();
+			provider = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/services/piToolBridge/index.ts
+/**
+* Environment variable stamped onto every run launched from a Pi session.
+*
+* `RunWorkflowService` forwards `env` to the inner CLI invocation across the
+* `launch-command` delegation boundary and persists it on the run record, so
+* this survives backgrounding and identifies the launching session afterwards.
+*/
+const PI_SESSION_ENV$1 = "PI_SESSION_ID";
+/** Operator override for the per-session launch ceiling. */
+const MAX_CONCURRENT_ENV = "WORKFLOW_MCP_MAX_CONCURRENT";
+const DEFAULT_MAX_CONCURRENT = 5;
+/** Resolve the per-session launch ceiling from the environment. */
+function resolveMaxConcurrent(env = process.env) {
+	const parsed = Number(env[MAX_CONCURRENT_ENV]);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CONCURRENT;
+}
+/**
+* True when this session launched the run.
+*
+* Fails closed on a missing session id: an unstamped record (a CLI launch) and
+* a call arriving before the session id is known both match nothing, so no run
+* ever leaks across sessions through an undefined-equals-undefined comparison.
+*/
+function isSessionRun(record, sessionId) {
+	return sessionId !== void 0 && record.env?.["PI_SESSION_ID"] === sessionId;
+}
+/** True when this session handed the run to a workflow session of its own: it is told, but does not own it. */
+function isLaunchedRun(record, sessionId) {
+	return sessionId !== void 0 && record.env?.["PO_WORKFLOW_LAUNCHER_SESSION_ID"] === sessionId && !isSessionRun(record, sessionId);
+}
+/** The line a launcher's finish notice adds: where the run lived, and where to take it up. */
+function launchedRunHint(record) {
+	return `It ran in workflow session ${record.env?.["PI_SESSION_ID"] ?? "unknown"}; troubleshoot and recover it there.`;
+}
+/**
+* True when this session owns a run another session handed to it: it is the
+* run's workflow session, so a finished run is posted without starting a turn.
+*/
+function isOwnedDelegatedRun(record, sessionId) {
+	const launcher = record.env?.[WORKFLOW_LAUNCHER_SESSION_ENV];
+	return isSessionRun(record, sessionId) && typeof launcher === "string" && launcher !== "" && launcher !== sessionId;
+}
+/**
+* What the caller is told when the registry, not the launcher, acknowledged a
+* launch.
+*
+* Leads with the run key because it is the handle every other workflow action
+* takes, and it is no longer available any other way: the launcher's own output
+* is not waited for, so nothing else in this result carries it.
+*/
+function launchedRunSummary(record) {
+	return [
+		`Started ${record.displayName} in workspace ${record.workspace}.`,
+		`Run key: ${record.runKey}`,
+		"The run is registered and going. This call returned at that point rather than waiting for the launcher process to exit."
+	].join("\n");
+}
+/**
+* What the caller is told when the launch was handed off but no run has
+* registered inside the acknowledgement budget.
+*
+* Deliberately not an error: the launcher is slow rather than broken often
+* enough that failing here would strand runs that go on to start normally.
+* There is no run key to offer yet, so it points at the surfaces that do not
+* need one.
+*/
+function launchHandoffSummary(workflowPath) {
+	return [
+		`Launch handed off for ${workflowPath}, but no run has registered yet.`,
+		"Nothing was cancelled: the launcher is still starting, and a run that registers later still reports back here when it finishes.",
+		"Do not launch it again. Ask the user to check the active workflow list if they need to see it sooner."
+	].join("\n");
+}
+new RegExp([
+	"\\u001B\\[[0-9;?]*[ -/]*[@-~]",
+	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
+	"\\u001B[@-Z\\\\-_]"
+].join("|"), "g");
+/** Flatten MCP tool content to text for Pi. */
+function toolResultText(result) {
+	return result.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n").trim();
+}
+/**
+* Attach a short menu of next steps to a problem.
+*
+* An error with no route forward is where an agent invents one: retrying a
+* capacity limit, relaunching a run that should be recovered, or silently
+* giving up on work the user is waiting for. Naming two or three real options
+* turns an error into a decision, and the decision belongs to the user.
+*/
+function withOptions(problem, options) {
+	if (options.length === 0) return problem;
+	return [
+		problem,
+		"",
+		"Options, put these to the user rather than picking one yourself:",
+		...options.map(bullet)
+	].join("\n");
+}
+function bullet(option) {
+	return `- ${option}`;
+}
+/** The job and step a run died on, preferring the progress log to the record. */
+function failurePosition(record, jobs) {
+	const failedJob = jobs.find((job) => job.status === "failed");
+	const failedStep = failedJob?.steps.find((step) => step.status === "failed");
+	return {
+		job: failedJob?.name ?? record.failedJob,
+		step: failedStep?.name,
+		reason: failedStep?.reason ?? failedJob?.reason
+	};
+}
+/**
+* Describe a finished run for the agent that launched it.
+*
+* Carries the job identifiers back so a dispatching agent can match the run to
+* the work item it launched it for without another lookup. When the run failed,
+* carries the failing step and a set of options too: the agent is being told
+* about this out of band, with no user question in flight, so without them it
+* has to guess whether to recover, relaunch, or report.
+*/
+function finishedRunSummary(record, jobs = []) {
+	const outcome = record.stage === "completed" ? "completed" : `ended in ${record.stage}`;
+	const failure = failurePosition(record, jobs);
+	const lines = [
+		`Workflow run ${record.runKey} in workspace ${record.workspace} ${outcome}.`,
+		record.workflowId ? `Workflow: ${record.workflowId}` : void 0,
+		failure.job ? `Failed job: ${failure.job}${failure.step ? ` (step: ${failure.step})` : ""}` : void 0,
+		record.errorMessage ? `Error: ${record.errorMessage}` : void 0,
+		failure.reason && failure.reason !== record.errorMessage ? `Step reported: ${failure.reason}` : void 0
+	];
+	const jobId = record.env?.AGIFLOW_JOB_ID;
+	if (jobId) lines.push(`Agiflow job: ${record.env?.AGIFLOW_JOB_KIND ?? "unknown"} ${jobId}`);
+	const summary = lines.filter((line) => Boolean(line)).join("\n");
+	if (record.stage === "completed") return summary;
+	if (record.outcome === "interrupted") return withOptions(summary, [`workflow_run {"action":"recover","runKey":${JSON.stringify(record.runKey)}}: pick it up where it stopped.`, "Leave it stopped and move on."]);
+	const diagnosticText = [record.errorMessage, failure.reason].filter(Boolean).join("\n");
+	if (diagnosticText.includes("JOB_ALREADY_CLAIMED")) return withOptions(summary, ["Report contention: another worker owns this job. Do not unlock, release, or retry the claim automatically."]);
+	if (diagnosticText.includes("WORKFLOW_NOT_OWNED") || /release failed/i.test(diagnosticText)) return withOptions(summary, ["Inspect the current workflow ownership and ask the user before any release or unlock. Never force another worker’s lock."]);
+	if (/running workflow not found/i.test(diagnosticText)) return withOptions(summary, [`workflow_run {"action":"status","runKey":${JSON.stringify(record.runKey)}}: re-check current state before retrying.`, "Report the recorded terminal state when no running owner remains."]);
+	return withOptions(summary, [
+		`workflow_run {"action":"tail","runKey":${JSON.stringify(record.runKey)}}: read the run's own output first, when the error above does not explain the failure.`,
+		`workflow_run {"action":"recover","runKey":${JSON.stringify(record.runKey)}}: resume from the failed job, keeping the work already done. Fits a transient or external cause.`,
+		"Report the failure and stop, when it needs a code change or a decision you cannot make."
+	]);
+}
+//#endregion
+//#region src/services/workflowExecution/index.ts
+const AGIFLOW_JOB_ID_ENV = "AGIFLOW_JOB_ID";
+const AGIFLOW_JOB_KIND_ENV = "AGIFLOW_JOB_KIND";
+const AGIFLOW_PROJECT_ID_ENV = "AGIFLOW_PROJECT_ID";
+/** How often the registry is asked whether the launch has produced a run. */
+const LAUNCH_ACK_POLL_MS = 500;
+/**
+* How long to wait for that before answering without a run key.
+*
+* Long enough to cover a launcher that is merely slow, short enough that a
+* caller is never left holding a turn open for a launcher that will not answer.
+*/
+const LAUNCH_ACK_TIMEOUT_MS = 15e3;
+function reportProgress(onUpdate, tool, message) {
+	onUpdate?.({
+		content: [{
+			type: "text",
+			text: message
+		}],
+		details: { tool }
+	});
+}
+const launchFailureOptions = [
+	"Report the failure to the user with the error above. A launch failure is usually a bad workflow path, a missing launcher, or a workflow whose own pre-conditions refused.",
+	"list_workflows: confirm the workflow path exists and its description matches the work, if the path may be wrong.",
+	"workflow_run with action status: check whether an earlier attempt is already running before launching again."
+];
+/**
+* An Error, whatever the launch rejected with.
+*
+* A rejection reaches here as `unknown` because it crossed a promise boundary,
+* and rethrowing that as-is hands Pi's tool layer something it cannot read a
+* message or a stack off. The original is kept as the cause rather than
+* flattened into a string.
+*/
+function asError$1(value) {
+	return value instanceof Error ? value : new Error(String(value), { cause: value });
+}
+/** Resolves to undefined, so a race against it reads as "nothing settled yet". */
+function sleep(ms) {
+	return new Promise((settle) => {
+		setTimeout(() => settle(void 0), ms).unref?.();
+	});
+}
+/**
+* Wait for whichever answer arrives first: the launch settling, the run
+* appearing in the registry, or the budget running out.
+*
+* A launch that delegates to a terminal launcher settles when that launcher's
+* whole process chain closes, which on a loaded machine has been measured
+* minutes after the run itself was registered and working. The registry is the
+* earlier and more truthful signal: a run recorded there is a run that started.
+*/
+async function awaitLaunchAck(settled, dependencies, query) {
+	const findLaunchedRun = dependencies.findLaunchedRun;
+	if (!findLaunchedRun) return {
+		kind: "settled",
+		outcome: await settled
+	};
+	return awaitRunAck(settled, () => findLaunchedRun(query), dependencies.launchAckPollMs, dependencies.launchAckTimeoutMs);
+}
+async function awaitRunAck(settled, find, pollMs = LAUNCH_ACK_POLL_MS, timeoutMs = LAUNCH_ACK_TIMEOUT_MS) {
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const outcome = await Promise.race([settled, sleep(pollMs)]);
+		if (outcome) return {
+			kind: "settled",
+			outcome
+		};
+		const record = await find().catch(() => void 0);
+		if (record) return {
+			kind: "record",
+			record
+		};
+		if (Date.now() >= deadline) return { kind: "handoff" };
+	}
+}
+/**
+* Carry a failure that lands after the caller was told the run started.
+*
+* Answering early trades the launcher's exit code for timeliness. Dropping that
+* code entirely is not part of the trade: a launch that fails a minute later
+* would otherwise leave a user waiting on a run that never existed.
+*/
+function reportLateFailure(settled, dependencies, ctx) {
+	settled.then((outcome) => {
+		if (outcome.kind === "error") {
+			dependencies.onLateFailure?.(asError$1(outcome.error), ctx);
+			return;
+		}
+		if (outcome.result.isError) dependencies.onLateFailure?.(new Error(toolResultText(outcome.result) || "Workflow launch failed."), ctx);
+	});
+}
+function createWorkflowLaunchExecutor(dependencies) {
+	return { async execute(input, ctx, onUpdate) {
+		const sessionId = resolveRootSessionId(ctx.sessionManager.getSessionId(), dependencies.environment);
+		dependencies.observeSession?.(sessionId);
+		const agiflowJobKind = input.env?.[AGIFLOW_JOB_KIND_ENV]?.trim();
+		const agiflowJobId = input.env?.[AGIFLOW_JOB_ID_ENV]?.trim();
+		const explicitProjectId = input.env?.[AGIFLOW_PROJECT_ID_ENV]?.trim();
+		if (Boolean(agiflowJobKind) !== Boolean(agiflowJobId)) throw new Error("Agiflow workflow launches require AGIFLOW_JOB_KIND and AGIFLOW_JOB_ID together.");
+		if (agiflowJobKind && agiflowJobKind !== "task" && agiflowJobKind !== "work-unit") throw new Error("Agiflow workflow launches require AGIFLOW_JOB_KIND to be task or work-unit.");
+		if (agiflowJobKind && !explicitProjectId) throw new Error("Agiflow workflow launches require AGIFLOW_PROJECT_ID with the job identity.");
+		if (agiflowJobKind && !input.prompt?.trim()) throw new Error("Agiflow workflow launches require a non-empty prompt so user_prompt runs do not wait for terminal input.");
+		reportProgress(onUpdate, LAUNCH_WORKFLOW_TOOL_NAME, "Checking workflow capacity...");
+		const maxConcurrent = resolveMaxConcurrent(dependencies.environment);
+		const active = await dependencies.activeRunCount?.() ?? 0;
+		if (active >= maxConcurrent) throw new Error(withOptions(`This session is at capacity: ${active}/${maxConcurrent} workflows running.`, [
+			"Wait for a running workflow to finish, then launch again. The extension reports each one as it ends.",
+			"workflow_run with action status: show what is running, so the user can judge whether something is stuck.",
+			"workflow_run with action stop: free a slot by stopping a run the user no longer wants."
+		]));
+		if (input.runner) {
+			const rejection = dependencies.rejectRunner?.(input.workflowPath, input.runner);
+			if (rejection) throw new Error(rejection);
+		}
+		reportProgress(onUpdate, LAUNCH_WORKFLOW_TOOL_NAME, `Launching workflow ${input.workflowPath}...`);
+		const workflowEnv = { ...input.env };
+		const dispatcherContextFile = dependencies.environment.AGIFLOW_DISPATCH_CONTEXT_FILE;
+		const dispatcherProjectId = dependencies.environment[AGIFLOW_PROJECT_ID_ENV]?.trim();
+		if (dispatcherContextFile && agiflowJobKind && dispatcherProjectId && explicitProjectId && dispatcherProjectId !== explicitProjectId) throw new Error(`Agiflow workflow project identity conflicts with the dispatcher context (${explicitProjectId} versus ${dispatcherProjectId}).`);
+		if (dispatcherContextFile) for (const key of [
+			"AGIFLOW_ORGANIZATION_ID",
+			"AGIFLOW_PROJECT_ID",
+			"AGIFLOW_DEVICE_ID",
+			"BACKEND_AGIFLOW_API_ENDPOINT",
+			"AGIFLOW_DISPATCH_SECRET_FILE"
+		]) {
+			const hostValue = dependencies.environment[key];
+			if (hostValue) workflowEnv[key] = hostValue;
+		}
+		const since = Date.now();
+		const launchId = randomUUID();
+		const settled = foldOutcome(dependencies.trackPendingRun(dependencies.runTool.execute({
+			...input,
+			env: {
+				...workflowEnv,
+				[PI_SESSION_ENV$1]: sessionId,
+				[WORKFLOW_LAUNCH_ID_ENV]: launchId
+			}
+		})));
+		const ack = await awaitLaunchAck(settled, dependencies, {
+			launchId,
+			sessionId,
+			since,
+			workflowPath: input.workflowPath
+		});
+		if (ack.kind === "settled") {
+			const outcome = ack.outcome;
+			if (outcome.kind === "error") throw asError$1(outcome.error);
+			const result = outcome.result;
+			if (result.isError) throw new Error(withOptions(toolResultText(result) || "Workflow launch failed.", launchFailureOptions));
+			await dependencies.onLaunch?.(ctx);
+			return result;
+		}
+		reportLateFailure(settled, dependencies, ctx);
+		await dependencies.onLaunch?.(ctx);
+		return { content: [{
+			type: "text",
+			text: ack.kind === "record" ? launchedRunSummary(ack.record) : launchHandoffSummary(input.workflowPath)
+		}] };
+	} };
+}
+function foldOutcome(promise) {
+	return promise.then((result) => ({
+		kind: "value",
+		result
+	}), (error) => ({
+		kind: "error",
+		error
+	}));
+}
+//#endregion
+//#region src/services/workflowRuns/index.ts
+/**
+* MIRRORS @agimon-ai/workflow-mcp's on-disk registry
+* (src/services/WorkflowRegistryService.ts and WorkflowProgressService.ts in
+* that package). The engine keeps one directory per run under
+* `<home>/workspaces/<workspace>/<stage>/<runKey>/` holding a `run.json`
+* record and an append-only `progress.ndjson` job/step log; the hub only ever
+* reads them. The derivation is duplicated rather than imported because
+* po-web must not depend on the engine at runtime; the unit suite pins
+* this mirror against the package's published types.
+*/
+const DEFAULT_WORKFLOW_HOME_DIR_NAME = ".workflow-mcp";
+const WORKSPACES_DIR_NAME = "workspaces";
+const RUN_RECORD_FILE_NAME = "run.json";
+const PROGRESS_FILE_NAME = "progress.ndjson";
+const WORKFLOW_STAGES = [
+	"running",
+	"completed",
+	"error"
+];
+/**
+* Errored runs stay a day, which is how long recovery has to act on them.
+*
+* Finished runs have no retention of their own: a session keeps every run it
+* launched, grouped by outcome, for as long as the session lives. A run leaves
+* the view when the engine prunes its registry directory, not on a timer here,
+* because "what did this session run today" is a question asked long after the
+* run settled.
+*/
+const WORKFLOW_ERROR_RETENTION_MS = 864e5;
+/** The env key po-workflow stamps on runs it launches; ties a run to a Pi session. */
+const PI_SESSION_ENV = "PI_SESSION_ID";
+const PROGRESS_STATES = /* @__PURE__ */ new Set([
+	"running",
+	"completed",
+	"skipped",
+	"failed",
+	"pause_requested",
+	"paused",
+	"resumed"
+]);
+const OUTCOMES = /* @__PURE__ */ new Set([
+	"success",
+	"skipped",
+	"failed",
+	"interrupted"
+]);
+const EXECUTION_STATES = /* @__PURE__ */ new Set([
+	"running",
+	"pause_requested",
+	"paused",
+	"resume_requested"
+]);
+const STEP_TERMINAL_STATES = /* @__PURE__ */ new Set([
+	"completed",
+	"skipped",
+	"failed"
+]);
+/** The engine records its pre:/post: blocks under these reserved pseudo-job names. */
+const PHASE_JOB_PRE = "pre";
+const PHASE_JOB_POST = "post";
+const ANSI_ESCAPE_PATTERN = /\u001b\[[0-9;]*[A-Za-z]/g;
+/** Where workflow-mcp keeps its registry, mirroring the engine's own resolution. */
+function resolveWorkflowHome(input) {
+	return resolve(input.envValue !== void 0 && input.envValue !== "" ? input.envValue : resolve(input.homeDir, DEFAULT_WORKFLOW_HOME_DIR_NAME));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asOptionalString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function asOptionalNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Text without its terminal escape codes, as a log file or a reader wants it. */
+function withoutAnsi(text) {
+	return text.replace(ANSI_ESCAPE_PATTERN, "");
+}
+function stripAnsi(text) {
+	return withoutAnsi(text).trim();
+}
+/**
+* Validates one run.json into the wire shape plus scoping facts.
+*
+* Returns undefined for anything unreadable or a foreign format. The record
+* is trusted for its own stage: the registry rewrites it when a run moves
+* between stage directories.
+*/
+function parseWorkflowRunRecord(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (!isRecord(parsed)) return void 0;
+	const runKey = asOptionalString(parsed.runKey);
+	const workspace = asOptionalString(parsed.workspace);
+	const workflowPath = asOptionalString(parsed.workflowPath);
+	const startedAt = asOptionalString(parsed.startedAt);
+	const stage = asOptionalString(parsed.stage);
+	if (!runKey || !workspace || !workflowPath || !startedAt) return void 0;
+	if (stage === void 0 || !WORKFLOW_STAGES.includes(stage)) return void 0;
+	const outcome = asOptionalString(parsed.outcome);
+	const executionState = asOptionalString(parsed.executionState);
+	const rawError = asOptionalString(parsed.errorMessage);
+	const env = isRecord(parsed.env) ? parsed.env : void 0;
+	const view = {
+		...asOptionalString(parsed.runId) === void 0 ? {} : { runId: asOptionalString(parsed.runId) },
+		runKey,
+		workspace,
+		displayName: asOptionalString(parsed.displayName) ?? runKey,
+		...asOptionalString(parsed.workflowName) === void 0 ? {} : { workflowName: asOptionalString(parsed.workflowName) },
+		workflowPath,
+		stage,
+		...outcome !== void 0 && OUTCOMES.has(outcome) ? { outcome } : {},
+		...executionState !== void 0 && EXECUTION_STATES.has(executionState) ? { executionState } : {},
+		...asOptionalString(parsed.prompt) === void 0 ? {} : { prompt: asOptionalString(parsed.prompt) },
+		startedAt,
+		...asOptionalString(parsed.finishedAt) === void 0 ? {} : { finishedAt: asOptionalString(parsed.finishedAt) },
+		...rawError === void 0 ? {} : { errorMessage: stripAnsi(rawError) },
+		...asOptionalString(parsed.failedJob) === void 0 ? {} : { failedJob: asOptionalString(parsed.failedJob) },
+		...parsed.stale === true ? { stale: true } : {},
+		...asOptionalString(parsed.staleReason) === void 0 ? {} : { staleReason: asOptionalString(parsed.staleReason) },
+		...asOptionalString(parsed.worktreeBranch) === void 0 ? {} : { worktreeBranch: asOptionalString(parsed.worktreeBranch) },
+		jobs: []
+	};
+	const piSessionId = env === void 0 ? void 0 : asOptionalString(env[PI_SESSION_ENV]);
+	const launcherSessionId = env === void 0 ? void 0 : asOptionalString(env[WORKFLOW_LAUNCHER_SESSION_ENV]);
+	if (piSessionId !== void 0) view.ownerSessionId = piSessionId;
+	if (launcherSessionId !== void 0) view.launcherSessionId = launcherSessionId;
+	return {
+		view,
+		...piSessionId === void 0 ? {} : { piSessionId },
+		...launcherSessionId === void 0 ? {} : { launcherSessionId }
+	};
+}
+function parseStepRef(value) {
+	if (!isRecord(value)) return void 0;
+	const kind = asOptionalString(value.kind);
+	const id = asOptionalString(value.id);
+	if (!kind || !id) return void 0;
+	const label = asOptionalString(value.label);
+	return {
+		kind,
+		id,
+		...label === void 0 ? {} : { label }
+	};
+}
+/**
+* Parses the append-only progress log. Malformed lines are skipped rather
+* than failing the file: a reader routinely catches a torn final line
+* mid-append.
+*/
+function parseWorkflowProgress(raw) {
+	const events = [];
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed === "") continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			continue;
+		}
+		if (!isRecord(parsed)) continue;
+		const type = parsed.type;
+		const status = asOptionalString(parsed.status);
+		const job = asOptionalString(parsed.job);
+		const at = asOptionalString(parsed.at);
+		if (type !== "job" && type !== "step" || !job || !at) continue;
+		if (status === void 0 || !PROGRESS_STATES.has(status)) continue;
+		const step = asOptionalString(parsed.step);
+		const index = asOptionalNumber(parsed.index);
+		const total = asOptionalNumber(parsed.total);
+		const reason = asOptionalString(parsed.reason);
+		const ref = parseStepRef(parsed.ref);
+		const group = asOptionalString(parsed.group);
+		events.push({
+			type,
+			status,
+			job,
+			...step === void 0 ? {} : { step },
+			...index === void 0 ? {} : { index },
+			...total === void 0 ? {} : { total },
+			...reason === void 0 ? {} : { reason },
+			...ref === void 0 ? {} : { ref },
+			...group === void 0 ? {} : { group },
+			at
+		});
+	}
+	return events;
+}
+function jobPhase(name) {
+	if (name === PHASE_JOB_PRE) return PHASE_JOB_PRE;
+	if (name === PHASE_JOB_POST) return PHASE_JOB_POST;
+	return "job";
+}
+/** Names match the engine's progress log, including unnamed parallel children. */
+function plannedSteps(steps = []) {
+	return steps.flatMap((step, index) => {
+		const name = step.name ?? `step ${index + 1}`;
+		return step.parallel === void 0 ? [{
+			name,
+			status: "pending"
+		}] : step.parallel.map((child, childIndex) => ({
+			name: child.name ?? `${name} ${childIndex + 1}`,
+			status: "pending",
+			group: name
+		}));
+	});
+}
+/** The whole declared route, before any job or step has emitted progress. */
+function planWorkflowJobs(workflow, order) {
+	const jobs = order.map((name) => {
+		const job = workflow.jobs[name];
+		return {
+			name,
+			phase: "job",
+			status: "pending",
+			steps: [
+				...plannedSteps(job.preJob?.steps),
+				...plannedSteps(job.steps),
+				...plannedSteps(job.postJob?.steps)
+			]
+		};
+	});
+	if (workflow.pre !== void 0) jobs.unshift({
+		name: PHASE_JOB_PRE,
+		phase: "pre",
+		status: "pending",
+		steps: plannedSteps(workflow.pre.steps)
+	});
+	if (workflow.post !== void 0) jobs.push({
+		name: PHASE_JOB_POST,
+		phase: "post",
+		status: "pending",
+		steps: plannedSteps(workflow.post.steps)
+	});
+	return jobs;
+}
+/** Overlay progress on the plan, retaining recorded jobs and steps absent from the current definition. */
+function foldWorkflowProgress(events, plan = []) {
+	const jobs = plan.map((job) => ({
+		...job,
+		steps: job.steps.map((step) => ({ ...step }))
+	}));
+	const jobByName = new Map(jobs.map((job) => [job.name, job]));
+	for (const event of events) {
+		let job = jobByName.get(event.job);
+		if (job === void 0) {
+			job = {
+				name: event.job,
+				phase: jobPhase(event.job),
+				status: event.status,
+				steps: []
+			};
+			jobByName.set(event.job, job);
+			jobs.push(job);
+		}
+		if (event.type === "job") {
+			if (event.status === "running" && (event.index !== void 0 || job.status !== "running")) {
+				delete job.reason;
+				delete job.endedAt;
+				delete job.startedAt;
+			}
+			job.status = event.status;
+			if (event.reason !== void 0) job.reason = event.reason;
+			if (event.index !== void 0) job.index = event.index;
+			if (event.total !== void 0) job.total = event.total;
+			if (event.status === "running" && job.startedAt === void 0) job.startedAt = event.at;
+			if (STEP_TERMINAL_STATES.has(event.status)) job.endedAt = event.at;
+			continue;
+		}
+		if (event.step === void 0) continue;
+		if (job.status === "pending") job.status = event.status;
+		let step = job.steps.find((candidate) => candidate.name === event.step);
+		if (step === void 0) {
+			step = {
+				name: event.step,
+				status: event.status
+			};
+			job.steps.push(step);
+		} else if (event.status === "running" && (event.index !== void 0 || step.status !== "running")) {
+			delete step.ref;
+			delete step.reason;
+			delete step.endedAt;
+			delete step.startedAt;
+		}
+		step.status = event.status;
+		if (event.reason !== void 0) step.reason = event.reason;
+		if (event.ref !== void 0) step.ref = event.ref;
+		if (event.group !== void 0) step.group = event.group;
+		if (event.status === "running" && step.startedAt === void 0) step.startedAt = event.at;
+		if (STEP_TERMINAL_STATES.has(event.status)) step.endedAt = event.at;
+	}
+	for (const job of jobs) if (job.status === "skipped") {
+		for (const step of job.steps) if (step.status === "pending") step.status = "skipped";
+	}
+	return jobs;
+}
+const ACTIVE_PROGRESS_STATES = /* @__PURE__ */ new Set([
+	"running",
+	"pause_requested",
+	"paused",
+	"resumed"
+]);
+/** The job and step a run is on right now, for the NOW breadcrumb. */
+function workflowPosition(jobs) {
+	for (let jobIndex = jobs.length - 1; jobIndex >= 0; jobIndex -= 1) {
+		const job = jobs[jobIndex];
+		if (!ACTIVE_PROGRESS_STATES.has(job.status)) continue;
+		for (let stepIndex = job.steps.length - 1; stepIndex >= 0; stepIndex -= 1) {
+			const step = job.steps[stepIndex];
+			if (ACTIVE_PROGRESS_STATES.has(step.status)) return {
+				job: job.name,
+				step: step.name,
+				...job.index === void 0 ? {} : { index: job.index },
+				...job.total === void 0 ? {} : { total: job.total }
+			};
+		}
+		return {
+			job: job.name,
+			...job.index === void 0 ? {} : { index: job.index },
+			...job.total === void 0 ? {} : { total: job.total }
+		};
+	}
+}
+/** The finished view: record fields plus the folded job tree and position. */
+function completeWorkflowRunView(view, jobs) {
+	const position = view.stage === "running" ? workflowPosition(jobs) : void 0;
+	return {
+		...view,
+		jobs,
+		...position === void 0 ? {} : { position }
+	};
+}
+/**
+* Whether a run belongs on a session's workflow tab: launched by that Pi
+* session, which is the same env test po-workflow's isSessionRun applies.
+*
+* The registry is one directory under $HOME shared by every repository and
+* every Pi session on the machine, so repository proximity is not ownership.
+* Scoping on it as well let two sessions open in one repo read each other's
+* history, and kept a dead session's runs on the board of every session that
+* replaced it. Fails closed on an unstamped record, which is what a launch
+* from the CLI rather than from a session leaves behind.
+*/
+function runBelongsToSession(run, sessionId) {
+	return run.piSessionId !== void 0 && run.piSessionId === sessionId;
+}
+/** Whether the session handed this run to a workflow session of its own: it lists the run but does not own it. */
+function runLaunchedBySession(run, sessionId) {
+	return run.launcherSessionId !== void 0 && run.launcherSessionId === sessionId && !runBelongsToSession(run, sessionId);
+}
+function parseTime(value) {
+	if (value === void 0) return 0;
+	const time = Date.parse(value);
+	return Number.isFinite(time) ? time : 0;
+}
+const STAGE_ORDER = {
+	running: 0,
+	error: 1,
+	completed: 2
+};
+/**
+* Whether a run still belongs in the view.
+*
+* Only errored runs age out here, and slowly: everything else a session
+* started stays until the engine forgets the run itself.
+*/
+function withinRetention(run, now) {
+	if (run.stage !== "error") return true;
+	return now - (parseTime(run.finishedAt) || parseTime(run.startedAt)) < WORKFLOW_ERROR_RETENTION_MS;
+}
+/**
+* When a run last moved, which is what orders it within its group.
+*
+* A running run has only its start; a settled one is ordered by when it
+* settled, because a list kept for the whole session is read as a history and
+* two runs started together can finish an hour apart.
+*/
+function lastMovedAt(run) {
+	return run.stage === "running" ? parseTime(run.startedAt) : parseTime(run.finishedAt) || parseTime(run.startedAt);
+}
+/**
+* Running runs first, then errored (recovery acts on them), then finished;
+* newest first within a group, and each group capped on its own.
+*/
+function presentWorkflowRuns(runs, now) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const run of runs) {
+		if (!withinRetention(run, now)) continue;
+		const group = groups.get(run.stage);
+		if (group) group.push(run);
+		else groups.set(run.stage, [run]);
+	}
+	return [...groups.entries()].sort(([left], [right]) => STAGE_ORDER[left] - STAGE_ORDER[right]).flatMap(([, group]) => group.sort((left, right) => lastMovedAt(right) - lastMovedAt(left)).slice(0, 24));
+}
+//#endregion
+//#region src/services/serverLaunch/index.ts
+/** Beside the run's own files, so the run's artifacts list and its deletion both include it. */
+const RUN_LOG_FILENAME = "engine.log";
+/** Exit codes a run ends with when nothing went wrong: finished, or skipped by its triggers. */
+const SUCCESS_EXIT_CODES = /* @__PURE__ */ new Set([0, 2]);
+/** Lines kept before a run has a directory to write them to. */
+const PENDING_LINE_LIMIT = 500;
+/** How long closing a session waits for its in-process runs to stop. */
+const STOP_TIMEOUT_MS = 1e4;
+const SESSION_CLOSED_REASON = "The session that runs this workflow closed.";
+const RUNNING_STAGE$1 = "running";
+const LAUNCH_REQUESTED_EVENT = "doom_workflow.launch_requested";
+const RUN_STARTED_EVENT = "doom_workflow.run_started";
+const RUN_FINISHED_EVENT = "doom_workflow.run_finished";
+const RUN_FAILED_EVENT = "doom_workflow.run_failed";
+const ENGINE_ERROR_EVENT = "doom_workflow.engine_error";
+const ENGINE_WARNING_EVENT = "doom_workflow.engine_warning";
+const RUN_LOG_FAILED_EVENT = "doom_workflow.run_log_failed";
+const RUN_STOP_FAILED_EVENT = "doom_workflow.run_stop_failed";
+function delay$1(ms) {
+	return new Promise((settle) => {
+		setTimeout(settle, ms).unref?.();
+	});
+}
+function textResult$1(text, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+/**
+* The engine's log for one run, where a reader can find it.
+*
+* The engine writes why a step failed as a log line. Without a logger, those
+* lines exist only in the output the run returns at its end, so a run that is
+* still going, or one read later, has nothing to say about its failures. Here
+* every line goes to the run directory's `engine.log`, and errors and warnings
+* also go to telemetry, with the line as the exception so the text survives.
+*/
+function createRunLog(telemetry) {
+	const pending = [];
+	let file;
+	let writing = Promise.resolve();
+	const reportLogFailure = (error) => telemetry?.recordWarning(RUN_LOG_FAILED_EVENT, error) ?? Promise.resolve();
+	const append = (line) => {
+		if (file === void 0) {
+			pending.push(line);
+			if (pending.length > PENDING_LINE_LIMIT) pending.shift();
+			return;
+		}
+		const target = file;
+		writing = writing.then(() => fs.promises.appendFile(target, `${line}\n`, "utf8")).catch(reportLogFailure);
+	};
+	return {
+		logger: {
+			info: (message) => append(withoutAnsi(message)),
+			warn: (message) => {
+				const line = withoutAnsi(message);
+				append(line);
+				telemetry?.recordWarning(ENGINE_WARNING_EVENT, new Error(line.trim()));
+			},
+			error: (message) => {
+				const line = withoutAnsi(message);
+				append(line);
+				telemetry?.recordError(ENGINE_ERROR_EVENT, new Error(line.trim()), {}, { includeException: true });
+			}
+		},
+		attach(target) {
+			file = target;
+			const held = pending.splice(0);
+			if (held.length === 0) return;
+			writing = writing.then(() => fs.promises.appendFile(target, held.map((line) => `${line}\n`).join(""), "utf8")).catch(reportLogFailure);
+		},
+		flushed: () => writing
+	};
+}
+/**
+* Runs workflows inside the Po server for one session.
+*
+* It is the same launch the Pi extension runs, through the same executor:
+* the same Agiflow checks, capacity limit and runner check, and the same
+* answer once the run registers. What the server adds is where the run
+* happens, in this process with the host's step executor, and what it keeps:
+* each run's engine log, telemetry for its start and end, a notice when a run
+* fails after its launch already answered, and a stop for every run still
+* going when the session closes.
+*/
+function createServerLauncher(dependencies) {
+	const { feature, telemetry } = dependencies;
+	const active = /* @__PURE__ */ new Map();
+	let closing = false;
+	const stopRun = async (run) => {
+		if (run.stopRequested) return;
+		try {
+			const record = run.registration ?? (run.target ? await feature.registry.readRunByKey(run.target.workspace, RUNNING_STAGE$1, run.target.runKey) : void 0);
+			if (!record || !record.runId || run.target && "env" in record && record.env?.["PI_SESSION_ID"] !== dependencies.sessionId) return;
+			await feature.registry.requestStop(record.workspace, record.runKey, SESSION_CLOSED_REASON, record.runId);
+			run.stopRequested = true;
+		} catch (error) {
+			if (error instanceof Error && ("code" in error && error.code === "ENOENT" || error.message.startsWith("Workflow run not found: "))) return;
+			await telemetry?.recordWarning(RUN_STOP_FAILED_EVENT, error);
+		}
+	};
+	const runInProcess = async (input) => {
+		const launchId = input.env?.[WORKFLOW_LAUNCH_ID_ENV];
+		if (launchId === void 0) throw new Error("An in-process launch needs its launch id.");
+		const log = createRunLog(telemetry);
+		const run = { settled: Promise.resolve() };
+		active.set(launchId, run);
+		const runner = input.runner ?? input.cliAgent;
+		const execution = (async () => {
+			try {
+				const result = await feature.createRunService({ logger: log.logger }).run({
+					...input,
+					...runner === void 0 ? {} : { runner },
+					skipLaunch: true,
+					onRegistered: (registration) => {
+						run.registration = registration;
+						if (closing) stopRun(run);
+						log.attach(path.join(registration.runDir, RUN_LOG_FILENAME));
+						telemetry?.recordEvent(RUN_STARTED_EVENT, { outcome: "started" });
+						dependencies.onRunsChanged?.();
+					}
+				});
+				if (SUCCESS_EXIT_CODES.has(result.exitCode)) {
+					telemetry?.recordEvent(RUN_FINISHED_EVENT, {
+						outcome: "success",
+						exit_code: result.exitCode
+					});
+					return textResult$1(withoutAnsi(result.output) || "Workflow completed.");
+				}
+				const tail = withoutAnsi(result.output).trim().split("\n").slice(-20).join("\n");
+				telemetry?.recordError(RUN_FAILED_EVENT, new Error(tail || `The workflow exited with code ${String(result.exitCode)}.`), { exit_code: result.exitCode }, { includeException: true });
+				return textResult$1(`Workflow failed (exit code ${String(result.exitCode)}):\n\n${withoutAnsi(result.output)}`, true);
+			} catch (error) {
+				telemetry?.recordError(RUN_FAILED_EVENT, error, { outcome: "error" }, { includeException: true });
+				throw error;
+			} finally {
+				await log.flushed();
+				active.delete(launchId);
+				dependencies.onRunsChanged?.();
+			}
+		})();
+		run.settled = execution.then(() => void 0, () => void 0);
+		return execution;
+	};
+	const executor = createWorkflowLaunchExecutor({
+		environment: dependencies.environment,
+		activeRunCount: async () => active.size,
+		...dependencies.rejectRunner === void 0 ? {} : { rejectRunner: dependencies.rejectRunner },
+		runTool: { execute: runInProcess },
+		trackPendingRun: (pending) => pending,
+		findLaunchedRun: async ({ launchId }) => {
+			const registration = active.get(launchId)?.registration;
+			if (registration === void 0) return void 0;
+			return feature.registry.readRunByKey(registration.workspace, RUNNING_STAGE$1, registration.runKey);
+		},
+		onLateFailure: (error) => {
+			const detail = error instanceof Error ? error.message : String(error);
+			dependencies.notify(`Workflow launch failed after it was reported started.\n${detail}`, "warning");
+		},
+		onLaunch: () => {
+			telemetry?.recordEvent(LAUNCH_REQUESTED_EVENT, { outcome: "requested" });
+			dependencies.onRunsChanged?.();
+		},
+		...dependencies.launchAckPollMs === void 0 ? {} : { launchAckPollMs: dependencies.launchAckPollMs },
+		...dependencies.launchAckTimeoutMs === void 0 ? {} : { launchAckTimeoutMs: dependencies.launchAckTimeoutMs }
+	});
+	const context = { sessionManager: { getSessionId: () => dependencies.sessionId } };
+	return {
+		launch: (input) => executor.execute(input, context),
+		async recover(target, options) {
+			if (closing) return textResult$1("The workflow session is closing.", true);
+			const tool = dependencies.createRecoverTool({ ownerSessionId: () => dependencies.sessionId });
+			if (options.dryRun) return tool.execute({
+				...target,
+				...options
+			});
+			const key = `recover:${randomUUID()}`;
+			const run = {
+				target,
+				settled: Promise.resolve()
+			};
+			active.set(key, run);
+			const execution = Promise.resolve().then(() => tool.execute({
+				...target,
+				...options
+			})).finally(() => {
+				active.delete(key);
+				dependencies.onRunsChanged?.();
+			});
+			run.settled = execution.then(() => void 0, () => void 0);
+			const find = async () => {
+				const record = await feature.registry.readRunByKey(target.workspace, RUNNING_STAGE$1, target.runKey);
+				return record?.env?.["PI_SESSION_ID"] === dependencies.sessionId ? record : void 0;
+			};
+			(async () => {
+				while (active.has(key)) {
+					if (closing) await stopRun(run);
+					await Promise.race([run.settled, delay$1(dependencies.launchAckPollMs ?? 500)]);
+				}
+			})();
+			const settled = foldOutcome(execution);
+			const ack = await awaitRunAck(settled, find, dependencies.launchAckPollMs, dependencies.launchAckTimeoutMs);
+			if (ack.kind === "settled") {
+				if (ack.outcome.kind === "error") throw ack.outcome.error instanceof Error ? ack.outcome.error : new Error(String(ack.outcome.error));
+				return ack.outcome.result;
+			}
+			if (ack.kind === "record") dependencies.onRunsChanged?.();
+			settled.then((outcome) => {
+				if (outcome.kind === "error" || outcome.result.isError) {
+					const detail = outcome.kind === "error" ? String(outcome.error) : JSON.stringify(outcome.result.content);
+					dependencies.notify(`Workflow recovery failed after acknowledgement.\n${detail}`, "warning");
+				}
+			});
+			return textResult$1(ack.kind === "record" ? `Recovery started for ${ack.record.displayName} in workspace ${target.workspace}. Run key: ${target.runKey}. Started is not succeeded; check workflow_run status before reporting.` : "Recovery requested, not running yet; nothing was cancelled; do not recover it again.");
+		},
+		activeRunCount: () => active.size,
+		async dispose() {
+			closing = true;
+			const runs = [...active.values()];
+			if (runs.length === 0) return;
+			await Promise.all(runs.map(stopRun));
+			await Promise.race([Promise.all(runs.map((run) => run.settled)), delay$1(dependencies.stopTimeoutMs ?? STOP_TIMEOUT_MS)]);
+		}
+	};
+}
+//#endregion
+//#region src/types/webWorkflows.ts
+/** A customRun step ran as this child session. */
+const STEP_SESSION_REF_KIND = "session";
+/** A command step ran in this terminal pane. */
+const STEP_PANE_REF_KIND = "pane";
+const WORKFLOW_RUNS_TYPE = "workflow_runs";
+const WORKFLOW_CATALOG_TYPE = "workflow_catalog";
+//#endregion
+//#region src/services/stepExecutor/index.ts
+const STEP_DISPLAY_ENV = "WORKFLOW_STEP_DISPLAY";
+const WORKFLOW_NAME_ENV = "WORKFLOW_NAME";
+/** The engine's completion signal for terminal agents; a session this host steers never uses it. */
+const WORKFLOW_STATUS_FILE_ENV = "WORKFLOW_STATUS_FILE";
+/** How long a busy step session is left to finish a turn it was given elsewhere, such as web guidance. */
+const BUSY_RETRY_MS = 2e3;
+/** How long ending a step's session may take before the step stops waiting for it. */
+const RELEASE_TIMEOUT_MS = 1e4;
+/** What the runtime says when a turn is already running; the reminder then waits for it. */
+const BUSY_SESSION_PATTERN = /\bbusy\b|LaneBusy/i;
+const STEP_SESSION_STARTED_EVENT = "doom_workflow.step_session_started";
+const STEP_SESSION_FAILED_EVENT = "doom_workflow.step_session_failed";
+const STEP_REMINDER_EVENT = "doom_workflow.step_reminder";
+const STEP_WAITING_EVENT = "doom_workflow.step_waiting";
+const STEP_SESSION_RELEASE_FAILED_EVENT = "doom_workflow.step_session_release_failed";
+const STEP_PANE_FAILED_EVENT = "doom_workflow.step_pane_failed";
+const PO_KEYS = new Set(PO_RUN_CONFIG_KEYS);
+/**
+* A step's `runConfig`, validated against the keys Po understands.
+*
+* A templated step's may also carry keys its command template reads. A key
+* that is neither, such as `majormode`, fails the step rather than running it
+* on workspace defaults. An engine that does not say what its template reads
+* leaves such keys unchecked.
+*/
+function readPoRunConfig(runConfig, template) {
+	const parsed = (template === void 0 ? poRunConfigSchema : poTemplateRunConfigSchema).safeParse(runConfig ?? {});
+	if (!parsed.success) {
+		const problems = parsed.error.issues.map((issue) => `${issue.path.join(".") || "runConfig"}: ${issue.message}`);
+		throw new Error(`Invalid runConfig: ${problems.join("; ")}`);
+	}
+	if (template?.reads !== void 0 && typeof runConfig === "object" && runConfig !== null) {
+		const reads = new Set(template.reads);
+		const unknown = Object.keys(runConfig).filter((key) => !PO_KEYS.has(key) && !reads.has(key));
+		if (unknown.length > 0) throw new Error(`Invalid runConfig: ${unknown.join(", ")} is neither a Po setting nor read by the "${template.name}" command.`);
+	}
+	return parsed.data;
+}
+/** The selection a step session is pinned to; unset keys keep the workspace defaults. */
+function sessionSelection(config) {
+	return {
+		...config.majorMode === void 0 ? {} : { majorMode: config.majorMode },
+		...config.minorModes === void 0 ? {} : { minorModes: config.minorModes },
+		...config.profile === void 0 ? {} : { profile: config.profile },
+		...config.domains === void 0 ? {} : { domains: config.domains }
+	};
+}
+/**
+* What a step adds to the host environment.
+*
+* The step environment is the whole process environment plus the run's own
+* keys. Handing all of it to the session would pin a copy of the host's
+* variables into it; the difference is the part the agent actually needs, such
+* as WORKFLOW_RUN_DIR for the artifacts its prompt names.
+*/
+function stepEnvironment(env, host) {
+	return Object.fromEntries(Object.entries(env).filter(([key, value]) => host[key] !== value));
+}
+function stepSessionName(env, stepName) {
+	const display = env[STEP_DISPLAY_ENV] ?? stepName;
+	const workflow = env[WORKFLOW_NAME_ENV];
+	return workflow ? `${workflow}: ${display}` : display;
+}
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+function delay(ms) {
+	return new Promise((settle) => {
+		setTimeout(settle, ms).unref?.();
+	});
+}
+/** A promise settled by `settle`, so a stop can end a wait that nothing else would. */
+function signal() {
+	let settle = () => void 0;
+	return {
+		promise: new Promise((resolve) => {
+			settle = resolve;
+		}),
+		settle
+	};
+}
+/**
+* An execution that already failed, with why.
+*
+* Returned instead of throwing: the engine reports a thrown start as a spawn
+* error about shells and permissions, while a failed completion keeps this
+* message as the step's reason.
+*/
+function failedExecution(error) {
+	return {
+		completion: Promise.resolve({ error: asError(error) }),
+		stop: async () => void 0
+	};
+}
+/**
+* Runs workflow steps inside Po instead of a shell.
+*
+* A customRun step becomes a child session of the launching session, with the
+* step's major mode, minor modes, profile, domains and model, so its messages
+* stream like any other conversation. Command steps go to their own terminal
+* pane when a launcher is available and fall back to the engine's spawn when
+* it is not.
+*/
+function createStepExecutor(dependencies) {
+	const { sessionService, launchPane, telemetry } = dependencies;
+	const prompt = sessionService.prompt?.bind(sessionService);
+	const readExecutionState = sessionService.readExecutionState?.bind(sessionService);
+	/**
+	* Run a step as a child session of the launching session, with the step's
+	* major mode, minor modes, profile, domains and model.
+	*
+	* The session keeps going until the step has what the workflow needs: each
+	* time the agent settles, the engine's decision gate is asked, and while
+	* the step still lacks a decision (or its declared artifacts) the session is
+	* prompted with the gate's reminder. The gate counts reminders against its
+	* cap, so a stuck agent ends and the engine fails the step.
+	*/
+	async function runSession(request) {
+		if (prompt === void 0) return failedExecution("This host cannot prompt sessions, so this step cannot run here.");
+		if (readExecutionState === void 0) return failedExecution("This host cannot read execution state, so this step cannot run here.");
+		const attributes = {
+			"workflow.step.name": request.stepName,
+			templated: request.template !== void 0
+		};
+		let scope;
+		let name;
+		try {
+			const config = readPoRunConfig(request.runConfig, request.template);
+			if (config.majorMode === void 0) throw new Error("Agent steps require an effective runConfig.majorMode.");
+			name = stepSessionName(request.env, request.stepName);
+			const environment = stepEnvironment(request.env, dependencies.hostEnvironment);
+			delete environment[WORKFLOW_STATUS_FILE_ENV];
+			environment[WORKFLOW_DECISION_STEERING_ENV] = WORKFLOW_DECISION_STEERING_HOST;
+			scope = await sessionService.create({
+				cwd: request.cwd,
+				name,
+				parentSessionId: dependencies.parentSessionId,
+				sessionProvenance: WORKFLOW_STEP_SESSION_PROVENANCE,
+				selection: sessionSelection(config),
+				...config.model === void 0 ? {} : { model: config.model },
+				...config.thinking === void 0 ? {} : { thinking: config.thinking },
+				...request.systemPrompt === void 0 ? {} : { appendSystemPrompt: request.systemPrompt },
+				environment
+			});
+		} catch (error) {
+			telemetry?.recordError(STEP_SESSION_FAILED_EVENT, error, attributes, { includeException: true });
+			return failedExecution(error);
+		}
+		telemetry?.recordEvent(STEP_SESSION_STARTED_EVENT, {
+			...attributes,
+			outcome: "started"
+		});
+		const sessionId = scope.sessionId;
+		const stopped = signal();
+		let stopRequested = false;
+		const decided = () => {
+			const path = request.env[WORKFLOW_DECISION_FILE_ENV];
+			return path !== void 0 && readStepDecision(path) !== void 0;
+		};
+		/**
+		* Give the agent the gate's reminder. A session busy with a turn it was
+		* given elsewhere, like web guidance, is left to finish it, then reminded
+		* unless it decided meanwhile. Undefined means the step needs no more turns.
+		*/
+		const remind = async (message) => {
+			for (;;) try {
+				return await prompt(sessionId, message);
+			} catch (error) {
+				if (!BUSY_SESSION_PATTERN.test(asError(error).message)) throw error;
+				telemetry?.recordEvent(STEP_REMINDER_EVENT, {
+					...attributes,
+					outcome: "busy"
+				});
+				await Promise.race([delay(dependencies.busyRetryMs ?? BUSY_RETRY_MS), stopped.promise]);
+				if (stopRequested || decided()) return void 0;
+			}
+		};
+		/**
+		* End the session once the step is over. Released, it stays readable in the
+		* workflow's view without holding a model, tools and extensions in the host.
+		* A host that cannot release it is asked to abort a stopped turn instead.
+		*/
+		const endSession = async () => {
+			const ending = sessionService.release ? sessionService.release(sessionId) : stopRequested ? sessionService.abort?.(sessionId) ?? Promise.resolve() : Promise.resolve();
+			const timeout = delay(dependencies.releaseTimeoutMs ?? RELEASE_TIMEOUT_MS).then(() => {
+				throw new Error(`The step session did not end within ${String(dependencies.releaseTimeoutMs ?? RELEASE_TIMEOUT_MS)}ms.`);
+			});
+			try {
+				await Promise.race([ending, timeout]);
+			} catch (error) {
+				telemetry?.recordWarning(STEP_SESSION_RELEASE_FAILED_EVENT, error, attributes);
+			}
+		};
+		const completion = async () => {
+			let receipt = await prompt(sessionId, request.prompt);
+			while (receipt !== void 0) {
+				await Promise.race([receipt.settled, stopped.promise]);
+				if (stopRequested) return { exitCode: 0 };
+				let waiting = false;
+				for (;;) {
+					const state = await Promise.race([readExecutionState(sessionId, { parentSessionId: dependencies.parentSessionId }), stopped.promise.then(() => void 0)]);
+					if (stopRequested) return { exitCode: 0 };
+					const snapshot = state?.backgroundWork;
+					const items = snapshot?.items.filter(holdsSettledSession) ?? [];
+					const errors = snapshot?.errors.filter((error) => BACKGROUND_WORK_HOLDING_PROVIDERS.includes(error.provider)) ?? [];
+					if (state?.isIdle && !state.hasPendingMessages && snapshot !== void 0 && items.length === 0 && errors.length === 0) break;
+					if (!waiting) {
+						waiting = true;
+						telemetry?.recordEvent(STEP_WAITING_EVENT, {
+							...attributes,
+							items: items.map((item) => `${item.provider}:${item.id}`).join(", "),
+							errors: errors.map((error) => `${error.provider}: ${error.message}`).join(", "),
+							coordinator: snapshot === void 0 ? "missing" : "available"
+						});
+					}
+					await Promise.race([delay(dependencies.busyRetryMs ?? BUSY_RETRY_MS), stopped.promise]);
+					if (stopRequested) return { exitCode: 0 };
+				}
+				const gate = await gateStepDecision(request.env);
+				if (gate.action === "allow") return { exitCode: 0 };
+				telemetry?.recordEvent(STEP_REMINDER_EVENT, {
+					...attributes,
+					outcome: "sent"
+				});
+				receipt = await remind(gate.message);
+			}
+			return { exitCode: 0 };
+		};
+		return {
+			ref: {
+				kind: STEP_SESSION_REF_KIND,
+				id: sessionId,
+				label: name
+			},
+			completion: completion().catch((error) => ({ error: asError(error) })).then(async (outcome) => {
+				await endSession();
+				return outcome;
+			}),
+			stop: async () => {
+				stopRequested = true;
+				stopped.settle();
+			}
+		};
+	}
+	return {
+		async custom(request) {
+			return runSession({
+				cwd: request.cwd,
+				env: request.env,
+				stepName: request.stepName,
+				runConfig: request.runConfig,
+				prompt: request.customRun.prompt,
+				...request.customRun.systemPrompt === void 0 ? {} : { systemPrompt: request.customRun.systemPrompt }
+			});
+		},
+		async command(request) {
+			const template = request.template;
+			if (template?.inProcess && prompt !== void 0) return runSession({
+				cwd: request.cwd,
+				env: request.env,
+				stepName: request.stepName,
+				runConfig: request.runConfig,
+				template: {
+					name: template.name,
+					...template.reads === void 0 ? {} : { reads: template.reads }
+				},
+				prompt: template.prompt,
+				...template.systemPrompt === void 0 ? {} : { systemPrompt: template.systemPrompt }
+			});
+			if (launchPane === void 0) return void 0;
+			let pane;
+			try {
+				pane = await launchPane({
+					id: dependencies.createId(),
+					command: request.command,
+					cwd: request.cwd,
+					env: request.env
+				});
+			} catch (error) {
+				telemetry?.recordError(STEP_PANE_FAILED_EVENT, error, { "workflow.step.name": request.stepName }, { includeException: true });
+				return failedExecution(error);
+			}
+			if (pane === void 0) return void 0;
+			return {
+				ref: {
+					kind: STEP_PANE_REF_KIND,
+					id: pane.target,
+					label: request.stepName
+				},
+				completion: pane.completion.then((result) => result, (error) => ({ error: asError(error) })),
+				stop: async () => {
+					await pane.stop();
+				}
+			};
+		}
+	};
+}
+/** The shell a command step runs in, the same one the engine spawns it with. */
+const STEP_SHELL = "/bin/zsh";
+/** Namespace for step pane sockets, apart from whole-run terminal sockets. */
+const STEP_PANE_SOCKET_SCOPE = "po-workflow-steps";
+const PANE_LOG_SUFFIX = ".log";
+const PANE_CAPTURE_COLUMNS = 120;
+const PANE_CAPTURE_ROWS = 40;
+/** Where a finished step pane's last screen is kept: beside the socket that served it. */
+function stepPaneLogPath(socketPath) {
+	return `${socketPath}${PANE_LOG_SUFFIX}`;
+}
+/** The pane's current screen, or undefined once there is no pane left to read. */
+async function lastScreen(service, key) {
+	try {
+		const viewer = await service.attach(key, PANE_CAPTURE_COLUMNS, PANE_CAPTURE_ROWS);
+		const lines = await viewer.snapshot();
+		viewer.detach();
+		return `${lines.join("\n")}\n`;
+	} catch {
+		return;
+	}
+}
+/**
+* Opens each command step in its own RMUX pane, through workflow-mcp's terminal host.
+*
+* The pane gets the step's whole environment, which is what lets an agent's
+* Stop hook end an interactive step through WORKFLOW_STATUS_FILE. A unix
+* socket serves the pane to the run terminal in any scope; the socket path is
+* the pane's target. When the step ends or is stopped, its last screen is kept
+* beside the socket and the pane is released, whatever fails on the way.
+*/
+function createNativeStepPaneLauncher(service = new NativeTerminalService(), telemetry) {
+	const report = (stage) => (error) => telemetry?.recordWarning(STEP_PANE_FAILED_EVENT, error, { stage }) ?? Promise.resolve();
+	return async (request) => {
+		if (!await service.available()) return void 0;
+		await service.spawn({
+			command: STEP_SHELL,
+			args: ["-c", request.command],
+			cwd: request.cwd,
+			env: { ...request.env },
+			runKey: request.id
+		});
+		const target = terminalSocketPath(STEP_PANE_SOCKET_SCOPE, request.id);
+		let server;
+		try {
+			server = await serveNativeTerminal({
+				service,
+				runKey: request.id,
+				socketPath: target
+			});
+		} catch (error) {
+			await service.kill(request.id).catch(report("kill"));
+			throw error;
+		}
+		let finishing;
+		const finish = () => finishing ??= (async () => {
+			let screen;
+			try {
+				screen = await lastScreen(service, request.id);
+				if (screen !== void 0) await fs.promises.writeFile(stepPaneLogPath(target), screen, "utf8");
+			} catch (error) {
+				await report("keep-screen")(error);
+			} finally {
+				await server.close().catch(report("close-socket"));
+				await service.kill(request.id).catch(report("kill"));
+			}
+			return screen;
+		})();
+		return {
+			target,
+			completion: service.ended(request.id).then(async (exitCode) => {
+				const screen = (await finish())?.trimEnd();
+				return screen ? {
+					exitCode,
+					outputTail: screen
+				} : { exitCode };
+			}),
+			stop: async () => {
+				await finish();
+				return true;
+			}
+		};
+	};
+}
+//#endregion
+//#region src/services/webWorkflowCatalog/index.ts
+function unchanged(left, right) {
+	return left !== void 0 && right !== void 0 && left.size === right.size && left.modifiedAt === right.modifiedAt;
+}
+function createWorkflowCatalogReader(deps) {
+	const cache = /* @__PURE__ */ new Map();
+	const detailFor = (path) => {
+		const stamp = deps.stamp(path);
+		const cached = cache.get(path);
+		if (cached && unchanged(cached.stamp, stamp)) return cached.detail;
+		const detail = deps.summarize(path);
+		if (stamp !== void 0) cache.set(path, {
+			stamp,
+			detail
+		});
+		return detail;
+	};
+	return {
+		async read(directory) {
+			return (await deps.list(directory)).map((entry) => {
+				const detail = detailFor(entry.path);
+				return {
+					path: entry.path,
+					relativePath: entry.relativePath,
+					name: entry.name === "" ? entry.relativePath : entry.name,
+					description: entry.description,
+					tags: entry.tags,
+					triggers: detail.triggers,
+					inputs: detail.inputs,
+					jobs: detail.jobs,
+					artifacts: detail.artifacts,
+					...detail.runners === void 0 ? {} : { runners: detail.runners },
+					...detail.commands === void 0 ? {} : { commands: detail.commands },
+					...detail.choices === void 0 ? {} : { choices: detail.choices },
+					...detail.error === void 0 ? {} : { error: detail.error }
+				};
+			});
+		},
+		forget(keep) {
+			for (const path of cache.keys()) if (!keep.has(path)) cache.delete(path);
+		}
+	};
+}
+/** The launchable rows first, then the ones that would not parse, name ordered. */
+function presentWorkflowCatalog(entries) {
+	return [...entries].sort((left, right) => {
+		if (left.error === void 0 !== (right.error === void 0)) return left.error === void 0 ? -1 : 1;
+		return left.name.localeCompare(right.name);
+	});
+}
+//#endregion
+//#region src/services/workflowCatalogDeps/index.ts
+/**
+* Connect the pure catalog projection service to the workflow engine and filesystem.
+*
+* A workflow that parses can still be one Po would fail mid-run, such as
+* a step whose runConfig misspells `majorMode`. The engine's doctor, told the
+* keys Po reads, finds those; its errors mark the workflow as one that
+* cannot launch, in the catalog and at every launch, rather than at the step.
+*/
+function defaultCatalogDeps() {
+	return {
+		list: (directory) => readWorkflowCatalog(directory),
+		summarize: (workflowPath) => {
+			const detail = summarizeWorkflow(workflowPath);
+			if (detail.error !== void 0) return detail;
+			const errors = diagnoseWorkflow(workflowPath, { runConfigKeys: PO_RUN_CONFIG_KEYS }).diagnostics.filter((diagnostic) => diagnostic.level === "error");
+			if (errors.length === 0) return detail;
+			return {
+				...detail,
+				error: errors.map((diagnostic) => diagnostic.location === void 0 ? diagnostic.message : `${diagnostic.location}: ${diagnostic.message}`).join("\n")
+			};
+		},
+		stamp: (workflowPath) => {
+			try {
+				const stats = statSync(workflowPath);
+				return {
+					size: stats.size,
+					modifiedAt: stats.mtimeMs
+				};
+			} catch {
+				return;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/services/workflowFence/index.ts
+const DISPATCHER_AGENT_NAME = "agiflow-dispatcher";
+function resolveDispatcherParentSession(environment) {
+	return readChildProcessContext(environment)?.parentSessionId ?? (environment[SUBAGENT_PARENT_SESSION_ENV]?.trim() || void 0);
+}
+function isWorkflowDispatcherProcess(environment) {
+	if (readChildProcessContext(environment)?.mode === DISPATCHER_AGENT_NAME) return true;
+	return environment.PI_SUBAGENT_CHILD_AGENT === DISPATCHER_AGENT_NAME && Boolean(environment[SUBAGENT_PARENT_SESSION_ENV]?.trim());
+}
+//#endregion
+//#region src/services/stepPaneTerminal/index.ts
+const PROGRESS_FILENAME = "progress.ndjson";
+const NATIVE_LAUNCHER = "native";
+/** Runs whose folded refs are kept between reads; a screen stream reads its run twice a second. */
+const REFS_CACHE_LIMIT = 256;
+const PANE_CAPABILITIES = {
+	readable: true,
+	writable: true,
+	resizable: false
+};
+const PANE_LOG_CAPABILITIES = {
+	readable: true,
+	writable: false,
+	resizable: false,
+	reason: "That step has finished; this is the output it left."
+};
+const SESSION_STEP_REASON = "This step runs as an agent session; its conversation appears here as soon as the session starts.";
+const PANE_GONE_LINE = "The step pane has closed.";
+/**
+* The steps a run is on and its latest pane, folded from its progress log.
+*
+* Later events win, as in the engine's own summary. Steps of a parallel group
+* run at once, so every running step is kept, and the current one is the
+* latest-started step still running. A step that starts again is a new
+* attempt: its previous session or pane is not this attempt's, so the ref is
+* dropped until the new one is recorded. The latest pane is kept after it
+* finishes so a run between steps, or one that has ended, can still show what
+* its last command printed.
+*/
+function stepRefsFrom(events) {
+	const steps = /* @__PURE__ */ new Map();
+	const known = /* @__PURE__ */ new Map();
+	let lastPane;
+	for (const event of events) {
+		if (event.type !== "step" || event.step === void 0) continue;
+		const key = `${event.job}\u0000${event.step}`;
+		const previous = steps.get(key);
+		const running = event.status === "running";
+		const restarted = running && (event.index !== void 0 || previous?.running !== true);
+		if (restarted) steps.delete(key);
+		const ref = event.ref ?? (restarted ? void 0 : previous?.ref);
+		steps.set(key, {
+			running,
+			...ref === void 0 ? {} : { ref }
+		});
+		if (event.ref !== void 0) known.set(event.ref.id, event.ref);
+		if (event.ref?.kind === "pane") lastPane = event.ref;
+	}
+	const running = [...steps.values()].filter((step) => step.running && step.ref !== void 0).map((step) => step.ref);
+	const current = running.at(-1);
+	return {
+		...current === void 0 ? {} : { current },
+		...running.length === 0 ? {} : { running },
+		...lastPane === void 0 ? {} : { lastPane },
+		...known.size === 0 ? {} : { known: [...known.values()] }
+	};
+}
+/**
+* Reads a run's refs, folding its progress log again only when the log changed.
+*
+* Every screen, keystroke and capability check asks for them, and the log grows
+* with every fix loop, so an unchanged file (same size and modification time)
+* answers from the last fold.
+*/
+function createStepRefsReader() {
+	const cache = /* @__PURE__ */ new Map();
+	return (file) => {
+		let stats;
+		try {
+			stats = fs.statSync(file);
+		} catch {
+			return {};
+		}
+		const cached = cache.get(file);
+		if (cached !== void 0 && cached.size === stats.size && cached.mtimeMs === stats.mtimeMs) return cached.refs;
+		let raw;
+		try {
+			raw = fs.readFileSync(file, "utf8");
+		} catch {
+			return {};
+		}
+		const refs = stepRefsFrom(parseWorkflowProgress(raw));
+		cache.delete(file);
+		cache.set(file, {
+			size: stats.size,
+			mtimeMs: stats.mtimeMs,
+			refs
+		});
+		if (cache.size > REFS_CACHE_LIMIT) cache.delete(cache.keys().next().value);
+		return refs;
+	};
+}
+/**
+* Real dependencies: the registry's run directory, and the step executor's pane sockets.
+*
+* A pane is reached through the socket its step was served on, so any scope
+* of the server can read it, and a finished one through the screen kept
+* beside that socket.
+*/
+function createStepPaneTerminalDependencies(registry) {
+	const native = connectNativeTerminal();
+	const readRefs = createStepRefsReader();
+	return {
+		stepRefs: (record) => readRefs(path.join(registry.runDirectoryFor(record), PROGRESS_FILENAME)),
+		paneClient: () => ({
+			capture: (target) => native.snapshot(target, {}).then((lines) => lines.join("\n"), () => void 0),
+			input: (target, text) => native.write(target, text).then(() => true, () => false)
+		}),
+		paneLog: (_record, pane) => fs.promises.readFile(stepPaneLogPath(pane.id), "utf8").catch(() => void 0)
+	};
+}
+/** Removes the screens a run's finished panes left behind, once the run itself is deleted. */
+async function removeStepPaneLogs(refs) {
+	const panes = (refs.known ?? []).filter((ref) => ref.kind === STEP_PANE_REF_KIND);
+	await Promise.all(panes.map((pane) => fs.promises.rm(stepPaneLogPath(pane.id), { force: true })));
+}
+function lastLines(text, count) {
+	const lines = text.replace(/\n+$/, "").split("\n");
+	return count === void 0 ? lines : lines.slice(-count);
+}
+/**
+* A run terminal that follows the step a host executor placed.
+*
+* A run executing in the server has no launcher pane of its own; each command
+* step gets one instead. A request naming a step reads that step's pane, which
+* is how each step of a parallel group gets its own screen and keyboard.
+* Without one it follows the current step. While a customRun step runs, there
+* is no terminal to show, so it says where the agent's messages are. Between
+* steps and after the run, an in-process run shows what its latest command
+* printed. A run delegated to a terminal launcher keeps the engine's facade.
+*/
+function createStepPaneTerminal(facade, dependencies) {
+	const inProcess = (record) => record.launcher?.type === NATIVE_LAUNCHER && record.terminalSocket === void 0;
+	const resolveStep = (target) => {
+		const refs = dependencies.stepRefs(target.record);
+		const isRunning = (ref) => refs.running?.some((candidate) => candidate.id === ref.id) === true;
+		if (target.step !== void 0) {
+			const named = refs.known?.find((ref) => ref.id === target.step);
+			if (named !== void 0) return {
+				ref: named,
+				running: isRunning(named)
+			};
+		}
+		if (refs.current !== void 0) return {
+			ref: refs.current,
+			running: true
+		};
+		if (refs.lastPane !== void 0 && inProcess(target.record)) return {
+			ref: refs.lastPane,
+			running: false
+		};
+	};
+	const readLog = async (record, pane, lines) => {
+		const log = await dependencies.paneLog(record, pane);
+		return log === void 0 ? [PANE_GONE_LINE] : lastLines(log, lines);
+	};
+	return {
+		capabilities(target) {
+			const step = resolveStep(target);
+			if (step === void 0) return facade.capabilities(target.record);
+			if (step.ref.kind === "session") return {
+				readable: false,
+				writable: false,
+				resizable: false,
+				reason: SESSION_STEP_REASON
+			};
+			return step.running ? PANE_CAPABILITIES : PANE_LOG_CAPABILITIES;
+		},
+		async screen(target, options) {
+			const step = resolveStep(target);
+			if (step === void 0) return facade.screen(target.record, options);
+			if (step.ref.kind === "session") return [SESSION_STEP_REASON];
+			if (step.running) {
+				const screen = await dependencies.paneClient(target.record).capture(step.ref.id);
+				if (screen !== void 0) return lastLines(screen, options.lines);
+			}
+			return readLog(target.record, step.ref, options.lines);
+		},
+		async write(target, data) {
+			const step = resolveStep(target);
+			if (step === void 0) return facade.write(target.record, data);
+			if (step.ref.kind !== "pane" || !step.running) throw new Error(PANE_GONE_LINE);
+			if (!await dependencies.paneClient(target.record).input(step.ref.id, data)) throw new Error(PANE_GONE_LINE);
+		},
+		async resize(target, columns, rows) {
+			if (resolveStep(target) !== void 0) return false;
+			return facade.resize(target.record, columns, rows);
+		}
+	};
+}
+//#endregion
+//#region src/services/workflowTerminal/index.ts
+const DEFAULT_REFRESH_MS = 750;
+const DEFAULT_LEASE_MS = 6e4;
+const NOT_HELD = "Another reader holds the keyboard for this run.";
+function createWorkflowTerminalService(deps) {
+	const refreshMs = deps.refreshMs ?? DEFAULT_REFRESH_MS;
+	const leaseMs = deps.leaseMs ?? DEFAULT_LEASE_MS;
+	const screens = /* @__PURE__ */ new Map();
+	const leases = /* @__PURE__ */ new Map();
+	const heldBy = (identity) => {
+		const lease = leases.get(identity);
+		if (lease === void 0) return void 0;
+		if (lease.expiresAt > deps.now()) return lease;
+		leases.delete(identity);
+	};
+	return {
+		async screen(identity, record, lines) {
+			const entry = screens.get(identity) ?? { lines: [] };
+			screens.set(identity, entry);
+			if (entry.inFlight) return entry.lines;
+			if (entry.at !== void 0 && deps.now() - entry.at < refreshMs) return entry.lines;
+			entry.inFlight = deps.terminal.screen(record, { lines });
+			try {
+				entry.lines = await entry.inFlight;
+			} finally {
+				entry.at = deps.now();
+				entry.inFlight = void 0;
+			}
+			return entry.lines;
+		},
+		capabilities(record) {
+			return deps.terminal.capabilities(record);
+		},
+		takeControl(identity, token) {
+			const holder = heldBy(identity);
+			if (holder !== void 0 && holder.token !== token) return false;
+			leases.set(identity, {
+				token,
+				expiresAt: deps.now() + leaseMs
+			});
+			return true;
+		},
+		releaseControl(identity, token) {
+			if (heldBy(identity)?.token === token) leases.delete(identity);
+		},
+		async write(identity, record, token, data) {
+			const holder = heldBy(identity);
+			if (holder === void 0 || holder.token !== token) throw new Error(NOT_HELD);
+			leases.set(identity, {
+				token,
+				expiresAt: deps.now() + leaseMs
+			});
+			await deps.terminal.write(record, data);
+		},
+		async resize(identity, record, token, columns, rows) {
+			const holder = heldBy(identity);
+			if (holder === void 0 || holder.token !== token) throw new Error(NOT_HELD);
+			return deps.terminal.resize(record, columns, rows);
+		},
+		forget(live) {
+			for (const identity of screens.keys()) if (!live.has(identity)) screens.delete(identity);
+			for (const identity of leases.keys()) if (!live.has(identity)) leases.delete(identity);
+		},
+		forgetRun(identity) {
+			screens.delete(identity);
+			leases.delete(identity);
+		}
+	};
+}
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/(backend)/api/workflow/`, so the mount is stated once, by the
+* folder that creates it. The same API answers at all three scopes, because a
+* global contribution cascades into workspace and session; the folder under
+* `workspaces/sessions/` only re-mounts it for a session's own server.
+*
+* This is the one file the routes, the Hono app and the browser all read, so a
+* path cannot move on one side alone. The page used to build the hub's own
+* absolute URL and then rewrite its plugin prefix with String.replace to reach
+* a session, which is exactly the kind of copy that can move by one character
+* without anything noticing.
+*
+* `:workspace` and `:runKey` are Hono's own parameter syntax, because the app
+* registers `path` verbatim.
+*/
+/** One run, which every route below addresses. */
+const RUN = "/runs/:workspace/:runKey";
+/**
+* The artifact route's parameter, as Hono spells a multi-segment match.
+*
+* An artifact is named by its path inside the run directory, so `reports/a.md`
+* is one parameter across two segments. The client's `params` substitution
+* fills a single segment and percent-encodes the slash with it, so the page
+* substitutes this one itself; see the page's `_lib/terminalApi.ts`.
+*/
+const ARTIFACT_NAME_PARAM = ":name{.+}";
+/**
+* The step whose pane a terminal route reads: a step ref's id. Absent, the
+* route follows the run's current step, which is one of a parallel group's.
+*/
+const STEP_TARGET_PARAM = "step";
+var apiRoutes_default = defineApiRoutes({
+	/**
+	* The terminal, as server-sent events.
+	*
+	* `stream: true` gets a URL and no call method: the consumer is the browser's
+	* own `EventSource`, and a relayed call would buffer a stream that never ends.
+	*/
+	screen: {
+		method: "GET",
+		path: `${RUN}/screen/stream`,
+		query: [STEP_TARGET_PARAM],
+		stream: true
+	},
+	control: {
+		method: "POST",
+		path: `${RUN}/control`,
+		response: apiResponse()
+	},
+	keys: {
+		method: "POST",
+		path: `${RUN}/keys`
+	},
+	resize: {
+		method: "POST",
+		path: `${RUN}/resize`,
+		response: apiResponse()
+	},
+	remove: {
+		method: "DELETE",
+		path: RUN,
+		response: apiResponse()
+	},
+	stop: {
+		method: "POST",
+		path: `${RUN}/stop`,
+		response: apiResponse()
+	},
+	/** Guidance for the agent session the running step is in, like steering a Team sub-agent. */
+	steer: {
+		method: "POST",
+		path: `${RUN}/steer`,
+		response: apiResponse()
+	},
+	/**
+	* Launch a workflow into the mounting session's own runtime, which then owns
+	* the run. A dispatcher session reaches its root's session mount through this.
+	*/
+	launch: {
+		method: "POST",
+		path: "/launch",
+		response: apiResponse()
+	},
+	openRunDirectory: {
+		method: "POST",
+		path: `${RUN}/open-directory`,
+		response: apiResponse()
+	},
+	artifacts: {
+		method: "GET",
+		path: `${RUN}/artifacts`,
+		query: ["directory"],
+		response: apiResponse()
+	},
+	/** One artifact: its metadata and text, or its raw bytes under `raw=1`. */
+	artifact: {
+		method: "GET",
+		path: `${RUN}/artifacts/${ARTIFACT_NAME_PARAM}`,
+		query: ["raw", "download"],
+		response: apiResponse()
+	}
+});
+//#endregion
+//#region src/types/webWorkflowTerminal.ts
+/**
+* The wire contract between this package's hub API and its cockpit client:
+* one run's terminal, and the files its run directory holds.
+*
+* Both halves of the cockpit import these names, so the route strings and the
+* event names live here rather than being spelled twice.
+*/
+/**
+* Segment this package's API is mounted under, below /api/plugins/.
+*
+* The same word names `src/extensions/(backend)/api/workflow/`, which is where
+* the build reads the mount for the browser's client, so the two cannot drift.
+* The routes themselves are declared in `apiRoutes.ts`.
+*/
+const WORKFLOW_API_BASE_PATH = "workflow";
+/** The SSE event name the screen stream writes. */
+const WORKFLOW_SCREEN_EVENT = "screen";
+//#endregion
+//#region src/services/workflowHubApi/index.ts
+/** Stages a run can be recorded under, newest first: a live run is the common case. */
+const STAGES = [
+	"running",
+	"error",
+	"completed"
+];
+/** Lines of screen the stream sends, which is a terminal's visible height plus room. */
+const SCREEN_LINES = 48;
+/** How often the stream re-reads; the service coalesces, so this is an upper bound. */
+const STREAM_TICK_MS = 500;
+/** How often a settled run is re-checked before the stream closes itself. */
+const SETTLED_POLL_TICKS = 4;
+/** Bytes of one textual artifact returned as JSON; binary previews use a stream. */
+const MAX_ARTIFACT_BYTES = 524288;
+/** Recorded with a stop the web panel asks for, so the run log says where it came from. */
+const WEB_STOP_REASON = "Stopped from the web workflow panel.";
+/** Path segments a client supplies are names, never paths. */
+const SAFE_SEGMENT = /^[\w.@-]+$/;
+const ARTIFACT_MIME_TYPES = {
+	".aac": "audio/aac",
+	".bmp": "image/bmp",
+	".css": "text/css",
+	".csv": "text/csv",
+	".gif": "image/gif",
+	".htm": "text/html",
+	".html": "text/html",
+	".ico": "image/x-icon",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".js": "text/javascript",
+	".json": "application/json",
+	".jsx": "text/jsx",
+	".log": "text/plain",
+	".m4a": "audio/mp4",
+	".markdown": "text/markdown",
+	".md": "text/markdown",
+	".mov": "video/quicktime",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".oga": "audio/ogg",
+	".ogg": "audio/ogg",
+	".ogv": "video/ogg",
+	".pdf": "application/pdf",
+	".png": "image/png",
+	".sh": "text/x-shellscript",
+	".svg": "image/svg+xml",
+	".toml": "text/toml",
+	".ts": "text/typescript",
+	".tsv": "text/tab-separated-values",
+	".tsx": "text/tsx",
+	".txt": "text/plain",
+	".wav": "audio/wav",
+	".webm": "video/webm",
+	".webp": "image/webp",
+	".xml": "application/xml",
+	".yaml": "text/yaml",
+	".yml": "text/yaml"
+};
+/**
+* One request's JSON body as a plain record.
+*
+* A body that is absent, malformed, or not an object reads as empty rather
+* than failing the route: every field is checked by the route anyway, and a
+* 400 naming the missing field beats a parse error naming nothing.
+*/
+async function jsonBody(context) {
+	const parsed = await context.req.json().catch(() => void 0);
+	return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+/** Rejects anything that could climb out of the registry before a path is built. */
+function isSafeSegment(value) {
+	return value !== "" && value !== "../adapters" && value !== ".." && SAFE_SEGMENT.test(value);
+}
+/**
+* One terminal's identity for caches and leases, stable across stage moves: a
+* run's, or one step's pane in it, which keeps its own screen and keyboard.
+*/
+function runIdentityOf(workspace, runKey, step) {
+	return step === void 0 ? `${workspace}/${runKey}` : `${workspace}/${runKey}#${step}`;
+}
+/** The step a terminal request names, from its query or body; absent follows the current step. */
+function stepOf(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/**
+* This package's HTTP surface: one workflow run's terminal, and the files its
+* run directory holds.
+*
+* Mounted in the hub rather than in a session's server, because a run's
+* terminal belongs to its multiplexer rather than to the session that launched
+* it: any process can read a tmux pane, and the session's own server cannot
+* reach anything more. The routes therefore name a run, never a session.
+*/
+function createWorkflowHubApi(options = {}) {
+	const registry = options.registry ?? new WorkflowRegistryService();
+	const facade = options.terminal ?? new WorkflowTerminalService();
+	const stepPanes = createStepPaneTerminalDependencies(registry);
+	const terminal = createWorkflowTerminalService({
+		terminal: createStepPaneTerminal(facade, stepPanes),
+		now: options.now ?? (() => Date.now())
+	});
+	const app = new Hono();
+	/** The record behind a request, whichever stage it now sits in. */
+	const runOf = async (workspace, runKey) => {
+		if (!isSafeSegment(workspace) || !isSafeSegment(runKey)) return void 0;
+		for (const stage of STAGES) try {
+			return await registry.readRunByKey(workspace, stage, runKey);
+		} catch {}
+	};
+	const missing = (workspace, runKey) => ({ error: `No workflow run '${runKey}' in workspace '${workspace}'.` });
+	app.get(apiRoutes_default.screen.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const step = stepOf(context.req.query(STEP_TARGET_PARAM));
+		const identity = runIdentityOf(workspace, runKey, step);
+		return streamSSE(context, async (stream) => {
+			let settledTicks = 0;
+			let running = true;
+			let latest = record;
+			stream.onAbort(() => {
+				running = false;
+			});
+			while (running) {
+				const current = await runOf(workspace, runKey) ?? record;
+				latest = current;
+				const target = {
+					record: current,
+					...step === void 0 ? {} : { step }
+				};
+				const capabilities = terminal.capabilities(target);
+				const lines = capabilities.readable ? await terminal.screen(identity, target, SCREEN_LINES) : [];
+				const settled = current.stage !== "running";
+				if (settled) settledTicks += 1;
+				const ended = settled && settledTicks >= SETTLED_POLL_TICKS;
+				const event = {
+					lines,
+					capabilities,
+					...ended ? { ended: true } : {}
+				};
+				await stream.writeSSE({
+					event: WORKFLOW_SCREEN_EVENT,
+					data: JSON.stringify(event)
+				});
+				if (ended) break;
+				await stream.sleep(STREAM_TICK_MS);
+			}
+			if (latest.stage !== "running") terminal.forgetRun(identity);
+		});
+	});
+	app.post(apiRoutes_default.control.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const body = await jsonBody(context);
+		const step = stepOf(body.step);
+		const identity = runIdentityOf(workspace, runKey, step);
+		const capabilities = terminal.capabilities({
+			record,
+			...step === void 0 ? {} : { step }
+		});
+		if (body.release === true) {
+			if (typeof body.token === "string") terminal.releaseControl(identity, body.token);
+			return context.json({ held: false });
+		}
+		if (!capabilities.writable) {
+			const refused = {
+				held: false,
+				reason: capabilities.reason
+			};
+			return context.json(refused, 409);
+		}
+		const token = typeof body.token === "string" && body.token !== "" ? body.token : randomUUID();
+		if (!terminal.takeControl(identity, token)) return context.json({
+			held: false,
+			reason: "Another reader holds the keyboard."
+		}, 409);
+		const held = {
+			held: true,
+			token
+		};
+		return context.json(held);
+	});
+	app.post(apiRoutes_default.keys.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const body = await jsonBody(context);
+		if (typeof body.token !== "string" || typeof body.data !== "string") return context.json({ error: "A keystroke needs a control token and its data." }, 400);
+		const step = stepOf(body.step);
+		try {
+			await terminal.write(runIdentityOf(workspace, runKey, step), {
+				record,
+				...step === void 0 ? {} : { step }
+			}, body.token, body.data);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+		return context.body(null, 204);
+	});
+	app.post(apiRoutes_default.resize.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const body = await jsonBody(context);
+		const { token, columns, rows } = body;
+		if (typeof token !== "string" || typeof columns !== "number" || typeof rows !== "number") return context.json({ error: "A resize needs a control token, columns and rows." }, 400);
+		const step = stepOf(body.step);
+		try {
+			const resized = await terminal.resize(runIdentityOf(workspace, runKey, step), {
+				record,
+				...step === void 0 ? {} : { step }
+			}, token, columns, rows);
+			return context.json({ resized });
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+	});
+	app.post(apiRoutes_default.stop.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		if (record.stage !== "running" || record.runId === void 0) return context.json({ error: "Only a running workflow can be stopped." }, 409);
+		try {
+			await registry.requestStop(workspace, runKey, WEB_STOP_REASON, record.runId);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+		return context.json({ requested: true });
+	});
+	app.post(apiRoutes_default.steer.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const body = await jsonBody(context);
+		const message = typeof body.message === "string" ? body.message.trim() : "";
+		if (message === "") return context.json({ error: "Guidance needs a message." }, 400);
+		if (record.stage !== "running") return context.json({ error: "Only a running workflow can be steered." }, 409);
+		const refs = stepPanes.stepRefs(record);
+		const step = typeof body.step === "string" ? body.step : void 0;
+		const current = step === void 0 ? refs.current : (refs.running ?? []).find((candidate) => candidate.id === step);
+		if (current?.kind !== "session") return context.json({ error: "The running step is not an agent session." }, 409);
+		if (options.steer === void 0) return context.json({ error: "Steering is available from the session that launched this run." }, 409);
+		try {
+			await options.steer(current.id, message);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+		return context.json({ delivered: true });
+	});
+	app.post(apiRoutes_default.launch.path, async (context) => {
+		if (options.launch === void 0) return context.json({ error: "Launching needs the mount of a session with a workflow runtime." }, 409);
+		const response = await options.launch(await jsonBody(context));
+		return context.json(response);
+	});
+	app.delete(apiRoutes_default.remove.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		if (record.stage === "running") return context.json({ error: "A running workflow must be stopped before it can be deleted." }, 409);
+		const refs = stepPanes.stepRefs(record);
+		try {
+			fs.rmSync(registry.runDirectoryFor(record), {
+				recursive: true,
+				force: true
+			});
+			await removeStepPaneLogs(refs);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+		return context.json({ deleted: true });
+	});
+	app.post(apiRoutes_default.openRunDirectory.path, async (context) => {
+		if (doomApiCallerFrom(context.req.raw.headers)?.locality !== "local") return context.json({ error: "Opening Finder is only available on the host." }, 403);
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		if (process.platform !== "darwin") return context.json({ error: "Finder is only available on macOS." }, 409);
+		try {
+			const runDir = path.resolve(registry.runDirectoryFor(record));
+			if (!fs.statSync(runDir).isDirectory()) return context.json({ error: "The run directory is not a folder." }, 409);
+			await new Promise((resolve, reject) => {
+				execFile("/usr/bin/open", [
+					"-a",
+					"Finder",
+					runDir
+				], { timeout: 5e3 }, (error) => {
+					if (error) reject(error);
+					else resolve();
+				});
+			});
+			return context.json({ opened: true });
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+	});
+	app.get(apiRoutes_default.artifacts.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const runDir = registry.runDirectoryFor(record);
+		const directory = context.req.query("directory") ?? "";
+		if (resolveInside(runDir, directory) === void 0) return context.json({ error: "That folder is not inside this run." }, 400);
+		try {
+			const body = {
+				runDir,
+				description: record.runDirectory?.description ?? "",
+				artifacts: readArtifacts(runDir, record, directory)
+			};
+			return context.json(body);
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+	});
+	app.get(apiRoutes_default.artifact.path, async (context) => {
+		const workspace = context.req.param("workspace");
+		const runKey = context.req.param("runKey");
+		const record = await runOf(workspace, runKey);
+		if (record === void 0) return context.json(missing(workspace, runKey), 404);
+		const runDir = registry.runDirectoryFor(record);
+		const requested = context.req.param("name");
+		const resolved = resolveInside(runDir, requested);
+		if (resolved === void 0) return context.json({ error: `'${requested}' is not inside this run.` }, 400);
+		if (context.req.query("raw") === "1") return streamArtifact(resolved, requested, context.req.header("range"), context.req.query("download") === "1") ?? context.json({ error: `'${requested}' has not been written.` }, 404);
+		const body = readArtifact(resolved, requested);
+		if (body === void 0) return context.json({ error: `'${requested}' has not been written.` }, 404);
+		return context.json(body);
+	});
+	return app;
+}
+/**
+* A path inside the run directory, or undefined when it points anywhere else.
+*
+* The client supplies this one verbatim, unlike the run key, so it is resolved
+* and then checked rather than trusted: without the check the route would read
+* any file the hub can reach.
+*/
+function resolveInside(runDir, requested) {
+	const resolved = path.resolve(runDir, requested);
+	const root = path.resolve(runDir);
+	if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) return void 0;
+	try {
+		const realRoot = fs.realpathSync(root);
+		let ancestor = resolved;
+		while (!fs.existsSync(ancestor)) {
+			const parent = path.dirname(ancestor);
+			if (parent === ancestor) return void 0;
+			ancestor = parent;
+		}
+		const real = fs.realpathSync(ancestor);
+		if (real !== realRoot && !real.startsWith(`${realRoot}${path.sep}`)) return void 0;
+		return resolved;
+	} catch {
+		return;
+	}
+}
+/** Size and modification time of one path, or undefined when it is not there. */
+function statOf(target) {
+	try {
+		return fs.statSync(target);
+	} catch {
+		return;
+	}
+}
+function stateOf(stats) {
+	if (stats === void 0) return "pending";
+	if (stats.isDirectory()) return "written";
+	return stats.size === 0 ? "empty" : "written";
+}
+function viewOf(runDir, entry) {
+	const target = resolveInside(runDir, entry.path);
+	const stats = target === void 0 ? void 0 : statOf(target);
+	return {
+		...entry,
+		kind: stats?.isDirectory() ? "directory" : entry.kind,
+		state: target === void 0 ? "unreadable" : stateOf(stats),
+		...stats === void 0 ? {} : {
+			size: stats.size,
+			modifiedAt: stats.mtime.toISOString()
+		}
+	};
+}
+/**
+* What the run directory holds: the workflow's own declaration first, then the
+* files nobody declared.
+*
+* The declaration is the point of the folder, so it leads and keeps its order
+* even for entries no job has written yet. The rest follows rather than being
+* hidden: the engine's own context.md and progress log are often exactly what a
+* reader is looking for.
+*/
+function readArtifacts(runDir, record, directory = "") {
+	const declared = (record.runDirectory?.entries ?? []).map((entry) => viewOf(runDir, {
+		path: entry.path,
+		kind: entry.kind,
+		description: entry.description,
+		producedBy: entry["produced-by"] ?? [],
+		declared: true
+	}));
+	const children = declared.filter((entry) => path.posix.dirname(entry.path) === (directory || "."));
+	const claimed = new Set(children.map((entry) => entry.path));
+	const found = fs.readdirSync(path.join(runDir, directory), { withFileTypes: true }).filter((entry) => !claimed.has(path.posix.join(directory, entry.name))).map((entry) => viewOf(runDir, {
+		path: path.posix.join(directory, entry.name),
+		kind: entry.isDirectory() ? "directory" : "file",
+		description: "",
+		producedBy: [],
+		declared: false
+	})).sort((left, right) => left.path.localeCompare(right.path));
+	return [...directory === "" ? declared : children, ...found];
+}
+/** Browser content type inferred from a filename without trusting client input. */
+function artifactMimeType(requested) {
+	return ARTIFACT_MIME_TYPES[path.extname(requested).toLowerCase()] ?? "application/octet-stream";
+}
+function isTextArtifact(mimeType) {
+	return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml";
+}
+/** One artifact's metadata and bounded text, or undefined when it is not readable. */
+function readArtifact(resolved, requested) {
+	const stats = statOf(resolved);
+	if (stats === void 0 || stats.isDirectory()) return void 0;
+	const mimeType = artifactMimeType(requested);
+	let text;
+	if (isTextArtifact(mimeType)) try {
+		const handle = fs.openSync(resolved, "r");
+		try {
+			const buffer = Buffer.alloc(Math.min(stats.size, MAX_ARTIFACT_BYTES));
+			fs.readSync(handle, buffer, 0, buffer.length, 0);
+			text = buffer.toString("utf8");
+		} finally {
+			fs.closeSync(handle);
+		}
+	} catch {
+		return;
+	}
+	return {
+		path: requested,
+		size: stats.size,
+		modifiedAt: stats.mtime.toISOString(),
+		mimeType,
+		...text === void 0 ? {} : { text },
+		truncated: text !== void 0 && stats.size > MAX_ARTIFACT_BYTES
+	};
+}
+/** Streams media with byte-range support so browser audio, video, and PDF controls can seek. */
+function streamArtifact(resolved, requested, rangeHeader, download) {
+	const stats = statOf(resolved);
+	if (stats === void 0 || stats.isDirectory()) return void 0;
+	const mimeType = artifactMimeType(requested);
+	let start = 0;
+	let end = Math.max(0, stats.size - 1);
+	let partial = false;
+	const match = rangeHeader?.match(/^bytes=(\d*)-(\d*)$/);
+	if (match !== null && match !== void 0 && stats.size > 0) {
+		const requestedStart = match[1] === "" ? void 0 : Number(match[1]);
+		const requestedEnd = match[2] === "" ? void 0 : Number(match[2]);
+		if (requestedStart === void 0 && requestedEnd !== void 0) start = Math.max(0, stats.size - requestedEnd);
+		else if (requestedStart !== void 0) {
+			start = requestedStart;
+			end = requestedEnd === void 0 ? end : Math.min(requestedEnd, end);
+		}
+		if (start >= stats.size || start > end) return new Response(null, {
+			status: 416,
+			headers: { "content-range": `bytes */${String(stats.size)}` }
+		});
+		partial = true;
+	}
+	const filename = path.basename(requested).replace(/["\\\r\n]/g, "_");
+	const headers = new Headers({
+		"accept-ranges": "bytes",
+		"content-disposition": `${download || mimeType === "text/html" ? "attachment" : "inline"}; filename="${filename}"`,
+		"content-length": String(stats.size === 0 ? 0 : end - start + 1),
+		"content-type": mimeType,
+		"x-content-type-options": "nosniff"
+	});
+	if (partial) headers.set("content-range", `bytes ${String(start)}-${String(end)}/${String(stats.size)}`);
+	if (stats.size === 0) return new Response(null, {
+		status: 200,
+		headers
+	});
+	const body = Readable.toWeb(fs.createReadStream(resolved, {
+		start,
+		end
+	}));
+	return new Response(body, {
+		status: partial ? 206 : 200,
+		headers
+	});
+}
+/**
+* This package's API, mounted by a session with its runtime's `launch` and by
+* the hub without one.
+*/
+function createWorkflowApi(launch) {
+	return {
+		basePath: WORKFLOW_API_BASE_PATH,
+		start(context) {
+			const steer = context.sessionService?.steer?.bind(context.sessionService);
+			const app = createWorkflowHubApi({
+				...steer === void 0 ? {} : { steer: (sessionId, message) => steer(sessionId, message) },
+				...launch === void 0 ? {} : { launch }
+			});
+			return {
+				fetch: (request) => app.fetch(request),
+				close: () => void 0
+			};
+		}
+	};
+}
+/** The named export a host imports from this package's built hub entry. */
+const api = createWorkflowApi();
+//#endregion
+//#region src/services/workflowNarration/index.ts
+const RUNNING_STAGE = "running";
+const COMPLETED_STAGE = "completed";
+const ERROR_STAGE = "error";
+/**
+* Translate an observed workflow lifecycle transition into generic speech.
+* Voice owns delivery and ignores requests while its minor mode is inactive.
+*/
+function narrateWorkflowTransition(requester, record, previousStage, startedDuringSession) {
+	const newlyLaunched = previousStage === void 0 && startedDuringSession;
+	if (newlyLaunched) requester.narrate(`Workflow launched: ${record.displayName}.`);
+	if (previousStage !== RUNNING_STAGE && !newlyLaunched) return;
+	if (record.stage === COMPLETED_STAGE) requester.narrate(`Workflow succeeded: ${record.displayName}.`);
+	if (record.stage === ERROR_STAGE) requester.narrate(`Workflow failed: ${record.displayName}.`);
+}
+//#endregion
+//#region src/services/workflowResource/index.ts
+function packageRoot() {
+	let directory = path.dirname(fileURLToPath(import.meta.url));
+	while (!existsSync(path.join(directory, "package.json"))) {
+		const parent = path.dirname(directory);
+		if (parent === directory) throw new Error("Workflow package resources are unavailable.");
+		directory = parent;
+	}
+	return directory;
+}
+async function readWorkflowSkill(name) {
+	return readFile(path.join(packageRoot(), name === "workflow-recovery" ? "skills" : "src/prompts", name, "SKILL.md"), "utf8");
+}
+//#endregion
+//#region src/services/workflowSession/index.ts
+/**
+* The workflow session: the child session a launch creates to own and run one
+* workflow, nested under the session that launched it.
+*
+* DESIGN PATTERNS:
+* - Pure presenters for the rail line and the owner agent's brief
+* - A lifecycle driven by the run snapshots the runtime already publishes,
+*   with every host effect injected
+*
+* AVOID:
+* - Posting or releasing on startup: a woken session reports nothing it did
+*   not see change, so opening a stopped session never stops it again
+*/
+const MINUTE_MS = 6e4;
+const HOUR_MS = 36e5;
+/** A failure cause is a line in a notice, not the log; a longer one is cut. */
+const MAX_CAUSE = 1e3;
+const WORKFLOW_FILE_SUFFIX = /\.workflow\.ya?ml$|\.ya?ml$/u;
+/** Whether this session was created to own a workflow run. */
+function isWorkflowSession(context) {
+	return context.sessionContext?.provenance === WORKFLOW_SESSION_PROVENANCE;
+}
+/** The rail name of a workflow session: the catalog's name, else the file's stem. */
+function workflowSessionName(workflowPath, catalogName) {
+	if (catalogName !== void 0 && catalogName.trim() !== "") return catalogName.trim();
+	return basename(workflowPath).replace(WORKFLOW_FILE_SUFFIX, "") || "workflow";
+}
+function isPaused(run) {
+	return run.stage === "running" && (run.executionState === "paused" || run.executionState === "pause_requested");
+}
+function needsAttention(run) {
+	return run.stage === "error" || run.stale === true || isPaused(run);
+}
+function succeeded(run) {
+	return run.stage === "completed" && (run.outcome === void 0 || run.outcome === "success" || run.outcome === "skipped");
+}
+function duration(run) {
+	const start = Date.parse(run.startedAt);
+	const end = run.finishedAt === void 0 ? NaN : Date.parse(run.finishedAt);
+	if (!Number.isFinite(start) || !Number.isFinite(end)) return void 0;
+	const elapsed = Math.max(0, end - start);
+	if (elapsed < MINUTE_MS) return "under a minute";
+	if (elapsed < HOUR_MS) return `${Math.floor(elapsed / MINUTE_MS)}m`;
+	return `${Math.floor(elapsed / HOUR_MS)}h ${String(Math.floor(elapsed % HOUR_MS / MINUTE_MS)).padStart(2, "0")}m`;
+}
+/**
+* The line the rail shows for a workflow session, in place of an idle agent's
+* copy. A failure or pause outranks a run in progress, because it is the one
+* that needs the reader.
+*/
+function workflowSessionActivity(runs) {
+	if (runs.length === 0) return void 0;
+	const failed = runs.find((run) => run.stage === "error");
+	if (failed !== void 0) return {
+		label: `workflow failed · ${failed.failedJob ?? failed.displayName}`,
+		attention: true
+	};
+	const paused = runs.find(isPaused);
+	if (paused !== void 0) return {
+		label: paused.position === void 0 ? "workflow paused" : `workflow paused · ${paused.position.job}`,
+		attention: true
+	};
+	if (runs.find((run) => run.stage === "running" && run.stale === true) !== void 0) return {
+		label: "workflow interrupted",
+		attention: true
+	};
+	const running = runs.find((run) => run.stage === "running");
+	if (running !== void 0) {
+		const where = [running.position?.job, running.position?.step].filter(Boolean).join(" › ");
+		return {
+			label: where === "" ? "workflow · starting" : `workflow · ${where}`,
+			since: running.startedAt
+		};
+	}
+	if (runs.every(succeeded)) return { label: "workflow succeeded" };
+	return {
+		label: `workflow ${runs[0].outcome ?? "ended"}`,
+		attention: true
+	};
+}
+function runState(run) {
+	if (run.stage === "error") return "failed";
+	if (run.stale === true) return "interrupted (its process is gone)";
+	if (isPaused(run)) return "paused";
+	if (run.stage === "running") return "running";
+	return run.outcome ?? "completed";
+}
+/**
+* The owner agent's live brief, added to its system prompt on every turn.
+*
+* Read from the registry each time rather than written once, so it survives a
+* wake and never describes a run that has since moved on.
+*/
+function workflowSessionBrief(runs) {
+	if (runs.length === 0) return "";
+	return [
+		"# Workflow session",
+		"You are the owner agent of this workflow session. It runs the workflow below for the session that launched it, and you troubleshoot it.",
+		...runs.map((run) => {
+			const where = [run.position?.job, run.position?.step].filter(Boolean).join(" › ");
+			const failure = run.stage === "error" ? `; ${run.failedJob === void 0 ? "" : `job '${run.failedJob}' `}failed: ${run.errorMessage ?? "no cause recorded"}` : "";
+			return `- ${run.displayName} (runKey ${run.runKey}, workspace ${run.workspace}): ${runState(run)}${where === "" ? "" : ` at ${where}`}${failure}`;
+		}),
+		"On a workflow error, diagnose it locally and summarize the cause here. Do not wake the launcher to diagnose it, automatically restart it, or diagnose a user-requested stop. When the user or launcher session asks: use workflow_run status with the runKey and workspace for progress, workflow_tools recovery-evidence to read a failure, and load the workflow-recovery skill before workflow_tools recover. Recover, pause, resume or stop a run only when the user asks or the launcher explicitly delegates it through intercom."
+	].join("\n");
+}
+function failureNotice(run) {
+	const cause = (run.errorMessage ?? "the run ended in the error stage").slice(0, MAX_CAUSE);
+	const job = run.failedJob === void 0 ? "" : ` at job "${run.failedJob}"`;
+	return {
+		title: "Workflow failed",
+		body: `Workflow "${run.displayName}" failed${job}: ${cause}. Ask me to diagnose or recover it.`,
+		level: "error"
+	};
+}
+function finishNotice(run) {
+	const took = duration(run);
+	if (succeeded(run)) return {
+		title: "Workflow succeeded",
+		body: `Workflow "${run.displayName}" ${run.outcome === "skipped" ? "was skipped" : "succeeded"}${took === void 0 ? "" : ` in ${took}`}.`,
+		level: "info"
+	};
+	return {
+		title: "Workflow ended",
+		body: `Workflow "${run.displayName}" ended: ${run.outcome ?? "no outcome recorded"}. Ask me to look into it.`,
+		level: "error"
+	};
+}
+const identity = (run) => `${run.workspace}/${run.runKey}`;
+/**
+* What a workflow session does as its runs move: keep the rail line current,
+* post a notice when a handed-off run fails or finishes, and ask its parent to
+* release it after an untouched success.
+*
+* "Untouched" means no run ever needed attention and nobody started a turn
+* here. A session you are reading or troubleshooting stays live until you
+* remove it.
+*/
+function createWorkflowSessionLifecycle(deps) {
+	const stages = /* @__PURE__ */ new Map();
+	let seeded = false;
+	let attention = false;
+	let engaged = false;
+	let requested = false;
+	let disposed = false;
+	let stopWaiting;
+	const releasable = (runs) => deps.parentSessionId !== void 0 && !attention && !engaged && !disposed && runs.length > 0 && runs.every(succeeded) && runs.some((run) => run.launcherSessionId === deps.parentSessionId);
+	const requestRelease = async (runs) => {
+		const parent = deps.parentSessionId;
+		if (parent === void 0 || requested || deps.requestRelease === void 0 || !releasable(runs)) return;
+		if (!await deps.isIdle() || disposed) return;
+		requested = true;
+		const runKeys = runs.map((run) => run.runKey);
+		if (deps.requestRelease(parent, runKeys)) return;
+		stopWaiting = deps.onPeerReady?.((peer) => {
+			if (peer !== parent) return;
+			stopWaiting?.();
+			stopWaiting = void 0;
+			if (releasable(runs)) deps.requestRelease?.(parent, runKeys);
+		});
+	};
+	return {
+		async observe(runs) {
+			if (disposed) return;
+			deps.publishActivity?.(workflowSessionActivity(runs));
+			if (runs.some(needsAttention)) attention = true;
+			if (!seeded) {
+				for (const run of runs) stages.set(identity(run), run.stage);
+				seeded = true;
+				return;
+			}
+			let finished = false;
+			for (const run of runs) {
+				const previous = stages.get(identity(run));
+				stages.set(identity(run), run.stage);
+				if (previous === run.stage || run.launcherSessionId === void 0) continue;
+				if (run.stage === "error") await deps.postNotice(failureNotice(run));
+				else if (run.stage === "completed") {
+					await deps.postNotice(finishNotice(run));
+					finished = true;
+				}
+			}
+			if (finished) await requestRelease(runs);
+		},
+		agentStarted() {
+			engaged = true;
+		},
+		dispose() {
+			disposed = true;
+			stopWaiting?.();
+			stopWaiting = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/services/workflowWatcher/index.ts
+const { parser } = createEmbeddedWorkflowFeature();
+/**
+* Read the durable workflow registry once.
+*
+* The registry is an initial snapshot only. Live delivery belongs to the
+* session lifecycle and is routed through the host-owned direct event bus.
+*/
+function readWorkflowRuns(options = {}) {
+	const environment = options.environment;
+	const homeDir = options.homeDir ?? resolveWorkflowHome({
+		envValue: environment?.["WORKFLOW_MCP_HOME"],
+		homeDir: os.homedir()
+	});
+	const workspacesDir = path.join(homeDir, WORKSPACES_DIR_NAME);
+	const recordCache = /* @__PURE__ */ new Map();
+	const progressCache = /* @__PURE__ */ new Map();
+	const cachedParse = (cache, filePath, parse, empty) => {
+		let stat;
+		try {
+			stat = fs.statSync(filePath);
+		} catch {
+			cache.delete(filePath);
+			return empty;
+		}
+		const cached = cache.get(filePath);
+		if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.value;
+		let raw;
+		try {
+			raw = fs.readFileSync(filePath, "utf8");
+		} catch {
+			cache.delete(filePath);
+			return empty;
+		}
+		const value = parse(raw);
+		cache.set(filePath, {
+			size: stat.size,
+			mtimeMs: stat.mtimeMs,
+			value
+		});
+		return value;
+	};
+	const listDir = (directory) => {
+		try {
+			return fs.readdirSync(directory).sort();
+		} catch {
+			return [];
+		}
+	};
+	const plans = /* @__PURE__ */ new Map();
+	const planFor = (workflowPath) => {
+		const cached = plans.get(workflowPath);
+		if (cached !== void 0) return cached;
+		let plan = [];
+		try {
+			const workflow = parser.parseWorkflowFile(workflowPath);
+			plan = planWorkflowJobs(workflow, parser.resolveJobOrder(workflow.jobs, null));
+		} catch {}
+		plans.set(workflowPath, plan);
+		return plan;
+	};
+	const runs = [];
+	for (const workspace of listDir(workspacesDir)) for (const stage of WORKFLOW_STAGES) {
+		const stageDir = path.join(workspacesDir, workspace, stage);
+		for (const runKey of listDir(stageDir)) {
+			const runDir = path.join(stageDir, runKey);
+			const recordPath = path.join(runDir, RUN_RECORD_FILE_NAME);
+			const progressPath = path.join(runDir, PROGRESS_FILE_NAME);
+			const parsed = cachedParse(recordCache, recordPath, parseWorkflowRunRecord, void 0);
+			if (parsed === void 0) continue;
+			const jobs = foldWorkflowProgress(cachedParse(progressCache, progressPath, parseWorkflowProgress, []), planFor(parsed.view.workflowPath));
+			runs.push({
+				...parsed,
+				view: completeWorkflowRunView(parsed.view, jobs)
+			});
+		}
+	}
+	return runs;
+}
+//#endregion
+//#region src/services/serverRuntime/index.ts
+const SOURCE = "@agimon-ai/po-workflow";
+const WORKFLOW_MODE_ID = "workflow";
+const LIST_TOOL = "list_workflows";
+const LAUNCH_TOOL = "launch_workflow";
+const RUN_TOOL = "workflow_run";
+/** Origin of a request dispatched in process to another mount; nothing resolves it. */
+const IN_PROCESS_ORIGIN = "http://po.local";
+/** A burst of job and step events is published once, this long after the first. */
+const RUNS_PUBLISH_DEBOUNCE_MS = 100;
+/** A notification body's limit; a longer failure is cut to it. */
+const NOTICE_BODY_LIMIT = 4e3;
+/**
+* A launch refused because the workflow needs fixing. The doctor's findings
+* name only a job and a step, so the notice names the workflow and says
+* nothing ran; in a conversation it otherwise reads as part of whatever run
+* was reported just before it.
+*/
+function needsFixingNotice(workflow, error) {
+	return `Workflow "${workflow}" was not launched: it needs fixing.\n${error}`;
+}
+function textResult(text, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+function isLaunchResponse(value) {
+	return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
+}
+function errorOf(value) {
+	return typeof value === "object" && value !== null && "error" in value && typeof value.error === "string" ? value.error : void 0;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** The text of a launch's tool result, as the launch tool and the API report it. */
+function launchResultOf(result) {
+	return textResult(result.content.map((item) => item.type === "text" ? item.text : "").filter((line) => line !== "").join("\n") || "Workflow launch requested.", result.isError === true);
+}
+function callResult(value) {
+	const content = [];
+	if (typeof value === "object" && value !== null && "content" in value && Array.isArray(value.content)) for (const item of value.content) {
+		if (typeof item !== "object" || item === null || !("type" in item)) continue;
+		const record = item;
+		if (record.type === "text" && typeof record.text === "string") content.push({
+			type: "text",
+			text: record.text
+		});
+		else if (record.type === "image" && typeof record.data === "string" && typeof record.mimeType === "string") content.push({
+			type: "image",
+			data: record.data,
+			mimeType: record.mimeType
+		});
+	}
+	if (content.length === 0) content.push({
+		type: "text",
+		text: JSON.stringify(value, null, 2)
+	});
+	return {
+		content,
+		details: value,
+		...typeof value === "object" && value !== null && "isError" in value && value.isError === true ? { isError: true } : {}
+	};
+}
+function untilAborted(work, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolveWork, rejectWork) => {
+		const onAbort = () => rejectWork(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		work.then(resolveWork, rejectWork).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+function createWorkflowServerRuntime(host, serverHost) {
+	if (serverHost.context.directEvents === void 0) throw new Error("Workflow headless facet requires the session direct event bus.");
+	const directEvents = serverHost.context.directEvents;
+	let disposed = false;
+	let runProvider;
+	let narration;
+	let readiness;
+	let ownedReadiness;
+	let ready;
+	const generation = randomUUID();
+	const startupAbort = new AbortController();
+	const sessionStartedAt = Date.now();
+	let narrationReady = false;
+	let previousStages = /* @__PURE__ */ new Map();
+	let activeRunCount = 0;
+	let stepGatePending = false;
+	let serviceContext;
+	const runIdentity = ({ view }) => view.runId ?? `${view.workspace}/${view.runKey}/${view.startedAt}`;
+	const pendingCompletions = /* @__PURE__ */ new Map();
+	const completionBatches = [];
+	const deliveredCompletions = /* @__PURE__ */ new Set();
+	let delivery;
+	let deliveryRetry;
+	const catalogDeps = defaultCatalogDeps();
+	const catalogReader = createWorkflowCatalogReader(catalogDeps);
+	const telemetry = createDoomTelemetry({
+		serviceName: "doom-workflow",
+		packageName: SOURCE,
+		cwd: host.context.cwd,
+		env: host.context.environment,
+		enableLogs: true,
+		enableTraces: true
+	});
+	/** True when this session was created to own one workflow run for the session that launched it. */
+	const workflowSession = isWorkflowSession(host.context);
+	const communication = serverHost.context.sessionCommunication;
+	const lifecycle = workflowSession ? createWorkflowSessionLifecycle({
+		parentSessionId: host.context.sessionContext?.parentSessionId,
+		publishActivity: (activity) => serverHost.context.publishActivity?.(activity),
+		postNotice: async (notice) => {
+			const data = createDoomNotificationEntryData({
+				title: notice.title,
+				body: notice.body,
+				level: notice.level
+			});
+			if (data !== void 0) await host.context.session.appendCustomEntry(DOOM_NOTIFICATION_ENTRY_TYPE, data);
+		},
+		isIdle: async () => {
+			const activity = await host.context.session.activity();
+			return activity.isIdle && !activity.hasPendingMessages;
+		},
+		...communication === void 0 ? {} : {
+			requestRelease: (parent, runKeys) => communication.publish(parent, WORKFLOW_SESSION_RELEASE_TYPE, { runKeys }),
+			onPeerReady: (listener) => communication.onPeerReady(listener)
+		}
+	}) : void 0;
+	const reportLifecycleFailure = (error) => {
+		telemetry.recordWarning("doom_workflow.session_lifecycle_failed", error);
+	};
+	/** This session's runs, published to its panel and counted as its background work. */
+	const publishRuns = (executionContext) => {
+		const records = readWorkflowRuns({ environment: executionContext.environment }).filter((run) => runBelongsToSession(run, executionContext.sessionId) || runLaunchedBySession(run, executionContext.sessionId));
+		const activeItems = records.filter((run) => run.view.stage === "running" && run.view.stale !== true).map((run) => ({
+			id: `${run.view.workspace}/${run.view.runKey}`,
+			sessionId: executionContext.sessionId
+		}));
+		activeRunCount = activeItems.length;
+		const nextStages = /* @__PURE__ */ new Map();
+		for (const record of records) {
+			const { view } = record;
+			const identity = runIdentity(record);
+			const previous = previousStages.get(identity);
+			nextStages.set(identity, view.stage);
+			if (view.stage === "error" && previous !== "error" && runLaunchedBySession(record, executionContext.sessionId)) Promise.resolve(executionContext.client.notify({
+				body: `Workflow "${view.displayName}" failed: ${view.errorMessage ?? "no cause recorded"}. Diagnose it in its workflow-owner session.`,
+				level: "error"
+			})).catch(reportLifecycleFailure);
+			if (!dispatcher && view.stage !== "running" && !(view.stage === "error" && runLaunchedBySession(record, host.context.sessionId)) && !deliveredCompletions.has(identity) && (previous === "running" || previous === void 0 && Date.parse(view.startedAt) >= sessionStartedAt)) {
+				if (!pendingCompletions.has(identity)) pendingCompletions.set(identity, {
+					run: record,
+					attempts: 0
+				});
+			}
+			if (narrationReady && !disposed && narration !== void 0 && runBelongsToSession(record, executionContext.sessionId)) {
+				const startedAt = Date.parse(view.startedAt);
+				narrateWorkflowTransition({ narrate(text) {
+					const request = createNarrationRequest(text);
+					if (request === void 0 || narration === void 0) return;
+					try {
+						Promise.resolve(narration.request(request)).catch((error) => telemetry.recordWarning("doom_workflow.narration_failed", error));
+					} catch (error) {
+						telemetry.recordWarning("doom_workflow.narration_failed", error);
+					}
+				} }, view, previous, previous === void 0 && (!Number.isFinite(startedAt) || startedAt >= sessionStartedAt));
+			}
+		}
+		previousStages = nextStages;
+		const retained = new Map(activeItems.map((item) => [item.id, item]));
+		for (const { run } of pendingCompletions.values()) {
+			const id = `${run.view.workspace}/${run.view.runKey}`;
+			retained.set(id, {
+				id,
+				sessionId: executionContext.sessionId
+			});
+		}
+		runProvider?.update([...retained.values()]);
+		const runs = presentWorkflowRuns(records.map((run) => run.view), Date.now());
+		if (disposed) return false;
+		directEvents.publish(WORKFLOW_RUNS_TYPE, executionContext.sessionId, { runs });
+		lifecycle?.observe(runs).catch(reportLifecycleFailure);
+		return retained.size > 0;
+	};
+	/** Retain terminal work until its batch is durably posted or, when loud, admitted. */
+	const deliverCompletions = (automatic = false) => {
+		if (disposed || delivery !== void 0) return delivery ?? Promise.resolve();
+		delivery = (async () => {
+			const prepared = [];
+			for (const [identity, pending] of pendingCompletions) {
+				if (disposed) return;
+				if (pending.batched || automatic && pending.attempts >= 5) continue;
+				try {
+					const view = pending.run.view;
+					const records = await feature.registry.listRuns(view.workspace);
+					if (disposed) return;
+					const record = records.find((candidate) => candidate.runKey === view.runKey && candidate.stage === view.stage && (view.runId !== void 0 ? candidate.runId === view.runId : candidate.startedAt === view.startedAt));
+					if (record === void 0) throw new Error(`Completion record is unavailable: ${identity}`);
+					const events = record.stage === "completed" ? [] : await readWorkflowProgress(feature.registry.runDirectoryFor(record));
+					if (disposed) return;
+					const startedAt = Date.parse(record.startedAt);
+					const summary = finishedRunSummary(record, summarizeWorkflowProgress(events.filter((event) => !Number.isFinite(startedAt) || !Number.isFinite(Date.parse(event.at)) || Date.parse(event.at) >= startedAt)));
+					const text = isLaunchedRun(record, host.context.sessionId) ? `${summary}\n${launchedRunHint(record)}` : summary;
+					prepared.push({
+						identity,
+						record,
+						text
+					});
+				} catch (error) {
+					if (disposed) return;
+					pending.attempts += 1;
+					await telemetry.recordError("doom_workflow.terminal_delivery_failed", error, { "workflow.pending_terminal_count": pendingCompletions.size });
+				}
+			}
+			for (const quiet of [true, false]) {
+				const members = prepared.filter(({ record }) => (isOwnedDelegatedRun(record, host.context.sessionId) && record.stage !== "error") === quiet);
+				if (members.length === 0) continue;
+				for (const { identity } of members) pendingCompletions.get(identity).batched = true;
+				completionBatches.push({
+					identities: members.map(({ identity }) => identity),
+					outcomes: members.map(({ record }) => record.stage),
+					quiet,
+					requestId: `workflow-finished:${generation}:${members.map(({ identity }) => identity).join(",")}`,
+					message: {
+						type: "workflow-run-finished",
+						text: members.map(({ text }) => text).join("\n\n"),
+						display: true,
+						details: {
+							runIds: members.map(({ identity, record }) => record.runId ?? identity),
+							runs: members.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 } : {}
+							}))
+						}
+					},
+					attempts: 0
+				});
+			}
+			for (const batch of completionBatches.slice()) {
+				if (disposed) return;
+				if (automatic && batch.attempts >= 5) continue;
+				try {
+					if (batch.quiet) {
+						if (host.context.session.appendMessage === void 0) throw new Error("Workflow completion requires informational message support.");
+						await host.context.session.appendMessage(batch.message);
+					} else {
+						if (host.context.session.admitMessage === void 0) throw new Error("Workflow completion requires custom message admission support.");
+						await host.context.session.admitMessage(batch.message, "steer", batch.requestId);
+					}
+					if (disposed) return;
+					completionBatches.splice(completionBatches.indexOf(batch), 1);
+					for (const identity of batch.identities) {
+						deliveredCompletions.add(identity);
+						pendingCompletions.delete(identity);
+					}
+					for (const outcome of batch.outcomes) telemetry.recordEvent("doom_workflow.run_transition", { outcome });
+					publishRuns(host.context);
+				} catch (error) {
+					if (disposed) return;
+					batch.attempts += 1;
+					await telemetry.recordError("doom_workflow.terminal_delivery_failed", error, { "workflow.pending_terminal_count": pendingCompletions.size });
+				}
+			}
+		})().finally(() => {
+			delivery = void 0;
+			if (!disposed && ([...pendingCompletions.values()].some((pending) => !pending.batched && pending.attempts < 5) || completionBatches.some((batch) => batch.attempts < 5)) && deliveryRetry === void 0) {
+				deliveryRetry = setTimeout(() => {
+					deliveryRetry = void 0;
+					deliverCompletions(true);
+				}, 1e3);
+				deliveryRetry.unref?.();
+			}
+		});
+		return delivery;
+	};
+	/** The workflows this session can launch. Runs moving on do not change them, so their events skip this. */
+	const publishCatalog = async (executionContext) => {
+		try {
+			const workflows = presentWorkflowCatalog(await catalogReader.read(executionContext.cwd));
+			if (disposed) return;
+			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
+				cwd: executionContext.cwd,
+				workflows
+			});
+		} catch (error) {
+			if (disposed) return;
+			const warning = error instanceof Error ? error.message : String(error);
+			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
+				cwd: executionContext.cwd,
+				workflows: [],
+				warning
+			});
+		}
+	};
+	const publishLifecycle = async (executionContext) => {
+		publishRuns(executionContext);
+		await deliverCompletions();
+		await publishCatalog(executionContext);
+		return activeRunCount > 0 || pendingCompletions.size > 0;
+	};
+	let runsTimer;
+	let runsAfter;
+	/** Publishes the runs once for a burst of job and step events, which a fix loop can produce by the dozen. */
+	const publishRunsSoon = (executionContext, after) => {
+		if (disposed) return;
+		if (after !== void 0) runsAfter = after;
+		if (runsTimer !== void 0) return;
+		runsTimer = setTimeout(() => {
+			runsTimer = void 0;
+			const done = runsAfter;
+			runsAfter = void 0;
+			try {
+				publishRuns(executionContext);
+				deliverCompletions().then(() => done?.(activeRunCount > 0 || pendingCompletions.size > 0));
+			} catch (error) {
+				telemetry.recordWarning("doom_workflow.publish_failed", error);
+			}
+		}, RUNS_PUBLISH_DEBOUNCE_MS);
+		runsTimer.unref?.();
+	};
+	const sessionService = serverHost.context.sessionService;
+	const featureOptions = sessionService === void 0 ? {} : { stepExecutor: createStepExecutor({
+		sessionService,
+		parentSessionId: host.context.sessionId,
+		hostEnvironment: process.env,
+		launchPane: createNativeStepPaneLauncher(void 0, telemetry),
+		createId: () => `workflow-${randomUUID()}`,
+		telemetry
+	}) };
+	const feature = createEmbeddedWorkflowFeature(featureOptions);
+	const launcher = createServerLauncher({
+		feature,
+		createRecoverTool: (options) => createEmbeddedWorkflowFeature({
+			...featureOptions,
+			registry: feature.registry
+		}).createRecoverTool(options),
+		sessionId: host.context.sessionId,
+		environment: host.context.environment,
+		telemetry,
+		notify: (body, level) => host.context.client.notify({
+			body: body.slice(0, NOTICE_BODY_LIMIT),
+			level
+		}),
+		onRunsChanged: () => publishRunsSoon(host.context)
+	});
+	/**
+	* Why this session cannot run a launch, or undefined when it can.
+	*
+	* The checks the slash command makes through the catalog, made for every
+	* launch whatever asked for it: the launch tool, another session, or the
+	* browser. The workflow must be a file in the repository the launch comes
+	* from, a worktree's own when it runs in one, and its runner, command,
+	* choice, inputs and prompt must be ones it declares.
+	*/
+	const refuseLaunch = (input, where) => {
+		if (typeof input.workflowPath !== "string" || input.workflowPath === "") return "A launch needs a workflowPath.";
+		const workflowPath = resolve(where.cwd, input.workflowPath);
+		const inside = relative(where.repoRoot, workflowPath);
+		if (inside.startsWith("..") || isAbsolute(inside)) return `Workflow ${input.workflowPath} is outside this session's repository, so it cannot be launched here.`;
+		const detail = catalogDeps.summarize(workflowPath);
+		if (detail.error !== void 0) return needsFixingNotice(inside, detail.error);
+		const problems = validateWorkflowLaunch(detail, {
+			inputs: input.inputs ?? {},
+			...input.prompt === void 0 ? {} : { prompt: input.prompt },
+			...(input.runner ?? input.cliAgent) === void 0 ? {} : { runner: input.runner ?? input.cliAgent },
+			...input.command === void 0 ? {} : { command: input.command },
+			...input.choice === void 0 ? {} : { choice: input.choice }
+		});
+		return problems.length === 0 ? void 0 : problems.join("\n");
+	};
+	/**
+	* Run a workflow in this process and answer once it has registered.
+	*
+	* The launch goes through the same executor the Pi extension uses; see
+	* `createServerLauncher` for what the server adds around it.
+	*/
+	const launchHere = async (parameters, where = host.context) => {
+		let input;
+		try {
+			input = feature.runTool.getInputSchema().parse(parameters);
+		} catch (error) {
+			return textResult(`Error: ${errorMessage(error)}`, true);
+		}
+		const refusal = refuseLaunch(input, where);
+		if (refusal !== void 0) return textResult(`Error: ${refusal}`, true);
+		try {
+			return launchResultOf(await launcher.launch({
+				...input,
+				workflowPath: resolve(where.cwd, input.workflowPath)
+			}));
+		} catch (error) {
+			return textResult(`Error: ${errorMessage(error)}`, true);
+		}
+	};
+	/**
+	* Hand a launch to the session that owns this session's runs, through that
+	* session's own mount of this package's API. The owner runs it, so the run
+	* and its step sessions outlive this session, as a dispatcher's launches must.
+	*/
+	const launchIn = async (owner, parameters) => {
+		if (serverHost.context.requestApi === void 0) return textResult(`Error: this host cannot reach session ${owner} to launch the workflow there.`, true);
+		const response = await serverHost.context.requestApi({
+			scope: "session",
+			sessionId: owner
+		}, WORKFLOW_API_BASE_PATH, new Request(`${IN_PROCESS_ORIGIN}${apiRoutes_default.launch.path}`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(parameters)
+		}));
+		const body = await response.json().catch((error) => ({ error: String(error) }));
+		if (response.ok && isLaunchResponse(body)) return textResult(body.text, body.isError === true);
+		return textResult(`Error: session ${owner} did not launch the workflow (${errorOf(body) ?? `HTTP ${String(response.status)}`}).`, true);
+	};
+	/**
+	* A workflow dispatcher launches for its root session, the way a CLI
+	* dispatcher child does: the same markers name it, and the root runs what
+	* it launches. Any other session runs its own launches.
+	*/
+	const dispatcher = isWorkflowDispatcherProcess(host.context.environment);
+	const launchOwner = () => {
+		if (!dispatcher) return void 0;
+		const parent = resolveDispatcherParentSession(host.context.environment);
+		if (parent === void 0) return void 0;
+		const owner = resolveRootSessionId(parent, host.context.environment);
+		return owner === host.context.sessionId ? void 0 : owner;
+	};
+	/** Sessions this one is creating to hand launches to; they count toward its capacity before their runs register. */
+	let creatingWorkflowSessions = 0;
+	/** A host that can create a session and reach its API, for a session that is not itself a workflow session. */
+	const canHandOff = () => !workflowSession && sessionService !== void 0 && serverHost.context.requestApi !== void 0;
+	/**
+	* Create a workflow session under this one and hand it the launch, so the
+	* run, its step sessions and its owner agent live there, nested under this
+	* session in the rail. The launch is checked here first: a refused launch
+	* creates nothing.
+	*/
+	const launchInWorkflowSession = async (parameters, where = host.context) => {
+		let input;
+		try {
+			input = feature.runTool.getInputSchema().parse(parameters);
+		} catch (error) {
+			return textResult(`Error: ${errorMessage(error)}`, true);
+		}
+		const refusal = refuseLaunch(input, where);
+		if (refusal !== void 0) return textResult(`Error: ${refusal}`, true);
+		const self = host.context.sessionId;
+		const running = readWorkflowRuns({ environment: host.context.environment }).filter((run) => run.view.stage === "running" && run.view.stale !== true && (runBelongsToSession(run, self) || runLaunchedBySession(run, self))).length;
+		const ceiling = resolveMaxConcurrent(host.context.environment);
+		if (running + creatingWorkflowSessions >= ceiling) return textResult(`Error: This session is at capacity: ${String(running + creatingWorkflowSessions)}/${String(ceiling)} workflows running.`, true);
+		const workflowPath = resolve(where.cwd, input.workflowPath);
+		creatingWorkflowSessions += 1;
+		let child;
+		try {
+			const name = workflowSessionName(workflowPath, (await catalogReader.read(where.cwd)).find((candidate) => candidate.path === workflowPath)?.name);
+			const config = poTemplateRunConfigSchema.parse(feature.parser.parseWorkflowFile(workflowPath).runConfig ?? {});
+			if (config.majorMode === void 0) throw new Error("Delegated workflows require top-level runConfig.majorMode.");
+			const selection = sessionSelection(config);
+			child = (await sessionService.create({
+				cwd: where.cwd,
+				name,
+				parentSessionId: self,
+				sessionProvenance: WORKFLOW_SESSION_PROVENANCE,
+				selection: {
+					...selection,
+					minorModes: [...(selection.minorModes ?? []).filter((mode) => mode !== WORKFLOW_MODE_ID), WORKFLOW_MODE_ID]
+				}
+			})).sessionId;
+			const result = await launchIn(child, {
+				...parameters,
+				workflowPath,
+				env: {
+					...input.env,
+					[WORKFLOW_LAUNCHER_SESSION_ENV]: self
+				}
+			});
+			if (result.isError === true) {
+				await sessionService.close(child).catch(reportLifecycleFailure);
+				return result;
+			}
+			return textResult(`${result.content.map((item) => item.text).join("\n")}\nRuns in workflow session "${name}" (${child}), nested under this session. Failures notify you here without waking this agent. Its owner diagnoses failures locally, but recovers only on request; delegate to its owner with intercom send to "${child}".`);
+		} catch (error) {
+			if (child !== void 0) await sessionService.close(child).catch(reportLifecycleFailure);
+			return textResult(`Error: ${errorMessage(error)}`, true);
+		} finally {
+			creatingWorkflowSessions -= 1;
+		}
+	};
+	const launch = async (parameters, where) => {
+		const owner = launchOwner();
+		if (owner !== void 0) return launchIn(owner, parameters);
+		return canHandOff() ? launchInWorkflowSession(parameters, where) : launchHere(parameters, where);
+	};
+	/**
+	* A launch another session handed this one. A hand-off from a launcher
+	* carries its stamp and runs here; any other, such as a dispatcher's, goes
+	* through the same routing as a launch made here.
+	*/
+	const launchFromApi = async (parameters) => {
+		const env = parameters.env;
+		const result = typeof env === "object" && env !== null && typeof env["PO_WORKFLOW_LAUNCHER_SESSION_ID"] === "string" ? await launchHere(parameters) : await launch(parameters);
+		publishRunsSoon(host.context);
+		return {
+			text: result.content.map((item) => item.text).join("\n"),
+			...result.isError === true ? { isError: true } : {}
+		};
+	};
+	/**
+	* A workflow session asks to be released after an untouched success. Only
+	* the hub-attached source is trusted, and the registry, not the message,
+	* decides: every run it owns succeeded and one was launched from here.
+	*/
+	const releaseWorkflowSession = async (source) => {
+		if (sessionService?.release === void 0) return;
+		const owned = readWorkflowRuns({ environment: host.context.environment }).filter((run) => runBelongsToSession(run, source));
+		const succeeded = (run) => run.view.stage === "completed" && (run.view.outcome === void 0 || run.view.outcome === "success" || run.view.outcome === "skipped");
+		if (owned.length === 0 || !owned.every(succeeded)) return;
+		if (!owned.some((run) => runLaunchedBySession(run, host.context.sessionId))) return;
+		await sessionService.release(source);
+		telemetry.recordEvent("doom_workflow.session_released", { outcome: "released" });
+	};
+	const stopReleaseRequests = communication?.subscribe(WORKFLOW_SESSION_RELEASE_TYPE, (source) => {
+		releaseWorkflowSession(source).catch(reportLifecycleFailure);
+	});
+	const stopPeerReady = communication?.onPeerReady(() => void 0);
+	let control;
+	let controlDisposers = [];
+	const disposeControl = () => {
+		for (const dispose of controlDisposers.splice(0)) dispose();
+		control?.dispose();
+		control = void 0;
+	};
+	let modeOwner;
+	const modeSelected = () => (host.context.selection.state?.["minor-mode"] ?? []).includes(WORKFLOW_MODE_ID);
+	const modeState = () => {
+		const active = modeSelected();
+		return {
+			activation: active ? "active" : "inactive",
+			condition: ready?.snapshot().state === "failed" ? "failed" : "ready",
+			...active ? { detail: "workflow tools available" } : {},
+			actions: [{
+				id: "activate",
+				enabled: !active,
+				...!active ? {} : { disabledReason: "Workflow mode is active." }
+			}, {
+				id: "deactivate",
+				enabled: active,
+				...active ? {} : { disabledReason: "Workflow mode is inactive." }
+			}]
+		};
+	};
+	const selectMode = async (enabled) => {
+		const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== WORKFLOW_MODE_ID);
+		await host.changeSelection({
+			axis: "state",
+			key: "minor-mode",
+			values: enabled ? [...modes, WORKFLOW_MODE_ID] : modes
+		});
+		modeOwner?.publish();
+	};
+	modeOwner = defineMinorMode({
+		descriptor: {
+			source: SOURCE,
+			id: WORKFLOW_MODE_ID,
+			label: "Workflow",
+			description: "Workflow discovery, launch, inspection, control, and recovery tools.",
+			order: 20,
+			actions: [{
+				id: "activate",
+				label: "Activate",
+				description: "Enable workflow tools for this session.",
+				contexts: ["headless"],
+				parameters: []
+			}, {
+				id: "deactivate",
+				label: "Deactivate",
+				description: "Disable workflow tools without stopping active runs.",
+				contexts: ["headless"],
+				parameters: []
+			}]
+		},
+		state: modeState,
+		async handleAction(_runtime, actionId, _argumentsValue, execution) {
+			execution.signal.throwIfAborted();
+			if (ready?.snapshot().state !== "ready") await waitForReadiness(execution.signal);
+			if (actionId === "activate") {
+				await selectMode(true);
+				return { message: "Workflow mode activated." };
+			}
+			if (actionId === "deactivate") {
+				await selectMode(false);
+				return { message: "Workflow mode deactivated." };
+			}
+			throw new Error(`Unknown workflow mode action: ${actionId}`);
+		}
+	}).createOwner(void 0);
+	let startingControl;
+	const startControl = (executionContext) => {
+		startingControl ??= (async () => {
+			if (control !== void 0) {
+				const ownedControl = control;
+				await publishLifecycle(executionContext);
+				return ownedControl;
+			}
+			if (disposed) throw new Error("Workflow runtime is disposed.");
+			control = feature.createRunControl({ recordFilter: (record) => isSessionRun(record, host.context.sessionId) || isLaunchedRun(record, host.context.sessionId) });
+			const ownedControl = control;
+			const refresh = () => {
+				publishRunsSoon(executionContext, (active) => {
+					if (!active && !modeSelected() && control === ownedControl) disposeControl();
+				});
+			};
+			controlDisposers = [
+				ownedControl.on("runStarted", refresh),
+				ownedControl.on("runUpdated", refresh),
+				ownedControl.on("runFinished", refresh),
+				ownedControl.on("job", refresh),
+				ownedControl.on("step", refresh)
+			];
+			try {
+				await ownedControl.start();
+				if (disposed || control !== ownedControl) throw new Error("Workflow observer was superseded.");
+				await publishLifecycle(executionContext);
+				return ownedControl;
+			} catch (error) {
+				if (control === ownedControl) disposeControl();
+				throw error;
+			}
+		})().finally(() => {
+			startingControl = void 0;
+		});
+		return startingControl;
+	};
+	const waitForReadiness = async (signal) => {
+		signal?.throwIfAborted();
+		if (disposed) throw new Error("Workflow runtime is disposed.");
+		if (ready === void 0) throw new Error("Workflow session initialization has not started.");
+		await ready.wait(signal === void 0 ? void 0 : { signal });
+		if (disposed) throw new Error("Workflow runtime is disposed.");
+	};
+	return {
+		api: [createWorkflowApi(async (parameters) => {
+			await waitForReadiness();
+			return launchFromApi(parameters);
+		})],
+		async onStart() {
+			readiness ??= ownedReadiness = createDoomReadinessCoordinator({ notify: (notice) => {
+				host.context.client.notify({
+					body: `${SOURCE} initialization ${notice.state}: ${notice.error?.message ?? notice.diagnostics.join("; ")}`,
+					level: "warning"
+				});
+			} });
+			ready = readiness.start(SOURCE, generation, async (signal) => {
+				signal.throwIfAborted();
+				await untilAborted(startControl(host.context), AbortSignal.any([signal, startupAbort.signal]));
+				signal.throwIfAborted();
+				if (disposed) throw new Error("Workflow runtime is disposed.");
+				narrationReady = true;
+				return { value: void 0 };
+			});
+			await Promise.allSettled([ready.wait()]);
+			modeOwner?.publish();
+		},
+		services: [
+			(context) => {
+				readiness = readDoomReadinessCoordinator(context);
+				context.inject([DOOM_NARRATION_SERVICE], (serviceContext) => {
+					const service = requireDoomNarrationService(serviceContext);
+					narration = service;
+					return () => {
+						if (narration === service) narration = void 0;
+					};
+				});
+			},
+			serverMinorModes([modeOwner]),
+			(context) => {
+				serviceContext = context;
+				const provider = registerRunProvider(context);
+				runProvider = provider;
+				return () => {
+					provider.dispose();
+					if (serviceContext === context) serviceContext = void 0;
+					if (runProvider === provider) runProvider = void 0;
+				};
+			}
+		],
+		hooks: [
+			{
+				event: "tool_execution_end",
+				handle: async (_event, executionContext) => {
+					await publishLifecycle(executionContext);
+				}
+			},
+			{
+				event: "session_shutdown",
+				handle: disposeControl
+			},
+			{
+				event: "session_start",
+				handle: async () => {
+					if ((workflowSession || dispatcher || host.context.environment.WORKFLOW_MCP_MODE === "on") && !modeSelected()) await selectMode(true);
+				}
+			},
+			{
+				event: "agent_start",
+				handle: () => {
+					lifecycle?.agentStarted();
+				}
+			},
+			{
+				event: "agent_settled",
+				handle: async (_event, execution) => {
+					const environment = execution.environment;
+					if (disposed || stepGatePending || !environment[WORKFLOW_DECISION_FILE_ENV] || environment[WORKFLOW_DECISION_STEERING_ENV] === WORKFLOW_DECISION_STEERING_HOST || environment.PI_SUBAGENT_CHILD) return;
+					stepGatePending = true;
+					try {
+						const activity = await execution.session.activity();
+						if (disposed || !activity.isIdle || activity.hasPendingMessages) return;
+						const snapshot = serviceContext === void 0 ? void 0 : readDoomBackgroundWorkService(serviceContext)?.snapshot(execution.sessionId);
+						if (snapshot === void 0 || snapshot.items.some(holdsSettledSession) || snapshot.errors.some((error) => BACKGROUND_WORK_HOLDING_PROVIDERS.includes(error.provider))) return;
+						const gate = await gateStepDecision(environment);
+						if (disposed || gate.action !== "block") return;
+						if (execution.session.admitPrompt === void 0) throw new Error("This host cannot admit workflow reminders.");
+						await execution.session.admitPrompt(gate.message, "steer");
+					} finally {
+						stepGatePending = false;
+					}
+				}
+			}
+		],
+		resources: [
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "po-author-workflow",
+				kind: "skill",
+				read: () => readWorkflowSkill("po-author-workflow")
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "po-use-workflow",
+				kind: "skill",
+				read: () => readWorkflowSkill("po-use-workflow")
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "workflow-recovery",
+				kind: "skill",
+				read: () => readWorkflowSkill("workflow-recovery")
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "workflow-session",
+				kind: "context",
+				read: (executionContext) => workflowSession ? workflowSessionBrief(presentWorkflowRuns(readWorkflowRuns({ environment: executionContext.environment }).filter((run) => runBelongsToSession(run, executionContext.sessionId)).map((run) => run.view), Date.now())) : ""
+			}
+		],
+		activities: [{
+			when: {
+				state: { "minor-mode": WORKFLOW_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: WORKFLOW_MODE_ID
+				}
+			},
+			name: SOURCE,
+			async start(executionContext) {
+				const reportFailure = (error) => {
+					process.emitWarning(`Could not publish headless workflow state: ${String(error)}`);
+				};
+				const stopFor = (ownedControl) => () => {
+					publishLifecycle(executionContext).then((active) => {
+						if (!active && !modeSelected() && control === ownedControl) disposeControl();
+					}).catch(reportFailure);
+				};
+				return stopFor(await startControl(executionContext));
+			}
+		}],
+		tools: [
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: LIST_TOOL,
+				label: "List Workflows",
+				description: "List workflow definitions in this repository, not existing runs.",
+				promptGuidelines: ["Use list_workflows to discover definitions, not to find an existing run."],
+				parameters: z.toJSONSchema(feature.listWorkflowsTool.getInputSchema()),
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal, _onUpdate, context) {
+					signal?.throwIfAborted();
+					await waitForReadiness(signal);
+					const input = parameters;
+					return callResult(await feature.listWorkflowsTool.execute({
+						...input,
+						directory: input?.directory === void 0 ? context.cwd : typeof input.directory === "string" ? resolve(context.cwd, input.directory) : input.directory
+					}));
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: LAUNCH_TOOL,
+				label: "Launch Workflow",
+				description: "Start a workflow run. Prefer in-process Pi execution with command: \"pi\" when supported; runner: \"codex\" is not an alias for it. A successful launch is not a completed workflow.",
+				promptGuidelines: [
+					"Before launching, inspect the workflow and its imports for commands and interactiveRun choices. Prefer a supported Pi template with inProcess: true, selected explicitly with command: \"pi\" (or a supported in-process \"pi-claude\" command when requested). Only use an external CLI when the user requests it or no in-process option exists.",
+					"command selects the exact template. Without it, runner only matches an exact command name; otherwise each step uses its first command. runner: \"codex\" does not imply command: \"pi\", so pass command explicitly to avoid switching to \"claude\" on later steps.",
+					"Launch returns when a run starts, not when it finishes. Use the exact run key and separate workspace from its launch result for workflow_run status, not Agiflow project or job identifiers.",
+					"Do not relaunch a healthy running workflow merely because it has not completed."
+				],
+				parameters: z.toJSONSchema(feature.runTool.getInputSchema()),
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal, _onUpdate, context) {
+					signal?.throwIfAborted();
+					await waitForReadiness(signal);
+					const input = parameters;
+					return callResult(await launch({
+						...input,
+						...typeof input.workflowPath === "string" ? { workflowPath: resolve(context.cwd, input.workflowPath) } : {}
+					}, context));
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: RUN_TOOL,
+				label: "Workflow Run",
+				description: "Inspect a session-owned workflow by exact run key and separate workspace, or request cooperative control.",
+				promptGuidelines: [
+					"Use workflow_run status for the recorded stage, outcome, position, jobs, and steps. A successful status lookup is not evidence that the workflow completed.",
+					"For a healthy running workflow, summarize the recorded progress. Do not automatically search CLI commands or filesystem logs, relaunch, or diagnose failure merely because it remains running.",
+					"Investigate further when the run reports failure or staleness, or when the user requests diagnostics. Only status, pause, resume, and stop are supported here; stop only on user request.",
+					"Use exact registry runKey and separate workspace from the launch or status result. Agiflow project and job identifiers are not workflow run keys."
+				],
+				parameters: {
+					type: "object",
+					properties: {
+						action: {
+							type: "string",
+							enum: [
+								"status",
+								"pause",
+								"resume",
+								"stop"
+							]
+						},
+						runKey: {
+							type: "string",
+							minLength: 1,
+							description: "Exact registry run key from the launch result, without the workspace prefix. Not an Agiflow job ID."
+						},
+						workspace: {
+							type: "string",
+							description: "Workspace from the launch result, passed separately from runKey."
+						},
+						reason: { type: "string" },
+						expectedRunId: { type: "string" }
+					},
+					required: ["action", "runKey"],
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					signal?.throwIfAborted();
+					await waitForReadiness(signal);
+					const input = parameters;
+					const runs = readWorkflowRuns({ environment: host.context.environment }).filter((run) => (runBelongsToSession(run, host.context.sessionId) || runLaunchedBySession(run, host.context.sessionId)) && run.view.runKey === input.runKey && (input.workspace === void 0 || run.view.workspace === input.workspace));
+					if (runs.length !== 1) return {
+						...callResult({ error: runs.length === 0 ? "No matching workflow run was found in this session. This is a lookup failure, not evidence that the workflow failed. Use the exact runKey and separate workspace from its launch result, not Agiflow job identifiers." : "Specify the workspace for this run key." }),
+						isError: true
+					};
+					const run = runs[0].view;
+					if (input.action === "status") return callResult(run);
+					if (!runBelongsToSession(runs[0], host.context.sessionId)) return callResult({ error: `This run belongs to workflow session ${run.ownerSessionId ?? "unknown"}; pause, resume or stop it there.` });
+					if (!control) return callResult({ error: "Workflow activity is not active." });
+					if (typeof input.expectedRunId !== "string" || input.expectedRunId.length === 0) return callResult({ error: "expectedRunId is required for workflow control." });
+					return callResult(input.action === "pause" ? await control.pause(input.runKey, input.expectedRunId, input.workspace, input.reason) : input.action === "resume" ? await control.resume(input.runKey, input.expectedRunId, input.workspace) : await control.stop(input.runKey, input.expectedRunId, input.workspace, input.reason));
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: WORKFLOW_TOOLS_TOOL_NAME,
+				label: "Workflow Tools",
+				description: "Workflow actions beyond workflow_run: recovery-evidence reads a failed run's durable evidence, including one an earlier session launched; recover resumes it from its active repair in this session.",
+				promptGuidelines: [
+					"Load workflow-recovery and read recovery-evidence before recover; recover is not a fresh launch.",
+					"A recover answer means the replay started, not that it succeeded; verify with workflow_run status.",
+					"Already claimed means another recovery won: do not retry or launch fresh. Never edit issue.md or repair.json."
+				],
+				parameters: z.toJSONSchema(workflowToolsInputSchema),
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					try {
+						signal?.throwIfAborted();
+						await waitForReadiness(signal);
+						const input = workflowToolsInputSchema.parse(parameters);
+						const matches = (await feature.registry.listRuns(input.workspace)).filter((record) => record.runKey === input.runKey && record.stage === "error");
+						if (matches.length > 1) throw new Error("Run key exists in more than one workspace; retry with its workspace.");
+						const record = matches[0];
+						if (!record) throw new Error("No failed workflow run matches this key; do not recover a running or completed workflow.");
+						const owner = record.env?.PI_SESSION_ID;
+						if (input.action === "recover" && owner !== void 0 && owner !== host.context.sessionId && sessionService?.isLive(owner) === true) throw new Error(`Run ${record.runKey} belongs to live workflow session ${owner}; recover it there.`);
+						if (input.action === "recover") return launchResultOf(await launcher.recover({
+							runKey: record.runKey,
+							workspace: record.workspace
+						}, {
+							dryRun: input.dryRun,
+							runner: input.runner
+						}));
+						telemetry.recordEvent("doom_workflow.recovery_evidence_requested", { outcome: "requested" });
+						const sections = [];
+						for (const name of [
+							"changelog.md",
+							"context.md",
+							"progress.ndjson"
+						]) try {
+							const bytes = await readFile(join(feature.registry.runDirectoryFor(record), name));
+							sections.push(`--- ${name} ---\n${bytes.subarray(-65536).toString("utf8")}`);
+						} catch (error) {
+							if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+						}
+						return { content: [{
+							type: "text",
+							text: `Workflow: ${record.displayName} (${record.runKey})\n${sections.length ? "" : "No durable evidence files found.\n"}--- run.json ---\n${JSON.stringify(record, null, 2)}${sections.length ? "\n" + sections.join("\n") : ""}`
+						}] };
+					} catch (error) {
+						return {
+							content: [{
+								type: "text",
+								text: `Error: ${error instanceof Error ? error.message : String(error)}`
+							}],
+							isError: true
+						};
+					}
+				}
+			}
+		],
+		commands: [{
+			when: {
+				state: { "minor-mode": WORKFLOW_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: WORKFLOW_MODE_ID
+				}
+			},
+			name: "workflow-launch",
+			description: "Launch a workflow from a slash command.",
+			async execute(args, execution) {
+				const parsed = parseWorkflowLaunchCommand(args);
+				if ("error" in parsed) {
+					await execution.client.notify({
+						body: parsed.error,
+						level: "error"
+					});
+					return;
+				}
+				try {
+					const entry = resolveWorkflowEntry(await catalogReader.read(execution.cwd), parsed.workflow);
+					if (!entry || entry.error) {
+						await execution.client.notify({
+							body: entry?.error ? needsFixingNotice(entry.name, entry.error) : `Workflow not found: ${parsed.workflow}`,
+							level: "error"
+						});
+						return;
+					}
+					const problems = validateWorkflowLaunch(entry, parsed);
+					if (problems.length > 0) {
+						await execution.client.notify({
+							body: problems.join("\n"),
+							level: "error"
+						});
+						return;
+					}
+					const result = callResult(await launch({
+						workflowPath: entry.path,
+						...parsed.runner === void 0 ? {} : { runner: parsed.runner },
+						...parsed.command === void 0 ? {} : { command: parsed.command },
+						...parsed.choice === void 0 ? {} : { choice: parsed.choice },
+						...Object.keys(parsed.inputs).length === 0 ? {} : { inputs: parsed.inputs },
+						...parsed.prompt === void 0 ? {} : { prompt: parsed.prompt }
+					}, execution));
+					const rendered = result.content.find((item) => item.type === "text");
+					await execution.client.notify({
+						body: rendered?.type === "text" ? rendered.text : "Workflow launch requested.",
+						level: result.isError ? "error" : "info"
+					});
+				} catch (error) {
+					await execution.client.notify({
+						body: String(error),
+						level: "error"
+					});
+				}
+			}
+		}],
+		...dispatcher ? { toolRestrictions: [{ excludedTools: [RUN_TOOL, WORKFLOW_TOOLS_TOOL_NAME] }] } : {},
+		async onDispose() {
+			disposed = true;
+			startupAbort.abort();
+			if (deliveryRetry !== void 0) clearTimeout(deliveryRetry);
+			deliveryRetry = void 0;
+			pendingCompletions.clear();
+			narrationReady = false;
+			narration = void 0;
+			await ownedReadiness?.dispose();
+			disposeControl();
+			lifecycle?.dispose();
+			stopReleaseRequests?.();
+			stopPeerReady?.();
+			if (runsTimer !== void 0) clearTimeout(runsTimer);
+			runsTimer = void 0;
+			runsAfter = void 0;
+			await launcher.dispose();
+			runProvider?.dispose();
+			runProvider = void 0;
+			await telemetry.shutdown();
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/index.server.ts
+var index_server_default$1 = (({ agent, host }) => agent ? createWorkflowServerRuntime(agent, host) : { api: [api] });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot((context) => {
+	const value = index_server_default$1(context);
+	return {
+		value,
+		services: value.services,
+		activities: value.activities,
+		onStart: value.onStart,
+		onStop: value.onStop,
+		onDispose: value.onDispose
+	};
+});
+//#endregion
+//#region src/services/workflowCatalogChannel/index.ts
+/**
+* The workflow catalog channel. Durable state seeds a session once, then
+* session lifecycle events deliver updates over the direct event bus.
+*/
+function createWorkflowCatalogChannel(options = {}) {
+	const reader = createWorkflowCatalogReader(options.deps ?? defaultCatalogDeps());
+	return {
+		frameType: WORKFLOW_CATALOG_TYPE,
+		start(host) {
+			const scopes = /* @__PURE__ */ new Map();
+			const latest = /* @__PURE__ */ new Map();
+			const subscriptions = /* @__PURE__ */ new Map();
+			const publish = (scope, payload) => {
+				latest.set(scope.sessionId, payload);
+				host.publish(scope.sessionId, payload);
+			};
+			const readInitial = async (scope) => {
+				let payload;
+				try {
+					payload = {
+						cwd: scope.cwd,
+						workflows: presentWorkflowCatalog(await reader.read(scope.cwd))
+					};
+				} catch (error) {
+					const warning = error instanceof Error ? error.message : String(error);
+					payload = {
+						cwd: scope.cwd,
+						workflows: [],
+						warning
+					};
+					host.onNotice(`workflow catalog for ${scope.cwd} is unavailable (${warning})`);
+				}
+				if (scopes.get(scope.sessionId) === scope) publish(scope, payload);
+			};
+			return {
+				payloadFor(scope) {
+					return scopes.has(scope.sessionId) ? latest.get(scope.sessionId) : void 0;
+				},
+				sessionAdded(scope) {
+					scopes.set(scope.sessionId, scope);
+					subscriptions.get(scope.sessionId)?.();
+					const unsubscribe = host.directEvents.subscribe(WORKFLOW_CATALOG_TYPE, scope.sessionId, (value) => {
+						if (isWorkflowCatalogPayload(value)) publish(scope, value);
+					}, { replayLatest: true });
+					subscriptions.set(scope.sessionId, unsubscribe);
+					readInitial(scope);
+				},
+				sessionRemoved(sessionId) {
+					subscriptions.get(sessionId)?.();
+					subscriptions.delete(sessionId);
+					scopes.delete(sessionId);
+					latest.delete(sessionId);
+				},
+				close() {
+					for (const unsubscribe of subscriptions.values()) unsubscribe();
+					subscriptions.clear();
+					scopes.clear();
+					latest.clear();
+				}
+			};
+		}
+	};
+}
+function isWorkflowCatalogPayload(value) {
+	return typeof value === "object" && value !== null && typeof value.cwd === "string" && Array.isArray(value.workflows);
+}
+//#endregion
+//#region src/services/workflowsHubChannel/index.ts
+function isWorkflowRunsPayload(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.runs);
+}
+/**
+* The workflow runs data channel. Durable registry state seeds each session
+* once; subsequent updates arrive through the host-owned direct event bus.
+*
+* A session sees the runs it owns and, beside them, the runs it handed to its
+* own workflow sessions, so its Activity rows can open each one. Those come
+* from the owners' updates, routed here by the launcher stamp on each run, and
+* from the registry for workflow sessions that are no longer live.
+*/
+function createWorkflowsChannel(options = {}) {
+	const read = options.read ?? readWorkflowRuns;
+	return {
+		frameType: WORKFLOW_RUNS_TYPE,
+		start(host) {
+			const scopes = /* @__PURE__ */ new Map();
+			const latest = /* @__PURE__ */ new Map();
+			const subscriptions = /* @__PURE__ */ new Map();
+			/** Each session's own runs, as it last reported them. */
+			const own = /* @__PURE__ */ new Map();
+			/** Launcher, then owning workflow session, then the runs one handed the other. */
+			const delegated = /* @__PURE__ */ new Map();
+			const publish = (sessionId) => {
+				if (!scopes.has(sessionId)) return;
+				const handed = [...delegated.get(sessionId)?.values() ?? []].flat();
+				const payload = { runs: presentWorkflowRuns([...own.get(sessionId) ?? [], ...handed], Date.now()) };
+				latest.set(sessionId, payload);
+				host.publish(sessionId, payload);
+			};
+			/** Hands an owner's update to every session that launched one of its runs, or did until now. */
+			const routeToLaunchers = (owner, runs) => {
+				const launchers = /* @__PURE__ */ new Set();
+				for (const run of runs) if (run.launcherSessionId !== void 0 && run.launcherSessionId !== owner) launchers.add(run.launcherSessionId);
+				for (const [launcher, byOwner] of delegated) if (byOwner.has(owner)) launchers.add(launcher);
+				for (const launcher of launchers) {
+					if (!scopes.has(launcher)) continue;
+					const mine = runs.filter((run) => run.launcherSessionId === launcher);
+					const byOwner = delegated.get(launcher) ?? /* @__PURE__ */ new Map();
+					delegated.set(launcher, byOwner);
+					if (mine.length === 0) byOwner.delete(owner);
+					else byOwner.set(owner, mine);
+					publish(launcher);
+				}
+			};
+			return {
+				payloadFor(scope) {
+					return scopes.has(scope.sessionId) ? latest.get(scope.sessionId) : void 0;
+				},
+				sessionAdded(scope) {
+					const sessionId = scope.sessionId;
+					scopes.set(sessionId, scope);
+					const parsed = read({ environment: scope.environment });
+					own.set(sessionId, parsed.filter((run) => runBelongsToSession(run, sessionId)).map((run) => run.view));
+					const byOwner = /* @__PURE__ */ new Map();
+					for (const run of parsed) {
+						if (!runLaunchedBySession(run, sessionId) || run.piSessionId === void 0) continue;
+						byOwner.set(run.piSessionId, [...byOwner.get(run.piSessionId) ?? [], run.view]);
+					}
+					delegated.set(sessionId, byOwner);
+					subscriptions.get(sessionId)?.();
+					const unsubscribe = host.directEvents.subscribe(WORKFLOW_RUNS_TYPE, sessionId, (value) => {
+						if (!isWorkflowRunsPayload(value)) return;
+						own.set(sessionId, value.runs);
+						publish(sessionId);
+						routeToLaunchers(sessionId, value.runs);
+					}, { replayLatest: true });
+					subscriptions.set(sessionId, unsubscribe);
+					publish(sessionId);
+				},
+				sessionRemoved(sessionId) {
+					subscriptions.get(sessionId)?.();
+					subscriptions.delete(sessionId);
+					scopes.delete(sessionId);
+					latest.delete(sessionId);
+					own.delete(sessionId);
+					delegated.delete(sessionId);
+				},
+				close() {
+					for (const unsubscribe of subscriptions.values()) unsubscribe();
+					subscriptions.clear();
+					scopes.clear();
+					latest.clear();
+					own.clear();
+					delegated.clear();
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/_lib/index.server.ts
+var index_server_default = (({ host }) => host.scope === "session" ? {} : {
+	channels: [createWorkflowsChannel, createWorkflowCatalogChannel],
+	api: [api]
+});
+//#endregion
+//#region src/extensions/(backend)/api/workflow/route.server.ts
+var route_server_default$1 = defineRoutedContribution((context) => index_server_default(context).api?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/(backend)/channel/workflow-catalog.server.ts
+var workflow_catalog_server_default = defineChannel(createWorkflowCatalogChannel);
+//#endregion
+//#region src/extensions/(backend)/channel/workflows.server.ts
+var workflows_server_default = defineChannel(createWorkflowsChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/workflow/route.server.ts
+var route_server_default = defineRoutedContribution((context) => context.root.api?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/workflow-launch.server.ts
+var workflow_launch_server_default = defineRoutedContribution((context) => context.root.commands?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.server.ts
+var agent_settled_server_default = defineRoutedContribution((context) => context.root.hooks?.[4], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-start.server.ts
+var agent_start_server_default = defineRoutedContribution((context) => context.root.hooks?.[3], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.ts
+var session_shutdown_server_default = defineRoutedContribution((context) => context.root.hooks?.[1], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-start.server.ts
+var session_start_server_default = defineRoutedContribution((context) => context.root.hooks?.[2], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.ts
+var tool_execution_end_server_default = defineRoutedContribution((context) => context.root.hooks?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/po-author-workflow.server.ts
+var po_author_workflow_server_default = defineRoutedContribution((context) => context.root.resources?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/po-use-workflow.server.ts
+var po_use_workflow_server_default = defineRoutedContribution((context) => context.root.resources?.[1], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/workflow-recovery.server.ts
+var workflow_recovery_server_default = defineRoutedContribution((context) => context.root.resources?.[2], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/workflow-session.server.ts
+var workflow_session_server_default = defineRoutedContribution((context) => context.root.resources?.[3], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool-restriction/dispatcher.server.ts
+var dispatcher_server_default = defineRoutedContribution((context) => context.root.toolRestrictions?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/launch-workflow.server.ts
+var launch_workflow_server_default = defineRoutedContribution((context) => context.root.tools?.[1], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/list-workflows.server.ts
+var list_workflows_server_default = defineRoutedContribution((context) => context.root.tools?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/workflow-run.server.ts
+var workflow_run_server_default = defineRoutedContribution((context) => context.root.tools?.[2], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/workflow-tools.server.ts
+var workflow_tools_server_default = defineRoutedContribution((context) => context.root.tools?.[3], { cardinality: "optional" });
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-workflow",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	global: (context) => ({
+		get api() {
+			return defined([at(route_server_default$1, context)]);
+		},
+		get channels() {
+			return [() => via({ frameType: "workflow_catalog" }, workflow_catalog_server_default()), () => via({ frameType: "workflows" }, workflows_server_default())];
+		}
+	}),
+	workspace: (context) => ({
+		get api() {
+			return defined([at(route_server_default$1, context)]);
+		},
+		get channels() {
+			return [() => via({ frameType: "workflow_catalog" }, workflow_catalog_server_default()), () => via({ frameType: "workflows" }, workflows_server_default())];
+		}
+	}),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get api() {
+				return defined([at(route_server_default$1, context), at(route_server_default, contextSession)]);
+			},
+			get channels() {
+				return [() => via({ frameType: "workflow_catalog" }, workflow_catalog_server_default()), () => via({ frameType: "workflows" }, workflows_server_default())];
+			},
+			get commands() {
+				return defined([via({ name: "workflow-launch" }, at(workflow_launch_server_default, contextSession))]);
+			},
+			get hooks() {
+				return defined([
+					via({ event: "agent_settled" }, at(agent_settled_server_default, contextSession)),
+					via({ event: "agent_start" }, at(agent_start_server_default, contextSession)),
+					via({ event: "session_shutdown" }, at(session_shutdown_server_default, contextSession)),
+					via({ event: "session_start" }, at(session_start_server_default, contextSession)),
+					via({ event: "tool_execution_end" }, at(tool_execution_end_server_default, contextSession))
+				]);
+			},
+			get resources() {
+				return defined([
+					at(po_author_workflow_server_default, contextSession),
+					at(po_use_workflow_server_default, contextSession),
+					at(workflow_recovery_server_default, contextSession),
+					at(workflow_session_server_default, contextSession)
+				]);
+			},
+			get toolRestrictions() {
+				return defined([at(dispatcher_server_default, contextSession)]);
+			},
+			get tools() {
+				return defined([
+					via({ name: "launch_workflow" }, at(launch_workflow_server_default, contextSession)),
+					via({ name: "list_workflows" }, at(list_workflows_server_default, contextSession)),
+					via({ name: "workflow_run" }, at(workflow_run_server_default, contextSession)),
+					via({ name: "workflow_tools" }, at(workflow_tools_server_default, contextSession))
+				]);
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map