@hank-warren/pi-auto-permissions 0.16.0 → 0.16.2

package/session-overrides.ts

@@ -0,0 +1,264 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AutoPermissionsConfig } from "./config.js";
+import type { PromptChoiceClassification } from "./evaluation-log.js";
+import type { PermissionOverride } from "./override-evidence.js";
+import type { ReviewScope } from "./review-scope.js";
+import type { DenialSummary } from "./settings-menu.js";
+import {
+  grantStandingApproval,
+  readStandingApprovals,
+  STANDING_APPROVAL_LIMIT,
+  standingApprovalsToPermissionOverrides,
+} from "./standing-overrides.js";
+
+/**
+ * Overrides persist as custom session entries the way the loop budget does,
+ * so a resumed session keeps the user's prompt decisions instead of
+ * forgetting every allow and standing block constraint.
+ */
+const OVERRIDES_ENTRY_TYPE = "auto-permissions-overrides";
+
+export interface SessionOverrides {
+  /** Commands a `request_override` grant cleared for the rest of this session. */
+  readonly allowedConventionCommands: ReadonlySet<string>;
+  /** The override records, live, for merging into reviewer evidence. */
+  list(): readonly PermissionOverride[];
+  allowConvention(command: string): void;
+  activateOverrideTool(): void;
+  reconcileOverrideTool(): void;
+  persist(): void;
+  restore(branch: readonly unknown[]): void;
+  removeStanding(matches: (override: PermissionOverride) => boolean): void;
+  loadStanding(config: AutoPermissionsConfig, ctx: ExtensionContext): void;
+  recordPromptDecision(
+    scope: ReviewScope,
+    classification: PromptChoiceClassification,
+    detail: string,
+    anchorKey: string | undefined,
+  ): void;
+  allowRetry(denial: DenialSummary, anchorKey: string | undefined): void;
+  resetForSession(): void;
+}
+
+/**
+ * The user's own permission decisions for this session: the exception grants
+ * that let a convention-blocked command run, and the override records the
+ * guardian is shown as user-source evidence.
+ *
+ * One owner, because the pieces are one fact seen three ways — the in-memory
+ * record, the session entry that survives a resume, and (for standing
+ * approvals) the cross-project ledger.
+ */
+export function createSessionOverrides(pi: ExtensionAPI): SessionOverrides {
+  const allowedConventionCommands = new Set<string>();
+  const permissionOverrides: PermissionOverride[] = [];
+  let overrideSeq = 0;
+  let standingApprovalCapNotified = false;
+  let overrideToolActivated = false;
+
+  function reconcileOverrideTool(): void {
+    if (typeof pi.getActiveTools !== "function" || typeof pi.setActiveTools !== "function") return;
+    const active = pi.getActiveTools();
+    const present = active.includes("request_override");
+    if (overrideToolActivated === present) return;
+    pi.setActiveTools(
+      overrideToolActivated
+        ? [...active, "request_override"]
+        : active.filter((name) => name !== "request_override"),
+    );
+  }
+
+  function persist(): void {
+    try {
+      pi.appendEntry(OVERRIDES_ENTRY_TYPE, {
+        seq: overrideSeq,
+        overrides: permissionOverrides
+          .filter((override) => !override.standing)
+          .map((override) => ({ ...override })),
+      });
+    } catch {
+      // Persistence is best-effort; the in-memory records still apply now.
+    }
+  }
+
+  /** Fail-open like the loop budget: unreadable state means no overrides. */
+  function restoreOverrides(entries: readonly unknown[]): void {
+    permissionOverrides.length = 0;
+    overrideSeq = 0;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+      const entry = entries[index] as { type?: string; customType?: string; data?: unknown } | undefined;
+      if (entry?.type !== "custom" || entry.customType !== OVERRIDES_ENTRY_TYPE) continue;
+      const data = entry.data as { seq?: unknown; overrides?: unknown } | undefined;
+      if (Array.isArray(data?.overrides)) {
+        for (const raw of data.overrides) {
+          if (!raw || typeof raw !== "object") continue;
+          const candidate = raw as PermissionOverride;
+          if (
+            typeof candidate.seq !== "number"
+            || typeof candidate.gateLabel !== "string"
+            || typeof candidate.command !== "string"
+            || typeof candidate.reviewerReason !== "string"
+            || !["allow", "allow_unnecessary", "allow_appropriate", "block"].includes(candidate.choice)
+          ) {
+            continue;
+          }
+          permissionOverrides.push({
+            seq: candidate.seq,
+            ...(typeof candidate.anchorKey === "string" ? { anchorKey: candidate.anchorKey } : {}),
+            gateLabel: candidate.gateLabel,
+            command: candidate.command,
+            reviewerReason: candidate.reviewerReason,
+            choice: candidate.choice,
+          });
+        }
+      }
+      if (typeof data?.seq === "number" && Number.isSafeInteger(data.seq) && data.seq >= 0) {
+        overrideSeq = data.seq;
+      }
+      return;
+    }
+  }
+
+  /** Drop matching ledger-backed evidence in place; the array is shared by reference. */
+  function removeStanding(matches: (override: PermissionOverride) => boolean): void {
+    const kept = permissionOverrides.filter((override) => !override.standing || !matches(override));
+    permissionOverrides.splice(0, permissionOverrides.length, ...kept);
+  }
+
+  return {
+    allowedConventionCommands,
+    list: () => permissionOverrides,
+    allowConvention(command: string): void {
+      allowedConventionCommands.add(command);
+    },
+    reconcileOverrideTool,
+    activateOverrideTool(): void {
+      overrideToolActivated = true;
+      reconcileOverrideTool();
+    },
+    persist,
+    removeStanding,
+
+    restore(branch: readonly unknown[]): void {
+      // Restore prompt decisions from the branch: a resumed session keeps its
+      // allows and standing block constraints (parity with the loop budget).
+      restoreOverrides(branch);
+      for (const entry of branch as Array<{
+        type?: string;
+        message?: { role?: string; toolName?: string; details?: unknown };
+      }>) {
+        if (entry.type !== "message" || entry.message?.role !== "toolResult") continue;
+        if (entry.message.toolName !== "request_override") continue;
+        const details = entry.message.details as { success?: boolean; command?: string } | undefined;
+        if (details?.success && details.command) allowedConventionCommands.add(details.command);
+      }
+    },
+
+    /** Replace only ledger-backed evidence; session prompt decisions stay put. */
+    loadStanding(config: AutoPermissionsConfig, ctx: ExtensionContext): void {
+      removeStanding(() => true);
+      if (!config.standingApprovals.enabled) return;
+      try {
+        const records = readStandingApprovals(config.standingApprovals.path);
+        permissionOverrides.push(...standingApprovalsToPermissionOverrides(records));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Could not load standing Auto Permissions approvals: ${message}`, "warning");
+      }
+    },
+
+    /**
+     * Feed the user's decision back to the guardian as session-scoped
+     * user-source evidence. Only the caller knows whether the prompt came from
+     * a guardian judgment, which is the one case this may be called for.
+     */
+    recordPromptDecision(
+      scope: ReviewScope,
+      classification: PromptChoiceClassification,
+      detail: string,
+      anchorKey: string | undefined,
+    ): void {
+      const { ctx, config, gate, command } = scope;
+      const overrideChoice = classification.userChoice ?? (classification.allowsExecution ? "allow" as const : undefined);
+      if (!overrideChoice) return;
+      let recordedStanding = false;
+      if (classification.standingApproval && config.standingApprovals.enabled) {
+        try {
+          const { evicted, override } = grantStandingApproval(
+            config.standingApprovals.path,
+            {
+              gate: { label: gate.label, group: gate.group },
+              command,
+              project: ctx.cwd,
+              reason: detail,
+            },
+            overrideSeq++,
+            anchorKey,
+          );
+          removeStanding(
+            (existing) => existing.standing?.gateGroup === gate.group && existing.command === command,
+          );
+          permissionOverrides.push(override);
+          recordedStanding = true;
+          if (evicted > 0 && !standingApprovalCapNotified) {
+            standingApprovalCapNotified = true;
+            ctx.ui.notify(
+              `Standing approvals reached ${STANDING_APPROVAL_LIMIT} entries; the oldest approval was removed.`,
+              "warning",
+            );
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Could not save standing approval: ${message}`, "warning");
+        }
+      }
+      if (!recordedStanding) {
+        permissionOverrides.push({
+          seq: overrideSeq++,
+          anchorKey,
+          gateLabel: gate.label,
+          command,
+          reviewerReason: detail,
+          choice: overrideChoice,
+        });
+      }
+      persist();
+    },
+
+    /**
+     * "Allow on retry": the existing override machinery, driven from the
+     * denial ledger. An exact-command allow override (which already
+     * generalizes correctly and survives via evidence re-injection and the
+     * session entry), plus a visible injected message telling the agent it
+     * may retry. No new authorization pathway.
+     */
+    allowRetry(denial: DenialSummary, anchorKey: string | undefined): void {
+      permissionOverrides.push({
+        seq: overrideSeq++,
+        anchorKey,
+        gateLabel: denial.gateLabel,
+        command: denial.command,
+        reviewerReason: denial.reason,
+        choice: "allow",
+      });
+      persist();
+      try {
+        // The same channel a prompt note uses. This is a real user decision
+        // made in the menu, so a user message is honest provenance — and it
+        // gives the agent a turn to actually retry.
+        pi.sendUserMessage(
+          `Auto Permissions: I reviewed the denied command in /auto-permissions and allowed it on retry:\n\n  ${denial.command}\n\nYou may run this exact command again; a session override now authorizes it.`,
+        );
+      } catch {
+        // The override itself is already in force; the nudge is best-effort.
+      }
+    },
+
+    resetForSession(): void {
+      overrideToolActivated = false;
+      reconcileOverrideTool();
+      standingApprovalCapNotified = false;
+      allowedConventionCommands.clear();
+    },
+  };
+}

