omni-pi 0.8.3 → 0.9.0

package/README.md

@@ -14,6 +14,7 @@ Requires Node.js 22 or newer.
 - `/omni-mode` turns on Omni's specialized interview, plan, build, and verify workflow for the current project.
 - Keeps durable standards and project context in `.omni/`, even when Omni mode is off.
 - Writes specs, tasks, and progress into `.omni/` once Omni mode is enabled.
+- Adds a repo map that indexes supported source files, ranks them by structure plus recent activity, and injects a compact codebase-awareness block into Omni prompts.
 - Bundles web search, guided interviews, themed UI, native micro-UI via Glimpse, a task viewer, a powerbar, custom provider/model management, and automatic updates out of the box.
 
 ## Install
@@ -41,6 +42,25 @@ Omni-Pi now ships the essential skill-discovery stack in the package itself:
 - `skill-creator` is bundled for creating project-specific skills when nothing suitable exists
 - `brainstorming` is bundled and used for Omni planning and task creation flows
 
+### Repo Map
+
+Omni-Pi now includes a SoulForge-style repo map for codebase awareness while Omni mode is on.
+
+The first shipped version includes:
+
+- incremental indexing of supported repo files while respecting `.gitignore`
+- symbol/import extraction for TypeScript/JavaScript-family files with graceful fallback for partial/unsupported cases
+- graph-aware ranking blended with current-turn boosts from recent reads, edits, writes, and prompt mentions
+- budget-aware prompt rendering so Omni gets a compact ranked view of important files and exported symbols
+- runtime cache storage under `.pi/repo-map/` rather than durable `.omni/` memory
+
+Current deferred roadmap items remain intentional and visible in docs rather than hidden in code:
+
+- semantic symbol summaries
+- git co-change ranking
+- richer analysis views such as dead-code or clone-detection signals
+- broader parser/language coverage as needed
+
 ### Bundled Extensions
 
 | Extension | What it does |
@@ -107,6 +127,7 @@ Omni-Pi keeps its current branding and shell at all times, but the specialized w
 
 - When Omni mode is off, Omni behaves like normal Pi and only uses `.omni/` as passive standards/context when those files already exist.
 - When Omni mode is on, Omni lazily initializes or migrates `.omni/` on the first real turn, then uses the full interview, planning, task, and verification workflow.
