surgent 0.7.0-alpha.0

package/src/agent/types.ts

@@ -0,0 +1,28 @@
+export type AgentMode = "assistant" | "yolo" | "restricted";
+
+export interface AgentMeta {
+  description: string;
+  tools?: string[];
+  mcp_tools?: string[];
+  skills?: string[];
+  bash?: string[];
+  "files.read"?: string[];
+  "files.write"?: string[];
+  model?: string;
+  thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+}
+
+export interface Agent {
+  name: string;
+  meta: AgentMeta;
+  body: string;
+  filePath: string;
+}
+
+export interface SettingsSchema {
+  agent?: {
+    mode?: AgentMode;
+    meta?: Record<string, Partial<AgentMeta>>;
+  };
+  [key: string]: unknown;
+}

package/src/checkpoint/git.ts

@@ -0,0 +1,173 @@
+import { createHash } from "node:crypto";
+import { access, copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getPiPath } from "../utils.js";
+import type { Repo } from "./index.js";
+
+const CHECKPOINT_SOURCE_KEY = "surgent.checkpointSource";
+
+export async function getCheckpointRepo(pi: ExtensionAPI, cwd: string): Promise<Repo | undefined> {
+  const projectRootResult = await pi.exec("git", ["rev-parse", "--show-toplevel"], { cwd });
+  const projectRoot = projectRootResult.stdout.trim();
+  if (projectRootResult.code !== 0 || !projectRoot) return;
+
+  return {
+    projectRoot,
+    directory: getPiPath(
+      "checkpoints",
+      "global",
+      createHash("sha256").update(projectRoot).digest("hex"),
+    ),
+  };
+}
+
+export async function openCheckpointRepo(pi: ExtensionAPI, cwd: string): Promise<Repo | undefined> {
+  const repo = await getCheckpointRepo(pi, cwd);
+  if (!repo) return;
+
+  const sourceGitDirResult = await pi.exec(
+    "git",
+    ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+    { cwd: repo.projectRoot },
+  );
+  const sourceGitDir = sourceGitDirResult.stdout.trim();
+  if (sourceGitDirResult.code !== 0 || !sourceGitDir) return;
+  let needsInitialization = false;
+
+  try {
+    await access(join(repo.directory, ".git"));
+  } catch {
+    needsInitialization = true;
+  }
+
+  if (!needsInitialization) {
+    const configuredSourceResult = await runCheckpointGit(pi, repo, [
+      "config",
+      "--get",
+      CHECKPOINT_SOURCE_KEY,
+    ]);
+    if (
+      configuredSourceResult.code !== 0 ||
+      configuredSourceResult.stdout.trim() !== sourceGitDir
+    ) {
+      await rm(repo.directory, { recursive: true, force: true });
+      needsInitialization = true;
+    }
+  }
+
+  if (needsInitialization) {
+    const initialized = await initializeCheckpointRepo(pi, repo, sourceGitDir);
+    if (!initialized) return;
+  }
+
+  await syncCheckpointIgnore(pi, repo);
+  return repo;
+}
+
+export async function runCheckpointGit(pi: ExtensionAPI, repo: Repo, args: string[]) {
+  return pi.exec(
+    "git",
+    [`--git-dir=${join(repo.directory, ".git")}`, `--work-tree=${repo.projectRoot}`, ...args],
+    { cwd: repo.projectRoot },
+  );
+}
+
+export async function gcCheckpointRepo(pi: ExtensionAPI, repo: Repo) {
+  return runCheckpointGit(pi, repo, ["gc", "--auto"]);
+}
+
+async function initializeCheckpointRepo(
+  pi: ExtensionAPI,
+  repo: Repo,
+  sourceGitDir: string,
+): Promise<boolean> {
+  try {
+    await access(join(sourceGitDir, "objects"));
+    await mkdir(dirname(repo.directory), { recursive: true });
+  } catch {
+    return false;
+  }
+
+  const initializeResult = await pi.exec("git", ["init", repo.directory], {
+    cwd: repo.projectRoot,
+  });
+  if (initializeResult.code !== 0) return false;
+
+  for (const config of [
+    { key: "core.autocrlf", value: "false" },
+    { key: "core.longpaths", value: "true" },
+    { key: "core.symlinks", value: "true" },
+    { key: "core.fsmonitor", value: "false" },
+    { key: CHECKPOINT_SOURCE_KEY, value: sourceGitDir },
+  ]) {
+    const configResult = await runCheckpointGit(pi, repo, ["config", config.key, config.value]);
+    if (configResult.code !== 0) return false;
+  }
+
+  const checkpointGitDir = join(repo.directory, ".git");
+  try {
+    await mkdir(join(checkpointGitDir, "objects", "info"), { recursive: true });
+    await writeFile(
+      join(checkpointGitDir, "objects", "info", "alternates"),
+      `${join(sourceGitDir, "objects")}\n`,
+      "utf8",
+    );
+  } catch {
+    return false;
+  }
+
+  const sourceIndexResult = await pi.exec(
+    "git",
+    ["rev-parse", "--path-format=absolute", "--git-path", "index"],
+    { cwd: repo.projectRoot },
+  );
+  let hasSeededIndex = false;
+  if (sourceIndexResult.code === 0 && sourceIndexResult.stdout.trim()) {
+    try {
+      await copyFile(sourceIndexResult.stdout.trim(), join(checkpointGitDir, "index"));
+      const indexResult = await runCheckpointGit(pi, repo, ["ls-files", "-z"]);
+      hasSeededIndex = indexResult.code === 0;
+      if (!hasSeededIndex) {
+        await rm(join(checkpointGitDir, "index"), { force: true });
+      }
+    } catch {
+      await rm(join(checkpointGitDir, "index"), { force: true });
+    }
+  }
+
+  if (!hasSeededIndex) {
+    const sourceHeadResult = await pi.exec("git", ["rev-parse", "HEAD"], {
+      cwd: repo.projectRoot,
+    });
+    if (sourceHeadResult.code === 0 && sourceHeadResult.stdout.trim()) {
+      const seedResult = await runCheckpointGit(pi, repo, [
+        "read-tree",
+        sourceHeadResult.stdout.trim(),
+      ]);
+      if (seedResult.code !== 0) return false;
+    }
+  }
+
+  return true;
+}
+
+async function syncCheckpointIgnore(pi: ExtensionAPI, repo: Repo) {
+  const sourceIgnoreResult = await pi.exec(
+    "git",
+    ["rev-parse", "--path-format=absolute", "--git-path", "info/exclude"],
+    { cwd: repo.projectRoot },
+  );
+  if (sourceIgnoreResult.code !== 0 || !sourceIgnoreResult.stdout.trim()) return;
+
+  const checkpointIgnoreFile = join(repo.directory, ".git", "info", "exclude");
+  const sourceIgnoreFile = sourceIgnoreResult.stdout.trim();
+  const sourceIgnoreContents = await readFile(sourceIgnoreFile, "utf8").catch(() => undefined);
+  if (sourceIgnoreContents === undefined) {
+    await rm(checkpointIgnoreFile, { force: true });
+    return;
+  }
+
+  await mkdir(dirname(checkpointIgnoreFile), { recursive: true });
+  await writeFile(checkpointIgnoreFile, sourceIgnoreContents, "utf8");
+}

