@bastani/atomic 0.9.11-alpha.7 → 0.9.11-alpha.9

package/dist/builtin/workflows/src/shared/expanded-workflow-graph.ts

@@ -1,276 +1,285 @@
 import type { RunSnapshot, StageSnapshot, StoreSnapshot, ToolNodeSnapshot } from "./store-types.js";
-import {
-  authoritativeWorkflowChildRunId,
-  reciprocalWorkflowRootRunId,
-} from "./workflow-run-ownership.js";
+import { authoritativeWorkflowChildRunId, reciprocalWorkflowRootRunId } from "./workflow-run-ownership.js";
 
 export interface ExpandedWorkflowStageTarget {
-  readonly runId: string;
-  readonly stageId: string;
-  readonly runName: string;
-  readonly depth: number;
+	readonly runId: string;
+	readonly stageId: string;
+	readonly runName: string;
+	readonly depth: number;
 }
 
 export interface ExpandedWorkflowStage extends StageSnapshot {
-  readonly workflowGraphTarget: ExpandedWorkflowStageTarget;
+	readonly workflowGraphTarget: ExpandedWorkflowStageTarget;
 }
 
 export interface ExpandedWorkflowTool extends ToolNodeSnapshot {
-  readonly runId: string;
-  readonly runName: string;
-  readonly depth: number;
+	readonly runId: string;
+	readonly runName: string;
+	readonly depth: number;
 }
 
 export type ExpandedWorkflowNode =
-  | { readonly kind: "stage"; readonly stage: ExpandedWorkflowStage }
-  | { readonly kind: "tool"; readonly tool: ExpandedWorkflowTool };
+	| { readonly kind: "stage"; readonly stage: ExpandedWorkflowStage }
+	| { readonly kind: "tool"; readonly tool: ExpandedWorkflowTool };
 
 export interface ExpandedWorkflowGraph {
-  /** Stage-only inspection/control nodes; excludes tool projections. */
-  readonly stages: readonly ExpandedWorkflowStage[];
-  readonly tools: readonly ExpandedWorkflowTool[];
-  readonly nodes: readonly ExpandedWorkflowNode[];
-  /** All stage-compatible render projections, including non-attachable tool cards. */
-  readonly renderStages: readonly ExpandedWorkflowStage[];
-  /** Stage targets only; tool nodes intentionally have no chat/control target. */
-  readonly targets: ReadonlyMap<string, ExpandedWorkflowStageTarget>;
+	/** Stage-only inspection/control nodes; excludes tool projections. */
+	readonly stages: readonly ExpandedWorkflowStage[];
+	readonly tools: readonly ExpandedWorkflowTool[];
+	readonly nodes: readonly ExpandedWorkflowNode[];
+	/** All stage-compatible render projections, including non-attachable tool cards. */
+	readonly renderStages: readonly ExpandedWorkflowStage[];
+	/**
+	 * Control targets for stages and tool nodes. Tool entries are abort-only
+	 * control targets: they stay `attachable: false` and never become chat
+	 * targets (see `graph-view-state._stageChatTarget`).
+	 */
+	readonly targets: ReadonlyMap<string, ExpandedWorkflowStageTarget>;
 }
 
 interface ExpandedRunResult {
-  readonly stages: ExpandedWorkflowStage[];
-  readonly tools: ExpandedWorkflowTool[];
-  readonly nodes: ExpandedWorkflowNode[];
-  readonly terminalIds: readonly string[];
+	readonly stages: ExpandedWorkflowStage[];
+	readonly tools: ExpandedWorkflowTool[];
+	readonly nodes: ExpandedWorkflowNode[];
+	readonly terminalIds: readonly string[];
 }
 
 type LocalItem =
