@duckmind/dm-darwin-x64 0.43.2 → 0.43.8

package/extensions/dm-subagents/src/runs/shared/turn-budget.ts

@@ -1,52 +0,0 @@
-import type { ResolvedTurnBudget, TurnBudgetState } from "../../shared/types.ts";
-
-export const DEFAULT_TURN_BUDGET_GRACE_TURNS = 1;
-
-export function appendTurnBudgetSystemPrompt(systemPrompt: string, budget: ResolvedTurnBudget | undefined): string {
-	if (!budget) return systemPrompt;
-	const grace = budget.graceTurns === 1 ? "1 additional assistant turn" : `${budget.graceTurns} additional assistant turns`;
-	const block = [
-		"## Turn budget",
-		`This child run has a soft budget of ${budget.maxTurns} assistant turn${budget.maxTurns === 1 ? "" : "s"}.`,
-		`After that, ${grace} may be allowed only for a final wrap-up.`,
-		"When you approach or reach the soft budget, stop starting new tool work and return the final answer immediately.",
-		"This runner uses process-mode execution, so live steering after launch may be unavailable; treat this instruction as the wrap-up request.",
-		"If you continue past the soft budget plus grace turns, the supervisor may abort the process and return only partial output.",
-	].join("\n");
-	return systemPrompt.trim() ? `${systemPrompt.trim()}\n\n${block}` : block;
-}
-
-export function turnBudgetSoftNote(budget: ResolvedTurnBudget, turnCount: number): string {
-	return `Turn budget wrap-up was requested after ${turnCount} assistant turn${turnCount === 1 ? "" : "s"} (soft limit ${budget.maxTurns}, grace ${budget.graceTurns}). Process-mode live steering is unavailable, so the child was warned at launch to wrap up by this budget. Output may be partial.`;
-}
-
-export function turnBudgetExceededMessage(budget: ResolvedTurnBudget, turnCount: number): string {
-	return `Subagent exceeded turn budget after ${turnCount} assistant turn${turnCount === 1 ? "" : "s"} (soft limit ${budget.maxTurns} + grace ${budget.graceTurns}).`;
-}
-
-export function formatTurnBudgetOutput(message: string, output: string): string {
-	return output.trim()
-		? `${message}\n\nPartial output before turn-budget abort:\n${output}`
-		: message;
-}
-
-export function initialTurnBudgetState(budget: ResolvedTurnBudget): TurnBudgetState {
-	return { ...budget, outcome: "within-budget", turnCount: 0 };
-}
-
-export function turnBudgetState(budget: ResolvedTurnBudget, turnCount: number, exceeded: boolean): TurnBudgetState {
-	return {
-		...budget,
-		turnCount,
-		outcome: exceeded ? "exceeded" : "wrap-up-requested",
-		wrapUpRequestedAtTurn: budget.maxTurns,
-		...(exceeded ? { exceededAtTurn: turnCount } : {}),
-	};
-}
-
-export function shouldAbortForTurnBudget(budget: ResolvedTurnBudget, turnCount: number, terminalAssistantStop: boolean): boolean {
-	const hardLimit = budget.maxTurns + budget.graceTurns;
-	if (turnCount < hardLimit) return false;
-	if (turnCount > hardLimit) return true;
-	return !terminalAssistantStop;
-}

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