package/src/checkpoint/index.ts

@@ -0,0 +1,117 @@
+import { join } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { gcCheckpointRepo, openCheckpointRepo } from "./git.js";
+import { createSnapshot, retainSnapshot, restoreSnapshot } from "./snapshot.js";
+import {
+  BASE_CHECKPOINT_KEY,
+  readCheckpointStore,
+  shouldOfferRestore,
+  writeCheckpointStore,
+} from "./store.js";
+
+export interface Repo {
+  projectRoot: string;
+  directory: string;
+}
+
+export default function (pi: ExtensionAPI) {
+  const checkpoints = new Map<string, string>();
+  const pendingCheckpoints = new Map<string, { entryId: string; tree: string }>();
+  let repo: Repo | undefined;
+
+  async function saveCheckpoints(ctx: ExtensionContext) {
+    if (!repo) return;
+    await writeCheckpointStore(
+      join(repo.directory, "entries.json"),
+      ctx.sessionManager.getSessionId(),
+      checkpoints,
+    );
+  }
+
+  async function restoreCheckpoint(
+    ctx: ExtensionContext,
+    targetEntryId: string,
+    currentEntryId: string | null,
+  ): Promise<{ cancel: boolean } | void> {
+    if (!ctx.hasUI || !repo) return;
+
+    const decision = shouldOfferRestore(targetEntryId, currentEntryId, ctx, checkpoints);
+    if (!decision.shouldRestore || !decision.tree) return;
+
+    const options = ["Yes, restore code to that point", "No, keep current code"];
+    const choice = await ctx.ui.select("Restore code state?", options);
+    if (choice !== options[0]) return;
+
+    const restoreResult = await restoreSnapshot(pi, repo, decision.tree);
+    if (restoreResult.code !== 0) {
+      const reason = restoreResult.stderr.trim() || restoreResult.stdout.trim();
+      ctx.ui.notify(
+        reason
+          ? `Checkpoint restore failed: ${reason}`
+          : "Checkpoint restore failed due to git error.",
+        "error",
+      );
+      return { cancel: true };
+    }
+
+    ctx.ui.notify("Code restored to checkpoint", "info");
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    checkpoints.clear();
+    pendingCheckpoints.clear();
+    repo = await openCheckpointRepo(pi, ctx.cwd);
+    if (!repo) return;
+
+    const store = await readCheckpointStore(join(repo.directory, "entries.json"));
+    const sessionCheckpoints = store[ctx.sessionManager.getSessionId()] ?? {};
+    for (const [entryId, tree] of Object.entries(sessionCheckpoints)) {
+      checkpoints.set(entryId, tree);
+    }
+
+    if (checkpoints.has(BASE_CHECKPOINT_KEY)) return;
+    const tree = await createSnapshot(pi, repo);
+    if (tree && (await retainSnapshot(pi, repo, tree))) {
+      checkpoints.set(BASE_CHECKPOINT_KEY, tree);
+    }
+  });
+
+  pi.on("tool_call", async (event, ctx) => {
+    if ((event.toolName !== "write" && event.toolName !== "edit") || !repo) return;
+
+    const entryId = ctx.sessionManager.getLeafId();
+    if (!entryId) return;
+
+    const tree = await createSnapshot(pi, repo);
+    if (tree) pendingCheckpoints.set(event.toolCallId, { entryId, tree });
+  });
+
+  pi.on("tool_result", async (event) => {
+    const pendingCheckpoint = pendingCheckpoints.get(event.toolCallId);
+    if (!pendingCheckpoint) return;
+    pendingCheckpoints.delete(event.toolCallId);
+    if (event.isError || !repo) return;
+
+    const retained = await retainSnapshot(pi, repo, pendingCheckpoint.tree);
+    if (retained) checkpoints.set(pendingCheckpoint.entryId, pendingCheckpoint.tree);
+  });
+
+  pi.on("session_before_tree", (event, ctx) => {
+    const { targetId, oldLeafId } = event.preparation;
+    return restoreCheckpoint(ctx, targetId, oldLeafId);
+  });
+
+  pi.on("session_before_fork", (event, ctx) => {
+    return restoreCheckpoint(ctx, event.entryId, ctx.sessionManager.getLeafId());
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    await saveCheckpoints(ctx);
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    await saveCheckpoints(ctx);
+    if (!repo) return;
+    await gcCheckpointRepo(pi, repo);
+  });
+}

