aisnitch 0.2.20 → 0.2.22

package/dist/cli/index.cjs

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,733 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
+function hasDockerEnv() {
+  try {
+    import_node_fs4.default.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return import_node_fs4.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var import_node_fs4, isDockerCached;
+var init_is_docker = __esm({
+  "node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js"() {
+    "use strict";
+    import_node_fs4 = __toESM(require("fs"), 1);
+  }
+});
+
+// node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var import_node_fs5, cachedResult, hasContainerEnv;
+var init_is_inside_container = __esm({
+  "node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js"() {
+    "use strict";
+    import_node_fs5 = __toESM(require("fs"), 1);
+    init_is_docker();
+    hasContainerEnv = () => {
+      try {
+        import_node_fs5.default.statSync("/run/.containerenv");
+        return true;
+      } catch {
+        return false;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/is-wsl@3.1.1/node_modules/is-wsl/index.js
+var import_node_process, import_node_os5, import_node_fs6, isWsl, is_wsl_default;
+var init_is_wsl = __esm({
+  "node_modules/.pnpm/is-wsl@3.1.1/node_modules/is-wsl/index.js"() {
+    "use strict";
+    import_node_process = __toESM(require("process"), 1);
+    import_node_os5 = __toESM(require("os"), 1);
+    import_node_fs6 = __toESM(require("fs"), 1);
+    init_is_inside_container();
+    isWsl = () => {
+      if (import_node_process.default.platform !== "linux") {
+        return false;
+      }
+      if (import_node_os5.default.release().toLowerCase().includes("microsoft")) {
+        if (isInsideContainer()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        if (import_node_fs6.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+          return !isInsideContainer();
+        }
+      } catch {
+      }
+      if (import_node_fs6.default.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || import_node_fs6.default.existsSync("/run/WSL")) {
+        return !isInsideContainer();
+      }
+      return false;
+    };
+    is_wsl_default = import_node_process.default.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+  }
+});
+
+// node_modules/.pnpm/powershell-utils@0.1.0/node_modules/powershell-utils/index.js
+var import_node_process2, import_node_buffer, import_node_util15, import_node_child_process16, import_promises19, execFile15, powerShellPath, executePowerShell;
+var init_powershell_utils = __esm({
+  "node_modules/.pnpm/powershell-utils@0.1.0/node_modules/powershell-utils/index.js"() {
+    "use strict";
+    import_node_process2 = __toESM(require("process"), 1);
+    import_node_buffer = require("buffer");
+    import_node_util15 = require("util");
+    import_node_child_process16 = __toESM(require("child_process"), 1);
+    import_promises19 = __toESM(require("fs/promises"), 1);
+    execFile15 = (0, import_node_util15.promisify)(import_node_child_process16.default.execFile);
+    powerShellPath = () => `${import_node_process2.default.env.SYSTEMROOT || import_node_process2.default.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    executePowerShell = async (command, options = {}) => {
+      const {
+        powerShellPath: psPath,
+        ...execFileOptions
+      } = options;
+      const encodedCommand = executePowerShell.encodeCommand(command);
+      return execFile15(
+        psPath ?? powerShellPath(),
+        [
+          ...executePowerShell.argumentsPrefix,
+          encodedCommand
+        ],
+        {
+          encoding: "utf8",
+          ...execFileOptions
+        }
+      );
+    };
+    executePowerShell.argumentsPrefix = [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand"
+    ];
+    executePowerShell.encodeCommand = (command) => import_node_buffer.Buffer.from(command, "utf16le").toString("base64");
+    executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+  }
+});
+
+// node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/utilities.js
+function parseMountPointFromConfig(content) {
+  for (const line of content.split("\n")) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+var init_utilities = __esm({
+  "node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/utilities.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js
+var import_node_util16, import_node_child_process17, import_promises20, execFile16, wslDrivesMountPoint, powerShellPathFromWsl, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell, wslDefaultBrowser, convertWslPathToWindows;
+var init_wsl_utils = __esm({
+  "node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js"() {
+    "use strict";
+    import_node_util16 = require("util");
+    import_node_child_process17 = __toESM(require("child_process"), 1);
+    import_promises20 = __toESM(require("fs/promises"), 1);
+    init_is_wsl();
+    init_powershell_utils();
+    init_utilities();
+    init_is_wsl();
+    execFile16 = (0, import_node_util16.promisify)(import_node_child_process17.default.execFile);
+    wslDrivesMountPoint = /* @__PURE__ */ (() => {
+      const defaultMountPoint = "/mnt/";
+      let mountPoint;
+      return async function() {
+        if (mountPoint) {
+          return mountPoint;
+        }
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+          await import_promises20.default.access(configFilePath, import_promises20.constants.F_OK);
+          isConfigFileExists = true;
+        } catch {
+        }
+        if (!isConfigFileExists) {
+          return defaultMountPoint;
+        }
+        const configContent = await import_promises20.default.readFile(configFilePath, { encoding: "utf8" });
+        const parsedMountPoint = parseMountPointFromConfig(configContent);
+        if (parsedMountPoint === void 0) {
+          return defaultMountPoint;
+        }
+        mountPoint = parsedMountPoint;
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+      };
+    })();
+    powerShellPathFromWsl = async () => {
+      const mountPoint = await wslDrivesMountPoint();
+      return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+    };
+    powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+    canAccessPowerShell = async () => {
+      canAccessPowerShellPromise ??= (async () => {
+        try {
+          const psPath = await powerShellPath2();
+          await import_promises20.default.access(psPath, import_promises20.constants.X_OK);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      return canAccessPowerShellPromise;
+    };
+    wslDefaultBrowser = async () => {
+      const psPath = await powerShellPath2();
+      const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+      const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+      return stdout.trim();
+    };
+    convertWslPathToWindows = async (path2) => {
+      if (/^[a-z]+:\/\//i.test(path2)) {
+        return path2;
+      }
+      try {
+        const { stdout } = await execFile16("wslpath", ["-aw", path2], { encoding: "utf8" });
+        return stdout.trim();
+      } catch {
+        return path2;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+var init_define_lazy_prop = __esm({
+  "node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
+async function defaultBrowserId() {
+  if (import_node_process3.default.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync2("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var import_node_util17, import_node_process3, import_node_child_process18, execFileAsync2;
+var init_default_browser_id = __esm({
+  "node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js"() {
+    "use strict";
+    import_node_util17 = require("util");
+    import_node_process3 = __toESM(require("process"), 1);
+    import_node_child_process18 = require("child_process");
+    execFileAsync2 = (0, import_node_util17.promisify)(import_node_child_process18.execFile);
+  }
+});
+
+// node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (import_node_process4.default.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync3("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+var import_node_process4, import_node_util18, import_node_child_process19, execFileAsync3;
+var init_run_applescript = __esm({
+  "node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js"() {
+    "use strict";
+    import_node_process4 = __toESM(require("process"), 1);
+    import_node_util18 = require("util");
+    import_node_child_process19 = require("child_process");
+    execFileAsync3 = (0, import_node_util18.promisify)(import_node_child_process19.execFile);
+  }
+});
+
+// node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var init_bundle_name = __esm({
+  "node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js"() {
+    "use strict";
+    init_run_applescript();
+  }
+});
+
+// node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/windows.js
+async function defaultBrowser(_execFileAsync = execFileAsync4) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? void 0 : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? void 0 : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+var import_node_util19, import_node_child_process20, execFileAsync4, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
+var init_windows = __esm({
+  "node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/windows.js"() {
+    "use strict";
+    import_node_util19 = require("util");
+    import_node_child_process20 = require("child_process");
+    execFileAsync4 = (0, import_node_util19.promisify)(import_node_child_process20.execFile);
+    windowsBrowserProgIds = {
+      MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+      // The missing `L` is correct.
+      MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+      MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+      AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+      ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+      ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+      ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+      ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+      BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+      BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+      BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+      BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+      FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+      OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+      VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+      "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+    };
+    _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+    UnknownBrowserError = class extends Error {
+    };
+  }
+});
+
+// node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/index.js
+async function defaultBrowser2() {
+  if (import_node_process5.default.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (import_node_process5.default.platform === "linux") {
+    const { stdout } = await execFileAsync5("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (import_node_process5.default.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var import_node_util20, import_node_process5, import_node_child_process21, execFileAsync5, titleize;
+var init_default_browser = __esm({
+  "node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/index.js"() {
+    "use strict";
+    import_node_util20 = require("util");
+    import_node_process5 = __toESM(require("process"), 1);
+    import_node_child_process21 = require("child_process");
+    init_default_browser_id();
+    init_bundle_name();
+    init_windows();
+    init_windows();
+    execFileAsync5 = (0, import_node_util20.promisify)(import_node_child_process21.execFile);
+    titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+  }
+});
+
+// node_modules/.pnpm/is-in-ssh@1.0.0/node_modules/is-in-ssh/index.js
+var import_node_process6, isInSsh, is_in_ssh_default;
+var init_is_in_ssh = __esm({
+  "node_modules/.pnpm/is-in-ssh@1.0.0/node_modules/is-in-ssh/index.js"() {
+    "use strict";
+    import_node_process6 = __toESM(require("process"), 1);
+    isInSsh = Boolean(import_node_process6.default.env.SSH_CONNECTION || import_node_process6.default.env.SSH_CLIENT || import_node_process6.default.env.SSH_TTY);
+    is_in_ssh_default = isInSsh;
+  }
+});
+
+// node_modules/.pnpm/open@11.0.0/node_modules/open/index.js
+var open_exports = {};
+__export(open_exports, {
+  apps: () => apps,
+  default: () => open_default,
+  openApp: () => openApp
+});
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var import_node_process7, import_node_path21, import_node_url, import_node_child_process22, import_promises21, import_meta, fallbackAttemptSymbol, __dirname, localXdgOpenPath, platform, arch, tryEachApp, baseOpen, open, openApp, apps, open_default;
+var init_open = __esm({
+  "node_modules/.pnpm/open@11.0.0/node_modules/open/index.js"() {
+    "use strict";
+    import_node_process7 = __toESM(require("process"), 1);
+    import_node_path21 = __toESM(require("path"), 1);
+    import_node_url = require("url");
+    import_node_child_process22 = __toESM(require("child_process"), 1);
+    import_promises21 = __toESM(require("fs/promises"), 1);
+    init_wsl_utils();
+    init_powershell_utils();
+    init_define_lazy_prop();
+    init_default_browser();
+    init_is_inside_container();
+    init_is_in_ssh();
+    import_meta = {};
+    fallbackAttemptSymbol = /* @__PURE__ */ Symbol("fallbackAttempt");
+    __dirname = import_meta.url ? import_node_path21.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url)) : "";
+    localXdgOpenPath = import_node_path21.default.join(__dirname, "xdg-open");
+    ({ platform, arch } = import_node_process7.default);
+    tryEachApp = async (apps2, opener) => {
+      if (apps2.length === 0) {
+        return;
+      }
+      const errors = [];
+      for (const app of apps2) {
+        try {
+          return await opener(app);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      throw new AggregateError(errors, "Failed to open in all supported apps");
+    };
+    baseOpen = async (options) => {
+      options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+      };
+      const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+      delete options[fallbackAttemptSymbol];
+      if (Array.isArray(options.app)) {
+        return tryEachApp(options.app, (singleApp) => baseOpen({
+          ...options,
+          app: singleApp,
+          [fallbackAttemptSymbol]: true
+        }));
+      }
+      let { name: app, arguments: appArguments = [] } = options.app ?? {};
+      appArguments = [...appArguments];
+      if (Array.isArray(app)) {
+        return tryEachApp(app, (appName) => baseOpen({
+          ...options,
+          app: {
+            name: appName,
+            arguments: appArguments
+          },
+          [fallbackAttemptSymbol]: true
+        }));
+      }
+      if (app === "browser" || app === "browserPrivate") {
+        const ids = {
+          "com.google.chrome": "chrome",
+          "google-chrome.desktop": "chrome",
+          "com.brave.browser": "brave",
+          "org.mozilla.firefox": "firefox",
+          "firefox.desktop": "firefox",
+          "com.microsoft.msedge": "edge",
+          "com.microsoft.edge": "edge",
+          "com.microsoft.edgemac": "edge",
+          "microsoft-edge.desktop": "edge",
+          "com.apple.safari": "safari"
+        };
+        const flags = {
+          chrome: "--incognito",
+          brave: "--incognito",
+          firefox: "--private-window",
+          edge: "--inPrivate"
+          // Safari doesn't support private mode via command line
+        };
+        let browser;
+        if (is_wsl_default) {
+          const progId = await wslDefaultBrowser();
+          const browserInfo = _windowsBrowserProgIdMap.get(progId);
+          browser = browserInfo ?? {};
+        } else {
+          browser = await defaultBrowser2();
+        }
+        if (browser.id in ids) {
+          const browserName = ids[browser.id.toLowerCase()];
+          if (app === "browserPrivate") {
+            if (browserName === "safari") {
+              throw new Error("Safari doesn't support opening in private mode via command line");
+            }
+            appArguments.push(flags[browserName]);
+          }
+          return baseOpen({
+            ...options,
+            app: {
+              name: apps[browserName],
+              arguments: appArguments
+            }
+          });
+        }
+        throw new Error(`${browser.name} is not supported as a default browser`);
+      }
+      let command;
+      const cliArguments = [];
+      const childProcessOptions = {};
+      let shouldUseWindowsInWsl = false;
+      if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+        shouldUseWindowsInWsl = await canAccessPowerShell();
+      }
+      if (platform === "darwin") {
+        command = "open";
+        if (options.wait) {
+          cliArguments.push("--wait-apps");
+        }
+        if (options.background) {
+          cliArguments.push("--background");
+        }
+        if (options.newInstance) {
+          cliArguments.push("--new");
+        }
+        if (app) {
+          cliArguments.push("-a", app);
+        }
+      } else if (platform === "win32" || shouldUseWindowsInWsl) {
+        command = await powerShellPath2();
+        cliArguments.push(...executePowerShell.argumentsPrefix);
+        if (!is_wsl_default) {
+          childProcessOptions.windowsVerbatimArguments = true;
+        }
+        if (is_wsl_default && options.target) {
+          options.target = await convertWslPathToWindows(options.target);
+        }
+        const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+        if (options.wait) {
+          encodedArguments.push("-Wait");
+        }
+        if (app) {
+          encodedArguments.push(executePowerShell.escapeArgument(app));
+          if (options.target) {
+            appArguments.push(options.target);
+          }
+        } else if (options.target) {
+          encodedArguments.push(executePowerShell.escapeArgument(options.target));
+        }
+        if (appArguments.length > 0) {
+          appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+          encodedArguments.push("-ArgumentList", appArguments.join(","));
+        }
+        options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+        }
+      } else {
+        if (app) {
+          command = app;
+        } else {
+          const isBundled = !__dirname || __dirname === "/";
+          let exeLocalXdgOpen = false;
+          try {
+            await import_promises21.default.access(localXdgOpenPath, import_promises21.constants.X_OK);
+            exeLocalXdgOpen = true;
+          } catch {
+          }
+          const useSystemXdgOpen = import_node_process7.default.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+          command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) {
+          cliArguments.push(...appArguments);
+        }
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+          childProcessOptions.detached = true;
+        }
+      }
+      if (platform === "darwin" && appArguments.length > 0) {
+        cliArguments.push("--args", ...appArguments);
+      }
+      if (options.target) {
+        cliArguments.push(options.target);
+      }
+      const subprocess = import_node_child_process22.default.spawn(command, cliArguments, childProcessOptions);
+      if (options.wait) {
+        return new Promise((resolve2, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("close", (exitCode) => {
+            if (!options.allowNonzeroExitCode && exitCode !== 0) {
+              reject(new Error(`Exited with code ${exitCode}`));
+              return;
+            }
+            resolve2(subprocess);
+          });
+        });
+      }
+      if (isFallbackAttempt) {
+        return new Promise((resolve2, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("spawn", () => {
+            subprocess.once("close", (exitCode) => {
+              subprocess.off("error", reject);
+              if (exitCode !== 0) {
+                reject(new Error(`Exited with code ${exitCode}`));
+                return;
+              }
+              subprocess.unref();
+              resolve2(subprocess);
+            });
+          });
+        });
+      }
+      subprocess.unref();
+      return new Promise((resolve2, reject) => {
+        subprocess.once("error", reject);
+        subprocess.once("spawn", () => {
+          subprocess.off("error", reject);
+          resolve2(subprocess);
+        });
+      });
+    };
+    open = (target, options) => {
+      if (typeof target !== "string") {
+        throw new TypeError("Expected a `target`");
+      }
+      return baseOpen({
+        ...options,
+        target
+      });
+    };
+    openApp = (name, options) => {
+      if (typeof name !== "string" && !Array.isArray(name)) {
+        throw new TypeError("Expected a valid `name`");
+      }
+      const { arguments: appArguments = [] } = options ?? {};
+      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+        throw new TypeError("Expected `appArguments` as Array type");
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name,
+          arguments: appArguments
+        }
+      });
+    };
+    apps = {
+      browser: "browser",
+      browserPrivate: "browserPrivate"
+    };
+    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+      darwin: "google chrome",
+      win32: "chrome",
+      // `chromium-browser` is the older deb package name used by Ubuntu/Debian before snap.
+      linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+      darwin: "brave browser",
+      win32: "brave",
+      linux: ["brave-browser", "brave"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+        x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+      darwin: "firefox",
+      win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+      linux: "firefox"
+    }, {
+      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+    }));
+    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+      darwin: "microsoft edge",
+      win32: "msedge",
+      linux: ["microsoft-edge", "microsoft-edge-dev"]
+    }, {
+      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+    }));
+    defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+      darwin: "Safari"
+    }));
+    open_default = open;
+  }
+});
+
 // src/cli/index.ts
 var cli_exports = {};
 __export(cli_exports, {
@@ -41,7 +771,7 @@ var import_commander = require("commander");
 
 // src/package-info.ts
 var AISNITCH_PACKAGE_NAME = "aisnitch";
-var AISNITCH_VERSION = "0.2.20";
+var AISNITCH_VERSION = "0.2.22";
 var AISNITCH_DESCRIPTION = "Universal bridge for AI coding tool activity \u2014 capture, normalize, stream.";
 
 // src/core/events/schema.ts
@@ -82,6 +812,8 @@ var TOOL_NAMES = [
   "kiro",
   "augment-code",
   "mistral",
+  "zed",
+  "pi",
   "unknown"
 ];
 var ERROR_TYPES = [
@@ -129,6 +861,11 @@ var ToolInputSchema = import_zod.z.strictObject({
   (value) => value.filePath !== void 0 || value.command !== void 0,
   "toolInput must include filePath or command"
 );
+var ThinkingContentSchema = import_zod.z.string().max(1e5).describe("Raw thinking/reasoning content from the AI model");
+var ToolCallNameSchema = import_zod.z.string().min(1).max(100).describe("Name of the tool being invoked (e.g., Edit, Bash, Grep)");
+var FinalMessageSchema = import_zod.z.string().max(5e4).describe("End-of-run summary or completion message");
+var ToolResultSchema = import_zod.z.string().max(1e4).describe("Tool execution result or output");
+var MessageContentSchema = import_zod.z.string().max(1e5).describe("Raw text content from AI messages");
 var ToolNameSchema = import_zod.z.enum(TOOL_NAMES);
 var AISnitchEventTypeSchema = import_zod.z.enum(AISNITCH_EVENT_TYPES);
 var ErrorTypeSchema = import_zod.z.enum(ERROR_TYPES);
@@ -143,6 +880,9 @@ var EventDataSchema = import_zod.z.strictObject({
   activeFile: import_zod.z.string().min(1).max(4096).optional(),
   model: import_zod.z.string().min(1).max(200).optional(),
   tokensUsed: import_zod.z.number().int().min(0).optional(),
+  inputTokens: import_zod.z.number().int().min(0).optional(),
+  outputTokens: import_zod.z.number().int().min(0).optional(),
+  cachedTokens: import_zod.z.number().int().min(0).optional(),
   errorMessage: import_zod.z.string().min(1).max(1e4).optional(),
   errorType: ErrorTypeSchema.optional(),
   raw: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
@@ -151,7 +891,13 @@ var EventDataSchema = import_zod.z.strictObject({
   pid: import_zod.z.number().int().positive().optional(),
   instanceId: import_zod.z.string().min(1).max(255).optional(),
   instanceIndex: import_zod.z.number().int().min(1).optional(),
-  instanceTotal: import_zod.z.number().int().min(1).optional()
+  instanceTotal: import_zod.z.number().int().min(1).optional(),
+  // New fields for enhanced content capture
+  thinkingContent: ThinkingContentSchema.optional(),
+  toolCallName: ToolCallNameSchema.optional(),
+  finalMessage: FinalMessageSchema.optional(),
+  toolResult: ToolResultSchema.optional(),
+  messageContent: MessageContentSchema.optional()
 });
 var AISnitchEventSchema = import_zod.z.strictObject({
   specversion: import_zod.z.literal("1.0"),
@@ -956,8 +1702,8 @@ var ClaudeCodeSetup = class extends FileToolSetupBase {
     return `${JSON.stringify(nextSettings, null, 2)}
 `;
   }
-  getFileBackupPath(path) {
-    return `${path}.bak`;
+  getFileBackupPath(path2) {
+    return `${path2}.bak`;
   }
 };
 var OpenCodeSetup = class extends FileToolSetupBase {
@@ -1197,8 +1943,8 @@ var CopilotCLISetup = class {
     return `${JSON.stringify(nextConfig, null, 2)}
 `;
   }
-  getBackupPath(path) {
-    return `${path}.bak`;
+  getBackupPath(path2) {
+    return `${path2}.bak`;
   }
 };
 var OpenClawSetup = class {
@@ -1323,8 +2069,8 @@ var OpenClawSetup = class {
     return `${JSON.stringify(nextConfig, null, 2)}
 `;
   }
-  getBackupPath(path) {
-    return `${path}.bak`;
+  getBackupPath(path2) {
+    return `${path2}.bak`;
   }
 };
 async function createToolSetup(toolName, options = {}, dependencies = {}) {
@@ -2367,17 +3113,17 @@ async function isBinaryAvailable(binaryName) {
     return false;
   }
 }
-async function fileExists(path) {
+async function fileExists(path2) {
   try {
-    await (0, import_promises2.access)(path, import_node_fs.constants.F_OK);
+    await (0, import_promises2.access)(path2, import_node_fs.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readOptionalFile(path) {
+async function readOptionalFile(path2) {
   try {
-    return await (0, import_promises2.readFile)(path, "utf8");
+    return await (0, import_promises2.readFile)(path2, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -2388,14 +3134,14 @@ async function readOptionalFile(path) {
 function shellEscapeSingle(value) {
   return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
-async function restoreBackupOrRemove(path) {
-  const backupPath = `${path}.bak`;
+async function restoreBackupOrRemove(path2) {
+  const backupPath = `${path2}.bak`;
   if (await fileExists(backupPath)) {
-    await (0, import_promises2.copyFile)(backupPath, path);
+    await (0, import_promises2.copyFile)(backupPath, path2);
     await (0, import_promises2.rm)(backupPath, { force: true });
     return;
   }
-  await (0, import_promises2.rm)(path, { force: true });
+  await (0, import_promises2.rm)(path2, { force: true });
 }
 function buildAiderNotificationCommand(options) {
   const cliArgs = [process.execPath, resolveCurrentCliEntryPath(), "aider-notify"];
@@ -2463,13 +3209,13 @@ function toConfigPathOptions(options) {
 }
 
 // src/cli/runtime.ts
-var import_node_child_process15 = require("child_process");
-var import_node_fs4 = require("fs");
-var import_promises18 = require("fs/promises");
+var import_node_child_process23 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_promises22 = require("fs/promises");
 var import_node_net4 = require("net");
-var import_node_os5 = require("os");
-var import_node_path19 = require("path");
-var import_node_util14 = require("util");
+var import_node_os6 = require("os");
+var import_node_path22 = require("path");
+var import_node_util21 = require("util");
 
 // src/adapters/generic-pty.ts
 var import_node_path5 = require("path");
@@ -2540,9 +3286,11 @@ var TOOL_BINARY_MAP = {
   "openhands": "openhands",
   "openclaw": "openclaw",
   "opencode": "opencode",
+  "pi": "pi",
   "qwen-code": "qwen",
   "unknown": "unknown",
-  "windsurf": "windsurf"
+  "windsurf": "windsurf",
+  "zed": "zed"
 };
 var ContextDetector = class {
   cache = /* @__PURE__ */ new Map();
@@ -4401,7 +5149,7 @@ var UDSServer = class {
 };
 
 // src/core/engine/pipeline.ts
-var import_node_path16 = require("path");
+var import_node_path18 = require("path");
 var import_zod4 = require("zod");
 
 // src/adapters/aider.ts
@@ -4508,20 +5256,29 @@ var BaseAdapter = class {
     });
     let published;
     try {
-      published = await this.publishEventImplementation(event, {
-        cwd: context.cwd,
-        env: context.env,
-        hookPayload: context.hookPayload,
-        pid: context.pid,
-        sessionId,
-        source: context.source,
-        transcriptPath: context.transcriptPath
+      published = await SHARED_BREAKERS.adapterEmit.execute(async () => {
+        return await this.publishEventImplementation(event, {
+          cwd: context.cwd,
+          env: context.env,
+          hookPayload: context.hookPayload,
+          pid: context.pid,
+          sessionId,
+          source: context.source,
+          transcriptPath: context.transcriptPath
+        });
       });
     } catch (error) {
-      logger.error(
-        { error, eventType: type, adapter: this.name, sessionId },
-        "\u{1F4D6} Failed to publish event \u2014 swallowing to prevent daemon crash"
-      );
+      if (error instanceof Error && error.name === "CircuitOpenError") {
+        logger.warn(
+          { error, eventType: type, adapter: this.name },
+          "\u{1F4D6} Adapter emit blocked by open circuit \u2014 event dropped"
+        );
+      } else {
+        logger.error(
+          { error, eventType: type, adapter: this.name, sessionId },
+          "\u{1F4D6} Failed to publish event \u2014 swallowing to prevent daemon crash"
+        );
+      }
       published = false;
     }
     if (published) {
@@ -5535,7 +6292,11 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "SessionEnd": {
-        await this.emitStateChange("session.end", sharedData, context);
+        const finalMessage = extractFinalMessageFromPayload(payload);
+        await this.emitStateChange("session.end", {
+          ...sharedData,
+          finalMessage
+        }, context);
         return;
       }
       case "UserPromptSubmit":
@@ -5552,12 +6313,22 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "PreToolUse": {
-        await this.emitStateChange("agent.tool_call", sharedData, context);
+        const toolCallName = extractToolNameFromPayload(payload);
+        await this.emitStateChange("agent.tool_call", {
+          ...sharedData,
+          toolCallName
+        }, context);
         return;
       }
       case "PostToolUse": {
+        const toolCallName = extractToolNameFromPayload(payload);
+        const toolResult = extractToolResultFromPayload(payload);
         const emittedType = isClaudeCodingTool(sharedData.toolName) ? "agent.coding" : "agent.tool_call";
-        await this.emitStateChange(emittedType, sharedData, context);
+        await this.emitStateChange(emittedType, {
+          ...sharedData,
+          toolCallName,
+          toolResult
+        }, context);
         return;
       }
       case "PostToolUseFailure":
@@ -5742,7 +6513,7 @@ function extractClaudeTranscriptObservations(payload, transcriptPath) {
   });
   const contentParts = extractClaudeContentParts(payload);
   const model = getString(payload, "model") ?? getString(getRecord(payload.message), "model");
-  const tokensUsed = extractTokenUsage(payload);
+  const tokens = extractTokenUsageDetailed(payload);
   const rawPayload = payload;
   const sharedContext = {
     // 📖 Pass process.env so terminal detection works from transcript path too
@@ -5755,25 +6526,57 @@ function extractClaudeTranscriptObservations(payload, transcriptPath) {
   const sharedData = {
     model,
     raw: rawPayload,
-    tokensUsed
+    tokensUsed: tokens.total,
+    inputTokens: tokens.input,
+    outputTokens: tokens.output,
+    cachedTokens: tokens.cached
   };
   const observations = [];
   if (contentParts.some((part) => part.type === "thinking")) {
+    const thinkingParts = contentParts.filter((part) => part.type === "thinking");
+    const thinkingText = thinkingParts.map((part) => {
+      const text = part.text;
+      return typeof text === "string" ? text : void 0;
+    }).filter((text) => text !== void 0).join("\n");
     observations.push({
       context: sharedContext,
-      data: sharedData,
+      data: {
+        ...sharedData,
+        thinkingContent: thinkingText.length > 0 ? thinkingText : void 0
+      },
       type: "agent.thinking"
     });
   }
   if (contentParts.some(
     (part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0
   )) {
+    const messageTexts = contentParts.filter((part) => part.type === "text").map((part) => part.text).filter((text) => text.trim().length > 0);
+    const messageContent = messageTexts.join("\n");
     observations.push({
       context: sharedContext,
-      data: sharedData,
+      data: {
+        ...sharedData,
+        messageContent: messageContent.length > 0 ? messageContent : void 0
+      },
       type: "agent.streaming"
     });
   }
+  const toolUseParts = contentParts.filter(
+    (part) => part.type === "tool_use" || part.type === "toolUse"
+  );
+  if (toolUseParts.length > 0) {
+    const toolName = getString(toolUseParts[0], "name") ?? getString(toolUseParts[0], "tool");
+    if (toolName) {
+      observations.push({
+        context: sharedContext,
+        data: {
+          ...sharedData,
+          toolCallName: toolName
+        },
+        type: "agent.tool_call"
+      });
+    }
+  }
   return observations;
 }
 function extractClaudeContentParts(payload) {
@@ -5784,23 +6587,28 @@ function extractClaudeContentParts(payload) {
   }
   return content.filter(isRecord2);
 }
-function extractTokenUsage(payload) {
+function extractTokenUsageDetailed(payload) {
   const tokens = getNumber(payload, "tokens");
   if (tokens !== void 0) {
-    return tokens;
+    return { total: tokens };
   }
   const usage = getRecord(payload.usage);
   if (!usage) {
-    return void 0;
+    return {};
   }
   const totalTokens = getNumber(usage, "total_tokens");
   if (totalTokens !== void 0) {
-    return totalTokens;
+    return {
+      total: totalTokens,
+      input: getNumber(usage, "input_tokens"),
+      output: getNumber(usage, "output_tokens"),
+      cached: getNumber(usage, "cached_tokens")
+    };
   }
   const inputTokens = getNumber(usage, "input_tokens") ?? 0;
   const outputTokens = getNumber(usage, "output_tokens") ?? 0;
   const usageSum = inputTokens + outputTokens;
-  return usageSum > 0 ? usageSum : void 0;
+  return usageSum > 0 ? { total: usageSum, input: inputTokens, output: outputTokens } : {};
 }
 function extractClaudeToolInput(payload) {
   const toolInput = getRecord(payload.tool_input) ?? getRecord(payload.toolInput);
@@ -5896,6 +6704,51 @@ function getString(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
+function extractToolNameFromPayload(payload) {
+  const directToolName = getString(payload, "tool_name") ?? getString(payload, "toolName");
+  if (directToolName) {
+    return directToolName;
+  }
+  const toolUse = getRecord(payload.tool_use) ?? getRecord(payload.toolUse);
+  if (toolUse) {
+    return getString(toolUse, "name") ?? getString(toolUse, "tool");
+  }
+  const toolInput = getRecord(payload.tool_input) ?? getRecord(payload.toolInput);
+  if (toolInput) {
+    return getString(toolInput, "tool_name") ?? getString(toolInput, "type");
+  }
+  return void 0;
+}
+function extractToolResultFromPayload(payload) {
+  const directResult = getString(payload, "result") ?? getString(payload, "output");
+  if (directResult) {
+    return directResult;
+  }
+  const toolResult = getRecord(payload.tool_result) ?? getRecord(payload.toolResult);
+  if (toolResult) {
+    return getString(toolResult, "content") ?? getString(toolResult, "output");
+  }
+  const errorField = getString(payload, "error") ?? getString(payload, "error_message");
+  if (errorField) {
+    return errorField;
+  }
+  return void 0;
+}
+function extractFinalMessageFromPayload(payload) {
+  const directMessage = getString(payload, "final_message") ?? getString(payload, "finalMessage") ?? getString(payload, "summary") ?? getString(payload, "completion_message");
+  if (directMessage) {
+    return directMessage;
+  }
+  const result = getString(payload, "result") ?? getString(payload, "output") ?? getString(payload, "message");
+  if (result) {
+    return result;
+  }
+  const stats = getRecord(payload.stats);
+  if (stats) {
+    return getString(stats, "summary") ?? getString(stats, "completion_summary");
+  }
+  return void 0;
+}
 
 // src/adapters/copilot-cli.ts
 var import_node_child_process5 = require("child_process");
@@ -10859,7 +11712,17 @@ var OpenCodeAdapter = class extends BaseAdapter {
       project: extractOpenCodeProject(payload),
       raw: payload,
       toolInput: extractOpenCodeToolInput(payload),
-      toolName: extractOpenCodeToolName(payload)
+      toolName: extractOpenCodeToolName(payload),
+      // 📖 Extract token usage from payload (with input/output/cached breakdown)
+      ...(() => {
+        const tokens = extractOpenCodeTokens(payload);
+        return {
+          tokensUsed: tokens.total,
+          inputTokens: tokens.inputTokens,
+          outputTokens: tokens.outputTokens,
+          cachedTokens: tokens.cachedTokens
+        };
+      })()
     };
     switch (eventType) {
       case "session.created": {
@@ -10869,7 +11732,11 @@ var OpenCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "session.deleted": {
-        await this.emitStateChange("session.end", sharedData, context);
+        const finalMessage = extractOpenCodeFinalMessage(payload);
+        await this.emitStateChange("session.end", {
+          ...sharedData,
+          finalMessage
+        }, context);
         return;
       }
       case "session.error": {
@@ -10884,9 +11751,21 @@ var OpenCodeAdapter = class extends BaseAdapter {
         await this.emitStateChange("agent.compact", sharedData, context);
         return;
       }
+      case "thinking": {
+        const thinkingContent = extractOpenCodeThinkingContent(payload);
+        await this.emitStateChange("agent.thinking", {
+          ...sharedData,
+          thinkingContent
+        }, context);
+        return;
+      }
       case "message.updated":
       case "message.part.updated": {
-        await this.emitStateChange("agent.streaming", sharedData, context);
+        const messageContent = extractOpenCodeMessageContent(payload);
+        await this.emitStateChange("agent.streaming", {
+          ...sharedData,
+          messageContent
+        }, context);
         return;
       }
       case "permission.asked": {
@@ -10894,12 +11773,22 @@ var OpenCodeAdapter = class extends BaseAdapter {
         return;
       }
       case "tool.execute.before": {
-        await this.emitStateChange("agent.tool_call", sharedData, context);
+        const toolCallName = extractOpenCodeToolName(payload);
+        await this.emitStateChange("agent.tool_call", {
+          ...sharedData,
+          toolCallName
+        }, context);
         return;
       }
       case "tool.execute.after": {
+        const toolCallName = extractOpenCodeToolName(payload);
+        const toolResult = extractOpenCodeToolResult(payload);
         const emittedType = isOpenCodeCodingTool(sharedData.toolName) ? "agent.coding" : "agent.tool_call";
-        await this.emitStateChange(emittedType, sharedData, context);
+        await this.emitStateChange(emittedType, {
+          ...sharedData,
+          toolCallName,
+          toolResult
+        }, context);
         return;
       }
       default: {
@@ -11066,7 +11955,597 @@ function getString10(payload, key) {
   const value = payload[key];
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
-
+function extractOpenCodeFinalMessage(payload) {
+  const directMessage = getString10(payload, "final_message") ?? getString10(payload, "finalMessage") ?? getString10(payload, "summary") ?? getString10(payload, "completion_message");
+  if (directMessage) {
+    return directMessage;
+  }
+  const result = getString10(payload, "result") ?? getString10(payload, "output") ?? getString10(getRecord9(payload.properties), "result");
+  if (result) {
+    return result;
+  }
+  return void 0;
+}
+function extractOpenCodeToolResult(payload) {
+  const directResult = getString10(payload, "result") ?? getString10(payload, "output") ?? getString10(payload, "toolResult");
+  if (directResult) {
+    return directResult;
+  }
+  const toolResult = getRecord9(payload.tool_result) ?? getRecord9(payload.toolResult);
+  if (toolResult) {
+    return getString10(toolResult, "content") ?? getString10(toolResult, "output");
+  }
+  const props = getRecord9(payload.properties);
+  if (props) {
+    const nestedResult = getRecord9(props.tool_result) ?? getRecord9(props.toolResult);
+    if (nestedResult) {
+      return getString10(nestedResult, "content") ?? getString10(nestedResult, "output");
+    }
+  }
+  return void 0;
+}
+function extractOpenCodeMessageContent(payload) {
+  const directMessage = getString10(payload, "text") ?? getString10(payload, "message") ?? getString10(payload, "content") ?? getString10(payload, "output");
+  if (directMessage) {
+    return directMessage;
+  }
+  const part = getRecord9(payload.part) ?? getRecord9(getRecord9(payload.properties)?.part);
+  if (part) {
+    return getString10(part, "text") ?? getString10(part, "content");
+  }
+  const props = getRecord9(payload.properties);
+  if (props) {
+    const message = getRecord9(props.message) ?? getRecord9(props.info);
+    if (message) {
+      return getString10(message, "text") ?? getString10(message, "content");
+    }
+    return getString10(props, "text") ?? getString10(props, "message");
+  }
+  return void 0;
+}
+function extractOpenCodeThinkingContent(payload) {
+  const directThinking = getString10(payload, "thinking") ?? getString10(payload, "thinkingContent") ?? getString10(payload, "reasoning") ?? getString10(payload, "thought");
+  if (directThinking) {
+    return directThinking;
+  }
+  const props = getRecord9(payload.properties);
+  if (props) {
+    return getString10(props, "thinking") ?? getString10(props, "reasoning") ?? getString10(props, "thought");
+  }
+  return void 0;
+}
+function extractOpenCodeTokens(payload) {
+  const directTokens = getNumber8(payload, "tokensUsed") ?? getNumber8(payload, "tokens");
+  if (directTokens !== void 0) {
+    return { total: directTokens };
+  }
+  const props = getRecord9(payload.properties);
+  if (props) {
+    const info = getRecord9(props.info);
+    if (info) {
+      const tokens = getRecord9(info.tokens);
+      if (tokens) {
+        const inputTokens = getNumber8(tokens, "input") ?? 0;
+        const outputTokens = getNumber8(tokens, "output") ?? 0;
+        const reasoningTokens = getNumber8(tokens, "reasoning") ?? 0;
+        const total = inputTokens + outputTokens + reasoningTokens;
+        return total > 0 ? {
+          total,
+          inputTokens,
+          outputTokens,
+          // reasoning tokens are often billed as cached on some providers
+          cachedTokens: reasoningTokens
+        } : {};
+      }
+    }
+    const fallbackTokens = getNumber8(props, "tokensUsed") ?? getNumber8(props, "tokens");
+    if (fallbackTokens !== void 0) {
+      return { total: fallbackTokens };
+    }
+  }
+  return {};
+}
+
+// src/adapters/pi.ts
+var import_node_child_process14 = require("child_process");
+var import_node_path16 = require("path");
+var import_node_util14 = require("util");
+var execFileAsync = (0, import_node_util14.promisify)(import_node_child_process14.execFile);
+var PiAdapter = class extends BaseAdapter {
+  displayName = "Pi (MiniMax)";
+  name = "pi";
+  strategies = [
+    "process-detect",
+    "api-client",
+    "log-watch"
+  ];
+  apiPort = 7890;
+  logPath;
+  poller = null;
+  activePiSessions = /* @__PURE__ */ new Map();
+  lastCheckedTime = 0;
+  constructor(options) {
+    super(options);
+    this.logPath = (0, import_node_path16.join)(
+      options.homeDirectory ?? process.env.HOME ?? "",
+      ".pi",
+      "agent.log"
+    );
+  }
+  start() {
+    if (this.getStatus().running) {
+      return Promise.resolve();
+    }
+    this.setRunning(true);
+    this.startPolling();
+    logger.info({ adapter: this.name }, "Pi adapter started");
+    return Promise.resolve();
+  }
+  stop() {
+    if (this.poller !== null) {
+      clearInterval(this.poller);
+      this.poller = null;
+    }
+    this.setRunning(false);
+    logger.info({ adapter: this.name }, "Pi adapter stopped");
+    return Promise.resolve();
+  }
+  async handleHook(payload) {
+    const normalized = this.parseNormalizedHookPayload(payload);
+    if (normalized === null) {
+      return;
+    }
+    const context = {
+      cwd: normalized.cwd,
+      pid: normalized.pid,
+      sessionId: normalized.sessionId,
+      source: "pi-hook"
+    };
+    const eventType = this.mapEventType(normalized.type ?? "");
+    const eventData = this.buildEventData(eventType, normalized);
+    await this.emit(eventType, eventData, context);
+  }
+  startPolling() {
+    this.poller = setInterval(() => {
+      void this.pollPiActivity();
+    }, 2e3);
+  }
+  async pollPiActivity() {
+    const running = await this.detectPiInstance();
+    if (!running) {
+      for (const [sessionId, activity] of this.activePiSessions) {
+        if (activity.state !== "idle") {
+          activity.state = "idle";
+          await this.emitIdle(sessionId);
+        }
+      }
+      return;
+    }
+    try {
+      const response = await fetch(
+        `http://127.0.0.1:${this.apiPort}/api/status`,
+        {
+          signal: AbortSignal.timeout(500)
+        }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        await this.processPiApiResponse(data);
+      }
+    } catch {
+      await this.checkMiniMaxApi();
+    }
+  }
+  async detectPiInstance() {
+    try {
+      const result = await execFileAsync("pgrep", ["-l", "pi|minimax"]);
+      if (result.stdout.includes("pi") || result.stdout.includes("minimax")) {
+        return true;
+      }
+    } catch {
+    }
+    try {
+      const response = await fetch(
+        `http://127.0.0.1:${this.apiPort}/health`,
+        {
+          signal: AbortSignal.timeout(200)
+        }
+      );
+      if (response.ok) {
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+  async checkMiniMaxApi() {
+    try {
+      const response = await fetch("http://127.0.0.1:3000/api/agent/status", {
+        signal: AbortSignal.timeout(500)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        await this.processPiApiResponse(data);
+      }
+    } catch {
+    }
+  }
+  async processPiApiResponse(data) {
+    const rawSession = data.sessionId ?? data.project ?? "default";
+    const sessionId = `pi:${rawSession.replace(/[^a-zA-Z0-9-_]/g, "-")}`;
+    let activity = this.activePiSessions.get(sessionId);
+    if (!activity) {
+      activity = { sessionId, state: "idle" };
+      this.activePiSessions.set(sessionId, activity);
+      await this.emitSessionStart(sessionId, data);
+    }
+    const rawState = data.state ?? "idle";
+    const state = rawState;
+    if (state !== activity.state) {
+      switch (state) {
+        case "thinking": {
+          const rawThinking = data.thinking;
+          if (rawThinking) {
+            await this.emitThinking(sessionId, rawThinking);
+          }
+          break;
+        }
+        case "tool": {
+          const rawFilePath = data.filePath;
+          const rawCommand = data.command;
+          const rawToolName = data.toolName ?? "unknown";
+          await this.emitToolCall(
+            sessionId,
+            {
+              filePath: rawFilePath ?? "",
+              command: rawCommand ?? ""
+            },
+            rawToolName
+          );
+          break;
+        }
+        case "output": {
+          const rawOutput = data.output;
+          if (rawOutput) {
+            await this.emitOutput(sessionId, rawOutput);
+          }
+          break;
+        }
+        case "error": {
+          const rawError = data.error ?? "Unknown error";
+          await this.emitError(sessionId, rawError);
+          break;
+        }
+        case "idle":
+          await this.emitIdle(sessionId);
+          break;
+      }
+      activity.state = state;
+    }
+  }
+  async emitSessionStart(sessionId, data) {
+    const rawProject = data.project ?? "pi-project";
+    const rawModel = data.model ?? "minimax/moonshot";
+    const eventData = {
+      state: "session.start",
+      project: rawProject,
+      model: rawModel,
+      raw: data
+    };
+    await this.emit("session.start", eventData, { sessionId });
+  }
+  async emitThinking(sessionId, content) {
+    if (!content) return;
+    const eventData = {
+      state: "agent.thinking",
+      thinkingContent: content
+    };
+    await this.emit("agent.thinking", eventData, { sessionId });
+  }
+  async emitToolCall(sessionId, toolInput, toolName) {
+    const eventData = {
+      state: "agent.tool_call",
+      toolCallName: toolName,
+      toolInput,
+      activeFile: toolInput.filePath
+    };
+    await this.emit("agent.tool_call", eventData, { sessionId });
+  }
+  async emitOutput(sessionId, content) {
+    if (!content) return;
+    const eventData = {
+      state: "agent.streaming",
+      messageContent: content
+    };
+    await this.emit("agent.streaming", eventData, { sessionId });
+  }
+  async emitError(sessionId, errorMessage) {
+    const eventData = {
+      state: "agent.error",
+      errorMessage,
+      errorType: "api_error"
+    };
+    await this.emit("agent.error", eventData, { sessionId });
+  }
+  async emitIdle(sessionId) {
+    const eventData = {
+      state: "agent.idle"
+    };
+    await this.emit("agent.idle", eventData, { sessionId });
+  }
+  mapEventType(type) {
+    const mapping = {
+      "session.start": "session.start",
+      "session.end": "session.end",
+      "task.start": "task.start",
+      "task.complete": "task.complete",
+      thinking: "agent.thinking",
+      tool: "agent.tool_call",
+      coding: "agent.coding",
+      output: "agent.streaming",
+      message: "agent.streaming",
+      ask: "agent.asking_user",
+      error: "agent.error",
+      idle: "agent.idle",
+      compact: "agent.compact"
+    };
+    return mapping[type] ?? "agent.streaming";
+  }
+  buildEventData(eventType, payload) {
+    const data = payload.data ?? {};
+    return {
+      state: eventType,
+      project: data.project,
+      activeFile: data.activeFile,
+      model: data.model,
+      toolInput: data.toolInput,
+      toolCallName: data.toolCallName,
+      thinkingContent: data.thinkingContent,
+      messageContent: data.messageContent,
+      finalMessage: data.finalMessage,
+      toolResult: data.toolResult,
+      errorMessage: data.errorMessage,
+      errorType: data.errorType,
+      raw: data.raw
+    };
+  }
+};
+
+// src/adapters/zed.ts
+var import_promises15 = require("fs/promises");
+var import_node_path17 = require("path");
+var ZedAdapter = class extends BaseAdapter {
+  displayName = "Zed AI";
+  name = "zed";
+  strategies = [
+    "process-detect",
+    "api-client"
+  ];
+  logPaths;
+  apiPort = 9876;
+  pollIntervalMs;
+  poller = null;
+  lastEventTime = 0;
+  activeZedSessions = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super(options);
+    this.pollIntervalMs = 2e3;
+    this.logPaths = [
+      (0, import_node_path17.join)(options.homeDirectory ?? process.env.HOME ?? "", ".config", "zed", "logs", "agent.log"),
+      "/tmp/zed-agent.log"
+    ];
+  }
+  start() {
+    if (this.getStatus().running) {
+      return Promise.resolve();
+    }
+    this.setRunning(true);
+    this.startPolling();
+    logger.info({ adapter: this.name }, "Zed adapter started");
+    return Promise.resolve();
+  }
+  stop() {
+    if (this.poller !== null) {
+      clearInterval(this.poller);
+      this.poller = null;
+    }
+    this.setRunning(false);
+    logger.info({ adapter: this.name }, "Zed adapter stopped");
+    return Promise.resolve();
+  }
+  async handleHook(payload) {
+    const normalized = this.parseNormalizedHookPayload(payload);
+    if (normalized === null) {
+      return;
+    }
+    const context = {
+      cwd: normalized.cwd,
+      pid: normalized.pid,
+      sessionId: normalized.sessionId,
+      source: "zed-hook"
+    };
+    const eventType = this.mapEventType(normalized.type ?? "");
+    const eventData = this.buildEventData(eventType, normalized);
+    await this.emit(eventType, eventData, context);
+  }
+  startPolling() {
+    this.poller = setInterval(() => {
+      void this.pollZedStatus();
+    }, this.pollIntervalMs);
+  }
+  async pollZedStatus() {
+    try {
+      const response = await fetch(`http://127.0.0.1:${this.apiPort}/api/agent/status`, {
+        signal: AbortSignal.timeout(1e3)
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (data.sessionId && typeof data.sessionId === "string") {
+          const sessionId = `zed:${data.sessionId}`;
+          if (!this.activeZedSessions.has(sessionId)) {
+            this.activeZedSessions.set(sessionId, sessionId);
+            await this.emitSessionStart(sessionId, data);
+          }
+          if (data.state === "thinking" && this.lastEventTime < Date.now() - 5e3) {
+            const rawThinking = data.thinking;
+            if (rawThinking) {
+              await this.emitThinking(sessionId, rawThinking);
+            }
+          } else if (data.state === "tool" && data.toolName) {
+            const rawFilePath = data.filePath;
+            const rawCommand = data.command;
+            const rawToolName = data.toolName ?? "unknown";
+            await this.emitToolCall(
+              sessionId,
+              {
+                filePath: rawFilePath ?? "",
+                command: rawCommand ?? ""
+              },
+              rawToolName
+            );
+          } else if (data.state === "idle") {
+            await this.emitIdle(sessionId);
+          }
+        }
+      }
+    } catch {
+      await this.checkLogFiles();
+    }
+  }
+  async checkLogFiles() {
+    for (const logPath of this.logPaths) {
+      try {
+        const content = await (0, import_promises15.readFile)(logPath, "utf8");
+        await this.parseLogContent(content);
+      } catch {
+      }
+    }
+  }
+  async parseLogContent(content) {
+    const lines = content.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      if (this.lastEventTime > 0 && this.lastEventTime >= Date.now() - 2e3) {
+        continue;
+      }
+      const event = this.extractZedEventFromLog(line);
+      if (event) {
+        await this.handleHook(event);
+        this.lastEventTime = Date.now();
+      }
+    }
+  }
+  extractZedEventFromLog(line) {
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed.type || typeof parsed.type !== "string") {
+        return null;
+      }
+      const rawSessionId = parsed.sessionId;
+      const rawWorkspace = parsed.workspace;
+      const sessionId = rawSessionId ? rawSessionId : rawWorkspace ? `zed:${(0, import_node_path17.basename)(rawWorkspace)}` : `zed:${Date.now()}`;
+      const rawCwd = parsed.cwd ?? rawWorkspace;
+      return {
+        type: parsed.type,
+        sessionId,
+        cwd: rawCwd,
+        data: {
+          project: parsed.project ?? rawWorkspace ? (0, import_node_path17.basename)(String(rawWorkspace)) : void 0,
+          model: parsed.model,
+          state: parsed.type,
+          thinkingContent: parsed.thinking,
+          toolCallName: parsed.toolName,
+          toolInput: parsed.toolInput,
+          messageContent: parsed.message ?? parsed.output,
+          errorMessage: parsed.error,
+          raw: parsed
+        }
+      };
+    } catch {
+      if (line.includes("[zed:agent]")) {
+        const cleaned = line.replace(/^\[.*?\] \[.*?\] /, "");
+        if (cleaned.includes("Thinking:")) {
+          return { type: "thinking", thinkingContent: cleaned.replace("Thinking:", "").trim() };
+        }
+        if (cleaned.includes("Executing tool:")) {
+          return { type: "tool", toolCallName: cleaned.replace("Executing tool:", "").trim() };
+        }
+        if (cleaned.includes("Error:")) {
+          return { type: "error", errorMessage: cleaned.replace("Error:", "").trim() };
+        }
+      }
+      return null;
+    }
+  }
+  async emitSessionStart(sessionId, _data) {
+    const eventData = {
+      state: "session.start",
+      project: sessionId.split(":")[1] ?? "unknown"
+    };
+    await this.emit("session.start", eventData, { sessionId });
+  }
+  async emitThinking(sessionId, content) {
+    if (!content) return;
+    const eventData = {
+      state: "agent.thinking",
+      thinkingContent: content
+    };
+    await this.emit("agent.thinking", eventData, { sessionId });
+    this.lastEventTime = Date.now();
+  }
+  async emitToolCall(sessionId, toolInput, toolName) {
+    const eventData = {
+      state: "agent.tool_call",
+      toolCallName: toolName,
+      toolInput,
+      activeFile: toolInput.filePath
+    };
+    await this.emit("agent.tool_call", eventData, { sessionId });
+    this.lastEventTime = Date.now();
+  }
+  async emitIdle(sessionId) {
+    const eventData = {
+      state: "agent.idle"
+    };
+    await this.emit("agent.idle", eventData, { sessionId });
+  }
+  mapEventType(type) {
+    const mapping = {
+      "session.start": "session.start",
+      "session.end": "session.end",
+      "task.start": "task.start",
+      "task.complete": "task.complete",
+      thinking: "agent.thinking",
+      tool: "agent.tool_call",
+      coding: "agent.coding",
+      output: "agent.streaming",
+      message: "agent.streaming",
+      ask: "agent.asking_user",
+      error: "agent.error",
+      idle: "agent.idle",
+      compact: "agent.compact"
+    };
+    return mapping[type] ?? "agent.streaming";
+  }
+  buildEventData(eventType, payload) {
+    const data = payload.data ?? {};
+    return {
+      state: eventType,
+      project: data.project,
+      activeFile: data.activeFile,
+      model: data.model,
+      toolInput: data.toolInput,
+      toolCallName: data.toolCallName,
+      thinkingContent: data.thinkingContent,
+      messageContent: data.messageContent,
+      finalMessage: data.finalMessage,
+      toolResult: data.toolResult,
+      errorMessage: data.errorMessage,
+      errorType: data.errorType,
+      raw: data.raw
+    };
+  }
+};
+
 // src/adapters/registry.ts
 var AdapterRegistry = class {
   adapters = /* @__PURE__ */ new Map();
@@ -11150,7 +12629,9 @@ function createDefaultAdapters(options) {
     new KiloAdapter(options),
     new CodexAdapter(options),
     new OpenClawAdapter(options),
-    new OpenCodeAdapter(options)
+    new OpenCodeAdapter(options),
+    new PiAdapter(options),
+    new ZedAdapter(options)
   ];
 }
 
@@ -11171,7 +12652,7 @@ function getSocketPath(aisnitchHomePath) {
   if (process.platform === "win32") {
     return "\\\\.\\pipe\\aisnitch.sock";
   }
-  return (0, import_node_path16.join)(aisnitchHomePath, "aisnitch.sock");
+  return (0, import_node_path18.join)(aisnitchHomePath, "aisnitch.sock");
 }
 var Pipeline = class {
   eventBus = new EventBus();
@@ -11376,6 +12857,30 @@ var Pipeline = class {
   getEventBus() {
     return this.eventBus;
   }
+  /**
+   * Returns the adapter registry for graceful shutdown coordination.
+   */
+  getAdapterRegistry() {
+    return this.adapterRegistry ?? void 0;
+  }
+  /**
+   * Returns the HTTP receiver for graceful shutdown coordination.
+   */
+  getHttpReceiver() {
+    return this.httpReceiver;
+  }
+  /**
+   * Returns the UDS server for graceful shutdown coordination.
+   */
+  getUdsServer() {
+    return this.udsServer;
+  }
+  /**
+   * Returns the WebSocket server for graceful shutdown coordination.
+   */
+  getWsServer() {
+    return this.wsServer;
+  }
   getHealthSnapshot() {
     const status = this.getStatus();
     return {
@@ -11500,6 +13005,72 @@ var DEFAULT_TIMEOUTS = Object.freeze({
   pipelineStartup: 15e3
 });
 
+// src/core/graceful-shutdown.ts
+async function withShutdownTimeout(fn, timeoutMs, component) {
+  if (timeoutMs <= 0) {
+    await fn();
+    return;
+  }
+  const timeoutPromise = new Promise((resolve2) => {
+    setTimeout(() => {
+      resolve2("timed_out");
+    }, timeoutMs).unref();
+  });
+  const result = await Promise.race([
+    fn().then(() => "completed"),
+    timeoutPromise
+  ]);
+  if (result === "timed_out") {
+    logger.warn(
+      { component, timeoutMs },
+      `Graceful shutdown exceeded ${timeoutMs}ms timeout \u2014 forcing through`
+    );
+  }
+}
+async function shutdownInOrder(components, timeouts, label) {
+  const getTimeout = (key) => {
+    return timeouts[key] ?? DEFAULT_TIMEOUTS.daemonShutdown;
+  };
+  const stopSafely = async (key, fn) => {
+    const timeoutMs = getTimeout(key);
+    try {
+      await withShutdownTimeout(fn, timeoutMs, `${label}.${key}`);
+    } catch (error) {
+      logger.warn(
+        { error, key, label },
+        `Error during shutdown of ${key} \u2014 continuing with remaining components`
+      );
+    }
+  };
+  if (components.cleanupFns) {
+    for (const cleanupFn of components.cleanupFns) {
+      try {
+        await withShutdownTimeout(
+          async () => {
+            const result = cleanupFn();
+            if (result instanceof Promise) {
+              await result;
+            }
+          },
+          1e3,
+          `${label}.cleanup`
+        );
+      } catch (error) {
+        logger.warn({ error, label }, "Cleanup function failed");
+      }
+    }
+  }
+  if (components.eventBus) {
+    components.eventBus.unsubscribeAll();
+  }
+  await stopSafely("wsServer", () => components.wsServer.stop());
+  await stopSafely("udsServer", () => components.udsServer.stop());
+  await stopSafely("httpReceiver", () => components.httpReceiver.stop());
+  if (components.adapterRegistry) {
+    await stopSafely("adapterRegistry", () => components.adapterRegistry.stopAll());
+  }
+}
+
 // src/tui/index.tsx
 var import_ink13 = require("ink");
 var import_fullscreen_ink = require("fullscreen-ink");
@@ -11703,9 +13274,11 @@ var TOOL_COLORS = {
   "openhands": "#facc15",
   "openclaw": "#ef4444",
   "opencode": "#10b981",
+  "pi": "#1db954",
   "qwen-code": "#22c55e",
   "unknown": "#94a3b8",
-  "windsurf": "#a855f7"
+  "windsurf": "#a855f7",
+  "zed": "#e85d04"
 };
 var EVENT_COLORS = {
   "agent.asking_user": "#ef4444",
@@ -13459,10 +15032,10 @@ async function renderManagedTui(options) {
 
 // src/cli/pid.ts
 var import_node_fs3 = require("fs");
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_node_net3 = require("net");
 var import_node_os4 = require("os");
-var import_node_path17 = require("path");
+var import_node_path19 = require("path");
 var import_zod5 = require("zod");
 var DaemonStateSchema = import_zod5.z.strictObject({
   pid: import_zod5.z.number().int().positive(),
@@ -13477,14 +15050,14 @@ function getDefaultSocketPath(options) {
   if (process.platform === "win32") {
     return "\\\\.\\pipe\\aisnitch.sock";
   }
-  return (0, import_node_path17.join)(getAISnitchHomePath(options), "aisnitch.sock");
+  return (0, import_node_path19.join)(getAISnitchHomePath(options), "aisnitch.sock");
 }
 async function cleanupSocketPathIfStale(socketPath) {
   if (process.platform === "win32") {
     return false;
   }
   try {
-    await (0, import_promises15.access)(socketPath, import_node_fs3.constants.F_OK);
+    await (0, import_promises16.access)(socketPath, import_node_fs3.constants.F_OK);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return false;
@@ -13508,20 +15081,20 @@ async function cleanupSocketPathIfStale(socketPath) {
   if (!staleSocket) {
     return false;
   }
-  await (0, import_promises15.rm)(socketPath, { force: true });
+  await (0, import_promises16.rm)(socketPath, { force: true });
   return true;
 }
 function getPidFilePath(options = {}) {
-  return (0, import_node_path17.join)(getAISnitchHomePath(options), "aisnitch.pid");
+  return (0, import_node_path19.join)(getAISnitchHomePath(options), "aisnitch.pid");
 }
 function getDaemonStatePath(options = {}) {
-  return (0, import_node_path17.join)(getAISnitchHomePath(options), "daemon-state.json");
+  return (0, import_node_path19.join)(getAISnitchHomePath(options), "daemon-state.json");
 }
 function getDaemonLogPath(options = {}) {
-  return (0, import_node_path17.join)(getAISnitchHomePath(options), "daemon.log");
+  return (0, import_node_path19.join)(getAISnitchHomePath(options), "daemon.log");
 }
 function getLaunchAgentPath(options = {}) {
-  return (0, import_node_path17.join)(
+  return (0, import_node_path19.join)(
     options.launchAgentHomeDirectory ?? (0, import_node_os4.homedir)(),
     "Library",
     "LaunchAgents",
@@ -13531,13 +15104,13 @@ function getLaunchAgentPath(options = {}) {
 async function writePid(pid, options = {}) {
   await ensureConfigDir(options);
   const pidFilePath = getPidFilePath(options);
-  await (0, import_promises15.writeFile)(pidFilePath, `${pid}
+  await (0, import_promises16.writeFile)(pidFilePath, `${pid}
 `, "utf8");
   return pidFilePath;
 }
 async function readPid(options = {}) {
   try {
-    const rawPid = await (0, import_promises15.readFile)(getPidFilePath(options), "utf8");
+    const rawPid = await (0, import_promises16.readFile)(getPidFilePath(options), "utf8");
     const parsedPid = Number.parseInt(rawPid.trim(), 10);
     if (!Number.isInteger(parsedPid) || parsedPid <= 0) {
       throw new Error("Invalid PID file contents.");
@@ -13551,13 +15124,13 @@ async function readPid(options = {}) {
   }
 }
 async function removePid(options = {}) {
-  await (0, import_promises15.rm)(getPidFilePath(options), { force: true });
+  await (0, import_promises16.rm)(getPidFilePath(options), { force: true });
 }
 async function writeDaemonState(state, options = {}) {
   await ensureConfigDir(options);
   const daemonStatePath = getDaemonStatePath(options);
   const validatedState = DaemonStateSchema.parse(state);
-  await (0, import_promises15.writeFile)(
+  await (0, import_promises16.writeFile)(
     daemonStatePath,
     `${JSON.stringify(validatedState, null, 2)}
 `,
@@ -13567,7 +15140,7 @@ async function writeDaemonState(state, options = {}) {
 }
 async function readDaemonState(options = {}) {
   try {
-    const rawJson = await (0, import_promises15.readFile)(getDaemonStatePath(options), "utf8");
+    const rawJson = await (0, import_promises16.readFile)(getDaemonStatePath(options), "utf8");
     const parsedJson = JSON.parse(rawJson);
     return DaemonStateSchema.parse(parsedJson);
   } catch (error) {
@@ -13578,7 +15151,7 @@ async function readDaemonState(options = {}) {
   }
 }
 async function removeDaemonState(options = {}) {
-  await (0, import_promises15.rm)(getDaemonStatePath(options), { force: true });
+  await (0, import_promises16.rm)(getDaemonStatePath(options), { force: true });
 }
 function isProcessRunning(pid) {
   try {
@@ -13614,13 +15187,13 @@ async function cleanupStaleDaemonFiles(options = {}) {
 }
 async function ensureLaunchAgentDir(options = {}) {
   const launchAgentPath = getLaunchAgentPath(options);
-  const directoryPath = (0, import_node_path17.dirname)(launchAgentPath);
-  await (0, import_promises15.mkdir)(directoryPath, { recursive: true });
+  const directoryPath = (0, import_node_path19.dirname)(launchAgentPath);
+  await (0, import_promises16.mkdir)(directoryPath, { recursive: true });
   return directoryPath;
 }
 async function getDaemonLogSize(options = {}) {
   try {
-    const logStats = await (0, import_promises15.stat)(getDaemonLogPath(options));
+    const logStats = await (0, import_promises16.stat)(getDaemonLogPath(options));
     return logStats.size;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -13634,16 +15207,16 @@ function getEffectiveCliConfigPath(options = {}) {
 }
 
 // src/cli/auto-update.ts
-var import_node_child_process14 = require("child_process");
-var import_promises16 = require("fs/promises");
+var import_node_child_process15 = require("child_process");
 var import_promises17 = require("fs/promises");
-var import_node_path18 = require("path");
+var import_promises18 = require("fs/promises");
+var import_node_path20 = require("path");
 var AUTO_UPDATE_STATE_FILE = "auto-update.json";
 var AUTO_UPDATE_LOG_FILE = "auto-update.log";
 function createAutoUpdateController(dependencies = {}) {
   const fetchImplementation = dependencies.fetch ?? globalThis.fetch;
   const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
-  const spawnImplementation = dependencies.spawn ?? import_node_child_process14.spawn;
+  const spawnImplementation = dependencies.spawn ?? import_node_child_process15.spawn;
   return {
     runDetachedUpdate: async (options) => {
       const pathOptions = toPathOptions(options);
@@ -13651,8 +15224,8 @@ function createAutoUpdateController(dependencies = {}) {
       const command = resolveUpdateCommand(options.manager);
       const args = resolveUpdateArgs(options.manager);
       const aisnitchHomePath = getAISnitchHomePath(pathOptions);
-      await (0, import_promises16.mkdir)(aisnitchHomePath, { recursive: true });
-      const logFilePath = (0, import_node_path18.join)(aisnitchHomePath, AUTO_UPDATE_LOG_FILE);
+      await (0, import_promises17.mkdir)(aisnitchHomePath, { recursive: true });
+      const logFilePath = (0, import_node_path20.join)(aisnitchHomePath, AUTO_UPDATE_LOG_FILE);
       const startedAt = now().toISOString();
       await writeAutoUpdateState(
         {
@@ -13685,7 +15258,7 @@ function createAutoUpdateController(dependencies = {}) {
       });
       combinedLog += `[${now().toISOString()}] finished with code ${exitCode}
 `;
-      await (0, import_promises16.writeFile)(logFilePath, combinedLog, "utf8");
+      await (0, import_promises17.writeFile)(logFilePath, combinedLog, "utf8");
       await writeAutoUpdateState(
         {
           attemptedVersion: options.latestVersion,
@@ -13776,7 +15349,7 @@ async function detectInstallManager(options) {
   }
   let resolvedCliPath = options.cliEntryPath;
   try {
-    resolvedCliPath = await (0, import_promises17.realpath)(options.cliEntryPath);
+    resolvedCliPath = await (0, import_promises18.realpath)(options.cliEntryPath);
   } catch {
   }
   if (resolvedCliPath.includes("/Cellar/aisnitch/")) {
@@ -13840,7 +15413,7 @@ function resolveUpdateArgs(manager) {
 async function readAutoUpdateState(options) {
   const statePath = getAutoUpdateStatePath(options);
   try {
-    const rawJson = await (0, import_promises16.readFile)(statePath, "utf8");
+    const rawJson = await (0, import_promises17.readFile)(statePath, "utf8");
     return JSON.parse(rawJson);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -13851,8 +15424,8 @@ async function readAutoUpdateState(options) {
 }
 async function writeAutoUpdateState(state, options) {
   const aisnitchHomePath = getAISnitchHomePath(options);
-  await (0, import_promises16.mkdir)(aisnitchHomePath, { recursive: true });
-  await (0, import_promises16.writeFile)(
+  await (0, import_promises17.mkdir)(aisnitchHomePath, { recursive: true });
+  await (0, import_promises17.writeFile)(
     getAutoUpdateStatePath(options),
     `${JSON.stringify(state, null, 2)}
 `,
@@ -13860,7 +15433,7 @@ async function writeAutoUpdateState(state, options) {
   );
 }
 function getAutoUpdateStatePath(options) {
-  return (0, import_node_path18.join)(getAISnitchHomePath(options), AUTO_UPDATE_STATE_FILE);
+  return (0, import_node_path20.join)(getAISnitchHomePath(options), AUTO_UPDATE_STATE_FILE);
 }
 function toPathOptions(options) {
   return {
@@ -13974,9 +15547,9 @@ function flattenValue(lines, currentPath, value) {
   }
   lines.push(formatLoggerField(currentPath, value, inferValueKind(value)));
 }
-function formatLoggerField(path, value, kind) {
+function formatLoggerField(path2, value, kind) {
   const renderedValue = typeof value === "string" ? JSON.stringify(value) : value === null ? "null" : typeof value === "undefined" ? "undefined" : JSON.stringify(value);
-  return `${colorize(path, TUI_THEME.warning)} ${colorize("=", TUI_THEME.muted)} ${colorize(
+  return `${colorize(path2, TUI_THEME.warning)} ${colorize("=", TUI_THEME.muted)} ${colorize(
     renderedValue,
     getValueColor(kind)
   )}`;
@@ -14051,7 +15624,8 @@ function isRecord13(value) {
 }
 
 // src/cli/runtime.ts
-var execFile14 = (0, import_node_util14.promisify)(import_node_child_process15.execFile);
+var openPromise = Promise.resolve().then(() => (init_open(), open_exports));
+var execFile21 = (0, import_node_util21.promisify)(import_node_child_process23.execFile);
 var DAEMON_READY_TIMEOUT_MS = 4e3;
 var DAEMON_READY_POLL_INTERVAL_MS = 100;
 var DAEMON_STOP_TIMEOUT_MS = 4e3;
@@ -14061,13 +15635,13 @@ function createCliRuntime(dependencies = {}) {
   const output = dependencies.output ?? createProcessOutput();
   const fetchImplementation = dependencies.fetch ?? globalThis.fetch;
   const renderManagedTuiImplementation = dependencies.renderManagedTui ?? renderManagedTui;
-  const spawnImplementation = dependencies.spawn ?? import_node_child_process15.spawn;
+  const spawnImplementation = dependencies.spawn ?? import_node_child_process23.spawn;
   const autoUpdateController = createAutoUpdateController({
     fetch: fetchImplementation,
     spawn: spawnImplementation
   });
   const execFileImplementation = dependencies.execFile ?? (async (file, args) => {
-    return await execFile14(file, [...args], {
+    return await execFile21(file, [...args], {
       encoding: "utf8"
     });
   });
@@ -14120,8 +15694,8 @@ function createCliRuntime(dependencies = {}) {
     await ensureConfigDir(daemonPathOptions);
     await rotateDaemonLogIfNeeded(daemonPathOptions);
     const daemonLogPath = getDaemonLogPath(daemonPathOptions);
-    const stdoutFd = (0, import_node_fs4.openSync)(daemonLogPath, "w");
-    const stderrFd = (0, import_node_fs4.openSync)(daemonLogPath, "a");
+    const stdoutFd = (0, import_node_fs7.openSync)(daemonLogPath, "w");
+    const stderrFd = (0, import_node_fs7.openSync)(daemonLogPath, "a");
     const cliEntryPath = resolveCliEntryPath();
     const daemonArgs = [cliEntryPath, "daemon-run", ...toDaemonArgv(options)];
     const child = spawnImplementation(process.execPath, daemonArgs, {
@@ -14133,8 +15707,8 @@ function createCliRuntime(dependencies = {}) {
       stdio: ["ignore", stdoutFd, stderrFd]
     });
     child.unref();
-    (0, import_node_fs4.closeSync)(stdoutFd);
-    (0, import_node_fs4.closeSync)(stderrFd);
+    (0, import_node_fs7.closeSync)(stdoutFd);
+    (0, import_node_fs7.closeSync)(stderrFd);
     if (child.pid === void 0) {
       throw new Error("Failed to obtain the AISnitch daemon PID.");
     }
@@ -14206,8 +15780,8 @@ function createCliRuntime(dependencies = {}) {
     if (logSize < DAEMON_LOG_MAX_BYTES) {
       return;
     }
-    await (0, import_promises18.rm)(backupPath, { force: true });
-    await (0, import_promises18.rename)(logFilePath, backupPath);
+    await (0, import_promises22.rm)(backupPath, { force: true });
+    await (0, import_promises22.rename)(logFilePath, backupPath);
   }
   async function waitForDaemonReady(pathOptions) {
     const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
@@ -14242,7 +15816,7 @@ function createCliRuntime(dependencies = {}) {
   }
   async function readDaemonStartupFailure(pathOptions) {
     try {
-      const daemonLog = await (0, import_promises18.readFile)(getDaemonLogPath(pathOptions), "utf8");
+      const daemonLog = await (0, import_promises22.readFile)(getDaemonLogPath(pathOptions), "utf8");
       const logLines = daemonLog.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
       const lastLine = logLines.at(-1);
       if (!lastLine) {
@@ -14340,22 +15914,35 @@ function createCliRuntime(dependencies = {}) {
         return;
       }
       shuttingDown = true;
-      try {
-        await pipeline.stop();
-      } finally {
-        if (daemonMode) {
-          const daemonPathOptions = toPathOptions2(options);
+      const shutdownTimeouts = {
+        adapterRegistry: DEFAULT_TIMEOUTS.adapterShutdown,
+        httpReceiver: DEFAULT_TIMEOUTS.httpRequest,
+        udsServer: DEFAULT_TIMEOUTS.fileOperation,
+        wsServer: DEFAULT_TIMEOUTS.wsConnection,
+        cleanupFns: 1e3
+      };
+      const components = {
+        adapterRegistry: pipeline.getAdapterRegistry(),
+        httpReceiver: pipeline.getHttpReceiver(),
+        udsServer: pipeline.getUdsServer(),
+        wsServer: pipeline.getWsServer(),
+        eventBus: pipeline.getEventBus(),
+        cleanupFns: daemonMode ? [async () => {
           await Promise.all([
-            removePid(daemonPathOptions),
-            removeDaemonState(daemonPathOptions)
+            removePid(toPathOptions2(options)),
+            removeDaemonState(toPathOptions2(options))
           ]);
-        }
-      }
-      if (!daemonMode) {
-        output.stdout(`AISnitch stopped after ${signal}.
+        }] : []
+      };
+      try {
+        await shutdownInOrder(components, shutdownTimeouts, "pipeline");
+      } finally {
+        if (!daemonMode) {
+          output.stdout(`AISnitch stopped after ${signal}.
 `);
+        }
+        process.exit(exitCode);
       }
-      process.exit(exitCode);
     };
     if (daemonMode) {
       process.once("SIGTERM", () => {
@@ -14541,6 +16128,113 @@ function createCliRuntime(dependencies = {}) {
       }
     });
   }
+  async function fullscreen(options) {
+    const snapshot = await getStatusSnapshot(options);
+    if (!snapshot.running && options.daemonMode) {
+      output.stdout("Starting daemon...\n");
+      await startDetachedDaemon(options);
+    }
+    if (!snapshot.running && !options.daemonMode) {
+      throw new Error(
+        "AISnitch daemon is not running. Start one with `aisnitch start --daemon` or use `aisnitch fs --daemon` to start and open the dashboard."
+      );
+    }
+    for (let i = 0; i < 20; i++) {
+      const health = await fetchHealth(snapshot.httpPort);
+      if (health) break;
+      await new Promise((resolve2) => setTimeout(resolve2, 200).unref());
+    }
+    const dashboardPort = options.dashboardPort ?? 5174;
+    const dashboardUrl = `http://127.0.0.1:${dashboardPort}`;
+    const distPath = (0, import_node_path22.join)(process.cwd(), "examples", "fullscreen-dashboard", "dist");
+    output.stdout(`Starting dashboard server on port ${dashboardPort}...
+`);
+    const viteProcess = spawnImplementation(process.execPath, [
+      "-e",
+      `
+import { createServer } from 'vite';
+import path from 'path';
+
+const distPath = '${distPath}';
+const port = ${dashboardPort};
+
+const server = await createServer({
+  root: distPath,
+  server: {
+    port,
+    strictPort: true,
+    allowedHosts: true,
+  },
+  preview: {
+    port,
+    strictPort: true,
+  },
+});
+
+await server.listen();
+console.log('READY');
+
+process.stdin.resume();
+`
+    ], {
+      cwd: distPath,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let serverOutput = "";
+    viteProcess.stdout?.on("data", (data) => {
+      serverOutput += data.toString();
+    });
+    viteProcess.stderr?.on("data", (data) => {
+      serverOutput += data.toString();
+    });
+    let serverReady = false;
+    for (let i = 0; i < 100; i++) {
+      await new Promise((resolve2) => setTimeout(resolve2, 100).unref());
+      try {
+        const response = await fetchImplementation(dashboardUrl);
+        if (response.ok) {
+          serverReady = true;
+          break;
+        }
+      } catch {
+      }
+      if (!viteProcess.pid) break;
+    }
+    if (!serverReady) {
+      output.stdout(`Server output: ${serverOutput}
+`);
+      throw new Error("Failed to start dashboard server");
+    }
+    output.stdout(`Dashboard ready at ${dashboardUrl}
+`);
+    if (!options.noBrowser) {
+      output.stdout("Opening browser...\n");
+      const openModule = await openPromise;
+      await openModule.default(dashboardUrl);
+    }
+    output.stdout("Press Ctrl+C to stop\n");
+    await new Promise((resolve2) => {
+      const shutdown = () => {
+        process.off("SIGINT", handleSigint);
+        process.off("SIGTERM", handleSigterm);
+        if (viteProcess.pid !== void 0) {
+          try {
+            process.kill(viteProcess.pid, "SIGTERM");
+          } catch {
+          }
+        }
+        resolve2();
+      };
+      const handleSigint = () => {
+        shutdown();
+      };
+      const handleSigterm = () => {
+        shutdown();
+      };
+      process.once("SIGINT", handleSigint);
+      process.once("SIGTERM", handleSigterm);
+    });
+  }
   async function logger2(options) {
     const snapshot = await getStatusSnapshot(options);
     if (!snapshot.running) {
@@ -14612,7 +16306,7 @@ function createCliRuntime(dependencies = {}) {
     }
     const { config } = await loadEffectiveConfig(options);
     setLoggerLevel(getForegroundSafeLogLevel(config.logLevel, false));
-    const ephemeralHomeDirectory = await (0, import_promises18.mkdtemp)((0, import_node_path19.join)((0, import_node_os5.tmpdir)(), "aisnitch-mock-"));
+    const ephemeralHomeDirectory = await (0, import_promises22.mkdtemp)((0, import_node_path22.join)((0, import_node_os6.tmpdir)(), "aisnitch-mock-"));
     const ephemeralPipeline = new Pipeline();
     const status2 = await ephemeralPipeline.start({
       config: {
@@ -14651,7 +16345,7 @@ function createCliRuntime(dependencies = {}) {
     } finally {
       await Promise.resolve(monitorClose());
       await ephemeralPipeline.stop();
-      await (0, import_promises18.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
+      await (0, import_promises22.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
     }
   }
   async function install(options) {
@@ -14673,7 +16367,7 @@ function createCliRuntime(dependencies = {}) {
       await execFileImplementation("launchctl", ["bootout", domainTarget, launchAgentPath]);
     } catch {
     }
-    await (0, import_promises18.writeFile)(launchAgentPath, plistContents, "utf8");
+    await (0, import_promises22.writeFile)(launchAgentPath, plistContents, "utf8");
     await execFileImplementation("launchctl", ["bootstrap", domainTarget, launchAgentPath]);
     output.stdout(`AISnitch LaunchAgent installed at ${launchAgentPath}
 `);
@@ -14696,7 +16390,7 @@ function createCliRuntime(dependencies = {}) {
     } else {
       const { config } = await loadEffectiveConfig(options);
       setLoggerLevel(getForegroundSafeLogLevel(config.logLevel, false));
-      ephemeralHomeDirectory = await (0, import_promises18.mkdtemp)((0, import_node_path19.join)((0, import_node_os5.tmpdir)(), "aisnitch-wrap-"));
+      ephemeralHomeDirectory = await (0, import_promises22.mkdtemp)((0, import_node_path22.join)((0, import_node_os6.tmpdir)(), "aisnitch-wrap-"));
       ephemeralPipeline = new Pipeline();
       await ephemeralPipeline.start({
         config: {
@@ -14751,7 +16445,7 @@ function createCliRuntime(dependencies = {}) {
         await ephemeralPipeline.stop();
       }
       if (ephemeralHomeDirectory !== null) {
-        await (0, import_promises18.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
+        await (0, import_promises22.rm)(ephemeralHomeDirectory, { force: true, recursive: true });
       }
     }
     process.exit(wrappedExitCode);
@@ -14771,7 +16465,7 @@ function createCliRuntime(dependencies = {}) {
           },
           pid: process.ppid > 1 ? process.ppid : void 0,
           source: "aisnitch://adapters/aider/notifications-command",
-          transcriptPath: (0, import_node_path19.join)(process.cwd(), ".aider.chat.history.md"),
+          transcriptPath: (0, import_node_path22.join)(process.cwd(), ".aider.chat.history.md"),
           type: "agent.idle"
         }),
         headers: {
@@ -14793,7 +16487,7 @@ function createCliRuntime(dependencies = {}) {
       await execFileImplementation("launchctl", ["bootout", domainTarget, launchAgentPath]);
     } catch {
     }
-    await (0, import_promises18.rm)(launchAgentPath, { force: true });
+    await (0, import_promises22.rm)(launchAgentPath, { force: true });
     output.stdout(`AISnitch LaunchAgent removed from ${launchAgentPath}
 `);
   }
@@ -14832,6 +16526,7 @@ function createCliRuntime(dependencies = {}) {
     adapters,
     aiderNotify,
     attach,
+    fullscreen,
     install,
     logger: logger2,
     mock,
@@ -14972,7 +16667,7 @@ function joinSocketPath(pathOptions) {
 }
 function resolveCliEntryPath() {
   const cliEntryPath = process.argv[1];
-  if (!cliEntryPath || (0, import_node_path19.basename)(cliEntryPath).length === 0) {
+  if (!cliEntryPath || (0, import_node_path22.basename)(cliEntryPath).length === 0) {
     throw new Error("Unable to resolve the AISnitch CLI entry path.");
   }
   return cliEntryPath;
@@ -15043,6 +16738,9 @@ Examples:
   aisnitch start --daemon
   aisnitch start --view full-data
   aisnitch start --mock
+  aisnitch fs
+  aisnitch fs --daemon
+  aisnitch fs --dashboard-port 8080
   aisnitch status
   aisnitch attach
   aisnitch attach --view full-data
@@ -15066,6 +16764,7 @@ Examples:
   addAdaptersCommand(program, runtime);
   addSetupCommand(program, runtime);
   addAttachCommand(program, runtime);
+  addFullscreenCommand(program, runtime);
   addLoggerCommand(program, runtime);
   addMockCommand(program, runtime);
   addWrapCommand(program, runtime);
@@ -15198,6 +16897,23 @@ function addAttachCommand(program, runtime) {
     await runtime.attach(options);
   });
 }
+function addFullscreenCommand(program, runtime) {
+  addCommonOptions(
+    program.command("fs").description("Open the fullscreen web dashboard in browser (starts daemon if needed with --daemon)").alias("fullscreen").option(
+      "--daemon",
+      "Start the daemon automatically if not running"
+    ).option(
+      "--dashboard-port <port>",
+      "Port for the dashboard server (default: 5174)",
+      wrapOptionParser(parsePortOption)
+    ).option(
+      "--no-browser",
+      "Start server without opening browser"
+    )
+  ).action(async (options) => {
+    await runtime.fullscreen(options);
+  });
+}
 function addWrapCommand(program, runtime) {
   addCommonOptions(
     program.command("wrap").description("Run a command inside a PTY while AISnitch observes its terminal activity").allowUnknownOption(true).argument("<command>", "Command to wrap").argument("[args...]", "Arguments forwarded to the wrapped command").option("--cwd <path>", "Run the wrapped command from a specific working directory")