package/settings-command.ts

@@ -0,0 +1,261 @@
+import {
+  getSelectListTheme,
+  getSettingsListTheme,
+  type ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+import { SettingsList } from "@earendil-works/pi-tui";
+import {
+  autoPermissionsConfigPath,
+  loadAutoPermissionsConfig,
+  type AutoPermissionsConfig,
+} from "./config.js";
+import { patchAutoPermissionsConfig } from "./config-writer.js";
+import { readRecentDenials } from "./denial-log.js";
+import type { GuardianReviewer } from "./guardian-reviewer.js";
+import type { SessionOverrides } from "./session-overrides.js";
+import {
+  applySettingChange,
+  buildSettingItems,
+  createDenialsSubmenu,
+  createModelSubmenu,
+  createStandingApprovalsSubmenu,
+  createTimeoutSubmenu,
+  type DenialsSubmenuHost,
+  type DenialSummary,
+  type StandingApprovalsSubmenuHost,
+  type StandingApprovalSummary,
+  type MenuModel,
+  type ReviewerSettings,
+  type SettingChange,
+  type SubmenuHost,
+} from "./settings-menu.js";
+import { readStandingApprovals, revokeStandingApproval } from "./standing-overrides.js";
+
+/**
+ * What `/auto-permissions setup` says on the user's behalf. Named after the
+ * bundled skill rather than a `/skill:` invocation, because skill commands can
+ * be turned off in settings while the skill itself stays discoverable.
+ */
+const SETUP_SKILL_HANDOFF_MESSAGE =
+  "Use the auto-permissions-setup skill to set up my Auto Permissions policy.";
+
+export function registerSettingsCommand(
+  pi: ExtensionAPI,
+  { overrides, reviewer }: { overrides: SessionOverrides; reviewer: GuardianReviewer },
+): void {
+  /**
+   * `/auto-permissions`: edit the reviewer model, thinking level, timeout and
+   * the enabled flag without hand-editing config.json.
+   *
+   * There is no live-apply step: every tool call re-reads the config through
+   * currentConfig(), so a saved edit is in force immediately -- in this session
+   * and in every other one. reviewerFingerprint() covers provider, model and
+   * reasoning effort, so the cached reviewer lineage self-invalidates too.
+   *
+   * `/auto-permissions setup` is a pointer, not a wizard: it hands the job to
+   * the bundled auto-permissions-setup skill. A conversational setup can ask
+   * about an ambiguous host, weigh history-wide friction and back out of a bad
+   * suggestion; a fixed accept-or-discard draft could do none of that, so the
+   * two paths were never equal and keeping both only split the maintenance.
+   */
+  pi.registerCommand("auto-permissions", {
+    description: "Configure Auto Permissions (\"setup\" hands off to the auto-permissions-setup skill)",
+    handler: async (args, ctx) => {
+      if ((args ?? "").trim() === "setup") {
+        // Dispatch rather than instruct: the point of the pointer is that the
+        // interview starts on this keystroke.
+        pi.sendUserMessage(SETUP_SKILL_HANDOFF_MESSAGE);
+        return;
+      }
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/auto-permissions requires interactive TUI mode", "warning");
+        return;
+      }
+
+      const path = autoPermissionsConfigPath();
+      let settings: ReviewerSettings;
+      let denialLog: AutoPermissionsConfig["denialLog"];
+      let standingApprovalsConfig: AutoPermissionsConfig["standingApprovals"];
+      try {
+        const config = loadAutoPermissionsConfig(path);
+        settings = {
+          enabled: config.enabled,
+          reviewer: config.reviewer,
+          systemPromptSource: config.systemPromptSource,
+        };
+        denialLog = config.denialLog;
+        standingApprovalsConfig = config.standingApprovals;
+      } catch (error) {
+        // Editing a file we cannot validate is the one way this writer could
+        // quietly make things worse, so refuse rather than open.
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Auto Permissions config error: ${message} \u2014 fix ${path} first`, "warning");
+        return;
+      }
+
+      /** Persist one accepted edit, then report anything the save surfaced. */
+      const commit = (change: SettingChange): void => {
+        if (change.kind === "ignored") return;
+        if (change.kind === "error") {
+          ctx.ui.notify(change.message, "warning");
+          return;
+        }
+        const previous = settings;
+        settings = change.settings;
+        try {
+          patchAutoPermissionsConfig(path, { enabled: settings.enabled, reviewer: settings.reviewer });
+        } catch (error) {
+          settings = previous;
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Could not save Auto Permissions settings: ${message}`, "warning");
+          return;
+        }
+        if (change.kind === "warn") ctx.ui.notify(change.message, "warning");
+        // A breakage elsewhere in the file would otherwise surface at the next
+        // bash call, looking like this edit caused it.
+        try {
+          loadAutoPermissionsConfig(path);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Auto Permissions config error: ${message}`, "warning");
+        }
+      };
+
+      const reviewerModel = (): MenuModel | undefined => {
+        if (!settings.reviewer) return undefined;
+        return ctx.modelRegistry.find(settings.reviewer.provider, settings.reviewer.model) as MenuModel | undefined;
+      };
+
+      const recentDenials = (): DenialSummary[] => {
+        if (!denialLog.enabled) return [];
+        try {
+          return readRecentDenials(denialLog.path, 20).map((record) => ({
+            id: record.id,
+            ts: record.ts,
+            gateLabel: record.gate.label,
+            command: record.command,
+            verdict: record.verdict,
+            reason: record.reason,
+          }));
+        } catch {
+          return [];
+        }
+      };
+
+      const standingApprovalSummaries = (): StandingApprovalSummary[] => {
+        if (!standingApprovalsConfig.enabled) return [];
+        try {
+          return readStandingApprovals(standingApprovalsConfig.path).map((record, index) => ({
+            id: `${index}:${record.ts}:${record.gate.label}`,
+            record,
+          }));
+        } catch {
+          return [];
+        }
+      };
+
+      const revokeApproval = (approval: StandingApprovalSummary): void => {
+        try {
+          if (!revokeStandingApproval(standingApprovalsConfig.path, approval.record)) {
+            ctx.ui.notify("That standing approval is no longer in the ledger.", "warning");
+            return;
+          }
+          const config = loadAutoPermissionsConfig(path);
+          overrides.loadStanding(config, ctx);
+          reviewer.discardLineage();
+          ctx.ui.notify("Standing approval revoked.", "info");
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Could not revoke standing approval: ${message}`, "warning");
+        }
+      };
+
+      /**
+       * Closes the settings dialog. Assigned when `ctx.ui.custom` builds the
+       * component, so it is only ever called from inside the dialog it closes.
+       */
+      let closeSettings: (() => void) | undefined;
+
+      /**
+       * "Allow on retry": the existing override machinery, driven from the
+       * denial ledger. An exact-command allow override (which already
+       * generalizes correctly and survives via evidence re-injection and the
+       * session entry), plus a visible injected message telling the agent it
+       * may retry. No new authorization pathway.
+       *
+       * The dialog is closed *before* the message is dispatched, and the order
+       * is load-bearing. The retry hits the same gate, so the approval prompt
+       * opens another `ctx.ui.custom` — stacked on a still-open settings
+       * dialog, that orphans this one: it stops rendering but keeps consuming
+       * editor input, and the composer never submits again. Observed live
+       * twice; the only escape was restarting pi.
+       */
+      const allowRetry = (denial: DenialSummary): void => {
+        closeSettings?.();
+        overrides.allowRetry(denial, reviewer.lastEvidenceKey);
+        ctx.ui.notify("Override added for the exact command; the agent may retry it.", "info");
+      };
+
+      await ctx.ui.custom<void>((tui, _theme, _keybindings, done) => {
+        closeSettings = () => done(undefined);
+        const host: SubmenuHost = {
+          getSettings: () => settings,
+          commit,
+          availableModels: () => ctx.modelRegistry.getAvailable() as MenuModel[],
+          requestRender: () => tui.requestRender(),
+          settingsTheme: getSettingsListTheme(),
+          selectTheme: getSelectListTheme(),
+        };
+        const denialsHost: DenialsSubmenuHost = {
+          recentDenials,
+          allowRetry,
+          settingsTheme: getSettingsListTheme(),
+          selectTheme: getSelectListTheme(),
+          requestRender: () => tui.requestRender(),
+        };
+        const standingHost: StandingApprovalsSubmenuHost = {
+          standingApprovals: standingApprovalSummaries,
+          revokeStandingApproval: revokeApproval,
+          settingsTheme: getSettingsListTheme(),
+          selectTheme: getSelectListTheme(),
+          requestRender: () => tui.requestRender(),
+        };
+        const list = new SettingsList(
+          buildSettingItems(
+            settings,
+            {
+              reviewerModel: createModelSubmenu(host),
+              timeout: createTimeoutSubmenu(host),
+              ...(denialLog.enabled ? { recentDenials: createDenialsSubmenu(denialsHost) } : {}),
+              ...(standingApprovalsConfig.enabled
+                ? { standingApprovals: createStandingApprovalsSubmenu(standingHost) }
+                : {}),
+            },
+            undefined,
+            denialLog.enabled ? recentDenials().length : undefined,
+            standingApprovalsConfig.enabled ? standingApprovalSummaries().length : undefined,
+          ),
+          10,
+          host.settingsTheme,
+          (id, value) => {
+            commit(applySettingChange(settings, id, value, reviewerModel()));
+            tui.requestRender();
+          },
+          () => done(undefined),
+          { enableSearch: true },
+        );
+        return {
+          invalidate(): void {
+            list.invalidate();
+          },
+          handleInput(data: string): void {
+            list.handleInput(data);
+          },
+          render(width: number): string[] {
+            return list.render(width);
+          },
+        };
+      });
+    },
+  });
+}

