@agimon-ai/doompi-workflow 0.0.1-alpha.101 → 0.0.1-alpha.104

package/README.md

@@ -64,9 +64,10 @@ Core tools are:
 - `list_workflows`: discover workflows.
 - `launch_workflow`: register and start an asynchronous run.
 - `workflow_run`: inspect or control a run through supported actions.
+- `workflow_tools` (server/web sessions): read failed-run recovery evidence or resume the existing run.
 
-Launch returns after the run is registered, not after all jobs complete. Use status and follow
-controls for progress, and wait for a terminal notification.
+Launch returns after the run is registered, not after all jobs complete. Use status for progress
+and wait for a terminal notification. The TUI also supports follow controls.
 
 In the TUI, `SPC w l` lists the repository's workflows and launches the one under the cursor with
 `r`, `SPC w r` inspects this session's runs, `SPC w c` opens recovery, and `SPC w e`
@@ -96,10 +97,31 @@ adopts the eligible failure, validates the evidence, and transfers ownership to
 Live controls remain scoped to the owning session. Recovery does not launch a second copy beside a
 still-running job and does not guarantee that parent-session work survives shutdown.
 
-The package publishes `workflow-recovery` for active Workflow mode. While parent Help mode is
-active, it also contributes `doompi-author-workflow` for writing workflow definitions and
-`doompi-use-workflow` for launching, monitoring, and recovering runs. Deactivating Help hides both
-descriptors; cached files may remain.
+The package publishes `workflow-recovery`, `doompi-author-workflow` for writing workflow
+definitions, and `doompi-use-workflow` for launching, monitoring, and recovering runs while Workflow
+mode is active. Deactivating Workflow mode hides them; cached files may remain.
+
+## Workflow sessions
+
+In a server (web cockpit) session, a launch does not run in the session that asked for it. The
+session creates a child **workflow session** (provenance `workflow-session`), nested under it in the
+rail, and hands it the launch. The workflow session owns the run (`PI_SESSION_ID`), runs its step
+sessions, and has Workflow mode on, so its agent can troubleshoot and recover the run. The run's
+environment also carries `DOOMPI_WORKFLOW_LAUNCHER_SESSION_ID`, naming the launching session, which
+lists the run in its Activity group, is told when it ends, and may read its status.
+
+- The workflow session's rail row shows the run (`workflow · build › test · 4m`, or a failure or
+  pause marked like a pending question) through the host's per-session activity line.
+- A failure or finish is posted into the workflow session's conversation as a notice, without
+  starting an agent turn. The owner agent also gets a live brief of its runs on every turn.
+- After a success, a workflow session nobody interacted with asks its launcher to release it, and it
+  becomes `stopped · open to wake`. A session whose run failed or paused, or whose agent you
+  prompted, stays live until you remove it. Removing or restarting a live workflow session stops its
+  run.
+- Recovery is refused from any session other than the owner while the owner is live.
+
+Launches from inside a workflow session, and launches in hosts without a session service (the TUI
+and CLI), run in place as before.
 
 Each Pi extension instance uses the runner's shared Doom lifecycle. Reload or shutdown stops retained
 callbacks, interrupts bounded inline work, removes UI and service registrations, and releases
@@ -125,10 +147,12 @@ Maintained by [Agimon](https://agimon.ai/about).
 ## Web cockpit plugin
 
 The `.web` routed files under `src/extensions/workspaces/sessions/(frontend)` are this package's
-DoomPi web cockpit plugin: the workflows panel the dock's workflows group opens in a temporary tab,
-its store, and its `workflow_runs` session channel, compiled into the cockpit bundle by
-`doompi-web`'s build. Each surface keeps its components in a colocated `_components` folder and its
-stores and helpers in `_lib`.
+DoomPi web cockpit plugin: the `workflow` dock face beside Activity and Context (the owned run's
+jobs, active steps and artifacts, each opening its own tab), the workflow catalog and launch
+dialog in the overlay slot, the Activity group's run rows (a handed-off run opens its workflow
+session), their stores, and the `workflow_runs` session channel, compiled into the cockpit bundle
+by `doompi-web`'s build. Each surface keeps its components in a colocated `_components` folder and
+its stores and helpers in `_lib`.
 The hub-side data source ships behind the `./web-hub` subpath and reads the workflow registry
 (run.json plus progress.ndjson) exactly as the engine writes it. Both halves are declared by the
 `doompiWeb` block in package.json.

