@selesai/code 0.5.28 → 0.6.1

package/dist/extensions/pi-subagents/src/runs/shared/usage-budget.ts

@@ -0,0 +1,65 @@
+import type { CostSummary, UsageBudgetConfig, UsageBudgetLimitConfig, UsageBudgetState } from "../../shared/types.ts";
+
+function validateLimit(value: unknown, label: string): { limit?: UsageBudgetLimitConfig; error?: string } {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: `${label} must be an object.` };
+	const raw = value as Record<string, unknown>;
+	const unknown = Object.keys(raw).find((key) => key !== "soft" && key !== "hard");
+	if (unknown) return { error: `${label}.${unknown} is not supported.` };
+	if (typeof raw.hard !== "number" || !Number.isFinite(raw.hard) || raw.hard <= 0) return { error: `${label}.hard must be a positive number.` };
+	if (raw.soft !== undefined && (typeof raw.soft !== "number" || !Number.isFinite(raw.soft) || raw.soft <= 0)) return { error: `${label}.soft must be a positive number.` };
+	if (typeof raw.soft === "number" && raw.soft > raw.hard) return { error: `${label}.soft must be less than or equal to ${label}.hard.` };
+	return { limit: { ...(typeof raw.soft === "number" ? { soft: raw.soft } : {}), hard: raw.hard } };
+}
+
+export function validateUsageBudgetConfig(value: unknown, label = "usageBudget"): { budget?: UsageBudgetConfig; error?: string } {
+	if (value === undefined) return {};
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: `${label} must be an object.` };
+	const raw = value as Record<string, unknown>;
+	const unknown = Object.keys(raw).find((key) => key !== "tokens" && key !== "costUsd");
+	if (unknown) return { error: `${label}.${unknown} is not supported.` };
+	const budget: UsageBudgetConfig = {};
+	if (raw.tokens !== undefined) {
+		const tokens = validateLimit(raw.tokens, `${label}.tokens`);
+		if (tokens.error) return { error: tokens.error };
+		budget.tokens = tokens.limit;
+	}
+	if (raw.costUsd !== undefined) {
+		const costUsd = validateLimit(raw.costUsd, `${label}.costUsd`);
+		if (costUsd.error) return { error: costUsd.error };
+		budget.costUsd = costUsd.limit;
+	}
+	if (!budget.tokens && !budget.costUsd) return { error: `${label} must include tokens or costUsd.` };
+	return { budget };
+}
+
+function metricState(limit: UsageBudgetLimitConfig | undefined, used: number): UsageBudgetState["tokens"] {
+	if (!limit) return undefined;
+	return {
+		...limit,
+		used,
+		outcome: used >= limit.hard ? "hard-exceeded" : limit.soft !== undefined && used >= limit.soft ? "soft-exceeded" : "within-budget",
+	};
+}
+
+export function usageBudgetState(config: UsageBudgetConfig | undefined, totals: CostSummary | undefined): UsageBudgetState | undefined {
+	if (!config) return undefined;
+	const inputTokens = totals?.inputTokens ?? 0;
+	const outputTokens = totals?.outputTokens ?? 0;
+	const tokens = metricState(config.tokens, inputTokens + outputTokens);
+	const costUsd = metricState(config.costUsd, totals?.costUsd ?? 0);
+	const reason = tokens?.outcome === "hard-exceeded" ? "tokens" : costUsd?.outcome === "hard-exceeded" ? "costUsd" : undefined;
+	return {
+		version: 1,
+		source: "reported",
+		...(tokens ? { tokens } : {}),
+		...(costUsd ? { costUsd } : {}),
+		exhausted: reason !== undefined,
+		...(reason ? { reason } : {}),
+	};
+}
+
+export function usageBudgetExceededMessage(state: UsageBudgetState): string {
+	if (state.reason === "tokens" && state.tokens) return `Usage budget exhausted: reported tokens ${state.tokens.used} reached hard limit ${state.tokens.hard}.`;
+	if (state.reason === "costUsd" && state.costUsd) return `Usage budget exhausted: reported cost $${state.costUsd.used.toFixed(6)} reached hard limit $${state.costUsd.hard.toFixed(6)}.`;
+	return "Usage budget exhausted.";
+}