-  | { readonly kind: "stage"; readonly stage: StageSnapshot; readonly sourceIndex: number }
-  | { readonly kind: "tool"; readonly tool: ToolNodeSnapshot; readonly sourceIndex: number };
+	| { readonly kind: "stage"; readonly stage: StageSnapshot; readonly sourceIndex: number }
+	| { readonly kind: "tool"; readonly tool: ToolNodeSnapshot; readonly sourceIndex: number };
 
 function virtualNodeId(runId: string, nodeId: string, isRootRun: boolean): string {
-  return isRootRun ? nodeId : `${runId}:${nodeId}`;
+	return isRootRun ? nodeId : `${runId}:${nodeId}`;
 }
 
 function localItems(run: RunSnapshot): LocalItem[] {
-  const stages = run.stages.map((stage, sourceIndex) => ({ kind: "stage" as const, stage, sourceIndex }));
-  const tools = (run.toolNodes ?? []).map((tool, sourceIndex) => ({ kind: "tool" as const, tool, sourceIndex }));
-  return [...stages, ...tools].sort((left, right) => {
-    const leftOrder = left.kind === "stage" ? left.stage.executionOrder : left.tool.executionOrder;
-    const rightOrder = right.kind === "stage" ? right.stage.executionOrder : right.tool.executionOrder;
-    if (leftOrder !== undefined || rightOrder !== undefined) return (leftOrder ?? Number.MAX_SAFE_INTEGER) - (rightOrder ?? Number.MAX_SAFE_INTEGER);
-    if (left.kind !== right.kind) return left.kind === "stage" ? -1 : 1;
-    return left.sourceIndex - right.sourceIndex;
-  });
+	const stages = run.stages.map((stage, sourceIndex) => ({ kind: "stage" as const, stage, sourceIndex }));
+	const tools = (run.toolNodes ?? []).map((tool, sourceIndex) => ({ kind: "tool" as const, tool, sourceIndex }));
+	return [...stages, ...tools].sort((left, right) => {
+		const leftOrder = left.kind === "stage" ? left.stage.executionOrder : left.tool.executionOrder;
+		const rightOrder = right.kind === "stage" ? right.stage.executionOrder : right.tool.executionOrder;
+		if (leftOrder !== undefined || rightOrder !== undefined)
+			return (leftOrder ?? Number.MAX_SAFE_INTEGER) - (rightOrder ?? Number.MAX_SAFE_INTEGER);
+		if (left.kind !== right.kind) return left.kind === "stage" ? -1 : 1;
+		return left.sourceIndex - right.sourceIndex;
+	});
 }
 
 function itemId(item: LocalItem): string {
-  return item.kind === "stage" ? item.stage.id : item.tool.id;
+	return item.kind === "stage" ? item.stage.id : item.tool.id;
 }
 
 function itemParents(item: LocalItem): readonly string[] {
-  return item.kind === "stage" ? item.stage.parentIds : item.tool.parentIds;
+	return item.kind === "stage" ? item.stage.parentIds : item.tool.parentIds;
 }
 
 function localTerminalIds(items: readonly LocalItem[]): readonly string[] {
-  const parents = new Set(items.flatMap((item) => [...itemParents(item)]));
-  const terminals = items.map(itemId).filter((id) => !parents.has(id));
-  return terminals.length > 0 ? terminals : items.map(itemId);
+	const parents = new Set(items.flatMap((item) => [...itemParents(item)]));
+	const terminals = items.map(itemId).filter((id) => !parents.has(id));
+	return terminals.length > 0 ? terminals : items.map(itemId);
 }
 
 function isTerminalNonCompletedBoundary(stage: StageSnapshot): boolean {
-  return stage.status === "failed" || stage.status === "skipped";
+	return stage.status === "failed" || stage.status === "skipped";
 }
 
