@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/extension/workflow-durable-resume-command.ts

@@ -1,270 +0,0 @@
-import { listOpenableCompletedWorkflows } from "../durable/completed-catalog.js";
-import { openCompletedDurableWorkflow } from "../durable/completed-inspection.js";
-import { getDurableBackend } from "../durable/factory.js";
-import { formatResumableWorkflowList } from "../durable/resume-catalog.js";
-import { isWorkflowRunResumable } from "../durable/resume-eligibility.js";
-import { type DurableWorkflowDeleteOutcome, deleteDurableWorkflowIfSafe } from "../durable/retention-policy.js";
-import type { ResumableWorkflowEntry } from "../durable/types.js";
-import { isFullRunId, malformedRunIdMessage } from "../shared/run-id.js";
-import { store } from "../shared/store.js";
-import type { RunSnapshot } from "../shared/store-types.js";
-import { workflowRunResumeCandidate } from "../shared/workflow-artifacts.js";
-import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
-import { openWorkflowResumeSelector } from "../tui/workflow-resume-selector.js";
-import type { ExtensionAPI, PiCommandContext } from "./public-types.js";
-import type { ExtensionRuntime } from "./runtime.js";
-import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
-import type { WorkflowCommandReporter } from "./workflow-command-utils.js";
-import { workflowPolicyFromContext } from "./workflow-policy.js";
-import { overlaySurfaceFromContext } from "./workflow-targets.js";
-
-export interface WorkflowRunControlDeps {
-	pi: ExtensionAPI;
-	overlay: GraphOverlayPort;
-	runtimeForContext: (ctx?: PiCommandContext) => ExtensionRuntime;
-	ensureWorkflowResourcesLoaded: () => Promise<void> | void;
-	/** Seed lifecycle state before the direct completed-inspection fallback restores history. */
-	beforeRestoreCompleted?: (snapshots: readonly RunSnapshot[]) => void;
-}
-
-export interface WorkflowResumeCatalog {
-	readonly resumable: readonly ResumableWorkflowEntry[];
-	readonly completed: readonly ResumableWorkflowEntry[];
-}
-
-export interface WorkflowResumeTarget {
-	readonly kind: "live" | "durable" | "completed";
-	readonly workflowId: string;
-	readonly name: string;
-}
-
-export type WorkflowResumeTargetResolution =
-	| WorkflowResumeTarget
-	| { readonly kind: "malformed"; readonly message: string }
-	| { readonly kind: "not_found" };
-
-export async function prepareWorkflowResumeCatalog(
-	runtime: ExtensionRuntime,
-	suppressedLiveIds: ReadonlySet<string>,
-	target?: string,
-): Promise<WorkflowResumeCatalog> {
-	const shared = await runtime.prepareDurableCatalog?.();
-	const prepared = shared?.resumable ?? (await runtime.prepareDurableResumable(target));
-	const backend = getDurableBackend();
-	const isDisplayLoadable = (entry: ResumableWorkflowEntry): boolean =>
-		shared !== undefined || backend.isWorkflowLoadable(entry.workflowId);
-	// The durable catalog is already produced by `listResumableWorkflows()`, which
-	// applies `isDurableWorkflowResumable`; re-filtering here would only drop rows
-	// a hydrating backend has not yet materialized.
-	const resumable = filterSelectorDurableEntries(runtime, prepared).filter(
-		(entry) => !suppressedLiveIds.has(entry.workflowId) && isDisplayLoadable(entry),
-	);
-	const completed =
-		shared?.completed ??
-		(runtime.prepareCompletedDurable !== undefined
-			? await runtime.prepareCompletedDurable()
-			: listOpenableCompletedWorkflows(backend));
-	return {
-		resumable,
-		completed: completed.filter((entry) => isDisplayLoadable(entry)),
-	};
-}
-
-export function deleteWorkflowResumeEntry(workflowId: string): Promise<DurableWorkflowDeleteOutcome> {
-	return deleteDurableWorkflowIfSafe(getDurableBackend(), workflowId, (candidateId) => {
-		const run = store.runs().find((candidate) => candidate.id === candidateId);
-		return run !== undefined && run.status !== "completed" && (run.endedAt === undefined || run.status === "paused");
-	});
-}
-
-export async function handleDurableResume(
-	target: string | undefined,
-	ctx: PiCommandContext,
-	reporter: WorkflowCommandReporter,
-	deps: WorkflowRunControlDeps,
-	preparedCatalog?: WorkflowResumeCatalog,
-): Promise<boolean> {
-	const print = (message: string): void => reporter.info(message);
-	const fail = (message: string): void => reporter.error(message);
-	try {
-		await deps.ensureWorkflowResourcesLoaded();
-	} catch (error) {
-		ctx.ui?.notify(formatWorkflowResourceLoadWarning(error), "warning");
-	}
-	const runtime = deps.runtimeForContext(ctx);
-	const policy = workflowPolicyFromContext(ctx);
-	const catalog = preparedCatalog ?? (await prepareWorkflowResumeCatalog(runtime, new Set(), target));
-	const allOpenable = [...catalog.resumable, ...catalog.completed];
-
-	if (target !== undefined) {
-		const resolved = resolveWorkflowResumeTarget(
-			target,
-			[],
-			catalog.resumable,
-			// Reuse the catalog prepared above instead of re-enumerating the durable
-			// directory a second time for the same command invocation.
-			catalog.completed,
-		);
-		if (resolved.kind === "malformed") {
-			fail(resolved.message);
-			return true;
-		}
-		if (resolved.kind === "completed") {
-			return openCompletedTarget(resolved.workflowId, catalog.completed, ctx, reporter, deps, runtime);
-		}
-		if (resolved.kind === "durable") {
-			return await resumeDurableTarget(resolved.workflowId, ctx, reporter, deps, runtime);
-		}
-
-		const completedAttempt = openCompleted(runtime, target, catalog.completed, deps.beforeRestoreCompleted);
-		if (!completedAttempt.ok && completedAttempt.reason !== "not_found") {
-			fail(completedAttempt.message);
-			return true;
-		}
-		const result = await runtime.resumeDurableWorkflow(target, { policy, actor: "user" });
-		fail(
-			allOpenable.length === 0 ? result.message : `${result.message}\n\n${formatResumableWorkflowList(allOpenable)}`,
-		);
-		return true;
-	}
-
-	if (allOpenable.length === 0) {
-		fail(
-			"No resumable or completed durable workflows found. Usage: /workflow resume <id> (or /resume for Atomic sessions).",
-		);
-		return true;
-	}
-	if (!policy.allowInputPicker) {
-		const instruction = catalog.completed.length === 0 ? "Resume with" : "Resume/open with";
-		print(`${formatResumableWorkflowList(allOpenable)}\n\n${instruction}: /workflow resume <id>`);
-		return true;
-	}
-	let picked: Awaited<ReturnType<typeof openWorkflowResumeSelector>>;
-	try {
-		picked = await openWorkflowResumeSelector(
-			ctx.ui,
-			[],
-			// Catalog already prepared above; resolve it immediately with no rescan.
-			() => Promise.resolve({ durable: catalog.resumable, completed: catalog.completed }),
-			{ deleteWorkflow: deleteWorkflowResumeEntry },
-		);
-	} catch (error) {
-		// No fallback: a host without the session-picker capability fails the
-		// resume command with one actionable message.
-		fail(error instanceof Error ? error.message : String(error));
-		return true;
-	}
-	if (picked.result.kind === "durable") {
-		return resumeDurableTarget(picked.result.workflowId, ctx, reporter, deps, runtime);
-	}
-	if (picked.result.kind === "completed") {
-		return openCompletedTarget(picked.result.workflowId, catalog.completed, ctx, reporter, deps, runtime);
-	}
-	return true;
-}
-
-function filterSelectorDurableEntries(
-	runtime: ExtensionRuntime,
-	entries: readonly ResumableWorkflowEntry[],
-): readonly ResumableWorkflowEntry[] {
-	const registry = runtime.registry as { has(name: string): boolean } | undefined;
-	if (registry === undefined) return entries;
-	return entries.filter((entry) => {
-		const requiresDefinition = entry.status === "running" || entry.status === "failed" || entry.status === "blocked";
-		return !requiresDefinition || registry.has(entry.name);
-	});
-}
-
-export function resolveWorkflowResumeTarget(
-	target: string,
-	liveRuns: readonly RunSnapshot[],
-	resumable: readonly ResumableWorkflowEntry[],
-	completed: readonly ResumableWorkflowEntry[],
-): WorkflowResumeTargetResolution {
-	const targets = new Map<string, WorkflowResumeTarget>();
-	for (const entry of resumable) {
-		targets.set(entry.workflowId, { kind: "durable", workflowId: entry.workflowId, name: entry.name });
-	}
-	for (const entry of completed) {
-		if (!targets.has(entry.workflowId)) {
-			targets.set(entry.workflowId, { kind: "completed", workflowId: entry.workflowId, name: entry.name });
-		}
-	}
-	for (const run of liveRuns.filter(isExplicitResumeCandidate)) {
-		targets.set(run.id, {
-			kind: run.status === "completed" ? "completed" : "live",
-			workflowId: run.id,
-			name: run.name,
-		});
-	}
-	if (!isFullRunId(target)) return { kind: "malformed", message: malformedRunIdMessage(target) };
-	const exact = targets.get(target);
-	return exact ?? { kind: "not_found" };
-}
-
-function isExplicitResumeCandidate(run: RunSnapshot): boolean {
-	if (run.status === "completed") return true;
-	return (
-		isWorkflowRunResumable(workflowRunResumeCandidate(run)) || (run.endedAt === undefined && run.status === "running")
-	);
-}
-
-async function resumeDurableTarget(
-	workflowId: string,
-	ctx: PiCommandContext,
-	reporter: WorkflowCommandReporter,
-	deps: WorkflowRunControlDeps,
-	runtime: ExtensionRuntime,
-): Promise<boolean> {
-	const result = await runtime.resumeDurableWorkflow(workflowId, {
-		policy: workflowPolicyFromContext(ctx),
-		actor: "user",
-	});
-	if (!result.ok) reporter.error(result.message);
-	else {
-		reporter.info(result.message);
-		if (workflowPolicyFromContext(ctx).allowInputPicker) {
-			deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
-		}
-	}
-	return true;
-}
-
-function openCompletedTarget(
-	workflowId: string,
-	catalog: readonly ResumableWorkflowEntry[],
-	ctx: PiCommandContext,
-	reporter: WorkflowCommandReporter,
-	deps: WorkflowRunControlDeps,
-	runtime: ExtensionRuntime,
-): boolean {
-	const result = openCompleted(runtime, workflowId, catalog, deps.beforeRestoreCompleted);
-	if (!result.ok) reporter.error(result.message);
-	else {
-		reporter.info(result.message);
-		if (workflowPolicyFromContext(ctx).allowInputPicker) {
-			deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
-		}
-	}
-	return true;
-}
-
-function openCompleted(
-	runtime: ExtensionRuntime,
-	workflowId: string,
-	catalog: readonly ResumableWorkflowEntry[],
-	beforeRestoreCompleted?: (snapshots: readonly RunSnapshot[]) => void,
-) {
-	return (
-		runtime.openCompletedDurableWorkflow?.(workflowId, catalog) ??
-		openCompletedDurableWorkflow(
-			workflowId,
-			{
-				durableBackend: getDurableBackend(),
-				store,
-				beforeRestore: beforeRestoreCompleted,
-			},
-			catalog,
-		)
-	);
-}