@@ -1,206 +0,0 @@
-import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
-import type { SingleResult, SubagentRunMode, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../shared/types.ts";
-
-export interface WorkflowGraphBuildInput {
-	runId: string;
-	mode?: SubagentRunMode;
-	steps: ChainStep[];
-	results?: Array<Pick<SingleResult, "exitCode" | "detached" | "interrupted" | "error" | "acceptance">>;
-	currentFlatIndex?: number;
-	currentStepIndex?: number;
-	stepStatuses?: Array<{ status?: string; error?: string }>;
-	dynamicChildren?: Record<number, Array<{ agent: string; label?: string; flatIndex: number; itemKey: string; outputName?: string; structured?: boolean; error?: string }>>;
-	dynamicGroupStatuses?: Record<number, { status: WorkflowNodeStatus; error?: string; acceptance?: SingleResult["acceptance"] }>;
-}
-
-function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undefined {
-	switch (status) {
-		case "complete":
-		case "completed":
-			return "completed";
-		case "running":
-			return "running";
-		case "failed":
-			return "failed";
-		case "paused":
-			return "paused";
-		case "detached":
-			return "detached";
-		case "pending":
-			return "pending";
-		default:
-			return undefined;
-	}
-}
-
-function resultStatus(result: Pick<SingleResult, "exitCode" | "detached" | "interrupted"> | undefined): WorkflowNodeStatus | undefined {
-	if (!result) return undefined;
-	if (result.detached) return "detached";
-	if (result.interrupted) return "paused";
-	return result.exitCode === 0 ? "completed" : "failed";
-}
-
-function nodeStatus(input: WorkflowGraphBuildInput, flatIndex: number): WorkflowNodeStatus {
-	return normalizeStatus(input.stepStatuses?.[flatIndex]?.status)
-		?? resultStatus(input.results?.[flatIndex])
-		?? (input.currentFlatIndex === flatIndex ? "running" : "pending");
-}
-
-function pushPhase(phases: WorkflowGraphSnapshot["phases"], phase: string | undefined, nodeId: string): void {
-	if (!phase) return;
-	let group = phases.find((candidate) => candidate.title === phase);
-	if (!group) {
-		group = { title: phase, nodeIds: [] };
-		phases.push(group);
-	}
-	group.nodeIds.push(nodeId);
-}
-
-function seqLabel(step: SequentialStep, stepIndex: number): string {
-	return step.label?.trim() || step.agent || `Step ${stepIndex + 1}`;
-}
-
-function summarizeParallelStatuses(statuses: WorkflowNodeStatus[]): WorkflowNodeStatus {
-	if (statuses.some((status) => status === "running")) return "running";
-	if (statuses.some((status) => status === "failed")) return "failed";
-	if (statuses.some((status) => status === "paused")) return "paused";
-	if (statuses.some((status) => status === "detached")) return "detached";
-	if (statuses.length > 0 && statuses.every((status) => status === "completed")) return "completed";
-	if (statuses.some((status) => status === "completed")) return "running";
-	return "pending";
-}
-
-export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): WorkflowGraphSnapshot {
-	const nodes: WorkflowGraphNode[] = [];
-	const phases: WorkflowGraphSnapshot["phases"] = [];
-	let flatIndex = 0;
-	let currentNodeId: string | undefined;
-
-	for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
-		const step = input.steps[stepIndex]!;
-		if (isParallelStep(step)) {
-			const groupId = `step-${stepIndex}`;
-			const children: WorkflowGraphNode[] = [];
-			const childStatuses: WorkflowNodeStatus[] = [];
-			for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
-				const task = step.parallel[taskIndex]!;
-				const status = nodeStatus(input, flatIndex);
-				childStatuses.push(status);
-				const childId = `step-${stepIndex}-agent-${taskIndex}`;
-				const child: WorkflowGraphNode = {
-					id: childId,
-					kind: "agent",
-					agent: task.agent,
-					phase: task.phase,
-					label: task.label?.trim() || task.agent || `Agent ${taskIndex + 1}`,
-					status,
-					flatIndex,
-					stepIndex,
-					outputName: task.as,
-					structured: Boolean(task.outputSchema),
-					acceptanceStatus: input.results?.[flatIndex]?.acceptance?.status,
-					error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
-				};
-				children.push(child);
-				pushPhase(phases, task.phase, childId);
-				if (status === "running" || input.currentFlatIndex === flatIndex) currentNodeId = childId;
-				flatIndex++;
-			}
-			const groupStatus = summarizeParallelStatuses(childStatuses);
-			if (input.currentStepIndex === stepIndex && !currentNodeId) currentNodeId = groupId;
-			nodes.push({
-				id: groupId,
-				kind: "parallel-group",
-				label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
-				status: groupStatus,
-				stepIndex,
-				children,
-			});
-			continue;
-		}
-
-		if (isDynamicParallelStep(step)) {
-			const groupId = `step-${stepIndex}`;
-			const materialized = input.dynamicChildren?.[stepIndex] ?? [];
-			const groupOverride = input.dynamicGroupStatuses?.[stepIndex];
-			const children: WorkflowGraphNode[] = [];
-			const childStatuses: WorkflowNodeStatus[] = [];
-			for (let taskIndex = 0; taskIndex < materialized.length; taskIndex++) {
-				const task = materialized[taskIndex]!;
-				const status = nodeStatus(input, task.flatIndex);
-				childStatuses.push(status);
-				const childId = `step-${stepIndex}-item-${task.itemKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`;
-				const child: WorkflowGraphNode = {
-					id: childId,
-					kind: "agent",
-					agent: task.agent,
-					phase: step.parallel.phase ?? step.phase,
-					label: task.label?.trim() || step.parallel.label?.trim() || `${task.agent} ${task.itemKey}`,
-					status,
-					flatIndex: task.flatIndex,
-					stepIndex,
-					itemKey: task.itemKey,
-					outputName: task.outputName,
-					structured: task.structured,
-					acceptanceStatus: input.results?.[task.flatIndex]?.acceptance?.status,
-					error: input.stepStatuses?.[task.flatIndex]?.error ?? input.results?.[task.flatIndex]?.error ?? task.error,
-				};
-				children.push(child);
-				pushPhase(phases, child.phase, childId);
-				if (status === "running" || input.currentFlatIndex === task.flatIndex) currentNodeId = childId;
-			}
-			const groupStatus = groupOverride?.status ?? (children.length > 0 ? summarizeParallelStatuses(childStatuses) : (input.currentStepIndex === stepIndex ? "running" : "pending"));
-			if (input.currentStepIndex === stepIndex && !currentNodeId) currentNodeId = groupId;
-			nodes.push({
-				id: groupId,
-				kind: "dynamic-parallel-group",
-				label: step.label?.trim() || step.parallel.label?.trim() || `Dynamic fanout (${step.collect.as})`,
-				status: groupStatus,
-				stepIndex,
-				outputName: step.collect.as,
-				structured: Boolean(step.collect.outputSchema),
-				acceptanceStatus: groupOverride?.acceptance?.status,
-				error: groupOverride?.error,
-				dynamic: {
-					sourceOutput: step.expand.from.output,
-					sourcePath: step.expand.from.path,
-					itemName: step.expand.item ?? "item",
-					maxItems: step.expand.maxItems,
-					collectAs: step.collect.as,
-				},
-				children,
-			});
-			if (materialized.length > 0) flatIndex = Math.max(flatIndex, ...materialized.map((child) => child.flatIndex + 1));
-			continue;
-		}
-
-		const seq = step as SequentialStep;
-		const status = nodeStatus(input, flatIndex);
-		const id = `step-${stepIndex}`;
-		nodes.push({
-			id,
-			kind: "step",
-			agent: seq.agent,
-			phase: seq.phase,
-			label: seqLabel(seq, stepIndex),
-			status,
-			flatIndex,
-			stepIndex,
-			outputName: seq.as,
-			structured: Boolean(seq.outputSchema),
-			acceptanceStatus: input.results?.[flatIndex]?.acceptance?.status,
-			error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
-		});
-		pushPhase(phases, seq.phase, id);
-		if (status === "running" || input.currentFlatIndex === flatIndex || input.currentStepIndex === stepIndex) currentNodeId = id;
-		flatIndex++;
-	}
-
-	return {
-		runId: input.runId,
-		mode: input.mode ?? "chain",
-		phases,
-		nodes,
-		currentNodeId,
-	};
-}