-
 function childAliasFor(stage: StageSnapshot): string | undefined {
-  if (isTerminalNonCompletedBoundary(stage)) return undefined;
-  if (stage.status === "completed") return stage.workflowChild?.alias ?? stage.workflowChildRun?.alias;
-  return stage.workflowChildRun?.alias;
+	if (isTerminalNonCompletedBoundary(stage)) return undefined;
+	if (stage.status === "completed") return stage.workflowChild?.alias ?? stage.workflowChildRun?.alias;
+	return stage.workflowChildRun?.alias;
 }
 
 function projectedToolStatus(tool: ToolNodeSnapshot): StageSnapshot["status"] {
-  if (tool.status === "cached") return "completed";
-  if (tool.status === "cancelled") return "skipped";
-  return tool.status;
+	if (tool.status === "cached") return "completed";
+	if (tool.status === "cancelled") return "skipped";
+	return tool.status;
 }
 
 export function expandWorkflowGraph(snapshot: StoreSnapshot, rootRunId: string): ExpandedWorkflowGraph {
-  const runById = new Map(snapshot.runs.map((run) => [run.id, run]));
-  const root = runById.get(rootRunId);
-  if (!root) return { stages: [], renderStages: [], tools: [], nodes: [], targets: new Map() };
-  const targets = new Map<string, ExpandedWorkflowStageTarget>();
-  const rootOwnerByRunId = new Map<string, string | undefined>();
-  const rootOwnerFor = (runId: string): string | undefined => {
-    if (rootOwnerByRunId.has(runId)) return rootOwnerByRunId.get(runId);
-    const owner = reciprocalWorkflowRootRunId(runById, runId);
-    rootOwnerByRunId.set(runId, owner);
-    return owner;
-  };
-  const visiting = new Set<string>();
-  const expandedChildren = new Set<string>();
+	const runById = new Map(snapshot.runs.map((run) => [run.id, run]));
+	const root = runById.get(rootRunId);
+	if (!root) return { stages: [], renderStages: [], tools: [], nodes: [], targets: new Map() };
+	const targets = new Map<string, ExpandedWorkflowStageTarget>();
+	const rootOwnerByRunId = new Map<string, string | undefined>();
+	const rootOwnerFor = (runId: string): string | undefined => {
+		if (rootOwnerByRunId.has(runId)) return rootOwnerByRunId.get(runId);
+		const owner = reciprocalWorkflowRootRunId(runById, runId);
+		rootOwnerByRunId.set(runId, owner);
+		return owner;
+	};
+	const visiting = new Set<string>();
+	const expandedChildren = new Set<string>();
 
-  const expandRun = (run: RunSnapshot, depth: number, incomingParentIds: readonly string[]): ExpandedRunResult => {
-    if (visiting.has(run.id)) return { stages: [], tools: [], nodes: [], terminalIds: [] };
-    visiting.add(run.id);
-    const isRootRun = run.id === rootRunId;
-    const items = localItems(run);
-    const stages: ExpandedWorkflowStage[] = [];
-    const tools: ExpandedWorkflowTool[] = [];
-    const nodes: ExpandedWorkflowNode[] = [];
-    const stageById = new Map(run.stages.map((stage) => [stage.id, stage]));
-    const boundaryExpansions = new Map<string, ExpandedRunResult | null>();
+	const expandRun = (run: RunSnapshot, depth: number, incomingParentIds: readonly string[]): ExpandedRunResult => {
+		if (visiting.has(run.id)) return { stages: [], tools: [], nodes: [], terminalIds: [] };
+		visiting.add(run.id);
+		const isRootRun = run.id === rootRunId;
+		const items = localItems(run);
+		const stages: ExpandedWorkflowStage[] = [];
+		const tools: ExpandedWorkflowTool[] = [];
+		const nodes: ExpandedWorkflowNode[] = [];
+		const stageById = new Map(run.stages.map((stage) => [stage.id, stage]));
+		const boundaryExpansions = new Map<string, ExpandedRunResult | null>();
 
-    const validChildRunFor = (stage: StageSnapshot): RunSnapshot | undefined => {
-      const childRunId = authoritativeWorkflowChildRunId(stage);
-      if (childRunId === undefined) return undefined;
-      const childRun = runById.get(childRunId);
-      const runRoot = rootOwnerFor(run.id);
-      if (
-        childRun === undefined ||
-        expandedChildren.has(childRun.id) ||
-        localItems(childRun).length === 0 ||
-        childRun.parentRunId !== run.id ||
-        childRun.parentStageId !== stage.id ||
-        runRoot === undefined ||
-        rootOwnerFor(childRun.id) !== runRoot
-      ) {
-        return undefined;
-      }
-      return childRun;
-    };
+		const validChildRunFor = (stage: StageSnapshot): RunSnapshot | undefined => {
+			const childRunId = authoritativeWorkflowChildRunId(stage);
+			if (childRunId === undefined) return undefined;
+			const childRun = runById.get(childRunId);
+			const runRoot = rootOwnerFor(run.id);
+			if (
+				childRun === undefined ||
+				expandedChildren.has(childRun.id) ||
+				localItems(childRun).length === 0 ||
+				childRun.parentRunId !== run.id ||
+				childRun.parentStageId !== stage.id ||
+				runRoot === undefined ||
+				rootOwnerFor(childRun.id) !== runRoot
+			) {
+				return undefined;
+			}
+			return childRun;
+		};
 
-    const resolvedParentIdsFor = (item: LocalItem): string[] => {
-      const parentIds = itemParents(item);
-      if (parentIds.length === 0) return [...incomingParentIds];
-      return parentIds.flatMap((parentId) => {
-        const parentStage = stageById.get(parentId);
-        const parentExpansion = parentStage === undefined
-          ? undefined
-          : boundaryExpansionFor(parentStage);
-        return parentExpansion?.terminalIds.length
-          ? [...parentExpansion.terminalIds]
-          : [virtualNodeId(run.id, parentId, isRootRun)];
-      });
-    };
+		const resolvedParentIdsFor = (item: LocalItem): string[] => {
+			const parentIds = itemParents(item);
+			if (parentIds.length === 0) return [...incomingParentIds];
+			return parentIds.flatMap((parentId) => {
+				const parentStage = stageById.get(parentId);
+				const parentExpansion = parentStage === undefined ? undefined : boundaryExpansionFor(parentStage);
+				return parentExpansion?.terminalIds.length
+					? [...parentExpansion.terminalIds]
+					: [virtualNodeId(run.id, parentId, isRootRun)];
+			});
+		};
 
-    const boundaryExpansionFor = (stage: StageSnapshot): ExpandedRunResult | undefined => {
-      const cached = boundaryExpansions.get(stage.id);
-      if (cached !== undefined) return cached ?? undefined;
-      const childRun = validChildRunFor(stage);
-      if (childRun === undefined) return undefined;
-      boundaryExpansions.set(stage.id, null);
-      expandedChildren.add(childRun.id);
-      const stageItem: LocalItem = { kind: "stage", stage, sourceIndex: 0 };
-      const childExpanded = expandRun(childRun, depth + 1, resolvedParentIdsFor(stageItem));
-      if (childExpanded.stages.length === 0 || childExpanded.terminalIds.length === 0) return undefined;
-      boundaryExpansions.set(stage.id, childExpanded);
-      return childExpanded;
-    };
+		const boundaryExpansionFor = (stage: StageSnapshot): ExpandedRunResult | undefined => {
+			const cached = boundaryExpansions.get(stage.id);
+			if (cached !== undefined) return cached ?? undefined;
+			const childRun = validChildRunFor(stage);
+			if (childRun === undefined) return undefined;
+			boundaryExpansions.set(stage.id, null);
+			expandedChildren.add(childRun.id);
+			const stageItem: LocalItem = { kind: "stage", stage, sourceIndex: 0 };
+			const childExpanded = expandRun(childRun, depth + 1, resolvedParentIdsFor(stageItem));
+			if (childExpanded.stages.length === 0 || childExpanded.terminalIds.length === 0) return undefined;
+			boundaryExpansions.set(stage.id, childExpanded);
+			return childExpanded;
+		};
 
-    for (const item of items) {
-      const sourceId = itemId(item);
-      const id = virtualNodeId(run.id, sourceId, isRootRun);
-      const resolvedParentIds = resolvedParentIdsFor(item);
+		for (const item of items) {
+			const sourceId = itemId(item);
+			const id = virtualNodeId(run.id, sourceId, isRootRun);
+			const resolvedParentIds = resolvedParentIdsFor(item);
 
-      if (item.kind === "tool") {
-        const tool: ExpandedWorkflowTool = {
-          ...item.tool,
-          id,
-          parentIds: Object.freeze(resolvedParentIds),
-          runId: run.id,
-          runName: run.name,
-          depth,
-        };
-        const projectionTarget: ExpandedWorkflowStageTarget = {
-          runId: run.id,
-          stageId: item.tool.id,
-          runName: run.name,
-          depth,
-        };
-        const projection: ExpandedWorkflowStage = {
-          id,
-          name: item.tool.name,
-          status: projectedToolStatus(item.tool),
-          parentIds: Object.freeze(resolvedParentIds),
-          executionOrder: item.tool.executionOrder,
-          nodeKind: "tool",
-          toolStatus: item.tool.status,
-          startedAt: item.tool.startedAt,
-          endedAt: item.tool.endedAt,
-          result: item.tool.resultSummary,
-          error: item.tool.error,
-          toolEvents: [],
-          attachable: false,
-          workflowGraphTarget: projectionTarget,
-        };
-        tools.push(tool);
-        stages.push(projection);
-        nodes.push({ kind: "tool", tool });
-        continue;
-      }
+			if (item.kind === "tool") {
+				const tool: ExpandedWorkflowTool = {
+					...item.tool,
+					id,
+					parentIds: Object.freeze(resolvedParentIds),
+					runId: run.id,
+					runName: run.name,
+					depth,
+				};
+				const projectionTarget: ExpandedWorkflowStageTarget = {
+					runId: run.id,
+					stageId: item.tool.id,
+					runName: run.name,
+					depth,
+				};
+				const projection: ExpandedWorkflowStage = {
+					id,
+					name: item.tool.name,
+					status: projectedToolStatus(item.tool),
+					parentIds: Object.freeze(resolvedParentIds),
+					executionOrder: item.tool.executionOrder,
+					nodeKind: "tool",
+					toolStatus: item.tool.status,
+					startedAt: item.tool.startedAt,
+					endedAt: item.tool.endedAt,
+					result: item.tool.resultSummary,
+					error: item.tool.error,
+					toolEvents: [],
+					attachable: false,
+					workflowGraphTarget: projectionTarget,
+				};
+				targets.set(id, projectionTarget);
+				tools.push(tool);
+				stages.push(projection);
+				nodes.push({ kind: "tool", tool });
+				continue;
+			}
 
-      const childExpanded = boundaryExpansionFor(item.stage);
-      if (childExpanded !== undefined) {
-        stages.push(...childExpanded.stages);
-        tools.push(...childExpanded.tools);
-        nodes.push(...childExpanded.nodes);
-        continue;
-      }
+			const childExpanded = boundaryExpansionFor(item.stage);
+			if (childExpanded !== undefined) {
+				stages.push(...childExpanded.stages);
+				tools.push(...childExpanded.tools);
+				nodes.push(...childExpanded.nodes);
+				continue;
+			}
 
-      const target: ExpandedWorkflowStageTarget = {
-        runId: run.id,
-        stageId: item.stage.id,
-        runName: run.name,
-        depth,
-      };
-      targets.set(id, target);
-      const stage: ExpandedWorkflowStage = {
-        ...item.stage,
-        id,
-        parentIds: Object.freeze(resolvedParentIds),
-        workflowGraphTarget: target,
-      };
-      stages.push(stage);
-      nodes.push({ kind: "stage", stage });
-    }
+			const target: ExpandedWorkflowStageTarget = {
+				runId: run.id,
+				stageId: item.stage.id,
+				runName: run.name,
+				depth,
+			};
+			targets.set(id, target);
+			const stage: ExpandedWorkflowStage = {
+				...item.stage,
+				id,
+				parentIds: Object.freeze(resolvedParentIds),
+				workflowGraphTarget: target,
+			};
+			stages.push(stage);
+			nodes.push({ kind: "stage", stage });
+		}
 
-    const terminalIds = localTerminalIds(items).flatMap((sourceId) => {
-      const stage = stageById.get(sourceId);
-      const replacement = stage === undefined ? undefined : boundaryExpansionFor(stage);
-      return replacement?.terminalIds.length
-        ? [...replacement.terminalIds]
-        : [virtualNodeId(run.id, sourceId, isRootRun)];
-    });
-    visiting.delete(run.id);
-    return { stages, tools, nodes, terminalIds };
-  };
+		const terminalIds = localTerminalIds(items).flatMap((sourceId) => {
+			const stage = stageById.get(sourceId);
+			const replacement = stage === undefined ? undefined : boundaryExpansionFor(stage);
+			return replacement?.terminalIds.length
+				? [...replacement.terminalIds]
+				: [virtualNodeId(run.id, sourceId, isRootRun)];
+		});
+		visiting.delete(run.id);
+		return { stages, tools, nodes, terminalIds };
+	};
 
-  const expanded = expandRun(root, 0, []);
-  return {
-    stages: expanded.stages.filter((stage) => stage.nodeKind !== "tool"),
-    renderStages: expanded.stages,
-    tools: expanded.tools,
-    nodes: expanded.nodes,
-    targets,
-  };
+	const expanded = expandRun(root, 0, []);
+	return {
+		stages: expanded.stages.filter((stage) => stage.nodeKind !== "tool"),
+		renderStages: expanded.stages,
+		tools: expanded.tools,
+		nodes: expanded.nodes,
+		targets,
+	};
 }
 
