@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/runs/shared/dynamic-fanout.ts

@@ -1,459 +0,0 @@
-import { isRecord, isUnknownArray, recordAt, type UnknownRecord } from "../../shared/unknown.ts";
-import type { DynamicParallelStep, ParallelTaskItem } from "../../shared/types/workflow.ts";
-import type {
-  ReadonlyInput,
-  ArtifactPaths,
-  ChainOutputMap,
-  JsonSchemaObject,
-  SingleResult,
-} from "../../shared/types.ts";
-import { getSingleResultOutput } from "../../shared/utils.ts";
-import { validateStructuredOutputValue } from "./structured-output.ts";
-
-import {
-  DynamicFanoutError,
-  assertJsonPointer,
-  resolveJsonPointer,
-  scalarToKey,
-  normalizeItemKeyForId,
-  resolveItemTemplate,
-} from "./dynamic-item.ts";
-export {
-  DynamicFanoutError,
-  assertJsonPointer,
-  resolveJsonPointer,
-  normalizeItemKeyForId,
-  resolveItemTemplate,
-} from "./dynamic-item.ts";
-
-export interface DynamicFanoutConfig {
-  readonly maxItems?: number;
-  readonly allowRunnerFields?: boolean;
-}
-
-export interface DynamicMaterializedItem {
-  readonly index: number;
-  readonly key: string;
-  readonly idKey: string;
-  readonly item: unknown;
-}
-
-export interface DynamicCollectedResult {
-  key: string;
-  index: number;
-  item: unknown;
-  agent: string;
-  exitCode: number | null;
-  text: string;
-  structured?: unknown;
-  error?: string;
-  outputPath?: string;
-  artifactPaths?: ArtifactPaths;
-}
-
-export interface DynamicMaterializedGroup {
-  items: DynamicMaterializedItem[];
-  parallel: ParallelTaskItem[];
-}
-
-const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const ITEM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
-const RESERVED_TEMPLATE_NAMES = new Set(["task", "previous", "chain_dir", "outputs"]);
-const DYNAMIC_STEP_KEYS = [
-  "expand",
-  "parallel",
-  "collect",
-  "concurrency",
-  "failFast",
-  "phase",
-  "label",
-  "acceptance",
-];
-const RUNNER_DYNAMIC_STEP_KEYS = [...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "sessionFiles"];
-const DYNAMIC_EXPAND_KEYS = ["from", "item", "key", "maxItems", "onEmpty"];
-const DYNAMIC_EXPAND_FROM_KEYS = ["output", "path"];
-const DYNAMIC_PARALLEL_KEYS = [
-  "agent",
-  "task",
-  "phase",
-  "label",
-  "outputSchema",
-  "cwd",
-  "output",
-  "outputMode",
-  "reads",
-  "progress",
-  "skill",
-  "model",
-  "acceptance",
-];
-const RUNNER_DYNAMIC_PARALLEL_KEYS = [
-  ...DYNAMIC_PARALLEL_KEYS,
-  "outputName",
-  "structured",
-  "inheritProjectContext",
-  "inheritSkills",
-  "skills",
-  "outputPath",
-  "outputPathFromAgentDefault",
-  "allowSubagents",
-  "maxSubagentDepth",
-  "structuredOutput",
-  "structuredOutputSchema",
-  "tools",
-  "extensions",
-  "mcpDirectTools",
-  "completionGuard",
-  "systemPrompt",
-  "systemPromptMode",
-  "thinking",
-  "modelCandidates",
-  "sessionFile",
-  "effectiveAcceptance",
-  "maxExecutionTimeMs",
-  "maxTokens",
-  "launch",
-];
-const DYNAMIC_COLLECT_KEYS = ["as", "outputSchema"];
-
-export function isSafeOutputName(name: string): boolean {
-  return SAFE_OUTPUT_NAME_PATTERN.test(name);
-}
-
-function validateObjectKeys(
-  value: unknown,
-  allowed: readonly string[],
-  label: string,
-): UnknownRecord {
-  if (!isRecord(value)) {
-    throw new DynamicFanoutError(`${label} must be an object.`);
-  }
-  for (const key of Object.keys(value)) {
-    if (!allowed.includes(key)) {
-      throw new DynamicFanoutError(`${label} does not support field '${key}'.`);
-    }
-  }
-  return value;
-}
-
-const VALID_ITEM_REF_PATTERN = new RegExp(ITEM_REF_PATTERN.source);
-
-function validateTemplateReference(
-  raw: string,
-  reference: string,
-  itemName: string,
-  label: string,
-): void {
-  if (reference === itemName || reference.startsWith(`${itemName}.`)) {
-    if (
-      !VALID_ITEM_REF_PATTERN.test(raw) ||
-      reference === `${itemName}.` ||
-      reference.includes("..")
-    ) {
-      throw new DynamicFanoutError(`Invalid item reference '${raw}' in ${label}.`);
-    }
-    return;
-  }
-  const name = reference.match(/^[A-Za-z_][A-Za-z0-9_]*/)?.[0];
-  if (name === itemName) {
-    throw new DynamicFanoutError(`Invalid item reference '${raw}' in ${label}.`);
-  }
-  if (name === undefined || RESERVED_TEMPLATE_NAMES.has(name)) {
-    return;
-  }
-  throw new DynamicFanoutError(`Unsupported template reference '${raw}' in ${label}.`);
-}
-
-export function assertNoUnresolvedItemReferences(
-  template: string,
-  itemName: string,
-  label: string,
-): void {
-  for (const match of template.matchAll(/\{([^{}]*)\}/g)) {
-    validateTemplateReference(match[0], match[1], itemName, label);
-  }
-  if (
-    template.includes(`{${itemName}.}`) ||
-    new RegExp(`\\{${itemName}(?:\\.|$)[^}]*$`).test(template)
-  ) {
-    throw new DynamicFanoutError(`Invalid item reference in ${label}.`);
-  }
-}
-
-export function hasDynamicFanoutFields(step: unknown): boolean {
-  return (
-    isRecord(step) &&
-    (Object.prototype.hasOwnProperty.call(step, "expand") ||
-      Object.prototype.hasOwnProperty.call(step, "collect"))
-  );
-}
-
-function requireString(value: unknown, label: string): string {
-  if (typeof value !== "string") {
-    throw new DynamicFanoutError(`${label} must be a string.`);
-  }
-  return value;
-}
-
-function validateItemLimit(value: unknown, label: string): void {
-  if (value !== undefined && (typeof value !== "number" || !Number.isInteger(value) || value < 0)) {
-    throw new DynamicFanoutError(`${label} must be an integer >= 0.`);
-  }
-}
-
-function validateExpandFrom(from: UnknownRecord, prefix: string): void {
-  validateObjectKeys(from, DYNAMIC_EXPAND_FROM_KEYS, `${prefix} expand.from`);
-  const output = requireString(from.output, `${prefix} expand.from.output`);
-  if (!isSafeOutputName(output)) {
-    throw new DynamicFanoutError(`${prefix} has invalid expand.from.output '${output}'.`);
-  }
-  assertJsonPointer(
-    requireString(from.path, `${prefix} expand.from.path`),
-    `${prefix} expand.from.path`,
-  );
-}
-
-function validateExpansion(expand: unknown, prefix: string, config: DynamicFanoutConfig): string {
-  const from = recordAt(expand, "from");
-  if (!isRecord(expand) || !from) {
-    throw new DynamicFanoutError(`${prefix} requires expand.from.`);
-  }
-  validateObjectKeys(expand, DYNAMIC_EXPAND_KEYS, `${prefix} expand`);
-  validateExpandFrom(from, prefix);
-  if (expand.key !== undefined) {
-    assertJsonPointer(requireString(expand.key, `${prefix} expand.key`), `${prefix} expand.key`);
-  }
-  const itemName = requireString(expand.item ?? "item", `${prefix} expand.item`);
-  if (!ITEM_NAME_PATTERN.test(itemName)) {
-    throw new DynamicFanoutError(`${prefix} has invalid expand.item '${itemName}'.`);
-  }
-  if (expand.maxItems === undefined && config.maxItems === undefined) {
-    throw new DynamicFanoutError(
-      `${prefix} requires expand.maxItems or config.chain.dynamicFanout.maxItems.`,
-    );
-  }
-  validateItemLimit(expand.maxItems, `${prefix} expand.maxItems`);
-  validateItemLimit(config.maxItems, "config.chain.dynamicFanout.maxItems");
-  return itemName;
-}
-
-function validateParallelTemplate(
-  parallel: unknown,
-  prefix: string,
-  itemName: string,
-  runnerFields: boolean,
-): void {
-  if (!isRecord(parallel)) {
-    throw new DynamicFanoutError(
-      `${prefix} requires a single parallel template object and cannot mix dynamic expand/collect with static parallel arrays.`,
-    );
-  }
-  validateObjectKeys(
-    parallel,
-    runnerFields ? RUNNER_DYNAMIC_PARALLEL_KEYS : DYNAMIC_PARALLEL_KEYS,
-    `${prefix} parallel`,
-  );
-  if ("expand" in parallel) {
-    throw new DynamicFanoutError(`${prefix} does not support nested dynamic fanout.`);
-  }
-  if (typeof parallel.agent !== "string" || parallel.agent.length === 0) {
-    throw new DynamicFanoutError(`${prefix} parallel.agent is required.`);
-  }
-  for (const [label, value] of [
-    ["parallel.task", parallel.task],
-    ["parallel.label", parallel.label],
-  ] as const) {
-    if (value === undefined) {
-      continue;
-    }
-    const template = requireString(value, `${prefix} ${label}`);
-    if (template.length > 0) {
-      assertNoUnresolvedItemReferences(template, itemName, `${prefix} ${label}`);
-    }
-  }
-}
-
-function validateCollection(collect: unknown, prefix: string): void {
-  if (!isRecord(collect) || typeof collect.as !== "string" || !isSafeOutputName(collect.as)) {
-    throw new DynamicFanoutError(`${prefix} requires collect.as with a safe output name.`);
-  }
-  validateObjectKeys(collect, DYNAMIC_COLLECT_KEYS, `${prefix} collect`);
-}
-
-/** Validates dynamic vocabulary and expansion semantics, not the entire child execution schema. */
-export function validateDynamicStepShape(
-  step: unknown,
-  stepIndex: number,
-  config: DynamicFanoutConfig = {},
-): void {
-  const prefix = `Dynamic chain step ${stepIndex + 1}`;
-  if (
-    isRecord(step) &&
-    (Object.hasOwn(step, "acceptance") || Object.hasOwn(step, "effectiveAcceptance"))
-  ) {
-    throw new DynamicFanoutError(
-      `Dynamic fanout step ${stepIndex + 1} does not support group-level acceptance; set acceptance on the child template instead.`,
-    );
-  }
-  const record = validateObjectKeys(
-    step,
-    config.allowRunnerFields === true ? RUNNER_DYNAMIC_STEP_KEYS : DYNAMIC_STEP_KEYS,
-    prefix,
-  );
-  const itemName = validateExpansion(record.expand, prefix, config);
-  validateParallelTemplate(record.parallel, prefix, itemName, config.allowRunnerFields === true);
-  validateCollection(record.collect, prefix);
-}
-
-export function resolveDynamicFanoutItems(
-  step: ReadonlyInput<DynamicParallelStep>,
-  outputs: ReadonlyInput<ChainOutputMap>,
-  stepIndex: number,
-  config: DynamicFanoutConfig = {},
-): DynamicMaterializedItem[] {
-  validateDynamicStepShape(step, stepIndex, config);
-  const sourceName = step.expand.from.output;
-  const source = outputs[sourceName];
-  if (!Object.hasOwn(outputs, sourceName)) {
-    throw new DynamicFanoutError(
-      `Dynamic chain step ${stepIndex + 1} references unknown output '${sourceName}'.`,
-    );
-  }
-  if (source.structured === undefined) {
-    throw new DynamicFanoutError(
-      `Dynamic chain step ${stepIndex + 1} requires structured output '${sourceName}'.`,
-    );
-  }
-  const value = resolveJsonPointer(
-    source.structured,
-    step.expand.from.path,
-    `Dynamic chain step ${stepIndex + 1} expand.from.path`,
-  );
-  if (!isUnknownArray(value)) {
-    throw new DynamicFanoutError(
-      `Dynamic chain step ${stepIndex + 1} expand.from.path must resolve to an array.`,
-    );
-  }
-  const maxItems = step.expand.maxItems ?? config.maxItems;
-  if (maxItems === undefined) {
-    throw new DynamicFanoutError(
-      `Dynamic chain step ${stepIndex + 1} requires an effective maxItems.`,
-    );
-  }
-  if (value.length > maxItems) {
-    throw new DynamicFanoutError(
-      `Dynamic chain step ${stepIndex + 1} resolved ${value.length} items, exceeding maxItems ${maxItems}.`,
-    );
-  }
-  const seen = new Set<string>();
-  const seenIds = new Set<string>();
-  return value.map((item: unknown, index) => {
-    const key =
-      step.expand.key === undefined
-        ? String(index)
-        : scalarToKey(
-            resolveJsonPointer(
-              item,
-              step.expand.key,
-              `Dynamic chain step ${stepIndex + 1} expand.key`,
-            ),
-            `Dynamic chain step ${stepIndex + 1} expand.key`,
-          );
-    if (seen.has(key)) {
-      throw new DynamicFanoutError(
-        `Dynamic chain step ${stepIndex + 1} produced duplicate item key '${key}'.`,
-      );
-    }
-    seen.add(key);
-    const idKey = normalizeItemKeyForId(key);
-    if (seenIds.has(idKey)) {
-      throw new DynamicFanoutError(
-        `Dynamic chain step ${stepIndex + 1} produced colliding item id '${idKey}'.`,
-      );
-    }
-    seenIds.add(idKey);
-    return { index, key, idKey, item };
-  });
-}
-
-export function materializeDynamicParallelStep(
-  step: ReadonlyInput<DynamicParallelStep>,
-  outputs: ReadonlyInput<ChainOutputMap>,
-  stepIndex: number,
-  config: DynamicFanoutConfig = {},
-): DynamicMaterializedGroup {
-  const items = resolveDynamicFanoutItems(step, outputs, stepIndex, config);
-  if (items.length === 0) {
-    if ((step.expand.onEmpty ?? "skip") === "fail") {
-      throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} source array is empty.`);
-    }
-    return { items, parallel: [] };
-  }
-  const itemName = step.expand.item ?? "item";
-  const parallel = items.map((entry) => {
-    const task = resolveItemTemplate(step.parallel.task ?? "{previous}", itemName, entry.item);
-    const label =
-      (step.parallel.label ?? "").length > 0
-        ? resolveItemTemplate(step.parallel.label ?? "", itemName, entry.item)
-        : undefined;
-    return {
-      ...step.parallel,
-      task,
-      ...(label !== undefined ? { label } : {}),
-    };
-  });
-  return { items, parallel };
-}
-
-type CollectionChild = ReadonlyInput<
-  Pick<
-    SingleResult,
-    "agent" | "error" | "structuredOutput" | "artifactPaths" | "savedOutputPath" | "messages"
-  > & { exitCode: number | null; output?: string; finalOutput?: string }
->;
-
-function collectionText(result: CollectionChild): string {
-  return typeof result.output === "string" ? result.output : getSingleResultOutput(result);
-}
-
-function collectionMetadata(result: CollectionChild): Partial<DynamicCollectedResult> {
-  return {
-    ...(result.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
-    ...((result.error ?? "").length > 0 ? { error: result.error } : {}),
-    ...((result.savedOutputPath ?? "").length > 0 ? { outputPath: result.savedOutputPath } : {}),
-    ...(result.artifactPaths ? { artifactPaths: result.artifactPaths } : {}),
-  };
-}
-
-export function collectDynamicResults(
-  step: ReadonlyInput<DynamicParallelStep>,
-  items: readonly DynamicMaterializedItem[],
-  results: readonly CollectionChild[],
-): DynamicCollectedResult[] {
-  return items.map((entry, index) => {
-    const result = Object.hasOwn(results, index) ? results[index] : undefined;
-    return {
-      key: entry.key,
-      index: entry.index,
-      item: entry.item,
-      agent: result?.agent ?? step.parallel.agent,
-      exitCode: result?.exitCode ?? null,
-      text: result ? collectionText(result) : "",
-      ...(result ? collectionMetadata(result) : {}),
-    };
-  });
-}
-
-export function validateDynamicCollection(
-  schema: ReadonlyInput<JsonSchemaObject> | undefined,
-  value: readonly ReadonlyInput<DynamicCollectedResult>[],
-): void {
-  if (!schema) {
-    return;
-  }
-  const validation = validateStructuredOutputValue(schema, value);
-  if (validation.status === "invalid") {
-    throw new DynamicFanoutError(`Collected output validation failed: ${validation.message}`);
-  }
-}

package/src/runs/shared/dynamic-item.ts

@@ -1,114 +0,0 @@
-import { isRecord, isUnknownArray } from "../../shared/unknown.ts";
-
-export class DynamicFanoutError extends Error {}
-const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
-
-export function assertJsonPointer(pointer: string, label: string): void {
-  if (pointer === "") {
-    return;
-  }
-  if (!pointer.startsWith("/")) {
-    throw new DynamicFanoutError(`${label} must be a JSON Pointer starting with '/'.`);
-  }
-  for (const segment of pointer.slice(1).split("/")) {
-    if (/~(?![01])/.test(segment)) {
-      throw new DynamicFanoutError(`${label} contains invalid JSON Pointer escape.`);
-    }
-  }
-}
-
-export function resolveJsonPointer(value: unknown, pointer: string, label: string): unknown {
-  assertJsonPointer(pointer, label);
-  if (pointer === "") {
-    return value;
-  }
-  let current = value;
-  for (const rawSegment of pointer.slice(1).split("/")) {
-    const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
-    if (isUnknownArray(current)) {
-      if (!/^(0|[1-9][0-9]*)$/.test(segment)) {
-        throw new DynamicFanoutError(
-          `${label} segment '${segment}' does not address an array index.`,
-        );
-      }
-      const index = Number(segment);
-      if (index >= current.length) {
-        throw new DynamicFanoutError(`${label} does not exist.`);
-      }
-      current = current[index];
-      continue;
-    }
-    if (!isRecord(current) || !Object.hasOwn(current, segment)) {
-      throw new DynamicFanoutError(`${label} does not exist.`);
-    }
-    current = current[segment];
-  }
-  return current;
-}
-
-export function scalarToKey(value: unknown, label: string): string {
-  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
-    throw new DynamicFanoutError(`${label} must resolve to a string, number, or boolean.`);
-  }
-  const key = String(value);
-  if (key.trim().length === 0) {
-    throw new DynamicFanoutError(`${label} resolved to an empty key.`);
-  }
-  // Item identifiers cross process boundaries; reject ASCII C0 controls and DEL.
-  // oxlint-disable-next-line no-control-regex
-  if (/[\u0000-\u001F\u007F]/.test(key)) {
-    throw new DynamicFanoutError(`${label} resolved to an unsafe key.`);
-  }
-  if (key.length > 200) {
-    throw new DynamicFanoutError(`${label} resolved to a key longer than 200 characters.`);
-  }
-  return key;
-}
-
-export function normalizeItemKeyForId(key: string): string {
-  const normalized = key
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80);
-  return normalized.length > 0 ? normalized : "item";
-}
-
-function valueToTemplateText(value: unknown, reference: string): string {
-  if (value === undefined) {
-    throw new DynamicFanoutError(`Unresolved item reference '${reference}'.`);
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean" || value === null) {
-    return String(value);
-  }
-  return JSON.stringify(value);
-}
-
-function resolveItemPath(item: unknown, pathText: string | undefined, reference: string): unknown {
-  if (pathText === undefined || pathText.length === 0) {
-    return item;
-  }
-  const pointer = `/${pathText
-    .split(".")
-    .map((segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1"))
-    .join("/")}`;
-  return resolveJsonPointer(item, pointer, reference);
-}
-
-export function resolveItemTemplate(template: string, itemName: string, item: unknown): string {
-  return template.replace(
-    ITEM_REF_PATTERN,
-    (raw: string, name: string, pathText: string | undefined) => {
-      if (name !== itemName) {
-        return raw;
-      }
-      if (pathText !== undefined && (pathText.trim().length === 0 || pathText.includes(".."))) {
-        throw new DynamicFanoutError(`Invalid item reference '${raw}'.`);
-      }
-      return valueToTemplateText(resolveItemPath(item, pathText, raw), raw);
-    },
-  );
-}

package/src/runs/shared/history-index.ts

@@ -1,130 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { SubagentHistoryIndex } from "../../history/index.ts";
-import type { HistoryIndexHandle } from "../../shared/types/history.ts";
-import type { OwnedRun, SubagentState } from "../../shared/types.ts";
-import { getAgentDir } from "../../shared/agent-dir.ts";
-import type { OwnedRunReadState } from "./owned-run-read-state.ts";
-
-function reportCloseFailure(error: unknown): void {
-  console.error("Could not close subagent history:", error);
-}
-
-async function closeOwners(
-  previous: Promise<void> | undefined,
-  index: HistoryIndexHandle | undefined,
-): Promise<void> {
-  await Promise.all([previous, index?.close()]);
-}
-
-export function closeRunHistory(state: SubagentState): Promise<void> {
-  const index = state.historyIndex;
-  state.historyIndex = undefined;
-  state.historyReady = undefined;
-  const closing = closeOwners(state.historyClosing, index);
-  state.historyClosing = closing;
-  return closing;
-}
-
-function observeReadiness(state: SubagentState, index: HistoryIndexHandle): void {
-  // Keep the original rejected readiness promise for callers and explicit retry.
-  // This observer owns disposal, not a replacement readiness result.
-  state.historyReady?.catch(() => {
-    if (state.historyIndex === index) {
-      index.close().catch(reportCloseFailure);
-    }
-  });
-}
-
-function admitOwner(
-  state: SubagentState,
-  ownerSessionId: string,
-  ownerSessionFile?: string,
-): HistoryIndexHandle {
-  const index = new SubagentHistoryIndex(getAgentDir());
-  state.historyIndex = index;
-  const snapshot = {
-    ownerSessionId,
-    ownerSessionFile,
-    runs: [...(state.ownedRuns?.values() ?? [])],
-    foregroundRuns: [...(state.foregroundRuns?.values() ?? [])],
-  };
-  state.historyReady = (state.historyClosing ?? Promise.resolve()).then(() =>
-    index.setOwner(snapshot),
-  );
-  index.onChanged(() => {
-    if (state.historyIndex === index) {
-      state.onRunsChanged?.();
-    }
-  });
-  observeReadiness(state, index);
-  return index;
-}
-
-export function startRunHistory(state: SubagentState, ctx: ExtensionContext): void {
-  closeRunHistory(state).catch(reportCloseFailure);
-  // Fresh sessions pay no process/database startup cost until they browse or own work.
-  if ((state.ownedRuns?.size ?? 0) > 0) {
-    admitOwner(state, ctx.sessionManager.getSessionId(), ctx.sessionManager.getSessionFile());
-  }
-}
-
-export function updateRunHistory(state: SubagentState, run: OwnedRun): void {
-  const index = state.historyIndex;
-  if (!index) {
-    return;
-  }
-  state.historyReady = (state.historyReady ?? Promise.resolve()).then(() =>
-    index.updateRun(run, state.foregroundRuns?.get(run.runId)),
-  );
-  observeReadiness(state, index);
-}
-
-type HistoryOwnerState = OwnedRunReadState &
-  Readonly<Pick<SubagentState, "lastUiContext" | "currentSessionId">>;
-
-function historyOwner(state: HistoryOwnerState): string {
-  const current = state.lastUiContext?.sessionManager.getSessionId();
-  if (current !== undefined && current !== "") {
-    return current;
-  }
-  // Non-UI callers hold restored handles; a directory/index record cannot grant ownership.
-  const owners = new Set([...(state.ownedRuns?.values() ?? [])].map((run) => run.ownerSessionId));
-  if (owners.size > 1) {
-    throw new Error("History requires one verified owning session.");
-  }
-  const owner = owners.values().next().value ?? state.currentSessionId;
-  if (owner === null || owner === "") {
-    throw new Error("History requires an active owning session.");
-  }
-  return owner;
-}
-
-async function retryFailedOwner(state: SubagentState, ownerSessionId: string): Promise<void> {
-  const closing = closeRunHistory(state);
-  await closing;
-  if (state.historyClosing !== closing || historyOwner(state) !== ownerSessionId) {
-    throw new Error("Owning session changed while history was loading.");
-  }
-}
-
-export async function runHistoryIndex(
-  state: SubagentState,
-  retry = false,
-): Promise<HistoryIndexHandle> {
-  const ownerSessionId = historyOwner(state);
-  if (retry && state.historyIndex?.failure !== undefined) {
-    await retryFailedOwner(state, ownerSessionId);
-  }
-  const index =
-    state.historyIndex ??
-    admitOwner(state, ownerSessionId, state.lastUiContext?.sessionManager.getSessionFile());
-  await state.historyReady;
-  if (state.historyIndex !== index || historyOwner(state) !== ownerSessionId) {
-    throw new Error("Owning session changed while history was loading.");
-  }
-  const failure = index.failure;
-  if (failure instanceof Error) {
-    throw failure;
-  }
-  return index;
-}