@narumitw/pi-files 0.0.0-stage → 0.1.0

package/dist/index.ts

@@ -0,0 +1,1789 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  MAX_PENDING_QUOTES,
+  MAX_PENDING_QUOTE_BYTES,
+  MAX_QUOTE_BYTES,
+  MAX_QUOTE_LINES,
+  appendPendingQuote,
+  discoverProjectFiles,
+  formatQuoteContext,
+  loadProjectTextFile
+} from "./chunks/chunk-WOTDNRTG.ts";
+import {
+  STATE_TYPE,
+  createSnapshot,
+  parseSnapshot,
+  restoreScope,
+  sameScope
+} from "./chunks/chunk-NFNGJETD.ts";
+import {
+  awaitFileContextSettingsWrites,
+  fileContextSettingsPath,
+  loadFileContextSettings,
+  updateFileContextSettings
+} from "./chunks/chunk-OPGTWNJI.ts";
+import {
+  assertScopeTarget,
+  resolveScopeTarget
+} from "./chunks/chunk-F5QFC255.ts";
+import {
+  displayError,
+  displayPath
+} from "./chunks/chunk-AXW73HDJ.ts";
+
+// src/external-editor.ts
+import { spawn } from "node:child_process";
+import { lstat, realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { getAgentDir, SettingsManager, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+async function editProjectFileInExternalEditor(options) {
+  options.signal?.throwIfAborted();
+  const target = await resolveEditableProjectFile(options.root, options.projectPath, options.signal);
+  options.signal?.throwIfAborted();
+  const command = options.command ?? SettingsManager.create(options.root, options.agentDir ?? getAgentDir(), {
+    projectTrusted: options.projectTrusted
+  }).getExternalEditorCommand();
+  const [editor, ...editorArgs] = command.trim().split(/\s+/u);
+  if (!editor) throw new Error("External editor command is empty");
+  assertEditorTargetSafeForPlatform(target);
+  await withFileMutationQueue(target, async () => {
+    options.signal?.throwIfAborted();
+    let stopped = false;
+    try {
+      options.tui.stop();
+      stopped = true;
+      process.stdout.write("Launching external editor. Pi will resume when the editor exits.\n");
+      await runExternalEditorProcess(editor, [...editorArgs, target], options.signal, options.spawnProcess);
+      options.signal?.throwIfAborted();
+    } finally {
+      if (stopped && !options.signal?.aborted && (options.isCurrent === void 0 || options.isCurrent())) {
+        options.tui.start();
+        options.tui.requestRender(true);
+      }
+    }
+  });
+}
+async function resolveEditableProjectFile(root, projectPath, signal) {
+  signal?.throwIfAborted();
+  if (!projectPath || isAbsolute(projectPath) || projectPath.includes("\0")) {
+    throw new Error("File path is outside the project");
+  }
+  const canonicalRoot = await realpath(root);
+  signal?.throwIfAborted();
+  const candidate = resolve(canonicalRoot, projectPath);
+  if (!isInside(canonicalRoot, candidate)) throw new Error("File path is outside the project");
+  const candidateInfo = await lstat(candidate);
+  signal?.throwIfAborted();
+  if (candidateInfo.isSymbolicLink()) throw new Error(`${projectPath} is a symbolic link`);
+  const canonicalFile = await realpath(candidate);
+  signal?.throwIfAborted();
+  if (!isInside(canonicalRoot, canonicalFile)) throw new Error("File path is outside the project");
+  const info = await lstat(canonicalFile);
+  signal?.throwIfAborted();
+  if (!info.isFile()) throw new Error(`${projectPath} is not a regular file`);
+  return canonicalFile;
+}
+async function runExternalEditorProcess(command, args, signal, spawnProcess = defaultSpawnExternalEditorProcess) {
+  signal?.throwIfAborted();
+  const child = spawnProcess(command, args);
+  await new Promise((resolvePromise, reject) => {
+    let settled = false;
+    let aborted = signal?.aborted ?? false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", abort);
+      if (error) reject(error);
+      else resolvePromise();
+    };
+    const abort = () => {
+      aborted = true;
+      if (!child.killed) child.kill();
+    };
+    child.once("error", (error) => finish(aborted ? abortError() : error));
+    child.once("close", (code) => {
+      if (aborted) {
+        finish(abortError());
+        return;
+      }
+      if (code === 0) {
+        finish();
+        return;
+      }
+      finish(new Error(`External editor exited with code ${code ?? "unknown"}`));
+    });
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+  });
+}
+function assertEditorTargetSafeForPlatform(target, platform = process.platform) {
+  if (platform === "win32" && /[\r\n"&|<>^()%!]/u.test(target)) {
+    throw new Error("File path contains characters unsafe for the Windows external-editor shell");
+  }
+}
+function defaultSpawnExternalEditorProcess(command, args) {
+  return spawn(command, [...args], {
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+}
+function isInside(root, candidate) {
+  const result = relative(root, candidate);
+  return result === "" || !result.startsWith(`..${sep}`) && result !== ".." && !isAbsolute(result);
+}
+function abortError() {
+  return new DOMException("External editor cancelled", "AbortError");
+}
+
+// src/files-widget.ts
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { EditorStatusWidget } from "@narumitw/pi-tui-kit/editor-status-widget";
+import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
+function publishFilesWidget(ctx, quotes, scope) {
+  if (!ctx.hasUI) return;
+  if (!quotes.length && (!scope || scope.state === "inactive")) {
+    ctx.ui.setWidget("files", void 0);
+    return;
+  }
+  const totalBytes = quotes.reduce((total, quote) => total + Buffer.byteLength(quote.text, "utf8"), 0);
+  const lines = [];
+  if (scope && scope.state !== "inactive") {
+    lines.push({
+      role: scope.state === "blocked" ? "error" : "accent",
+      text: `${scope.state === "blocked" ? "Edit Scope unavailable \xB7 edits blocked" : `Editing limited to ${scope.targets.length} file${scope.targets.length === 1 ? "" : "s"}`} \xB7 /files off`
+    });
+    lines.push({
+      role: "muted",
+      text: `${scope.targets.slice(0, 2).map((target) => displayPath(target.path)).join(" \xB7 ")}${scope.targets.length > 2 ? " \xB7 \u2026" : ""}`
+    });
+  }
+  if (quotes.length) {
+    lines.push({
+      role: "accent",
+      text: `Next prompt context \xB7 ${quotes.length} ${quotes.length === 1 ? "snippet" : "snippets"} \xB7 ~${Math.max(1, Math.ceil(totalBytes / 4))} tokens \xB7 /file-context to review`
+    });
+    lines.push(
+      ...quotes.map((quote, index) => ({
+        role: "muted",
+        text: `${index + 1}. ${sanitizeTerminalText(escapeControls(quote.path))} \xB7 lines ${quote.startLine}-${quote.endLine} \xB7 ~${Math.max(1, Math.ceil(Buffer.byteLength(quote.text, "utf8") / 4))} tokens`
+      }))
+    );
+  }
+  const render = (theme) => lines.map((line) => theme.fg(line.role, line.text));
+  if (ctx.mode !== "tui") {
+    ctx.ui.setWidget("files", render(ctx.ui.theme));
+    return;
+  }
+  ctx.ui.setWidget(
+    "files",
+    (_tui, theme) => new EditorStatusWidget({
+      theme,
+      renderBody: (width) => width === 0 ? lines.map(() => "") : render(theme).flatMap((line) => wrapTextWithAnsi(line, width))
+    })
+  );
+}
+function escapeControls(text) {
+  return [...text].map((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159 ? `\\x${code.toString(16).padStart(2, "0")}` : character;
+  }).join("");
+}
+
+// src/git-context.ts
+import { execFile } from "node:child_process";
+import { realpath as realpath2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 5e3;
+var GIT_MAX_BUFFER = 11e5;
+var MAX_HISTORY_ENTRIES = 20;
+var GitContext = class {
+  constructor(projectRoot, project2, statuses) {
+    this.projectRoot = projectRoot;
+    this.project = project2;
+    this.statusMap = new Map(statuses);
+  }
+  projectRoot;
+  project;
+  statusMap;
+  work = /* @__PURE__ */ new Set();
+  get statuses() {
+    return this.statusMap;
+  }
+  async getFileContext(projectPath, signal) {
+    this.assertProjectPath(projectPath);
+    const [blobResult, diffResult] = await Promise.all([
+      this.run(["rev-parse", "--verify", `HEAD:${this.repositoryPath(projectPath)}`], true, signal),
+      this.run(["diff", "--no-ext-diff", "--no-textconv", "--unified=3", "HEAD", "--", projectPath], true, signal)
+    ]);
+    signal?.throwIfAborted();
+    return {
+      status: this.statusMap.get(projectPath),
+      blob: blobResult.ok ? blobResult.stdout.trim() || void 0 : void 0,
+      hunks: diffResult.ok ? parseUnifiedDiff(diffResult.stdout) : []
+    };
+  }
+  async refreshFileContext(projectPath, signal) {
+    const [fileContext, statusResult] = await Promise.all([
+      this.getFileContext(projectPath, signal),
+      this.run(
+        [
+          "-c",
+          "status.relativePaths=true",
+          "status",
+          "--porcelain=v1",
+          "-z",
+          "--untracked-files=all",
+          "--ignored=traditional",
+          "--",
+          "."
+        ],
+        true,
+        signal
+      )
+    ]);
+    signal?.throwIfAborted();
+    if (!statusResult.ok) return fileContext;
+    const statuses = parseStatuses(statusResult.stdout, this.project.projectPrefix);
+    this.statusMap.clear();
+    for (const [path, status] of statuses) this.statusMap.set(path, status);
+    this.project.dirty = [...statuses.values()].some((status) => !status.ignored);
+    return { ...fileContext, status: this.statusMap.get(projectPath) };
+  }
+  async getBlame(projectPath, line, revision, signal) {
+    this.assertProjectPath(projectPath);
+    if (!Number.isSafeInteger(line) || line < 1) throw new Error("Blame line must be positive");
+    if (revision && !/^[0-9a-f]{40}$/i.test(revision)) throw new Error("Invalid blame revision");
+    const result = await this.run(
+      [
+        "blame",
+        "--no-textconv",
+        "--line-porcelain",
+        "-L",
+        `${line},${line}`,
+        ...revision ? [revision] : [],
+        "--",
+        projectPath
+      ],
+      true,
+      signal
+    );
+    signal?.throwIfAborted();
+    if (!result.ok) return void 0;
+    return parseBlame(result.stdout);
+  }
+  async getHistory(projectPath, signal) {
+    this.assertProjectPath(projectPath);
+    const result = await this.run(
+      [
+        "log",
+        `--max-count=${MAX_HISTORY_ENTRIES}`,
+        "--format=%x1e%H%x1f%an%x1f%at%x1f%s",
+        "--name-only",
+        "-z",
+        "--follow",
+        "--",
+        projectPath
+      ],
+      true,
+      signal
+    );
+    signal?.throwIfAborted();
+    return result.ok ? parseHistory(result.stdout) : [];
+  }
+  async loadRevision(projectPath, revision, historicalPath, signal) {
+    this.assertProjectPath(projectPath);
+    const normalizedRevision = revision.trim();
+    if (!normalizedRevision || /[\0\r\n]/.test(normalizedRevision)) {
+      throw new Error("Revision is required");
+    }
+    const resolved = await this.run(
+      ["rev-parse", "--verify", "--end-of-options", `${normalizedRevision}^{commit}`],
+      true,
+      signal
+    );
+    if (!resolved.ok || !/^[0-9a-f]{40}$/i.test(resolved.stdout.trim())) {
+      throw new Error(`Unknown Git revision: ${normalizedRevision}`);
+    }
+    signal?.throwIfAborted();
+    const commit = resolved.stdout.trim().toLowerCase();
+    const repositoryPath = historicalPath ? this.assertRepositoryPath(historicalPath) : this.repositoryPath(projectPath);
+    const [contentsResult, blobResult] = await Promise.all([
+      this.run(["show", `${commit}:${repositoryPath}`], true, signal),
+      this.run(["rev-parse", "--verify", `${commit}:${repositoryPath}`], true, signal)
+    ]);
+    signal?.throwIfAborted();
+    if (!contentsResult.ok) {
+      throw new Error(`${projectPath} does not exist at ${normalizedRevision}`);
+    }
+    if (Buffer.byteLength(contentsResult.stdout, "utf8") > 1e6) {
+      throw new Error(`${projectPath} exceeds 1000000 bytes at ${normalizedRevision}`);
+    }
+    if (contentsResult.stdout.includes("\0")) {
+      throw new Error(`${projectPath} appears to be binary at ${normalizedRevision}`);
+    }
+    return {
+      path: historicalPath ?? projectPath,
+      lines: normalizeLines(contentsResult.stdout),
+      revision: normalizedRevision,
+      commit,
+      blob: blobResult.ok ? blobResult.stdout.trim() || void 0 : void 0
+    };
+  }
+  /** Drain processes after the owning explorer cancels its request controllers. */
+  async whenIdle() {
+    await Promise.allSettled([...this.work]);
+  }
+  run(args, allowFailure = false, signal) {
+    const work = runGit(this.projectRoot, args, allowFailure, signal);
+    this.work.add(work);
+    void work.then(
+      () => this.work.delete(work),
+      () => this.work.delete(work)
+    );
+    return work;
+  }
+  repositoryPath(projectPath) {
+    return `${this.project.projectPrefix}${projectPath}`.replaceAll("\\", "/");
+  }
+  assertRepositoryPath(repositoryPath) {
+    const normalized = repositoryPath.replaceAll("\\", "/");
+    if (!normalized || isAbsolute2(normalized) || normalized.includes("\0")) {
+      throw new Error("Invalid historical Git path");
+    }
+    const candidate = resolve2(this.project.repositoryRoot, normalized);
+    const result = relative2(this.project.repositoryRoot, candidate);
+    if (result === ".." || result.startsWith(`..${sep2}`)) {
+      throw new Error("Historical Git path is outside the repository");
+    }
+    return normalized;
+  }
+  assertProjectPath(projectPath) {
+    if (!projectPath || isAbsolute2(projectPath) || projectPath.includes("\0")) {
+      throw new Error("Invalid project path");
+    }
+    const candidate = resolve2(this.projectRoot, projectPath);
+    const result = relative2(this.projectRoot, candidate);
+    if (result === ".." || result.startsWith(`..${sep2}`)) {
+      throw new Error("Git path is outside the project");
+    }
+  }
+};
+async function createGitContext(root, signal) {
+  signal?.throwIfAborted();
+  const projectRoot = await realpath2(root);
+  signal?.throwIfAborted();
+  const repositoryResult = await runGit(projectRoot, ["rev-parse", "--show-toplevel"], true, signal);
+  if (!repositoryResult.ok) return void 0;
+  const repositoryRoot = stripLineEnding(repositoryResult.stdout);
+  if (!repositoryRoot) return void 0;
+  const [prefixResult, headResult, branchResult, statusResult] = await settleGitReads([
+    runGit(projectRoot, ["rev-parse", "--show-prefix"], true, signal),
+    runGit(projectRoot, ["rev-parse", "--verify", "HEAD"], true, signal),
+    runGit(projectRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"], true, signal),
+    runGit(
+      projectRoot,
+      [
+        "-c",
+        "status.relativePaths=true",
+        "status",
+        "--porcelain=v1",
+        "-z",
+        "--untracked-files=all",
+        "--ignored=traditional",
+        "--",
+        "."
+      ],
+      true,
+      signal
+    )
+  ]);
+  signal?.throwIfAborted();
+  const head = headResult.ok ? headResult.stdout.trim().toLowerCase() : "unborn";
+  const branch = branchResult.ok ? branchResult.stdout.trim() : head === "unborn" ? "unborn" : head.slice(0, 12);
+  const projectPrefix = prefixResult.ok ? stripLineEnding(prefixResult.stdout) : "";
+  const statuses = statusResult.ok ? parseStatuses(statusResult.stdout, projectPrefix) : /* @__PURE__ */ new Map();
+  return new GitContext(
+    projectRoot,
+    {
+      repositoryRoot,
+      projectPrefix,
+      branch,
+      head,
+      dirty: [...statuses.values()].some((status) => !status.ignored)
+    },
+    statuses
+  );
+}
+async function runGit(cwd, args, allowFailure, signal) {
+  try {
+    const task = execFileAsync("git", ["--no-pager", "-c", "core.pager=cat", "-c", "core.fsmonitor=false", ...args], {
+      cwd,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+      signal,
+      env: {
+        ...process.env,
+        GIT_OPTIONAL_LOCKS: "0",
+        GIT_PAGER: "cat",
+        PAGER: "cat"
+      }
+    });
+    const closed = new Promise((resolve5) => {
+      task.child.once("close", () => resolve5());
+    });
+    let stdout;
+    try {
+      ({ stdout } = await task);
+    } finally {
+      await closed;
+    }
+    return { ok: true, stdout };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    if (allowFailure) return { ok: false, stdout: "" };
+    throw error;
+  }
+}
+async function settleGitReads(reads) {
+  const results = await Promise.allSettled(reads);
+  return results.map((result) => {
+    if (result.status === "rejected") throw result.reason;
+    return result.value;
+  });
+}
+function parseStatuses(output, projectPrefix) {
+  const statuses = /* @__PURE__ */ new Map();
+  const records = output.split("\0");
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record || record.length < 4) continue;
+    const code = record.slice(0, 2);
+    const repositoryPath = record.slice(3).replaceAll("\\", "/");
+    const projectPath = projectPrefix ? repositoryPath.startsWith(projectPrefix) ? repositoryPath.slice(projectPrefix.length) : void 0 : repositoryPath;
+    if (projectPath) statuses.set(projectPath, statusFromCode(code));
+    if (code.includes("R") || code.includes("C")) index += 1;
+  }
+  return new Map([...statuses].sort(([left], [right]) => compareStrings(left, right)));
+}
+function statusFromCode(code) {
+  const conflicted = /^(DD|AU|UD|UA|DU|AA|UU)$/.test(code);
+  const untracked = code === "??";
+  const ignored = code === "!!";
+  const staged = !untracked && !ignored && code[0] !== " ";
+  const unstaged = !untracked && !ignored && code[1] !== " ";
+  let label;
+  if (conflicted) label = "conflicted";
+  else if (untracked) label = "untracked";
+  else if (ignored) label = "ignored";
+  else {
+    const character = unstaged ? code[1] : code[0];
+    const action = character === "A" ? "added" : character === "D" ? "deleted" : character === "R" ? "renamed" : character === "C" ? "copied" : character === "T" ? "type changed" : "modified";
+    const location = staged && unstaged ? "staged + unstaged" : staged ? "staged" : "unstaged";
+    label = `${action} (${location})`;
+  }
+  return { code, label, staged, unstaged, untracked, ignored, conflicted };
+}
+function parseUnifiedDiff(output) {
+  const hunks = [];
+  let current;
+  let newLine = 0;
+  for (const line of output.replaceAll("\r\n", "\n").split("\n")) {
+    const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(line);
+    if (match) {
+      current = {
+        header: line,
+        oldStart: Number(match[1]),
+        oldCount: Number(match[2] ?? 1),
+        newStart: Number(match[3]),
+        newCount: Number(match[4] ?? 1),
+        lines: [line],
+        changedLines: []
+      };
+      newLine = current.newStart;
+      hunks.push(current);
+      continue;
+    }
+    if (!current) continue;
+    current.lines.push(line);
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      current.changedLines.push(newLine);
+      newLine += 1;
+    } else if (!line.startsWith("-") && !line.startsWith("\\")) {
+      newLine += 1;
+    }
+  }
+  for (const hunk of hunks) {
+    while (hunk.lines.at(-1) === "") hunk.lines.pop();
+  }
+  return hunks;
+}
+function parseBlame(output) {
+  const lines = output.split("\n");
+  const commit = lines[0]?.split(" ")[0];
+  if (!commit) return void 0;
+  const field = (name) => lines.find((line) => line.startsWith(`${name} `))?.slice(name.length + 1);
+  const authorTime = Number(field("author-time"));
+  return {
+    commit,
+    author: field("author") ?? "Unknown",
+    authorTime: Number.isFinite(authorTime) ? authorTime : void 0,
+    summary: field("summary") ?? "",
+    committed: !/^0+$/.test(commit)
+  };
+}
+function parseHistory(output) {
+  return output.split("").filter(Boolean).flatMap((record) => {
+    const [metadata = "", ...pathRecords] = record.split("\0");
+    const [commit, author, authorTime, ...summaryParts] = metadata.replace(/^\n+/, "").split("");
+    const path = pathRecords.map((value) => value.replace(/^\n+/, "")).find(Boolean);
+    const time = Number(authorTime);
+    return commit && author && path && Number.isFinite(time) ? [{ commit, author, authorTime: time, summary: summaryParts.join(""), path }] : [];
+  });
+}
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function stripLineEnding(value) {
+  return value.endsWith("\r\n") ? value.slice(0, -2) : value.endsWith("\n") ? value.slice(0, -1) : value;
+}
+function normalizeLines(contents) {
+  if (contents === "") return [];
+  const lines = contents.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+
+// src/context-service.ts
+async function registerFileContext(pi, dependencies = {}) {
+  const settingsPath = dependencies.settingsPath ?? fileContextSettingsPath();
+  const loadSettings = dependencies.loadSettings ?? (() => loadFileContextSettings(settingsPath));
+  const updateSettings = dependencies.updateSettings ?? updateFileContextSettings;
+  const initialSettings = await loadSettings();
+  const discoverFiles = dependencies.discoverFiles ?? discoverProjectFiles;
+  const createGit = dependencies.createGit ?? createGitContext;
+  const owners = /* @__PURE__ */ new Map();
+  const requireOwner = (ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    if (!owner || owner.controller.signal.aborted) throw new Error("File Context is not initialized; reload first");
+    return owner;
+  };
+  function createOwner(context) {
+    let loadedSettings = initialSettings;
+    let pendingQuotes = [];
+    let nextPendingQuoteId = 1;
+    const activeSessionManager = context.sessionManager;
+    const sessionGeneration = 0;
+    const sessionController = new AbortController();
+    const activeExplorers = /* @__PURE__ */ new Set();
+    const nativeWork = /* @__PURE__ */ new Set();
+    const gitContexts = /* @__PURE__ */ new Set();
+    const track = (work) => {
+      nativeWork.add(work);
+      void work.then(
+        () => nativeWork.delete(work),
+        () => nativeWork.delete(work)
+      );
+      return work;
+    };
+    let activeExplorerLaunch;
+    let activeMenuLaunch;
+    const updatePendingWidget = (ctx) => (dependencies.onChange ?? publishFilesWidget)(
+      ctx,
+      pendingQuotes.map((item) => item.quote)
+    );
+    const clearPending = (ctx) => {
+      pendingQuotes = [];
+      nextPendingQuoteId = 1;
+      updatePendingWidget(ctx);
+    };
+    const validatePending = (quote) => {
+      appendPendingQuote(
+        pendingQuotes.map((item) => item.quote),
+        quote
+      );
+    };
+    const appendPending = (quote, ctx) => {
+      validatePending(quote);
+      pendingQuotes = [...pendingQuotes, { id: `quote-${nextPendingQuoteId++}`, quote }];
+      updatePendingWidget(ctx);
+    };
+    const isCurrentSession = (key, generation) => key === activeSessionManager && generation === sessionGeneration && owners.get(activeSessionManager) === runtime && !sessionController.signal.aborted;
+    const menuQuote = ({ id, quote }) => ({
+      id,
+      path: quote.path,
+      startLine: quote.startLine,
+      endLine: quote.endLine,
+      text: quote.text
+    });
+    const cancelExplorers = () => {
+      for (const explorer of activeExplorers) {
+        explorer.controller.abort(new DOMException("File Context explorer closed", "AbortError"));
+        explorer.component?.dispose();
+      }
+      activeExplorers.clear();
+    };
+    const runExplorer = async (ctx, options = {}) => {
+      if (ctx.mode !== "tui") {
+        rejectCommand(ctx, "File Context requires Pi's interactive TUI.");
+        return "close";
+      }
+      const owner = ctx.sessionManager;
+      const generation = sessionGeneration;
+      const activeExplorer = { controller: new AbortController() };
+      let explorerGit;
+      const { controller } = activeExplorer;
+      const flowSignal = AbortSignal.any([
+        controller.signal,
+        sessionController.signal,
+        ...ctx.signal ? [ctx.signal] : [],
+        ...options.signal ? [options.signal] : []
+      ]);
+      activeExplorers.add(activeExplorer);
+      try {
+        const [{ runCustomInteraction, runTask }, { FileQuoteExplorer }] = await Promise.all([
+          import("@narumitw/pi-tui-kit"),
+          import("./chunks/file-context-explorer-WR6GQZHF.ts")
+        ]);
+        if (!isCurrentSession(owner, generation) || flowSignal.aborted) return "close";
+        const task = await runTask(ctx, {
+          label: "Scanning project files\u2026",
+          signal: flowSignal,
+          isCurrent: () => isCurrentSession(owner, generation) && !flowSignal.aborted,
+          task: ({ signal }) => Promise.all([track(discoverFiles(ctx.cwd, { signal })), track(createGit(ctx.cwd, signal))]),
+          onError: (_taskContext, error) => {
+            ctx.ui.notify(
+              `File Context could not scan project files: ${escapeTerminalControls(formatError(error))}. Open File Context to retry.`,
+              "error"
+            );
+          }
+        });
+        if (task.kind === "cancelled" || task.kind === "error") {
+          return options.menuOwned ? "stay" : "close";
+        }
+        if (task.kind === "stale") return "close";
+        const discovery = task.value;
+        if (!isCurrentSession(owner, generation) || flowSignal.aborted) return "close";
+        const [files, gitContext] = discovery;
+        if (gitContext) {
+          explorerGit = gitContext;
+          gitContexts.add(gitContext);
+        }
+        if (files.length === 0) {
+          ctx.ui.notify("File Context found no project files. Choose Add context snippet to retry.", "warning");
+          return options.menuOwned ? "stay" : "close";
+        }
+        const interaction = await runCustomInteraction(ctx, {
+          signal: flowSignal,
+          isCurrent: () => isCurrentSession(owner, generation),
+          onError: () => {
+          },
+          create: ({ tui, theme, keybindings, signal: interactionSignal, complete }) => {
+            const component = new FileQuoteExplorer({
+              tui,
+              theme,
+              keybindings,
+              files,
+              cwd: ctx.cwd,
+              loadFile: (path, signal) => track(
+                loadProjectTextFile(ctx.cwd, path, {
+                  signal: signal ? AbortSignal.any([signal, interactionSignal]) : interactionSignal
+                })
+              ),
+              editFile: (path, signal) => track(
+                editProjectFileInExternalEditor({
+                  root: ctx.cwd,
+                  projectPath: path,
+                  tui,
+                  projectTrusted: ctx.isProjectTrusted(),
+                  signal: signal ? AbortSignal.any([signal, interactionSignal]) : interactionSignal,
+                  isCurrent: () => isCurrentSession(owner, generation) && !interactionSignal.aborted
+                })
+              ),
+              gitContext,
+              rootNavigation: options.menuOwned,
+              getSelectedContextState: () => ({
+                count: pendingQuotes.length,
+                totalBytes: pendingQuotes.reduce(
+                  (total, item) => total + Buffer.byteLength(item.quote.text, "utf8"),
+                  0
+                ),
+                maximumCount: MAX_PENDING_QUOTES,
+                maximumBytes: MAX_PENDING_QUOTE_BYTES,
+                maximumSnippetLines: MAX_QUOTE_LINES,
+                maximumSnippetBytes: MAX_QUOTE_BYTES
+              }),
+              validateQuote: validatePending,
+              onAddAndContinue: (quote) => {
+                if (!isCurrentSession(owner, generation) || interactionSignal.aborted) {
+                  throw new DOMException("File Context session replaced", "AbortError");
+                }
+                appendPending(quote, ctx);
+                try {
+                  ctx.ui.notify(
+                    `Added to next prompt context: ${escapeTerminalControls(quote.path)} \xB7 lines ${quote.startLine}-${quote.endLine}.`,
+                    "info"
+                  );
+                } catch {
+                }
+              },
+              done: complete
+            });
+            activeExplorer.component = component;
+            return component;
+          }
+        });
+        if (interaction.kind === "error") throw interaction.error;
+        const result = interaction.kind === "completed" ? interaction.value : void 0;
+        if (!isCurrentSession(owner, generation) || flowSignal.aborted) return "close";
+        if (result?.kind === "quote") {
+          appendPending(result.quote, ctx);
+          return "close";
+        }
+        if (result?.kind === "reference") {
+          ctx.ui.pasteToEditor(formatFileReference(result.path));
+          return "close";
+        }
+        return result?.kind === "back" ? "stay" : "close";
+      } catch (error) {
+        if (!isCurrentSession(owner, generation) || flowSignal.aborted || isAbortError(error)) {
+          return "close";
+        }
+        try {
+          ctx.ui.notify(
+            `File Context failed: ${escapeTerminalControls(formatError(error))}. Open File Context to retry.`,
+            "error"
+          );
+        } catch {
+        }
+        return options.menuOwned ? "stay" : "close";
+      } finally {
+        activeExplorers.delete(activeExplorer);
+        if (explorerGit) {
+          await explorerGit.whenIdle();
+          gitContexts.delete(explorerGit);
+        }
+      }
+    };
+    const openExplorer = (ctx) => {
+      if (activeExplorerLaunch) return activeExplorerLaunch.promise;
+      if (activeMenuLaunch) return activeMenuLaunch.promise;
+      const launch = { promise: runExplorer(ctx).then(() => void 0) };
+      activeExplorerLaunch = launch;
+      void launch.promise.finally(() => {
+        if (activeExplorerLaunch === launch) activeExplorerLaunch = void 0;
+      }).catch(() => {
+      });
+      return launch.promise;
+    };
+    const openMenu = (ctx, start = "main") => {
+      if (ctx.mode !== "tui") {
+        rejectCommand(ctx, "File Context requires Pi's interactive TUI.");
+        return Promise.resolve();
+      }
+      if (activeMenuLaunch) return activeMenuLaunch.promise;
+      if (activeExplorerLaunch) return activeExplorerLaunch.promise;
+      if (start === "remove" && pendingQuotes.length === 0) {
+        ctx.ui.notify("File Context has no context selected for the next prompt.", "warning");
+        return Promise.resolve();
+      }
+      const owner = ctx.sessionManager;
+      const generation = sessionGeneration;
+      const ownerController = {
+        signal: AbortSignal.any([sessionController.signal, ...ctx.signal ? [ctx.signal] : []])
+      };
+      const isCurrent = () => isCurrentSession(owner, generation) && !ownerController.signal.aborted;
+      const promise = import("./chunks/file-context-menu-VPLHUUQ6.ts").then(({ showFileContextMenu }) => {
+        if (!isCurrent()) return;
+        return showFileContextMenu(ctx, {
+          start,
+          signal: ownerController.signal,
+          isCurrent,
+          getState: () => {
+            if (!isCurrent()) throw new DOMException("File Context session replaced", "AbortError");
+            const quotes = pendingQuotes.map(menuQuote);
+            return {
+              quotes,
+              shortcut: loadedSettings.settings.openShortcut,
+              maximumQuotes: MAX_PENDING_QUOTES,
+              maximumBytes: MAX_PENDING_QUOTE_BYTES,
+              totalBytes: quotes.reduce((total, quote) => total + Buffer.byteLength(quote.text, "utf8"), 0),
+              settingsPath,
+              settingsInvalidReason: loadedSettings.invalidReason
+            };
+          },
+          addQuote: (signal) => runExplorer(ctx, { menuOwned: true, signal }),
+          saveShortcut: async (shortcut, signal) => {
+            if (!isCurrent() || signal.aborted) {
+              throw new DOMException("File Context session replaced", "AbortError");
+            }
+            if (pendingQuotes.length > 0)
+              throw new Error("Submit or remove selected context before changing the shortcut");
+            const saved = await updateSettings(shortcut, { settingsPath, signal });
+            if (!isCurrent() || signal.aborted) return;
+            loadedSettings = { settings: saved };
+          },
+          removeQuote: (id, signal) => {
+            if (!isCurrent() || signal.aborted) return { kind: "missing" };
+            const index = pendingQuotes.findIndex((item) => item.id === id);
+            const selected = pendingQuotes[index];
+            if (!selected) return { kind: "missing" };
+            pendingQuotes = pendingQuotes.filter((_item, itemIndex) => itemIndex !== index);
+            updatePendingWidget(ctx);
+            return {
+              kind: "removed",
+              quote: menuQuote(selected),
+              remaining: pendingQuotes.length
+            };
+          }
+        });
+      }).then(() => void 0);
+      const launch = { promise };
+      activeMenuLaunch = launch;
+      const clearLaunch = () => {
+        if (activeMenuLaunch === launch) activeMenuLaunch = void 0;
+      };
+      void promise.then(clearLaunch, clearLaunch);
+      return promise;
+    };
+    const runtime = {
+      controller: sessionController,
+      open: openMenu,
+      browse: openExplorer,
+      getState: () => ({
+        quotes: pendingQuotes.map(menuQuote),
+        shortcut: loadedSettings.settings.openShortcut,
+        maximumQuotes: MAX_PENDING_QUOTES,
+        maximumBytes: MAX_PENDING_QUOTE_BYTES,
+        totalBytes: pendingQuotes.reduce((total, item) => total + Buffer.byteLength(item.quote.text, "utf8"), 0),
+        settingsPath,
+        settingsInvalidReason: loadedSettings.invalidReason
+      }),
+      saveShortcut: async (ctx, shortcut, signal) => {
+        if (pendingQuotes.length) throw new Error("Submit or remove selected context before changing the shortcut");
+        const operation = AbortSignal.any([signal, sessionController.signal, ...ctx.signal ? [ctx.signal] : []]);
+        operation.throwIfAborted();
+        const saved = await updateSettings(shortcut, { settingsPath, signal: operation });
+        if (!isCurrentSession(activeSessionManager, sessionGeneration) || operation.aborted) return;
+        loadedSettings = { settings: saved };
+      },
+      refresh: async (ctx) => {
+        const refreshed = await loadSettings();
+        if (!isCurrentSession(activeSessionManager, sessionGeneration)) return;
+        loadedSettings = refreshed;
+        if (refreshed.warning && ctx.hasUI) ctx.ui.notify(escapeTerminalControls(refreshed.warning), "warning");
+      },
+      consume: (ctx) => {
+        const quotes = pendingQuotes.map((item) => item.quote);
+        clearPending(ctx);
+        return quotes;
+      },
+      release: async (ctx) => {
+        const work = [activeExplorerLaunch?.promise];
+        sessionController.abort(new DOMException("File Context session ended", "AbortError"));
+        cancelExplorers();
+        const settled = await Promise.allSettled([
+          awaitFileContextSettingsWrites(settingsPath),
+          Promise.resolve().then(() => clearPending(ctx)),
+          ...work,
+          ...nativeWork,
+          ...[...gitContexts].map((git) => git.whenIdle())
+        ]);
+        for (const result of settled.slice(0, 2)) if (result.status === "rejected") throw result.reason;
+      }
+    };
+    return runtime;
+  }
+  const service = {
+    open: (ctx, start) => requireOwner(ctx).open(ctx, start),
+    browse: (ctx) => requireOwner(ctx).browse(ctx),
+    getState: (ctx) => requireOwner(ctx).getState(),
+    saveShortcut: (ctx, shortcut, signal) => requireOwner(ctx).saveShortcut(ctx, shortcut, signal),
+    signal: (ctx) => requireOwner(ctx).controller.signal
+  };
+  if (initialSettings.settings.openShortcut) {
+    pi.registerShortcut(initialSettings.settings.openShortcut, {
+      description: "Open File Context",
+      handler: service.browse
+    });
+  }
+  pi.registerCommand("file-context", {
+    description: "Open the File Context menu",
+    getArgumentCompletions: (prefix) => {
+      const items = [
+        { value: "browse", label: "browse", description: "Open the file browser directly" },
+        { value: "remove", label: "remove", description: "Review selected context directly" }
+      ].filter((item) => item.value.startsWith(prefix.trimStart().toLowerCase()));
+      return items.length ? items : null;
+    },
+    handler: async (args, ctx) => {
+      const route = args.trim().toLowerCase();
+      if (route !== "" && route !== "browse" && route !== "remove")
+        return rejectCommand(ctx, "Usage: /file-context [browse|remove]");
+      if (ctx.mode !== "tui") return rejectCommand(ctx, "File Context requires Pi's interactive TUI.");
+      if (route === "browse") await service.browse(ctx);
+      else await service.open(ctx, route === "remove" ? "remove" : "main");
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    const key = ctx.sessionManager;
+    const previous = owners.get(key);
+    const owner = createOwner(ctx);
+    owners.set(key, owner);
+    if (previous) await previous.release(ctx);
+    if (owners.get(key) !== owner || owner.controller.signal.aborted) return;
+    (dependencies.onChange ?? publishFilesWidget)(ctx, []);
+    await owner.refresh(ctx);
+  });
+  pi.on("before_agent_start", (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    if (event.messageType === "custom" || !owner || owner.controller.signal.aborted || !owner.getState().quotes.length)
+      return;
+    return {
+      message: { customType: "file-context-quotes", content: formatQuoteContext(owner.consume(ctx)), display: false }
+    };
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    const key = ctx.sessionManager;
+    const owner = owners.get(key);
+    if (!owner) return;
+    try {
+      await owner.release(ctx);
+    } finally {
+      if (owners.get(key) === owner) owners.delete(key);
+    }
+  });
+  return service;
+}
+function formatFileReference(path) {
+  const escaped = path.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+  return /\s|["\\]/.test(path) ? `@"${escaped}" ` : `@${path} `;
+}
+function escapeTerminalControls(text) {
+  return [...text].map((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159 ? `\\x${code.toString(16).padStart(2, "0")}` : character;
+  }).join("");
+}
+function rejectCommand(ctx, message) {
+  if (ctx.hasUI) {
+    ctx.ui.notify(message, "warning");
+    return;
+  }
+  throw new Error(message);
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/scope/edit-scope.ts
+import { join as join2, resolve as resolve4 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
+
+// src/scope/contracts.ts
+import { createHash } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { convertToLlm } from "@earendil-works/pi-coding-agent";
+var NOTICE_TYPE = "scope-contract";
+var ANCHOR_TYPE = "scope-context-anchor";
+var MAX_NOTICE_BYTES = 48e3;
+var NON_MODEL_FIELDS = /* @__PURE__ */ new Set([
+  "timestamp",
+  "durationMs",
+  "usage",
+  "stopReason",
+  "errorMessage",
+  "api",
+  "provider",
+  "model",
+  "details",
+  "nestedCalls"
+]);
+function createScopeNotice(state, timestamp = 0) {
+  if (!state.entryId) return void 0;
+  let content;
+  if (state.state === "blocked") {
+    content = "Scope state is unavailable. Do not edit files or use writing commands. The user must repair it with /scope or exit with /scope off. Reading remains available.";
+  } else if (state.state === "inactive") {
+    content = "The user ended the Scope editing restriction. Earlier Scope notices no longer apply. All other existing instructions and tool restrictions remain unchanged.";
+  } else {
+    content = [
+      "Scope editing restriction is active. This notice replaces earlier Scope notices.",
+      "Only write or edit these exact selected file targets. Use their file URLs as tool paths to preserve literal Unicode and control characters:",
+      ...(state.snapshot?.targets ?? []).map(
+        (target) => `- ${JSON.stringify(pathToFileURL(target.path).href)}${target.path === target.canonical ? "" : ` (canonical target ${displayPath(target.canonical)})`}`
+      ),
+      "Other files may be read. Shell commands and unsupported tools cannot bypass this editing boundary. Only the user can change or end the scope with /scope."
+    ].join("\n");
+  }
+  if (Buffer.byteLength(content) > MAX_NOTICE_BYTES)
+    throw new Error(`Scope notice exceeds ${MAX_NOTICE_BYTES} bytes; select fewer files`);
+  return {
+    role: "custom",
+    customType: NOTICE_TYPE,
+    content,
+    display: false,
+    details: { version: 1, stateId: state.entryId },
+    timestamp
+  };
+}
+function contractKey(message) {
+  if (message.role !== "custom" || message.customType !== NOTICE_TYPE || typeof message.content !== "string") return;
+  const details = message.details;
+  if (details?.version !== 1 || typeof details.stateId !== "string") return;
+  return JSON.stringify([details.stateId, message.content]);
+}
+function noticeKey(message) {
+  const key = contractKey(message);
+  if (!key) return;
+  const recovery = message.details;
+  return JSON.stringify([key, typeof recovery?.recovery === "number" ? recovery.recovery : 0]);
+}
+function anchoredNotice(notice, anchor) {
+  return anchor.recovery === void 0 ? notice : { ...notice, details: { version: 1, stateId: anchor.stateId, recovery: anchor.recovery } };
+}
+function prefixDigests(messages, counts) {
+  const hash = createHash("sha256");
+  const results = /* @__PURE__ */ new Map();
+  if (counts.has(0)) results.set(0, hash.copy().digest("hex"));
+  for (let index = 0; index < messages.length; index += 1) {
+    const normalized = convertToLlm([messages[index]]).map(
+      (message) => Object.fromEntries(Object.entries(message).filter(([key]) => !NON_MODEL_FIELDS.has(key)))
+    );
+    hash.update(JSON.stringify(normalized));
+    hash.update("\n");
+    if (counts.has(index + 1)) results.set(index + 1, hash.copy().digest("hex"));
+  }
+  return results;
+}
+function readAnchors(branch) {
+  const states = new Map(
+    branch.filter((entry) => entry.type === "custom" && entry.customType === STATE_TYPE).map((entry) => [entry.id, entry])
+  );
+  const found = /* @__PURE__ */ new Map();
+  for (const entry of branch) {
+    if (entry.type !== "custom" || entry.customType !== ANCHOR_TYPE || !entry.data || typeof entry.data !== "object")
+      continue;
+    const value = entry.data;
+    if (value.version !== 1 || typeof value.stateId !== "string" || !["active", "inactive", "blocked"].includes(value.state ?? "") || !Number.isSafeInteger(value.count) || value.count < 0 || typeof value.digest !== "string" || !/^[a-f0-9]{64}$/.test(value.digest) || typeof value.sentAt !== "number" || !Number.isFinite(value.sentAt) || value.recovery !== void 0 && (!Number.isSafeInteger(value.recovery) || value.recovery <= 0))
+      continue;
+    const source = states.get(value.stateId);
+    if (source?.type !== "custom") continue;
+    try {
+      const state = value.state === "blocked" ? { state: "blocked", entryId: source.id } : { state: value.state, entryId: source.id, snapshot: parseSnapshot(source.data) };
+      if (state.state !== "blocked" && state.snapshot?.targets === null !== (state.state === "inactive")) continue;
+      const anchor = value;
+      const notice = createScopeNotice(state, anchor.sentAt);
+      if (!notice) continue;
+      const key = JSON.stringify([anchor.stateId, anchor.state, anchor.count, anchor.digest, anchor.recovery ?? 0]);
+      if (!found.has(key)) found.set(key, { anchor, notice: anchoredNotice(notice, anchor) });
+    } catch {
+    }
+  }
+  return [...found.values()];
+}
+function baseFor(messages, anchors, exclude = []) {
+  const keys = /* @__PURE__ */ new Set([...anchors.map(({ notice }) => noticeKey(notice)), ...exclude.map(noticeKey)]);
+  return messages.filter((message) => !keys.has(noticeKey(message)));
+}
+function project(messages, candidates, exclude = []) {
+  const anchors = [...candidates];
+  let base;
+  for (; ; ) {
+    base = baseFor(messages, anchors, exclude);
+    const hashes = prefixDigests(base, new Set(anchors.map(({ anchor }) => anchor.count)));
+    const firstSlot = base[0]?.role === "system" ? 1 : 0;
+    const stale = anchors.findIndex(
+      ({ anchor }) => anchor.count < firstSlot || hashes.get(anchor.count) !== anchor.digest
+    );
+    if (stale < 0) break;
+    anchors.splice(stale, 1);
+  }
+  const at = /* @__PURE__ */ new Map();
+  for (const { anchor, notice } of anchors) {
+    const notices = at.get(anchor.count) ?? [];
+    notices.push(notice);
+    at.set(anchor.count, notices);
+  }
+  const placed = [];
+  for (let index = 0; index <= base.length; index += 1) {
+    placed.push(...at.get(index) ?? []);
+    if (index < base.length) placed.push(base[index]);
+  }
+  return { messages: placed, base, anchors };
+}
+function hasCurrentScopeNotice(messages, state) {
+  const expected = createScopeNotice(state);
+  if (!expected) return true;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index].role === "custom" && messages[index].customType === NOTICE_TYPE) {
+      return contractKey(messages[index]) === contractKey(expected);
+    }
+  }
+  return false;
+}
+function reconcileScopeContext(messages, branch, state, sentAt = Date.now()) {
+  const candidates = readAnchors(branch);
+  const placed = project(messages, candidates);
+  if (hasCurrentScopeNotice(placed.messages, state)) return { messages: placed.messages };
+  const notice = createScopeNotice(state, sentAt);
+  if (!notice || !state.entryId) return { messages: placed.messages };
+  const repeated = placed.messages.some((message) => contractKey(message) === contractKey(notice));
+  const prepared = project(messages, placed.anchors, repeated ? [] : [notice]);
+  const count = prepared.base.length;
+  const digest = prefixDigests(prepared.base, /* @__PURE__ */ new Set([count])).get(count);
+  const anchor = { version: 1, stateId: state.entryId, state: state.state, count, digest, sentAt };
+  if (repeated) {
+    anchor.recovery = candidates.reduce(
+      (latest, candidate) => candidate.anchor.stateId === state.entryId ? Math.max(latest, candidate.anchor.recovery ?? 0) : latest,
+      0
+    ) + 1;
+    if (!Number.isSafeInteger(anchor.recovery)) throw new Error("Scope recovery sequence is exhausted");
+  }
+  const next = project(messages, [...prepared.anchors, { anchor, notice: anchoredNotice(notice, anchor) }]);
+  return { messages: next.messages, anchor };
+}
+
+// src/scope/policy.ts
+var READERS = /* @__PURE__ */ new Set(["read", "ls", "find", "grep"]);
+var WRITERS = /* @__PURE__ */ new Set(["write", "edit"]);
+function isStockBuiltin(tool, name) {
+  return tool?.sourceInfo.source === "builtin" && tool.sourceInfo.path === `builtin:${name}`;
+}
+function assertUsableLoadout(pi) {
+  const tools = pi.getAllTools();
+  const active = new Set(pi.getActiveTools());
+  const codemode = tools.find((tool) => tool.name === "codemode");
+  if (active.has("codemode") && isStockBuiltin(codemode, "codemode") && pi.getSettings().codemode?.mode === "only") {
+    throw new Error(
+      "Scope cannot start with active codemode.mode=only: codemode can bypass tool guards and hides the direct editing tools. Set Pi's codemode.mode to on and reload first; Scope does not change that setting."
+    );
+  }
+  if (![...WRITERS].some(
+    (name) => active.has(name) && isStockBuiltin(
+      tools.find((tool) => tool.name === name),
+      name
+    )
+  )) {
+    throw new Error(
+      "Scope requires an active, unmodified built-in write or edit tool; custom replacements are unsupported"
+    );
+  }
+}
+function decideTool(name, tools, scope) {
+  if (scope.state === "inactive") return { kind: "pass" };
+  const tool = tools.find((candidate) => candidate.name === name);
+  if (READERS.has(name) && isStockBuiltin(tool, name)) return { kind: "pass" };
+  if (scope.state === "blocked") {
+    return {
+      kind: "block",
+      reason: scope.error ?? "Scope is not initialized; edits remain blocked. Use /scope to repair or /scope off to exit."
+    };
+  }
+  if (WRITERS.has(name) && isStockBuiltin(tool, name)) return { kind: "target" };
+  return {
+    kind: "block",
+    reason: `${JSON.stringify(name)} is blocked while Scope is active. Only stock readers and target-checked write/edit calls are supported. Shell, codemode, delegation, and opaque tools require /scope off.`
+  };
+}
+
+// src/scope/settings.ts
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import { basename, dirname, join, resolve as resolve3 } from "node:path";
+var queues = /* @__PURE__ */ new Map();
+function enqueue(path, operation) {
+  const result = (queues.get(path) ?? Promise.resolve()).then(operation);
+  const settled = result.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  queues.set(path, settled);
+  void settled.then(() => {
+    if (queues.get(path) === settled) queues.delete(path);
+  });
+  return result;
+}
+function isMissing(error) {
+  return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+function validateDocument(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid Scope settings at ${JSON.stringify(path)}: expected a JSON object.`);
+  }
+  const document = value;
+  if (Object.hasOwn(document, "showHiddenFiles") && typeof document.showHiddenFiles !== "boolean") {
+    throw new Error(`Invalid Scope settings at ${JSON.stringify(path)}: showHiddenFiles must be a boolean.`);
+  }
+  return document;
+}
+async function readDocument(path) {
+  let stats;
+  try {
+    stats = await fs.lstat(path);
+  } catch (error) {
+    if (isMissing(error)) return { document: {}, mode: 384 };
+    throw error;
+  }
+  if (stats.isSymbolicLink() || !stats.isFile()) {
+    throw new Error(`Scope settings must be a regular file, not a symlink: ${JSON.stringify(path)}.`);
+  }
+  const text = await fs.readFile(path, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Invalid Scope settings JSON at ${JSON.stringify(path)}. Repair the file before saving.`, {
+      cause: error
+    });
+  }
+  return { document: validateDocument(parsed, path), mode: Number(stats.mode) & 511 };
+}
+var ScopeSettingsStore = class {
+  #filePath;
+  #current = { showHiddenFiles: false };
+  constructor(filePath) {
+    this.#filePath = resolve3(filePath);
+  }
+  get current() {
+    return { ...this.#current };
+  }
+  /** Side-effect-free load; a failed read leaves the last effective value intact. */
+  load() {
+    return enqueue(this.#filePath, async () => {
+      const { document } = await readDocument(this.#filePath);
+      this.#current = { showHiddenFiles: document.showHiddenFiles ?? false };
+      return this.current;
+    });
+  }
+  /** Read the latest valid document and change only the owned field. */
+  saveShowHiddenFiles(value) {
+    return enqueue(this.#filePath, async () => {
+      if (typeof value !== "boolean") throw new Error("showHiddenFiles must be a boolean.");
+      const { document, mode } = await readDocument(this.#filePath);
+      const directory = dirname(this.#filePath);
+      await fs.mkdir(directory, { recursive: true });
+      const temporary = join(directory, `.${basename(this.#filePath)}.${process.pid}.${randomUUID()}.tmp`);
+      let handle;
+      let ownedTemporary = false;
+      try {
+        handle = await fs.open(temporary, "wx", mode);
+        ownedTemporary = true;
+        await handle.writeFile(`${JSON.stringify({ ...document, showHiddenFiles: value }, null, 2)}
+`, "utf8");
+        await handle.close();
+        handle = void 0;
+        await fs.rename(temporary, this.#filePath);
+        ownedTemporary = false;
+      } catch (error) {
+        const failures = [error];
+        if (handle) {
+          try {
+            await handle.close();
+          } catch (closeError) {
+            failures.push(closeError);
+          }
+        }
+        if (ownedTemporary) {
+          try {
+            await fs.unlink(temporary);
+          } catch (cleanupError) {
+            if (!isMissing(cleanupError)) failures.push(cleanupError);
+          }
+        }
+        if (failures.length > 1) {
+          throw new AggregateError(failures, `Scope settings save and cleanup failed at ${JSON.stringify(temporary)}.`);
+        }
+        throw error;
+      }
+      this.#current = { showHiddenFiles: value };
+      return this.current;
+    });
+  }
+  /** Drain prior operations; load/save promises carry their own errors to the caller. */
+  flush() {
+    return enqueue(this.#filePath, async () => {
+    });
+  }
+};
+
+// src/scope/edit-scope.ts
+var uninitialized = () => ({ state: "blocked", error: "Scope is not initialized; edits remain blocked" });
+var showMenu = async (ctx, options) => {
+  const { showScopeMenu } = await import("./chunks/menu-P6IBMROH.ts");
+  options.signal.throwIfAborted();
+  if (options.isCurrent()) await showScopeMenu(ctx, options);
+};
+function registerScope(pi, options = {}) {
+  const show = options.showMenu ?? showMenu;
+  const owners = /* @__PURE__ */ new Map();
+  const starts = /* @__PURE__ */ new WeakMap();
+  function current(owner, _ctx) {
+    return !owner.controller.signal.aborted && owners.get(owner.key) === owner;
+  }
+  function check(owner, ctx, flow) {
+    owner.controller.signal.throwIfAborted();
+    flow?.signal.throwIfAborted();
+    if (!current(owner, ctx) || flow && (owner.flow !== flow || owner.revision !== flow.revision)) {
+      throw new DOMException("Scope session or selection changed", "AbortError");
+    }
+    ctx.signal?.throwIfAborted();
+  }
+  function mutationCheck(owner, ctx, flow) {
+    check(owner, ctx, flow);
+    if (!ctx.isIdle() || ctx.hasPendingMessages()) {
+      throw new Error("Stop the current run and clear pending messages before changing Scope");
+    }
+  }
+  function view(owner, ctx) {
+    return {
+      state: owner.scope.state,
+      cwd: ctx.cwd,
+      targets: (owner.scope.snapshot?.targets ?? []).map((target) => ({ ...target })),
+      ...owner.scope.error ? { error: owner.scope.error } : {}
+    };
+  }
+  function updateView(owner, ctx) {
+    if (!current(owner, ctx)) return;
+    options.onChange?.(ctx, view(owner, ctx));
+  }
+  function notify(ctx, message, kind = "info") {
+    if (ctx.hasUI) ctx.ui.notify(displayError(message).slice(0, 4e3), kind);
+  }
+  async function release(owner, ctx) {
+    let report;
+    if (!owner.controller.signal.aborted) {
+      owner.controller.abort(new DOMException("Scope session ended", "AbortError"));
+      report = Promise.resolve().then(() => options.onChange?.(ctx, void 0));
+    }
+    const settled = await Promise.allSettled([owner.flow?.promise, owner.settings.flush(), report, ...owner.checks]);
+    if (settled[1].status === "rejected") throw settled[1].reason;
+    if (settled[2].status === "rejected") throw settled[2].reason;
+  }
+  async function initialize(ctx) {
+    const key = ctx.sessionManager;
+    const token = {};
+    starts.set(key, token);
+    const previous = owners.get(key);
+    const owner = {
+      key,
+      controller: new AbortController(),
+      // Keep the existing settings path so the package rename preserves user preferences.
+      settings: new ScopeSettingsStore(join2(getAgentDir2(), "pi-scope.json")),
+      scope: uninitialized(),
+      revision: 0,
+      checks: /* @__PURE__ */ new Set()
+    };
+    owners.set(key, owner);
+    if (previous) await release(previous, ctx);
+    if (starts.get(key) !== token || !current(owner, ctx)) return;
+    try {
+      owner.scope = restoreScope(ctx.sessionManager.getBranch(), ctx.cwd);
+    } catch {
+      owner.scope = {
+        state: "blocked",
+        error: "Scope restoration failed; edits remain blocked. Use /scope to repair or /scope off to exit."
+      };
+    }
+    if (owner.scope.state === "active") {
+      try {
+        assertUsableLoadout(pi);
+      } catch (error) {
+        owner.scope = { ...owner.scope, state: "blocked", error: displayError(error) };
+      }
+    }
+    try {
+      await owner.settings.load();
+    } catch (error) {
+      if (current(owner, ctx)) notify(ctx, `Scope settings were not loaded: ${displayError(error)}`, "warning");
+    }
+    if (starts.get(key) !== token || !current(owner, ctx)) return;
+    updateView(owner, ctx);
+    if (owner.scope.state === "blocked") notify(ctx, owner.scope.error ?? "Scope restoration failed", "error");
+  }
+  function publish(owner, ctx) {
+    const notice = createScopeNotice(owner.scope);
+    if (!notice) return;
+    try {
+      pi.sendMessage(notice, { triggerTurn: false });
+    } catch (error) {
+      notify(ctx, `Scope is applied, but its model notice needs recovery: ${displayError(error)}`, "warning");
+    }
+  }
+  function commit(owner, ctx, snapshot, flow, signal) {
+    signal?.throwIfAborted();
+    mutationCheck(owner, ctx, flow);
+    owner.scope = { state: "blocked", error: "Scope update is incomplete; edits remain blocked" };
+    owner.revision += 1;
+    if (flow) flow.revision = owner.revision;
+    try {
+      pi.appendEntry(STATE_TYPE, snapshot);
+      check(owner, ctx, flow);
+      const restored = restoreScope(ctx.sessionManager.getBranch(), ctx.cwd);
+      if (restored.state === "blocked" || !sameScope(restored.snapshot, snapshot) || !restored.entryId) {
+        throw new Error("Scope state was not retained by the session");
+      }
+      owner.scope = restored;
+    } catch (error) {
+      if (current(owner, ctx)) {
+        owner.scope = {
+          state: "blocked",
+          error: `Scope state could not be saved; edits remain blocked. Repair with /scope or /scope off. ${displayError(error)}`
+        };
+        updateView(owner, ctx);
+      }
+      throw error;
+    }
+    updateView(owner, ctx);
+    publish(owner, ctx);
+  }
+  async function apply(owner, ctx, targets, flow, newFile = false, operation) {
+    const signal = AbortSignal.any([owner.controller.signal, flow.signal, ...operation ? [operation] : []]);
+    signal.throwIfAborted();
+    mutationCheck(owner, ctx, flow);
+    const proposed = createSnapshot(resolve4(ctx.cwd), targets);
+    const existing = new Set(
+      targets.filter((target) => "exists" in target && target.exists === true).map((target) => target.canonical)
+    );
+    if (newFile && proposed.targets?.length !== 1) throw new Error("New file requires exactly one target");
+    assertUsableLoadout(pi);
+    const checked = [];
+    for (const target of proposed.targets ?? []) {
+      const candidate = await resolveScopeTarget(
+        pathToFileURL2(target.path).href,
+        ctx.cwd,
+        newFile ? "new" : existing.has(target.canonical) ? "existing" : "either",
+        signal
+      );
+      signal.throwIfAborted();
+      mutationCheck(owner, ctx, flow);
+      if (candidate.canonical !== target.canonical)
+        throw new Error(`Scope target changed: ${displayPath(target.path)}; select it again`);
+      checked.push({ path: candidate.path, canonical: candidate.canonical });
+    }
+    assertUsableLoadout(pi);
+    const snapshot = createSnapshot(resolve4(ctx.cwd), checked);
+    createScopeNotice({ state: "active", snapshot, entryId: "preview" });
+    if (owner.scope.state !== "blocked" && sameScope(owner.scope.snapshot, snapshot)) {
+      notify(ctx, "Scope unchanged");
+      return;
+    }
+    commit(owner, ctx, snapshot, flow, signal);
+    notify(ctx, `Editing limited to ${checked.length} file${checked.length === 1 ? "" : "s"}`);
+  }
+  function off(owner, ctx, flow) {
+    mutationCheck(owner, ctx, flow);
+    if (owner.scope.state === "inactive") {
+      notify(ctx, "Scope is already inactive");
+      return;
+    }
+    commit(owner, ctx, createSnapshot(resolve4(ctx.cwd), null), flow);
+    notify(ctx, "Scope restriction ended");
+  }
+  pi.on("session_start", (_event, ctx) => initialize(ctx));
+  pi.on("session_tree", (_event, ctx) => initialize(ctx));
+  pi.on("session_shutdown", async (_event, ctx) => {
+    const key = ctx.sessionManager;
+    starts.delete(key);
+    const owner = owners.get(key);
+    if (!owner) return;
+    try {
+      await release(owner, ctx);
+    } finally {
+      if (owners.get(key) === owner) owners.delete(key);
+    }
+  });
+  pi.on("tool_call", async (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    const scope = owner && current(owner) ? owner.scope : uninitialized();
+    if (scope.state === "inactive") return;
+    const decision = decideTool(event.toolName, pi.getAllTools(), scope);
+    if (decision.kind === "pass") return;
+    if (decision.kind === "block") return { block: true, reason: displayError(decision.reason).slice(0, 4e3) };
+    const revision = owner?.revision;
+    let work;
+    try {
+      const path = event.input && typeof event.input === "object" && "path" in event.input ? event.input.path : void 0;
+      if (!owner || !scope.snapshot?.targets || typeof path !== "string")
+        throw new Error("Invalid Scope write/edit call");
+      check(owner, ctx);
+      const signal = ctx.signal ? AbortSignal.any([owner.controller.signal, ctx.signal]) : owner.controller.signal;
+      work = assertScopeTarget(path, ctx.cwd, scope.snapshot.targets, signal);
+      owner.checks.add(work);
+      await work;
+      check(owner, ctx);
+      if (owner.revision !== revision || owner.scope !== scope)
+        throw new Error("Scope changed while checking this call");
+    } catch (error) {
+      return { block: true, reason: `Scope blocked this edit: ${displayError(error).slice(0, 4e3)}` };
+    } finally {
+      if (work) owner?.checks.delete(work);
+    }
+  });
+  pi.on("context_with_system", (event, ctx) => {
+    const owner = owners.get(ctx.sessionManager);
+    if (!owner || !current(owner, ctx) || ctx.signal?.aborted) return;
+    try {
+      if (owner.scope.state === "active") {
+        try {
+          assertUsableLoadout(pi);
+        } catch (error) {
+          owner.scope = { ...owner.scope, state: "blocked", error: displayError(error) };
+          owner.revision += 1;
+          owner.flow?.controller.abort(new DOMException("Scope tool configuration changed", "AbortError"));
+          updateView(owner, ctx);
+          notify(ctx, owner.scope.error ?? "Scope tool configuration is unsupported", "error");
+        }
+      }
+      const result = reconcileScopeContext(event.messages, ctx.sessionManager.getBranch(), owner.scope);
+      if (result.anchor) {
+        pi.appendEntry(ANCHOR_TYPE, result.anchor);
+        check(owner, ctx);
+      }
+      return { messages: result.messages };
+    } catch (error) {
+      if (!current(owner) || ctx.signal?.aborted) return;
+      owner.scope = {
+        ...owner.scope,
+        state: "blocked",
+        error: "Scope context could not be restored; edits remain blocked. Repair with /scope or /scope off."
+      };
+      owner.revision += 1;
+      owner.flow?.controller.abort(new DOMException("Scope context restoration failed", "AbortError"));
+      updateView(owner, ctx);
+      throw error;
+    }
+  });
+  function getOwner(ctx) {
+    const owner = owners.get(ctx.sessionManager);
+    if (!owner) throw new Error("Scope is not initialized; reload the session first");
+    check(owner, ctx);
+    return owner;
+  }
+  function assertNoFlow(owner) {
+    if (owner.flow) throw new Error("A Scope menu is already open; close it before issuing another Scope command");
+  }
+  const service = {
+    async open(ctx, signal) {
+      if (ctx.mode !== "tui" || !ctx.hasUI) throw new Error("/edit-scope requires Pi TUI mode");
+      const owner = getOwner(ctx);
+      mutationCheck(owner, ctx);
+      assertNoFlow(owner);
+      signal?.throwIfAborted();
+      const controller = new AbortController();
+      const flow = {
+        controller,
+        signal: AbortSignal.any([
+          owner.controller.signal,
+          controller.signal,
+          ...ctx.signal ? [ctx.signal] : [],
+          ...signal ? [signal] : []
+        ]),
+        revision: owner.revision
+      };
+      owner.flow = flow;
+      const menu = {
+        signal: flow.signal,
+        isCurrent: () => current(owner, ctx) && !flow.signal.aborted && owner.flow === flow && owner.revision === flow.revision,
+        getView: () => {
+          check(owner, ctx, flow);
+          return service.getView(ctx);
+        },
+        getSettings: () => {
+          check(owner, ctx, flow);
+          return service.getSettings(ctx);
+        },
+        saveShowHiddenFiles: async (value) => {
+          check(owner, ctx, flow);
+          await service.saveShowHiddenFiles(ctx, value);
+          check(owner, ctx, flow);
+        },
+        apply: (targets, newFile, operation) => {
+          const work = apply(owner, ctx, targets, flow, newFile, operation);
+          owner.checks.add(work);
+          void work.then(
+            () => owner.checks.delete(work),
+            () => owner.checks.delete(work)
+          );
+          return work;
+        },
+        off: async () => off(owner, ctx, flow)
+      };
+      flow.promise = Promise.resolve().then(() => {
+        check(owner, ctx, flow);
+        return show(ctx, menu);
+      });
+      try {
+        await flow.promise;
+        check(owner, ctx, flow);
+      } catch (error) {
+        if (current(owner, ctx)) throw error;
+      } finally {
+        controller.abort(new DOMException("Scope menu closed", "AbortError"));
+        if (owner.flow === flow) owner.flow = void 0;
+      }
+    },
+    off(ctx) {
+      const owner = getOwner(ctx);
+      mutationCheck(owner, ctx);
+      assertNoFlow(owner);
+      off(owner, ctx);
+    },
+    getView(ctx) {
+      return view(getOwner(ctx), ctx);
+    },
+    getSettings(ctx) {
+      return getOwner(ctx).settings.current;
+    },
+    async saveShowHiddenFiles(ctx, value) {
+      const owner = getOwner(ctx);
+      await owner.settings.saveShowHiddenFiles(value);
+      check(owner, ctx);
+    },
+    signal(ctx) {
+      return getOwner(ctx).controller.signal;
+    }
+  };
+  for (const commandName of ["edit-scope", "scope"]) {
+    pi.registerCommand(commandName, {
+      description: commandName === "scope" ? "Compatibility alias for /edit-scope" : "Temporarily restrict editing to selected files",
+      getArgumentCompletions: (prefix) => "off".startsWith(prefix) ? [{ value: "off", label: "off", description: "End the editing restriction" }] : [],
+      handler: async (args, ctx) => {
+        const route = args.trim();
+        if (route !== "" && route !== "off") throw new Error(`Usage: /${commandName} or /${commandName} off`);
+        if (ctx.mode !== "tui" || !ctx.hasUI) throw new Error(`/${commandName} requires Pi TUI mode`);
+        if (route === "off") return service.off(ctx);
+        await service.open(ctx);
+      }
+    });
+  }
+  return service;
+}
+
+// src/files.ts
+async function registerFiles(pi, options = {}) {
+  const flows = /* @__PURE__ */ new Map();
+  const displays = /* @__PURE__ */ new Map();
+  const display = (ctx) => {
+    let state = displays.get(ctx.sessionManager);
+    if (!state) {
+      state = { quotes: [] };
+      displays.set(ctx.sessionManager, state);
+    }
+    return state;
+  };
+  const redraw = (ctx) => {
+    const state = display(ctx);
+    publishFilesWidget(ctx, state.quotes, state.scope);
+  };
+  const runFlow = (ctx, kind, run) => {
+    const key = ctx.sessionManager;
+    const previous = flows.get(key);
+    if (previous) {
+      if (kind === "context" && previous.kind === kind) return previous.promise;
+      throw new Error(
+        kind === "scope" && previous.kind === "scope" ? "A Scope menu is already open; close it before issuing another Scope command" : "A Files menu is already open; close it before opening another file flow"
+      );
+    }
+    const flow = { kind, controller: new AbortController(), promise: Promise.resolve() };
+    const signal = AbortSignal.any([flow.controller.signal, ...ctx.signal ? [ctx.signal] : []]);
+    const scoped = Object.create(ctx);
+    Object.defineProperty(scoped, "signal", { value: signal });
+    flows.set(key, flow);
+    flow.promise = Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return run(scoped);
+    }).finally(() => {
+      if (flows.get(key) === flow) flows.delete(key);
+    });
+    return flow.promise;
+  };
+  const cancelFlow = (ctx) => {
+    const flow = flows.get(ctx.sessionManager);
+    if (!flow) return;
+    flow.controller.abort(new DOMException("Files session or branch changed", "AbortError"));
+    if (flows.get(ctx.sessionManager) === flow) flows.delete(ctx.sessionManager);
+  };
+  pi.on("session_start", (_event, ctx) => cancelFlow(ctx));
+  pi.on("session_tree", (_event, ctx) => cancelFlow(ctx));
+  pi.on("session_shutdown", (_event, ctx) => cancelFlow(ctx));
+  const serviceAPI = {
+    ...pi,
+    registerCommand(name, command) {
+      pi.registerCommand(name, {
+        ...command,
+        handler: (args, ctx) => {
+          const route = name === "file-context" ? args.trim().toLowerCase() : args.trim();
+          const valid = name === "file-context" ? ["", "browse", "remove"].includes(route) : ["", "off"].includes(route);
+          if (!valid || ctx.mode !== "tui") return command.handler(args, ctx);
+          return runFlow(
+            ctx,
+            name === "file-context" ? "context" : "scope",
+            (scoped) => command.handler(args, scoped)
+          );
+        }
+      });
+    },
+    registerShortcut(key, shortcut) {
+      pi.registerShortcut(key, {
+        ...shortcut,
+        handler: (ctx) => runFlow(ctx, "context", (scoped) => shortcut.handler(scoped))
+      });
+    }
+  };
+  const scope = registerScope(serviceAPI, {
+    ...options.scope,
+    onChange: (ctx, state) => {
+      display(ctx).scope = state;
+      redraw(ctx);
+    }
+  });
+  const context = await registerFileContext(serviceAPI, {
+    ...options.context,
+    onChange: (ctx, quotes) => {
+      display(ctx).quotes = quotes;
+      redraw(ctx);
+    }
+  });
+  pi.registerCommand("files", {
+    description: "Browse file context and manage allowed edit targets",
+    getArgumentCompletions: (prefix) => [
+      { value: "browse", label: "browse", description: "Open the context browser" },
+      { value: "off", label: "off", description: "End the editing restriction" }
+    ].filter((item) => item.value.startsWith(prefix)),
+    handler: async (args, ctx) => {
+      const route = args.trim();
+      if (route !== "" && route !== "browse" && route !== "off") throw new Error("Usage: /files [browse|off]");
+      if (ctx.mode !== "tui" || !ctx.hasUI) throw new Error("/files requires Pi TUI mode");
+      await runFlow(ctx, route === "browse" ? "context" : "manager", async (scoped) => {
+        if (route === "browse") return context.browse(scoped);
+        const commandCtx = scoped;
+        if (route === "off") {
+          scope.off(commandCtx);
+          return;
+        }
+        const { showFilesMenu } = await import("./chunks/files-menu-MES4MQ4F.ts");
+        scoped.signal?.throwIfAborted();
+        await showFilesMenu(commandCtx, context, scope);
+      });
+    }
+  });
+  pi.on("session_shutdown", (_event, ctx) => {
+    displays.delete(ctx.sessionManager);
+    if (ctx.hasUI) ctx.ui.setWidget("files", void 0);
+  });
+}
+var files_default = registerFiles;
+export {
+  files_default as default
+};
+//# sourceMappingURL=index.ts.map