package/dist/extensions/pi.cjs

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_workflowTerminal = require("../workflowTerminal-Bb4bLtLu.cjs");
+const require_workflowTerminal = require("../workflowTerminal-DeJ9BBta.cjs");
 const require_workflowLaunchCommand = require("../workflowLaunchCommand-DJyDB96d.cjs");
 let _agimon_ai_doompi_core_piExtension = require("@agimon-ai/doompi-core/piExtension");
 let _agimon_ai_doompi_core_extensionFile = require("@agimon-ai/doompi-core/extensionFile");
@@ -23,76 +23,6 @@ let _agimon_ai_doompi_core_readiness = require("@agimon-ai/doompi-core/readiness
 let _agimon_ai_doompi_minor_mode = require("@agimon-ai/doompi-minor-mode");
 let _agimon_ai_doompi_telemetry = require("@agimon-ai/doompi-telemetry");
 let _earendil_works_pi_tui = require("@earendil-works/pi-tui");
-//#region src/schemas/workflowPi.ts
-const RUN_SELECTOR_FIELDS = {
-	runKey: zod.z.string().min(1).describe("Run key of the workflow run."),
-	workspace: zod.z.string().optional().describe("Workspace the run belongs to.")
-};
-const workflowRunInputSchema = zod.z.discriminatedUnion("action", [
-	zod.z.object({
-		action: zod.z.literal("status"),
-		...RUN_SELECTOR_FIELDS
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("tail"),
-		...RUN_SELECTOR_FIELDS
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("recovery-evidence"),
-		...RUN_SELECTOR_FIELDS
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("follow"),
-		...RUN_SELECTOR_FIELDS
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("open"),
-		...RUN_SELECTOR_FIELDS
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("pause"),
-		...RUN_SELECTOR_FIELDS,
-		reason: zod.z.string().optional()
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("resume"),
-		...RUN_SELECTOR_FIELDS,
-		reason: zod.z.string().optional()
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("stop"),
-		...RUN_SELECTOR_FIELDS,
-		reason: zod.z.string().optional()
-	}).strict(),
-	zod.z.object({
-		action: zod.z.literal("recover"),
-		...RUN_SELECTOR_FIELDS,
-		dryRun: zod.z.boolean().optional(),
-		job: zod.z.string().optional(),
-		runner: zod.z.string().optional()
-	}).strict()
-]);
-const dispatchInputSchema = zod.z.object({
-	description: zod.z.string().optional().describe("Description shown for the workflow input."),
-	required: zod.z.boolean().optional().describe("Whether the workflow input must be provided."),
-	default: zod.z.string().optional().describe("Default value for the workflow input."),
-	type: zod.z.string().optional().describe("Declared workflow input type."),
-	options: zod.z.array(zod.z.string()).optional().describe("Allowed values for the workflow input.")
-}).passthrough();
-const workflowDispatchInputsSchema = zod.z.object({ inputs: zod.z.record(zod.z.string(), dispatchInputSchema).optional().describe("Workflow dispatch input definitions.") }).passthrough();
-const workflowCatalogPageSchema = zod.z.object({
-	directory: zod.z.string().min(1).describe("Directory searched for workflow definitions."),
-	hasNextPage: zod.z.boolean().describe("Whether another catalog page exists."),
-	page: zod.z.number().int().positive().describe("One-based catalog page number."),
-	pageSize: zod.z.number().int().positive().describe("Catalog page size."),
-	workflows: zod.z.array(zod.z.object({
-		path: zod.z.string().min(1).describe("Workflow path relative to the catalog directory."),
-		name: zod.z.string().describe("Workflow display name."),
-		description: zod.z.string().describe("Workflow description."),
-		tags: zod.z.array(zod.z.string()).describe("Workflow tags.")
-	}).passthrough()).describe("Workflow definitions on this page.")
-}).passthrough();
-//#endregion
 //#region src/services/workflowTools/index.ts
 const PI_LAUNCH_FIELDS = {
 	workflowPath: true,
@@ -175,11 +105,11 @@ function createWorkflowTools(dependencies, renderers = () => ({})) {
 				"Use action recover only after loading the `workflow-recovery` skill and gathering its required evidence. Recovery may adopt a terminal failed run from an earlier Pi session; it never grants cross-session control of running work. Never edit issue.md or repair.json, and verify real process and registry progress before recovery.",
 				"Never unlock or force-release an Agiflow claim from this tool."
 			],
-			parameters: zod.z.toJSONSchema(workflowRunInputSchema),
+			parameters: zod.z.toJSONSchema(require_workflowTerminal.workflowRunInputSchema),
 			renderShell: "self",
 			...renderers(require_workflowTerminal.WORKFLOW_RUN_TOOL_NAME),
 			async execute(_toolCallId, rawParams, _signal, onUpdate, ctx) {
-				const input = workflowRunInputSchema.parse(rawParams);
+				const input = require_workflowTerminal.workflowRunInputSchema.parse(rawParams);
 				const sessionId = (0, _agimon_ai_doompi_core_childProcess.resolveRootSessionId)(ctx.sessionManager.getSessionId(), dependencies.environment);
 				dependencies.observeSession?.(sessionId);
 				const selector = {
@@ -887,7 +817,7 @@ function workflowTriggerBlock(workflow) {
 function dispatchInputs(workflow) {
 	const dispatch = workflowTriggerBlock(workflow)[WORKFLOW_DISPATCH_TRIGGER];
 	if (dispatch === null || dispatch === void 0) return {};
-	const parsed = workflowDispatchInputsSchema.safeParse(dispatch);
+	const parsed = require_workflowTerminal.workflowDispatchInputsSchema.safeParse(dispatch);
 	if (!parsed.success) throw new Error(`Invalid workflow_dispatch input definitions: ${parsed.error.message}`);
 	return parsed.data.inputs ?? {};
 }
@@ -902,7 +832,7 @@ function parseWorkflowCatalogPage(result) {
 	} catch (cause) {
 		throw new Error("Workflow catalog returned invalid JSON.", { cause });
 	}
-	const parsed = workflowCatalogPageSchema.safeParse(value);
+	const parsed = require_workflowTerminal.workflowCatalogPageSchema.safeParse(value);
 	if (!parsed.success) throw new Error(`Workflow catalog response was invalid: ${parsed.error.message}`);
 	return {
 		directory: parsed.data.directory,
@@ -3532,12 +3462,13 @@ function createWorkflowPiRuntime(pi, options) {
 			if (!refreshIsCurrent()) return;
 			const sessionId = (0, _agimon_ai_doompi_core_childProcess.resolveRootSessionId)(ctx.sessionManager.getSessionId(), options.environment);
 			const rootProcess = isRootProcess(ctx, sessionId);
-			const sessionRecords = records.filter((record) => require_workflowTerminal.isSessionRun(record, sessionId));
-			const running = sessionRecords.filter((record) => record.stage === RUNNING_STATUS && !record.stale);
-			const failed = sessionRecords.filter((record) => record.stage === ERROR_STAGE);
+			const ownRecords = records.filter((record) => require_workflowTerminal.isSessionRun(record, sessionId));
+			const sessionRecords = records.filter((record) => require_workflowTerminal.isSessionRun(record, sessionId) || require_workflowTerminal.isLaunchedRun(record, sessionId));
+			const running = ownRecords.filter((record) => record.stage === RUNNING_STATUS && !record.stale);
+			const failed = ownRecords.filter((record) => record.stage === ERROR_STAGE);
 			if (activeRevisionAtRead === activeRunRevision) replaceActiveRecords(running);
 			activeTelemetry.recordEvent("doom_workflow.monitor_counts", {
-				"workflow.run_count": sessionRecords.length,
+				"workflow.run_count": ownRecords.length,
 				"workflow.running_count": running.length,
 				"workflow.failed_count": failed.length,
 				mode: workflowMode ? "on" : "off"
@@ -3552,11 +3483,12 @@ function createWorkflowPiRuntime(pi, options) {
 				const previous = previousStages.get(identity);
 				const startedAt = Date.parse(record.startedAt);
 				const startedDuringSession = previous === void 0 && (sessionStartedAt === 0 || !Number.isFinite(startedAt) || startedAt >= sessionStartedAt);
-				if (lifecycleNarrationReady) narrateWorkflowTransition(narrationSink, record, previous === RUNNING_STATUS || previous === COMPLETED_STATUS || previous === ERROR_STAGE ? previous : void 0, startedDuringSession);
+				if (lifecycleNarrationReady && require_workflowTerminal.isSessionRun(record, sessionId)) narrateWorkflowTransition(narrationSink, record, previous === RUNNING_STATUS || previous === COMPLETED_STATUS || previous === ERROR_STAGE ? previous : void 0, startedDuringSession);
 				if (!notifyChanges || !rootProcess || record.stage === RUNNING_STATUS) continue;
 				if (!deliveredTerminalRuns.has(identity) && (previous === RUNNING_STATUS || startedDuringSession)) pendingTerminalRuns.set(identity, record);
 			}
 			const retainedWork = new Map(mine.map((record) => [runIdentity(record), record]));
+			for (const record of sessionRecords) if (require_workflowTerminal.isLaunchedRun(record, sessionId) && record.stage === RUNNING_STATUS && !record.stale) retainedWork.set(runIdentity(record), record);
 			for (const [identity, record] of pendingTerminalRuns) retainedWork.set(identity, record);
 			if (!refreshIsCurrent()) return;
 			runProvider?.update([...retainedWork.values()].map((record) => ({
@@ -3575,28 +3507,39 @@ function createWorkflowPiRuntime(pi, options) {
 			if (rootProcess && pendingTerminalRuns.size > 0) try {
 				const terminalRecords = [...pendingTerminalRuns.values()];
 				const summaries = await Promise.all(terminalRecords.map(async (record) => {
-					if (record.stage === COMPLETED_STATUS) return require_workflowTerminal.finishedRunSummary(record, []);
+					if (record.stage === COMPLETED_STATUS) {
+						const summary = require_workflowTerminal.finishedRunSummary(record, []);
+						return require_workflowTerminal.isLaunchedRun(record, sessionId) ? `${summary}\n${require_workflowTerminal.launchedRunHint(record)}` : summary;
+					}
 					const identity = runIdentity(record);
 					const events = runEvents.get(identity) ?? progressEventsForRun(record, await (0, _agimon_ai_workflow_mcp.readWorkflowProgress)(registry.runDirectoryFor(record)));
-					return require_workflowTerminal.finishedRunSummary(record, (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(events));
+					const summary = require_workflowTerminal.finishedRunSummary(record, (0, _agimon_ai_workflow_mcp.summarizeWorkflowProgress)(events));
+					return require_workflowTerminal.isLaunchedRun(record, sessionId) ? `${summary}\n${require_workflowTerminal.launchedRunHint(record)}` : summary;
 				}));
 				if (!refreshIsCurrent()) return;
-				pi.sendMessage({
+				const message = (indexes) => ({
 					customType: WORKFLOW_FINISHED_MESSAGE$1,
-					content: summaries.join("\n\n"),
+					content: indexes.map((index) => summaries[index]).join("\n\n"),
 					display: true,
 					details: {
-						runIds: terminalRecords.map((record) => record.runId ?? runIdentity(record)),
-						runs: terminalRecords.map((record) => ({
-							runKey: record.runKey,
-							workspace: record.workspace,
-							stage: record.stage,
-							...record.workflowId ? { workflowId: record.workflowId } : {},
-							...record.failedJob ? { failedJob: record.failedJob } : {},
-							...record.errorMessage ? { error: record.errorMessage } : {}
-						}))
+						runIds: indexes.map((index) => terminalRecords[index].runId ?? runIdentity(terminalRecords[index])),
+						runs: indexes.map((index) => {
+							const record = terminalRecords[index];
+							return {
+								runKey: record.runKey,
+								workspace: record.workspace,
+								stage: record.stage,
+								...record.workflowId ? { workflowId: record.workflowId } : {},
+								...record.failedJob ? { failedJob: record.failedJob } : {},
+								...record.errorMessage ? { error: record.errorMessage } : {}
+							};
+						})
 					}
-				}, {
+				});
+				const quiet = terminalRecords.flatMap((record, index) => require_workflowTerminal.isOwnedDelegatedRun(record, sessionId) ? [index] : []);
+				const loud = terminalRecords.flatMap((record, index) => require_workflowTerminal.isOwnedDelegatedRun(record, sessionId) ? [] : [index]);
+				if (quiet.length > 0) pi.sendMessage(message(quiet), { triggerTurn: false });
+				if (loud.length > 0) pi.sendMessage(message(loud), {
 					triggerTurn: true,
 					deliverAs: "steer"
 				});