@bastani/atomic 0.9.16-alpha.6 → 0.9.16-alpha.8

package/dist/builtin/workflows/builtin/chunk-x2ghn0je.js

@@ -0,0 +1,4110 @@
+import {
+  __require
+} from "./chunk-5wgwscd0.js";
+
+// src/utils/child-process.ts
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "node:child_process";
+import { basename } from "node:path";
+import crossSpawn from "cross-spawn";
+
+// src/utils/agent-attribution.ts
+var ATOMIC_AI_AGENT = "atomic";
+
+// src/utils/child-process.ts
+var EXIT_STDIO_IDLE_GRACE_MS = 100;
+var EXIT_STDIO_ACTIVE_DRAIN_HARD_CAP_MS = 5000;
+var WINDOWS_EXIT_POLL_INTERVAL_MS = 50;
+var WINDOWS_EXIT_CODE_GRACE_MS = 1000;
+function createChildProcessEnvironment(overrides, baseEnv = process.env) {
+  return { ...baseEnv, ...overrides, AI_AGENT: ATOMIC_AI_AGENT };
+}
+var WINDOWS_SHELL_COMMANDS = new Set(["bun", "npm", "npx", "pnpm", "yarn", "yarnpkg", "corepack"]);
+function shouldUseWindowsShell(command) {
+  if (process.platform !== "win32")
+    return false;
+  const commandName = basename(command).toLowerCase();
+  return commandName.endsWith(".cmd") || commandName.endsWith(".bat") || WINDOWS_SHELL_COMMANDS.has(commandName);
+}
+function spawnProcess(command, args, options) {
+  const childOptions = {
+    ...options,
+    env: options.env ? createChildProcessEnvironment(undefined, options.env) : createChildProcessEnvironment()
+  };
+  return process.platform === "win32" ? crossSpawn(command, args, childOptions) : nodeSpawn(command, args, childOptions);
+}
+function spawnProcessSync(command, args, options) {
+  const childOptions = {
+    ...options,
+    env: options.env ? createChildProcessEnvironment(undefined, options.env) : createChildProcessEnvironment()
+  };
+  return process.platform === "win32" ? crossSpawn.sync(command, args, childOptions) : nodeSpawnSync(command, args, childOptions);
+}
+function isWindowsProcessAlive(pid) {
+  const result = nodeSpawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/NH"], {
+    encoding: "utf-8",
+    windowsHide: true,
+    env: createChildProcessEnvironment()
+  });
+  if (result.status !== 0)
+    return true;
+  return new RegExp(`\\b${pid}\\b`).test(result.stdout);
+}
+function waitForChildProcess(child, options = {}) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let exited = false;
+    let exitCode = null;
+    let postExitIdleTimer;
+    let postExitActiveDrainHardCapTimer;
+    let stdoutEnded = child.stdout === null;
+    let stderrEnded = child.stderr === null;
+    let windowsExitPoll;
+    let windowsExitCodeGraceTimer;
+    const platform = options.platform ?? process.platform;
+    const processAlive = options.isWindowsProcessAlive ?? isWindowsProcessAlive;
+    const windowsExitPollIntervalMs = options.windowsExitPollIntervalMs ?? WINDOWS_EXIT_POLL_INTERVAL_MS;
+    const windowsExitCodeGraceMs = options.windowsExitCodeGraceMs ?? WINDOWS_EXIT_CODE_GRACE_MS;
+    const cleanup = () => {
+      if (windowsExitPoll) {
+        clearInterval(windowsExitPoll);
+        windowsExitPoll = undefined;
+      }
+      if (postExitIdleTimer) {
+        clearTimeout(postExitIdleTimer);
+        postExitIdleTimer = undefined;
+      }
+      if (postExitActiveDrainHardCapTimer) {
+        clearTimeout(postExitActiveDrainHardCapTimer);
+        postExitActiveDrainHardCapTimer = undefined;
+      }
+      if (windowsExitCodeGraceTimer) {
+        clearTimeout(windowsExitCodeGraceTimer);
+        windowsExitCodeGraceTimer = undefined;
+      }
+      child.removeListener("error", onError);
+      child.removeListener("exit", onExit);
+      child.removeListener("close", onClose);
+      child.stdout?.removeListener("end", onStdoutEnd);
+      child.stderr?.removeListener("end", onStderrEnd);
+      child.stdout?.removeListener("data", onData);
+      child.stderr?.removeListener("data", onData);
+    };
+    const finalize = (code) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve(code);
+    };
+    const maybeFinalizeAfterExit = () => {
+      if (!exited || settled)
+        return;
+      if (stdoutEnded && stderrEnded) {
+        finalize(exitCode);
+      }
+    };
+    const armIdleTimer = () => {
+      if (postExitIdleTimer)
+        clearTimeout(postExitIdleTimer);
+      postExitIdleTimer = setTimeout(() => finalize(exitCode), EXIT_STDIO_IDLE_GRACE_MS);
+    };
+    const armActiveDrainHardCapTimer = () => {
+      if (postExitActiveDrainHardCapTimer)
+        return;
+      postExitActiveDrainHardCapTimer = setTimeout(() => finalize(exitCode), EXIT_STDIO_ACTIVE_DRAIN_HARD_CAP_MS);
+    };
+    const onData = () => {
+      if (exited && !settled)
+        armIdleTimer();
+    };
+    const onStdoutEnd = () => {
+      stdoutEnded = true;
+      maybeFinalizeAfterExit();
+    };
+    const onStderrEnd = () => {
+      stderrEnded = true;
+      maybeFinalizeAfterExit();
+    };
+    const onError = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const onExit = (code) => {
+      if (windowsExitCodeGraceTimer) {
+        clearTimeout(windowsExitCodeGraceTimer);
+        windowsExitCodeGraceTimer = undefined;
+      }
+      exited = true;
+      exitCode = code;
+      maybeFinalizeAfterExit();
+      if (!settled) {
+        armActiveDrainHardCapTimer();
+        armIdleTimer();
+      }
+    };
+    const armWindowsExitCodeGraceTimer = () => {
+      if (windowsExitCodeGraceTimer)
+        return;
+      if (windowsExitPoll) {
+        clearInterval(windowsExitPoll);
+        windowsExitPoll = undefined;
+      }
+      windowsExitCodeGraceTimer = setTimeout(() => {
+        windowsExitCodeGraceTimer = undefined;
+        onExit(child.exitCode ?? 0);
+      }, windowsExitCodeGraceMs);
+    };
+    const pollWindowsExit = () => {
+      if (platform !== "win32" || !child.pid || exited || settled)
+        return;
+      if (!processAlive(child.pid)) {
+        if (child.exitCode !== null) {
+          onExit(child.exitCode);
+        } else {
+          armWindowsExitCodeGraceTimer();
+        }
+      }
+    };
+    const onClose = (code) => {
+      finalize(code);
+    };
+    if (platform === "win32" && child.pid) {
+      windowsExitPoll = setInterval(pollWindowsExit, windowsExitPollIntervalMs);
+    }
+    child.stdout?.once("end", onStdoutEnd);
+    child.stderr?.once("end", onStderrEnd);
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.once("error", onError);
+    child.once("exit", onExit);
+    child.once("close", onClose);
+  });
+}
+
+// src/utils/paths.ts
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve as nodeResolvePath, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function getHomeDir() {
+  if (process.platform === "win32") {
+    if (process.env.USERPROFILE)
+      return process.env.USERPROFILE;
+    if (process.env.HOMEDRIVE && process.env.HOMEPATH)
+      return `${process.env.HOMEDRIVE}${process.env.HOMEPATH}`;
+    if (process.env.HOME)
+      return process.env.HOME;
+    return homedir();
+  }
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+function canonicalizePath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function isLocalPath(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("npm:") || trimmed.startsWith("git:") || trimmed.startsWith("github:") || trimmed.startsWith("http:") || trimmed.startsWith("https:") || trimmed.startsWith("ssh:")) {
+    return false;
+  }
+  return true;
+}
+function normalizeWindowsShellPath(filePath) {
+  if (!filePath.startsWith("/") || filePath.startsWith("//") || filePath.includes("\\"))
+    return filePath;
+  const match = filePath.match(/^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i);
+  if (!match)
+    return filePath;
+  const suffix = match[2]?.replaceAll("/", "\\");
+  return `${match[1].toUpperCase()}:\\${suffix ?? ""}`;
+}
+function normalizePath(input, options = {}) {
+  let normalized = options.trim ? input.trim() : input;
+  if (options.normalizeUnicodeSpaces) {
+    normalized = normalized.replace(UNICODE_SPACES, " ");
+  }
+  if (options.stripAtPrefix && normalized.startsWith("@")) {
+    normalized = normalized.slice(1);
+  }
+  if (process.platform === "win32") {
+    normalized = normalizeWindowsShellPath(normalized);
+  }
+  if (options.expandTilde ?? true) {
+    const home = options.homeDir ?? getHomeDir();
+    if (normalized === "~")
+      return home;
+    if (normalized.startsWith("~/") || process.platform === "win32" && normalized.startsWith("~\\")) {
+      return join(home, normalized.slice(2));
+    }
+  }
+  if (/^file:\/\//.test(normalized)) {
+    decodeURI(normalized);
+    return fileURLToPath(normalized);
+  }
+  return normalized;
+}
+function resolvePath(input, baseDir = process.cwd(), options = {}) {
+  const normalized = normalizePath(input, options);
+  const normalizedBaseDir = normalizePath(baseDir);
+  return isAbsolute(normalized) ? nodeResolvePath(normalized) : nodeResolvePath(normalizedBaseDir, normalized);
+}
+function getCwdRelativePath(filePath, cwd) {
+  const resolvedCwd = resolvePath(cwd);
+  const resolvedPath = resolvePath(filePath, resolvedCwd);
+  const relativePath = relative(resolvedCwd, resolvedPath);
+  const isInsideCwd = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+  return isInsideCwd ? relativePath || "." : undefined;
+}
+function formatPathRelativeToCwdOrAbsolute(filePath, cwd) {
+  const absolutePath = resolvePath(filePath, cwd);
+  return (getCwdRelativePath(absolutePath, cwd) ?? absolutePath).split(sep).join("/");
+}
+function markPathIgnoredByCloudSync(path) {
+  const attrs = process.platform === "darwin" ? ["com.dropbox.ignored", "com.apple.fileprovider.ignore#P"] : process.platform === "linux" ? ["user.com.dropbox.ignored"] : [];
+  for (const attr of attrs) {
+    if (process.platform === "darwin") {
+      spawnProcessSync("xattr", ["-w", attr, "1", path], { encoding: "utf-8", stdio: "ignore" });
+    } else {
+      spawnProcessSync("setfattr", ["-n", attr, "-v", "1", path], { encoding: "utf-8", stdio: "ignore" });
+    }
+  }
+}
+
+// src/config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname4, join as join5, resolve as resolve2 } from "path";
+
+// src/config-package-identity.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+
+// src/core/builtin-install-layout.ts
+var BUILTIN_PACKAGE_DIR_NAMES = ["workflows", "subagents", "mcp", "web-access", "intercom"];
+var SOURCE_EXTENSION_ENTRIES = {
+  workflows: "src/extension/index.ts",
+  subagents: "src/extension/index.ts",
+  mcp: "index.ts",
+  "web-access": "index.ts",
+  intercom: "index.ts"
+};
+var INSTALLED_EXTENSION_ENTRIES = {
+  workflows: "src/extension/index.bundle.mjs",
+  subagents: "src/extension/index.bundle.mjs",
+  mcp: "index.bundle.mjs",
+  "web-access": "index.bundle.mjs",
+  intercom: "index.bundle.mjs"
+};
+function requiredEntriesForBuiltin(dirName) {
+  return [INSTALLED_EXTENSION_ENTRIES[dirName], SOURCE_EXTENSION_ENTRIES[dirName]];
+}
+
+// src/utils/text.ts
+function splitBom(content) {
+  return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+function stripBom(content) {
+  return splitBom(content).text;
+}
+
+// src/config-package-identity.ts
+var COMPANION_BUILTIN_PACKAGE_NAMES = BUILTIN_PACKAGE_DIR_NAMES.map((dirName) => `@bastani/${dirName}`);
+function isCompanionBuiltinPackageName(name) {
+  return name !== undefined && COMPANION_BUILTIN_PACKAGE_NAMES.includes(name);
+}
+function packageJsonDefinesAppIdentity(pkg) {
+  if (pkg.name === "@bastani/atomic" || pkg.name === "@mariozechner/pi")
+    return true;
+  return pkg.atomicConfig !== undefined || pkg.piConfig !== undefined;
+}
+function resolvePackageDirFrom(startDir) {
+  let dir = startDir;
+  let firstPackageDir;
+  while (dir !== dirname(dir)) {
+    const packageJsonPath = join2(dir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      firstPackageDir ??= dir;
+      if (shouldUsePackageDir(readPackageIdentity(packageJsonPath))) {
+        return dir;
+      }
+    }
+    dir = dirname(dir);
+  }
+  return firstPackageDir ?? startDir;
+}
+function shouldUsePackageDir(pkg) {
+  if (packageJsonDefinesAppIdentity(pkg))
+    return true;
+  return !isCompanionBuiltinPackageName(pkg.name);
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  if (Array.isArray(value))
+    return value.every(isJsonValue);
+  if (typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype)
+    return false;
+  return Object.values(value).every(isJsonValue);
+}
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readPackageIdentity(packageJsonPath) {
+  try {
+    const parsed = JSON.parse(stripBom(readFileSync(packageJsonPath, "utf-8")));
+    if (!isJsonValue(parsed) || !isJsonObject(parsed))
+      return {};
+    const name = parsed.name;
+    const atomicConfig = parsed.atomicConfig;
+    const piConfig = parsed.piConfig;
+    return {
+      ...typeof name === "string" ? { name } : {},
+      ...atomicConfig !== undefined && isJsonObject(atomicConfig) ? { atomicConfig } : {},
+      ...piConfig !== undefined && isJsonObject(piConfig) ? { piConfig } : {}
+    };
+  } catch {}
+  return {};
+}
+
+// src/utils/split-launcher.ts
+import { dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function isSplitLauncherRuntime() {
+  return process.env.ATOMIC_CODING_AGENT === "true" && /(?:^|[\\/])atomic(?:\.exe)?$/i.test(process.execPath);
+}
+function splitLauncherDir() {
+  return dirname2(process.execPath);
+}
+function moduleDirFromMetaUrl(metaUrl, ...execRelativeSegments) {
+  try {
+    return dirname2(fileURLToPath2(metaUrl));
+  } catch (error) {
+    if (isSplitLauncherRuntime())
+      return join3(splitLauncherDir(), ...execRelativeSegments);
+    throw error;
+  }
+}
+function moduleFileFromMetaUrl(metaUrl, execRelativeFile) {
+  try {
+    return fileURLToPath2(metaUrl);
+  } catch (error) {
+    if (isSplitLauncherRuntime())
+      return join3(splitLauncherDir(), execRelativeFile);
+    throw error;
+  }
+}
+
+// src/config-self-update.ts
+import { accessSync, constants, existsSync as existsSync2, realpathSync as realpathSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, dirname as dirname3, join as join4, resolve, sep as sep2, win32 } from "path";
+function normalizeSelfUpdateTarget(target) {
+  if (typeof target === "string")
+    return { packageName: target, installSpec: target };
+  return { packageName: target.packageName, installSpec: target.installSpec ?? target.packageName };
+}
+function makeSelfUpdateCommand(installStep, uninstallStep) {
+  if (!uninstallStep)
+    return installStep;
+  return {
+    ...installStep,
+    display: `${uninstallStep.display} && ${installStep.display}`,
+    steps: [uninstallStep, installStep]
+  };
+}
+function makeSelfUpdateCommandStep(command, args) {
+  return {
+    command,
+    args,
+    display: [command, ...args].map((arg) => /\s/.test(arg) ? `"${arg}"` : arg).join(" ")
+  };
+}
+function detectInstallMethodForRuntime(runtime) {
+  if (runtime.isBunBinary) {
+    return "bun-binary";
+  }
+  const resolvedPath = `${runtime.moduleDir}\x00${process.execPath || ""}`.toLowerCase().replace(/\\/g, "/");
+  if (resolvedPath.includes("/pnpm/") || resolvedPath.includes("/.pnpm/")) {
+    return "pnpm";
+  }
+  if (resolvedPath.includes("/yarn/") || resolvedPath.includes("/.yarn/")) {
+    return "yarn";
+  }
+  if (resolvedPath.includes("/install/global/node_modules/")) {
+    return "bun";
+  }
+  if (resolvedPath.includes("/npm/") || resolvedPath.includes("/node_modules/")) {
+    return "npm";
+  }
+  return "unknown";
+}
+function getInferredNpmInstall(runtime) {
+  const packageDir = runtime.getPackageDir();
+  const path = process.platform === "win32" || packageDir.includes("\\") ? win32 : { basename: basename2, dirname: dirname3 };
+  const parent = path.dirname(packageDir);
+  let root;
+  if (path.basename(parent).startsWith("@") && path.basename(path.dirname(parent)) === "node_modules") {
+    root = path.dirname(parent);
+  } else if (path.basename(parent) === "node_modules") {
+    root = parent;
+  }
+  if (!root)
+    return;
+  const rootParent = path.dirname(root);
+  if (path.basename(rootParent) === "lib")
+    return { root, prefix: path.dirname(rootParent) };
+  return;
+}
+function getSelfUpdateCommandForMethod(runtime, method, installedPackageName, updatePackageName = installedPackageName, npmCommand, installSpec = updatePackageName) {
+  switch (method) {
+    case "bun-binary":
+      return;
+    case "pnpm": {
+      const match = readCommandOutput("pnpm", ["root", "-g"]) ? undefined : /^(.*[\\/]global[\\/][^\\/]+)[\\/]\.pnpm[\\/]/.exec(runtime.getPackageDir());
+      const binDirArgs = match ? [`--config.global-bin-dir=${process.env.PNPM_HOME || dirname3(dirname3(match[1]))}`] : [];
+      return makeSelfUpdateCommand(makeSelfUpdateCommandStep("pnpm", [
+        "install",
+        "-g",
+        "--ignore-scripts",
+        "--config.minimumReleaseAge=0",
+        ...binDirArgs,
+        installSpec
+      ]), updatePackageName === installedPackageName ? undefined : makeSelfUpdateCommandStep("pnpm", ["remove", "-g", ...binDirArgs, installedPackageName]));
+    }
+    case "yarn":
+      return makeSelfUpdateCommand(makeSelfUpdateCommandStep("yarn", ["global", "add", "--ignore-scripts", installSpec]), updatePackageName === installedPackageName ? undefined : makeSelfUpdateCommandStep("yarn", ["global", "remove", installedPackageName]));
+    case "bun":
+      return makeSelfUpdateCommand(makeSelfUpdateCommandStep("bun", [
+        "install",
+        "-g",
+        "--ignore-scripts",
+        "--minimum-release-age=0",
+        installSpec
+      ]), updatePackageName === installedPackageName ? undefined : makeSelfUpdateCommandStep("bun", ["uninstall", "-g", installedPackageName]));
+    case "npm": {
+      const [command = "npm", ...npmArgs] = npmCommand ?? [];
+      const inferred = npmCommand?.length ? undefined : getInferredNpmInstall(runtime);
+      const prefixArgs = [...npmArgs, ...inferred ? ["--prefix", inferred.prefix] : []];
+      const installStep = makeSelfUpdateCommandStep(command, [
+        ...prefixArgs,
+        "install",
+        "-g",
+        "--ignore-scripts",
+        "--min-release-age=0",
+        installSpec
+      ]);
+      const uninstallStep = updatePackageName === installedPackageName ? undefined : makeSelfUpdateCommandStep(command, [...prefixArgs, "uninstall", "-g", installedPackageName]);
+      return makeSelfUpdateCommand(installStep, uninstallStep);
+    }
+    case "unknown":
+      return;
+  }
+}
+function readCommandOutput(command, args, options = {}) {
+  const result = spawnProcessSync(command, args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env,
+    shell: shouldUseWindowsShell(command)
+  });
+  if (result.status === 0)
+    return result.stdout.trim() || undefined;
+  if (options.requireSuccess) {
+    const reason = result.error?.message || result.stderr.trim() || `exit code ${result.status ?? "unknown"}`;
+    throw new Error(`Failed to run ${[command, ...args].join(" ")}: ${reason}`);
+  }
+  return;
+}
+function getGlobalPackageRoots(runtime, method, _packageName, npmCommand) {
+  switch (method) {
+    case "npm": {
+      const configured = !!npmCommand?.length;
+      const [command = "npm", ...npmArgs] = npmCommand ?? [];
+      if (configured && command === "bun") {
+        const bunBin = readCommandOutput(command, [...npmArgs, "pm", "bin", "-g"], {
+          requireSuccess: true
+        });
+        const roots = [join4(homedir2(), ".bun", "install", "global", "node_modules")];
+        if (bunBin) {
+          roots.push(join4(dirname3(bunBin), "install", "global", "node_modules"));
+        }
+        return roots;
+      }
+      const root = readCommandOutput(command, [...npmArgs, "root", "-g"], {
+        requireSuccess: configured
+      });
+      const inferred = configured ? undefined : getInferredNpmInstall(runtime);
+      return [root, inferred?.root].filter((x) => !!x);
+    }
+    case "pnpm": {
+      const root = readCommandOutput("pnpm", ["root", "-g"]);
+      if (root)
+        return [root, dirname3(root)];
+      const match = /^(.*[\\/]global[\\/][^\\/]+)[\\/]\.pnpm[\\/]/.exec(runtime.getPackageDir());
+      return match ? [match[1]] : [];
+    }
+    case "yarn": {
+      const dir = readCommandOutput("yarn", ["global", "dir"]);
+      return dir ? [dir, join4(dir, "node_modules")] : [];
+    }
+    case "bun": {
+      const bunBin = readCommandOutput("bun", ["pm", "bin", "-g"]);
+      const roots = [join4(homedir2(), ".bun", "install", "global", "node_modules")];
+      if (bunBin) {
+        roots.push(join4(dirname3(bunBin), "install", "global", "node_modules"));
+      }
+      return roots;
+    }
+    case "bun-binary":
+    case "unknown":
+      return [];
+  }
+}
+function normalizeExistingPathForComparison(path, resolveSymlinks) {
+  const resolvedPath = resolve(path);
+  if (!existsSync2(resolvedPath)) {
+    return;
+  }
+  let normalizedPath = resolvedPath;
+  if (resolveSymlinks) {
+    try {
+      normalizedPath = realpathSync2(resolvedPath);
+    } catch {
+      return;
+    }
+  }
+  if (process.platform === "win32") {
+    normalizedPath = normalizedPath.toLowerCase();
+  }
+  return normalizedPath;
+}
+function getPathComparisonCandidates(path) {
+  return Array.from(new Set([normalizeExistingPathForComparison(path, false), normalizeExistingPathForComparison(path, true)].filter((candidate) => !!candidate)));
+}
+function getEntrypointPackageDir() {
+  const entrypoint = process.argv[1];
+  if (!entrypoint)
+    return;
+  let dir = dirname3(entrypoint);
+  while (dir !== dirname3(dir)) {
+    if (existsSync2(join4(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname3(dir);
+  }
+  return;
+}
+function isSelfUpdatePathWritable(runtime) {
+  const packageDir = runtime.getPackageDir();
+  try {
+    accessSync(packageDir, constants.W_OK);
+    accessSync(dirname3(packageDir), constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isManagedByGlobalPackageManager(runtime, method, packageName, npmCommand) {
+  const packageDirs = [runtime.getPackageDir(), getEntrypointPackageDir()].filter((dir) => !!dir);
+  const packageDirCandidates = packageDirs.flatMap((dir) => getPathComparisonCandidates(dir));
+  return getGlobalPackageRoots(runtime, method, packageName, npmCommand).some((root) => {
+    return getPathComparisonCandidates(root).some((normalizedRoot) => {
+      const rootPrefix = normalizedRoot.endsWith(sep2) ? normalizedRoot : `${normalizedRoot}${sep2}`;
+      return packageDirCandidates.some((packageDir) => packageDir.startsWith(rootPrefix));
+    });
+  });
+}
+function getSelfUpdateCommandForRuntime(runtime, packageName, npmCommand, updateTarget = packageName) {
+  const method = detectInstallMethodForRuntime(runtime);
+  const target = normalizeSelfUpdateTarget(updateTarget);
+  const command = getSelfUpdateCommandForMethod(runtime, method, packageName, target.packageName, npmCommand, target.installSpec);
+  if (!command || !isManagedByGlobalPackageManager(runtime, method, packageName, npmCommand) || !isSelfUpdatePathWritable(runtime)) {
+    return;
+  }
+  return command;
+}
+function getSelfUpdateUnavailableInstructionForRuntime(runtime, packageName, npmCommand, updateTarget = packageName) {
+  const method = detectInstallMethodForRuntime(runtime);
+  if (method === "bun-binary") {
+    return `Download from: https://github.com/bastani-inc/atomic/releases/latest`;
+  }
+  const target = normalizeSelfUpdateTarget(updateTarget);
+  const command = getSelfUpdateCommandForMethod(runtime, method, packageName, target.packageName, npmCommand, target.installSpec);
+  if (command) {
+    if (isManagedByGlobalPackageManager(runtime, method, packageName, npmCommand) && !isSelfUpdatePathWritable(runtime)) {
+      return `This installation is managed by a global ${method} install, but the install path is not writable. Update it yourself with: ${command.display}`;
+    }
+    return `This installation is not managed by a global ${method} install. Update it with the package manager, wrapper, or source checkout that provides it.`;
+  }
+  return `Update ${target.installSpec} using the package manager, wrapper, or source checkout that provides this installation.`;
+}
+
+// src/config.ts
+var __filename2 = moduleFileFromMetaUrl(import.meta.url, "app.js");
+var __dirname2 = dirname4(__filename2);
+var bunFsMarkers = ["$bunfs", "~BUN", "%7EBUN"];
+var isBunBinary = isSplitLauncherRuntime() || [import.meta.url, process.argv[1] ?? ""].some((candidate) => bunFsMarkers.some((marker) => candidate.includes(marker)));
+var isBundledBuild = process.env.ATOMIC_BUNDLED_BUILD === "1";
+var isBunRuntime = !!process.versions.bun;
+function selfUpdateRuntime() {
+  return {
+    isBunBinary,
+    isBunRuntime,
+    moduleDir: __dirname2,
+    getPackageDir
+  };
+}
+function detectInstallMethod() {
+  return detectInstallMethodForRuntime(selfUpdateRuntime());
+}
+function getSelfUpdateCommand(packageName, npmCommand, updateTarget = { packageName, installSpec: packageName }) {
+  return getSelfUpdateCommandForRuntime(selfUpdateRuntime(), packageName, npmCommand, updateTarget);
+}
+function getSelfUpdateUnavailableInstruction(packageName, npmCommand, updateTarget = { packageName, installSpec: packageName }) {
+  return getSelfUpdateUnavailableInstructionForRuntime(selfUpdateRuntime(), packageName, npmCommand, updateTarget);
+}
+function getPackageDir() {
+  const envDir = process.env.ATOMIC_PACKAGE_DIR ?? process.env.PI_PACKAGE_DIR;
+  if (envDir) {
+    return normalizePath(envDir);
+  }
+  if (isBunBinary) {
+    return dirname4(process.execPath);
+  }
+  return resolvePackageDirFrom(__dirname2);
+}
+function getModuleAssetRoot() {
+  const hasPackageDirOverride = !!(process.env.ATOMIC_PACKAGE_DIR || process.env.PI_PACKAGE_DIR);
+  if (!isBundledBuild && !hasPackageDirOverride) {
+    return __dirname2;
+  }
+  const packageDir = getPackageDir();
+  return join5(packageDir, existsSync3(join5(packageDir, "src")) ? "src" : "dist");
+}
+function getThemesDir() {
+  if (isBunBinary) {
+    return join5(getPackageDir(), "theme");
+  }
+  return join5(getModuleAssetRoot(), "modes", "interactive", "theme");
+}
+function getExportTemplateDir() {
+  if (isBunBinary) {
+    return join5(getPackageDir(), "export-html");
+  }
+  return join5(getModuleAssetRoot(), "core", "export-html");
+}
+function getPackageJsonPath() {
+  return join5(getPackageDir(), "package.json");
+}
+function getReadmePath() {
+  return resolve2(join5(getPackageDir(), "README.md"));
+}
+function getDocsPath() {
+  return resolve2(join5(getPackageDir(), "docs"));
+}
+function getExamplesPath() {
+  return resolve2(join5(getPackageDir(), "examples"));
+}
+function getChangelogPath() {
+  return resolve2(join5(getPackageDir(), "CHANGELOG.md"));
+}
+function getInteractiveAssetsDir() {
+  if (isBunBinary) {
+    return join5(getPackageDir(), "assets");
+  }
+  return join5(getModuleAssetRoot(), "modes", "interactive", "assets");
+}
+function getBundledInteractiveAssetPath(name) {
+  return join5(getInteractiveAssetsDir(), name);
+}
+var pkg = {};
+try {
+  pkg = JSON.parse(stripBom(readFileSync2(getPackageJsonPath(), "utf-8")));
+} catch (e) {
+  const err = e;
+  if (err.code !== "ENOENT")
+    throw e;
+}
+function appNameFromPackageName(packageName) {
+  const localName = packageName?.split("/").pop()?.trim();
+  return localName && localName.length > 0 ? localName : undefined;
+}
+function readAppConfig(packageJson, appName) {
+  if (appName) {
+    const appConfig = packageJson[`${appName}Config`];
+    if (appConfig && typeof appConfig === "object" && !Array.isArray(appConfig)) {
+      return appConfig;
+    }
+  }
+  return packageJson.piConfig;
+}
+var PACKAGE_NAME = pkg.name || "@bastani/atomic";
+var packageAppName = appNameFromPackageName(PACKAGE_NAME);
+var appConfig = readAppConfig(pkg, packageAppName);
+var APP_NAME = appConfig?.name || packageAppName || "pi";
+var APP_TITLE = appConfig?.name !== undefined || APP_NAME !== "pi" ? APP_NAME : "π";
+var CONFIG_DIR_NAME = appConfig?.configDir || (APP_NAME === "pi" ? ".pi" : `.${APP_NAME}`);
+var LEGACY_CONFIG_DIR_NAME = ".pi";
+var CONFIG_DIR_NAMES = CONFIG_DIR_NAME === LEGACY_CONFIG_DIR_NAME ? [CONFIG_DIR_NAME] : [CONFIG_DIR_NAME, LEGACY_CONFIG_DIR_NAME];
+var VERSION = pkg.version || "0.0.0";
+var CHANGELOG_URL = appConfig?.changelogUrl?.trim() || undefined;
+var ENV_PREFIX = APP_NAME.toUpperCase();
+var LEGACY_ENV_PREFIX = "PI";
+var ENV_AGENT_DIR = `${ENV_PREFIX}_CODING_AGENT_DIR`;
+var ENV_SESSION_DIR = `${ENV_PREFIX}_CODING_AGENT_SESSION_DIR`;
+var ENV_PACKAGE_DIR = `${ENV_PREFIX}_PACKAGE_DIR`;
+var ENV_OFFLINE = `${ENV_PREFIX}_OFFLINE`;
+var ENV_SKIP_VERSION_CHECK = `${ENV_PREFIX}_SKIP_VERSION_CHECK`;
+var ENV_STARTUP_BENCHMARK = `${ENV_PREFIX}_STARTUP_BENCHMARK`;
+var ENV_TELEMETRY = `${ENV_PREFIX}_TELEMETRY`;
+var ENV_SHARE_VIEWER_URL = `${ENV_PREFIX}_SHARE_VIEWER_URL`;
+var ENV_CLEAR_ON_SHRINK = `${ENV_PREFIX}_CLEAR_ON_SHRINK`;
+var ENV_HARDWARE_CURSOR = `${ENV_PREFIX}_HARDWARE_CURSOR`;
+var ENV_TIMING = `${ENV_PREFIX}_TIMING`;
+var ENV_CODEX_FAST_MODE = `${ENV_PREFIX}_CODEX_FAST_MODE`;
+var WORKFLOW_STAGE_SUBAGENT_GUARD_ENV = `${ENV_PREFIX}_WORKFLOW_STAGE_SUBAGENT_GUARD`;
+function parseCodexFastModeEnvBoolean(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "1":
+    case "true":
+    case "enabled":
+    case "on":
+      return true;
+    case "0":
+    case "false":
+    case "disabled":
+    case "off":
+      return false;
+    default:
+      return;
+  }
+}
+function serializeCodexFastModeEnvironmentSettings(settings) {
+  return `chat=${settings.chat ? "1" : "0"};workflow=${settings.workflow ? "1" : "0"}`;
+}
+function parseCodexFastModeEnvironmentSettings(value) {
+  if (!value)
+    return;
+  const settings = {};
+  for (const part of value.split(/[;,]/)) {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1)
+      continue;
+    const key = part.slice(0, separatorIndex).trim();
+    const parsedValue = parseCodexFastModeEnvBoolean(part.slice(separatorIndex + 1));
+    if (parsedValue === undefined)
+      continue;
+    if (key === "chat")
+      settings.chat = parsedValue;
+    if (key === "workflow")
+      settings.workflow = parsedValue;
+  }
+  return settings.chat !== undefined || settings.workflow !== undefined ? settings : undefined;
+}
+function getCodexFastModeEnvironmentSettings() {
+  return parseCodexFastModeEnvironmentSettings(getEnvValue(ENV_CODEX_FAST_MODE));
+}
+function setCodexFastModeEnvironmentSettings(settings) {
+  setEnvValue(ENV_CODEX_FAST_MODE, serializeCodexFastModeEnvironmentSettings(settings));
+}
+function getEnvNames(name) {
+  if (ENV_PREFIX === LEGACY_ENV_PREFIX || !name.startsWith(`${ENV_PREFIX}_`))
+    return [name];
+  return [name, `${LEGACY_ENV_PREFIX}_${name.slice(ENV_PREFIX.length + 1)}`];
+}
+function getEnvValue(name) {
+  for (const candidate of getEnvNames(name)) {
+    const value = process.env[candidate];
+    if (value !== undefined)
+      return value;
+  }
+  return;
+}
+function hasEnvValue(name) {
+  return getEnvValue(name) !== undefined;
+}
+function setEnvValue(name, value) {
+  process.env[name] = value;
+}
+function expandTildePath(path) {
+  return normalizePath(path);
+}
+var DEFAULT_SHARE_VIEWER_URL = "https://pi.dev/session/";
+function getShareViewerUrl(gistId) {
+  const baseUrl = getEnvValue(ENV_SHARE_VIEWER_URL) || DEFAULT_SHARE_VIEWER_URL;
+  return `${baseUrl}#${gistId}`;
+}
+function getAgentDir() {
+  const envDir = getEnvValue(ENV_AGENT_DIR);
+  if (envDir) {
+    return expandTildePath(envDir);
+  }
+  return join5(getHomeDir(), CONFIG_DIR_NAME, "agent");
+}
+function getLegacyAgentDir() {
+  return join5(getHomeDir(), LEGACY_CONFIG_DIR_NAME, "agent");
+}
+function getAgentDirs() {
+  const primary = getAgentDir();
+  if (hasEnvValue(ENV_AGENT_DIR) || CONFIG_DIR_NAME === LEGACY_CONFIG_DIR_NAME) {
+    return [primary];
+  }
+  const legacy = getLegacyAgentDir();
+  return legacy === primary ? [primary] : [primary, legacy];
+}
+function getUserConfigDirs() {
+  return CONFIG_DIR_NAMES.map((name) => join5(getHomeDir(), name));
+}
+function getProjectConfigDirs(cwd) {
+  return CONFIG_DIR_NAMES.map((name) => join5(cwd, name));
+}
+function getUserConfigPaths(...segments) {
+  return getUserConfigDirs().map((dir) => join5(dir, ...segments));
+}
+function getAgentConfigPaths(...segments) {
+  return getAgentDirs().map((dir) => join5(dir, ...segments));
+}
+function getProjectConfigPaths(cwd, ...segments) {
+  return getProjectConfigDirs(cwd).map((dir) => join5(dir, ...segments));
+}
+function getCustomThemesDir() {
+  return join5(getAgentDir(), "themes");
+}
+function getAuthPath() {
+  return join5(getAgentDir(), "auth.json");
+}
+function getSettingsPath() {
+  return join5(getAgentDir(), "settings.json");
+}
+function getBinDir() {
+  return join5(getAgentDir(), "bin");
+}
+function getExtensionTranspileCacheDir() {
+  return join5(getAgentDir(), "cache", "jiti", VERSION);
+}
+function getSessionsDir() {
+  return join5(getAgentDir(), "sessions");
+}
+function getDebugLogPath() {
+  return join5(getAgentDir(), `${APP_NAME}-debug.log`);
+}
+
+// src/core/messages.ts
+var BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
+
+<summary>
+`;
+var BRANCH_SUMMARY_SUFFIX = `</summary>`;
+function normalizeMessageContent(message) {
+  switch (message.role) {
+    case "user":
+    case "assistant":
+    case "toolResult":
+    case "custom":
+      return message.content == null ? { ...message, content: [] } : message;
+    default:
+      return message;
+  }
+}
+function userLikeContentBlockIsLlmVisible(block) {
+  if (!block || typeof block !== "object")
+    return false;
+  const candidate = block;
+  if (candidate.type === "image")
+    return true;
+  if (candidate.type === "text")
+    return typeof candidate.text === "string" && candidate.text.trim().length > 0;
+  return typeof candidate.type === "string" && candidate.type.trim().length > 0;
+}
+function userLikeContentIsLlmVisible(content, deletedBlockIndexes = new Set) {
+  if (typeof content === "string")
+    return content.trim().length > 0;
+  if (!Array.isArray(content))
+    return false;
+  return content.some((block, index) => !deletedBlockIndexes.has(index) && userLikeContentBlockIsLlmVisible(block));
+}
+function messageStartsLlmUserTurn(message, deletedBlockIndexes = new Set) {
+  switch (message.role) {
+    case "user":
+      return userLikeContentIsLlmVisible(message.content, deletedBlockIndexes);
+    case "custom":
+      return message.excludeFromContext !== true && userLikeContentIsLlmVisible(message.content, deletedBlockIndexes);
+    case "branchSummary":
+      return typeof message.summary === "string" && message.summary.length > 0;
+    case "bashExecution":
+      return message.excludeFromContext !== true;
+    default:
+      return false;
+  }
+}
+function messageIsLlmVisible(message, deletedBlockIndexes = new Set) {
+  if (message.role === "assistant" || message.role === "toolResult")
+    return true;
+  return messageStartsLlmUserTurn(message, deletedBlockIndexes);
+}
+function filterUserLikeContentBlocks(content) {
+  return content.filter(userLikeContentBlockIsLlmVisible);
+}
+function normalizeRawRedactedThinking(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.content))
+    return message;
+  let changed = false;
+  const content = message.content.map((block) => {
+    if (!block || typeof block !== "object")
+      return block;
+    const candidate = block;
+    if (candidate.type !== "redacted_thinking" || typeof candidate.data !== "string")
+      return block;
+    changed = true;
+    return {
+      type: "thinking",
+      thinking: "",
+      thinkingSignature: candidate.data,
+      redacted: true
+    };
+  });
+  return changed ? { ...message, content } : message;
+}
+function bashExecutionToText(msg) {
+  let text = `Ran \`${msg.command}\`
+`;
+  if (msg.output) {
+    text += `\`\`\`
+${msg.output}
+\`\`\``;
+  } else {
+    text += "(no output)";
+  }
+  if (msg.cancelled) {
+    text += `
+
+(command cancelled)`;
+  } else if (msg.exitCode !== null && msg.exitCode !== undefined && msg.exitCode !== 0) {
+    text += `
+
+Command exited with code ${msg.exitCode}`;
+  }
+  if (msg.truncated && msg.fullOutputPath) {
+    text += `
+
+[Output truncated. Full output: ${msg.fullOutputPath}]`;
+  }
+  return text;
+}
+var VERBATIM_COMPACTION_PREFIX = `The earlier conversation was compacted. Below is the verbatim transcript of the retained lines; elided spans are marked "(filtered N lines)".
+
+`;
+var verbatimCompactionMessages = new WeakSet;
+function isVerbatimCompactionMessage(message) {
+  return verbatimCompactionMessages.has(message);
+}
+function createVerbatimCompactionMessage(compactedText, tokensBefore, timestamp, details, retainedTail) {
+  const content = [{ type: "text", text: VERBATIM_COMPACTION_PREFIX + compactedText }];
+  for (const block of retainedTail ?? []) {
+    const last = content[content.length - 1];
+    if (block.type === "text" && last.type === "text")
+      last.text += block.text;
+    else
+      content.push({ ...block });
+  }
+  const message = createCustomMessage("compaction", content, true, details ?? { tokensBefore }, timestamp);
+  verbatimCompactionMessages.add(message);
+  return message;
+}
+function createBranchSummaryMessage(summary, fromId, timestamp) {
+  return {
+    role: "branchSummary",
+    summary,
+    fromId,
+    timestamp: new Date(timestamp).getTime()
+  };
+}
+function createCustomMessage(customType, content, display, details, timestamp, excludeFromContext, stageAdmissionKey) {
+  const message = {
+    role: "custom",
+    customType,
+    content: content ?? [],
+    display,
+    details,
+    ...stageAdmissionKey === undefined ? {} : { stageAdmissionKey },
+    timestamp: new Date(timestamp).getTime()
+  };
+  if (excludeFromContext === true)
+    message.excludeFromContext = true;
+  return message;
+}
+function collectAssistantToolCalls(message) {
+  const content = message.content;
+  const calls = [];
+  if (!Array.isArray(content))
+    return calls;
+  for (const block of content) {
+    if (!block || typeof block !== "object")
+      continue;
+    const candidate = block;
+    if (candidate.type === "toolCall" && typeof candidate.id === "string" && typeof candidate.name === "string") {
+      calls.push({ id: candidate.id, name: candidate.name });
+    }
+  }
+  return calls;
+}
+function getToolResultCallId(message) {
+  if (message.role !== "toolResult")
+    return;
+  const toolCallId = message.toolCallId;
+  return typeof toolCallId === "string" ? toolCallId : undefined;
+}
+function repairOrphanToolResults(messages, options = {}) {
+  let allowedToolCallIds;
+  let answeredToolCallIds;
+  let pendingToolCalls = [];
+  let pendingTimestamp = 0;
+  let changed = false;
+  const repaired = [];
+  const flushUnanswered = () => {
+    for (const call of pendingToolCalls) {
+      if (answeredToolCallIds?.has(call.id))
+        continue;
+      const interrupted = {
+        role: "toolResult",
+        toolCallId: call.id,
+        toolName: call.name,
+        content: [
+          {
+            type: "text",
+            text: "Tool execution was interrupted after it started; its result is unavailable. Inspect side effects before deciding whether to retry it."
+          }
+        ],
+        isError: true,
+        timestamp: pendingTimestamp
+      };
+      repaired.push(interrupted);
+      changed = true;
+    }
+    allowedToolCallIds = undefined;
+    answeredToolCallIds = undefined;
+    pendingToolCalls = [];
+  };
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      flushUnanswered();
+      const announcedToolCalls = collectAssistantToolCalls(message);
+      pendingToolCalls = message.stopReason === "toolUse" ? announcedToolCalls : [];
+      allowedToolCallIds = new Set(announcedToolCalls.map((call) => call.id));
+      answeredToolCallIds = new Set;
+      pendingTimestamp = message.timestamp;
+      repaired.push(message);
+      continue;
+    }
+    if (message.role === "toolResult") {
+      const toolCallId = getToolResultCallId(message);
+      if (toolCallId && allowedToolCallIds?.has(toolCallId) && answeredToolCallIds?.has(toolCallId) === false) {
+        answeredToolCallIds.add(toolCallId);
+        repaired.push(message);
+        continue;
+      }
+      changed = true;
+      continue;
+    }
+    flushUnanswered();
+    repaired.push(message);
+  }
+  if (options.repairTrailing)
+    flushUnanswered();
+  return changed ? repaired : messages;
+}
+function convertToLlm(messages) {
+  const converted = messages.map((rawMessage) => {
+    const m = normalizeRawRedactedThinking(normalizeMessageContent(rawMessage));
+    switch (m.role) {
+      case "bashExecution":
+        if (!messageStartsLlmUserTurn(m))
+          return;
+        return {
+          role: "user",
+          content: [{ type: "text", text: bashExecutionToText(m) }],
+          timestamp: m.timestamp
+        };
+      case "custom": {
+        if (!messageStartsLlmUserTurn(m))
+          return;
+        const content = typeof m.content === "string" ? [{ type: "text", text: m.content }] : filterUserLikeContentBlocks(m.content);
+        return { role: "user", content, timestamp: m.timestamp };
+      }
+      case "branchSummary":
+        if (!messageStartsLlmUserTurn(m))
+          return;
+        return {
+          role: "user",
+          content: [{ type: "text", text: BRANCH_SUMMARY_PREFIX + m.summary + BRANCH_SUMMARY_SUFFIX }],
+          timestamp: m.timestamp
+        };
+      case "user": {
+        if (!messageStartsLlmUserTurn(m))
+          return;
+        if (!Array.isArray(m.content))
+          return m;
+        return { ...m, content: filterUserLikeContentBlocks(m.content) };
+      }
+      case "assistant":
+      case "toolResult":
+        return m;
+      case "compactionSummary":
+        return;
+      default: {
+        const _exhaustiveCheck = m;
+        return;
+      }
+    }
+  }).filter((m) => m !== undefined);
+  return repairOrphanToolResults(converted);
+}
+
+// src/core/compaction/transcript-serialization.ts
+var FILTERED_MARKER_RE = /^\(filtered (\d+) lines\)$/;
+var LINE_NUMBER_SEPARATOR = "→";
+var ROLE_HEADER_RE = /^\[(User|Assistant|Assistant thinking|Assistant tool calls|Tool result)\]: /;
+var KEEP_CONTEXT_OPEN_LINE_RE = /^<keepContext>$/i;
+var KEEP_CONTEXT_CLOSE_LINE_RE = /^<\/keepContext>$/i;
+var TOOL_RESULT_MAX_CHARS = 16000;
+function filteredMarker(lineCount) {
+  return `(filtered ${lineCount} lines)`;
+}
+function truncateToolResult(text) {
+  if (text.length <= TOOL_RESULT_MAX_CHARS)
+    return text;
+  return `${text.slice(0, TOOL_RESULT_MAX_CHARS)}
+
+[... ${text.length - TOOL_RESULT_MAX_CHARS} more characters truncated]`;
+}
+function lastChunk(chunks) {
+  return chunks.length > 0 ? chunks[chunks.length - 1] : undefined;
+}
+function appendText(chunks, text) {
+  if (text.length === 0)
+    return;
+  const last = lastChunk(chunks);
+  if (last !== undefined && last.type === "text")
+    last.text += text;
+  else
+    chunks.push({ type: "text", text });
+}
+function hasContent(chunks) {
+  return chunks.some((chunk) => chunk.type !== "text" || chunk.text.length > 0);
+}
+function serializeContentBlocks(content, mode) {
+  if (typeof content === "string")
+    return content.length > 0 ? [{ type: "text", text: content }] : [];
+  const chunks = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      appendText(chunks, block.text);
+      continue;
+    }
+    if (block.type !== "image")
+      continue;
+    if (mode === "retained") {
+      if (chunks.length > 0)
+        appendText(chunks, `
+`);
+      chunks.push({ ...block });
+      continue;
+    }
+    const last = lastChunk(chunks);
+    const needsBreak = last !== undefined && last.type === "text" && !last.text.endsWith(`
+`);
+    appendText(chunks, `${needsBreak ? `
+` : ""}[image]
+`);
+  }
+  const trailing = lastChunk(chunks);
+  if (trailing !== undefined && trailing.type === "text" && trailing.text.endsWith(`
+`)) {
+    trailing.text = trailing.text.slice(0, -1);
+  }
+  return chunks;
+}
+function serializeTranscriptChunks(messages, mode) {
+  const chunks = [];
+  const pushSection = (header, section) => {
+    if (!hasContent(section))
+      return;
+    appendText(chunks, `${chunks.length > 0 ? `
+
+` : ""}${header}`);
+    for (const chunk of section) {
+      if (chunk.type === "text")
+        appendText(chunks, chunk.text);
+      else
+        chunks.push(chunk);
+    }
+  };
+  for (const message of messages) {
+    if (message.role === "user") {
+      pushSection("[User]: ", serializeContentBlocks(message.content, mode));
+      continue;
+    }
+    if (message.role === "assistant") {
+      const text = [];
+      const thinking = [];
+      const toolCalls = [];
+      for (const block of message.content) {
+        if (block.type === "text")
+          text.push(block.text);
+        else if (block.type === "thinking")
+          thinking.push(block.thinking);
+        else if (block.type === "toolCall") {
+          const args = Object.entries(block.arguments).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join(", ");
+          toolCalls.push(`${block.name}(${args})`);
+        }
+      }
+      if (thinking.length > 0)
+        pushSection("[Assistant thinking]: ", [{ type: "text", text: thinking.join(`
+`) }]);
+      if (text.length > 0)
+        pushSection("[Assistant]: ", [{ type: "text", text: text.join(`
+`) }]);
+      if (toolCalls.length > 0)
+        pushSection("[Assistant tool calls]: ", [{ type: "text", text: toolCalls.join("; ") }]);
+      continue;
+    }
+    if (message.role === "toolResult") {
+      const section = serializeContentBlocks(message.content, mode);
+      if (mode === "compacted") {
+        for (const chunk of section) {
+          if (chunk.type === "text")
+            chunk.text = truncateToolResult(chunk.text);
+        }
+      }
+      pushSection("[Tool result]: ", section);
+    }
+  }
+  return chunks;
+}
+function serializeConversationForCompaction(messages) {
+  return serializeTranscriptChunks(messages, "compacted").map((chunk) => chunk.type === "text" ? chunk.text : "").join("");
+}
+function serializeRetainedTranscript(messages) {
+  return serializeTranscriptChunks(messages, "retained");
+}
+function keepContextMarker(line) {
+  const body = line.replace(ROLE_HEADER_RE, "").trim();
+  if (KEEP_CONTEXT_OPEN_LINE_RE.test(body))
+    return "open";
+  if (KEEP_CONTEXT_CLOSE_LINE_RE.test(body))
+    return "close";
+  return;
+}
+var UNTRUSTED_MARKER_ROLE = "Tool result";
+function roleMayProtect(role) {
+  return role !== UNTRUSTED_MARKER_ROLE;
+}
+function keepContextLineNumbers(lines) {
+  const protectedLines = new Set;
+  let openIndex;
+  let role;
+  const protectThrough = (endIndex) => {
+    if (openIndex === undefined)
+      return;
+    for (let line = openIndex;line <= endIndex; line++)
+      protectedLines.add(line + 1);
+    openIndex = undefined;
+  };
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index];
+    const header = ROLE_HEADER_RE.exec(line);
+    if (header) {
+      protectThrough(index - 1);
+      role = header[1];
+    }
+    if (!roleMayProtect(role))
+      continue;
+    const marker = keepContextMarker(line);
+    if (marker === "open") {
+      if (openIndex === undefined)
+        openIndex = index;
+      continue;
+    }
+    if (marker === "close")
+      protectThrough(index);
+  }
+  protectThrough(lines.length - 1);
+  return protectedLines;
+}
+function createNumberedRegion(text, protectedLineNumbers) {
+  const lines = text.split(`
+`);
+  const headerLineNumbers = new Set;
+  const priorMarkerNs = new Map;
+  for (let index = 0;index < lines.length; index++) {
+    const lineNumber = index + 1;
+    if (ROLE_HEADER_RE.test(lines[index]))
+      headerLineNumbers.add(lineNumber);
+    const markerMatch = FILTERED_MARKER_RE.exec(lines[index]);
+    if (markerMatch)
+      priorMarkerNs.set(lineNumber, Number(markerMatch[1]));
+  }
+  const detected = keepContextLineNumbers(lines);
+  const merged = protectedLineNumbers === undefined ? detected : new Set([...protectedLineNumbers, ...detected]);
+  return {
+    __brand: "NumberedRegion",
+    lines,
+    headerLineNumbers,
+    priorMarkerNs,
+    protectedLineNumbers: merged.size > 0 ? merged : undefined,
+    tokenEstimate: Math.ceil(text.length / 4)
+  };
+}
+function numberRegionLines(region, start = 1, end = region.lines.length) {
+  const first = Math.max(1, Math.trunc(start));
+  const last = Math.min(region.lines.length, Math.trunc(end));
+  if (first > last)
+    return "";
+  return region.lines.slice(first - 1, last).map((line, index) => `${first + index}${LINE_NUMBER_SEPARATOR}${line}`).join(`
+`);
+}
+
+// src/core/session-entry-normalization.ts
+function normalizeDerivedSessionEntries(entries) {
+  return entries.map((entry) => {
+    if (entry.type !== "message")
+      return entry;
+    const message = normalizeMessageContent(entry.message);
+    return message === entry.message ? entry : { ...entry, message };
+  });
+}
+
+// src/core/session-manager-history.ts
+function contextMessageFromEntry(entry) {
+  if (entry.type === "message")
+    return normalizeMessageContent(entry.message);
+  if (entry.type === "custom_message") {
+    return createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp, entry.excludeFromContext, entry.stageAdmissionKey);
+  }
+  if (entry.type === "branch_summary" && typeof entry.summary === "string" && entry.summary.length > 0) {
+    return createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp);
+  }
+  return;
+}
+function serializeKeptTail(entries) {
+  const messages = [];
+  for (const entry of entries) {
+    const message = contextMessageFromEntry(entry);
+    if (message)
+      messages.push(message);
+  }
+  if (messages.length === 0)
+    return [];
+  return serializeRetainedTranscript(convertToLlm(messages));
+}
+function getLatestCompactionBoundaryEntry(entries) {
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type !== "compaction")
+      continue;
+    const details = entry.details;
+    if (details?.strategy === "verbatim-lines")
+      return entry;
+  }
+  return null;
+}
+function sessionEntryToContextMessages(entry) {
+  if (entry.type === "message")
+    return [normalizeMessageContent(entry.message)];
+  if (entry.type === "custom_message") {
+    return [
+      createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp, entry.excludeFromContext, entry.stageAdmissionKey)
+    ];
+  }
+  if (entry.type === "branch_summary" && entry.summary.length > 0) {
+    return [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)];
+  }
+  if (entry.type === "compaction") {
+    const details = entry.details;
+    if (details?.strategy === "verbatim-lines") {
+      return [
+        createVerbatimCompactionMessage(entry.summary, entry.tokensBefore, entry.timestamp, entry.details)
+      ];
+    }
+  }
+  return [];
+}
+function buildContextEntries(entries, leafId, byId = new Map(entries.map((entry) => [entry.id, entry]))) {
+  if (leafId === null)
+    return [];
+  const leaf = leafId ? byId.get(leafId) : entries[entries.length - 1];
+  if (!leaf)
+    return [];
+  const path = normalizeDerivedSessionEntries(getBranchPath(leaf.id, byId));
+  const boundary = getLatestCompactionBoundaryEntry(path);
+  if (!boundary)
+    return path;
+  const boundaryIndex = path.findIndex((entry) => entry.id === boundary.id);
+  const firstKeptIndex = path.findIndex((entry, index) => index < boundaryIndex && entry.id === boundary.firstKeptEntryId);
+  return [
+    boundary,
+    ...firstKeptIndex >= 0 ? path.slice(firstKeptIndex, boundaryIndex) : [],
+    ...path.slice(boundaryIndex + 1)
+  ];
+}
+function buildSessionContext(entries, leafId, byId) {
+  if (!byId) {
+    byId = new Map;
+    for (const entry of entries) {
+      byId.set(entry.id, entry);
+    }
+  }
+  let leaf;
+  if (leafId === null) {
+    return { messages: [], thinkingLevel: "off", model: null };
+  }
+  if (leafId) {
+    leaf = byId.get(leafId);
+  }
+  if (!leaf) {
+    leaf = entries[entries.length - 1];
+  }
+  if (!leaf) {
+    return { messages: [], thinkingLevel: "off", model: null };
+  }
+  const path = normalizeDerivedSessionEntries(getBranchPath(leaf.id, byId));
+  let thinkingLevel = "off";
+  let model = null;
+  for (const entry of path) {
+    if (entry.type === "thinking_level_change") {
+      thinkingLevel = entry.thinkingLevel;
+    } else if (entry.type === "model_change") {
+      model = { provider: entry.provider, modelId: entry.modelId };
+    } else if (entry.type === "message" && entry.message.role === "assistant") {
+      model = { provider: entry.message.provider, modelId: entry.message.model };
+    }
+  }
+  const messages = [];
+  const appendMessage = (entry) => {
+    const message = contextMessageFromEntry(entry);
+    if (message)
+      messages.push(message);
+  };
+  const boundary = getLatestCompactionBoundaryEntry(path);
+  if (!boundary) {
+    for (const entry of path)
+      appendMessage(entry);
+    return { messages, thinkingLevel, model };
+  }
+  const boundaryIndex = path.findIndex((entry) => entry.id === boundary.id);
+  const firstKeptIndex = path.findIndex((entry, index) => index < boundaryIndex && entry.id === boundary.firstKeptEntryId);
+  const keptTail = firstKeptIndex >= 0 ? serializeKeptTail(path.slice(firstKeptIndex, boundaryIndex)) : [];
+  const separator = keptTail.length > 0 && boundary.summary.length > 0 ? [{ type: "text", text: `
+
+` }] : [];
+  messages.push(createVerbatimCompactionMessage(boundary.summary, boundary.tokensBefore, boundary.timestamp, boundary.details, [
+    ...separator,
+    ...keptTail
+  ]));
+  for (let i = boundaryIndex + 1;i < path.length; i++)
+    appendMessage(path[i]);
+  return { messages, thinkingLevel, model };
+}
+function buildSessionIndex(fileEntries) {
+  const byId = new Map;
+  const labelsById = new Map;
+  const labelTimestampsById = new Map;
+  let leafId = null;
+  for (const entry of fileEntries) {
+    if (entry.type === "session")
+      continue;
+    byId.set(entry.id, entry);
+    leafId = entry.id;
+    if (entry.type === "label") {
+      if (entry.label) {
+        labelsById.set(entry.targetId, entry.label);
+        labelTimestampsById.set(entry.targetId, entry.timestamp);
+      } else {
+        labelsById.delete(entry.targetId);
+        labelTimestampsById.delete(entry.targetId);
+      }
+    }
+  }
+  return { byId, labelsById, labelTimestampsById, leafId };
+}
+function getBranchPath(fromId, byId) {
+  const path = [];
+  let current = fromId ? byId.get(fromId) : undefined;
+  while (current) {
+    path.push(current);
+    current = current.parentId ? byId.get(current.parentId) : undefined;
+  }
+  path.reverse();
+  return path;
+}
+function buildSessionTree(entries, labelsById, labelTimestampsById) {
+  const nodeMap = new Map;
+  const roots = [];
+  for (const entry of entries) {
+    const label = labelsById.get(entry.id);
+    const labelTimestamp = labelTimestampsById.get(entry.id);
+    nodeMap.set(entry.id, { entry, children: [], label, labelTimestamp });
+  }
+  for (const entry of entries) {
+    const node = nodeMap.get(entry.id);
+    if (entry.parentId === null || entry.parentId === entry.id) {
+      roots.push(node);
+    } else {
+      const parent = nodeMap.get(entry.parentId);
+      if (parent) {
+        parent.children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+  }
+  const stack = [...roots];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    node.children.sort((a, b) => new Date(a.entry.timestamp).getTime() - new Date(b.entry.timestamp).getTime());
+    stack.push(...node.children);
+  }
+  return roots;
+}
+
+// src/core/session-manager-classification.ts
+var WORKFLOW_SESSION_METADATA_ENV = "ATOMIC_WORKFLOW_SESSION_METADATA";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function validSessionWorkflowMetadata(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return;
+  const metadata = value;
+  if (!isNonEmptyString(metadata.runId) || !isNonEmptyString(metadata.stageId) || !isNonEmptyString(metadata.stageName)) {
+    return;
+  }
+  return value;
+}
+function classifiedWorkflowMetadata(header) {
+  if (header?.internal !== true)
+    return;
+  return validSessionWorkflowMetadata(header.workflow);
+}
+function isClassifiedWorkflowSession(header) {
+  return classifiedWorkflowMetadata(header) !== undefined;
+}
+function workflowSessionMetadataFromEnv(env = process.env) {
+  const serialized = env[WORKFLOW_SESSION_METADATA_ENV];
+  if (!serialized)
+    return;
+  try {
+    return validSessionWorkflowMetadata(JSON.parse(serialized));
+  } catch {
+    return;
+  }
+}
+
+// src/core/session-manager-types.ts
+var CURRENT_SESSION_VERSION = 3;
+
+// src/core/session-manager-validation.ts
+import { uuidv7 } from "@bastani/pi-ai";
+import { randomUUID } from "crypto";
+function createSessionId() {
+  return uuidv7();
+}
+function assertValidSessionId(id) {
+  if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) {
+    throw new Error("Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character");
+  }
+}
+function generateId(byId) {
+  for (let i = 0;i < 100; i++) {
+    const id = randomUUID().slice(0, 8);
+    if (!byId.has(id))
+      return id;
+  }
+  return randomUUID();
+}
+
+// src/core/session-manager-migrations.ts
+function migrateV1ToV2(entries) {
+  const ids = new Set;
+  let prevId = null;
+  for (const entry of entries) {
+    if (entry.type === "session") {
+      entry.version = 2;
+      continue;
+    }
+    entry.id = generateId(ids);
+    entry.parentId = prevId;
+    prevId = entry.id;
+    if (entry.type === "compaction") {
+      const comp = entry;
+      if (typeof comp.firstKeptEntryIndex === "number") {
+        const targetEntry = entries[comp.firstKeptEntryIndex];
+        if (targetEntry && targetEntry.type !== "session") {
+          comp.firstKeptEntryId = targetEntry.id;
+        }
+        delete comp.firstKeptEntryIndex;
+      }
+    }
+  }
+}
+function migrateV2ToV3(entries) {
+  for (const entry of entries) {
+    if (entry.type === "session") {
+      entry.version = 3;
+      continue;
+    }
+    if (entry.type === "message") {
+      const msgEntry = entry;
+      if (msgEntry.message && msgEntry.message.role === "hookMessage") {
+        msgEntry.message.role = "custom";
+      }
+    }
+  }
+}
+function migrateToCurrentVersion(entries) {
+  const header = entries.find((e) => e.type === "session");
+  const version = header?.version ?? 1;
+  if (version >= CURRENT_SESSION_VERSION)
+    return false;
+  if (version < 2)
+    migrateV1ToV2(entries);
+  if (version < 3)
+    migrateV2ToV3(entries);
+  return true;
+}
+function migrateSessionEntries(entries) {
+  migrateToCurrentVersion(entries);
+}
+function parseSessionEntries(content) {
+  const entries = [];
+  const lines = content.trim().split(`
+`);
+  for (const line of lines) {
+    if (!line.trim())
+      continue;
+    try {
+      const entry = JSON.parse(line);
+      entries.push(entry);
+    } catch {}
+  }
+  return entries;
+}
+
+// src/core/session-manager-core.ts
+import { existsSync as existsSync7, statSync as statSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/core/session-manager-archive.ts
+import { join as join9 } from "path";
+
+// src/core/session-manager-entries.ts
+import { join as join6 } from "path";
+function entryBase(byId, parentId) {
+  return {
+    id: generateId(byId),
+    parentId,
+    timestamp: new Date().toISOString()
+  };
+}
+function createSessionHeader(id, cwd, timestamp = new Date().toISOString(), parentSession, internal, workflow) {
+  const header = {
+    type: "session",
+    version: CURRENT_SESSION_VERSION,
+    id,
+    timestamp,
+    cwd
+  };
+  if (parentSession !== undefined)
+    header.parentSession = parentSession;
+  const validWorkflow = internal === true ? validSessionWorkflowMetadata(workflow) : undefined;
+  if (validWorkflow) {
+    header.internal = true;
+    header.workflow = validWorkflow;
+  }
+  return header;
+}
+function createSessionFilePath(sessionDir, timestamp, sessionId) {
+  const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+  return join6(sessionDir, `${fileTimestamp}_${sessionId}.jsonl`);
+}
+function createMessageEntry(message, byId, parentId) {
+  return {
+    type: "message",
+    ...entryBase(byId, parentId),
+    message
+  };
+}
+function createThinkingLevelChangeEntry(thinkingLevel, byId, parentId) {
+  return {
+    type: "thinking_level_change",
+    ...entryBase(byId, parentId),
+    thinkingLevel
+  };
+}
+function createModelChangeEntry(provider, modelId, byId, parentId) {
+  return {
+    type: "model_change",
+    ...entryBase(byId, parentId),
+    provider,
+    modelId
+  };
+}
+function createCompactionEntry(compactedText, firstKeptEntryId, tokensBefore, details, usage, byId, parentId) {
+  return {
+    type: "compaction",
+    ...entryBase(byId, parentId),
+    summary: compactedText,
+    firstKeptEntryId,
+    tokensBefore,
+    details,
+    usage,
+    fromHook: details.rung === "extension" || undefined
+  };
+}
+function createCustomEntry(customType, data, byId, parentId) {
+  return {
+    type: "custom",
+    customType,
+    data,
+    ...entryBase(byId, parentId)
+  };
+}
+function createSessionInfoEntry(name, byId, parentId) {
+  return {
+    type: "session_info",
+    ...entryBase(byId, parentId),
+    name: name.trim()
+  };
+}
+function createSessionSummaryEntry(summary, summarizedThroughId, usage, byId, parentId) {
+  return {
+    type: "session_summary",
+    ...entryBase(byId, parentId),
+    summary: summary.trim(),
+    summarizedThroughId,
+    usage
+  };
+}
+function getLastConversationMessageId(entries) {
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type !== "message")
+      continue;
+    const role = entry.message.role;
+    if (role === "user" || role === "assistant")
+      return entry.id;
+  }
+  return;
+}
+function getLatestSessionSummary(entries) {
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type === "branch_summary")
+      return;
+    if (entry.type === "session_summary")
+      return entry;
+  }
+  return;
+}
+function getLatestSessionName(entries) {
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type === "session_info") {
+      const name = entry.name?.trim() || undefined;
+      return { hasName: true, ...name !== undefined ? { name } : {} };
+    }
+  }
+  return { hasName: false };
+}
+function createCustomMessageEntry(customType, content, display, details, excludeFromContext, protectedReconciliation, byId, parentId, stageAdmissionKey) {
+  return {
+    type: "custom_message",
+    customType,
+    content,
+    display,
+    details,
+    ...excludeFromContext === true ? { excludeFromContext: true } : {},
+    ...stageAdmissionKey === undefined ? {} : { stageAdmissionKey },
+    ...protectedReconciliation === undefined ? {} : { protectedReconciliation },
+    ...entryBase(byId, parentId)
+  };
+}
+function createLabelEntry(targetId, label, byId, parentId, timestamp) {
+  return {
+    type: "label",
+    ...entryBase(byId, parentId),
+    ...timestamp !== undefined ? { timestamp } : {},
+    targetId,
+    label
+  };
+}
+function createBranchSummaryEntry(branchFromId, fromId, summary, details, usage, fromHook, byId) {
+  return {
+    type: "branch_summary",
+    ...entryBase(byId, branchFromId),
+    fromId,
+    summary,
+    details,
+    usage,
+    fromHook
+  };
+}
+function getEntriesWithoutHeader(fileEntries) {
+  return fileEntries.filter((entry) => entry.type !== "session");
+}
+
+// src/core/session-manager-paths.ts
+import { existsSync as existsSync4, mkdirSync } from "fs";
+import { join as join7 } from "path";
+function getDefaultSessionDirPath(cwd, agentDir = getAgentDir()) {
+  const resolvedCwd = resolvePath(cwd);
+  const resolvedAgentDir = resolvePath(agentDir);
+  const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+  return join7(resolvedAgentDir, "sessions", safePath);
+}
+function getDefaultSessionDir(cwd, agentDir = getAgentDir()) {
+  const sessionDir = getDefaultSessionDirPath(cwd, agentDir);
+  if (!existsSync4(sessionDir)) {
+    mkdirSync(sessionDir, { recursive: true });
+  }
+  return sessionDir;
+}
+
+// src/core/session-manager-storage.ts
+import {
+  appendFileSync,
+  closeSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readdirSync,
+  readSync,
+  statSync,
+  truncateSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { join as join8 } from "path";
+import { StringDecoder } from "string_decoder";
+var SESSION_READ_BUFFER_SIZE = 1024 * 1024;
+var HEADER_READ_BUFFER_SIZE = 64 * 1024;
+function parseSessionEntryLine(line) {
+  if (!line.trim())
+    return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function loadEntriesFromFile(filePath) {
+  const resolvedFilePath = normalizePath(filePath);
+  if (!existsSync5(resolvedFilePath))
+    return [];
+  const entries = [];
+  let pending = "";
+  const fd = openSync(resolvedFilePath, "r");
+  try {
+    const decoder = new StringDecoder("utf8");
+    const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
+    while (true) {
+      const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+      if (bytesRead === 0)
+        break;
+      pending += decoder.write(buffer.subarray(0, bytesRead));
+      let lineStart = 0;
+      let newlineIndex = pending.indexOf(`
+`, lineStart);
+      while (newlineIndex !== -1) {
+        const entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex));
+        if (entry)
+          entries.push(entry);
+        lineStart = newlineIndex + 1;
+        newlineIndex = pending.indexOf(`
+`, lineStart);
+      }
+      pending = pending.slice(lineStart);
+    }
+    pending += decoder.end();
+    const finalEntry = parseSessionEntryLine(pending);
+    if (finalEntry)
+      entries.push(finalEntry);
+  } finally {
+    closeSync(fd);
+  }
+  if (entries.length === 0)
+    return entries;
+  const header = entries[0];
+  if (header.type !== "session" || !("id" in header) || typeof header.id !== "string") {
+    return [];
+  }
+  if (pending)
+    appendFileSync(resolvedFilePath, `
+`);
+  return entries;
+}
+function readSessionHeader(filePath) {
+  try {
+    const fd = openSync(filePath, "r");
+    try {
+      const decoder = new StringDecoder("utf8");
+      const buffer = Buffer.allocUnsafe(HEADER_READ_BUFFER_SIZE);
+      let pending = "";
+      let foundNewline = false;
+      while (true) {
+        const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+        if (bytesRead === 0)
+          break;
+        pending += decoder.write(buffer.subarray(0, bytesRead));
+        const newlineIndex = pending.indexOf(`
+`);
+        if (newlineIndex !== -1) {
+          pending = pending.slice(0, newlineIndex);
+          foundNewline = true;
+          break;
+        }
+      }
+      if (!foundNewline) {
+        pending += decoder.end();
+      }
+      const firstLine = pending.split(`
+`)[0];
+      if (!firstLine)
+        return null;
+      const header = JSON.parse(firstLine);
+      if (header.type !== "session" || typeof header.id !== "string") {
+        return null;
+      }
+      return header;
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function isInternalHeader(header) {
+  return isClassifiedWorkflowSession(header);
+}
+function getSessionHeaderCwd(header) {
+  const cwd = header.cwd;
+  return typeof cwd === "string" ? cwd : undefined;
+}
+function sessionCwdMatches(cwd, resolvedCwd) {
+  return cwd !== undefined && cwd !== "" && resolvePath(cwd) === resolvedCwd;
+}
+function findMostRecentSession(sessionDir, cwd, includeInternal = false) {
+  const resolvedSessionDir = normalizePath(sessionDir);
+  const resolvedCwd = cwd ? resolvePath(cwd) : undefined;
+  try {
+    const files = readdirSync(resolvedSessionDir).filter((f) => f.endsWith(".jsonl")).map((f) => join8(resolvedSessionDir, f)).map((path) => ({ path, header: readSessionHeader(path) })).filter((file) => file.header !== null && (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)) && (includeInternal || !isInternalHeader(file.header))).map(({ path }) => ({ path, mtime: statSync(path).mtime })).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    return files[0]?.path || null;
+  } catch {
+    return null;
+  }
+}
+function serializeSessionEntries(entries) {
+  return `${entries.map((e) => JSON.stringify(e)).join(`
+`)}
+`;
+}
+function writeSessionEntries(filePath, entries) {
+  writeFileSync(filePath, serializeSessionEntries(entries));
+}
+function appendSessionPayload(filePath, payload) {
+  const existed = existsSync5(filePath);
+  const offset = existed ? statSync(filePath).size : 0;
+  try {
+    appendFileSync(filePath, payload);
+  } catch (writeError) {
+    try {
+      if (existed)
+        truncateSync(filePath, offset);
+      else if (existsSync5(filePath))
+        unlinkSync(filePath);
+    } catch (rollbackError) {
+      throw new AggregateError([writeError, rollbackError], "Session append and rollback failed");
+    }
+    throw writeError;
+  }
+}
+function appendSessionEntry(filePath, entry) {
+  appendSessionPayload(filePath, `${JSON.stringify(entry)}
+`);
+}
+function appendSessionEntries(filePath, entries) {
+  if (entries.length === 0)
+    return;
+  appendSessionPayload(filePath, serializeSessionEntries(entries));
+}
+function hasAssistantMessage(entries) {
+  return entries.some((entry) => entry.type === "message" && entry.message.role === "assistant");
+}
+function persistAppendedEntry(filePath, entries, entry, flushed) {
+  if (flushed)
+    appendSessionEntry(filePath, entry);
+  else if (!hasAssistantMessage(entries))
+    return false;
+  else
+    appendSessionEntries(filePath, entries);
+  return true;
+}
+function ensureDirectory(dir) {
+  if (!existsSync5(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+
+// src/core/session-manager-archive.ts
+function createBackupSnapshot(sessionFile, entries, label = "compact") {
+  if (!sessionFile)
+    return;
+  const safeLabel = label.replace(/[^a-z0-9_-]/gi, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "backup";
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${sessionFile}.${timestamp}.${safeLabel}.bak`;
+  writeSessionEntries(backupPath, entries);
+  return backupPath;
+}
+function collectLabelsForPath(pathEntryIds, labelsById, labelTimestampsById) {
+  const labelsToWrite = [];
+  for (const [targetId, label] of labelsById) {
+    if (pathEntryIds.has(targetId)) {
+      labelsToWrite.push({ targetId, label, timestamp: labelTimestampsById.get(targetId) });
+    }
+  }
+  return labelsToWrite;
+}
+function buildPersistedLabelEntries(pathEntryIds, lastEntryId, labelsToWrite) {
+  let parentId = lastEntryId;
+  const labelEntries = [];
+  for (const { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
+    const labelEntry = createLabelEntry(targetId, label, new Set(pathEntryIds), parentId, labelTimestamp);
+    pathEntryIds.add(labelEntry.id);
+    labelEntries.push(labelEntry);
+    parentId = labelEntry.id;
+  }
+  return labelEntries;
+}
+function buildInMemoryLabelEntries(pathEntryIds, lastEntryId, labelsToWrite) {
+  const labelEntries = [];
+  let parentId = lastEntryId;
+  for (const { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
+    const labelEntry = {
+      type: "label",
+      id: generateId(new Set([...pathEntryIds, ...labelEntries.map((e) => e.id)])),
+      parentId,
+      timestamp: labelTimestamp,
+      targetId,
+      label
+    };
+    labelEntries.push(labelEntry);
+    parentId = labelEntry.id;
+  }
+  return labelEntries;
+}
+function createBranchedSessionState(input) {
+  if (input.path.length === 0) {
+    throw new Error(`Entry ${input.leafId} not found`);
+  }
+  const pathWithoutLabels = input.path.filter((entry) => entry.type !== "label");
+  const newSessionId = createSessionId();
+  const timestamp = new Date().toISOString();
+  const newSessionFile = createSessionFilePath(input.sessionDir, timestamp, newSessionId);
+  const header = createSessionHeader(newSessionId, input.cwd, timestamp, input.persist ? input.previousSessionFile : undefined, input.workflow !== undefined, input.workflow);
+  const pathEntryIds = new Set(pathWithoutLabels.map((entry) => entry.id));
+  const labelsToWrite = collectLabelsForPath(pathEntryIds, input.labelsById, input.labelTimestampsById);
+  const lastEntryId = pathWithoutLabels[pathWithoutLabels.length - 1]?.id || null;
+  const labelEntries = input.persist ? buildPersistedLabelEntries(pathEntryIds, lastEntryId, labelsToWrite) : buildInMemoryLabelEntries(pathEntryIds, lastEntryId, labelsToWrite);
+  const fileEntries = [header, ...pathWithoutLabels, ...labelEntries];
+  if (!input.persist) {
+    return { sessionId: newSessionId, sessionFile: undefined, fileEntries, shouldRewriteFile: false };
+  }
+  const shouldRewriteFile = hasAssistantMessage(fileEntries);
+  return {
+    sessionId: newSessionId,
+    sessionFile: newSessionFile,
+    fileEntries,
+    shouldRewriteFile,
+    flushed: shouldRewriteFile
+  };
+}
+function forkSessionFromFile(sourcePath, targetCwd, sessionDir, options) {
+  const resolvedSourcePath = resolvePath(sourcePath);
+  const resolvedTargetCwd = resolvePath(targetCwd);
+  const sourceEntries = loadEntriesFromFile(resolvedSourcePath);
+  if (sourceEntries.length === 0) {
+    throw new Error(`Cannot fork: source session file is empty or invalid: ${resolvedSourcePath}`);
+  }
+  const sourceHeader = sourceEntries.find((entry) => entry.type === "session");
+  if (!sourceHeader) {
+    throw new Error(`Cannot fork: source session has no header: ${resolvedSourcePath}`);
+  }
+  const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(resolvedTargetCwd);
+  ensureDirectory(dir);
+  if (options?.id !== undefined) {
+    assertValidSessionId(options.id);
+  }
+  const newSessionId = options?.id ?? createSessionId();
+  const timestamp = new Date().toISOString();
+  const newSessionFile = join9(dir, `${timestamp.replace(/[:.]/g, "-")}_${newSessionId}.jsonl`);
+  const newHeader = createSessionHeader(newSessionId, resolvedTargetCwd, timestamp, resolvedSourcePath, options?.internal, options?.workflow);
+  appendSessionEntry(newSessionFile, newHeader);
+  for (const entry of sourceEntries) {
+    if (entry.type !== "session") {
+      appendSessionEntry(newSessionFile, entry);
+    }
+  }
+  return { cwd: resolvedTargetCwd, sessionDir: dir, sessionFile: newSessionFile };
+}
+
+// src/core/session-manager-list.ts
+import { existsSync as existsSync6 } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { join as join10 } from "path";
+
+// src/utils/event-loop.ts
+import { setImmediate as waitForImmediate } from "node:timers/promises";
+async function yieldToEventLoop() {
+  await waitForImmediate();
+}
+async function yieldToEventLoopIfSlow(startedAt, thresholdMs = 16) {
+  if (Date.now() - startedAt >= thresholdMs) {
+    await yieldToEventLoop();
+  }
+}
+
+// src/core/session-manager-list.ts
+function isMessageWithContent(message) {
+  return typeof message.role === "string" && "content" in message;
+}
+function extractTextContent(message) {
+  const content = message.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.filter((block) => block.type === "text").map((block) => block.text).join(" ");
+}
+function getLastActivityTime(entries) {
+  let lastActivityTime;
+  for (const entry of entries) {
+    if (entry.type !== "message")
+      continue;
+    const message = entry.message;
+    if (!isMessageWithContent(message))
+      continue;
+    if (message.role !== "user" && message.role !== "assistant")
+      continue;
+    const msgTimestamp = message.timestamp;
+    if (typeof msgTimestamp === "number") {
+      lastActivityTime = Math.max(lastActivityTime ?? 0, msgTimestamp);
+      continue;
+    }
+    const entryTimestamp = entry.timestamp;
+    if (typeof entryTimestamp === "string") {
+      const t = new Date(entryTimestamp).getTime();
+      if (!Number.isNaN(t)) {
+        lastActivityTime = Math.max(lastActivityTime ?? 0, t);
+      }
+    }
+  }
+  return lastActivityTime;
+}
+function getSessionModifiedDate(entries, header, statsMtime) {
+  const lastActivityTime = getLastActivityTime(entries);
+  if (typeof lastActivityTime === "number" && lastActivityTime > 0) {
+    return new Date(lastActivityTime);
+  }
+  const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+  return !Number.isNaN(headerTime) ? new Date(headerTime) : statsMtime;
+}
+var COOPERATIVE_PARSE_CONTENT_BYTES = 512 * 1024;
+var PARSE_YIELD_EVERY_LINES = 2000;
+var LIST_FILE_BATCH_SIZE = 24;
+async function parseSessionEntriesCooperatively(content) {
+  const entries = [];
+  const lines = content.trim().split(`
+`);
+  let startedAt = Date.now();
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.trim()) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {}
+    }
+    if ((index + 1) % PARSE_YIELD_EVERY_LINES === 0) {
+      await yieldToEventLoopIfSlow(startedAt);
+      startedAt = Date.now();
+    }
+  }
+  return entries;
+}
+async function mapSessionFilesCooperatively(files, includeInternal, onFileDone) {
+  const results = [];
+  for (let offset = 0;offset < files.length; offset += LIST_FILE_BATCH_SIZE) {
+    const batch = files.slice(offset, offset + LIST_FILE_BATCH_SIZE);
+    const startedAt = Date.now();
+    const batchResults = await Promise.all(batch.map(async (file) => {
+      if (!includeInternal && isInternalHeader(readSessionHeader(file))) {
+        onFileDone();
+        return null;
+      }
+      const info = await buildSessionInfo(file);
+      onFileDone();
+      return info;
+    }));
+    for (const info of batchResults)
+      results.push(info);
+    await yieldToEventLoopIfSlow(startedAt);
+  }
+  return results;
+}
+async function buildSessionInfo(filePath) {
+  try {
+    const content = await readFile(filePath, "utf8");
+    const entries = content.length > COOPERATIVE_PARSE_CONTENT_BYTES ? await parseSessionEntriesCooperatively(content) : parseSessionEntries(content);
+    if (entries.length === 0)
+      return null;
+    const header = entries[0];
+    if (header.type !== "session")
+      return null;
+    const stats = await stat(filePath);
+    let messageCount = 0;
+    let firstMessage = "";
+    const allMessages = [];
+    let name;
+    let hasName = false;
+    for (const entry of entries) {
+      if (entry.type === "session_info") {
+        const infoEntry = entry;
+        name = infoEntry.name?.trim() || undefined;
+        hasName = true;
+      }
+      if (entry.type !== "message")
+        continue;
+      messageCount++;
+      const message = entry.message;
+      if (!isMessageWithContent(message))
+        continue;
+      if (message.role !== "user" && message.role !== "assistant")
+        continue;
+      const textContent = extractTextContent(message);
+      if (!textContent)
+        continue;
+      allMessages.push(textContent);
+      if (!firstMessage && message.role === "user") {
+        firstMessage = textContent;
+      }
+    }
+    const cwd = typeof header.cwd === "string" ? header.cwd : "";
+    const parentSessionPath = header.parentSession;
+    const workflow = classifiedWorkflowMetadata(header);
+    const internal = workflow ? true : undefined;
+    const modified = getSessionModifiedDate(entries, header, stats.mtime);
+    const summaryEntry = getLatestSessionSummary(entries);
+    const summary = summaryEntry?.summarizedThroughId === getLastConversationMessageId(entries) ? summaryEntry?.summary : undefined;
+    return {
+      path: filePath,
+      id: header.id,
+      cwd,
+      name,
+      ...hasName ? { hasName: true } : {},
+      parentSessionPath,
+      ...internal ? { internal } : {},
+      ...workflow ? { workflow } : {},
+      created: new Date(header.timestamp),
+      modified,
+      messageCount,
+      firstMessage: firstMessage || "(no messages)",
+      summary,
+      allMessagesText: allMessages.join(" ")
+    };
+  } catch {
+    return null;
+  }
+}
+async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal, includeInternal = false) {
+  const sessions = [];
+  if (!existsSync6(dir)) {
+    return sessions;
+  }
+  try {
+    const dirEntries = await readdir(dir);
+    const files = dirEntries.filter((f) => f.endsWith(".jsonl")).map((f) => join10(dir, f));
+    const total = progressTotal ?? files.length;
+    let loaded = 0;
+    const results = await mapSessionFilesCooperatively(files, includeInternal, () => {
+      loaded++;
+      onProgress?.(progressOffset + loaded, total);
+    });
+    for (const info of results) {
+      if (info && (includeInternal || !info.internal)) {
+        sessions.push(info);
+      }
+    }
+  } catch {}
+  return sessions;
+}
+async function listProjectSessions(cwd, sessionDir, onProgress, includeInternal = false) {
+  const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+  const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+  const resolvedCwd = resolvePath(cwd);
+  const sessions = (await listSessionsFromDir(dir, onProgress, 0, undefined, includeInternal)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
+  sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+  return sessions;
+}
+async function listAllSessions(sessionDirOrOnProgress, onProgress, includeInternal = false) {
+  const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : undefined;
+  const progress = typeof sessionDirOrOnProgress === "function" ? sessionDirOrOnProgress : onProgress;
+  if (customSessionDir) {
+    const sessions = await listSessionsFromDir(customSessionDir, progress, 0, undefined, includeInternal);
+    sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    return sessions;
+  }
+  const sessionsDir = getSessionsDir();
+  try {
+    if (!existsSync6(sessionsDir)) {
+      return [];
+    }
+    const entries = await readdir(sessionsDir, { withFileTypes: true });
+    const dirs = entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => join10(sessionsDir, entry.name));
+    let totalFiles = 0;
+    const dirFiles = [];
+    for (const dir of dirs) {
+      try {
+        const files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
+        dirFiles.push(files.map((f) => join10(dir, f)));
+        totalFiles += files.length;
+      } catch {
+        dirFiles.push([]);
+      }
+    }
+    let loaded = 0;
+    const sessions = [];
+    const allFiles = dirFiles.flat();
+    const results = await mapSessionFilesCooperatively(allFiles, includeInternal, () => {
+      loaded++;
+      progress?.(loaded, totalFiles);
+    });
+    for (const info of results) {
+      if (info && (includeInternal || !info.internal)) {
+        sessions.push(info);
+      }
+    }
+    sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+
+// src/core/session-manager-core.ts
+class SessionManager {
+  sessionId = "";
+  sessionFile;
+  sessionDir;
+  cwd;
+  persist;
+  flushed = false;
+  fileEntries = [];
+  byId = new Map;
+  labelsById = new Map;
+  labelTimestampsById = new Map;
+  leafId = null;
+  constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries) {
+    this.cwd = resolvePath(cwd);
+    this.sessionDir = normalizePath(sessionDir);
+    this.persist = persist;
+    if (persist && this.sessionDir) {
+      ensureDirectory(this.sessionDir);
+    }
+    if (sessionFile) {
+      this._setSessionFile(sessionFile, preloadedFileEntries);
+    } else {
+      this.newSession(newSessionOptions);
+    }
+  }
+  setSessionFile(sessionFile) {
+    this._setSessionFile(sessionFile);
+  }
+  _setSessionFile(sessionFile, preloadedFileEntries) {
+    this.sessionFile = resolvePath(sessionFile);
+    if (existsSync7(this.sessionFile)) {
+      this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
+      if (this.fileEntries.length === 0) {
+        const explicitPath = this.sessionFile;
+        if (statSync2(explicitPath).size > 0) {
+          throw new Error(`Session file is not a valid ${APP_TITLE} session: ${explicitPath}`);
+        }
+        this.newSession();
+        this.sessionFile = explicitPath;
+        this._rewriteFile();
+        this.flushed = true;
+        return;
+      }
+      const header = this.fileEntries.find((entry) => entry.type === "session");
+      this.sessionId = header?.id ?? createSessionId();
+      if (migrateToCurrentVersion(this.fileEntries)) {
+        this._rewriteFile();
+      }
+      this._buildIndex();
+      this.flushed = true;
+    } else {
+      const explicitPath = this.sessionFile;
+      this.newSession();
+      this.sessionFile = explicitPath;
+    }
+  }
+  newSession(options) {
+    if (options?.id !== undefined) {
+      assertValidSessionId(options.id);
+    }
+    this.sessionId = options?.id ?? createSessionId();
+    const timestamp = new Date().toISOString();
+    const header = createSessionHeader(this.sessionId, this.cwd, timestamp, options?.parentSession, options?.internal, options?.workflow);
+    this.fileEntries = [header];
+    this.byId.clear();
+    this.labelsById.clear();
+    this.labelTimestampsById.clear();
+    this.leafId = null;
+    this.flushed = false;
+    if (this.persist) {
+      this.sessionFile = createSessionFilePath(this.getSessionDir(), timestamp, this.sessionId);
+    }
+    return this.sessionFile;
+  }
+  markSessionInternal(workflow) {
+    const header = this.fileEntries.find((entry) => entry.type === "session");
+    if (!header || classifiedWorkflowMetadata(header))
+      return;
+    const validWorkflow = validSessionWorkflowMetadata(workflow);
+    if (!validWorkflow)
+      return;
+    header.internal = true;
+    header.workflow = validWorkflow;
+    if (this.flushed)
+      this._rewriteFile();
+  }
+  _buildIndex() {
+    const index = buildSessionIndex(this.fileEntries);
+    this.byId = index.byId;
+    this.labelsById = index.labelsById;
+    this.labelTimestampsById = index.labelTimestampsById;
+    this.leafId = index.leafId;
+  }
+  _rewriteFile() {
+    if (!this.persist || !this.sessionFile)
+      return;
+    writeSessionEntries(this.sessionFile, this.fileEntries);
+  }
+  isPersisted() {
+    return this.persist;
+  }
+  flush() {
+    if (!this.persist || !this.sessionFile)
+      return;
+    this._rewriteFile();
+    this.flushed = true;
+  }
+  getCwd() {
+    return this.cwd;
+  }
+  getSessionDir() {
+    return this.sessionDir;
+  }
+  usesDefaultSessionDir() {
+    return this.sessionDir === getDefaultSessionDirPath(this.cwd);
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getSessionFile() {
+    return this.sessionFile;
+  }
+  _persist(entry) {
+    if (!this.persist || !this.sessionFile)
+      return;
+    this.flushed = persistAppendedEntry(this.sessionFile, this.fileEntries, entry, this.flushed);
+  }
+  _appendEntry(entry) {
+    const previousLeafId = this.leafId;
+    this.fileEntries.push(entry);
+    this.byId.set(entry.id, entry);
+    this.leafId = entry.id;
+    try {
+      this._persist(entry);
+    } catch (error) {
+      this.fileEntries.pop();
+      this.byId.delete(entry.id);
+      this.leafId = previousLeafId;
+      throw error;
+    }
+  }
+  appendMessage(message) {
+    const entry = createMessageEntry(message, this.byId, this.leafId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  appendThinkingLevelChange(thinkingLevel) {
+    const entry = createThinkingLevelChangeEntry(thinkingLevel, this.byId, this.leafId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  appendModelChange(provider, modelId) {
+    const entry = createModelChangeEntry(provider, modelId, this.byId, this.leafId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  appendCompaction(compactedText, firstKeptEntryId, tokensBefore, details, usage) {
+    if (firstKeptEntryId !== null && !this.byId.has(firstKeptEntryId))
+      throw new Error(`Entry ${firstKeptEntryId} not found`);
+    const entry = createCompactionEntry(compactedText, firstKeptEntryId, tokensBefore, details, usage, this.byId, this.leafId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  writeBackupSnapshot(label = "compact") {
+    if (!this.persist)
+      return;
+    return createBackupSnapshot(this.sessionFile, this.fileEntries, label);
+  }
+  appendCustomEntry(customType, data) {
+    const entry = createCustomEntry(customType, data, this.byId, this.leafId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  appendSessionInfo(name) {
+    const entry = createSessionInfoEntry(name, this.byId, this.leafId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  appendSessionSummary(summary, summarizedThroughId, usage) {
+    if (!this.byId.has(summarizedThroughId))
+      throw new Error(`Entry ${summarizedThroughId} not found`);
+    const entry = createSessionSummaryEntry(summary, summarizedThroughId, usage, this.byId, this.leafId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  getSessionName() {
+    return this.getSessionNameState().name;
+  }
+  getSessionNameState() {
+    return getLatestSessionName(this.getEntries());
+  }
+  appendCustomMessageEntry(customType, content, display, details, excludeFromContext, protectedReconciliation, stageAdmissionKey) {
+    const entry = createCustomMessageEntry(customType, content, display, details, excludeFromContext, protectedReconciliation, this.byId, this.leafId, stageAdmissionKey);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  getLeafId() {
+    return this.leafId;
+  }
+  getLeafEntry() {
+    return this.leafId ? this.byId.get(this.leafId) : undefined;
+  }
+  getEntry(id) {
+    return this.byId.get(id);
+  }
+  getChildren(parentId) {
+    const children = [];
+    for (const entry of this.byId.values()) {
+      if (entry.parentId === parentId) {
+        children.push(entry);
+      }
+    }
+    return children;
+  }
+  getLabel(id) {
+    return this.labelsById.get(id);
+  }
+  appendLabelChange(targetId, label) {
+    if (!this.byId.has(targetId)) {
+      throw new Error(`Entry ${targetId} not found`);
+    }
+    const entry = createLabelEntry(targetId, label, this.byId, this.leafId);
+    this._appendEntry(entry);
+    if (label) {
+      this.labelsById.set(targetId, label);
+      this.labelTimestampsById.set(targetId, entry.timestamp);
+    } else {
+      this.labelsById.delete(targetId);
+      this.labelTimestampsById.delete(targetId);
+    }
+    return entry.id;
+  }
+  getBranch(fromId) {
+    return getBranchPath(fromId ?? this.leafId, this.byId);
+  }
+  buildSessionContext() {
+    return buildSessionContext(this.getEntries(), this.leafId, this.byId);
+  }
+  getHeader() {
+    const header = this.fileEntries.find((entry) => entry.type === "session");
+    return header ? header : null;
+  }
+  getEntries() {
+    return getEntriesWithoutHeader(this.fileEntries);
+  }
+  getTree() {
+    return buildSessionTree(this.getEntries(), this.labelsById, this.labelTimestampsById);
+  }
+  branch(branchFromId) {
+    if (!this.byId.has(branchFromId)) {
+      throw new Error(`Entry ${branchFromId} not found`);
+    }
+    this.leafId = branchFromId;
+  }
+  resetLeaf() {
+    this.leafId = null;
+  }
+  branchWithSummary(branchFromId, summary, details, fromHook, usage, fromId = this.leafId ?? "root") {
+    if (branchFromId !== null && !this.byId.has(branchFromId)) {
+      throw new Error(`Entry ${branchFromId} not found`);
+    }
+    this.leafId = branchFromId;
+    const entry = createBranchSummaryEntry(branchFromId, fromId, summary, details, usage, fromHook, this.byId);
+    this._appendEntry(entry);
+    return entry.id;
+  }
+  createBranchedSession(leafId) {
+    const result = createBranchedSessionState({
+      leafId,
+      persist: this.persist,
+      sessionDir: this.getSessionDir(),
+      cwd: this.cwd,
+      previousSessionFile: this.sessionFile,
+      workflow: classifiedWorkflowMetadata(this.getHeader()),
+      path: this.getBranch(leafId),
+      labelsById: this.labelsById,
+      labelTimestampsById: this.labelTimestampsById
+    });
+    this.fileEntries = result.fileEntries;
+    this.sessionId = result.sessionId;
+    if (result.sessionFile)
+      this.sessionFile = result.sessionFile;
+    this._buildIndex();
+    if (this.persist) {
+      if (result.shouldRewriteFile)
+        this._rewriteFile();
+      this.flushed = result.flushed ?? false;
+      return result.sessionFile;
+    }
+    return;
+  }
+  static create(cwd, sessionDir, options) {
+    const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+    return new SessionManager(cwd, dir, undefined, true, options);
+  }
+  static open(path, sessionDir, cwdOverride) {
+    const resolvedPath = resolvePath(path);
+    const entries = loadEntriesFromFile(resolvedPath);
+    const header = entries.find((entry) => entry.type === "session");
+    const cwd = cwdOverride ?? header?.cwd ?? process.cwd();
+    const dir = sessionDir ? normalizePath(sessionDir) : resolve3(resolvedPath, "..");
+    return new SessionManager(cwd, dir, resolvedPath, true, undefined, entries);
+  }
+  static continueRecent(cwd, sessionDir, options) {
+    const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+    const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+    const mostRecent = findMostRecentSession(dir, filterCwd ? cwd : undefined, options?.includeInternal === true);
+    return new SessionManager(cwd, dir, mostRecent ?? undefined, true);
+  }
+  static inMemory(cwd = process.cwd(), options) {
+    return new SessionManager(cwd, "", undefined, false, options);
+  }
+  static forkFrom(sourcePath, targetCwd, sessionDir, options) {
+    const forked = forkSessionFromFile(sourcePath, targetCwd, sessionDir, options);
+    return new SessionManager(forked.cwd, forked.sessionDir, forked.sessionFile, true);
+  }
+  static async list(cwd, sessionDir, onProgress, options) {
+    return listProjectSessions(cwd, sessionDir, onProgress, options?.includeInternal === true);
+  }
+  static async listAll(sessionDirOrOnProgress, onProgress, options) {
+    return listAllSessions(sessionDirOrOnProgress, onProgress, options?.includeInternal === true);
+  }
+}
+// src/utils/fs-watch.ts
+import { realpathSync as realpathSync3, watch } from "node:fs";
+var FS_WATCH_RETRY_DELAY_MS = 5000;
+var SAFE_FS_WATCH_CANONICALIZATION_FAILED = "ERR_SAFE_FS_WATCH_CANONICALIZATION_FAILED";
+var SAFE_FS_WATCH_UNSAFE_WINDOWS_SHORT_PATH = "ERR_SAFE_FS_WATCH_UNSAFE_WINDOWS_SHORT_PATH";
+function closeWatcher(watcher) {
+  if (!watcher) {
+    return;
+  }
+  try {
+    watcher.close();
+  } catch {}
+}
+function createSafeFsWatchPathError(code, watchedPath, message, resolvedPath, cause) {
+  const error = new Error(message, cause ? { cause } : undefined);
+  error.name = "SafeFsWatchPathError";
+  error.code = code;
+  error.watchedPath = watchedPath;
+  if (resolvedPath !== undefined) {
+    error.resolvedPath = resolvedPath;
+  }
+  return error;
+}
+function isUnsafeWindowsShortPath(path, platform = process.platform) {
+  if (platform !== "win32") {
+    return false;
+  }
+  return path.split(/[\\/]+/).some((component) => /~\d+(?:\.|$)/i.test(component));
+}
+function isSafeFsWatchPathError(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === SAFE_FS_WATCH_CANONICALIZATION_FAILED || code === SAFE_FS_WATCH_UNSAFE_WINDOWS_SHORT_PATH;
+}
+function resolveNativeWatchPath(path, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") {
+    return { path };
+  }
+  const resolvePath2 = options.realpathSyncNative ?? realpathSync3.native;
+  let resolvedPath;
+  try {
+    resolvedPath = resolvePath2(path);
+  } catch (error) {
+    return {
+      error: createSafeFsWatchPathError(SAFE_FS_WATCH_CANONICALIZATION_FAILED, path, `Cannot canonicalize Windows fs.watch path '${path}'.`, undefined, error instanceof Error ? error : undefined)
+    };
+  }
+  if (isUnsafeWindowsShortPath(resolvedPath, platform)) {
+    return {
+      error: createSafeFsWatchPathError(SAFE_FS_WATCH_UNSAFE_WINDOWS_SHORT_PATH, path, `Refusing native fs.watch for unsafe Windows short-name path '${resolvedPath}'.`, resolvedPath)
+    };
+  }
+  return { path: resolvedPath };
+}
+function watchWithErrorHandler(path, listener, onError, options = {}) {
+  const resolved = resolveNativeWatchPath(path, options);
+  if ("error" in resolved) {
+    onError(resolved.error);
+    return null;
+  }
+  try {
+    const watchPath = options.watch ?? watch;
+    const watcher = watchPath(resolved.path, listener);
+    watcher.on("error", onError);
+    return watcher;
+  } catch (error) {
+    onError(error instanceof Error ? error : new Error(String(error)));
+    return null;
+  }
+}
+
+// src/modes/interactive/theme/theme-class.ts
+import chalk from "chalk";
+
+// src/modes/interactive/theme/color-utils.ts
+function detectColorMode() {
+  const colorterm = process.env.COLORTERM;
+  if (colorterm === "truecolor" || colorterm === "24bit") {
+    return "truecolor";
+  }
+  if (process.env.WT_SESSION) {
+    return "truecolor";
+  }
+  const term = process.env.TERM || "";
+  if (term === "dumb" || term === "" || term === "linux") {
+    return "256color";
+  }
+  if (process.env.TERM_PROGRAM === "Apple_Terminal") {
+    return "256color";
+  }
+  if (term === "screen" || term.startsWith("screen-") || term.startsWith("screen.")) {
+    return "256color";
+  }
+  return "truecolor";
+}
+function hexToRgb(hex) {
+  const cleaned = hex.replace("#", "");
+  if (cleaned.length !== 6) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  const r = parseInt(cleaned.substring(0, 2), 16);
+  const g = parseInt(cleaned.substring(2, 4), 16);
+  const b = parseInt(cleaned.substring(4, 6), 16);
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  return { r, g, b };
+}
+var CUBE_VALUES = [0, 95, 135, 175, 215, 255];
+var GRAY_VALUES = Array.from({ length: 24 }, (_, i) => 8 + i * 10);
+function findClosestCubeIndex(value) {
+  let minDist = Infinity;
+  let minIdx = 0;
+  for (let i = 0;i < CUBE_VALUES.length; i++) {
+    const dist = Math.abs(value - CUBE_VALUES[i]);
+    if (dist < minDist) {
+      minDist = dist;
+      minIdx = i;
+    }
+  }
+  return minIdx;
+}
+function findClosestGrayIndex(gray) {
+  let minDist = Infinity;
+  let minIdx = 0;
+  for (let i = 0;i < GRAY_VALUES.length; i++) {
+    const dist = Math.abs(gray - GRAY_VALUES[i]);
+    if (dist < minDist) {
+      minDist = dist;
+      minIdx = i;
+    }
+  }
+  return minIdx;
+}
+function colorDistance(r1, g1, b1, r2, g2, b2) {
+  const dr = r1 - r2;
+  const dg = g1 - g2;
+  const db = b1 - b2;
+  return dr * dr * 0.299 + dg * dg * 0.587 + db * db * 0.114;
+}
+function rgbTo256(r, g, b) {
+  const rIdx = findClosestCubeIndex(r);
+  const gIdx = findClosestCubeIndex(g);
+  const bIdx = findClosestCubeIndex(b);
+  const cubeR = CUBE_VALUES[rIdx];
+  const cubeG = CUBE_VALUES[gIdx];
+  const cubeB = CUBE_VALUES[bIdx];
+  const cubeIndex = 16 + 36 * rIdx + 6 * gIdx + bIdx;
+  const cubeDist = colorDistance(r, g, b, cubeR, cubeG, cubeB);
+  const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+  const grayIdx = findClosestGrayIndex(gray);
+  const grayValue = GRAY_VALUES[grayIdx];
+  const grayIndex = 232 + grayIdx;
+  const grayDist = colorDistance(r, g, b, grayValue, grayValue, grayValue);
+  const maxC = Math.max(r, g, b);
+  const minC = Math.min(r, g, b);
+  const spread = maxC - minC;
+  if (spread < 10 && grayDist < cubeDist) {
+    return grayIndex;
+  }
+  return cubeIndex;
+}
+function hexTo256(hex) {
+  const { r, g, b } = hexToRgb(hex);
+  return rgbTo256(r, g, b);
+}
+function fgAnsi(color, mode) {
+  if (color === "")
+    return "\x1B[39m";
+  if (typeof color === "number")
+    return `\x1B[38;5;${color}m`;
+  if (color.startsWith("#")) {
+    if (mode === "truecolor") {
+      const { r, g, b } = hexToRgb(color);
+      return `\x1B[38;2;${r};${g};${b}m`;
+    } else {
+      const index = hexTo256(color);
+      return `\x1B[38;5;${index}m`;
+    }
+  }
+  throw new Error(`Invalid color value: ${color}`);
+}
+function bgAnsi(color, mode) {
+  if (color === "")
+    return "\x1B[49m";
+  if (typeof color === "number")
+    return `\x1B[48;5;${color}m`;
+  if (color.startsWith("#")) {
+    if (mode === "truecolor") {
+      const { r, g, b } = hexToRgb(color);
+      return `\x1B[48;2;${r};${g};${b}m`;
+    } else {
+      const index = hexTo256(color);
+      return `\x1B[48;5;${index}m`;
+    }
+  }
+  throw new Error(`Invalid color value: ${color}`);
+}
+function resolveVarRefs(value, vars, visited = new Set) {
+  if (typeof value === "number" || value === "" || value.startsWith("#")) {
+    return value;
+  }
+  if (visited.has(value)) {
+    throw new Error(`Circular variable reference detected: ${value}`);
+  }
+  if (!(value in vars)) {
+    throw new Error(`Variable reference not found: ${value}`);
+  }
+  visited.add(value);
+  return resolveVarRefs(vars[value], vars, visited);
+}
+function resolveThemeColors(colors, vars = {}) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(colors)) {
+    resolved[key] = resolveVarRefs(value, vars);
+  }
+  return resolved;
+}
+function ansi256ToHex(index) {
+  const basicColors = [
+    "#000000",
+    "#800000",
+    "#008000",
+    "#808000",
+    "#000080",
+    "#800080",
+    "#008080",
+    "#c0c0c0",
+    "#808080",
+    "#ff0000",
+    "#00ff00",
+    "#ffff00",
+    "#0000ff",
+    "#ff00ff",
+    "#00ffff",
+    "#ffffff"
+  ];
+  if (index < 16) {
+    return basicColors[index];
+  }
+  if (index < 232) {
+    const cubeIndex = index - 16;
+    const r = Math.floor(cubeIndex / 36);
+    const g = Math.floor(cubeIndex % 36 / 6);
+    const b = cubeIndex % 6;
+    const toHex = (n) => (n === 0 ? 0 : 55 + n * 40).toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  }
+  const gray = 8 + (index - 232) * 10;
+  const grayHex = gray.toString(16).padStart(2, "0");
+  return `#${grayHex}${grayHex}${grayHex}`;
+}
+
+// src/modes/interactive/theme/theme-class.ts
+class Theme {
+  name;
+  sourcePath;
+  sourceInfo;
+  fgColors;
+  bgColors;
+  mode;
+  workingIndicatorColors;
+  constructor(fgColors, bgColors, mode, options = {}) {
+    this.name = options.name;
+    this.sourcePath = options.sourcePath;
+    this.sourceInfo = options.sourceInfo;
+    this.mode = mode;
+    this.fgColors = new Map;
+    const foregrounds = {
+      ...fgColors,
+      searchMatchText: fgColors.searchMatchText ?? fgColors.text
+    };
+    for (const [key, value] of Object.entries(foregrounds)) {
+      this.fgColors.set(key, fgAnsi(value, mode));
+    }
+    this.bgColors = new Map;
+    const backgrounds = {
+      ...bgColors,
+      scrollbarThumb: bgColors.scrollbarThumb ?? bgColors.selectedBg,
+      searchMatchBg: bgColors.searchMatchBg ?? bgColors.selectedBg
+    };
+    for (const [key, value] of Object.entries(backgrounds)) {
+      this.bgColors.set(key, bgAnsi(value, mode));
+    }
+    this.workingIndicatorColors = new Map;
+    for (const [key, value] of Object.entries(options.workingIndicator ?? {})) {
+      this.workingIndicatorColors.set(key, fgAnsi(value, mode));
+    }
+  }
+  fg(color, text) {
+    const ansi = this.fgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme color: ${color}`);
+    return `${ansi}${text}\x1B[39m`;
+  }
+  bg(color, text) {
+    const ansi = this.bgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme background color: ${color}`);
+    return `${ansi}${text}\x1B[49m`;
+  }
+  bold(text) {
+    return chalk.bold(text);
+  }
+  italic(text) {
+    return chalk.italic(text);
+  }
+  underline(text) {
+    return chalk.underline(text);
+  }
+  inverse(text) {
+    return chalk.inverse(text);
+  }
+  strikethrough(text) {
+    return chalk.strikethrough(text);
+  }
+  getFgAnsi(color) {
+    const ansi = this.fgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme color: ${color}`);
+    return ansi;
+  }
+  getWorkingIndicatorAnsi(tone) {
+    return this.workingIndicatorColors.get(tone);
+  }
+  getBgAnsi(color) {
+    const ansi = this.bgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme background color: ${color}`);
+    return ansi;
+  }
+  getColorMode() {
+    return this.mode;
+  }
+  getThinkingBorderColor(level) {
+    switch (level) {
+      case "off":
+        return (str) => this.fg("thinkingOff", str);
+      case "minimal":
+        return (str) => this.fg("thinkingMinimal", str);
+      case "low":
+        return (str) => this.fg("thinkingLow", str);
+      case "medium":
+        return (str) => this.fg("thinkingMedium", str);
+      case "high":
+        return (str) => this.fg("thinkingHigh", str);
+      case "xhigh":
+        return (str) => this.fg("thinkingXhigh", str);
+      case "max":
+        return (str) => this.fg("thinkingXhigh", str);
+      default:
+        return (str) => this.fg("thinkingOff", str);
+    }
+  }
+  getBashModeBorderColor() {
+    return (str) => this.fg("bashMode", str);
+  }
+}
+
+// src/modes/interactive/theme/global-theme.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/modes/interactive/theme/terminal-detection.ts
+function parseAutoThemeSetting(themeSetting) {
+  if (!themeSetting)
+    return;
+  const slashIndex = themeSetting.indexOf("/");
+  if (slashIndex === -1 || themeSetting.indexOf("/", slashIndex + 1) !== -1) {
+    return;
+  }
+  const lightTheme = themeSetting.slice(0, slashIndex).trim();
+  const darkTheme = themeSetting.slice(slashIndex + 1).trim();
+  if (!lightTheme || !darkTheme) {
+    return;
+  }
+  return { lightTheme, darkTheme };
+}
+function resolveThemeSetting(themeSetting, terminalTheme) {
+  const autoTheme = parseAutoThemeSetting(themeSetting);
+  if (autoTheme) {
+    return terminalTheme === "light" ? autoTheme.lightTheme : autoTheme.darkTheme;
+  }
+  if (themeSetting?.includes("/"))
+    return;
+  if (typeof themeSetting === "string")
+    return themeSetting;
+  return;
+}
+function getColorFgBgBackgroundIndex(colorfgbg) {
+  const parts = colorfgbg.split(";");
+  for (let i = parts.length - 1;i >= 0; i--) {
+    const bg = parseInt(parts[i].trim(), 10);
+    if (Number.isInteger(bg) && bg >= 0 && bg <= 255) {
+      return bg;
+    }
+  }
+  return;
+}
+function getRgbColorLuminance({ r, g, b }) {
+  const toLinear = (channel) => {
+    const value = channel / 255;
+    return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+function getAnsiColorLuminance(index) {
+  return getRgbColorLuminance(hexToRgb(ansi256ToHex(index)));
+}
+function getThemeForRgbColor(rgb) {
+  return getRgbColorLuminance(rgb) >= 0.5 ? "light" : "dark";
+}
+function detectTerminalBackgroundFromEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const colorfgbg = env.COLORFGBG || "";
+  const bg = getColorFgBgBackgroundIndex(colorfgbg);
+  if (bg !== undefined) {
+    return {
+      theme: getAnsiColorLuminance(bg) >= 0.5 ? "light" : "dark",
+      source: "COLORFGBG",
+      detail: `background color index ${bg}`,
+      confidence: "high"
+    };
+  }
+  return {
+    theme: "dark",
+    source: "fallback",
+    detail: "no terminal background hint found",
+    confidence: "low"
+  };
+}
+async function detectTerminalBackgroundTheme({
+  ui,
+  timeoutMs,
+  env
+}) {
+  try {
+    const rgb = await ui.queryTerminalBackgroundColor({ timeoutMs });
+    if (rgb) {
+      return {
+        theme: getThemeForRgbColor(rgb),
+        source: "terminal background",
+        detail: `OSC 11 background rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
+        confidence: "high"
+      };
+    }
+  } catch {}
+  return detectTerminalBackgroundFromEnv({ env });
+}
+async function detectTerminalThemeForAuto({
+  ui,
+  timeoutMs,
+  env
+}) {
+  let colorSchemePromise;
+  try {
+    colorSchemePromise = ui.queryTerminalColorScheme({ timeoutMs });
+  } catch {}
+  const backgroundThemePromise = detectTerminalBackgroundTheme({ ui, timeoutMs, env });
+  try {
+    const colorScheme = await colorSchemePromise;
+    if (colorScheme)
+      return colorScheme;
+  } catch {}
+  return (await backgroundThemePromise).theme;
+}
+function getDefaultTheme() {
+  return detectTerminalBackgroundFromEnv().theme;
+}
+
+// src/modes/interactive/theme/theme-loading.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/modes/interactive/theme/theme-schema.ts
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+var ColorValueSchema = Type.Union([
+  Type.String(),
+  Type.Integer({ minimum: 0, maximum: 255 })
+]);
+var ThemeJsonSchema = Type.Object({
+  $schema: Type.Optional(Type.String()),
+  name: Type.String(),
+  vars: Type.Optional(Type.Record(Type.String(), ColorValueSchema)),
+  colors: Type.Object({
+    accent: ColorValueSchema,
+    border: ColorValueSchema,
+    borderAccent: ColorValueSchema,
+    borderMuted: ColorValueSchema,
+    success: ColorValueSchema,
+    error: ColorValueSchema,
+    warning: ColorValueSchema,
+    muted: ColorValueSchema,
+    dim: ColorValueSchema,
+    text: ColorValueSchema,
+    thinkingText: ColorValueSchema,
+    selectedBg: ColorValueSchema,
+    scrollbarThumb: Type.Optional(ColorValueSchema),
+    searchMatchBg: Type.Optional(ColorValueSchema),
+    searchMatchText: Type.Optional(ColorValueSchema),
+    userMessageBg: ColorValueSchema,
+    userMessageText: ColorValueSchema,
+    customMessageBg: ColorValueSchema,
+    customMessageText: ColorValueSchema,
+    customMessageLabel: ColorValueSchema,
+    toolPendingBg: ColorValueSchema,
+    toolSuccessBg: ColorValueSchema,
+    toolErrorBg: ColorValueSchema,
+    toolTitle: ColorValueSchema,
+    toolOutput: ColorValueSchema,
+    mdHeading: ColorValueSchema,
+    mdLink: ColorValueSchema,
+    mdLinkUrl: ColorValueSchema,
+    mdCode: ColorValueSchema,
+    mdCodeBlock: ColorValueSchema,
+    mdCodeBlockBorder: ColorValueSchema,
+    mdQuote: ColorValueSchema,
+    mdQuoteBorder: ColorValueSchema,
+    mdHr: ColorValueSchema,
+    mdListBullet: ColorValueSchema,
+    toolDiffAdded: ColorValueSchema,
+    toolDiffRemoved: ColorValueSchema,
+    toolDiffContext: ColorValueSchema,
+    syntaxComment: ColorValueSchema,
+    syntaxKeyword: ColorValueSchema,
+    syntaxFunction: ColorValueSchema,
+    syntaxVariable: ColorValueSchema,
+    syntaxString: ColorValueSchema,
+    syntaxNumber: ColorValueSchema,
+    syntaxType: ColorValueSchema,
+    syntaxOperator: ColorValueSchema,
+    syntaxPunctuation: ColorValueSchema,
+    thinkingOff: ColorValueSchema,
+    thinkingMinimal: ColorValueSchema,
+    thinkingLow: ColorValueSchema,
+    thinkingMedium: ColorValueSchema,
+    thinkingHigh: ColorValueSchema,
+    thinkingXhigh: ColorValueSchema,
+    bashMode: ColorValueSchema
+  }),
+  workingIndicator: Type.Optional(Type.Object({
+    dark: Type.Optional(ColorValueSchema),
+    lift: Type.Optional(ColorValueSchema),
+    muted: Type.Optional(ColorValueSchema),
+    accent: Type.Optional(ColorValueSchema),
+    bright: Type.Optional(ColorValueSchema),
+    peak: Type.Optional(ColorValueSchema)
+  })),
+  export: Type.Optional(Type.Object({
+    pageBg: Type.Optional(ColorValueSchema),
+    cardBg: Type.Optional(ColorValueSchema),
+    infoBg: Type.Optional(ColorValueSchema)
+  }))
+});
+var validateThemeJson = Compile(ThemeJsonSchema);
+
+// src/modes/interactive/theme/theme-parse.ts
+function assertThemeNameIsValid(name) {
+  if (name.includes("/")) {
+    throw new Error(`Invalid theme name "${name}": theme names cannot contain "/" because it is reserved for automatic light/dark theme settings.`);
+  }
+}
+function parseThemeJson(label, json) {
+  if (!validateThemeJson.Check(json)) {
+    const errors = Array.from(validateThemeJson.Errors(json));
+    const missingColors = new Set;
+    const otherErrors = [];
+    for (const error of errors) {
+      if (error.keyword === "required" && error.instancePath === "/colors") {
+        const requiredProperties = error.params.requiredProperties;
+        for (const requiredProperty of requiredProperties ?? []) {
+          missingColors.add(requiredProperty);
+        }
+        continue;
+      }
+      const path = error.instancePath || "/";
+      otherErrors.push(`  - ${path}: ${error.message}`);
+    }
+    let errorMessage = `Invalid theme "${label}":
+`;
+    if (missingColors.size > 0) {
+      errorMessage += `
+Missing required color tokens:
+`;
+      errorMessage += Array.from(missingColors).sort().map((color) => `  - ${color}`).join(`
+`);
+      errorMessage += `
+
+Please add these colors to your theme's "colors" object.`;
+      errorMessage += `
+See the built-in themes (dark.json, light.json) for reference values.`;
+    }
+    if (otherErrors.length > 0) {
+      errorMessage += `
+
+Other errors:
+${otherErrors.join(`
+`)}`;
+    }
+    throw new Error(errorMessage);
+  }
+  const themeJson = json;
+  assertThemeNameIsValid(themeJson.name);
+  return themeJson;
+}
+function parseThemeJsonContent(label, content) {
+  let json;
+  try {
+    json = JSON.parse(stripBom(content));
+  } catch (error) {
+    throw new Error(`Failed to parse theme ${label}: ${error}`);
+  }
+  return parseThemeJson(label, json);
+}
+
+// src/modes/interactive/theme/theme-loading.ts
+var BUILTIN_THEMES;
+var registeredThemes = new Map;
+function getBuiltinThemes() {
+  if (!BUILTIN_THEMES) {
+    const themesDir = getThemesDir();
+    const themes = {};
+    for (const file of fs.readdirSync(themesDir).sort()) {
+      if (!file.endsWith(".json") || file === "theme-schema.json") {
+        continue;
+      }
+      const themePath = path.join(themesDir, file);
+      const themeJson = parseThemeJsonContent(themePath, fs.readFileSync(themePath, "utf-8"));
+      themes[themeJson.name] = themeJson;
+    }
+    BUILTIN_THEMES = themes;
+  }
+  return BUILTIN_THEMES;
+}
+function getAvailableThemes() {
+  return getAvailableThemesWithPaths().map(({ name }) => name);
+}
+function getAvailableThemesWithPaths() {
+  const themesDir = getThemesDir();
+  const result = [];
+  const seen = new Set;
+  const addTheme = (info) => {
+    if (seen.has(info.name))
+      return;
+    seen.add(info.name);
+    result.push(info);
+  };
+  for (const name of Object.keys(getBuiltinThemes())) {
+    addTheme({ name, path: path.join(themesDir, `${name}.json`) });
+  }
+  for (const info of getCustomThemeInfos()) {
+    addTheme(info);
+  }
+  for (const [name, theme] of registeredThemes.entries()) {
+    addTheme({ name, path: theme.sourcePath });
+  }
+  return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+function getCustomThemeInfos() {
+  const customThemesDir = getCustomThemesDir();
+  const result = [];
+  if (!fs.existsSync(customThemesDir)) {
+    return result;
+  }
+  for (const file of fs.readdirSync(customThemesDir)) {
+    if (!file.endsWith(".json")) {
+      continue;
+    }
+    const themePath = path.join(customThemesDir, file);
+    try {
+      const customTheme = loadThemeFromPath(themePath);
+      if (customTheme.name) {
+        result.push({ name: customTheme.name, path: themePath });
+      }
+    } catch {}
+  }
+  return result;
+}
+function loadThemeJson(name) {
+  const builtinThemes = getBuiltinThemes();
+  if (name in builtinThemes) {
+    return builtinThemes[name];
+  }
+  const registeredTheme = registeredThemes.get(name);
+  if (registeredTheme?.sourcePath) {
+    const content2 = fs.readFileSync(registeredTheme.sourcePath, "utf-8");
+    return parseThemeJsonContent(registeredTheme.sourcePath, content2);
+  }
+  if (registeredTheme) {
+    throw new Error(`Theme "${name}" does not have a source path for export`);
+  }
+  const customThemesDir = getCustomThemesDir();
+  const themePath = path.join(customThemesDir, `${name}.json`);
+  if (!fs.existsSync(themePath)) {
+    throw new Error(`Theme not found: ${name}`);
+  }
+  const content = fs.readFileSync(themePath, "utf-8");
+  return parseThemeJsonContent(name, content);
+}
+function createTheme(themeJson, mode, sourcePath) {
+  const colorMode = mode ?? detectColorMode();
+  const resolvedColors = resolveThemeColors(themeJson.colors, themeJson.vars);
+  const workingIndicator = themeJson.workingIndicator ? resolveThemeColors(themeJson.workingIndicator, themeJson.vars) : undefined;
+  const fgColors = {};
+  const bgColors = {};
+  const bgColorKeys = new Set([
+    "selectedBg",
+    "scrollbarThumb",
+    "searchMatchBg",
+    "userMessageBg",
+    "customMessageBg",
+    "toolPendingBg",
+    "toolSuccessBg",
+    "toolErrorBg"
+  ]);
+  for (const [key, value] of Object.entries(resolvedColors)) {
+    if (bgColorKeys.has(key)) {
+      bgColors[key] = value;
+    } else {
+      fgColors[key] = value;
+    }
+  }
+  return new Theme(fgColors, bgColors, colorMode, {
+    name: themeJson.name,
+    sourcePath,
+    workingIndicator
+  });
+}
+function loadThemeFromPath(themePath, mode) {
+  const content = fs.readFileSync(themePath, "utf-8");
+  return loadThemeFromContent(themePath, content, mode);
+}
+function loadThemeFromContent(themePath, content, mode) {
+  const themeJson = parseThemeJsonContent(themePath, content);
+  return createTheme(themeJson, mode, themePath);
+}
+function loadTheme(name, mode) {
+  const registeredTheme = registeredThemes.get(name);
+  if (registeredTheme) {
+    return registeredTheme;
+  }
+  const themeJson = loadThemeJson(name);
+  return createTheme(themeJson, mode);
+}
+function getThemeByName(name) {
+  try {
+    return loadTheme(name);
+  } catch {
+    return;
+  }
+}
+function setRegisteredThemes(themes) {
+  registeredThemes.clear();
+  for (const theme of themes) {
+    if (theme.name) {
+      assertThemeNameIsValid(theme.name);
+      registeredThemes.set(theme.name, theme);
+    }
+  }
+}
+function setRegisteredTheme(name, theme) {
+  registeredThemes.set(name, theme);
+}
+
+// src/modes/interactive/theme/global-theme.ts
+var THEME_KEY = Symbol.for("@bastani/atomic:theme");
+var THEME_KEY_OLD = Symbol.for("@bastani/atomic:theme");
+var theme = new Proxy({}, {
+  get(_target, prop) {
+    const t = globalThis[THEME_KEY];
+    if (!t)
+      throw new Error("Theme not initialized. Call initTheme() first.");
+    return t[prop];
+  }
+});
+function setGlobalTheme(t) {
+  globalThis[THEME_KEY] = t;
+  globalThis[THEME_KEY_OLD] = t;
+}
+var currentThemeName;
+var themeWatcher;
+var themeReloadTimer;
+var themeWatchFilePath;
+var themeWatchFileListener;
+var onThemeChangeCallback;
+function getCurrentThemeName() {
+  return currentThemeName;
+}
+function initTheme(themeName, enableWatcher = false) {
+  const name = themeName ?? getDefaultTheme();
+  currentThemeName = name;
+  try {
+    setGlobalTheme(loadTheme(name));
+    if (enableWatcher) {
+      startThemeWatcher();
+    }
+  } catch (_error) {
+    currentThemeName = "dark";
+    setGlobalTheme(loadTheme("dark"));
+  }
+}
+function setTheme(name, enableWatcher = false) {
+  currentThemeName = name;
+  try {
+    setGlobalTheme(loadTheme(name));
+    if (enableWatcher) {
+      startThemeWatcher();
+    }
+    if (onThemeChangeCallback) {
+      onThemeChangeCallback();
+    }
+    return { success: true };
+  } catch (error) {
+    currentThemeName = "dark";
+    setGlobalTheme(loadTheme("dark"));
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function setThemeInstance(themeInstance) {
+  setGlobalTheme(themeInstance);
+  currentThemeName = "<in-memory>";
+  stopThemeWatcher();
+  if (onThemeChangeCallback) {
+    onThemeChangeCallback();
+  }
+}
+function onThemeChange(callback) {
+  onThemeChangeCallback = callback;
+}
+function startThemeWatcher() {
+  stopThemeWatcher();
+  if (!currentThemeName || currentThemeName in getBuiltinThemes()) {
+    return;
+  }
+  const customThemesDir = getCustomThemesDir();
+  const watchedThemeName = currentThemeName;
+  const watchedFileName = `${watchedThemeName}.json`;
+  const themeFile = path2.join(customThemesDir, watchedFileName);
+  if (!fs2.existsSync(themeFile)) {
+    return;
+  }
+  const scheduleReload = () => {
+    if (themeReloadTimer) {
+      clearTimeout(themeReloadTimer);
+    }
+    themeReloadTimer = setTimeout(() => {
+      themeReloadTimer = undefined;
+      if (currentThemeName !== watchedThemeName) {
+        return;
+      }
+      if (!fs2.existsSync(themeFile)) {
+        return;
+      }
+      try {
+        const reloadedTheme = loadThemeFromPath(themeFile);
+        setRegisteredTheme(watchedThemeName, reloadedTheme);
+        setGlobalTheme(reloadedTheme);
+        if (onThemeChangeCallback) {
+          onThemeChangeCallback();
+        }
+      } catch (_error) {}
+    }, 100);
+  };
+  const startPollingFallback = () => {
+    if (themeWatchFilePath && themeWatchFileListener) {
+      return;
+    }
+    themeWatchFilePath = themeFile;
+    themeWatchFileListener = (current, previous) => {
+      if (current.mtimeMs !== previous.mtimeMs || current.ctimeMs !== previous.ctimeMs || current.size !== previous.size) {
+        scheduleReload();
+      }
+    };
+    fs2.watchFile(themeFile, { interval: 1000 }, themeWatchFileListener);
+  };
+  themeWatcher = watchWithErrorHandler(customThemesDir, (_eventType, filename) => {
+    if (currentThemeName !== watchedThemeName) {
+      return;
+    }
+    if (!filename) {
+      scheduleReload();
+      return;
+    }
+    if (filename !== watchedFileName) {
+      return;
+    }
+    scheduleReload();
+  }, (error) => {
+    closeWatcher(themeWatcher);
+    themeWatcher = undefined;
+    if (isSafeFsWatchPathError(error)) {
+      startPollingFallback();
+    }
+  }) ?? undefined;
+}
+function stopThemeWatcher() {
+  if (themeReloadTimer) {
+    clearTimeout(themeReloadTimer);
+    themeReloadTimer = undefined;
+  }
+  closeWatcher(themeWatcher);
+  themeWatcher = undefined;
+  if (themeWatchFilePath && themeWatchFileListener) {
+    fs2.unwatchFile(themeWatchFilePath, themeWatchFileListener);
+  }
+  themeWatchFilePath = undefined;
+  themeWatchFileListener = undefined;
+}
+
+// src/modes/interactive/theme/export-colors.ts
+function getResolvedThemeColors(themeName) {
+  const name = themeName ?? getCurrentThemeName() ?? getDefaultTheme();
+  const isLight = isLightTheme(name);
+  const themeJson = loadThemeJson(name);
+  const resolved = resolveThemeColors(themeJson.colors, themeJson.vars);
+  const defaultText = isLight ? "#000000" : "#e5e5e7";
+  const cssColors = {};
+  for (const [key, value] of Object.entries(resolved)) {
+    if (typeof value === "number") {
+      cssColors[key] = ansi256ToHex(value);
+    } else if (value === "") {
+      cssColors[key] = defaultText;
+    } else {
+      cssColors[key] = value;
+    }
+  }
+  return cssColors;
+}
+function isLightTheme(themeName) {
+  return themeName === "light" || themeName === "catppuccin-latte";
+}
+function getThemeExportColors(themeName) {
+  const name = themeName ?? getCurrentThemeName() ?? getDefaultTheme();
+  try {
+    const themeJson = loadThemeJson(name);
+    const exportSection = themeJson.export;
+    if (!exportSection)
+      return {};
+    const vars = themeJson.vars ?? {};
+    const resolve4 = (value) => {
+      if (value === undefined)
+        return;
+      const resolved = resolveVarRefs(value, vars);
+      if (typeof resolved === "number")
+        return ansi256ToHex(resolved);
+      if (resolved === "")
+        return;
+      return resolved;
+    };
+    return {
+      pageBg: resolve4(exportSection.pageBg),
+      cardBg: resolve4(exportSection.cardBg),
+      infoBg: resolve4(exportSection.infoBg)
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/modes/interactive/theme/tui-theme.ts
+import chalk2 from "chalk";
+
+// src/utils/syntax-highlight.ts
+import hljs from "highlight.js/lib/core.js";
+import bash from "highlight.js/lib/languages/bash.js";
+import c from "highlight.js/lib/languages/c.js";
+import cpp from "highlight.js/lib/languages/cpp.js";
+import csharp from "highlight.js/lib/languages/csharp.js";
+import dart from "highlight.js/lib/languages/dart.js";
+import go from "highlight.js/lib/languages/go.js";
+import groovy from "highlight.js/lib/languages/groovy.js";
+import java from "highlight.js/lib/languages/java.js";
+import javascript from "highlight.js/lib/languages/javascript.js";
+import kotlin from "highlight.js/lib/languages/kotlin.js";
+import lua from "highlight.js/lib/languages/lua.js";
+import nix from "highlight.js/lib/languages/nix.js";
+import perl from "highlight.js/lib/languages/perl.js";
+import php from "highlight.js/lib/languages/php.js";
+import python from "highlight.js/lib/languages/python.js";
+import ruby from "highlight.js/lib/languages/ruby.js";
+import rust from "highlight.js/lib/languages/rust.js";
+import scala from "highlight.js/lib/languages/scala.js";
+import swift from "highlight.js/lib/languages/swift.js";
+import typescript from "highlight.js/lib/languages/typescript.js";
+
+// src/utils/html.ts
+function decodeCodePoint(codePoint) {
+  if (!Number.isInteger(codePoint) || codePoint < 0 || codePoint > 1114111) {
+    return;
+  }
+  return String.fromCodePoint(codePoint);
+}
+function decodeHtmlEntity(entity) {
+  switch (entity) {
+    case "amp":
+      return "&";
+    case "lt":
+      return "<";
+    case "gt":
+      return ">";
+    case "quot":
+      return '"';
+    case "apos":
+      return "'";
+  }
+  if (entity.startsWith("#x") || entity.startsWith("#X")) {
+    return decodeCodePoint(Number.parseInt(entity.slice(2), 16));
+  }
+  if (entity.startsWith("#")) {
+    return decodeCodePoint(Number.parseInt(entity.slice(1), 10));
+  }
+  return;
+}
+function decodeHtmlEntityAt(html, index) {
+  const semicolonIndex = html.indexOf(";", index + 1);
+  if (semicolonIndex === -1 || semicolonIndex - index > 16) {
+    return;
+  }
+  const entity = html.slice(index + 1, semicolonIndex);
+  const decoded = decodeHtmlEntity(entity);
+  if (decoded === undefined) {
+    return;
+  }
+  return { text: decoded, length: semicolonIndex - index + 1 };
+}
+
+// src/utils/syntax-highlight.ts
+var eagerLanguages = {
+  python,
+  java,
+  go,
+  javascript,
+  cpp,
+  typescript,
+  php,
+  ruby,
+  c,
+  csharp,
+  nix,
+  bash,
+  rust,
+  scala,
+  kotlin,
+  swift,
+  dart,
+  groovy,
+  perl,
+  lua
+};
+for (const [name, language] of Object.entries(eagerLanguages)) {
+  hljs.registerLanguage(name, language);
+}
+var allLanguagesPromise;
+function loadAllHighlightLanguages() {
+  if (!allLanguagesPromise) {
+    allLanguagesPromise = new Promise((resolve4) => {
+      setImmediate(() => {
+        import("highlight.js/lib/index.js").then(() => resolve4(), () => {
+          resolve4();
+        });
+      });
+    });
+  }
+  return allLanguagesPromise;
+}
+var SPAN_CLOSE = "</span>";
+var HIGHLIGHT_CLASS_PREFIX = "hljs-";
+function getScopeFromSpanTag(tag) {
+  const match = /\sclass\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(tag);
+  const classValue = match?.[1] ?? match?.[2];
+  if (!classValue) {
+    return;
+  }
+  for (const className of classValue.split(/\s+/)) {
+    if (className.startsWith(HIGHLIGHT_CLASS_PREFIX)) {
+      return className.slice(HIGHLIGHT_CLASS_PREFIX.length);
+    }
+  }
+  return;
+}
+function getScopeFormatter(scope, theme2) {
+  const exact = theme2[scope];
+  if (exact) {
+    return exact;
+  }
+  const dotIndex = scope.indexOf(".");
+  if (dotIndex !== -1) {
+    const prefixFormatter = theme2[scope.slice(0, dotIndex)];
+    if (prefixFormatter) {
+      return prefixFormatter;
+    }
+  }
+  const dashIndex = scope.indexOf("-");
+  if (dashIndex !== -1) {
+    const prefixFormatter = theme2[scope.slice(0, dashIndex)];
+    if (prefixFormatter) {
+      return prefixFormatter;
+    }
+  }
+  return;
+}
+function getActiveFormatter(scopes, theme2) {
+  for (let i = scopes.length - 1;i >= 0; i--) {
+    const scope = scopes[i];
+    if (!scope) {
+      continue;
+    }
+    const formatter = getScopeFormatter(scope, theme2);
+    if (formatter) {
+      return formatter;
+    }
+  }
+  return theme2.default;
+}
+function isSpanOpenTagStart(html, index) {
+  if (!html.startsWith("<span", index)) {
+    return false;
+  }
+  const nextChar = html[index + "<span".length];
+  return nextChar === ">" || nextChar === " " || nextChar === "\t" || nextChar === `
+` || nextChar === "\r";
+}
+function renderHighlightedHtml(html, theme2 = {}) {
+  let output = "";
+  let textBuffer = "";
+  const scopes = [];
+  const flushText = () => {
+    if (!textBuffer) {
+      return;
+    }
+    const formatter = getActiveFormatter(scopes, theme2);
+    output += formatter ? formatter(textBuffer) : textBuffer;
+    textBuffer = "";
+  };
+  let index = 0;
+  while (index < html.length) {
+    if (isSpanOpenTagStart(html, index)) {
+      const tagEndIndex = html.indexOf(">", index + 5);
+      if (tagEndIndex !== -1) {
+        flushText();
+        const tag = html.slice(index, tagEndIndex + 1);
+        const scope = getScopeFromSpanTag(tag);
+        scopes.push(scope);
+        index = tagEndIndex + 1;
+        continue;
+      }
+    }
+    if (html.startsWith(SPAN_CLOSE, index)) {
+      flushText();
+      if (scopes.length > 0) {
+        scopes.pop();
+      }
+      index += SPAN_CLOSE.length;
+      continue;
+    }
+    if (html[index] === "&") {
+      const decoded = decodeHtmlEntityAt(html, index);
+      if (decoded) {
+        textBuffer += decoded.text;
+        index += decoded.length;
+        continue;
+      }
+    }
+    textBuffer += html[index];
+    index++;
+  }
+  flushText();
+  return output;
+}
+function highlight(code, options = {}) {
+  const html = options.language ? hljs.highlight(code, {
+    language: options.language,
+    ignoreIllegals: options.ignoreIllegals
+  }).value : hljs.highlightAuto(code, options.languageSubset).value;
+  return renderHighlightedHtml(html, options.theme);
+}
+function supportsLanguage(name) {
+  return hljs.getLanguage(name) !== undefined;
+}
+
+// src/modes/interactive/theme/tui-theme.ts
+var cachedHighlightThemeFor;
+var cachedCliHighlightTheme;
+function buildCliHighlightTheme(t) {
+  return {
+    keyword: (s) => t.fg("syntaxKeyword", s),
+    built_in: (s) => t.fg("syntaxType", s),
+    literal: (s) => t.fg("syntaxNumber", s),
+    number: (s) => t.fg("syntaxNumber", s),
+    regexp: (s) => t.fg("syntaxString", s),
+    string: (s) => t.fg("syntaxString", s),
+    comment: (s) => t.fg("syntaxComment", s),
+    doctag: (s) => t.fg("syntaxComment", s),
+    meta: (s) => t.fg("muted", s),
+    function: (s) => t.fg("syntaxFunction", s),
+    title: (s) => t.fg("syntaxFunction", s),
+    class: (s) => t.fg("syntaxType", s),
+    type: (s) => t.fg("syntaxType", s),
+    tag: (s) => t.fg("syntaxPunctuation", s),
+    name: (s) => t.fg("syntaxKeyword", s),
+    attr: (s) => t.fg("syntaxVariable", s),
+    variable: (s) => t.fg("syntaxVariable", s),
+    params: (s) => t.fg("syntaxVariable", s),
+    operator: (s) => t.fg("syntaxOperator", s),
+    punctuation: (s) => t.fg("syntaxPunctuation", s),
+    emphasis: (s) => t.italic(s),
+    strong: (s) => t.bold(s),
+    link: (s) => t.underline(s),
+    addition: (s) => t.fg("toolDiffAdded", s),
+    deletion: (s) => t.fg("toolDiffRemoved", s)
+  };
+}
+function getCliHighlightTheme(t) {
+  if (cachedHighlightThemeFor !== t || !cachedCliHighlightTheme) {
+    cachedHighlightThemeFor = t;
+    cachedCliHighlightTheme = buildCliHighlightTheme(t);
+  }
+  return cachedCliHighlightTheme;
+}
+function highlightCode(code, lang) {
+  const validLang = lang && supportsLanguage(lang) ? lang : undefined;
+  if (!validLang) {
+    return code.split(`
+`).map((line) => theme.fg("mdCodeBlock", line));
+  }
+  const opts = {
+    language: validLang,
+    ignoreIllegals: true,
+    theme: getCliHighlightTheme(theme)
+  };
+  try {
+    return highlight(code, opts).split(`
+`);
+  } catch {
+    return code.split(`
+`);
+  }
+}
+function getLanguageFromPath(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  if (!ext)
+    return;
+  const extToLang = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    kt: "kotlin",
+    swift: "swift",
+    c: "c",
+    h: "c",
+    cpp: "cpp",
+    cc: "cpp",
+    cxx: "cpp",
+    hpp: "cpp",
+    cs: "csharp",
+    php: "php",
+    sh: "bash",
+    bash: "bash",
+    zsh: "bash",
+    fish: "fish",
+    ps1: "powershell",
+    sql: "sql",
+    html: "html",
+    htm: "html",
+    css: "css",
+    scss: "scss",
+    sass: "sass",
+    less: "less",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "toml",
+    xml: "xml",
+    md: "markdown",
+    markdown: "markdown",
+    dockerfile: "dockerfile",
+    makefile: "makefile",
+    cmake: "cmake",
+    lua: "lua",
+    perl: "perl",
+    r: "r",
+    scala: "scala",
+    clj: "clojure",
+    ex: "elixir",
+    exs: "elixir",
+    erl: "erlang",
+    hs: "haskell",
+    ml: "ocaml",
+    vim: "vim",
+    graphql: "graphql",
+    proto: "protobuf",
+    tf: "hcl",
+    hcl: "hcl"
+  };
+  return extToLang[ext];
+}
+function getMarkdownTheme() {
+  return {
+    heading: (text) => theme.fg("mdHeading", text),
+    link: (text) => theme.fg("mdLink", text),
+    linkUrl: (text) => theme.fg("mdLinkUrl", text),
+    code: (text) => theme.fg("mdCode", text),
+    codeBlock: (text) => theme.fg("mdCodeBlock", text),
+    codeBlockBorder: (text) => theme.fg("mdCodeBlockBorder", text),
+    quote: (text) => theme.fg("mdQuote", text),
+    quoteBorder: (text) => theme.fg("mdQuoteBorder", text),
+    hr: (text) => theme.fg("mdHr", text),
+    listBullet: (text) => theme.fg("mdListBullet", text),
+    bold: (text) => theme.bold(text),
+    italic: (text) => theme.italic(text),
+    underline: (text) => theme.underline(text),
+    strikethrough: (text) => chalk2.strikethrough(text),
+    highlightCode: (code, lang) => {
+      const validLang = lang && supportsLanguage(lang) ? lang : undefined;
+      if (!validLang) {
+        return code.split(`
+`).map((line) => theme.fg("mdCodeBlock", line));
+      }
+      const opts = {
+        language: validLang,
+        ignoreIllegals: true,
+        theme: getCliHighlightTheme(theme)
+      };
+      try {
+        return highlight(code, opts).split(`
+`);
+      } catch {
+        return code.split(`
+`).map((line) => theme.fg("mdCodeBlock", line));
+      }
+    }
+  };
+}
+function getSelectListTheme() {
+  return {
+    selectedPrefix: (text) => theme.fg("accent", text),
+    selectedText: (text) => theme.fg("accent", text),
+    description: (text) => theme.fg("muted", text),
+    scrollInfo: (text) => theme.fg("muted", text),
+    noMatch: (text) => theme.fg("muted", text)
+  };
+}
+function getEditorTheme() {
+  return {
+    borderColor: (text) => theme.fg("borderMuted", text),
+    selectList: getSelectListTheme()
+  };
+}
+function getSettingsListTheme() {
+  return {
+    label: (text, selected) => selected ? theme.fg("accent", text) : text,
+    value: (text, selected) => selected ? theme.fg("accent", text) : theme.fg("muted", text),
+    description: (text) => theme.fg("dim", text),
+    cursor: theme.fg("accent", "→ "),
+    hint: (text) => theme.fg("dim", text)
+  };
+}
+export { requiredEntriesForBuiltin, stripBom, createChildProcessEnvironment, spawnProcess, spawnProcessSync, waitForChildProcess, getHomeDir, canonicalizePath, isLocalPath, normalizePath, resolvePath, getCwdRelativePath, formatPathRelativeToCwdOrAbsolute, markPathIgnoredByCloudSync, moduleDirFromMetaUrl, isBunBinary, isBundledBuild, detectInstallMethod, getSelfUpdateCommand, getSelfUpdateUnavailableInstruction, getPackageDir, getThemesDir, getExportTemplateDir, getPackageJsonPath, getReadmePath, getDocsPath, getExamplesPath, getChangelogPath, getInteractiveAssetsDir, getBundledInteractiveAssetPath, PACKAGE_NAME, APP_NAME, APP_TITLE, CONFIG_DIR_NAME, LEGACY_CONFIG_DIR_NAME, CONFIG_DIR_NAMES, VERSION, CHANGELOG_URL, LEGACY_ENV_PREFIX, ENV_AGENT_DIR, ENV_SESSION_DIR, ENV_PACKAGE_DIR, ENV_OFFLINE, ENV_SKIP_VERSION_CHECK, ENV_STARTUP_BENCHMARK, ENV_TELEMETRY, ENV_SHARE_VIEWER_URL, ENV_CLEAR_ON_SHRINK, ENV_HARDWARE_CURSOR, ENV_TIMING, ENV_CODEX_FAST_MODE, WORKFLOW_STAGE_SUBAGENT_GUARD_ENV, getCodexFastModeEnvironmentSettings, setCodexFastModeEnvironmentSettings, getEnvNames, getEnvValue, hasEnvValue, setEnvValue, expandTildePath, getShareViewerUrl, getAgentDir, getLegacyAgentDir, getAgentDirs, getUserConfigDirs, getProjectConfigDirs, getUserConfigPaths, getAgentConfigPaths, getProjectConfigPaths, getAuthPath, getSettingsPath, getBinDir, getExtensionTranspileCacheDir, getDebugLogPath, normalizeMessageContent, userLikeContentBlockIsLlmVisible, messageStartsLlmUserTurn, messageIsLlmVisible, VERBATIM_COMPACTION_PREFIX, isVerbatimCompactionMessage, createVerbatimCompactionMessage, createBranchSummaryMessage, createCustomMessage, repairOrphanToolResults, convertToLlm, filteredMarker, serializeConversationForCompaction, createNumberedRegion, numberRegionLines, normalizeDerivedSessionEntries, getLatestCompactionBoundaryEntry, sessionEntryToContextMessages, buildContextEntries, buildSessionContext, WORKFLOW_SESSION_METADATA_ENV, workflowSessionMetadataFromEnv, CURRENT_SESSION_VERSION, assertValidSessionId, getLastConversationMessageId, getLatestSessionSummary, getDefaultSessionDir, yieldToEventLoop, yieldToEventLoopIfSlow, migrateSessionEntries, parseSessionEntries, SessionManager, hexToRgb, fgAnsi, ansi256ToHex, FS_WATCH_RETRY_DELAY_MS, SAFE_FS_WATCH_CANONICALIZATION_FAILED, SAFE_FS_WATCH_UNSAFE_WINDOWS_SHORT_PATH, closeWatcher, isUnsafeWindowsShortPath, isSafeFsWatchPathError, resolveNativeWatchPath, watchWithErrorHandler, parseAutoThemeSetting, resolveThemeSetting, detectTerminalBackgroundFromEnv, detectTerminalBackgroundTheme, detectTerminalThemeForAuto, Theme, getAvailableThemes, getAvailableThemesWithPaths, loadThemeFromContent, getThemeByName, setRegisteredThemes, theme, initTheme, setTheme, setThemeInstance, onThemeChange, stopThemeWatcher, getResolvedThemeColors, getThemeExportColors, loadAllHighlightLanguages, highlightCode, getLanguageFromPath, getMarkdownTheme, getSelectListTheme, getEditorTheme, getSettingsListTheme };