package/src/checkpoint/snapshot.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runCheckpointGit } from "./git.js";
+import { stageCheckpoint } from "./stage.js";
+import type { Repo } from "./index.js";
+
+export async function createSnapshot(pi: ExtensionAPI, repo: Repo): Promise<string | undefined> {
+  const staged = await stageCheckpoint(pi, repo);
+  if (!staged) return;
+
+  const treeResult = await runCheckpointGit(pi, repo, ["write-tree"]);
+  if (treeResult.code !== 0) return;
+
+  const tree = treeResult.stdout.trim();
+  return /^[0-9a-f]{40,64}$/i.test(tree) ? tree : undefined;
+}
+
+export async function retainSnapshot(pi: ExtensionAPI, repo: Repo, tree: string): Promise<boolean> {
+  const referenceResult = await runCheckpointGit(pi, repo, [
+    "update-ref",
+    `refs/surgent/checkpoints/${tree}`,
+    tree,
+  ]);
+  return referenceResult.code === 0;
+}
+
+export async function restoreSnapshot(pi: ExtensionAPI, repo: Repo, tree: string) {
+  return runCheckpointGit(pi, repo, ["read-tree", "--reset", "-u", tree]);
+}

package/src/checkpoint/stage.ts

@@ -0,0 +1,59 @@
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runCheckpointGit } from "./git.js";
+import type { Repo } from "./index.js";
+
+const UNTRACKED_FILE_LIMIT = 2 * 1024 * 1024;
+const STAGE_BATCH_SIZE = 100;
+
+export async function stageCheckpoint(pi: ExtensionAPI, repo: Repo): Promise<boolean> {
+  const changedResult = await runCheckpointGit(pi, repo, [
+    "diff-files",
+    "--name-only",
+    "-z",
+    "--",
+    ".",
+  ]);
+  if (changedResult.code !== 0) return false;
+
+  const untrackedResult = await runCheckpointGit(pi, repo, [
+    "ls-files",
+    "--full-name",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    "--",
+    ".",
+  ]);
+  if (untrackedResult.code !== 0) return false;
+
+  const filePaths = changedResult.stdout.split("\0").filter(Boolean);
+
+  await Promise.all(
+    untrackedResult.stdout.split("\0").map(async (filePath) => {
+      if (!filePath) return;
+      try {
+        const fileStatus = await lstat(join(repo.projectRoot, filePath));
+        if (fileStatus.isFile() && fileStatus.size > UNTRACKED_FILE_LIMIT) return;
+        filePaths.push(filePath);
+      } catch {
+        return; // file disappeared before staging.
+      }
+    }),
+  );
+
+  for (let start = 0; start < filePaths.length; start += STAGE_BATCH_SIZE) {
+    const stageResult = await runCheckpointGit(pi, repo, [
+      "add",
+      "--all",
+      "--",
+      ...filePaths
+        .slice(start, start + STAGE_BATCH_SIZE)
+        .map((filePath) => `:(top,literal)${filePath}`),
+    ]);
+    if (stageResult.code !== 0) return false;
+  }
+
+  return true;
+}

