@agimon-ai/doompi-workflow 0.0.1-alpha.80 → 0.0.1-alpha.82

package/dist/extensions/server.cjs

@@ -2,23 +2,1510 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_root_server = require("../src/extensions/workspaces/sessions/(backend)/root.server.cjs");
-const require_route_server = require("../src/extensions/(backend)/api/workflow/route.server.cjs");
-const require_workflow_catalog_server = require("../src/extensions/(backend)/channel/workflow-catalog.server.cjs");
-const require_workflows_server = require("../src/extensions/(backend)/channel/workflows.server.cjs");
-const require_route_server$1 = require("../src/extensions/workspaces/sessions/(backend)/api/workflow/route.server.cjs");
-const require_workflow_launch_server = require("../src/extensions/workspaces/sessions/(backend)/command/workflow-launch.server.cjs");
-const require_session_shutdown_server = require("../src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.cjs");
-const require_tool_execution_end_server = require("../src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.cjs");
-const require_doompi_author_workflow_server = require("../src/extensions/workspaces/sessions/(backend)/resource/doompi-author-workflow.server.cjs");
-const require_doompi_use_workflow_server = require("../src/extensions/workspaces/sessions/(backend)/resource/doompi-use-workflow.server.cjs");
-const require_workflow_recovery_server = require("../src/extensions/workspaces/sessions/(backend)/resource/workflow-recovery.server.cjs");
-const require_workflow_server = require("../src/extensions/workspaces/sessions/(backend)/tool-restriction/workflow.server.cjs");
-const require_launch_workflow_server = require("../src/extensions/workspaces/sessions/(backend)/tool/launch-workflow.server.cjs");
-const require_list_workflows_server = require("../src/extensions/workspaces/sessions/(backend)/tool/list-workflows.server.cjs");
-const require_workflow_run_server = require("../src/extensions/workspaces/sessions/(backend)/tool/workflow-run.server.cjs");
-let _agimon_ai_doompi_core_extension_file = require("@agimon-ai/doompi-core/extension-file");
-let _agimon_ai_doompi_core_server_facet = require("@agimon-ai/doompi-core/server-facet");
+const require_workflowTerminal = require("../workflowTerminal-WM_cpxIO.cjs");
+const require_workflowLaunchCommand = require("../workflowLaunchCommand-7y8xg5YF.cjs");
+let _agimon_ai_doompi_core_extensionFile = require("@agimon-ai/doompi-core/extensionFile");
+let node_fs = require("node:fs");
+node_fs = require_workflowTerminal.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_workflowTerminal.__toESM(node_path, 1);
+let _agimon_ai_workflow_mcp = require("@agimon-ai/workflow-mcp");
+let zod = require("zod");
+let node_crypto = require("node:crypto");
+let _agimon_ai_doompi_minor_mode = require("@agimon-ai/doompi-minor-mode");
+let _agimon_ai_doompi_core_serverFacet = require("@agimon-ai/doompi-core/serverFacet");
+let node_os = require("node:os");
+node_os = require_workflowTerminal.__toESM(node_os, 1);
+let node_stream = require("node:stream");
+let hono = require("hono");
+let hono_streaming = require("hono/streaming");
+let _agimon_ai_doompi_core_web = require("@agimon-ai/doompi-core/web");
+//#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.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. */
+function defaultCatalogDeps() {
+	return {
+		list: (directory) => (0, _agimon_ai_workflow_mcp.readWorkflowCatalog)(directory),
+		summarize: (workflowPath) => (0, _agimon_ai_workflow_mcp.summarizeWorkflow)(workflowPath),
+		stamp: (workflowPath) => {
+			try {
+				const stats = (0, node_fs.statSync)(workflowPath);
+				return {
+					size: stats.size,
+					modifiedAt: stats.mtimeMs
+				};
+			} catch {
+				return;
+			}
+		}
+	};
+}
+//#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
+* doompi-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 doompi-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 (0, node_path.resolve)(input.envValue !== void 0 && input.envValue !== "" ? input.envValue : (0, node_path.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;
+}
+function stripAnsi(text) {
+	return text.replace(ANSI_ESCAPE_PATTERN, "").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 = {
+		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]);
+	return {
+		view,
+		...piSessionId === void 0 ? {} : { piSessionId }
+	};
+}
+/**
+* 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);
+		events.push({
+			type,
+			status,
+			job,
+			...step === void 0 ? {} : { step },
+			...index === void 0 ? {} : { index },
+			...total === void 0 ? {} : { total },
+			...reason === void 0 ? {} : { reason },
+			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";
+}
+/**
+* Folds the event log into the current job tree; later events win, so a job
+* that started and later failed reads as failed. Jobs and steps keep the
+* order of their first appearance.
+*/
+function foldWorkflowProgress(events) {
+	const jobs = [];
+	const jobByName = /* @__PURE__ */ new Map();
+	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") {
+			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;
+		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);
+		}
+		step.status = event.status;
+		if (event.reason !== void 0) step.reason = event.reason;
+		if (event.status === "running" && step.startedAt === void 0) step.startedAt = event.at;
+		if (STEP_TERMINAL_STATES.has(event.status)) step.endedAt = event.at;
+	}
+	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 doompi-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;
+}
+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/workflowWatcher/index.ts
+/**
+* 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: node_os.default.homedir()
+	});
+	const workspacesDir = node_path.default.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 = node_fs.default.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 = node_fs.default.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 node_fs.default.readdirSync(directory).sort();
+		} catch {
+			return [];
+		}
+	};
+	const runs = [];
+	for (const workspace of listDir(workspacesDir)) for (const stage of WORKFLOW_STAGES) {
+		const stageDir = node_path.default.join(workspacesDir, workspace, stage);
+		for (const runKey of listDir(stageDir)) {
+			const runDir = node_path.default.join(stageDir, runKey);
+			const recordPath = node_path.default.join(runDir, RUN_RECORD_FILE_NAME);
+			const progressPath = node_path.default.join(runDir, PROGRESS_FILE_NAME);
+			const parsed = cachedParse(recordCache, recordPath, parseWorkflowRunRecord, void 0);
+			if (parsed === void 0) continue;
+			const jobs = cachedParse(progressCache, progressPath, (raw) => foldWorkflowProgress(parseWorkflowProgress(raw)), []);
+			runs.push({
+				...parsed,
+				view: completeWorkflowRunView(parsed.view, jobs)
+			});
+		}
+	}
+	return runs;
+}
+//#endregion
+//#region src/types/webWorkflows.ts
+const WORKFLOW_RUNS_TYPE = "workflow_runs";
+const WORKFLOW_CATALOG_TYPE = "workflow_catalog";
+//#endregion
+//#region src/services/serverRuntime/index.ts
+const SOURCE = "@agimon-ai/doompi-workflow";
+const WORKFLOW_MODE_ID = "workflow";
+const LIST_TOOL = "list_workflows";
+const LAUNCH_TOOL = "launch_workflow";
+const RUN_TOOL = "workflow_run";
+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
+	};
+}
+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 runProvider;
+	const catalogReader = createWorkflowCatalogReader(defaultCatalogDeps());
+	const publishLifecycle = async (executionContext) => {
+		const records = readWorkflowRuns({ environment: executionContext.environment }).filter((run) => runBelongsToSession(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
+		}));
+		runProvider?.update(activeItems);
+		const runs = presentWorkflowRuns(records.map((run) => run.view), Date.now());
+		directEvents.publish(WORKFLOW_RUNS_TYPE, executionContext.sessionId, { runs });
+		try {
+			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
+				cwd: executionContext.cwd,
+				workflows: presentWorkflowCatalog(await catalogReader.read(executionContext.cwd))
+			});
+		} catch (error) {
+			const warning = error instanceof Error ? error.message : String(error);
+			directEvents.publish(WORKFLOW_CATALOG_TYPE, executionContext.sessionId, {
+				cwd: executionContext.cwd,
+				workflows: [],
+				warning
+			});
+		}
+		return activeItems.length > 0;
+	};
+	const feature = (0, _agimon_ai_workflow_mcp.createEmbeddedWorkflowFeature)();
+	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",
+			...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 = (0, _agimon_ai_doompi_minor_mode.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 (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);
+	return {
+		services: [(0, _agimon_ai_doompi_minor_mode.serverMinorModes)([modeOwner]), (context) => {
+			const provider = require_workflowTerminal.registerRunProvider(context);
+			runProvider = provider;
+			return () => {
+				provider.dispose();
+				if (runProvider === provider) runProvider = void 0;
+			};
+		}],
+		hooks: [{
+			event: "tool_execution_end",
+			handle: async (_event, executionContext) => {
+				await publishLifecycle(executionContext);
+			}
+		}, {
+			when: {
+				state: { "minor-mode": WORKFLOW_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: WORKFLOW_MODE_ID
+				}
+			},
+			event: "session_shutdown",
+			handle: disposeControl
+		}],
+		resources: [
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "doompi-author-workflow",
+				kind: "skill",
+				read: () => require_workflowTerminal.readWorkflowSkill("doompi-author-workflow")
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "doompi-use-workflow",
+				kind: "skill",
+				read: () => require_workflowTerminal.readWorkflowSkill("doompi-use-workflow")
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: "workflow-recovery",
+				kind: "skill",
+				read: () => require_workflowTerminal.readWorkflowSkill("workflow-recovery")
+			}
+		],
+		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);
+				};
+				if (control !== void 0) {
+					const ownedControl = control;
+					await publishLifecycle(executionContext);
+					return stopFor(ownedControl);
+				}
+				control = feature.createRunControl({});
+				const ownedControl = control;
+				const refresh = () => {
+					publishLifecycle(executionContext).then((active) => {
+						if (!active && !modeSelected() && control === ownedControl) disposeControl();
+					}).catch(reportFailure);
+				};
+				controlDisposers = [
+					ownedControl.on("runStarted", refresh),
+					ownedControl.on("runUpdated", refresh),
+					ownedControl.on("runFinished", refresh)
+				];
+				try {
+					await ownedControl.start();
+					await publishLifecycle(executionContext);
+					return stopFor(ownedControl);
+				} catch (error) {
+					if (control === ownedControl) disposeControl();
+					throw error;
+				}
+			}
+		}],
+		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 available in this repository.",
+				parameters: zod.z.toJSONSchema(feature.listWorkflowsTool.getInputSchema()),
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					signal?.throwIfAborted();
+					return callResult(await feature.listWorkflowsTool.execute(parameters));
+				}
+			},
+			{
+				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 and return its recorded launch result.",
+				parameters: zod.z.toJSONSchema(feature.runTool.getInputSchema()),
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					signal?.throwIfAborted();
+					return callResult(await feature.runTool.execute(parameters));
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": WORKFLOW_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: WORKFLOW_MODE_ID
+					}
+				},
+				name: RUN_TOOL,
+				label: "Workflow Run",
+				description: "Inspect the status of a workflow run or request cooperative control.",
+				parameters: {
+					type: "object",
+					properties: {
+						action: {
+							type: "string",
+							enum: [
+								"status",
+								"pause",
+								"resume",
+								"stop"
+							]
+						},
+						runKey: {
+							type: "string",
+							minLength: 1
+						},
+						workspace: { type: "string" },
+						reason: { type: "string" },
+						expectedRunId: { type: "string" }
+					},
+					required: ["action", "runKey"],
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, parameters, signal) {
+					signal?.throwIfAborted();
+					const input = parameters;
+					const runs = readWorkflowRuns({ environment: host.context.environment }).filter((run) => runBelongsToSession(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 ? "Workflow run was not found in this session." : "Specify the workspace for this run key." }),
+						isError: true
+					};
+					const run = runs[0].view;
+					if (input.action === "status") return callResult(run);
+					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));
+				}
+			}
+		],
+		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 = require_workflowLaunchCommand.parseWorkflowLaunchCommand(args);
+				if ("error" in parsed) {
+					await execution.client.notify({
+						body: parsed.error,
+						level: "error"
+					});
+					return;
+				}
+				const rendered = callResult(await feature.runTool.execute({
+					workflowPath: parsed.workflow,
+					...parsed.runner === void 0 ? {} : { runner: parsed.runner },
+					...Object.keys(parsed.inputs).length === 0 ? {} : { inputs: parsed.inputs },
+					...parsed.prompt === void 0 ? {} : { prompt: parsed.prompt }
+				})).content.find((entry) => entry.type === "text");
+				await execution.client.notify({
+					body: rendered?.type === "text" ? rendered.text : "Workflow launch requested.",
+					level: "info"
+				});
+			}
+		}],
+		onDispose() {
+			disposeControl();
+			runProvider?.dispose();
+			runProvider = void 0;
+		}
+	};
+}
+//#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";
+var apiRoutes_default = (0, _agimon_ai_doompi_core_web.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`,
+		stream: true
+	},
+	control: {
+		method: "POST",
+		path: `${RUN}/control`,
+		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
+	},
+	keys: {
+		method: "POST",
+		path: `${RUN}/keys`
+	},
+	resize: {
+		method: "POST",
+		path: `${RUN}/resize`,
+		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
+	},
+	remove: {
+		method: "DELETE",
+		path: RUN,
+		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
+	},
+	artifacts: {
+		method: "GET",
+		path: `${RUN}/artifacts`,
+		response: (0, _agimon_ai_doompi_core_web.apiResponse)()
+	},
+	/** One artifact: its metadata and text, or its raw bytes under `raw=1`. */
+	artifact: {
+		method: "GET",
+		path: `${RUN}/artifacts/:name{.+}`,
+		query: ["raw", "download"],
+		response: (0, _agimon_ai_doompi_core_web.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;
+/** 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",
+	".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 run's identity for caches and leases, stable across stage moves. */
+function runIdentityOf(workspace, runKey) {
+	return `${workspace}/${runKey}`;
+}
+/**
+* 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 _agimon_ai_workflow_mcp.WorkflowRegistryService();
+	const facade = options.terminal ?? new _agimon_ai_workflow_mcp.WorkflowTerminalService();
+	const terminal = require_workflowTerminal.createWorkflowTerminalService({
+		terminal: facade,
+		now: options.now ?? (() => Date.now())
+	});
+	const app = new hono.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 identity = runIdentityOf(workspace, runKey);
+		return (0, hono_streaming.streamSSE)(context, async (stream) => {
+			let settledTicks = 0;
+			let running = true;
+			stream.onAbort(() => {
+				running = false;
+			});
+			while (running) {
+				const current = await runOf(workspace, runKey) ?? record;
+				const capabilities = terminal.capabilities(current);
+				const lines = capabilities.readable ? await terminal.screen(identity, current, 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);
+			}
+			terminal.forget(/* @__PURE__ */ new Set());
+		});
+	});
+	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 identity = runIdentityOf(workspace, runKey);
+		const body = await jsonBody(context);
+		const capabilities = terminal.capabilities(record);
+		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 : (0, node_crypto.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);
+		try {
+			await terminal.write(runIdentityOf(workspace, runKey), record, 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 { token, columns, rows } = await jsonBody(context);
+		if (typeof token !== "string" || typeof columns !== "number" || typeof rows !== "number") return context.json({ error: "A resize needs a control token, columns and rows." }, 400);
+		try {
+			const resized = await terminal.resize(runIdentityOf(workspace, runKey), record, token, columns, rows);
+			return context.json({ resized });
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+	});
+	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);
+		try {
+			node_fs.default.rmSync(registry.runDirectoryFor(record), {
+				recursive: true,
+				force: true
+			});
+		} catch (error) {
+			return context.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+		return context.json({ deleted: true });
+	});
+	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 body = {
+			runDir,
+			description: record.runDirectory?.description ?? "",
+			artifacts: readArtifacts(runDir, record)
+		};
+		return context.json(body);
+	});
+	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 = node_path.default.resolve(runDir, requested);
+	const root = node_path.default.resolve(runDir);
+	if (resolved !== root && !resolved.startsWith(`${root}${node_path.default.sep}`)) return void 0;
+	return resolved;
+}
+/** Size and modification time of one path, or undefined when it is not there. */
+function statOf(target) {
+	try {
+		return node_fs.default.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 stats = statOf(node_path.default.join(runDir, entry.path));
+	return {
+		...entry,
+		state: 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) {
+	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 claimed = new Set(declared.map((entry) => entry.path));
+	let names;
+	try {
+		names = node_fs.default.readdirSync(runDir, { withFileTypes: true });
+	} catch {
+		return declared;
+	}
+	const found = names.filter((entry) => !claimed.has(entry.name)).map((entry) => viewOf(runDir, {
+		path: entry.name,
+		kind: entry.isDirectory() ? "directory" : "file",
+		description: "",
+		producedBy: [],
+		declared: false
+	})).sort((left, right) => left.path.localeCompare(right.path));
+	return [...declared, ...found];
+}
+/** Browser content type inferred from a filename without trusting client input. */
+function artifactMimeType(requested) {
+	return ARTIFACT_MIME_TYPES[node_path.default.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 = node_fs.default.openSync(resolved, "r");
+		try {
+			const buffer = Buffer.alloc(Math.min(stats.size, MAX_ARTIFACT_BYTES));
+			node_fs.default.readSync(handle, buffer, 0, buffer.length, 0);
+			text = buffer.toString("utf8");
+		} finally {
+			node_fs.default.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 = node_path.default.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 = node_stream.Readable.toWeb(node_fs.default.createReadStream(resolved, {
+		start,
+		end
+	}));
+	return new Response(body, {
+		status: partial ? 206 : 200,
+		headers
+	});
+}
+/** The named export a host imports from this package's built hub entry. */
+const api = {
+	basePath: WORKFLOW_API_BASE_PATH,
+	start(_context) {
+		const app = createWorkflowHubApi();
+		return {
+			fetch: (request) => app.fetch(request),
+			close: () => void 0
+		};
+	}
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/index.server.ts
+var index_server_default$1 = (({ agent, host }) => ({
+	api: [api],
+	...agent ? createWorkflowServerRuntime(agent, host) : {}
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = (0, _agimon_ai_doompi_core_extensionFile.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.
+*/
+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();
+			const runsFor = (scope, parsed) => presentWorkflowRuns(parsed.filter((run) => runBelongsToSession(run, scope.sessionId)).map((run) => run.view), Date.now());
+			const publish = (scope, payload) => {
+				latest.set(scope.sessionId, payload);
+				host.publish(scope.sessionId, 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_RUNS_TYPE, scope.sessionId, (value) => {
+						if (isWorkflowRunsPayload(value)) publish(scope, value);
+					}, { replayLatest: true });
+					subscriptions.set(scope.sessionId, unsubscribe);
+					const payload = { runs: runsFor(scope, read({ environment: scope.environment })) };
+					publish(scope, payload);
+				},
+				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();
+				}
+			};
+		}
+	};
+}
+//#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 = (0, _agimon_ai_doompi_core_extensionFile.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 = (0, _agimon_ai_doompi_core_extensionFile.defineChannel)(createWorkflowCatalogChannel);
+//#endregion
+//#region src/extensions/(backend)/channel/workflows.server.ts
+var workflows_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineChannel)(createWorkflowsChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/workflow/route.server.ts
+var route_server_default = (0, _agimon_ai_doompi_core_extensionFile.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 = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.commands?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.ts
+var session_shutdown_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.hooks?.[1], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.ts
+var tool_execution_end_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.hooks?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/doompi-author-workflow.server.ts
+var doompi_author_workflow_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.resources?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/doompi-use-workflow.server.ts
+var doompi_use_workflow_server_default = (0, _agimon_ai_doompi_core_extensionFile.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 = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.resources?.[2], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/launch-workflow.server.ts
+var launch_workflow_server_default = (0, _agimon_ai_doompi_core_extensionFile.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 = (0, _agimon_ai_doompi_core_extensionFile.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 = (0, _agimon_ai_doompi_core_extensionFile.defineRoutedContribution)((context) => context.root.tools?.[2], { cardinality: "optional" });
+//#endregion
 //#region generated/server.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
 /* v8 ignore next -- generated normalization branch */
@@ -27,59 +1514,56 @@ const via = (identity, value) => ({
 	...identity,
 	...value
 });
-const facet = (0, _agimon_ai_doompi_core_server_facet.defineServerPlugin)({
+const facet = (0, _agimon_ai_doompi_core_serverFacet.defineServerPlugin)({
 	name: "@agimon-ai/doompi-workflow",
 	global: (context) => ({
 		get api() {
-			return defined([at(require_route_server.default, context)]);
+			return defined([at(route_server_default$1, context)]);
 		},
 		get channels() {
-			return [() => via({ frameType: "workflow_catalog" }, require_workflow_catalog_server.default()), () => via({ frameType: "workflows" }, require_workflows_server.default())];
+			return [() => via({ frameType: "workflow_catalog" }, workflow_catalog_server_default()), () => via({ frameType: "workflows" }, workflows_server_default())];
 		}
 	}),
 	workspace: (context) => ({
 		get api() {
-			return defined([at(require_route_server.default, context)]);
+			return defined([at(route_server_default$1, context)]);
 		},
 		get channels() {
-			return [() => via({ frameType: "workflow_catalog" }, require_workflow_catalog_server.default()), () => via({ frameType: "workflows" }, require_workflows_server.default())];
+			return [() => via({ frameType: "workflow_catalog" }, workflow_catalog_server_default()), () => via({ frameType: "workflows" }, workflows_server_default())];
 		}
 	}),
 	session: async (context) => {
-		const scopeSession = await require_root_server.default(context);
+		const scopeSession = await root_server_default(context);
 		const contextSession = {
 			...context,
 			root: scopeSession.value
 		};
 		return {
-			...(0, _agimon_ai_doompi_core_extension_file.composeRootHooks)(scopeSession),
+			...(0, _agimon_ai_doompi_core_extensionFile.composeRootHooks)(scopeSession),
 			get api() {
-				return defined([at(require_route_server.default, context), at(require_route_server$1.default, contextSession)]);
+				return defined([at(route_server_default$1, context), at(route_server_default, contextSession)]);
 			},
 			get channels() {
-				return [() => via({ frameType: "workflow_catalog" }, require_workflow_catalog_server.default()), () => via({ frameType: "workflows" }, require_workflows_server.default())];
+				return [() => via({ frameType: "workflow_catalog" }, workflow_catalog_server_default()), () => via({ frameType: "workflows" }, workflows_server_default())];
 			},
 			get commands() {
-				return defined([via({ name: "workflow-launch" }, at(require_workflow_launch_server.default, contextSession))]);
+				return defined([via({ name: "workflow-launch" }, at(workflow_launch_server_default, contextSession))]);
 			},
 			get hooks() {
-				return defined([via({ event: "session_shutdown" }, at(require_session_shutdown_server.default, contextSession)), via({ event: "tool_execution_end" }, at(require_tool_execution_end_server.default, contextSession))]);
+				return defined([via({ event: "session_shutdown" }, at(session_shutdown_server_default, contextSession)), via({ event: "tool_execution_end" }, at(tool_execution_end_server_default, contextSession))]);
 			},
 			get resources() {
 				return defined([
-					at(require_doompi_author_workflow_server.default, contextSession),
-					at(require_doompi_use_workflow_server.default, contextSession),
-					at(require_workflow_recovery_server.default, contextSession)
+					at(doompi_author_workflow_server_default, contextSession),
+					at(doompi_use_workflow_server_default, contextSession),
+					at(workflow_recovery_server_default, contextSession)
 				]);
 			},
-			get toolRestrictions() {
-				return defined([at(require_workflow_server.default, contextSession)]);
-			},
 			get tools() {
 				return defined([
-					via({ name: "launch_workflow" }, at(require_launch_workflow_server.default, contextSession)),
-					via({ name: "list_workflows" }, at(require_list_workflows_server.default, contextSession)),
-					via({ name: "workflow_run" }, at(require_workflow_run_server.default, contextSession))
+					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))
 				]);
 			},
 			services: [...scopeSession.services ?? []],