Function syncKnownRoots

src/index.ts:431–480

(rootEntries: Array<{ rootPath: string; label?: string }>)

}

function syncKnownRoots(rootEntries: Array<{ rootPath: string; label?: string }>): void {
  const nextRoots = new Map<string, { rootPath: string; label?: string }>();
  const normalizedRoots =
    rootEntries.length > 0 ? rootEntries : primaryRootPath ? [{ rootPath: primaryRootPath }] : [];

  for (const entry of normalizedRoots) {
    const resolvedRootPath = path.resolve(entry.rootPath);
    nextRoots.set(normalizeRootKey(resolvedRootPath), {
      rootPath: resolvedRootPath,
      label: entry.label?.trim() || undefined
    });
  }

  // Always include config-registered roots — config is additive (REPO-03)
  for (const [rootKey, rootEntry] of configRoots.entries()) {
    if (!nextRoots.has(rootKey)) {
      nextRoots.set(rootKey, rootEntry);
    }
  }

  for (const [rootKey, existingRoot] of knownRoots.entries()) {
    if (!nextRoots.has(rootKey)) {
      removeProject(existingRoot.rootPath);
      forgetProjectPath(existingRoot.rootPath);
    }
  }

  for (const project of getAllProjects()) {
    const stillAllowed = Array.from(nextRoots.values()).some((knownRoot) =>
      isPathWithin(knownRoot.rootPath, project.rootPath)
    );
    if (!stillAllowed) {
      removeProject(project.rootPath);
      forgetProjectPath(project.rootPath);
    }
  }

  knownRoots.clear();
  clearDiscoveredProjectPaths();
  for (const [rootKey, rootEntry] of nextRoots.entries()) {
    knownRoots.set(rootKey, rootEntry);
    rememberProjectPath(rootEntry.rootPath, 'root', { touch: false });
  }

  if (activeProjectKey) {
    if (!getTrackedRootPathByKey(activeProjectKey)) {
      activeProjectKey = undefined;
    }
  }
}

function parseProjectSelector(value: unknown): string | undefined {
  if (typeof value !== 'string') return undefined;