package/src/checkpoint/store.ts

@@ -0,0 +1,108 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isUuidv7, readJson } from "../utils.js";
+
+export const BASE_CHECKPOINT_KEY = "__base__";
+
+export async function readCheckpointStore(
+  filePath: string,
+): Promise<Record<string, Record<string, string>>> {
+  const data = await readJson<unknown>(filePath, {});
+  if (!data || typeof data !== "object" || Array.isArray(data)) return {};
+
+  const store: Record<string, Record<string, string>> = {};
+  for (const [sessionId, checkpoints] of Object.entries(data)) {
+    if (!checkpoints || typeof checkpoints !== "object" || Array.isArray(checkpoints)) continue;
+
+    const sessionCheckpoints: Record<string, string> = {};
+    for (const [entryId, tree] of Object.entries(checkpoints)) {
+      if (typeof tree !== "string") continue;
+      const checkpointTree = tree.trim();
+      if (!/^[0-9a-f]{40,64}$/i.test(checkpointTree)) continue;
+      sessionCheckpoints[entryId] = checkpointTree;
+    }
+    store[sessionId] = sessionCheckpoints;
+  }
+
+  return store;
+}
+
+export async function writeCheckpointStore(
+  filePath: string,
+  sessionId: string,
+  checkpoints: Map<string, string>,
+) {
+  const store = await readCheckpointStore(filePath);
+  if (checkpoints.size === 0) {
+    delete store[sessionId];
+  } else {
+    store[sessionId] = Object.fromEntries(checkpoints);
+  }
+
+  await persistCheckpointStore(filePath, store);
+}
+
+export async function pruneCheckpointStore(
+  filePath: string,
+  sessionIds: Set<string>,
+): Promise<string[]> {
+  const store = await readCheckpointStore(filePath);
+  const removedTrees = new Set<string>();
+  let hasChanges = false;
+
+  for (const [sessionId, checkpoints] of Object.entries(store)) {
+    if (!isUuidv7(sessionId) || sessionIds.has(sessionId)) continue;
+    for (const tree of Object.values(checkpoints)) {
+      removedTrees.add(tree);
+    }
+    delete store[sessionId];
+    hasChanges = true;
+  }
+
+  if (!hasChanges) return [];
+  await persistCheckpointStore(filePath, store);
+
+  const activeTrees = new Set(
+    Object.values(store).flatMap((checkpoints) => Object.values(checkpoints)),
+  );
+  return [...removedTrees].filter((tree) => !activeTrees.has(tree));
+}
+
+async function persistCheckpointStore(
+  filePath: string,
+  store: Record<string, Record<string, string>>,
+) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(store, null, 2) + "\n", "utf8");
+}
+
+export function findCheckpoint(
+  entryId: string | null,
+  ctx: ExtensionContext,
+  checkpoints: Map<string, string>,
+): string | undefined {
+  let currentEntryId = entryId;
+  while (currentEntryId) {
+    const tree = checkpoints.get(currentEntryId);
+    if (tree) return tree;
+    currentEntryId = ctx.sessionManager.getEntry(currentEntryId)?.parentId ?? null;
+  }
+
+  return checkpoints.get(BASE_CHECKPOINT_KEY);
+}
+
+export function shouldOfferRestore(
+  targetEntryId: string,
+  currentEntryId: string | null,
+  ctx: ExtensionContext,
+  checkpoints: Map<string, string>,
+): { shouldRestore: boolean; tree?: string } {
+  const targetTree = findCheckpoint(targetEntryId, ctx, checkpoints);
+  if (!targetTree) return { shouldRestore: false };
+
+  const currentTree = findCheckpoint(currentEntryId, ctx, checkpoints);
+  if (currentTree === targetTree) return { shouldRestore: false };
+
+  return { shouldRestore: true, tree: targetTree };
+}

