@bastani/atomic 0.9.10 → 0.9.11-alpha.10

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

@@ -1,186 +1,285 @@
-import type {
-  RunSnapshot,
-  StageSnapshot,
-  StoreSnapshot,
-} from "./store-types.js";
+import type { RunSnapshot, StageSnapshot, StoreSnapshot, ToolNodeSnapshot } from "./store-types.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;
+}
+
+export type ExpandedWorkflowNode =
+	| { readonly kind: "stage"; readonly stage: ExpandedWorkflowStage }
+	| { readonly kind: "tool"; readonly tool: ExpandedWorkflowTool };
+
 export interface ExpandedWorkflowGraph {
-  readonly stages: readonly ExpandedWorkflowStage[];
-  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 terminalIds: readonly string[];
+	readonly stages: ExpandedWorkflowStage[];
+	readonly tools: ExpandedWorkflowTool[];
+	readonly nodes: ExpandedWorkflowNode[];
+	readonly terminalIds: readonly string[];
 }
 
-function virtualStageId(runId: string, stageId: string, isRootRun: boolean): string {
-  return isRootRun ? stageId : `${runId}:${stageId}`;
+type LocalItem =
+	| { 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}`;
 }
 
-function isTerminalNonCompletedBoundary(stage: StageSnapshot): boolean {
-  return stage.status === "failed" || stage.status === "skipped";
+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;
+	});
+}
+
+function itemId(item: LocalItem): string {
+	return item.kind === "stage" ? item.stage.id : item.tool.id;
 }
 
-function childRunIdFor(stage: StageSnapshot): string | undefined {
-  if (isTerminalNonCompletedBoundary(stage)) return undefined;
-  if (stage.status === "completed") return stage.workflowChild?.runId ?? stage.workflowChildRun?.runId;
-  return stage.workflowChildRun?.runId;
+function itemParents(item: LocalItem): readonly string[] {
+	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);
+}
+
+function isTerminalNonCompletedBoundary(stage: StageSnapshot): boolean {
+	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;
-}
-
-function localTerminalStageIds(stages: readonly StageSnapshot[]): readonly string[] {
-  const parentIds = new Set<string>();
-  for (const stage of stages) {
-    for (const parentId of stage.parentIds) parentIds.add(parentId);
-  }
-  const terminals = stages
-    .filter((stage) => !parentIds.has(stage.id))
-    .map((stage) => stage.id);
-  return terminals.length > 0 ? terminals : stages.map((stage) => stage.id);
-}
-
-/**
- * Build a view-only expanded graph for a run and any nested child workflow
- * runs it references. Child stages are cloned with virtual ids so their local
- * parent ids do not collide with parent-run stage ids; each virtual node keeps
- * a target mapping back to the actual `{ runId, stageId }` for attach/control.
- *
- * Imported workflows are flattened: a boundary stage that wraps a child run
- * with its own stages is NOT emitted as its own node. Instead the child's
- * stages stand in for it, so a nested workflow reads as a flat layout with no
- * extra "information" node marking the import boundary. The boundary's incoming
- * parents become the child roots' parents, and stages downstream of the
- * boundary rewire to the child's terminal stages. A boundary whose child run
- * produced no stages of its own is kept as a single node so the import stays
- * visible. Boundary stages are non-attachable, so dropping them loses no
- * interactive capability.
- */
-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: [], targets: new Map() };
-
-  const targets = new Map<string, ExpandedWorkflowStageTarget>();
-  // Cycle guard only. This relies on the store invariant that each child run is
-  // referenced by exactly one parent stage (runIds are unique and a child run
-  // has a single boundary stage), so removing a run from `visiting` on exit
-  // cannot double-expand a shared child into duplicate virtual stage ids. If
-  // that invariant is ever relaxed, dedupe expanded stages by virtual id here.
-  const visiting = new Set<string>();
-
-  const expandRun = (
-    run: RunSnapshot,
-    depth: number,
-    incomingParentIds: readonly string[],
-  ): ExpandedRunResult => {
-    if (visiting.has(run.id)) return { stages: [], terminalIds: [] };
-    visiting.add(run.id);
-
-    const isRootRun = run.id === rootRunId;
-    const expandedStages: ExpandedWorkflowStage[] = [];
-    const replacementTerminals = new Map<string, readonly string[]>();
-
-    for (const stage of run.stages) {
-      const id = virtualStageId(run.id, stage.id, isRootRun);
-      const resolvedParentIds = stage.parentIds.length === 0
-        ? [...incomingParentIds]
-        : stage.parentIds.flatMap((parentId) =>
-            replacementTerminals.get(parentId) ?? [virtualStageId(run.id, parentId, isRootRun)],
-          );
-
-      const childRunId = childRunIdFor(stage);
-      const childRun = childRunId === undefined ? undefined : runById.get(childRunId);
-
-      // Flatten the imported workflow in place: when the boundary wraps a child
-      // run that has its own stages, splice those stages in instead of emitting
-      // the boundary node. Child roots inherit the boundary's incoming parents,
-      // and downstream stages rewire to the child's terminals below.
-      if (childRun !== undefined && childRun.stages.length > 0) {
-        const childExpanded = expandRun(childRun, depth + 1, resolvedParentIds);
-        expandedStages.push(...childExpanded.stages);
-        replacementTerminals.set(
-          stage.id,
-          childExpanded.terminalIds.length > 0 ? childExpanded.terminalIds : resolvedParentIds,
-        );
-        continue;
-      }
-
-      // Regular stage, or a boundary whose child produced no stages of its own:
-      // emit it so the import still appears as exactly one node.
-      const target: ExpandedWorkflowStageTarget = {
-        runId: run.id,
-        stageId: stage.id,
-        runName: run.name,
-        depth,
-      };
-      targets.set(id, target);
-      expandedStages.push({
-        ...stage,
-        id,
-        parentIds: Object.freeze(resolvedParentIds),
-        workflowGraphTarget: target,
-      });
-    }
-
-    const terminalIds = localTerminalStageIds(run.stages).flatMap((stageId) =>
-      replacementTerminals.get(stageId) ?? [virtualStageId(run.id, stageId, isRootRun)],
-    );
-
-    visiting.delete(run.id);
-    return { stages: expandedStages, terminalIds };
-  };
-
-  const expanded = expandRun(root, 0, []);
-  return { stages: expanded.stages, targets };
+	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;
+}
+
+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 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 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;
+		};
+
+		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,
+				};
+				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 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 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,
+	graph: ExpandedWorkflowGraph,
+	virtualStageIdValue: string,
 ): ExpandedWorkflowStageTarget | undefined {
-  return graph.targets.get(virtualStageIdValue);
+	return graph.targets.get(virtualStageIdValue);
 }
 
-export function stageMatchesExpandedIdentifier(
-  stage: ExpandedWorkflowStage,
-  target: string,
-): boolean {
-  return (
-    stage.id === target ||
-    stage.name === target ||
-    stage.id.startsWith(target) ||
-    stage.workflowGraphTarget.stageId === target ||
-    stage.workflowGraphTarget.stageId.startsWith(target) ||
-    stage.workflowGraphTarget.runId === target ||
-    stage.workflowGraphTarget.runId.startsWith(target)
-  );
+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)
+	);
 }
 
 export function expandedStageLabel(stage: ExpandedWorkflowStage): string {
-  const runPrefix = stage.workflowGraphTarget.runId.slice(0, 8);
-  const stagePrefix = stage.workflowGraphTarget.stageId.slice(0, 8);
-  const depthPrefix = stage.workflowGraphTarget.depth > 0
-    ? `${childAliasFor(stage) ?? stage.workflowGraphTarget.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

@@ -4,35 +4,42 @@ import type { StageOptions } from "./types.js";
 /** The implicit group shared by every ungrouped session. */
 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}`;
+}
+
 /** 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;
 }
 
 /**
- * Resolve a stage's `group` option to a concrete home-group string, or undefined
- * when the stage did not request a group (so the intercom layer falls back to
- * env/config/default). A named string is trimmed; a bare `true` that survives to
- * this point (a single, non-parallel stage) mints one fresh UUID for that stage.
- * Parallel sets resolve `true` to one shared UUID upstream, so it never reaches
- * here as `true`.
+ * Resolve a stage's home group. An explicit authored group wins over the
+ * workflow invocation group. A named string is trimmed; a bare `true` that
+ * survives to this point (a single, non-parallel stage) mints one fresh UUID
+ * for that stage. Parallel sets resolve `true` to one shared UUID upstream.
+ * Without a workflow group, omission keeps the legacy env/config/default path.
  */
-export function resolveStageGroup(stageOptions?: { group?: string | true }): string | undefined {
-  if (!stageOptions) return undefined;
-  const group = stageOptions.group;
-  if (group === undefined) return undefined;
-  if (group === true) return randomUUID();
-  const trimmed = group.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
+export function resolveStageGroup(
+	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;
 }
 
 /**
@@ -41,11 +48,11 @@ export function resolveStageGroup(stageOptions?: { group?: string | true }): str
  * placed into an isolated group it cannot use.
  */
 export function stageHasIntercomAccess(stageOptions?: StageOptions): boolean {
-  if (!stageOptions) return true;
-  if (stageOptions.noTools === "all" || stageOptions.noTools === "builtin") 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,
+				});
+			}
+		}
+	});
 }