package/dist/builtin/workflows/src/extension/workflow-heartbeat-delivery.ts

@@ -1,241 +0,0 @@
-import type { WorkflowHeartbeatEventDetails } from "../shared/workflow-heartbeat-contract.js";
-
-/** Timer seam so the scheduler and its retries are testable without real waiting. */
-export interface WorkflowHeartbeatTimerHandle {
-	unref?: () => void;
-}
-
-export interface WorkflowHeartbeatTimerApi {
-	setTimeout(handler: () => void, delayMs: number): WorkflowHeartbeatTimerHandle;
-	clearTimeout(handle: WorkflowHeartbeatTimerHandle): void;
-}
-
-export const defaultWorkflowHeartbeatTimerApi: WorkflowHeartbeatTimerApi = {
-	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs) as WorkflowHeartbeatTimerHandle,
-	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
-};
-
-/**
- * Attempts a single heartbeat identity is given before its pending slot is
- * released. A heartbeat is a periodic nudge, not an exactly-once terminal
- * notice: retrying forever would hold the run's one pending slot and silence
- * every later boundary on the cadence. Releasing the slot lets the next future
- * boundary arm normally.
- */
-export const WORKFLOW_HEARTBEAT_MAX_DELIVERY_ATTEMPTS = 5;
-
-/**
- * Maximum time a single host admission may remain in flight. Two minutes is
- * comfortably shorter than the default fifteen-minute heartbeat cadence while
- * leaving a legitimately slow host enough time to admit a card.
- */
-export const WORKFLOW_HEARTBEAT_DELIVERY_TIMEOUT_MS = 120_000;
-
-interface WorkflowHeartbeatDeliveryOptions {
-	readonly emit: (details: WorkflowHeartbeatEventDetails) => boolean | Promise<boolean>;
-	/**
-	 * Live re-check taken immediately before every attempt, the retries included.
-	 * A run that reached a terminal state between attempt 1 and attempt 5 must not
-	 * be sent, so the guard belongs on the attempt rather than on the enqueue.
-	 */
-	readonly canDeliver?: (details: WorkflowHeartbeatEventDetails) => boolean;
-	/** Called exactly once per identity, after success or after attempts are exhausted. */
-	readonly onSettled: (details: WorkflowHeartbeatEventDetails, delivered: boolean) => void;
-	readonly timers: WorkflowHeartbeatTimerApi;
-}
-
-export interface WorkflowHeartbeatDelivery {
-	deliver(details: WorkflowHeartbeatEventDetails): void;
-	/**
-	 * Drop every not-yet-attempted identity belonging to one run, and cancel the
-	 * backoff timer of a head that belongs to it, then start the next identity.
-	 *
-	 * Terminal cleanup's queue half (issue #1975). A send already handed to the
-	 * host cannot be recalled, so an in-flight head stays where it is — but it is
-	 * marked, so whatever the host answers settles straight through instead of
-	 * arming a retry for a run that is already finished. Its `onSettled` is inert
-	 * at the scheduler too, because the pending slot is gone by then. Returns
-	 * whether anything was dropped, so a spared in-flight head alone reports
-	 * `false`.
-	 */
-	discard(runId: string): boolean;
-	dispose(): void;
-}
-
-/** Stable delivery key for one boundary: the slice-1 `runId + scheduledAt` identity. */
-export function workflowHeartbeatIdentityKey(identity: { runId: string; scheduledAt: number }): string {
-	return `${identity.runId}:${identity.scheduledAt}`;
-}
-
-/**
- * Owns heartbeat admission: one identity at a time, in the order handed over,
- * with capped-backoff retry.
- *
- * **Why the queue exists.** The scheduler sorts a due batch by `scheduledAt`
- * then `runId` and hands identities over in that order, but sorting only
- * controls the order attempts *start*. If the first identity's send is rejected
- * it enters backoff, and a later identity admitted in the meantime reaches the
- * parent first — the observed order becomes B, A. Admission order is what the
- * ordering rule is about, so the queue holds later identities until the head
- * reaches a terminal result: admitted, suppressed by its guard, or out of
- * attempts.
- *
- * Every retry re-sends the identical `WorkflowHeartbeatEventDetails`, so the
- * `runId + scheduledAt` identity is reused rather than re-derived from the
- * retry's own clock. Deliberately separate from `createLifecycleNoticeDelivery`:
- * that helper is hard-typed to lifecycle notices and its exact retry/handover
- * semantics are pinned by existing tests.
- */
-export function createWorkflowHeartbeatDelivery(options: WorkflowHeartbeatDeliveryOptions): WorkflowHeartbeatDelivery {
-	const retryTimers = new Set<WorkflowHeartbeatTimerHandle>();
-	const queue: WorkflowHeartbeatEventDetails[] = [];
-	let attempt = 0;
-	let attemptToken = 0;
-	let activeAttemptToken: number | undefined;
-	let watchdogHandle: WorkflowHeartbeatTimerHandle | undefined;
-	let running = false;
-	let active = true;
-	/**
-	 * Whether the in-flight head was discarded while its send was outstanding.
-	 *
-	 * The send itself cannot be recalled, but its *result* must not start a
-	 * retry: a rejection arriving after cleanup would otherwise arm a backoff
-	 * timer, and re-attempt the old identity, for a run whose cleanup already
-	 * finished. One boolean suffices because only one head is ever in flight,
-	 * and `settleHead` — the only path that shifts the queue — clears it, so it
-	 * can never carry over to the next identity or to another run.
-	 */
-	let headDiscarded = false;
-
-	const clearWatchdog = (): void => {
-		if (watchdogHandle === undefined) return;
-		options.timers.clearTimeout(watchdogHandle);
-		watchdogHandle = undefined;
-	};
-
-	/** Finish the head identity and start the next one, in handover order. */
-	const settleHead = (details: WorkflowHeartbeatEventDetails, delivered: boolean): void => {
-		clearWatchdog();
-		activeAttemptToken = undefined;
-		queue.shift();
-		attempt = 0;
-		running = false;
-		headDiscarded = false;
-		options.onSettled(details, delivered);
-		runHead();
-	};
-
-	const runHead = (): void => {
-		if (!active || running || retryTimers.size > 0) return;
-		const details = queue[0];
-		if (details === undefined) return;
-		// The live guard runs immediately before every attempt, including the
-		// first attempt of an identity that waited behind another one — the run
-		// may have finished or paused while it queued.
-		if (options.canDeliver !== undefined && !options.canDeliver(details)) {
-			// Suppressed rather than sent, and never retried: the run's state is the
-			// reason, and no amount of backoff changes it. Later identities proceed.
-			settleHead(details, false);
-			return;
-		}
-		running = true;
-		attempt += 1;
-		const thisAttempt = attempt;
-		const thisAttemptToken = ++attemptToken;
-		activeAttemptToken = thisAttemptToken;
-		const settle = (delivered: boolean): void => {
-			if (activeAttemptToken !== thisAttemptToken) return;
-			activeAttemptToken = undefined;
-			clearWatchdog();
-			// A discarded head settles straight through, whatever the host answered:
-			// no retry, and the real result is still reported once.
-			if (delivered || headDiscarded || thisAttempt >= WORKFLOW_HEARTBEAT_MAX_DELIVERY_ATTEMPTS || !active) {
-				settleHead(details, delivered);
-				return;
-			}
-			running = false;
-			const handle = options.timers.setTimeout(
-				() => {
-					retryTimers.delete(handle);
-					runHead();
-				},
-				Math.min(20 * 2 ** (thisAttempt - 1), 1_000),
-			);
-			handle.unref?.();
-			retryTimers.add(handle);
-		};
-		let result: boolean | Promise<boolean>;
-		try {
-			result = options.emit(details);
-		} catch {
-			// A host can throw synchronously before returning its admission result.
-			// Treat that exactly like an asynchronous rejection so the failed head
-			// enters capped backoff instead of leaving `running` set forever.
-			settle(false);
-			return;
-		}
-		if (typeof result === "boolean") {
-			settle(result);
-			return;
-		}
-		const watchdog = options.timers.setTimeout(() => {
-			if (activeAttemptToken !== thisAttemptToken) return;
-			activeAttemptToken = undefined;
-			watchdogHandle = undefined;
-			settleHead(details, false);
-		}, WORKFLOW_HEARTBEAT_DELIVERY_TIMEOUT_MS);
-		watchdogHandle = watchdog;
-		watchdog.unref?.();
-		void result.then(settle, () => settle(false));
-	};
-
-	const deliver = (details: WorkflowHeartbeatEventDetails): void => {
-		if (!active) return;
-		queue.push(details);
-		runHead();
-	};
-
-	const discard = (runId: string): boolean => {
-		// An attempt is already with the host and cannot be recalled, so the head
-		// is spared only while its send is genuinely in flight. A head sitting in
-		// backoff has nothing outstanding and is dropped with its timer.
-		const head = queue[0];
-		const headInFlight = running && head !== undefined && head.runId === runId;
-		let discarded = false;
-		// Back to front, so index 0 is decided last and the indices ahead of it
-		// stay valid while they are spliced out.
-		for (let index = queue.length - 1; index >= 0; index -= 1) {
-			if (queue[index]?.runId !== runId) continue;
-			if (index === 0 && headInFlight) {
-				// Spared, but invalidated: its settlement must not schedule a retry.
-				headDiscarded = true;
-				continue;
-			}
-			queue.splice(index, 1);
-			discarded = true;
-			if (index > 0) continue;
-			// The dropped head owned the attempt counter and, if it was waiting to
-			// retry, the only live backoff timer.
-			attempt = 0;
-			running = false;
-			for (const handle of retryTimers) options.timers.clearTimeout(handle);
-			retryTimers.clear();
-		}
-		if (discarded) runHead();
-		return discarded;
-	};
-
-	return {
-		deliver,
-		discard,
-		dispose() {
-			active = false;
-			clearWatchdog();
-			for (const handle of retryTimers) options.timers.clearTimeout(handle);
-			retryTimers.clear();
-			queue.length = 0;
-			// An in-flight send is left to settle on its own; `active` keeps it from
-			// starting a further retry. Its watchdog is cleared with the other timers.
-		},
-	};
-}