+- While Omni mode is on, Omni also maintains a runtime repo map in `.pi/repo-map/` so prompts can include a compact ranked view of important files and symbols.
 - During Omni init, Omni can discover standards from files like `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, Copilot instructions, Cursor rules, Windsurf rules, and Continue rules, then ask whether to keep those standards in Omni's durable memory.
 - In Git repos, Omni ensures `.pi/` is ignored because that directory is only runtime-local Pi state.
 - While Omni mode is on, every planned or executed task checks for required skills, auto-installs matching skills into `.omni/project-skills/`, creates a project skill when none exists, records task-to-skill dependencies, and removes project skills once no open task still needs them.

package/extensions/omni-core/index.ts

@@ -13,12 +13,23 @@ import {
   registerPiCommands,
 } from "../../src/pi.js";
 import { registerProviderAuthCommand } from "../../src/provider-auth-command.js";
+import {
+  buildRepoMapPromptSuffix,
+  registerRepoMapTracking,
+  warmRepoMap,
+} from "../../src/repo-map-runtime.js";
+import {
+  formatRtkModeStatus,
+  refreshRtkStatusIndicator,
+  registerRtkBashRouting,
+} from "../../src/rtk.js";
 import {
   createOmniTheme,
   ensurePiSettings,
   formatOmniModeStatus,
   loadSavedTheme,
   readOmniMode,
+  readRtkMode,
 } from "../../src/theme.js";
 import { registerThemeCommand } from "../../src/theme-command.js";
 import { registerTodoShortcut } from "../../src/todo-shortcut.js";
@@ -33,6 +44,8 @@ export default function omniCoreExtension(api: ExtensionAPI): void {
   registerThemeCommand(api);
   registerTodoShortcut(api);
   registerUpdater(api);
+  registerRtkBashRouting(api);
+  registerRepoMapTracking(api);
 
   api.on("session_start", async (_event, ctx) => {
     await ensurePiSettings(ctx.cwd);
@@ -42,6 +55,11 @@ export default function omniCoreExtension(api: ExtensionAPI): void {
     ctx.ui.setTheme(createOmniTheme());
     ctx.ui.setHeader((_tui, theme) => renderHeader(theme));
     ctx.ui.setStatus("omni", formatOmniModeStatus(omniMode));
+    ctx.ui.setStatus("rtk", formatRtkModeStatus(readRtkMode(ctx.cwd), false));
+    await refreshRtkStatusIndicator(ctx);
+    if (omniMode) {
+      void warmRepoMap(ctx.cwd);
+    }
   });
 
   api.on("before_agent_start", async (event, ctx) => {
@@ -62,10 +80,14 @@ export default function omniCoreExtension(api: ExtensionAPI): void {
     const onboardingKickoff = init.initResult?.onboardingInterviewNeeded
       ? buildOnboardingInterviewKickoff(init.initResult)
       : "";
+    const repoMapPrompt = await buildRepoMapPromptSuffix(ctx.cwd, {
+      prompt: typeof event.prompt === "string" ? event.prompt : "",
+    });
     const prompt = [
       event.systemPrompt,
       passivePrompt,
       workflowPrompt,
+      repoMapPrompt,
       onboardingKickoff,
     ]
       .filter(Boolean)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-pi",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "description": "Single-agent Pi package that interviews the user, documents the spec, and implements work in bounded slices.",
   "type": "module",
   "license": "MIT",
@@ -78,12 +78,12 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.84",
-    "@juanibiapina/pi-extension-settings": "^0.6.0",
-    "@juanibiapina/pi-powerbar": "^0.7.1",
-    "@mariozechner/pi-coding-agent": "^0.65.2",
-    "glimpseui": "^0.6.2",
-    "pi-interview": "^0.5.5",
-    "pi-web-access": "^0.10.3",
+    "@juanibiapina/pi-extension-settings": "^0.6.1",
+    "@juanibiapina/pi-powerbar": "^0.8.0",
+    "@mariozechner/pi-coding-agent": "^0.67.68",
+    "glimpseui": "^0.7.0",
+    "pi-interview": "^0.6.2",
+    "pi-web-access": "^0.10.6",
     "zod": "^4.3.6"
   },
   "overrides": {

package/src/commands.ts

@@ -1,4 +1,5 @@
 import type { AppCommandDefinition } from "./pi.js";
+import { executeRtkCommand } from "./rtk.js";
 import { formatOmniModeStatus, readOmniMode, saveOmniMode } from "./theme.js";
 
 export function createOmniCommands(): AppCommandDefinition[] {
@@ -22,5 +23,16 @@ export function createOmniCommands(): AppCommandDefinition[] {
           : "Omni mode is now OFF. Omni will keep using durable standards from .omni/ when present, but task workflow state is disabled.";
       },
     },
+    {
+      name: "omni-rtk",
+      description:
+        "Install RTK and control Omni's bash-side RTK routing (status, install, on, off)",
+      async execute(context) {
+        if (!context.runtime) {
+          return "The /omni-rtk command is only available inside Omni-Pi interactive sessions.";
+        }
+        return await executeRtkCommand(context.args, context.runtime.ctx);
+      },
+    },
   ];
 }

package/src/repo-map-contracts.ts

@@ -0,0 +1,93 @@
+import path from "node:path";
+
+export const REPO_MAP_DIR = path.join(".pi", "repo-map");
+export const REPO_MAP_STATE_FILE = path.join(REPO_MAP_DIR, "state.json");
+export const REPO_MAP_SCHEMA_VERSION = 1;
+
+export type RepoMapParserStatus =
+  | "indexed"
+  | "unsupported"
+  | "binary-fallback"
+  | "parse-fallback";
+
+export type RepoMapSignalType = "read" | "edit" | "write" | "mention";
+
+export interface RepoMapSymbol {
+  name: string;
+  kind:
+    | "function"
+    | "class"
+    | "interface"
+    | "type"
+    | "enum"
+    | "const"
+    | "default"
+    | "module";
+  signature?: string;
+  exported: boolean;
+}
+
+export interface RepoMapImport {
+  specifier: string;
+  resolvedPath?: string;
+}
+
+export interface RepoMapFileRecord {
+  path: string;
+  language: string;
+  parserStatus: RepoMapParserStatus;
+  size: number;
+  mtimeMs: number;
+  fingerprint: string;
+  indexedAt: string;
+  firstIndexedAt: string;
+  symbols: RepoMapSymbol[];
+  imports: RepoMapImport[];
+  outgoingPaths: string[];
+  incomingPaths: string[];
+}
+
+export interface RepoMapState {
+  schemaVersion: number;
+  indexedAt: string;
+  files: Record<string, RepoMapFileRecord>;
+}
+
+export interface RepoMapRankedEntry {
+  path: string;
+  file: RepoMapFileRecord;
+  baseScore: number;
+  turnScore: number;
+  finalScore: number;
+  blastRadius: number;
+  tags: string[];
+}
+
+export interface RepoMapSignal {
+  type: RepoMapSignalType;
+  path: string;
+  timestamp: number;
+}
+
+export interface RepoMapSessionState {
+  signals: RepoMapSignal[];
+  dirtyPaths: Set<string>;
+}
+
+export interface RepoMapRenderOptions {
+  prompt?: string;
+  maxTokens?: number;
+}
+
+export interface RepoMapRefreshResult {
+  state: RepoMapState;
+  indexedPaths: string[];
+  removedPaths: string[];
+  reusedPaths: string[];
+}
+
+export interface RepoMapDebugSnapshot {
+  state: RepoMapState;
+  ranked: RepoMapRankedEntry[];
+  rendered: string;
+}

package/src/repo-map-index.ts

@@ -0,0 +1,467 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+
+import type {
+  RepoMapFileRecord,
+  RepoMapImport,
+  RepoMapRefreshResult,
+  RepoMapState,
+  RepoMapSymbol,
+} from "./repo-map-contracts.js";
+import { REPO_MAP_SCHEMA_VERSION } from "./repo-map-contracts.js";
+import { readRepoMapState, writeRepoMapState } from "./repo-map-store.js";
+
+const DEFAULT_IGNORES = new Set([
+  ".git",
+  ".pi",
+  ".omni",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  "target",
+]);
+
+const SUPPORTED_EXTENSIONS = new Map<string, string>([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".json", "json"],
+]);
+
+interface IgnoreRule {
+  pattern: string;
+  anchored: boolean;
+  directoryOnly: boolean;
+}
+
+interface WalkContext {
+  rootDir: string;
+  relativeDir: string;
+  rules: IgnoreRule[];
+}
+
+interface ParsedFile {
+  language: string;
+  parserStatus: RepoMapFileRecord["parserStatus"];
+  symbols: RepoMapSymbol[];
+  imports: RepoMapImport[];
+}
+
+function normalizeRelativePath(value: string): string {
+  return value.split(path.sep).join("/");
+}
+
+function hashContent(text: string): string {
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16);
+}
+
+function parseIgnoreRules(content: string): IgnoreRule[] {
+  return content
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(
+      (line) =>
+        line.length > 0 && !line.startsWith("#") && !line.startsWith("!"),
+    )
+    .map((line) => {
+      const directoryOnly = line.endsWith("/");
+      const raw = directoryOnly ? line.slice(0, -1) : line;
+      const anchored = raw.startsWith("/");
+      return {
+        pattern: raw.replace(/^\//u, ""),
+        anchored,
+        directoryOnly,
+      };
+    });
+}
+
+function matchSingleSegment(pattern: string, value: string): boolean {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/gu, "\\$&")
+    .replace(/\*/gu, ".*");
+  return new RegExp(`^${escaped}$`, "u").test(value);
+}
+
+function isIgnored(
+  relativePath: string,
+  isDirectory: boolean,
+  rules: IgnoreRule[],
+): boolean {
+  const normalized = normalizeRelativePath(relativePath);
+  const segments = normalized.split("/").filter(Boolean);
+  return rules.some((rule) => {
+    if (rule.directoryOnly && !isDirectory) {
+      return false;
+    }
+    if (rule.pattern.includes("/")) {
+      const target = rule.anchored ? normalized : normalized;
+      if (rule.pattern.includes("*")) {
+        const escaped = rule.pattern
+          .replace(/[.+^${}()|[\]\\]/gu, "\\$&")
+          .replace(/\*/gu, ".*");
+        const regex = rule.anchored
+          ? new RegExp(`^${escaped}(?:/.*)?$`, "u")
+          : new RegExp(`(?:^|/)${escaped}(?:/.*)?$`, "u");
+        return regex.test(target);
+      }
+      return rule.anchored
+        ? target === rule.pattern || target.startsWith(`${rule.pattern}/`)
+        : target === rule.pattern ||
+            target.includes(`/${rule.pattern}`) ||
+            target.startsWith(`${rule.pattern}/`);
+    }
+    return segments.some((segment) =>
+      matchSingleSegment(rule.pattern, segment),
+    );
+  });
+}
+
+async function loadIgnoreRules(dir: string): Promise<IgnoreRule[]> {
+  try {
+    const content = await readFile(path.join(dir, ".gitignore"), "utf8");
+    return parseIgnoreRules(content);
+  } catch {
+    return [];
+  }
+}
+
+async function walkEligibleFiles(context: WalkContext): Promise<string[]> {
+  const absoluteDir = path.join(context.rootDir, context.relativeDir);
+  const [entries, localRules] = await Promise.all([
+    readdir(absoluteDir, { withFileTypes: true }),
+    loadIgnoreRules(absoluteDir),
+  ]);
+  const rules = [...context.rules, ...localRules];
+  const results: string[] = [];
+
+  for (const entry of entries) {
+    const relativePath = normalizeRelativePath(
+      path.join(context.relativeDir, entry.name),
+    );
+
+    if (DEFAULT_IGNORES.has(entry.name)) {
+      continue;
+    }
+    if (isIgnored(relativePath, entry.isDirectory(), rules)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      results.push(
+        ...(await walkEligibleFiles({
+          rootDir: context.rootDir,
+          relativeDir: relativePath,
+          rules,
+        })),
+      );
+      continue;
+    }
+
+    const extension = path.extname(entry.name).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.has(extension)) {
+      continue;
+    }
+    results.push(relativePath);
+  }
+
+  return results.sort();
+}
+
+export async function discoverRepoMapFiles(rootDir: string): Promise<string[]> {
+  return walkEligibleFiles({ rootDir, relativeDir: "", rules: [] });
+}
+
+function detectLanguage(filePath: string): string {
+  return (
+    SUPPORTED_EXTENSIONS.get(path.extname(filePath).toLowerCase()) ?? "text"
+  );
+}
+
+function resolveImportPath(
+  rootDir: string,
+  filePath: string,
+  specifier: string,
+): string | undefined {
+  if (!specifier.startsWith(".")) {
+    return undefined;
+  }
+
+  const basedir = path.dirname(path.join(rootDir, filePath));
+  const candidateBase = path.resolve(basedir, specifier);
+  const candidates = [
+    candidateBase,
+    `${candidateBase}.ts`,
+    `${candidateBase}.tsx`,
+    `${candidateBase}.mts`,
+    `${candidateBase}.cts`,
+    `${candidateBase}.js`,
+    `${candidateBase}.jsx`,
+    `${candidateBase}.mjs`,
+    `${candidateBase}.cjs`,
+    path.join(candidateBase, "index.ts"),
+    path.join(candidateBase, "index.tsx"),
+    path.join(candidateBase, "index.js"),
+    path.join(candidateBase, "index.jsx"),
+  ];
+
+  for (const candidate of candidates) {
+    const relative = normalizeRelativePath(path.relative(rootDir, candidate));
+    if (relative.startsWith("..")) {
+      continue;
+    }
+    if (
+      SUPPORTED_EXTENSIONS.has(path.extname(candidate).toLowerCase()) ||
+      candidate.endsWith("/index.ts") ||
+      candidate.endsWith("/index.tsx") ||
+      candidate.endsWith("/index.js") ||
+      candidate.endsWith("/index.jsx")
+    ) {
+      return relative;
+    }
+  }
+
+  return undefined;
+}
+
+function uniqueSymbols(symbols: RepoMapSymbol[]): RepoMapSymbol[] {
+  const seen = new Set<string>();
+  return symbols.filter((symbol) => {
+    const key = `${symbol.kind}:${symbol.name}:${symbol.exported}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+function parseModuleFile(
+  rootDir: string,
+  filePath: string,
+  content: string,
+): ParsedFile {
+  if (content.includes("\u0000")) {
+    return {
+      language: detectLanguage(filePath),
+      parserStatus: "binary-fallback",
+      symbols: [],
+      imports: [],
+    };
+  }
+
+  const imports: RepoMapImport[] = [];
+  const importRegex =
+    /^(?:import\s+[\s\S]*?\s+from\s+|export\s+[\s\S]*?\s+from\s+)["']([^"']+)["'];?/gmu;
+  for (const match of content.matchAll(importRegex)) {
+    const specifier = match[1]?.trim();
+    if (!specifier) continue;
+    imports.push({
+      specifier,
+      resolvedPath: resolveImportPath(rootDir, filePath, specifier),
+    });
+  }
+
+  const symbols: RepoMapSymbol[] = [];
+  const symbolPatterns: Array<{ regex: RegExp; kind: RepoMapSymbol["kind"] }> =
+    [
+      {
+        regex:
+          /^export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*(\([^)]*\))/gmu,
+        kind: "function",
+      },
+      {
+        regex: /^export\s+class\s+([A-Za-z_$][\w$]*)/gmu,
+        kind: "class",
+      },
+      {
+        regex: /^export\s+interface\s+([A-Za-z_$][\w$]*)/gmu,
+        kind: "interface",
+      },
+      {
+        regex: /^export\s+type\s+([A-Za-z_$][\w$]*)/gmu,
+        kind: "type",
+      },
+      {
+        regex: /^export\s+enum\s+([A-Za-z_$][\w$]*)/gmu,
+        kind: "enum",
+      },
+      {
+        regex: /^export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/gmu,
+        kind: "const",
+      },
+    ];
+
+  for (const pattern of symbolPatterns) {
+    for (const match of content.matchAll(pattern.regex)) {
+      const name = match[1]?.trim();
+      if (!name) continue;
+      const signature = match[2]?.trim();
+      symbols.push({
+        name,
+        kind: pattern.kind,
+        signature,
+        exported: true,
+      });
+    }
+  }
+
+  if (/^export\s+default\b/gmu.test(content)) {
+    symbols.push({
+      name: path.basename(filePath, path.extname(filePath)),
+      kind: "default",
+      exported: true,
+    });
+  }
+
+  return {
+    language: detectLanguage(filePath),
+    parserStatus: "indexed",
+    symbols: uniqueSymbols(symbols),
+    imports,
+  };
+}
+
+export async function indexRepoMapFile(
+  rootDir: string,
+  filePath: string,
+  previous?: RepoMapFileRecord,
+): Promise<RepoMapFileRecord> {
+  const absolutePath = path.join(rootDir, filePath);
+  const [stats, content] = await Promise.all([
+    stat(absolutePath),
+    readFile(absolutePath, "utf8"),
+  ]);
+  const parsed = parseModuleFile(rootDir, filePath, content);
+  const now = new Date().toISOString();
+
+  return {
+    path: filePath,
+    language: parsed.language,
+    parserStatus: parsed.parserStatus,
+    size: stats.size,
+    mtimeMs: stats.mtimeMs,
+    fingerprint: hashContent(content),
+    indexedAt: now,
+    firstIndexedAt: previous?.firstIndexedAt ?? now,
+    symbols: parsed.symbols,
+    imports: parsed.imports,
+    outgoingPaths: parsed.imports
+      .map((entry) => entry.resolvedPath)
+      .filter((value): value is string => Boolean(value)),
+    incomingPaths: previous?.incomingPaths ?? [],
+  };
+}
+
+function rebuildIncomingPaths(files: Record<string, RepoMapFileRecord>): void {
+  for (const file of Object.values(files)) {
+    file.incomingPaths = [];
+  }
+  for (const file of Object.values(files)) {
+    const uniqueOutgoing = [...new Set(file.outgoingPaths)].filter(
+      (target) => target in files,
+    );
+    file.outgoingPaths = uniqueOutgoing;
+    for (const target of uniqueOutgoing) {
+      files[target]?.incomingPaths.push(file.path);
+    }
+  }
+  for (const file of Object.values(files)) {
+    file.incomingPaths = [...new Set(file.incomingPaths)].sort();
+  }
+}
+
+export async function refreshRepoMapState(
+  rootDir: string,
+  dirtyPaths: Iterable<string> = [],
+): Promise<RepoMapRefreshResult> {
+  const previous = await readRepoMapState(rootDir);
+  const discovered = await discoverRepoMapFiles(rootDir);
+  const discoveredSet = new Set(discovered);
+  const dirtySet = new Set([...dirtyPaths].map(normalizeRelativePath));
+  const nextFiles: Record<string, RepoMapFileRecord> = {};
+  const indexedPaths: string[] = [];
+  const reusedPaths: string[] = [];
+
+  for (const filePath of discovered) {
+    const previousRecord = previous.files[filePath];
+    const absolutePath = path.join(rootDir, filePath);
+    const stats = await stat(absolutePath);
+    const unchanged =
+      previousRecord &&
+      previousRecord.mtimeMs === stats.mtimeMs &&
+      previousRecord.size === stats.size &&
+      !dirtySet.has(filePath) &&
+      previous.schemaVersion === REPO_MAP_SCHEMA_VERSION;
+
+    if (unchanged) {
+      nextFiles[filePath] = {
+        ...previousRecord,
+        incomingPaths: [...previousRecord.incomingPaths],
+        outgoingPaths: [...previousRecord.outgoingPaths],
+        imports: [...previousRecord.imports],
+        symbols: [...previousRecord.symbols],
+      };
+      reusedPaths.push(filePath);
+      continue;
+    }
+
+    try {
+      nextFiles[filePath] = await indexRepoMapFile(
+        rootDir,
+        filePath,
+        previousRecord,
+      );
+      indexedPaths.push(filePath);
+    } catch {
+      nextFiles[filePath] = {
+        path: filePath,
+        language: detectLanguage(filePath),
+        parserStatus: "parse-fallback",
+        size: stats.size,
+        mtimeMs: stats.mtimeMs,
+        fingerprint: `${stats.size}:${stats.mtimeMs}`,
+        indexedAt: new Date().toISOString(),
+        firstIndexedAt:
+          previousRecord?.firstIndexedAt ?? new Date().toISOString(),
+        symbols: [],
+        imports: [],
+        outgoingPaths: [],
+        incomingPaths: [],
+      };
+      indexedPaths.push(filePath);
+    }
+  }
+
+  rebuildIncomingPaths(nextFiles);
+  const removedPaths = Object.keys(previous.files).filter(
+    (filePath) => !discoveredSet.has(filePath),
+  );
+
+  const state: RepoMapState = {
+    schemaVersion: REPO_MAP_SCHEMA_VERSION,
+    indexedAt: new Date().toISOString(),
+    files: nextFiles,
+  };
+  await writeRepoMapState(rootDir, state);
+
+  return {
+    state,
+    indexedPaths: indexedPaths.sort(),
+    removedPaths: removedPaths.sort(),
+    reusedPaths: reusedPaths.sort(),
+  };
+}