package/dist/extensions/pi-subagents/src/runs/shared/workflow-graph.ts

@@ -1,4 +1,4 @@
-import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { isCheckpointStep, isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
 import type { SingleResult, SubagentRunMode, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../shared/types.ts";
 
 export interface WorkflowGraphBuildInput {
@@ -26,6 +26,8 @@ function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undef
 			return "paused";
 		case "detached":
 			return "detached";
+		case "rejected":
+			return "rejected";
 		case "pending":
 			return "pending";
 		default:
@@ -62,6 +64,7 @@ function seqLabel(step: SequentialStep, stepIndex: number): string {
 
 function summarizeParallelStatuses(statuses: WorkflowNodeStatus[]): WorkflowNodeStatus {
 	if (statuses.some((status) => status === "running")) return "running";
+	if (statuses.some((status) => status === "rejected")) return "rejected";
 	if (statuses.some((status) => status === "failed")) return "failed";
 	if (statuses.some((status) => status === "paused")) return "paused";
 	if (statuses.some((status) => status === "detached")) return "detached";
@@ -78,6 +81,28 @@ export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): Work
 
 	for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
 		const step = input.steps[stepIndex]!;
+		if (isCheckpointStep(step)) {
+			const status = normalizeStatus(input.stepStatuses?.[flatIndex]?.status)
+				?? (input.currentStepIndex === stepIndex ? "paused" : "pending");
+			const checkpoint = { name: step.checkpoint, ...(step.message ? { message: step.message } : {}), status: status === "rejected" ? "rejected" as const : status === "completed" ? "approved" as const : "pending" as const, stepIndex };
+			const id = `step-${stepIndex}`;
+			nodes.push({
+				id,
+				kind: "checkpoint",
+				phase: step.phase,
+				label: step.label?.trim() || step.checkpoint,
+				status,
+				flatIndex,
+				stepIndex,
+				checkpoint,
+				error: input.stepStatuses?.[flatIndex]?.error,
+			});
+			pushPhase(phases, step.phase, id);
+			if (status === "paused" || input.currentStepIndex === stepIndex) currentNodeId = id;
+			flatIndex++;
+			continue;
+		}
+
 		if (isParallelStep(step)) {
 			const groupId = `step-${stepIndex}`;
 			const children: WorkflowGraphNode[] = [];

package/dist/extensions/pi-subagents/src/shared/settings.ts

@@ -114,6 +114,14 @@ export interface DynamicParallelStep {
 	gateOn?: ChainGateLayer;
 }
 
+/** Approval checkpoint: pause before later chain steps until parent approval. */
+export interface CheckpointStep {
+	checkpoint: string;
+	message?: string;
+	phase?: string;
+	label?: string;
+}
+
 /** Parallel step: multiple agents running concurrently */
 export interface ParallelStep {
 	parallel: ParallelTaskItem[];
@@ -126,12 +134,16 @@ export interface ParallelStep {
 }
 
 /** Union type for chain steps */
-export type ChainStep = SequentialStep | ParallelStep | DynamicParallelStep;
+export type ChainStep = SequentialStep | ParallelStep | DynamicParallelStep | CheckpointStep;
 
 // =============================================================================
 // Type Guards
 // =============================================================================
 
+export function isCheckpointStep(step: ChainStep): step is CheckpointStep {
+	return "checkpoint" in step;
+}
+
 export function isParallelStep(step: ChainStep): step is ParallelStep {
 	return "parallel" in step && Array.isArray((step as ParallelStep).parallel);
 }
@@ -142,6 +154,9 @@ export function isDynamicParallelStep(step: ChainStep): step is DynamicParallelS
 
 /** Get all agent names in a step (single for sequential, multiple for parallel) */
 export function getStepAgents(step: ChainStep): string[] {
+	if (isCheckpointStep(step)) {
+		return [];
+	}
 	if (isParallelStep(step)) {
 		return step.parallel.map((t) => t.agent);
 	}
@@ -209,6 +224,7 @@ export function resolveChainTemplates(
 	steps: ChainStep[],
 ): ResolvedTemplates {
 	return steps.map((step, i) => {
+		if (isCheckpointStep(step)) return "";
 		if (isParallelStep(step)) {
 			// Parallel step: resolve each task's template
 			return step.parallel.map((task) => {