package/src/cleanup/checkpoint.ts

@@ -0,0 +1,31 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getCheckpointRepo, runCheckpointGit } from "../checkpoint/git.js";
+import { pruneCheckpointStore } from "../checkpoint/store.js";
+
+export async function cleanupCheckpoints(
+  pi: ExtensionAPI,
+  cwd: string,
+  sessionIds: Set<string>,
+) {
+  const repo = await getCheckpointRepo(pi, cwd);
+  if (!repo) return;
+
+  const trees = await pruneCheckpointStore(join(repo.directory, "entries.json"), sessionIds);
+  if (trees.length === 0) return;
+
+  try {
+    await access(join(repo.directory, ".git"));
+  } catch {
+    return;
+  }
+
+  for (const tree of trees) {
+    await runCheckpointGit(pi, repo, [
+      "update-ref",
+      "-d",
+      `refs/surgent/checkpoints/${tree}`,
+    ]);
+  }
+}

package/src/cleanup/helpers.ts

@@ -0,0 +1,24 @@
+import { isUuidv7, readJson, writeJson } from "../utils.js";
+
+export function pruneSessionMap(
+  data: { [sessionId: string]: unknown },
+  sessionIds: Set<string>,
+): boolean {
+  let hasChanges = false;
+  for (const sessionId of Object.keys(data)) {
+    if (!isUuidv7(sessionId) || sessionIds.has(sessionId)) {
+      continue;
+    }
+    delete data[sessionId];
+    hasChanges = true;
+  }
+  return hasChanges;
+}
+
+export async function pruneSessionFile(filePath: string, sessionIds: Set<string>) {
+  const data = await readJson<{ [sessionId: string]: unknown }>(filePath, {});
+  const hasChanges = pruneSessionMap(data, sessionIds);
+  if (hasChanges) {
+    await writeJson(filePath, data);
+  }
+}

