@bastani/atomic 0.9.14-alpha.4 → 0.9.14-alpha.6

package/dist/builtin/workflows/src/extension/lifecycle-notifications.ts

@@ -1,3 +1,4 @@
+import type { BudgetReport } from "../shared/budget.js";
 import {
 	actionableReturnedStatusText,
 	effectiveRunStatus,
@@ -33,6 +34,7 @@ export type WorkflowLifecycleNoticeKind =
 	| "completed"
 	| "failed"
 	| "blocked"
+	| "budget_warning"
 	| "awaiting_input"
 	| "paused"
 	| "quit"
@@ -45,12 +47,12 @@ export type WorkflowLifecycleNoticeKind =
  * action to a user.
  */
 type WorkflowControlNoticeKind = "started" | "paused" | "quit" | "resumed";
-
 export const WORKFLOW_LIFECYCLE_NOTICE_KINDS = [
 	"started",
 	"completed",
 	"failed",
 	"blocked",
+	"budget_warning",
 	"awaiting_input",
 	"paused",
 	"quit",
@@ -80,6 +82,7 @@ export interface WorkflowLifecycleNoticeDetails {
 	readonly toolNodeId?: string;
 	readonly toolName?: string;
 	readonly durationMs?: number;
+	readonly budgetDimension?: "duration" | "tokens" | "cost";
 	readonly active?: boolean;
 	/** Whether a failed author exit or quit run advertises itself as resumable. */
 	readonly resumable?: boolean;
@@ -156,6 +159,8 @@ export function seedWorkflowLifecycleNotificationState(
 				state.deliveredTerminalRuns.add(controlKey);
 			}
 		}
+		for (const warning of budgetWarningReports(run))
+			state.deliveredTerminalRuns.add(budgetWarningKey(run, warning.dimension));
 		if (run.pendingPrompt !== undefined) {
 			state.deliveredInputPrompts.add(runAwaitingInputKey(run.id, run.pendingPrompt));
 		}
@@ -308,6 +313,15 @@ export function installWorkflowLifecycleNotifications(options: WorkflowLifecycle
 		// through workflow status/connect surfaces instead of the main chat context.
 	};
 
+	const emitBudgetWarningOnce = (run: RunSnapshot): void => {
+		for (const warning of budgetWarningReports(run)) {
+			const key = budgetWarningKey(run, warning.dimension);
+			if (state.deliveredTerminalRuns.has(key) || state.pendingTerminalRuns.has(key)) continue;
+			if (state.suppressionDepth > 0) state.deliveredTerminalRuns.add(key);
+			else delivery.deliver(key, makeBudgetWarningNotice(run, warning));
+		}
+	};
+
 	const inspect = (snapshot: StoreSnapshot): void => {
 		for (const run of snapshot.runs) {
 			if (!isTopLevelWorkflowRun(run)) continue;
@@ -316,6 +330,7 @@ export function installWorkflowLifecycleNotifications(options: WorkflowLifecycle
 			emitTerminalNoticeOnce(run, "blocked");
 			emitControlNoticesOnce(run);
 
+			if (notifyOn.has("budget_warning")) emitBudgetWarningOnce(run);
 			if (!notifyOn.has("awaiting_input")) continue;
 			emitRunAwaitingInputNoticeOnce(run);
 			for (const stage of run.stages) {
@@ -386,6 +401,11 @@ export function formatWorkflowLifecycleNoticeText(details: WorkflowLifecycleNoti
 		const stateText = details.active === true ? "is blocked" : "ended blocked";
 		return `! Workflow "${workflowName}" ${stateText} (run ${details.runId})${origin}${errorText}. Inspect: /workflow status ${details.runId}`;
 	}
+	if (details.kind === "budget_warning") {
+		const warningText = details.error ? `: ${details.error}` : "";
+		const dimension = details.budgetDimension ?? "duration";
+		return `! Workflow "${workflowName}" is approaching its ${dimension} budget (run ${details.runId})${origin}${warningText}. Inspect: /workflow status ${details.runId}`;
+	}
 	if (details.kind === "paused" || details.kind === "quit") {
 		const stopStage = details.stageName ?? details.stageId;
 		// "(run 8c31), which you started, at stage review" — the stage clause takes a
@@ -448,13 +468,31 @@ function makeTerminalNotice(
 		...(failedToolNodeId !== undefined ? { toolNodeId: failedToolNodeId } : {}),
 		...(failedTool !== undefined ? { toolName: failedTool.name } : {}),
 		...(run.durationMs !== undefined ? { durationMs: run.durationMs } : {}),
-		// Attribution renders on every kind, and is omitted for a run that never
-		// recorded an origin rather than guessed at.
 		...(run.origin !== undefined ? { origin: run.origin } : {}),
 		createdAt: lifecycleOccurrenceAt(run, kind) ?? Date.now(),
 	};
 }
 
+function budgetWarningReports(run: RunSnapshot): readonly BudgetReport[] {
+	const warnings = Object.values(run.budgetState?.warnings ?? {}).filter(
+		(warning): warning is BudgetReport => warning !== undefined,
+	);
+	return warnings.length > 0 ? warnings : run.budgetState?.warning === undefined ? [] : [run.budgetState.warning];
+}
+function makeBudgetWarningNotice(run: RunSnapshot, warning: BudgetReport): WorkflowLifecycleNoticeDetails {
+	return {
+		kind: "budget_warning",
+		scope: "run",
+		runId: run.id,
+		workflowName: run.name,
+		status: run.status,
+		budgetDimension: warning.dimension,
+		error: `At ${warning.percent.toFixed(1)}% of the ${warning.dimension} budget (${warning.reading} / ${warning.ceiling}).`,
+		...(warning.dimension === "duration" ? { durationMs: warning.reading } : {}),
+		...(run.origin !== undefined ? { origin: run.origin } : {}),
+		createdAt: run.startedAt,
+	};
+}
 function makeControlNotice(run: RunSnapshot, occurrence: ControlOccurrence): WorkflowLifecycleNoticeDetails {
 	const stage = occurrence.stage ?? restingStage(run);
 	const elapsedMs = run.durationMs ?? (occurrence.at >= run.startedAt ? occurrence.at - run.startedAt : undefined);
@@ -531,6 +569,9 @@ function terminalRunKey(kind: "completed" | "failed" | "blocked", run: RunSnapsh
 	const occurrence = kind === "blocked" ? (run.blockedAt ?? lifecycleOccurrenceAt(run, kind)) : "";
 	return occurrence === undefined ? `${kind}:${run.id}` : `${kind}:${run.id}:${occurrence}`;
 }
+function budgetWarningKey(run: RunSnapshot, dimension = run.budgetState?.warning?.dimension ?? "duration"): string {
+	return `budget_warning:${run.id}:${dimension}`;
+}
 
 /** One deliberate control action a run currently carries. */
 interface ControlOccurrence {
@@ -697,12 +738,12 @@ function renderLifecycleNoticeCard(
 		...(opts.theme ? { theme: opts.theme } : {}),
 	});
 }
-
 function lifecycleNoticeTone(kind: WorkflowLifecycleNoticeKind): WorkflowNoticeTone {
 	switch (kind) {
 		case "failed":
 			return "error";
 		case "blocked":
+		case "budget_warning":
 		case "awaiting_input":
 		case "paused":
 		case "quit":
@@ -718,6 +759,8 @@ function lifecycleNoticeTitle(kind: WorkflowLifecycleNoticeKind): string {
 			return "WORKFLOW STARTED";
 		case "failed":
 			return "WORKFLOW FAILED";
+		case "budget_warning":
+			return "WORKFLOW BUDGET WARNING";
 		case "awaiting_input":
 			return "WORKFLOW INPUT";
 		case "blocked":
@@ -737,6 +780,8 @@ function lifecycleNoticeGlyph(kind: WorkflowLifecycleNoticeKind): string {
 	switch (kind) {
 		case "failed":
 			return "✗";
+		case "budget_warning":
+			return "!";
 		case "awaiting_input":
 			return "？";
 		case "blocked":
@@ -761,6 +806,8 @@ function lifecycleNoticeHeadline(details: WorkflowLifecycleNoticeDetails): strin
 			return `Workflow "${name}" started`;
 		case "failed":
 			return `Workflow "${name}" failed`;
+		case "budget_warning":
+			return `Workflow "${name}" is approaching its duration budget`;
 		case "awaiting_input":
 			return `Workflow "${name}" needs input`;
 		case "blocked":

package/dist/builtin/workflows/src/extension/public-types.ts

@@ -3,7 +3,7 @@ import type { Api, Model } from "@earendil-works/pi-ai/compat";
 import type { StageSessionRuntime } from "../runs/foreground/stage-runner.js";
 import type { SessionManager } from "../shared/persistence-restore.js";
 import type { RunStatus, StageStatus } from "../shared/store-types.js";
-import type { WorkflowInputValues } from "../shared/types.js";
+import type { WorkflowBudget, WorkflowInputValues } from "../shared/types.js";
 import type { WidgetFactory } from "../tui/store-widget-installer.js";
 import type { RenderResultOpts, WorkflowToolResult } from "./render-result.js";
 import type { PiUISurface } from "./wiring.js";
@@ -197,6 +197,8 @@ export interface ExtensionAPI {
 export interface WorkflowToolArgs {
 	workflow?: string;
 	inputs?: WorkflowInputValues;
+	/** Per-run budget override for action "run". */
+	budget?: WorkflowBudget;
 	action?:
 		| "models"
 		| "run"

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

@@ -18,6 +18,7 @@ import type { ResumableWorkflowEntry } from "../durable/types.js";
 import type { JobTracker } from "../runs/background/job-tracker.js";
 import type { RunOpts } from "../runs/foreground/executor.js";
 import type { StageAdapters } from "../runs/foreground/stage-runner.js";
+import type { WorkflowBudget } from "../shared/budget.js";
 import type { Store } from "../shared/store.js";
 import type { RunSnapshot, WorkflowActor } from "../shared/store-types.js";
 import type { WorkflowExecutionPolicy } from "../shared/types.js";
@@ -27,7 +28,11 @@ import { discoverWorkflows } from "./discovery.js";
 export interface DurableResumeRuntime {
 	resumeDurableWorkflow(
 		workflowId: string,
-		options?: { readonly policy?: WorkflowExecutionPolicy; readonly actor?: WorkflowActor },
+		options?: {
+			readonly policy?: WorkflowExecutionPolicy;
+			readonly actor?: WorkflowActor;
+			readonly budget?: WorkflowBudget;
+		},
 	): Promise<ResumeDurableResult>;
 	inspectDurableWorkflow(workflowId: string): Promise<TargetedDurableInspection>;
 	listDurableResumable(): readonly ResumableWorkflowEntry[];
@@ -83,6 +88,7 @@ export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): Dura
 				registry: deps.registry,
 				baseRunOpts: {
 					...deps.baseRunOpts(options?.policy),
+					...(options?.budget === undefined ? {} : { budget: options.budget }),
 					...(options?.actor === undefined ? {} : { resumeActor: options.actor }),
 				},
 				durableBackend: backend,

package/dist/builtin/workflows/src/extension/runtime.ts

@@ -20,6 +20,7 @@ import type { Store } from "../shared/store.js";
 import { store as defaultStore } from "../shared/store.js";
 import type { RunSnapshot, WorkflowActor } from "../shared/store-types.js";
 import type {
+	WorkflowBudget,
 	WorkflowDefinition,
 	WorkflowExecutionPolicy,
 	WorkflowMcpPort,
@@ -86,7 +87,7 @@ export interface ExtensionRuntimeOpts {
 // Public interface
 // ---------------------------------------------------------------------------
 export type ResumeFailedRunResult =
-	| { ok: true; runId: string; sourceRunId: string; resumeFromStageId: string; message: string }
+	| { ok: true; runId: string; sourceRunId: string; resumeFromStageId?: string; message: string }
 	| {
 			ok: false;
 			reason: "run_not_found" | "not_resumable" | "workflow_not_found" | "insufficient_state";
@@ -119,6 +120,8 @@ export interface RuntimeDispatchOptions {
 	readonly origin?: WorkflowActor;
 	/** Who requested this resume. Only an attributable requester supplies it. */
 	readonly actor?: WorkflowActor;
+	/** Run-level budget override used when a continuation is launched. */
+	readonly budget?: WorkflowBudget;
 }
 // ---------------------------------------------------------------------------
 // Factory
@@ -214,20 +217,21 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 	function resolveResumeStage(
 		source: RunSnapshot,
 		stageId?: string,
-	): { ok: true; stageId: string } | { ok: false; message: string } {
+	): { ok: true; stageId?: string } | { ok: false; message: string } {
+		const budgetExceededSource =
+			source.result?.status === "budget_exceeded" && source.budgetState?.systemOwnedStop === true;
 		if (stageId !== undefined) {
 			const resolved = resolveUniqueResumeStage(source, stageId);
 			if (!resolved.ok) return { ok: false, message: resolved.message };
 			const stage = resolved.stage;
-			if (stage.status !== "failed")
+			if (stage.status !== "failed" && !(budgetExceededSource && stage.id === source.failedStageId))
 				return { ok: false, message: `insufficient_state: stage ${stage.name} is ${stage.status}, not failed` };
 			return { ok: true, stageId: stage.id };
 		}
 		const failedStageId = source.failedStageId ?? source.stages.find((stage) => stage.status === "failed")?.id;
-		if (failedStageId === undefined) {
-			return { ok: false, message: `insufficient_state: failed run ${source.id} does not identify a failed stage` };
-		}
-		return { ok: true, stageId: failedStageId };
+		if (failedStageId !== undefined) return { ok: true, stageId: failedStageId };
+		if (budgetExceededSource && source.stages.length === 0) return { ok: true };
+		return { ok: false, message: `insufficient_state: failed run ${source.id} does not identify a failed stage` };
 	}
 
 	async function resumeFailedRun(
@@ -241,8 +245,12 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 		}
 		const isTerminalFailedResumable =
 			source.status === "failed" && source.endedAt !== undefined && source.resumable !== false;
+		const isBudgetResumable =
+			source.result?.status === "budget_exceeded" && source.budgetState?.systemOwnedStop === true;
 		const isActiveBlockedResumable =
-			source.endedAt === undefined && source.resumable === true && source.failureRecoverability === "recoverable";
+			(source.endedAt === undefined || isBudgetResumable) &&
+			source.resumable === true &&
+			source.failureRecoverability === "recoverable";
 		if (!isTerminalFailedResumable && !isActiveBlockedResumable) {
 			return { ok: false, reason: "not_resumable", message: `run ${sourceRunId} is not a resumable workflow run` };
 		}
@@ -265,13 +273,17 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 			};
 		}
 		const stageMessage = (verb: string, runId: string): string =>
-			`${verb} workflow "${def.name}" from run ${source.id} at stage ${resolvedStage.stageId} (run ${runId}).`;
+			`${verb} workflow "${def.name}" from run ${source.id}${resolvedStage.stageId === undefined ? " at workflow start" : ` at stage ${resolvedStage.stageId}`} (run ${runId}).`;
 		const launchContinuation = () =>
 			launchDetachedUntilStartup(def, sourceInputs, {
 				...runOptions(options?.policy),
-				continuation: { source, resumeFromStageId: resolvedStage.stageId },
+				continuation: {
+					source,
+					...(resolvedStage.stageId !== undefined ? { resumeFromStageId: resolvedStage.stageId } : {}),
+				},
 				...(options?.actor === undefined ? {} : { resumeActor: options.actor }),
 				...(jobs !== undefined ? { jobs } : {}),
+				...(options?.budget === undefined ? {} : { budget: options.budget }),
 			});
 		if (isActiveBlockedResumable) {
 			// Keep the durable blocked source recoverable until fresh-ID startup admission succeeds.

package/dist/builtin/workflows/src/extension/workflow-module-loader.ts

@@ -19,6 +19,7 @@ import ralph from "../../builtin/ralph.js";
 import tournament from "../../builtin/tournament.js";
 import { isBrandedWorkflowDefinition } from "../authoring/workflow.js";
 import * as workflowsSdkSurface from "../sdk-surface.js";
+import { validateWorkflowBudget } from "../shared/budget.js";
 
 const WORKFLOWS_MODULE_SPECIFIER = "@bastani/workflows";
 const WORKFLOWS_BUILTIN_MODULE_SPECIFIER = `${WORKFLOWS_MODULE_SPECIFIER}/builtin`;
@@ -130,6 +131,10 @@ export function validateWorkflowDefinitionShape(value: unknown): string | null {
 	if (typeof d.run !== "function") {
 		return "run must be a function";
 	}
+	if (d.budget !== undefined) {
+		const reason = validateWorkflowBudget(d.budget, "budget");
+		if (reason !== null) return reason;
+	}
 	return null;
 }
 

package/dist/builtin/workflows/src/extension/workflow-prompts.ts

@@ -3,6 +3,7 @@ export const WORKFLOW_TOOL_DESCRIPTION =
 	"when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; after successfully creating and reloading a newly authored custom workflow, report the folder containing its generated code as 'Custom workflow created. You can inspect its code at: <workflow-folder-path>'; do this only for newly created custom workflows, never builtin or pre-existing workflows; " +
 	"discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " +
 	"send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " +
+	"For action 'run' and 'resume', budget accepts per-field duration, token, cost, and warning overrides; fields resolve over the workflow declaration and config, and 0 disables a field. " +
 	"For primitive prompt answers, use booleans or the documented confirm labels, exact case-insensitive select labels or 1-based indexes, and text strings for input/editor; an invalid answer remains pending and returns guidance instead of choosing a default. " +
 	"For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " +
 	"Wrap critical parts of run inputs and steering messages in <keepContext>...</keepContext> so compaction preserves them verbatim in the stages that inherit them; tag role constraints, prohibitions, must-hold criteria, and identifiers, not background or bulk reference material. " +

package/dist/builtin/workflows/src/extension/workflow-schema.ts

@@ -28,6 +28,21 @@ const WorkflowResponseSchema = Type.Union(
 	},
 );
 
+/** Run-budget declaration accepted by config, authored workflows, and tool runs. */
+export const WorkflowBudgetSchema = Type.Object(
+	{
+		maxDurationMs: Type.Optional(
+			Type.Integer({ minimum: 0, description: "Maximum run duration in milliseconds; 0 disables it." }),
+		),
+		maxTokens: Type.Optional(Type.Integer({ minimum: 0, description: "Maximum charged tokens; 0 disables it." })),
+		maxCost: Type.Optional(Type.Number({ minimum: 0, description: "Maximum cost in USD; 0 disables it." })),
+		warnAtPercent: Type.Optional(
+			Type.Number({ minimum: 0, description: "Usage percentage at which to warn; 0 disables it." }),
+		),
+	},
+	{ additionalProperties: false, description: "Optional workflow run budget." },
+);
+
 export const WorkflowParametersSchema = Type.Object(
 	{
 		workflow: Type.Optional(
@@ -41,6 +56,7 @@ export const WorkflowParametersSchema = Type.Object(
 				description: "Key/value inputs passed to a named workflow run.",
 			}),
 		),
+		budget: Type.Optional(WorkflowBudgetSchema),
 		action: Type.Optional(
 			Type.Union(
 				[

package/dist/builtin/workflows/src/extension/workflow-status-summary.ts

@@ -16,6 +16,8 @@
 import { effectiveRunStatus } from "../shared/returned-run-status.js";
 import type {
 	PendingPrompt,
+	RunBudgetSnapshot,
+	RunBudgetState,
 	RunSnapshot,
 	RunStatus,
 	StageInputRequest,
@@ -91,6 +93,8 @@ export interface WorkflowRunStatusSummary {
 	readonly tools?: readonly WorkflowStatusToolNode[];
 	readonly awaitingInputCount: number;
 	readonly awaitingInput: readonly WorkflowStatusAwaitingInput[];
+	readonly budget?: RunBudgetSnapshot;
+	readonly budgetState?: RunBudgetState;
 	readonly exitReason?: string;
 	readonly error?: string;
 }
@@ -154,16 +158,55 @@ function awaitingInputEntries(run: RunSnapshot): WorkflowStatusAwaitingInput[] {
 	return entries;
 }
 
+function budgetReport(dimension: "duration" | "tokens" | "cost", reading: number, ceiling: number) {
+	return { dimension, reading, ceiling, percent: ceiling === 0 ? 0 : (reading / ceiling) * 100 };
+}
 /** Reduce one run snapshot to its concise status summary. */
 export function summarizeRunSnapshot(run: RunSnapshot, now = Date.now()): WorkflowRunStatusSummary {
 	const awaitingInput = awaitingInputEntries(run);
+	const elapsedMs = elapsedRunMs(run, now);
+	const duration =
+		run.budget === undefined
+			? undefined
+			: run.endedAt === undefined
+				? {
+						dimension: "duration" as const,
+						reading: elapsedMs,
+						ceiling: run.budget.maxDurationMs,
+						percent: run.budget.maxDurationMs === 0 ? 0 : (elapsedMs / run.budget.maxDurationMs) * 100,
+					}
+				: (run.budgetState?.duration ?? {
+						dimension: "duration" as const,
+						reading: elapsedMs,
+						ceiling: run.budget.maxDurationMs,
+						percent: run.budget.maxDurationMs === 0 ? 0 : (elapsedMs / run.budget.maxDurationMs) * 100,
+					});
+	const usageBudgetReport = (dimension: "tokens" | "cost", ceiling: number | undefined) => {
+		if (ceiling === undefined || ceiling <= 0) return undefined;
+		return (
+			run.budgetState?.[dimension] ?? budgetReport(dimension, run.budgetState?.accounting?.[dimension] ?? 0, ceiling)
+		);
+	};
+	const tokens = usageBudgetReport("tokens", run.budget?.maxTokens) as RunBudgetState["tokens"];
+	const cost = usageBudgetReport("cost", run.budget?.maxCost) as RunBudgetState["cost"];
+	const budgetState =
+		run.budget === undefined
+			? undefined
+			: {
+					...(run.budgetState ?? {}),
+					duration,
+					...(tokens !== undefined ? { tokens } : {}),
+					...(cost !== undefined ? { cost } : {}),
+				};
 	return {
 		runId: run.id,
 		name: run.name,
 		status: effectiveRunStatus(run),
 		startedAt: run.startedAt,
 		endedAt: run.endedAt,
-		elapsedMs: elapsedRunMs(run, now),
+		elapsedMs,
+		...(run.budget !== undefined ? { budget: run.budget } : {}),
+		...(budgetState !== undefined ? { budgetState } : {}),
 		activeStages: run.stages.filter(stageIsActive).map((stage) => ({
 			stageId: stage.id,
 			name: stage.name,

package/dist/builtin/workflows/src/extension/workflow-tool-content.ts

@@ -43,6 +43,14 @@ function statusRunHint(run: WorkflowRunStatusSummary): string | undefined {
 	const tools = run.tools ?? [];
 	const toolHint =
 		tools.length > 0 ? `tools: ${tools.map((tool) => `${tool.name} (${tool.status})`).join(", ")}` : undefined;
+	const budgetHint =
+		[run.budgetState?.duration, run.budgetState?.tokens, run.budgetState?.cost]
+			.filter((budget): budget is NonNullable<typeof budget> => budget !== undefined)
+			.map(
+				(budget) =>
+					`${budget.dimension === "duration" ? "budget" : budget.dimension}: ${budget.reading}/${budget.ceiling}${budget.dimension === "duration" ? "ms" : ""} (${budget.percent.toFixed(1)}%)`,
+			)
+			.join(", ") || undefined;
 	let primary: string | undefined;
 	if (run.awaitingInputCount > 0) {
 		const stages = run.awaitingInput
@@ -55,7 +63,8 @@ function statusRunHint(run: WorkflowRunStatusSummary): string | undefined {
 	} else if (run.activeStages.length > 0) {
 		primary = `stage: ${run.activeStages.map((stage) => stage.name).join(", ")}`;
 	}
-	if (primary !== undefined) return toolHint === undefined ? primary : `${primary} · ${toolHint}`;
+	if (primary !== undefined) return [primary, budgetHint, toolHint].filter((part) => part !== undefined).join(" · ");
+	if (budgetHint !== undefined) return toolHint === undefined ? budgetHint : `${budgetHint} · ${toolHint}`;
 	if (toolHint !== undefined) return toolHint;
 	if (run.error !== undefined && run.error.length > 0) return truncateStatusText(run.error);
 	if (run.exitReason !== undefined && run.exitReason.length > 0) {

package/dist/builtin/workflows/src/extension/workflow-tool-control.ts

@@ -343,6 +343,7 @@ export async function workflowInterruptAction(args: WorkflowToolArgs): Promise<W
 async function resumeDurableShadow(
 	runId: string,
 	deps: Pick<WorkflowControlActionDeps, "getRuntime" | "policy" | "ensureWorkflowResourcesLoaded">,
+	budget?: WorkflowToolArgs["budget"],
 ): Promise<WorkflowToolResult> {
 	const runtime = deps.getRuntime();
 	let warning: string | undefined;
@@ -354,7 +355,11 @@ async function resumeDurableShadow(
 	} catch (error) {
 		warning = formatWorkflowResourceLoadWarning(error);
 	}
-	const resumed = await runtime.resumeDurableWorkflow(runId, { policy: deps.policy, actor: "agent" });
+	const resumed = await runtime.resumeDurableWorkflow(runId, {
+		policy: deps.policy,
+		actor: "agent",
+		...(budget === undefined ? {} : { budget }),
+	});
 	const message = warning === undefined ? resumed.message : `${warning}\n\n${resumed.message}`;
 	return {
 		action: "resume",
@@ -367,9 +372,14 @@ async function resumeDurableShadow(
 async function resumePreparedDurableTarget(
 	runId: string,
 	deps: Pick<WorkflowControlActionDeps, "getRuntime" | "policy">,
+	budget?: WorkflowToolArgs["budget"],
 ): Promise<WorkflowToolResult> {
 	try {
-		const resumed = await deps.getRuntime().resumeDurableWorkflow(runId, { policy: deps.policy, actor: "agent" });
+		const resumed = await deps.getRuntime().resumeDurableWorkflow(runId, {
+			policy: deps.policy,
+			actor: "agent",
+			...(budget === undefined ? {} : { budget }),
+		});
 		return {
 			action: "resume",
 			runId: resumed.ok ? resumed.runId : runId,
@@ -398,7 +408,7 @@ async function resolveExplicitDurableTarget(
 	if (resolved.kind === "malformed") {
 		return { action: "resume", runId: target, status: "noop", message: resolved.message };
 	}
-	if (resolved.kind === "durable") return resumePreparedDurableTarget(resolved.workflowId, deps);
+	if (resolved.kind === "durable") return resumePreparedDurableTarget(resolved.workflowId, deps, args.budget);
 	if (resolved.kind === "live") {
 		return workflowResumeAction({ ...args, runId: resolved.workflowId }, deps);
 	}
@@ -424,7 +434,7 @@ async function resolveExplicitDurableTarget(
 			message: `Workflow ${target} has no durable checkpoint or pending prompt progress and is not resumable.`,
 		};
 	}
-	if (durableHandle !== undefined) return resumePreparedDurableTarget(target, deps);
+	if (durableHandle !== undefined) return resumePreparedDurableTarget(target, deps, args.budget);
 	return { action: "resume", runId: target, status: "noop", message: `Run not found: ${target}` };
 }
 
@@ -450,7 +460,7 @@ export async function workflowResumeAction(
 	const backend = getDurableBackend();
 	const exact = store.runs().find((run) => run.id === target.runId);
 	const shadow = exact === undefined ? "not_shadow" : classifyDurableResumeShadow(exact, store, { backend });
-	if (shadow === "eligible") return resumeDurableShadow(target.runId, deps);
+	if (shadow === "eligible") return resumeDurableShadow(target.runId, deps, args.budget);
 	if (shadow === "ineligible") {
 		return {
 			action: "resume",
@@ -488,16 +498,18 @@ export async function workflowResumeAction(
 		!isPaused &&
 		run.exitReason !== "quit" &&
 		isWorkflowRunResumable(workflowRunResumeCandidate(run));
-	if (isDurableAuthorExit) return resumeDurableShadow(stageRunId, deps);
+	if (isDurableAuthorExit) return resumeDurableShadow(stageRunId, deps, args.budget);
 	if (isResumableContinuation) {
 		try {
 			await deps.ensureWorkflowResourcesLoaded();
 		} catch (error) {
 			warning = formatWorkflowResourceLoadWarning(error);
 		}
-		const continuation = await deps
-			.getRuntime()
-			.resumeFailedRun(stageRunId, stage.stageId, { policy: deps.policy, actor: "agent" });
+		const continuation = await deps.getRuntime().resumeFailedRun(stageRunId, stage.stageId, {
+			policy: deps.policy,
+			actor: "agent",
+			...(args.budget === undefined ? {} : { budget: args.budget }),
+		});
 		const message = warning === undefined ? continuation.message : `${warning}\n\n${continuation.message}`;
 		return {
 			action: "resume",

package/dist/builtin/workflows/src/runs/foreground/executor-continuation.ts

@@ -62,6 +62,20 @@ export function createContinuationReplayIndex(continuation: RunContinuationOpts
 			markPromptAnswerReplayed: () => {},
 		};
 	}
+	if (continuation.resumeFromStageId === undefined) {
+		if (continuation.source.stages.length > 0)
+			throw new Error(
+				`atomic-workflows: insufficient_state: continuation has no resume stage in source run ${continuation.source.id}`,
+			);
+		return {
+			decide: (input) => ({
+				kind: "execute",
+				parentIds: input.parentIds,
+				answerReplay: "unavailable",
+			}),
+			markPromptAnswerReplayed: () => {},
+		};
+	}
 	const resumeStage = continuation.source.stages.find((stage) => stage.id === continuation.resumeFromStageId);
 	if (resumeStage === undefined) {
 		throw new Error(

package/dist/builtin/workflows/src/runs/foreground/executor-lifecycle.ts

@@ -2,6 +2,7 @@ import { appendRunBlocked, appendRunEnd } from "../../shared/persistence-session
 import type { Store } from "../../shared/store.js";
 import { isTerminalRunStatus } from "../../shared/store-internal.js";
 import type {
+	RunBudgetState,
 	RunSnapshot,
 	RunStatus,
 	StageSnapshot,
@@ -101,6 +102,9 @@ export interface RunFailureMetadata {
 	readonly failedToolNodeId?: string;
 	readonly resumable: boolean;
 	readonly retryAfterMs?: number;
+	readonly endedAt?: number;
+	readonly result?: WorkflowOutputValues;
+	readonly budgetState?: RunBudgetState;
 }
 
 /**
@@ -435,30 +439,33 @@ export function finalizeKilledByFailure(
 		onRunEnd,
 	);
 }
-
 export function recordActiveBlockedFailure(
 	runId: string,
 	runSnapshot: RunSnapshot,
 	activeStore: Store,
 	persistence: WorkflowPersistencePort | undefined,
-	metadata: RunFailureMetadata & { readonly failureRecoverability: "recoverable"; readonly failedStageId: string },
+	metadata: RunFailureMetadata & { readonly failureRecoverability: "recoverable" },
 ): RunResult {
 	const blockedAt = Date.now();
+	const endedAt = metadata.budgetState?.systemOwnedStop === true ? blockedAt : undefined;
 	const recorded = activeStore.recordRunBlocked(runId, metadata.errorMessage, {
 		failureKind: metadata.failureKind,
 		...(metadata.failureCode !== undefined ? { failureCode: metadata.failureCode } : {}),
 		failureRecoverability: "recoverable",
 		...(metadata.failureDisposition !== undefined ? { failureDisposition: metadata.failureDisposition } : {}),
 		failureMessage: metadata.failureMessage,
-		failedStageId: metadata.failedStageId,
+		...(metadata.failedStageId !== undefined ? { failedStageId: metadata.failedStageId } : {}),
 		resumable: true,
 		...(metadata.retryAfterMs !== undefined ? { retryAfterMs: metadata.retryAfterMs } : {}),
+		...(endedAt !== undefined ? { endedAt } : {}),
+		...(metadata.result !== undefined ? { result: metadata.result } : {}),
+		...(metadata.budgetState !== undefined ? { budgetState: metadata.budgetState } : {}),
 		blockedAt,
 	});
 	if (recorded && persistence !== undefined) {
 		appendRunBlocked(persistence, {
 			runId,
-			failedStageId: metadata.failedStageId,
+			...(metadata.failedStageId !== undefined ? { failedStageId: metadata.failedStageId } : {}),
 			error: metadata.errorMessage,
 			failureKind: metadata.failureKind,
 			...(metadata.failureCode !== undefined ? { failureCode: metadata.failureCode } : {}),
@@ -467,12 +474,16 @@ export function recordActiveBlockedFailure(
 			...(metadata.failureDisposition !== undefined ? { failureDisposition: metadata.failureDisposition } : {}),
 			...(metadata.retryAfterMs !== undefined ? { retryAfterMs: metadata.retryAfterMs } : {}),
 			resumable: true,
+			...(endedAt !== undefined ? { endedAt } : {}),
+			...(metadata.result !== undefined ? { result: metadata.result } : {}),
+			...(metadata.budgetState !== undefined ? { budgetState: metadata.budgetState } : {}),
 			ts: blockedAt,
 		});
 	}
 	return {
 		runId,
 		status: "running",
+		...(metadata.result !== undefined ? { result: metadata.result } : {}),
 		error: metadata.errorMessage,
 		stages: [...runSnapshot.stages],
 		toolNodes: [...(runSnapshot.toolNodes ?? [])],