-export function expandedStageTarget(graph: ExpandedWorkflowGraph, virtualStageIdValue: string): ExpandedWorkflowStageTarget | undefined {
-  return graph.targets.get(virtualStageIdValue);
+export function expandedStageTarget(
+	graph: ExpandedWorkflowGraph,
+	virtualStageIdValue: string,
+): ExpandedWorkflowStageTarget | undefined {
+	return graph.targets.get(virtualStageIdValue);
 }
 
 export function stageMatchesExpandedIdentifier(stage: ExpandedWorkflowStage, target: string): boolean {
-  const graphTarget = stage.workflowGraphTarget;
-  return stage.id === target || stage.name === target || stage.id.startsWith(target)
-    || graphTarget.stageId === target || graphTarget.stageId.startsWith(target)
-    || graphTarget.runId === target || graphTarget.runId.startsWith(target);
+	const graphTarget = stage.workflowGraphTarget;
+	return (
+		stage.id === target ||
+		stage.name === target ||
+		stage.id.startsWith(target) ||
+		graphTarget.stageId === target ||
+		graphTarget.stageId.startsWith(target) ||
+		graphTarget.runId === target ||
+		graphTarget.runId.startsWith(target)
+	);
 }
 
 export function expandedStageLabel(stage: ExpandedWorkflowStage): string {
-  const target = stage.workflowGraphTarget;
-  if (stage.nodeKind === "tool") return `${stage.name} (tool)`;
-  const runPrefix = target.runId.slice(0, 8);
-  const stagePrefix = target.stageId.slice(0, 8);
-  const depthPrefix = target.depth > 0 ? `${childAliasFor(stage) ?? target.runName}:` : "";
-  return `${depthPrefix}${stage.name} (${runPrefix}/${stagePrefix})`;
+	const target = stage.workflowGraphTarget;
+	if (stage.nodeKind === "tool") return `${stage.name} (tool)`;
+	const runPrefix = target.runId.slice(0, 8);
+	const stagePrefix = target.stageId.slice(0, 8);
+	const depthPrefix = target.depth > 0 ? `${childAliasFor(stage) ?? target.runName}:` : "";
+	return `${depthPrefix}${stage.name} (${runPrefix}/${stagePrefix})`;
 }

package/dist/builtin/workflows/src/shared/intercom-group.ts

@@ -6,21 +6,21 @@ export const DEFAULT_INTERCOM_GROUP = "default";
 
 /** Stable non-default home group for every stage in one top-level workflow invocation. */
 export function workflowInvocationIntercomGroup(rootRunId: string): string {
-  return `workflow:${rootRunId}`;
+	return `workflow:${rootRunId}`;
 }
 
 /** Normalize authored or agent-serialized auto-group sentinels without changing real group names. */
 export function normalizeAutoGroupSentinel(group: string | true): string | true {
-  if (group === true) return true;
-  const sentinel = group.trim().toLowerCase();
-  return sentinel === "true" || sentinel === "auto" ? true : group;
+	if (group === true) return true;
+	const sentinel = group.trim().toLowerCase();
+	return sentinel === "true" || sentinel === "auto" ? true : group;
 }
 
 /** Trim; empty/undefined collapses to the shared default group. */
 export function normalizeGroup(value?: string | null): string {
-  if (typeof value !== "string") return DEFAULT_INTERCOM_GROUP;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : DEFAULT_INTERCOM_GROUP;
+	if (typeof value !== "string") return DEFAULT_INTERCOM_GROUP;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : DEFAULT_INTERCOM_GROUP;
 }
 
 /**
@@ -31,15 +31,15 @@ export function normalizeGroup(value?: string | null): string {
  * Without a workflow group, omission keeps the legacy env/config/default path.
  */
 export function resolveStageGroup(
-  stageOptions?: { group?: string | true },
-  workflowGroup?: string,
+	stageOptions?: { group?: string | true },
+	workflowGroup?: string,
 ): string | undefined {
-  if (!stageOptions) return workflowGroup;
-  const group = stageOptions.group;
-  if (group === undefined) return workflowGroup;
-  if (group === true) return randomUUID();
-  const trimmed = group.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
+	if (!stageOptions) return workflowGroup;
+	const group = stageOptions.group;
+	if (group === undefined) return workflowGroup;
+	if (group === true) return randomUUID();
+	const trimmed = group.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
 }
 
 /**
@@ -48,11 +48,11 @@ export function resolveStageGroup(
  * placed into an isolated group it cannot use.
  */
 export function stageHasIntercomAccess(stageOptions?: StageOptions): boolean {
-  if (!stageOptions) return true;
-  if (stageOptions.noTools === "all") return false;
-  const tools = stageOptions.tools;
-  if (Array.isArray(tools) && !tools.includes("intercom")) return false;
-  const excluded = stageOptions.excludedTools;
-  if (Array.isArray(excluded) && excluded.includes("intercom")) return false;
-  return true;
+	if (!stageOptions) return true;
+	if (stageOptions.noTools === "all") return false;
+	const tools = stageOptions.tools;
+	if (Array.isArray(tools) && !tools.includes("intercom")) return false;
+	const excluded = stageOptions.excludedTools;
+	if (Array.isArray(excluded) && excluded.includes("intercom")) return false;
+	return true;
 }

package/dist/builtin/workflows/src/shared/persistence-compaction-policy.ts

@@ -10,9 +10,9 @@
  * cross-ref: pi-subagents fork-context children preservation pattern (upstream #147)
  */
 
-import type { Store } from "./store.js";
-import { appendRunStart, appendStageStart } from "./persistence-session-entries.js";
 import type { PersistenceAPI } from "./persistence-session-entries.js";
+import { appendRunStart, appendStageStart } from "./persistence-session-entries.js";
+import type { Store } from "./store.js";
 
 // ---------------------------------------------------------------------------
 // Compaction API structural type
@@ -20,8 +20,8 @@ import type { PersistenceAPI } from "./persistence-session-entries.js";
 
 /** Subset of the pi runtime API needed to install lifecycle hooks. */
 export interface CompactionAPI {
-  /** Register a listener for a pi lifecycle event. */
-  on?: (event: string, handler: () => void | Promise<void>) => void;
+	/** Register a listener for a pi lifecycle event. */
+	on?: (event: string, handler: () => void | Promise<void>) => void;
 }
 
 // ---------------------------------------------------------------------------
@@ -39,34 +39,34 @@ export interface CompactionAPI {
  * Degrades gracefully if `api.on` is not available.
  */
 export function installCompactionHook(api: CompactionAPI & PersistenceAPI, store: Store): void {
-  if (typeof api.on !== "function") return;
+	if (typeof api.on !== "function") return;
 
-  api.on("session_before_compact", () => {
-    const runs = store.runs();
-    const now = Date.now();
+	api.on("session_before_compact", () => {
+		const runs = store.runs();
+		const now = Date.now();
 
-    for (const run of runs) {
-      // Only preserve runs that haven't ended
-      if (run.endedAt !== undefined) continue;
+		for (const run of runs) {
+			// Only preserve runs that haven't ended
+			if (run.endedAt !== undefined) continue;
 
-      appendRunStart(api, {
-        runId: run.id,
-        name: run.name,
-        inputs: run.inputs,
-        ts: run.startedAt ?? now,
-      });
+			appendRunStart(api, {
+				runId: run.id,
+				name: run.name,
+				inputs: run.inputs,
+				ts: run.startedAt ?? now,
+			});
 
-      for (const stage of run.stages) {
-        // Re-append start for stages that haven't completed
-        if (stage.endedAt !== undefined) continue;
-        appendStageStart(api, {
-          runId: run.id,
-          stageId: stage.id,
-          name: stage.name,
-          parentIds: [...stage.parentIds],
-          ts: stage.startedAt ?? now,
-        });
-      }
-    }
-  });
+			for (const stage of run.stages) {
+				// Re-append start for stages that haven't completed
+				if (stage.endedAt !== undefined) continue;
+				appendStageStart(api, {
+					runId: run.id,
+					stageId: stage.id,
+					name: stage.name,
+					parentIds: [...stage.parentIds],
+					ts: stage.startedAt ?? now,
+				});
+			}
+		}
+	});
 }