package/src/cleanup/index.ts

@@ -0,0 +1,21 @@
+import { SessionManager, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { cleanupCheckpoints } from "./checkpoint.js";
+import { cleanupPermissions } from "./permission.js";
+import { cleanupSubsessions } from "./subsession.js";
+import { getPiPath } from "../utils.js";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    const [sessions, subsessions] = await Promise.all([
+      SessionManager.list(ctx.cwd),
+      SessionManager.list(ctx.cwd, getPiPath("subsessionsDir", ctx.cwd)),
+    ]);
+    const sessionIds = new Set(sessions.map((session) => session.id));
+    const allSessionIds = new Set([...sessionIds, ...subsessions.map((session) => session.id)]);
+    sessionIds.add(ctx.sessionManager.getSessionId());
+
+    cleanupCheckpoints(pi, ctx.cwd, allSessionIds).catch(() => undefined);
+    cleanupPermissions(ctx.cwd, allSessionIds).catch(() => undefined);
+    cleanupSubsessions(ctx.cwd, sessionIds).catch(() => undefined);
+  });
+}

package/src/cleanup/permission.ts

@@ -0,0 +1,74 @@
+import { matchesPattern } from "../permission/precedence.js";
+import { readRules, writeRules } from "../permission/storage.js";
+import type { FileAccess, PermissionRule } from "../permission/types.js";
+import { pruneSessionMap } from "./helpers.js";
+
+function pruneRules<T extends FileAccess | boolean>(
+  rules: Record<string, T>,
+  bash = false,
+): Record<string, T> {
+  const patterns = Object.keys(rules);
+  const result: Record<string, T> = {};
+
+  for (const pattern of patterns) {
+    const value = rules[pattern]!;
+    const isSubsumed = patterns.some((other) => {
+      if (other === pattern) return false;
+      if (rules[other] !== value) return false;
+      // other subsumes pattern if other matches pattern but pattern does not match other
+      return matchesPattern(pattern, other, bash) && !matchesPattern(other, pattern, bash);
+    });
+    if (!isSubsumed) {
+      result[pattern] = value;
+    }
+  }
+
+  return result;
+}
+
+function pruneSchema(schema: PermissionRule): PermissionRule {
+  const result: PermissionRule = {};
+  if (schema.file) {
+    const pruned = pruneRules(schema.file);
+    if (Object.keys(pruned).length > 0) result.file = pruned;
+  }
+  if (schema.web) {
+    const pruned = pruneRules(schema.web);
+    if (Object.keys(pruned).length > 0) result.web = pruned;
+  }
+  if (schema.bash) {
+    const pruned = pruneRules(schema.bash, true);
+    if (Object.keys(pruned).length > 0) result.bash = pruned;
+  }
+  if (schema.mcp) {
+    const pruned = pruneRules(schema.mcp);
+    if (Object.keys(pruned).length > 0) result.mcp = pruned;
+  }
+  return result;
+}
+
+export async function cleanupPermissions(cwd: string, sessionIds: Set<string>) {
+  cleanupLocal(cwd, sessionIds);
+  cleanupGlobal();
+}
+
+async function cleanupLocal(cwd: string, sessionIds: Set<string>) {
+  const local = await readRules(cwd);
+  let changed = pruneSessionMap(local, sessionIds);
+
+  if (local.project) {
+    const pruned = pruneSchema(local.project);
+    local.project = pruned;
+    changed = true;
+  }
+
+  if (changed) {
+    await writeRules(local, cwd);
+  }
+}
+
+async function cleanupGlobal() {
+  const global = await readRules();
+  const pruned = pruneSchema(global);
+  await writeRules(pruned);
+}