package/dist/builtin/workflows/src/extension/workflow-heartbeat-notice.ts

@@ -1,115 +0,0 @@
-import {
-	WORKFLOW_HEARTBEAT_CUSTOM_TYPE,
-	type WorkflowHeartbeatEventDetails,
-} from "../shared/workflow-heartbeat-contract.js";
-import { deriveGraphThemeFromPiTheme, type GraphTheme } from "../tui/graph-theme.js";
-import { renderWorkflowNoticeCard } from "../tui/workflow-notice-card.js";
-import type { ExtensionAPI, PiMessageRenderComponent, PiMessageRenderer } from "./index.js";
-
-/** Card title and glyph, both distinct from every lifecycle notice kind. */
-const WORKFLOW_HEARTBEAT_TITLE = "WORKFLOW HEARTBEAT";
-const WORKFLOW_HEARTBEAT_GLYPH = "♥";
-
-const rendererRegisteredHosts = new WeakSet<object>();
-
-/**
- * Model-facing heartbeat text. Derived only from the five slice-1 payload
- * fields: it names the workflow and run so the parent can identify the work,
- * states the cadence and elapsed time so it can judge drift, and points at the
- * existing status surface so it can inspect rather than guess.
- */
-export function formatWorkflowHeartbeatNoticeText(details: WorkflowHeartbeatEventDetails): string {
-	const workflowName = escapeQuotedText(details.workflowName);
-	const elapsed = formatWorkflowHeartbeatElapsed(details);
-	const cadence = formatWorkflowHeartbeatCadence(details.intervalMinutes);
-	return (
-		`${WORKFLOW_HEARTBEAT_GLYPH} Workflow "${workflowName}" heartbeat (run ${details.runId}) — still running` +
-		`${elapsed === undefined ? "" : ` after ${elapsed}`}, on a ${cadence} cadence. ` +
-		"This is a periodic alignment check, not a failure. Review whether the run is still on goal, then " +
-		"continue, steer it, stop and replace it, or ask the user. " +
-		`Inspect: /workflow status ${details.runId}`
-	);
-}
-
-export interface WorkflowHeartbeatRendererOptions {
-	readonly registerMessageRenderer?: ExtensionAPI["registerMessageRenderer"];
-	readonly rendererHost?: object;
-}
-
-export function registerWorkflowHeartbeatRenderer(options: WorkflowHeartbeatRendererOptions): void {
-	const register = options.registerMessageRenderer;
-	if (typeof register !== "function") return;
-
-	const host = options.rendererHost ?? register;
-	if (rendererRegisteredHosts.has(host)) return;
-
-	const renderer: PiMessageRenderer = (raw, _options, piTheme) => {
-		const message = raw as { details?: WorkflowHeartbeatEventDetails };
-		if (!message.details) return undefined;
-		return makeWorkflowHeartbeatComponent(message.details, themeFromRenderer(piTheme));
-	};
-
-	register(WORKFLOW_HEARTBEAT_CUSTOM_TYPE, renderer);
-	rendererRegisteredHosts.add(host);
-}
-
-function makeWorkflowHeartbeatComponent(
-	details: WorkflowHeartbeatEventDetails,
-	theme: GraphTheme | undefined,
-): PiMessageRenderComponent {
-	const text = formatWorkflowHeartbeatNoticeText(details);
-	return {
-		render(width: number): string[] {
-			return renderWorkflowHeartbeatCard(details, { width, theme, fallbackText: text });
-		},
-		invalidate() {
-			/* delivered heartbeats are immutable */
-		},
-	};
-}
-
-function renderWorkflowHeartbeatCard(
-	details: WorkflowHeartbeatEventDetails,
-	opts: { width: number; theme?: GraphTheme; fallbackText: string },
-): string[] {
-	return renderWorkflowNoticeCard({
-		title: WORKFLOW_HEARTBEAT_TITLE,
-		glyph: WORKFLOW_HEARTBEAT_GLYPH,
-		headline: `Workflow "${details.workflowName}" is still running`,
-		tone: "mauve",
-		fields: [
-			{ label: "workflow", value: details.workflowName },
-			{ label: "run", value: details.runId },
-			{ label: "cadence", value: formatWorkflowHeartbeatCadence(details.intervalMinutes), tone: "muted" },
-			{ label: "elapsed", value: formatWorkflowHeartbeatElapsed(details), tone: "muted" },
-		],
-		hints: [`/workflow status ${details.runId}`],
-		fallbackText: opts.fallbackText,
-		width: opts.width,
-		...(opts.theme ? { theme: opts.theme } : {}),
-	});
-}
-
-function formatWorkflowHeartbeatCadence(intervalMinutes: number): string {
-	return `${intervalMinutes}-minute`;
-}
-
-/** Elapsed run time at the boundary, derived from the payload's own timestamps. */
-function formatWorkflowHeartbeatElapsed(details: WorkflowHeartbeatEventDetails): string | undefined {
-	const elapsedMs = details.scheduledAt - details.startedAt;
-	if (!Number.isFinite(elapsedMs) || elapsedMs < 0) return undefined;
-	const totalMinutes = Math.floor(elapsedMs / 60_000);
-	if (totalMinutes < 1) return `${Math.max(0, Math.floor(elapsedMs / 1000))}s`;
-	if (totalMinutes < 60) return `${totalMinutes}m`;
-	const hours = Math.floor(totalMinutes / 60);
-	const minutes = totalMinutes % 60;
-	return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}m`;
-}
-
-function escapeQuotedText(value: string): string {
-	return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-
-function themeFromRenderer(piTheme: unknown): GraphTheme | undefined {
-	return piTheme === undefined ? undefined : deriveGraphThemeFromPiTheme(piTheme);
-}