@gotgenes/pi-permission-system 5.4.0 → 5.5.1

package/src/handlers/lifecycle.ts

@@ -19,25 +19,25 @@ export async function handleSessionStart(
   event: SessionStartPayload,
   ctx: ExtensionContext,
 ): Promise<void> {
-  deps.runtime.runtimeContext = ctx;
+  deps.session.runtimeContext = ctx;
   deps.refreshExtensionConfig(ctx);
-  deps.runtime.permissionManager = deps.createPermissionManagerForCwd(ctx.cwd);
-  deps.runtime.activeSkillEntries = [];
-  deps.runtime.lastActiveToolsCacheKey = null;
-  deps.runtime.lastPromptStateCacheKey = null;
-  deps.runtime.lastKnownActiveAgentName = getActiveAgentName(ctx);
+  deps.session.permissionManager = deps.createPermissionManagerForCwd(ctx.cwd);
+  deps.session.activeSkillEntries = [];
+  deps.session.lastActiveToolsCacheKey = null;
+  deps.session.lastPromptStateCacheKey = null;
+  deps.session.lastKnownActiveAgentName = getActiveAgentName(ctx);
   deps.startForwardedPermissionPolling(ctx);
   deps.logResolvedConfigPaths();
 
-  const agentName = deps.runtime.lastKnownActiveAgentName;
+  const agentName = deps.session.lastKnownActiveAgentName;
   const policyIssues =
-    deps.runtime.permissionManager.getConfigIssues(agentName);
+    deps.session.permissionManager.getConfigIssues(agentName);
   for (const issue of policyIssues) {
     deps.notifyWarning(issue);
   }
 
   if (event.reason === "reload") {
-    deps.runtime.writeDebugLog("lifecycle.reload", {
+    deps.writeDebugLog("lifecycle.reload", {
       triggeredBy: "session_start",
       reason: event.reason,
       cwd: ctx.cwd,
@@ -53,14 +53,14 @@ export async function handleResourcesDiscover(
     return;
   }
 
-  const { runtimeContext } = deps.runtime;
-  deps.runtime.permissionManager = deps.createPermissionManagerForCwd(
+  const { runtimeContext } = deps.session;
+  deps.session.permissionManager = deps.createPermissionManagerForCwd(
     runtimeContext?.cwd,
   );
-  deps.runtime.activeSkillEntries = [];
-  deps.runtime.lastActiveToolsCacheKey = null;
-  deps.runtime.lastPromptStateCacheKey = null;
-  deps.runtime.writeDebugLog("lifecycle.reload", {
+  deps.session.activeSkillEntries = [];
+  deps.session.lastActiveToolsCacheKey = null;
+  deps.session.lastPromptStateCacheKey = null;
+  deps.writeDebugLog("lifecycle.reload", {
     triggeredBy: "resources_discover",
     reason: event.reason,
     cwd: runtimeContext?.cwd ?? null,
@@ -68,15 +68,15 @@ export async function handleResourcesDiscover(
 }
 
 export async function handleSessionShutdown(deps: HandlerDeps): Promise<void> {
-  const { runtimeContext } = deps.runtime;
+  const { runtimeContext } = deps.session;
   if (runtimeContext) {
     runtimeContext.ui.setStatus(PERMISSION_SYSTEM_STATUS_KEY, undefined);
   }
-  deps.runtime.runtimeContext = null;
-  deps.runtime.activeSkillEntries = [];
-  deps.runtime.lastActiveToolsCacheKey = null;
-  deps.runtime.lastPromptStateCacheKey = null;
-  deps.runtime.sessionRules.clear();
+  deps.session.runtimeContext = null;
+  deps.session.activeSkillEntries = [];
+  deps.session.lastActiveToolsCacheKey = null;
+  deps.session.lastPromptStateCacheKey = null;
+  deps.session.sessionRules.clear();
   deps.stopForwardedPermissionPolling();
   deps.stopPermissionRpcHandlers();
 }

package/src/handlers/tool-call.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 
 import { toRecord } from "../common";
+import { emitDecisionEvent } from "../permission-events";
 import {
   formatMissingToolNameReason,
   formatUnknownToolReason,
@@ -13,8 +14,14 @@ import { evaluateBashExternalDirectoryGate } from "./gates/bash-external-directo
 import { evaluateExternalDirectoryGate } from "./gates/external-directory";
 import { evaluateSkillReadGate } from "./gates/skill-read";
 import { evaluateToolGate } from "./gates/tool";
-import type { ToolCallContext } from "./gates/types";
-import type { HandlerDeps } from "./types";
+import type {
+  BashExternalDirectoryGateDeps,
+  ExternalDirectoryGateDeps,
+  SkillReadGateDeps,
+  ToolCallContext,
+  ToolGateDeps,
+} from "./gates/types";
+import type { HandlerDeps, PromptPermissionDetails } from "./types";
 
 /**
  * Extract the tool input from an event, checking both `input` and `arguments`
@@ -39,7 +46,7 @@ export async function handleToolCall(
   event: unknown,
   ctx: ExtensionContext,
 ): Promise<{ block?: true; reason?: string }> {
-  deps.runtime.runtimeContext = ctx;
+  deps.session.runtimeContext = ctx;
   deps.startForwardedPermissionPolling(ctx);
 
   const agentName = deps.resolveAgentName(ctx);
@@ -81,26 +88,89 @@ export async function handleToolCall(
     cwd: ctx.cwd,
   };
 
+  // ── Shared gate adapter closures ───────────────────────────────────────
+  const canConfirm = () => deps.canRequestPermissionConfirmation(ctx);
+  const promptPermission = (details: PromptPermissionDetails) =>
+    deps.promptPermission(ctx, details);
+  const emitDecision = (e: Parameters<ToolGateDeps["emitDecision"]>[0]) =>
+    emitDecisionEvent(deps.events, e);
+  const { writeReviewLog } = deps;
+  const checkPermission: ToolGateDeps["checkPermission"] = (
+    surface,
+    input,
+    agent,
+    sessionRules,
+  ) =>
+    deps.session.permissionManager.checkPermission(
+      surface,
+      input,
+      agent,
+      sessionRules,
+    );
+  const getSessionRuleset = () => deps.session.sessionRules.getRuleset();
+  const approveSessionRule = (surface: string, pattern: string) =>
+    deps.session.sessionRules.approve(surface, pattern);
+
   // ── Skill-read gate ──────────────────────────────────────────────────────
-  const skillResult = await evaluateSkillReadGate(tcc, deps);
+  const skillReadGateDeps: SkillReadGateDeps = {
+    getActiveSkillEntries: () => deps.session.activeSkillEntries,
+    writeReviewLog,
+    emitDecision,
+    canConfirm,
+    promptPermission,
+  };
+  const skillResult = await evaluateSkillReadGate(tcc, skillReadGateDeps);
   if (skillResult?.action === "block") {
     return { block: true, reason: skillResult.reason };
   }
 
   // ── External-directory gate (file tools) ─────────────────────────────────
-  const extDirResult = await evaluateExternalDirectoryGate(tcc, deps);
+  const extDirGateDeps: ExternalDirectoryGateDeps = {
+    checkPermission,
+    getSessionRuleset,
+    approveSessionRule,
+    writeReviewLog,
+    emitDecision,
+    canConfirm,
+    promptPermission,
+    getInfrastructureDirs: () => [
+      ...deps.piInfrastructureDirs,
+      ...deps.getPiInfrastructureReadPaths(),
+    ],
+  };
+  const extDirResult = await evaluateExternalDirectoryGate(tcc, extDirGateDeps);
   if (extDirResult?.action === "block") {
     return { block: true, reason: extDirResult.reason };
   }
 
   // ── Bash external-directory gate ─────────────────────────────────────────
-  const bashExtResult = await evaluateBashExternalDirectoryGate(tcc, deps);
+  const bashExtGateDeps: BashExternalDirectoryGateDeps = {
+    checkPermission,
+    getSessionRuleset,
+    approveSessionRule,
+    writeReviewLog,
+    canConfirm,
+    promptPermission,
+  };
+  const bashExtResult = await evaluateBashExternalDirectoryGate(
+    tcc,
+    bashExtGateDeps,
+  );
   if (bashExtResult?.action === "block") {
     return { block: true, reason: bashExtResult.reason };
   }
 
   // ── Normal tool permission gate ──────────────────────────────────────────
-  const toolResult = await evaluateToolGate(tcc, deps);
+  const toolGateDeps: ToolGateDeps = {
+    checkPermission,
+    getSessionRuleset,
+    approveSessionRule,
+    writeReviewLog,
+    emitDecision,
+    canConfirm,
+    promptPermission,
+  };
+  const toolResult = await evaluateToolGate(tcc, toolGateDeps);
   if (toolResult.action === "block") {
     return { block: true, reason: toolResult.reason };
   }

package/src/handlers/types.ts

@@ -3,7 +3,7 @@ import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { PermissionPromptDecision } from "../permission-dialog";
 import type { PermissionEventBus } from "../permission-events";
 import type { PermissionManager } from "../permission-manager";
-import type { ExtensionRuntime } from "../runtime";
+import type { SessionState } from "../runtime";
 
 export type PermissionReviewSource = "tool_call" | "skill_input" | "skill_read";
 
@@ -27,13 +27,26 @@ export interface PromptPermissionDetails {
 /**
  * Explicit dependency bag passed to each extracted event handler.
  *
- * Mutable state lives in `runtime`; handlers read and write `deps.runtime.*`
- * directly instead of going through getter/setter pairs.
+ * Mutable session state lives in `session`; handlers read and write
+ * `deps.session.*` directly. Logging, infrastructure paths, and the
+ * event bus are promoted to top-level fields so handlers and gate
+ * adapters never reach through nested objects for leaf operations.
  */
 export interface HandlerDeps {
-  // ── Runtime context ────────────────────────────────────────────────────
-  /** All mutable extension state and log-writing methods. */
-  readonly runtime: ExtensionRuntime;
+  // ── Session state ─────────────────────────────────────────────────────
+  /** Mutable session state: permissionManager, sessionRules, cache keys. */
+  readonly session: SessionState;
+
+  // ── Logging (promoted from runtime) ───────────────────────────────────
+  writeDebugLog(event: string, details?: Record<string, unknown>): void;
+  writeReviewLog(event: string, details?: Record<string, unknown>): void;
+
+  // ── Immutable infrastructure paths ───────────────────────────────────
+  readonly piInfrastructureDirs: string[];
+  /** Returns config-derived infrastructure read paths (current at call time). */
+  getPiInfrastructureReadPaths(): string[];
+
+  // ── Event bus ────────────────────────────────────────────────────────
   /** Event bus for emitting permissions:decision broadcast events. */
   readonly events: PermissionEventBus;
 
@@ -54,7 +67,7 @@ export interface HandlerDeps {
   // ── Permission helpers ─────────────────────────────────────────────────
   /**
    * Resolve the active agent name from the session context or system prompt.
-   * Updates runtime.lastKnownActiveAgentName as a side effect.
+   * Updates session.lastKnownActiveAgentName as a side effect.
    */
   resolveAgentName(ctx: ExtensionContext, systemPrompt?: string): string | null;
   /** Whether the current context can show an interactive permission prompt. */

package/src/index.ts

@@ -78,7 +78,12 @@ export default function piPermissionSystemExtension(pi: ExtensionAPI): void {
   });
 
   const deps: HandlerDeps = {
-    runtime,
+    session: runtime,
+    writeDebugLog: (event, details) => runtime.writeDebugLog(event, details),
+    writeReviewLog: (event, details) => runtime.writeReviewLog(event, details),
+    piInfrastructureDirs: runtime.piInfrastructureDirs,
+    getPiInfrastructureReadPaths: () =>
+      runtime.config.piInfrastructureReadPaths ?? [],
     events: pi.events,
     createPermissionManagerForCwd: (cwd) =>
       createPermissionManagerForCwd(runtime.agentDir, cwd),

package/src/permission-manager.ts

@@ -1,21 +1,12 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
-
-import {
-  extractFrontmatter,
-  isPermissionState,
-  parseSimpleYamlMap,
-  toRecord,
-} from "./common";
-import {
-  loadUnifiedConfig,
-  normalizeUnifiedConfig,
-  stripJsonComments,
-} from "./config-loader";
-import { getGlobalConfigPath } from "./config-paths";
+import { isPermissionState } from "./common";
 import { normalizeInput } from "./input-normalizer";
 import { normalizeFlatConfig } from "./normalize";
+import {
+  FilePolicyLoader,
+  type PolicyLoader,
+  type PolicyLoaderOptions,
+  type ResolvedPolicyPaths,
+} from "./policy-loader";
 import type { Rule, RuleOrigin, Ruleset } from "./rule";
 import { evaluate, evaluateFirst } from "./rule";
 import {
@@ -27,19 +18,8 @@ import type {
   FlatPermissionConfig,
   PermissionCheckResult,
   PermissionState,
-  ScopeConfig,
 } from "./types";
 
-function defaultGlobalConfigPath(): string {
-  return getGlobalConfigPath(getAgentDir());
-}
-function defaultAgentsDir(): string {
-  return join(getAgentDir(), "agents");
-}
-function defaultGlobalMcpConfigPath(): string {
-  return join(getAgentDir(), "mcp.json");
-}
-
 const BUILT_IN_TOOL_PERMISSION_NAMES = new Set([
   "bash",
   "read",
@@ -83,49 +63,10 @@ function mergeFlatPermissions(
   return merged;
 }
 
-function readConfiguredMcpServerNamesFromConfigPath(
-  configPath: string,
-): string[] {
-  try {
-    const raw = readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(stripJsonComments(raw)) as unknown;
-    const root = toRecord(parsed);
-    const serverRecord = toRecord(root.mcpServers ?? root["mcp-servers"]);
-
-    return Object.keys(serverRecord)
-      .map((name) => name.trim())
-      .filter((name) => name.length > 0);
-  } catch {
-    return [];
-  }
-}
-
-function getConfiguredMcpServerNamesFromPaths(
-  paths: readonly string[],
-): string[] {
-  const seen = new Set<string>();
-
-  for (const path of paths) {
-    for (const name of readConfiguredMcpServerNamesFromConfigPath(path)) {
-      seen.add(name);
-    }
-  }
-
-  return [...seen].sort(
-    (left, right) => right.length - left.length || left.localeCompare(right),
-  );
-}
-
-export interface ResolvedPolicyPaths {
-  globalConfigPath: string;
-  globalConfigExists: boolean;
-  projectConfigPath: string | null;
-  projectConfigExists: boolean;
-  agentsDir: string;
-  agentsDirExists: boolean;
-  projectAgentsDir: string | null;
-  projectAgentsDirExists: boolean;
-}
+type FileCacheEntry<TValue> = {
+  stamp: string;
+  value: TValue;
+};
 
 type ResolvedPermissions = {
   /**
@@ -135,223 +76,47 @@ type ResolvedPermissions = {
   composedRules: Ruleset;
 };
 
-type FileCacheEntry<TValue> = {
-  stamp: string;
-  value: TValue;
-};
-
-function getFileStamp(path: string): string {
-  try {
-    return String(statSync(path).mtimeMs);
-  } catch {
-    return "missing";
-  }
+export interface PermissionManagerOptions extends PolicyLoaderOptions {
+  policyLoader?: PolicyLoader;
 }
 
 export class PermissionManager {
-  private readonly globalConfigPath: string;
-  private readonly agentsDir: string;
-  private readonly projectGlobalConfigPath: string | null;
-  private readonly projectAgentsDir: string | null;
-  private readonly globalMcpConfigPath: string;
-  private readonly configuredMcpServerNamesOverride: readonly string[] | null;
-  private globalConfigCache: FileCacheEntry<ScopeConfig> | null = null;
-  private projectGlobalConfigCache: FileCacheEntry<ScopeConfig> | null = null;
-  private readonly agentConfigCache = new Map<
-    string,
-    FileCacheEntry<ScopeConfig>
-  >();
-  private readonly projectAgentConfigCache = new Map<
-    string,
-    FileCacheEntry<ScopeConfig>
-  >();
+  private readonly loader: PolicyLoader;
   private readonly resolvedPermissionsCache = new Map<
     string,
     FileCacheEntry<ResolvedPermissions>
   >();
-  private configuredMcpServerNamesCache: FileCacheEntry<
-    readonly string[]
-  > | null = null;
-  private accumulatedConfigIssues: string[] = [];
-
-  constructor(
-    options: {
-      globalConfigPath?: string;
-      agentsDir?: string;
-      projectGlobalConfigPath?: string;
-      projectAgentsDir?: string;
-      globalMcpConfigPath?: string;
-      mcpServerNames?: readonly string[];
-    } = {},
-  ) {
-    this.globalConfigPath =
-      options.globalConfigPath || defaultGlobalConfigPath();
-    this.agentsDir = options.agentsDir || defaultAgentsDir();
-    this.projectGlobalConfigPath = options.projectGlobalConfigPath || null;
-    this.projectAgentsDir = options.projectAgentsDir || null;
-    this.globalMcpConfigPath =
-      options.globalMcpConfigPath || defaultGlobalMcpConfigPath();
-    this.configuredMcpServerNamesOverride = options.mcpServerNames
-      ? [
-          ...new Set(
-            options.mcpServerNames
-              .map((name) => name.trim())
-              .filter((name) => name.length > 0),
-          ),
-        ]
-      : null;
-  }
 
-  private accumulateConfigIssues(issues: string[]): void {
-    for (const issue of issues) {
-      if (!this.accumulatedConfigIssues.includes(issue)) {
-        this.accumulatedConfigIssues.push(issue);
-      }
-    }
+  constructor(options: PermissionManagerOptions = {}) {
+    this.loader = options.policyLoader ?? new FilePolicyLoader(options);
   }
 
   getConfigIssues(agentName?: string): string[] {
     // Trigger a load/resolve to ensure issues are collected.
     this.resolvePermissions(agentName);
-    return [...this.accumulatedConfigIssues];
-  }
-
-  private loadGlobalConfig(): ScopeConfig {
-    const stamp = getFileStamp(this.globalConfigPath);
-    if (this.globalConfigCache?.stamp === stamp) {
-      return this.globalConfigCache.value;
-    }
-
-    const { config, issues } = loadUnifiedConfig(this.globalConfigPath);
-    this.accumulateConfigIssues(issues);
-
-    const value: ScopeConfig = {
-      permission: config.permission,
-    };
-
-    this.globalConfigCache = { stamp, value };
-    return value;
-  }
-
-  private loadProjectGlobalConfig(): ScopeConfig {
-    if (!this.projectGlobalConfigPath) {
-      return {};
-    }
-
-    const stamp = getFileStamp(this.projectGlobalConfigPath);
-    if (this.projectGlobalConfigCache?.stamp === stamp) {
-      return this.projectGlobalConfigCache.value;
-    }
-
-    const { config, issues } = loadUnifiedConfig(this.projectGlobalConfigPath);
-    this.accumulateConfigIssues(issues);
-
-    const value: ScopeConfig = {
-      permission: config.permission,
-    };
-
-    this.projectGlobalConfigCache = { stamp, value };
-    return value;
-  }
-
-  private loadScopeConfigFrom(
-    dir: string | null,
-    cache: Map<string, FileCacheEntry<ScopeConfig>>,
-    agentName?: string,
-  ): ScopeConfig {
-    if (!dir || !agentName) {
-      return {};
-    }
-
-    const filePath = join(dir, `${agentName}.md`);
-    const stamp = getFileStamp(filePath);
-    const cached = cache.get(agentName);
-    if (cached?.stamp === stamp) {
-      return cached.value;
-    }
-
-    let value: ScopeConfig;
-    try {
-      const markdown = readFileSync(filePath, "utf-8");
-      const frontmatter = extractFrontmatter(markdown);
-      if (!frontmatter) {
-        value = {};
-      } else {
-        const parsed = parseSimpleYamlMap(frontmatter);
-        // Re-use the config-loader normalizer so the flat permission shape
-        // is validated the same way as on-disk config files.
-        const { config, issues } = normalizeUnifiedConfig(parsed);
-        this.accumulateConfigIssues(issues);
-        value = { permission: config.permission };
-      }
-    } catch {
-      value = {};
-    }
-
-    cache.set(agentName, { stamp, value });
-    return value;
-  }
-
-  private loadScopeConfig(agentName?: string): ScopeConfig {
-    return this.loadScopeConfigFrom(
-      this.agentsDir,
-      this.agentConfigCache,
-      agentName,
-    );
-  }
-
-  private loadProjectScopeConfig(agentName?: string): ScopeConfig {
-    return this.loadScopeConfigFrom(
-      this.projectAgentsDir,
-      this.projectAgentConfigCache,
-      agentName,
-    );
+    return [...this.loader.getConfigIssues()];
   }
 
   getResolvedPolicyPaths(): ResolvedPolicyPaths {
-    return {
-      globalConfigPath: this.globalConfigPath,
-      globalConfigExists: existsSync(this.globalConfigPath),
-      projectConfigPath: this.projectGlobalConfigPath,
-      projectConfigExists: this.projectGlobalConfigPath
-        ? existsSync(this.projectGlobalConfigPath)
-        : false,
-      agentsDir: this.agentsDir,
-      agentsDirExists: existsSync(this.agentsDir),
-      projectAgentsDir: this.projectAgentsDir,
-      projectAgentsDirExists: this.projectAgentsDir
-        ? existsSync(this.projectAgentsDir)
-        : false,
-    };
+    return this.loader.getResolvedPolicyPaths();
   }
 
   getPolicyCacheStamp(agentName?: string): string {
-    const agentStamp = agentName
-      ? getFileStamp(join(this.agentsDir, `${agentName}.md`))
-      : "missing";
-    const projectStamp = this.projectGlobalConfigPath
-      ? getFileStamp(this.projectGlobalConfigPath)
-      : "none";
-    const projectAgentStamp =
-      this.projectAgentsDir && agentName
-        ? getFileStamp(join(this.projectAgentsDir, `${agentName}.md`))
-        : "none";
-
-    return `${getFileStamp(this.globalConfigPath)}|${projectStamp}|${agentStamp}|${projectAgentStamp}`;
+    return this.loader.getCacheStamp(agentName);
   }
 
   private resolvePermissions(agentName?: string): ResolvedPermissions {
     const cacheKey = agentName || "__global__";
-    const stamp = this.getPolicyCacheStamp(agentName);
+    const stamp = this.loader.getCacheStamp(agentName);
     const cached = this.resolvedPermissionsCache.get(cacheKey);
     if (cached?.stamp === stamp) {
       return cached.value;
     }
 
-    const globalConfig = this.loadGlobalConfig();
-    const projectConfig = this.loadProjectGlobalConfig();
-    const agentConfig = this.loadScopeConfig(agentName);
-    const projectAgentConfig = this.loadProjectScopeConfig(agentName);
+    const globalConfig = this.loader.loadGlobalConfig();
+    const projectConfig = this.loader.loadProjectConfig();
+    const agentConfig = this.loader.loadAgentConfig(agentName);
+    const projectAgentConfig = this.loader.loadProjectAgentConfig(agentName);
 
     // Merge permission objects across scopes (lowest → highest precedence).
     // Build a parallel origin map that tracks which scope contributed each
@@ -442,24 +207,6 @@ export class PermissionManager {
     return value;
   }
 
-  private getConfiguredMcpServerNames(): readonly string[] {
-    if (this.configuredMcpServerNamesOverride) {
-      return this.configuredMcpServerNamesOverride;
-    }
-
-    const paths = [this.globalMcpConfigPath];
-    const stamp = paths
-      .map((path) => `${path}:${getFileStamp(path)}`)
-      .join("|");
-    if (this.configuredMcpServerNamesCache?.stamp === stamp) {
-      return this.configuredMcpServerNamesCache.value;
-    }
-
-    const value = getConfiguredMcpServerNamesFromPaths(paths);
-    this.configuredMcpServerNamesCache = { stamp, value };
-    return value;
-  }
-
   /**
    * Return the composed config-layer rules for the given agent scope.
    * Used by the `/permission-system show` command to display effective rules
@@ -518,7 +265,7 @@ export class PermissionManager {
     const { surface, values, resultExtras } = normalizeInput(
       normalizedToolName,
       input,
-      this.getConfiguredMcpServerNames(),
+      this.loader.getConfiguredMcpServerNames(),
     );
 
     const { rule, value } = evaluateFirst(surface, values, fullRules);
@@ -579,4 +326,6 @@ function deriveSource(
 
 // Keep isPermissionState and toRecord available for convenience — they are
 // used directly in some handler files that import from permission-manager.
-export { isPermissionState, toRecord };
+export { isPermissionState, toRecord } from "./common";
+// Re-export types that external modules import from this file.
+export type { PolicyLoader, ResolvedPolicyPaths } from "./policy-loader";