pi-ultracode 0.3.2 → 0.5.0

package/src/workflow/parser.ts

@@ -33,6 +33,7 @@ export interface ParsedWorkflow {
 export const WORKFLOW_CHECKPOINT_IDENTIFIER = "__ultracodeCheckpoint";
 const WORKFLOW_LOOP_IDENTIFIER = "__ultracodeLoop";
 const WORKFLOW_INVOKE_IDENTIFIER = "__ultracodeInvoke";
+const WORKFLOW_SAFE_MAP_IDENTIFIER = "__ultracodeMapThunks";
 const WORKFLOW_INTERNAL_CALLS = {
   agent: "__ultracodeAgent",
   parallel: "__ultracodeParallel",
@@ -43,6 +44,7 @@ const WORKFLOW_RESERVED_IDENTIFIERS = new Set([
   WORKFLOW_CHECKPOINT_IDENTIFIER,
   WORKFLOW_LOOP_IDENTIFIER,
   WORKFLOW_INVOKE_IDENTIFIER,
+  WORKFLOW_SAFE_MAP_IDENTIFIER,
   ...Object.values(WORKFLOW_INTERNAL_CALLS),
 ]);
 export const DEFAULT_WORKFLOW_CHECKPOINT_LIMIT = 1_000_000;
@@ -249,10 +251,18 @@ function assertDeterministicAst(
   if (isUnsupportedClassEagerOrchestration(node, orchestrationBindings)) {
     throw new Error("Workflow classes may call orchestration only from ordinary methods, not constructors, fields, or static blocks.");
   }
-  if (isUnsupportedFactoryProperty(node) || isUnsupportedAccessorForwarding(node, orchestrationBindings)) {
-    throw new Error("Workflow orchestration helper properties must use static methods; accessor forwarding is unsupported.");
+  if (
+    isUnsupportedFactoryProperty(node)
+    || isUnsupportedAccessorForwarding(node, orchestrationBindings)
+    || isAmbiguousOrchestrationContainer(node)
+  ) {
+    throw new Error("Workflow orchestration helper properties must use unique static methods without spreads; accessor forwarding is unsupported.");
   }
-  if (isUnsupportedCompositeFactory(node)) {
+  if (
+    isUnsupportedCompositeFactory(node, orchestrationBindings)
+    || isUnsupportedAnonymousHelperExtraction(node)
+    || isUnsupportedHelperDestructuringAssignment(node, orchestrationBindings)
+  ) {
     throw new Error("Workflow orchestration helper factories must use a direct function, object, or class declaration.");
   }
   if (isUnsupportedHelperAssignment(node, orchestrationBindings)) {
@@ -267,10 +277,11 @@ function assertDeterministicAst(
     isDynamicMethodCall(node)
     || isDynamicOrchestrationMember(node, orchestrationBindings)
     || isOrchestrationDestructure(node, orchestrationBindings)
-    || isOrchestrationArgumentEscape(node, orchestrationBindings)
+    || isOrchestrationArgumentEscape(node, orchestrationBindings, parent)
     || isOrchestrationFunctionAlias(node, parent)
     || isOrchestrationMemberAlias(node, parent, orchestrationBindings)
     || isOrchestrationBindingEscape(node, parent, orchestrationBindings)
+    || isTaintedTaggedCall(node, orchestrationBindings)
   ) {
     throw new Error(
       "Workflow scripts must use a static method name; dynamic method calls can bypass deterministic promise checks.",
@@ -279,6 +290,9 @@ function assertDeterministicAst(
   if (node.type === "Identifier" && node.name === "globalThis") {
     throw new Error("Workflow scripts must not access globalThis; use the declared workflow globals directly.");
   }
+  if (node.type === "Identifier" && node.name === "process" && isIdentifierReference(node, parent)) {
+    throw new Error("Workflow scripts do not expose process; use the declared cwd global directly.");
+  }
   if (
     node.type === "MemberExpression"
     && node.object?.type === "ThisExpression"
@@ -335,10 +349,21 @@ function collectCallSiteEdits(
 ): void {
   const orchestrationBindings = collectOrchestrationBindings(root);
   const localFunctions = collectLocalFunctionNames(root, orchestrationBindings);
-  const stack: Array<{ node: AnyNode; loops: string[] }> = [{ node: root, loops: [] }];
+  const stack: Array<{ node: AnyNode; parent?: AnyNode; loops: string[] }> = [{ node: root, loops: [] }];
   while (stack.length > 0) {
-    const { node, loops } = stack.pop()!;
-    if (
+    const { node, parent, loops } = stack.pop()!;
+    if (isSafeParallelMap(node, parent, orchestrationBindings)) {
+      const openOffset = source.slice(node.callee.end, node.end).indexOf("(");
+      if (openOffset < 0) throw new Error("unable to instrument safe parallel map");
+      const openParen = node.callee.end + openOffset;
+      const receiver = source.slice(node.callee.object.start, node.callee.object.end);
+      replacements.push({
+        start: node.callee.start,
+        end: node.callee.end,
+        text: WORKFLOW_SAFE_MAP_IDENTIFIER,
+      });
+      insertions.push({ pos: openParen + 1, text: `${receiver},` });
+    } else if (
       node.type === "CallExpression"
       && node.callee?.type === "Identifier"
       && Object.hasOwn(WORKFLOW_INTERNAL_CALLS, node.callee.name)
@@ -359,7 +384,8 @@ function collectCallSiteEdits(
         text: `${JSON.stringify(callSite)}${node.arguments.length > 0 ? "," : ""}`,
       });
     } else if (node.type === "CallExpression" && (
-      (node.callee?.type === "Identifier" && localFunctions.has(node.callee.name))
+      (node.callee?.type === "Identifier"
+        && (localFunctions.has(node.callee.name) || orchestrationBindings.has(node.callee.name)))
       || (node.callee?.type === "MemberExpression"
         && isTaintedStaticMember(node.callee, orchestrationBindings))
     )) {
@@ -394,6 +420,7 @@ function collectCallSiteEdits(
     for (const child of astChildren(node)) {
       stack.push({
         node: child,
+        parent: node,
         loops: body && loopSite && child === body ? [...loops, loopSite] : loops,
       });
     }
@@ -521,8 +548,8 @@ function collectOrchestrationBindings(root: AnyNode): Set<string> {
         ? containsDirectOrchestration(definition.value)
         : containsUnconsumedOrchestration(definition.value);
       if (tainted) seeds.add(definition.name);
-      if (definition.value.type === "ObjectExpression") {
-        for (const member of objectFactoryMembers(definition.name, definition.value)) addMemberSeed(seeds, member);
+      if (definition.value.type === "ObjectExpression" || definition.value.type === "ArrayExpression") {
+        for (const member of containerFactoryMembers(definition.name, definition.value)) addMemberSeed(seeds, member);
       }
       for (const alias of collectStaticAliases(definition.name, definition.value)) {
         const targets = aliases.get(alias.source) ?? new Set<string>();
@@ -620,18 +647,28 @@ function collectReferencedIdentifiers(root: AnyNode): Set<string> {
   return references;
 }
 
-function objectFactoryMembers(name: string, node: AnyNode): string[] {
+function containerFactoryMembers(name: string, node: AnyNode): string[] {
   const members: string[] = [];
-  for (const property of node.properties ?? []) {
-    if (property.type !== "Property") continue;
-    const key = property.computed
-      ? staticStringOf(property.key)
-      : property.key?.name ?? (typeof property.key?.value === "string" ? property.key.value : undefined);
-    if (!key) continue;
+  const entries: Array<{ key: string; value: AnyNode }> = [];
+  if (node.type === "ObjectExpression") {
+    for (const property of node.properties ?? []) {
+      if (property.type !== "Property") continue;
+      const key = property.computed
+        ? staticStringOf(property.key)
+        : property.key?.name ?? (typeof property.key?.value === "string" ? property.key.value : undefined);
+      if (key !== undefined) entries.push({ key, value: property.value });
+    }
+  } else if (node.type === "ArrayExpression") {
+    for (let index = 0; index < (node.elements?.length ?? 0); index++) {
+      const value = node.elements[index];
+      if (value && value.type !== "SpreadElement") entries.push({ key: String(index), value });
+    }
+  }
+  for (const { key, value } of entries) {
     const member = `${name}.${key}`;
-    if (isFunctionNode(property.value) && containsDirectOrchestration(property.value)) members.push(member);
-    if (property.value?.type === "ObjectExpression") {
-      members.push(...objectFactoryMembers(member, property.value));
+    if (isFunctionNode(value) && containsDirectOrchestration(value)) members.push(member);
+    if (value.type === "ObjectExpression" || value.type === "ArrayExpression") {
+      members.push(...containerFactoryMembers(member, value));
     }
   }
   return members;
@@ -759,7 +796,11 @@ function isDynamicOrchestrationMember(node: AnyNode, bindings: ReadonlySet<strin
     && isOrchestrationExpression(node.object, bindings);
 }
 
-function isOrchestrationArgumentEscape(node: AnyNode, bindings: ReadonlySet<string>): boolean {
+function isOrchestrationArgumentEscape(
+  node: AnyNode,
+  bindings: ReadonlySet<string>,
+  parent?: AnyNode,
+): boolean {
   if (node.type === "TaggedTemplateExpression") {
     return (node.quasi?.expressions ?? []).some((expression: AnyNode) =>
       isOrchestrationExpression(expression, bindings)
@@ -769,19 +810,98 @@ function isOrchestrationArgumentEscape(node: AnyNode, bindings: ReadonlySet<stri
     node.type === "CallExpression"
     && node.callee?.type === "Identifier"
     && ORCHESTRATION_FUNCTIONS.has(node.callee.name)
-  ) return false;
+  ) {
+    return node.arguments.some((argument: AnyNode) =>
+      containsEagerOrchestration(
+        argument.type === "SpreadElement" ? argument.argument : argument,
+        bindings,
+      ));
+  }
+  if (isSafeParallelMap(node, parent, bindings)) return false;
   return (node.type === "CallExpression" || node.type === "NewExpression")
-    && node.arguments.some((argument: AnyNode) =>
-      argument.type === "SpreadElement"
-        ? isOrchestrationExpression(argument.argument, bindings)
-        : isOrchestrationExpression(argument, bindings)
-    );
+    && node.arguments.some((argument: AnyNode) => {
+      const value = argument.type === "SpreadElement" ? argument.argument : argument;
+      return isOrchestrationExpression(value, bindings)
+        || containsEscapingOrchestration(value, bindings);
+    });
+}
+
+function containsEagerOrchestration(root: AnyNode, bindings: ReadonlySet<string>): boolean {
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop()!;
+    if (isFunctionNode(node)) continue;
+    if (node.type === "CallExpression" && isOrchestrationExpression(node, bindings)) return true;
+    if (node.type === "Identifier" && bindings.has(node.name)) return true;
+    if (node.type === "MemberExpression" && isTaintedStaticMember(node, bindings)) return true;
+    stack.push(...astChildren(node));
+  }
+  return false;
+}
+
+/** Find raw orchestration capabilities passed to another call; awaited results are plain data. */
+function containsEscapingOrchestration(root: AnyNode, bindings: ReadonlySet<string>): boolean {
+  const stack: Array<{ node: AnyNode; parent?: AnyNode }> = [{ node: root }];
+  while (stack.length > 0) {
+    const { node, parent } = stack.pop()!;
+    if (node.type === "AwaitExpression") continue;
+    if (isFunctionNode(node) && containsOrchestrationCall(node, bindings)) return true;
+    if (node.type === "CallExpression" && isOrchestrationExpression(node, bindings)) return true;
+    if (node.type === "MemberExpression" && propertyNameOf(node) !== undefined) {
+      if (isOrchestrationExpression(node, bindings)) return true;
+      continue;
+    }
+    if (
+      node.type === "Identifier"
+      && isIdentifierReference(node, parent)
+      && (bindings.has(node.name) || hasTaintedMember(bindings, node.name))
+    ) return true;
+    for (const child of astChildren(node)) stack.push({ node: child, parent: node });
+  }
+  return false;
+}
+
+function isSafeParallelMap(
+  node: AnyNode,
+  parent: AnyNode | undefined,
+  bindings: ReadonlySet<string>,
+): boolean {
+  if (
+    node.type !== "CallExpression"
+    || node.callee?.type !== "MemberExpression"
+    || propertyNameOf(node.callee) !== "map"
+    || parent?.type !== "CallExpression"
+    || parent.callee?.type !== "Identifier"
+    || parent.callee.name !== "parallel"
+    || !parent.arguments.includes(node)
+    || node.arguments?.length !== 1
+    || containsOrchestrationCall(node.callee.object, bindings)
+  ) return false;
+  const mapper = node.arguments[0];
+  if (
+    !mapper
+    || (mapper.type !== "ArrowFunctionExpression" && mapper.type !== "FunctionExpression")
+    || mapper.async
+    || mapper.generator
+    || (mapper.params ?? []).some((parameter: AnyNode) => containsOrchestrationCall(parameter, bindings))
+  ) return false;
+  const expressions = mapper.body?.type === "SequenceExpression"
+    ? mapper.body.expressions
+    : [mapper.body];
+  const thunk = expressions?.at(-1);
+  if (!isFunctionNode(thunk)) return false;
+  return expressions.slice(0, -1).every((expression: AnyNode) =>
+    !containsOrchestrationCall(expression, bindings));
 }
 
 function isUnsupportedHelperCall(node: AnyNode, bindings: ReadonlySet<string>): boolean {
   if (node.type !== "CallExpression") return false;
   if (node.callee?.type === "MemberExpression") {
-    if (node.callee.object?.type === "ThisExpression" || node.callee.object?.type === "AwaitExpression") return true;
+    if (
+      node.callee.object?.type === "ThisExpression"
+      || node.callee.object?.type === "AwaitExpression"
+      || node.callee.object?.type === "Super"
+    ) return true;
     return (node.callee.object?.type === "CallExpression" || node.callee.object?.type === "NewExpression")
       && isOrchestrationExpression(node.callee.object, bindings);
   }
@@ -844,10 +964,97 @@ function isUnsupportedAccessorForwarding(node: AnyNode, bindings: ReadonlySet<st
   return containsDirectOrchestration(value);
 }
 
-function isUnsupportedCompositeFactory(node: AnyNode): boolean {
+function isAmbiguousOrchestrationContainer(node: AnyNode): boolean {
+  if (node.type !== "ObjectExpression" || !containsDirectOrchestration(node)) return false;
+  const seen = new Set<string>();
+  for (const property of node.properties ?? []) {
+    if (property.type !== "Property") return true;
+    const key = property.computed ? staticStringOf(property.key) : propertyKeyName(property.key);
+    if (key === undefined || key === "__proto__" || seen.has(key)) return true;
+    seen.add(key);
+  }
+  return false;
+}
+
+function isUnsupportedCompositeFactory(node: AnyNode, bindings: ReadonlySet<string>): boolean {
   if (node.type !== "VariableDeclarator" || !node.init) return false;
-  return ["ConditionalExpression", "LogicalExpression", "SequenceExpression"].includes(node.init.type)
-    && containsDirectOrchestration(node.init);
+  if (["ConditionalExpression", "LogicalExpression", "SequenceExpression"].includes(node.init.type)) {
+    return containsDirectOrchestration(node.init);
+  }
+  const init = node.init.type === "ChainExpression" ? node.init.expression : node.init;
+  if (init.type !== "CallExpression") return false;
+  if (init.callee?.type === "Identifier") return bindings.has(init.callee.name);
+  if (isFunctionNode(init.callee)) return containsOrchestrationCall(init.callee, bindings);
+  if (init.callee?.type !== "MemberExpression") {
+    return containsOrchestrationCall(init.callee, bindings)
+      || isOrchestrationExpression(init.callee, bindings);
+  }
+  if (isTaintedStaticMember(init.callee, bindings)) return true;
+  return init.callee.object?.type === "Identifier"
+    && hasTaintedMember(bindings, init.callee.object.name);
+}
+
+function isUnsupportedAnonymousHelperExtraction(node: AnyNode): boolean {
+  if (node.type !== "VariableDeclarator" || !node.init) return false;
+  const init = node.init.type === "ChainExpression" ? node.init.expression : node.init;
+  if (node.id?.type === "ObjectPattern" || node.id?.type === "ArrayPattern") {
+    return destructureSelectsOrchestration(node.id, init);
+  }
+  if (node.id?.type !== "Identifier" || init.type !== "MemberExpression") return false;
+  const selected = selectedLiteralMember(init);
+  return selected ? containsDirectOrchestration(selected) : containsDirectOrchestration(init.object);
+}
+
+function isUnsupportedHelperDestructuringAssignment(
+  node: AnyNode,
+  bindings: ReadonlySet<string>,
+): boolean {
+  return node.type === "AssignmentExpression"
+    && (node.left?.type === "ObjectPattern" || node.left?.type === "ArrayPattern")
+    && (
+      destructureSelectsOrchestration(node.left, node.right)
+      || isOrchestrationExpression(node.right, bindings)
+    );
+}
+
+function destructureSelectsOrchestration(pattern: AnyNode, value: AnyNode): boolean {
+  if (pattern.type === "ObjectPattern" && value.type === "ObjectExpression") {
+    for (const selected of pattern.properties ?? []) {
+      if (selected.type !== "Property") return true;
+      const key = propertyKeyName(selected.key);
+      if (key === undefined) return true;
+      const match = findLastStaticProperty(value.properties ?? [], key);
+      if (match && containsDirectOrchestration(match.value)) return true;
+    }
+    return false;
+  }
+  if (pattern.type === "ArrayPattern" && value.type === "ArrayExpression") {
+    return (pattern.elements ?? []).some((selected: AnyNode | null, index: number) =>
+      !!selected && !!value.elements?.[index] && containsDirectOrchestration(value.elements[index]));
+  }
+  return containsDirectOrchestration(value);
+}
+
+function selectedLiteralMember(member: AnyNode): AnyNode | undefined {
+  const key = propertyNameOf(member);
+  if (key === undefined) return undefined;
+  if (member.object?.type === "ObjectExpression") {
+    return findLastStaticProperty(member.object.properties ?? [], key)?.value;
+  }
+  if (member.object?.type === "ArrayExpression" && /^\d+$/.test(key)) {
+    return member.object.elements?.[Number(key)] ?? undefined;
+  }
+  return undefined;
+}
+
+function findLastStaticProperty(properties: AnyNode[], key: string): AnyNode | undefined {
+  for (let index = properties.length - 1; index >= 0; index--) {
+    const property = properties[index];
+    if (property.type !== "Property") continue;
+    const candidate = property.computed ? staticStringOf(property.key) : propertyKeyName(property.key);
+    if (candidate === key) return property;
+  }
+  return undefined;
 }
 
 function isUnsupportedHelperAssignment(node: AnyNode, bindings: ReadonlySet<string>): boolean {
@@ -886,6 +1093,12 @@ function isOrchestrationBindingEscape(
 }
 
 function isTaintedStaticMember(node: AnyNode, bindings: ReadonlySet<string>): boolean {
+  const selected = selectedLiteralMember(node);
+  if (selected) {
+    return isFunctionNode(selected)
+      ? containsOrchestrationCall(selected, bindings)
+      : isOrchestrationExpression(selected, bindings);
+  }
   const member = staticMemberReference(node);
   if (!member) return isOrchestrationExpression(node.object, bindings);
   if (bindings.has(member) || hasTaintedMember(bindings, member)) return true;
@@ -933,6 +1146,14 @@ function isForbiddenPromiseDestructure(node: AnyNode, parent?: AnyNode): boolean
     && ["then", "catch", "finally"].includes(propertyNameOf(node) ?? propertyKeyName(node.key) ?? "");
 }
 
+function isTaintedTaggedCall(node: AnyNode, bindings: ReadonlySet<string>): boolean {
+  if (node.type !== "TaggedTemplateExpression") return false;
+  if (node.tag?.type === "Identifier") return bindings.has(node.tag.name);
+  if (node.tag?.type === "MemberExpression") return isTaintedStaticMember(node.tag, bindings);
+  return node.tag?.type === "ChainExpression"
+    && isOrchestrationExpression(node.tag.expression, bindings);
+}
+
 function isDynamicMethodCall(node: AnyNode): boolean {
   return node.type === "CallExpression"
     && node.callee?.type === "MemberExpression"
@@ -953,13 +1174,8 @@ function isForbiddenPromiseCall(node: AnyNode): boolean {
     && ["all", "allSettled", "race", "any"].includes(propertyNameOf(node.callee) ?? "");
 }
 
-function isForbiddenPromiseMember(node: AnyNode, parent?: AnyNode): boolean {
-  if (node.type !== "MemberExpression") return false;
-  const property = propertyNameOf(node);
-  if (property === "Promise") return true;
-  return ["all", "allSettled", "race", "any"].includes(property ?? "")
-    && parent?.type === "CallExpression"
-    && parent.callee === node;
+function isForbiddenPromiseMember(node: AnyNode, _parent?: AnyNode): boolean {
+  return node.type === "MemberExpression" && propertyNameOf(node) === "Promise";
 }
 
 function isAllowedPromiseReference(node: AnyNode, parent?: AnyNode, grandparent?: AnyNode): boolean {

package/src/workflow/registry.ts

@@ -1,7 +1,9 @@
 /**
- * Process-local registry of workflow runs, so the `/workflows` command can list
- * recent and in-flight runs and show live progress. Snapshots are updated in place
- * by the workflow tool as a run progresses.
+ * Process-local registry for one Pi extension session.
+ *
+ * A registry instance is permanently scoped by ownership: callers create one per
+ * extension/session and inject that same instance into the workflow tool and
+ * commands. No mutable process-global "current session" exists.
  */
 
 import * as fs from "node:fs";
@@ -16,15 +18,10 @@ export interface RunHandle {
   details?: WorkflowRunDetails;
 }
 
-interface RegistryScope {
-  runs: Map<string, RunHandle>;
-  order: string[];
-}
-
 export class WorkflowRegistry {
-  private readonly scopes = new Map<string, RegistryScope>();
+  private readonly runs = new Map<string, RunHandle>();
+  private order: string[] = [];
   private readonly listeners = new Set<() => void>();
-  private scopeDir?: string;
 
   register(
     runId: string,
@@ -32,13 +29,11 @@ export class WorkflowRegistry {
     abort: () => void,
     details?: WorkflowRunDetails,
   ): RunHandle {
-    const scope = this.currentScope();
     const handle: RunHandle = { snapshot, abort, startedAt: Date.now(), details };
-    scope.runs.set(runId, handle);
-    scope.order = scope.order.filter((id) => id !== runId);
-    scope.order.push(runId);
-    // Keep at most the 50 most recent runs per session without evicting active work.
-    this.trimRuns(scope);
+    this.runs.set(runId, handle);
+    this.order = this.order.filter((id) => id !== runId);
+    this.order.push(runId);
+    this.trimRuns();
     this.notify();
     return handle;
   }
@@ -58,10 +53,8 @@ export class WorkflowRegistry {
     }
   }
 
-  /** Restore the newest task-detail manifests for the current Pi session. */
+  /** Restore the newest task-detail manifests owned by this registry session. */
   restoreRuns(runsDir: string): number {
-    this.setScope(runsDir);
-    const scope = this.currentScope();
     let files: string[];
     try {
       files = fs.readdirSync(runsDir)
@@ -72,10 +65,11 @@ export class WorkflowRegistry {
     } catch {
       return 0;
     }
+
     let restored = 0;
     for (const file of files) {
       const loaded = WorkflowRunDetails.restore(file);
-      if (!loaded || scope.runs.has(loaded.snapshot.runId ?? loaded.details.runId)) continue;
+      if (!loaded || this.runs.has(loaded.snapshot.runId ?? loaded.details.runId)) continue;
       const runId = loaded.snapshot.runId ?? loaded.details.runId;
       if (loaded.snapshot.status === "running") {
         loaded.snapshot.status = "aborted";
@@ -83,7 +77,10 @@ export class WorkflowRegistry {
           if (agent.status !== "running") continue;
           agent.status = "cancelled";
           agent.currentTurn = undefined;
-          loaded.details.finishTask(agent.id, { status: "cancelled", error: "Session ended before the task completed." });
+          loaded.details.finishTask(agent.id, {
+            status: "cancelled",
+            error: "Session ended before the task completed.",
+          });
         }
         loaded.snapshot = recompute(loaded.snapshot);
         loaded.details.persist(loaded.snapshot);
@@ -94,85 +91,65 @@ export class WorkflowRegistry {
       } catch {
         // Keep a deterministic in-memory fallback if the manifest disappears.
       }
-      const handle: RunHandle = {
+      this.runs.set(runId, {
         snapshot: loaded.snapshot,
         abort: () => {},
         startedAt,
         details: loaded.details,
-      };
-      scope.runs.set(runId, handle);
-      scope.order.push(runId);
+      });
+      this.order.push(runId);
       restored++;
     }
-    this.trimRuns(scope);
+    this.trimRuns();
     if (restored) this.notify();
     return restored;
   }
 
-  /** Select a session without discarding live handles from other sessions. */
-  setScope(runsDir: string): void {
-    const resolved = path.resolve(runsDir);
-    if (this.scopeDir === resolved) return;
-    this.scopeDir = resolved;
-    this.currentScope();
-    this.notify();
-  }
-
   get(runId: string): RunHandle | undefined {
-    return this.currentScope().runs.get(runId);
+    const handle = this.runs.get(runId);
+    return handle ? publicHandle(handle) : undefined;
   }
 
   list(): RunHandle[] {
-    const scope = this.currentScope();
-    return scope.order
-      .map((id) => scope.runs.get(id))
+    return this.order
+      .map((id) => this.runs.get(id))
       .filter((handle): handle is RunHandle => Boolean(handle))
+      .map(publicHandle)
       .sort((left, right) => right.startedAt - left.startedAt);
   }
 
   active(): RunHandle[] {
-    return this.list().filter((h) => h.snapshot.status === "running");
+    return this.list().filter((handle) => handle.snapshot.status === "running");
   }
 
   abortAll(): void {
-    for (const handle of this.currentScope().runs.values()) {
-      if (handle.snapshot.status === "running") {
-        try {
-          handle.abort();
-        } catch {
-          // ignore
-        }
+    for (const handle of this.runs.values()) {
+      if (handle.snapshot.status !== "running") continue;
+      try {
+        handle.abort();
+      } catch {
+        // A failing callback must not prevent cancellation of sibling runs.
       }
     }
   }
 
-  private currentScope(): RegistryScope {
-    const key = this.scopeDir ?? "<default>";
-    let scope = this.scopes.get(key);
-    if (!scope) {
-      scope = { runs: new Map(), order: [] };
-      this.scopes.set(key, scope);
-    }
-    return scope;
-  }
-
-  private trimRuns(scope: RegistryScope): void {
-    while (scope.runs.size > 50) {
-      const candidate = [...scope.runs.entries()].sort((left, right) => {
+  private trimRuns(): void {
+    while (this.runs.size > 50) {
+      const candidate = [...this.runs.entries()].sort((left, right) => {
         const leftActive = left[1].snapshot.status === "running" ? 1 : 0;
         const rightActive = right[1].snapshot.status === "running" ? 1 : 0;
         return leftActive - rightActive || left[1].startedAt - right[1].startedAt;
       })[0];
       if (!candidate) break;
-      scope.runs.delete(candidate[0]);
-      scope.order = scope.order.filter((id) => id !== candidate[0]);
+      this.runs.delete(candidate[0]);
+      this.order = this.order.filter((id) => id !== candidate[0]);
     }
   }
 }
 
-let singleton: WorkflowRegistry | undefined;
-
-export function getRegistry(): WorkflowRegistry {
-  if (!singleton) singleton = new WorkflowRegistry();
-  return singleton;
+function publicHandle(handle: RunHandle): RunHandle {
+  return {
+    ...handle,
+    snapshot: structuredClone(handle.snapshot),
+  };
 }