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

package/README.md

@@ -97,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
@@ -126,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-Dse-ahCB.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");
@@ -3462,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"
@@ -3482,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) => ({
@@ -3505,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"
 				});