package/settings-menu.ts

@@ -29,11 +29,11 @@ import {
 import type { ReviewerBlock } from "./config-writer.js";
 import type { StandingApprovalRecord } from "./standing-overrides.js";
 
-export const ENABLED_ID = "enabled";
-export const REVIEWER_MODEL_ID = "reviewerModel";
-export const THINKING_LEVEL_ID = "reasoningEffort";
-export const TIMEOUT_ID = "timeoutMs";
-export const SYSTEM_PROMPT_ID = "systemPrompt";
+const ENABLED_ID = "enabled";
+const REVIEWER_MODEL_ID = "reviewerModel";
+const THINKING_LEVEL_ID = "reasoningEffort";
+const TIMEOUT_ID = "timeoutMs";
+const SYSTEM_PROMPT_ID = "systemPrompt";
 export const RECENT_DENIALS_ID = "recentDenials";
 export const STANDING_APPROVALS_ID = "standingApprovals";
 
@@ -41,7 +41,7 @@ export const ON = "on";
 export const OFF = "off";
 const TOGGLE_VALUES = [ON, OFF];
 
-export const UNSET_MODEL = "(unset)";
+const UNSET_MODEL = "(unset)";
 const UNAVAILABLE_SUFFIX = "(configured, unavailable)";
 const NO_REVIEWER_MESSAGE = "Select a reviewer model first";
 
@@ -66,13 +66,13 @@ export function modelKey(model: { provider: string; id: string }): string {
 }
 
 /** Inverse of {@link modelKey}; the provider itself never contains a slash. */
-export function parseModelKey(value: string): { provider: string; model: string } | undefined {
+function parseModelKey(value: string): { provider: string; model: string } | undefined {
   const slash = value.indexOf("/");
   if (slash <= 0 || slash === value.length - 1) return undefined;
   return { provider: value.slice(0, slash), model: value.slice(slash + 1) };
 }
 
-export function reviewerValue(settings: ReviewerSettings): string {
+function reviewerValue(settings: ReviewerSettings): string {
   return settings.reviewer ? modelKey({ provider: settings.reviewer.provider, id: settings.reviewer.model }) : UNSET_MODEL;
 }
 
@@ -80,11 +80,11 @@ export function toggleValue(enabled: boolean): string {
   return enabled ? ON : OFF;
 }
 
-export function thinkingValue(settings: ReviewerSettings): ReasoningEffort {
+function thinkingValue(settings: ReviewerSettings): ReasoningEffort {
   return settings.reviewer?.reasoningEffort ?? DEFAULT_REVIEWER_REASONING_EFFORT;
 }
 
-export function timeoutValue(settings: ReviewerSettings): number {
+function timeoutValue(settings: ReviewerSettings): number {
   return settings.reviewer?.timeoutMs ?? DEFAULT_REVIEWER_TIMEOUT_MS;
 }
 
@@ -117,7 +117,7 @@ export function formatTimeout(timeoutMs: number): string {
   return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
 }
 
-export type TimeoutParse = { timeoutMs: number } | { error: string };
+type TimeoutParse = { timeoutMs: number } | { error: string };
 
 /**
  * Parse a timeout the user typed. A bare number means seconds, because that is

package/standing-overrides.ts

@@ -13,7 +13,7 @@ import { dirname } from "node:path";
 import { pid } from "node:process";
 import { OVERRIDE_ANCHOR_START, type PermissionOverride } from "./override-evidence.js";
 
-export const STANDING_APPROVAL_SCOPE = "comparable" as const;
+const STANDING_APPROVAL_SCOPE = "comparable" as const;
 export const STANDING_APPROVAL_LIMIT = 200;
 const STALE_LEDGER_LOCK_MS = 60_000;
 
@@ -30,7 +30,7 @@ export interface StandingApprovalRecord {
   reason: string;
 }
 
-export interface StandingApprovalInput {
+interface StandingApprovalInput {
   gate: StandingApprovalRecord["gate"];
   command: string;
   project: string;
@@ -200,7 +200,7 @@ export function appendStandingApproval(
   });
 }
 
-export function standingApprovalToPermissionOverride(
+function standingApprovalToPermissionOverride(
   record: StandingApprovalRecord,
   seq: number,
   anchorKey: string = OVERRIDE_ANCHOR_START,

package/usage-log.ts

@@ -5,7 +5,7 @@ import { dirname } from "node:path";
 /** Rotate once the sidecar grows past this size; one previous generation is kept. */
 export const USAGE_LOG_ROTATE_BYTES = 16 * 1024 * 1024;
 
-export interface UsageLogTotals {
+interface UsageLogTotals {
   input: number;
   output: number;
   cacheRead: number;

package/widget-status.ts

@@ -12,9 +12,9 @@ export type ReviewDisplayState =
   | "ask_user"
   | "blocked";
 
-export type ReviewStatusTone = "muted" | "warning" | "success" | "accent" | "error";
+type ReviewStatusTone = "muted" | "warning" | "success" | "accent" | "error";
 
-export interface ReviewStatusFrame {
+interface ReviewStatusFrame {
   glyph: string;
   label: string;
   tone: ReviewStatusTone;