adhdev 0.9.43 → 0.9.45

package/dist/cli/index.js

@@ -500,18 +500,18 @@ var init_source = __esm({
         }
       }
     });
-    createStyler = (open3, close, parent) => {
+    createStyler = (open2, close, parent) => {
       let openAll;
       let closeAll;
       if (parent === void 0) {
-        openAll = open3;
+        openAll = open2;
         closeAll = close;
       } else {
-        openAll = parent.openAll + open3;
+        openAll = parent.openAll + open2;
         closeAll = close + parent.closeAll;
       }
       return {
-        open: open3,
+        open: open2,
         close,
         openAll,
         closeAll,
@@ -1410,17 +1410,17 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs(providerLoader) {
-  const os31 = (0, import_os2.platform)();
+  const os30 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
-    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os31] || []) || []);
+    const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os30] || []) || []);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os31 === "darwin") {
+    if (!resolvedCli && appPath && os30 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs3.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os31 === "win32") {
+    if (!resolvedCli && appPath && os30 === "win32") {
       const { dirname: dirname11 } = await import("path");
       const appDir = dirname11(appPath);
       const candidates = [
@@ -1437,7 +1437,7 @@ async function detectIDEs(providerLoader) {
         }
       }
     }
-    const installed = os31 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+    const installed = os30 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
     const version2 = resolvedCli ? getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
@@ -1506,8 +1506,8 @@ function execAsync(cmd, timeoutMs = 5e3) {
   });
 }
 async function detectCLIs(providerLoader, options) {
-  const platform13 = os3.platform();
-  const whichCmd = platform13 === "win32" ? "where" : "which";
+  const platform12 = os3.platform();
+  const whichCmd = platform12 === "win32" ? "where" : "which";
   const includeVersion = options?.includeVersion !== false;
   const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
   const results = await Promise.all(
@@ -1550,8 +1550,8 @@ async function detectCLI(cliId, providerLoader, options) {
     const cliList = providerLoader.getCliDetectionList();
     const target = cliList.find((c) => c.id === resolvedId);
     if (target) {
-      const platform13 = os3.platform();
-      const whichCmd = platform13 === "win32" ? "where" : "which";
+      const platform12 = os3.platform();
+      const whichCmd = platform12 === "win32" ? "where" : "which";
       try {
         const explicitPath = resolveCommandPath(target.command);
         const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
@@ -4552,6 +4552,27 @@ function computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatur
     persistedEntries: nextPersistedEntries
   };
 }
+function pageHistoryRecords(agentType, records, offset = 0, limit = 30, excludeRecentCount = 0, historyBehavior) {
+  const allMessages = records.map((message) => sanitizeHistoryMessage(agentType, message)).filter(Boolean);
+  allMessages.sort((a, b) => a.receivedAt - b.receivedAt);
+  const chronological = [];
+  let lastTurn = null;
+  for (const message of allMessages) {
+    const previous = chronological[chronological.length - 1];
+    if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
+    if (message.role !== "system" && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
+    chronological.push(message);
+    if (message.role !== "system") lastTurn = message;
+  }
+  const collapsed = collapseReplayAssistantTurns(chronological, historyBehavior);
+  const boundedLimit = Math.max(1, limit);
+  const boundedOffset = Math.max(0, offset);
+  const boundedExclude = Math.max(0, Math.min(excludeRecentCount, collapsed.length));
+  const endExclusive = Math.max(0, collapsed.length - boundedExclude - boundedOffset);
+  const startInclusive = Math.max(0, endExclusive - boundedLimit);
+  const sliced = collapsed.slice(startInclusive, endExclusive);
+  return { messages: sliced, hasMore: startInclusive > 0 };
+}
 function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, excludeRecentCount = 0, historyBehavior) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -4577,25 +4598,7 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
         }
       }
     }
-    allMessages.sort((a, b) => a.receivedAt - b.receivedAt);
-    const chronological = [];
-    let lastTurn = null;
-    for (const message of allMessages) {
-      const previous = chronological[chronological.length - 1];
-      if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
-      if (message.role !== "system" && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
-      chronological.push(message);
-      if (message.role !== "system") lastTurn = message;
-    }
-    const collapsed = collapseReplayAssistantTurns(chronological, historyBehavior);
-    const boundedLimit = Math.max(1, limit);
-    const boundedOffset = Math.max(0, offset);
-    const boundedExclude = Math.max(0, Math.min(excludeRecentCount, collapsed.length));
-    const endExclusive = Math.max(0, collapsed.length - boundedExclude - boundedOffset);
-    const startInclusive = Math.max(0, endExclusive - boundedLimit);
-    const sliced = collapsed.slice(startInclusive, endExclusive);
-    const hasMore = startInclusive > 0;
-    return { messages: sliced, hasMore };
+    return pageHistoryRecords(agentType, allMessages, offset, limit, excludeRecentCount, historyBehavior);
   } catch {
     return { messages: [], hasMore: false };
   }
@@ -4730,6 +4733,52 @@ function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
     return false;
   }
 }
+function buildHermesNativeHistoryRecords(historySessionId) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
+  if (!normalizedSessionId) return null;
+  try {
+    const sessionFilePath = path7.join(os6.homedir(), ".hermes", "sessions", `session_${normalizedSessionId}.json`);
+    if (!fs3.existsSync(sessionFilePath)) return null;
+    const raw = JSON.parse(fs3.readFileSync(sessionFilePath, "utf-8"));
+    const canonicalMessages = Array.isArray(raw.messages) ? raw.messages : [];
+    const records = [];
+    let fallbackTs = Date.parse(raw.session_start || raw.last_updated || "") || Date.now();
+    for (const message of canonicalMessages) {
+      const role = String(message.role || "").trim();
+      const content = normalizeCanonicalHermesMessageContent(message.content);
+      if (!content) continue;
+      const receivedAt = extractCanonicalHermesMessageTimestamp(message, fallbackTs);
+      fallbackTs = receivedAt + 1;
+      if (role === "user" || role === "assistant") {
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role,
+          content,
+          kind: "standard",
+          agent: "hermes-cli",
+          historySessionId: normalizedSessionId
+        });
+        continue;
+      }
+      if (role === "tool") {
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "assistant",
+          content,
+          kind: "tool",
+          senderName: "Tool",
+          agent: "hermes-cli",
+          historySessionId: normalizedSessionId
+        });
+      }
+    }
+    return records;
+  } catch {
+    return null;
+  }
+}
 function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId) {
   const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
   if (!normalizedSessionId) return false;
@@ -4879,6 +4928,77 @@ function extractClaudeUserContentParts(content) {
   }
   return parts;
 }
+function buildClaudeNativeHistoryRecords(historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
+  if (!normalizedSessionId) return null;
+  try {
+    const transcriptPath = resolveClaudeProjectTranscriptPath(normalizedSessionId, workspace);
+    if (!transcriptPath) return null;
+    const lines = fs3.readFileSync(transcriptPath, "utf-8").split("\n").filter(Boolean);
+    const records = [];
+    let fallbackTs = Date.now();
+    for (const line of lines) {
+      let parsed = null;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        parsed = null;
+      }
+      if (!parsed) continue;
+      const parsedSessionId = String(parsed.sessionId || "").trim();
+      if (parsedSessionId && parsedSessionId !== normalizedSessionId) continue;
+      const receivedAt = extractTimestampValue(parsed.timestamp) || fallbackTs;
+      fallbackTs = receivedAt + 1;
+      const parsedWorkspace = String(parsed.cwd || workspace || "").trim();
+      if (records.length === 0 && parsedWorkspace) {
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "system",
+          kind: "session_start",
+          content: parsedWorkspace,
+          agent: "claude-cli",
+          historySessionId: normalizedSessionId,
+          workspace: parsedWorkspace
+        });
+      }
+      const type = String(parsed.type || "").trim();
+      const message = parsed.message && typeof parsed.message === "object" ? parsed.message : null;
+      if (type === "user" && message) {
+        for (const part of extractClaudeUserContentParts(message.content)) {
+          records.push({
+            ts: new Date(receivedAt).toISOString(),
+            receivedAt,
+            role: part.role,
+            content: part.content,
+            kind: part.kind,
+            senderName: part.senderName,
+            agent: "claude-cli",
+            historySessionId: normalizedSessionId
+          });
+        }
+        continue;
+      }
+      if (type === "assistant" && message) {
+        for (const part of extractClaudeAssistantContentParts(message.content)) {
+          records.push({
+            ts: new Date(receivedAt).toISOString(),
+            receivedAt,
+            role: "assistant",
+            content: part.content,
+            kind: part.kind,
+            senderName: part.senderName,
+            agent: "claude-cli",
+            historySessionId: normalizedSessionId
+          });
+        }
+      }
+    }
+    return records;
+  } catch {
+    return null;
+  }
+}
 function rebuildClaudeSavedHistoryFromNativeProject(historySessionId, workspace) {
   const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
   if (!normalizedSessionId) return false;
@@ -4957,6 +5077,352 @@ function rebuildClaudeSavedHistoryFromNativeProject(historySessionId, workspace)
     return false;
   }
 }
+function isUuidLikeSessionId(sessionId) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
+}
+function readCodexSessionMeta(filePath) {
+  try {
+    const firstLine = fs3.readFileSync(filePath, "utf-8").split("\n").find(Boolean);
+    if (!firstLine) return null;
+    const parsed = JSON.parse(firstLine);
+    if (String(parsed.type || "") !== "session_meta") return null;
+    const payload = parsed.payload && typeof parsed.payload === "object" ? parsed.payload : null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function resolveCodexSessionTranscriptPath(historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
+  if (!normalizedSessionId || !isUuidLikeSessionId(normalizedSessionId)) return null;
+  const sessionsDir = path7.join(os6.homedir(), ".codex", "sessions");
+  if (!fs3.existsSync(sessionsDir)) return null;
+  const normalizedWorkspace = typeof workspace === "string" ? workspace.trim() : "";
+  const candidates = [];
+  const stack = [sessionsDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries = [];
+    try {
+      entries = fs3.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path7.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(entryPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl") || !entry.name.includes(normalizedSessionId)) continue;
+      const meta3 = readCodexSessionMeta(entryPath);
+      const metaSessionId = String(meta3?.id || "").trim();
+      if (metaSessionId && metaSessionId !== normalizedSessionId) continue;
+      const metaWorkspace = String(meta3?.cwd || "").trim();
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs3.statSync(entryPath).mtimeMs;
+      } catch {
+      }
+      candidates.push({
+        path: entryPath,
+        mtimeMs,
+        workspaceMatches: !!normalizedWorkspace && metaWorkspace === normalizedWorkspace,
+        metaMatches: metaSessionId === normalizedSessionId
+      });
+    }
+  }
+  candidates.sort((a, b) => Number(b.workspaceMatches) - Number(a.workspaceMatches) || Number(b.metaMatches) - Number(a.metaMatches) || b.mtimeMs - a.mtimeMs);
+  return candidates[0]?.path || null;
+}
+function flattenCodexContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (content == null) return "";
+  if (Array.isArray(content)) {
+    return content.map((entry) => flattenCodexContent(entry)).filter(Boolean).join("\n").trim();
+  }
+  if (typeof content === "object") {
+    const record2 = content;
+    if (typeof record2.text === "string") return record2.text.trim();
+    if (typeof record2.content === "string" || Array.isArray(record2.content)) return flattenCodexContent(record2.content);
+    if (typeof record2.output === "string") return record2.output.trim();
+    if (typeof record2.message === "string") return record2.message.trim();
+  }
+  return "";
+}
+function summarizeCodexToolCall(payload) {
+  const name = String(payload.name || payload.type || "tool").trim() || "tool";
+  const rawArguments = payload.arguments ?? payload.input;
+  let argumentValue = "";
+  if (typeof rawArguments === "string") {
+    const trimmed = rawArguments.trim();
+    try {
+      const parsed = JSON.parse(trimmed);
+      argumentValue = summarizeCodexToolArguments(parsed);
+    } catch {
+      argumentValue = trimmed;
+    }
+  } else {
+    argumentValue = summarizeCodexToolArguments(rawArguments);
+  }
+  return argumentValue ? `${name}: ${argumentValue}` : name;
+}
+function summarizeCodexToolArguments(value) {
+  if (typeof value === "string") return value.trim();
+  if (Array.isArray(value)) return value.map((entry) => String(entry)).join(" ").trim();
+  if (!value || typeof value !== "object") return "";
+  const record2 = value;
+  const direct = record2.command || record2.cmd || record2.query || record2.path || record2.prompt;
+  if (typeof direct === "string") return direct.trim();
+  if (Array.isArray(direct)) return direct.map((entry) => String(entry)).join(" ").trim();
+  try {
+    return JSON.stringify(record2).trim();
+  } catch {
+    return "";
+  }
+}
+function codexToolOutputContent(payload) {
+  const output = payload.output ?? payload.result ?? payload.content;
+  const text = flattenCodexContent(output);
+  if (text) return text;
+  if (output && typeof output === "object") {
+    try {
+      return JSON.stringify(output).trim();
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+function buildCodexNativeHistoryRecords(historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
+  if (!normalizedSessionId || !isUuidLikeSessionId(normalizedSessionId)) return null;
+  try {
+    const transcriptPath = resolveCodexSessionTranscriptPath(normalizedSessionId, workspace);
+    if (!transcriptPath) return null;
+    const lines = fs3.readFileSync(transcriptPath, "utf-8").split("\n").filter(Boolean);
+    const records = [];
+    let fallbackTs = Date.now();
+    for (const line of lines) {
+      let parsed = null;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        parsed = null;
+      }
+      if (!parsed) continue;
+      const receivedAt = extractTimestampValue(parsed.timestamp) || fallbackTs;
+      fallbackTs = receivedAt + 1;
+      const type = String(parsed.type || "").trim();
+      const payload = parsed.payload && typeof parsed.payload === "object" ? parsed.payload : null;
+      if (!payload) continue;
+      if (type === "session_meta") {
+        const parsedSessionId = String(payload.id || "").trim();
+        if (parsedSessionId && parsedSessionId !== normalizedSessionId) return null;
+        const parsedWorkspace = String(payload.cwd || workspace || "").trim();
+        if (records.length === 0 && parsedWorkspace) {
+          records.push({
+            ts: new Date(receivedAt).toISOString(),
+            receivedAt,
+            role: "system",
+            kind: "session_start",
+            content: parsedWorkspace,
+            agent: "codex-cli",
+            historySessionId: normalizedSessionId,
+            workspace: parsedWorkspace
+          });
+        }
+        continue;
+      }
+      if (type !== "response_item") continue;
+      const payloadType = String(payload.type || "").trim();
+      if (payloadType === "message") {
+        const role = String(payload.role || "").trim();
+        if (role !== "user" && role !== "assistant") continue;
+        const content = flattenCodexContent(payload.content);
+        if (!content) continue;
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role,
+          content,
+          kind: "standard",
+          agent: "codex-cli",
+          historySessionId: normalizedSessionId
+        });
+        continue;
+      }
+      if (payloadType === "function_call" || payloadType === "custom_tool_call") {
+        const content = summarizeCodexToolCall(payload);
+        if (!content) continue;
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "assistant",
+          content,
+          kind: "tool",
+          senderName: "Tool",
+          agent: "codex-cli",
+          historySessionId: normalizedSessionId
+        });
+        continue;
+      }
+      if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
+        const content = codexToolOutputContent(payload);
+        if (!content) continue;
+        records.push({
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: "assistant",
+          content,
+          kind: "tool",
+          senderName: "Tool",
+          agent: "codex-cli",
+          historySessionId: normalizedSessionId
+        });
+      }
+    }
+    return records;
+  } catch {
+    return null;
+  }
+}
+function rebuildCodexSavedHistoryFromNativeSession(historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
+  if (!normalizedSessionId || !isUuidLikeSessionId(normalizedSessionId)) return false;
+  const records = buildCodexNativeHistoryRecords(normalizedSessionId, workspace);
+  if (!records || records.length === 0) return false;
+  const existingSessionStart = readExistingSessionStartRecord("codex-cli", normalizedSessionId);
+  const recordsToWrite = existingSessionStart && records[0]?.kind !== "session_start" ? [{ ...existingSessionStart, historySessionId: normalizedSessionId }, ...records] : records;
+  return rewriteCanonicalSavedHistory("codex-cli", normalizedSessionId, recordsToWrite);
+}
+function isNativeSourceCanonicalHistory(canonicalHistory) {
+  if (!canonicalHistory) return false;
+  if (canonicalHistory.mode === "disabled") return false;
+  if (canonicalHistory.mode === "materialized-mirror") return false;
+  return true;
+}
+function buildNativeHistoryRecords(canonicalHistory, historySessionId, workspace) {
+  const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId || "");
+  if (!canonicalHistory || !normalizedSessionId || !isNativeSourceCanonicalHistory(canonicalHistory)) return null;
+  if (canonicalHistory.format === "hermes-json") return buildHermesNativeHistoryRecords(normalizedSessionId);
+  if (canonicalHistory.format === "claude-jsonl") return buildClaudeNativeHistoryRecords(normalizedSessionId, workspace);
+  if (canonicalHistory.format === "codex-jsonl") return buildCodexNativeHistoryRecords(normalizedSessionId, workspace);
+  return null;
+}
+function readProviderChatHistory(agentType, options = {}) {
+  if (isNativeSourceCanonicalHistory(options.canonicalHistory) && options.historySessionId) {
+    const records = buildNativeHistoryRecords(options.canonicalHistory, options.historySessionId, options.workspace);
+    if (!records) return { messages: [], hasMore: false, source: "native-unavailable" };
+    return {
+      ...pageHistoryRecords(agentType, records, options.offset || 0, options.limit || 30, options.excludeRecentCount || 0, options.historyBehavior),
+      source: "provider-native"
+    };
+  }
+  return {
+    ...readChatHistory(agentType, options.offset || 0, options.limit || 30, options.historySessionId, options.excludeRecentCount || 0, options.historyBehavior),
+    source: "adhdev-mirror"
+  };
+}
+function buildNativeSessionSummary(agentType, historySessionId, records, sourcePath) {
+  const visible = pageHistoryRecords(agentType, records, 0, Number.MAX_SAFE_INTEGER).messages;
+  if (visible.length === 0) return null;
+  let sourceMtimeMs = 0;
+  try {
+    sourceMtimeMs = fs3.statSync(sourcePath).mtimeMs;
+  } catch {
+  }
+  const firstMessageAt = visible[0]?.receivedAt || sourceMtimeMs || Date.now();
+  const lastMessageAt = visible[visible.length - 1]?.receivedAt || firstMessageAt;
+  const lastNonSystem = [...visible].reverse().find((message) => message.role !== "system") || visible[visible.length - 1];
+  const firstSystem = visible.find((message) => message.kind === "session_start");
+  return {
+    historySessionId,
+    sessionTitle: lastNonSystem?.content,
+    messageCount: visible.length,
+    firstMessageAt,
+    lastMessageAt,
+    preview: lastNonSystem?.content,
+    workspace: firstSystem?.workspace || (firstSystem?.kind === "session_start" ? firstSystem.content : void 0),
+    source: "provider-native",
+    sourcePath,
+    sourceMtimeMs
+  };
+}
+function listFilesRecursive(root, predicate) {
+  if (!fs3.existsSync(root)) return [];
+  const results = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries = [];
+    try {
+      entries = fs3.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path7.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(entryPath);
+        continue;
+      }
+      if (predicate(entryPath, entry)) results.push(entryPath);
+    }
+  }
+  return results;
+}
+function collectNativeHistorySessionSummaries(agentType, canonicalHistory) {
+  const summaries = [];
+  if (canonicalHistory.format === "hermes-json") {
+    const root = path7.join(os6.homedir(), ".hermes", "sessions");
+    for (const filePath of listFilesRecursive(root, (_entryPath, entry) => entry.isFile() && /^session_.+\.json$/.test(entry.name))) {
+      const fileName = path7.basename(filePath);
+      const historySessionId = fileName.replace(/^session_/, "").replace(/\.json$/, "");
+      const records = buildHermesNativeHistoryRecords(historySessionId);
+      const summary = records ? buildNativeSessionSummary(agentType, historySessionId, records, filePath) : null;
+      if (summary) summaries.push(summary);
+    }
+  } else if (canonicalHistory.format === "claude-jsonl") {
+    const root = path7.join(os6.homedir(), ".claude", "projects");
+    for (const filePath of listFilesRecursive(root, (_entryPath, entry) => entry.isFile() && entry.name.endsWith(".jsonl"))) {
+      const historySessionId = path7.basename(filePath, ".jsonl");
+      const records = buildClaudeNativeHistoryRecords(historySessionId);
+      const summary = records ? buildNativeSessionSummary(agentType, historySessionId, records, filePath) : null;
+      if (summary) summaries.push(summary);
+    }
+  } else if (canonicalHistory.format === "codex-jsonl") {
+    const root = path7.join(os6.homedir(), ".codex", "sessions");
+    const uuidPattern = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+    for (const filePath of listFilesRecursive(root, (_entryPath, entry) => entry.isFile() && entry.name.endsWith(".jsonl"))) {
+      const meta3 = readCodexSessionMeta(filePath);
+      const historySessionId = String(meta3?.id || path7.basename(filePath).match(uuidPattern)?.[1] || "").trim();
+      if (!historySessionId) continue;
+      const records = buildCodexNativeHistoryRecords(historySessionId, String(meta3?.cwd || "").trim() || void 0);
+      const summary = records ? buildNativeSessionSummary(agentType, historySessionId, records, filePath) : null;
+      if (summary) summaries.push(summary);
+    }
+  }
+  return sortSavedHistorySessionSummaries(summaries);
+}
+function listProviderHistorySessions(agentType, options = {}) {
+  if (isNativeSourceCanonicalHistory(options.canonicalHistory)) {
+    const offset = Math.max(0, options.offset || 0);
+    const limit = Math.max(1, options.limit || 30);
+    const summaries = collectNativeHistorySessionSummaries(agentType, options.canonicalHistory);
+    return {
+      sessions: summaries.slice(offset, offset + limit),
+      hasMore: offset + limit < summaries.length,
+      source: "provider-native"
+    };
+  }
+  return {
+    ...listSavedHistorySessions(agentType, { offset: options.offset, limit: options.limit }, options.historyBehavior),
+    source: "adhdev-mirror"
+  };
+}
 var fs3, path7, os6, HISTORY_DIR, RETAIN_DAYS, SAVED_HISTORY_INDEX_VERSION, SAVED_HISTORY_INDEX_FILE, SAVED_HISTORY_INDEX_LOCK_SUFFIX, SAVED_HISTORY_INDEX_LOCK_WAIT_MS, SAVED_HISTORY_INDEX_LOCK_STALE_MS, SAVED_HISTORY_INDEX_LOCK_POLL_MS, SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES, savedHistorySessionCache, savedHistoryFileSummaryCache, savedHistoryBackgroundRefresh, savedHistoryRollupInFlight, ChatHistoryWriter;
 var init_chat_history = __esm({
   "../../oss/packages/daemon-core/src/config/chat-history.ts"() {
@@ -5960,6 +6426,8 @@ function validateReadChatResultPayload(raw, source = "read_chat") {
   if (raw.summaryMetadata !== void 0) normalized.summaryMetadata = raw.summaryMetadata;
   if (Array.isArray(raw.effects)) normalized.effects = raw.effects;
   if (typeof raw.providerSessionId === "string") normalized.providerSessionId = raw.providerSessionId;
+  if (raw.transcriptAuthority === "provider" || raw.transcriptAuthority === "daemon") normalized.transcriptAuthority = raw.transcriptAuthority;
+  if (raw.coverage === "full" || raw.coverage === "tail" || raw.coverage === "current-turn") normalized.coverage = raw.coverage;
   return normalized;
 }
 var VALID_STATUSES, VALID_ROLES, VALID_BUBBLE_STATES, VALID_TURN_STATUSES;
@@ -8227,7 +8695,16 @@ async function handleChatHistory(h, args) {
       const visibleCount = Array.isArray(status?.messages) ? status.messages.length : 0;
       if (visibleCount > excludeRecentCount) excludeRecentCount = visibleCount;
     }
-    const result = readChatHistory(agentStr, offset || 0, limit || 30, historySessionId, excludeRecentCount);
+    const workspace = typeof args?.workspace === "string" ? args.workspace : typeof h.currentSession?.workspace === "string" ? h.currentSession.workspace : void 0;
+    const result = readProviderChatHistory(agentStr, {
+      canonicalHistory: provider?.canonicalHistory,
+      historySessionId,
+      workspace,
+      offset: offset || 0,
+      limit: limit || 30,
+      excludeRecentCount,
+      historyBehavior: provider?.historyBehavior
+    });
     return { success: true, ...result, agent: agentStr };
   } catch (e) {
     return { success: false, error: e.message };
@@ -8252,7 +8729,8 @@ async function handleReadChat(h, args) {
       }
       const parsedRecord = parsedStatus && typeof parsedStatus === "object" ? parsedStatus : null;
       const adapterStatus = adapter.getStatus();
-      const shouldPreferAdapterMessages = Array.isArray(adapterStatus.messages) && adapterStatus.messages.length > 0 && Array.isArray(parsedRecord?.messages) && adapterStatus.messages.length > parsedRecord.messages.length;
+      const parsedIsProviderAuthoritative = parsedRecord?.transcriptAuthority === "provider" || parsedRecord?.coverage === "full";
+      const shouldPreferAdapterMessages = !parsedIsProviderAuthoritative && Array.isArray(adapterStatus.messages) && adapterStatus.messages.length > 0 && Array.isArray(parsedRecord?.messages) && adapterStatus.messages.length > parsedRecord.messages.length;
       const parsedShowsApproval = hasNonEmptyModalButtons(parsedRecord?.activeModal) && parsedRecord?.status === "waiting_approval";
       const status = parsedRecord ? {
         ...parsedRecord,
@@ -8262,6 +8740,8 @@ async function handleReadChat(h, args) {
       } : adapterStatus;
       const title = typeof parsedRecord?.title === "string" ? parsedRecord.title : void 0;
       const providerSessionId = typeof parsedRecord?.providerSessionId === "string" ? parsedRecord.providerSessionId : void 0;
+      const transcriptAuthority = parsedRecord?.transcriptAuthority === "provider" || parsedRecord?.transcriptAuthority === "daemon" ? parsedRecord.transcriptAuthority : void 0;
+      const coverage = parsedRecord?.coverage === "full" || parsedRecord?.coverage === "tail" || parsedRecord?.coverage === "current-turn" ? parsedRecord.coverage : void 0;
       if (status) {
         LOG.debug("Command", `[read_chat] cli-like resolved provider=${adapter.cliType} target=${String(args?.targetSessionId || "")} adapterStatus=${String(adapterStatus.status || "")} parsedStatus=${String(parsedRecord?.status || "")} shouldPreferAdapterMessages=${String(shouldPreferAdapterMessages)} adapterMsgCount=${Array.isArray(adapterStatus.messages) ? adapterStatus.messages.length : 0} parsedMsgCount=${Array.isArray(parsedRecord?.messages) ? parsedRecord.messages.length : 0} returnedMsgCount=${Array.isArray(status.messages) ? status.messages.length : 0}`);
         return buildReadChatCommandResult({
@@ -8280,7 +8760,9 @@ async function handleReadChat(h, args) {
             returnedMsgCount: Array.isArray(status.messages) ? status.messages.length : 0
           },
           ...title ? { title } : {},
-          ...providerSessionId ? { providerSessionId } : {}
+          ...providerSessionId ? { providerSessionId } : {},
+          ...transcriptAuthority ? { transcriptAuthority } : {},
+          ...coverage ? { coverage } : {}
         }, args);
       }
     }
@@ -11072,18 +11554,18 @@ var init_source2 = __esm({
         }
       }
     });
-    createStyler2 = (open3, close, parent) => {
+    createStyler2 = (open2, close, parent) => {
       let openAll;
       let closeAll;
       if (parent === void 0) {
-        openAll = open3;
+        openAll = open2;
         closeAll = close;
       } else {
-        openAll = parent.openAll + open3;
+        openAll = parent.openAll + open2;
         closeAll = close + parent.closeAll;
       }
       return {
-        open: open3,
+        open: open2,
         close,
         openAll,
         closeAll,
@@ -11615,14 +12097,14 @@ function applyTerminalColorEnv(env3) {
 function ensureNodePtySpawnHelperPermissions(logFn) {
   if (os22.platform() === "win32") return;
   try {
-    const fs27 = __require("fs");
+    const fs22 = __require("fs");
     const ptyDir = path32.resolve(path32.dirname(__require.resolve("node-pty")), "..");
     const platformArch = `${os22.platform()}-${os22.arch()}`;
     const helper = path32.join(ptyDir, "prebuilds", platformArch, "spawn-helper");
-    if (fs27.existsSync(helper)) {
-      const stat4 = fs27.statSync(helper);
+    if (fs22.existsSync(helper)) {
+      const stat4 = fs22.statSync(helper);
       if (!(stat4.mode & 73)) {
-        fs27.chmodSync(helper, stat4.mode | 493);
+        fs22.chmodSync(helper, stat4.mode | 493);
         logFn?.(`Fixed spawn-helper permissions: ${helper}`);
       }
     }
@@ -12095,8 +12577,8 @@ var init_pty_transport = __esm({
         let cwd = options.cwd;
         if (cwd) {
           try {
-            const fs27 = require("fs");
-            const stat4 = fs27.statSync(cwd);
+            const fs22 = require("fs");
+            const stat4 = fs22.statSync(cwd);
             if (!stat4.isDirectory()) cwd = os10.homedir();
           } catch {
             cwd = os10.homedir();
@@ -12194,12 +12676,12 @@ function findBinary(name) {
 function isScriptBinary(binaryPath) {
   if (!path10.isAbsolute(binaryPath)) return false;
   try {
-    const fs27 = require("fs");
-    const resolved = fs27.realpathSync(binaryPath);
+    const fs22 = require("fs");
+    const resolved = fs22.realpathSync(binaryPath);
     const head = Buffer.alloc(8);
-    const fd = fs27.openSync(resolved, "r");
-    fs27.readSync(fd, head, 0, 8, 0);
-    fs27.closeSync(fd);
+    const fd = fs22.openSync(resolved, "r");
+    fs22.readSync(fd, head, 0, 8, 0);
+    fs22.closeSync(fd);
     let i = 0;
     if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
     return head[i] === 35 && head[i + 1] === 33;
@@ -12210,12 +12692,12 @@ function isScriptBinary(binaryPath) {
 function looksLikeMachOOrElf(filePath) {
   if (!path10.isAbsolute(filePath)) return false;
   try {
-    const fs27 = require("fs");
-    const resolved = fs27.realpathSync(filePath);
+    const fs22 = require("fs");
+    const resolved = fs22.realpathSync(filePath);
     const buf = Buffer.alloc(8);
-    const fd = fs27.openSync(resolved, "r");
-    fs27.readSync(fd, buf, 0, 8, 0);
-    fs27.closeSync(fd);
+    const fd = fs22.openSync(resolved, "r");
+    fs22.readSync(fd, buf, 0, 8, 0);
+    fs22.closeSync(fd);
     let i = 0;
     if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
     const b = buf.subarray(i);
@@ -12774,7 +13256,9 @@ var provider_cli_adapter_exports = {};
 __export(provider_cli_adapter_exports, {
   ProviderCliAdapter: () => ProviderCliAdapter,
   appendBoundedText: () => appendBoundedText,
-  normalizeCliProviderForRuntime: () => normalizeCliProviderForRuntime
+  normalizeCliProviderForRuntime: () => normalizeCliProviderForRuntime,
+  sanitizeCliStandardMessageContent: () => sanitizeCliStandardMessageContent,
+  trimLastAssistantEchoForCliMessages: () => trimLastAssistantEchoForCliMessages
 });
 function normalizeComparableTranscriptText(value) {
   return sanitizeTerminalText(String(value || "")).replace(/\s+/g, " ").trim();
@@ -12814,7 +13298,76 @@ function appendBoundedText(current, chunk, maxChars) {
   if (current.length <= keepFromCurrent) return current + chunk;
   return current.slice(-keepFromCurrent) + chunk;
 }
-var os13, ProviderCliAdapter;
+function isLikelyCommittedActivityPrefixContinuation(line) {
+  const trimmed = String(line || "").trim();
+  if (!trimmed) return false;
+  if (COMMITTED_ACTIVITY_PREFIX_BLOCK_RE.test(trimmed)) return false;
+  if (/\s/.test(trimmed)) return false;
+  if (/[가-힣]/.test(trimmed)) return false;
+  if (trimmed.length > 96) return false;
+  return /^[A-Za-z0-9_./:@+%=-]+$/.test(trimmed);
+}
+function parseCommittedActivityPrefixBlock(lines, index) {
+  const first = String(lines[index] || "").trim();
+  if (!COMMITTED_ACTIVITY_PREFIX_BLOCK_RE.test(first)) return null;
+  const parts = [first];
+  let nextIndex = index + 1;
+  while (nextIndex < lines.length && isLikelyCommittedActivityPrefixContinuation(lines[nextIndex])) {
+    parts.push(String(lines[nextIndex] || "").trim());
+    nextIndex += 1;
+  }
+  return { label: parts.join(""), nextIndex };
+}
+function sanitizeCliStandardMessageContent(content) {
+  const source = String(content || "").trim();
+  if (!source) return "";
+  const lines = source.split(/\r?\n/);
+  if (lines.length < 4) return source;
+  const counts = /* @__PURE__ */ new Map();
+  for (let index = 0; index < lines.length; index += 1) {
+    const block = parseCommittedActivityPrefixBlock(lines, index);
+    if (!block) continue;
+    counts.set(block.label, (counts.get(block.label) || 0) + 1);
+    index = block.nextIndex - 1;
+  }
+  const repeatedLabels = new Set(
+    Array.from(counts.entries()).filter(([, count]) => count >= 3).map(([label]) => label)
+  );
+  if (repeatedLabels.size === 0) return source;
+  const stripped = [];
+  let removed = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const block = parseCommittedActivityPrefixBlock(lines, index);
+    if (block && repeatedLabels.has(block.label)) {
+      removed += 1;
+      index = block.nextIndex - 1;
+      continue;
+    }
+    stripped.push(lines[index]);
+  }
+  const next = stripped.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  return removed >= 3 && next.length >= 80 ? next : source;
+}
+function sanitizeCommittedMessageForDisplay(message) {
+  if (!message || message.role !== "assistant" || (message.kind || "standard") !== "standard") return message;
+  const content = sanitizeCliStandardMessageContent(message.content);
+  if (content === message.content) return message;
+  return { ...message, content };
+}
+function trimLastAssistantEchoForCliMessages(messages, prompt2) {
+  if (!prompt2) return;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || message.role !== "assistant" || typeof message.content !== "string") continue;
+    if ((message.kind || "standard") !== "standard") continue;
+    message.content = trimPromptEchoPrefix(message.content, prompt2);
+    if (!message.content.trim()) {
+      messages.splice(index, 1);
+    }
+    return;
+  }
+}
+var os13, COMMITTED_ACTIVITY_PREFIX_BLOCK_RE, ProviderCliAdapter;
 var init_provider_cli_adapter = __esm({
   "../../oss/packages/daemon-core/src/cli-adapters/provider-cli-adapter.ts"() {
     "use strict";
@@ -12830,6 +13383,7 @@ var init_provider_cli_adapter = __esm({
     init_provider_cli_config();
     init_provider_cli_runtime();
     init_provider_cli_shared();
+    COMMITTED_ACTIVITY_PREFIX_BLOCK_RE = /^(?:📖|💻|🔎|📚|📋|✏️|📝|🔧|🛠️|⚙️)\s+(.+)$/;
     ProviderCliAdapter = class _ProviderCliAdapter {
       constructor(provider, workingDir, extraArgs = [], transportFactory = new NodePtyTransportFactory()) {
         this.extraArgs = extraArgs;
@@ -13010,7 +13564,14 @@ var init_provider_cli_adapter = __esm({
         }
         return null;
       }
+      providerOwnsTranscript() {
+        return this.provider.transcriptAuthority === "provider";
+      }
+      shouldUseFullProviderTranscriptContext() {
+        return this.providerOwnsTranscript() && this.provider.transcriptContext === "full";
+      }
       selectParseBaseMessages(baseMessages) {
+        if (this.shouldUseFullProviderTranscriptContext()) return baseMessages;
         if (baseMessages.length <= _ProviderCliAdapter.PARSE_MESSAGE_TAIL_LIMIT) return baseMessages;
         return baseMessages.slice(-_ProviderCliAdapter.PARSE_MESSAGE_TAIL_LIMIT);
       }
@@ -13041,7 +13602,10 @@ var init_provider_cli_adapter = __esm({
         const tailFirst = parseBaseMessages[0];
         if (tailFirst && this.messagesComparable(parsedFirst, tailFirst)) {
           const prefixLength = fullBaseMessages.length - parseBaseMessages.length;
-          return [...fullBaseMessages.slice(0, prefixLength), ...parsedMessages];
+          const prefix = fullBaseMessages.slice(0, prefixLength);
+          const shouldSanitizePrefix = !!this.currentTurnScope || this.currentStatus !== "idle" || !!this.activeModal;
+          const nextPrefix = shouldSanitizePrefix ? prefix.map((message) => sanitizeCommittedMessageForDisplay(message)) : prefix;
+          return [...nextPrefix, ...parsedMessages];
         }
         return [...fullBaseMessages, ...parsedMessages];
       }
@@ -13490,9 +14054,7 @@ var init_provider_cli_adapter = __esm({
         );
       }
       trimLastAssistantEcho(messages, prompt2) {
-        if (!prompt2) return;
-        const last = [...messages].reverse().find((m) => m.role === "assistant" && typeof m.content === "string");
-        if (last) last.content = trimPromptEchoPrefix(last.content, prompt2);
+        trimLastAssistantEchoForCliMessages(messages, prompt2);
       }
       clearAllTimers() {
         if (this.responseTimeout) {
@@ -14240,10 +14802,12 @@ var init_provider_cli_adapter = __esm({
       }
       buildCommittedChatMessages() {
         return this.committedMessages.map((message, index) => {
-          const contentValue = message.content;
+          const rawContentValue = message.content;
+          const rawContent = typeof rawContentValue === "string" ? rawContentValue : String(rawContentValue || "");
+          const content = message.role === "assistant" && (message.kind || "standard") === "standard" ? sanitizeCliStandardMessageContent(rawContent) : rawContent;
           return buildChatMessage({
             role: message.role,
-            content: typeof contentValue === "string" ? contentValue : String(contentValue || ""),
+            content,
             timestamp: message.timestamp,
             kind: message.kind,
             meta: message.meta,
@@ -14344,7 +14908,8 @@ var init_provider_cli_adapter = __esm({
             title: parsed.title || this.cliName,
             messages: hydratedMessages,
             activeModal: parsed.activeModal ?? this.activeModal,
-            providerSessionId: typeof parsed.providerSessionId === "string" ? parsed.providerSessionId : void 0
+            providerSessionId: typeof parsed.providerSessionId === "string" ? parsed.providerSessionId : void 0,
+            ...this.providerOwnsTranscript() ? { transcriptAuthority: "provider", coverage: this.shouldUseFullProviderTranscriptContext() ? "full" : "tail" } : {}
           };
         } else {
           const messages = [...this.committedMessages];
@@ -15236,6 +15801,8 @@ var init_cli_provider_instance = __esm({
       lastCanonicalHermesWatchPath = void 0;
       lastCanonicalClaudeRebuildMtimeMs = 0;
       lastCanonicalClaudeCheckAt = 0;
+      lastCanonicalCodexRebuildMtimeMs = 0;
+      lastCanonicalCodexCheckAt = 0;
       cachedSqliteDb = null;
       cachedSqliteDbPath = null;
       cachedSqliteDbMissingUntil = 0;
@@ -15935,6 +16502,25 @@ ${effect.notification.body || ""}`.trim();
         if (!this.providerSessionId) return false;
         const canonicalHistory = this.provider.canonicalHistory;
         if (!canonicalHistory) return false;
+        if (isNativeSourceCanonicalHistory(canonicalHistory)) {
+          const restoredHistory = readProviderChatHistory(this.type, {
+            canonicalHistory,
+            historySessionId: this.providerSessionId,
+            workspace: this.workingDir,
+            offset: 0,
+            limit: Number.MAX_SAFE_INTEGER,
+            historyBehavior: this.provider.historyBehavior
+          });
+          if (restoredHistory.source !== "provider-native") return false;
+          this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
+            role: message.role,
+            content: message.content,
+            kind: message.kind,
+            senderName: message.senderName,
+            receivedAt: message.receivedAt
+          }));
+          return true;
+        }
         try {
           let rebuilt = false;
           if (canonicalHistory.format === "hermes-json") {
@@ -15968,6 +16554,23 @@ ${effect.notification.body || ""}`.trim();
             if (transcriptMtime > 0 && transcriptMtime <= this.lastCanonicalClaudeRebuildMtimeMs) return true;
             rebuilt = rebuildClaudeSavedHistoryFromNativeProject(this.providerSessionId, this.workingDir);
             if (rebuilt) this.lastCanonicalClaudeRebuildMtimeMs = transcriptMtime || Date.now();
+          } else if (canonicalHistory.format === "codex-jsonl") {
+            const now = Date.now();
+            if (now - this.lastCanonicalCodexCheckAt < 2e3 && this.lastCanonicalCodexRebuildMtimeMs !== 0) {
+              return true;
+            }
+            this.lastCanonicalCodexCheckAt = now;
+            const transcriptFile = resolveCodexSessionTranscriptPath(this.providerSessionId, this.workingDir);
+            let transcriptMtime = 0;
+            if (transcriptFile) {
+              try {
+                transcriptMtime = fs5.statSync(transcriptFile).mtimeMs;
+              } catch {
+              }
+            }
+            if (transcriptMtime > 0 && transcriptMtime <= this.lastCanonicalCodexRebuildMtimeMs) return true;
+            rebuilt = rebuildCodexSavedHistoryFromNativeSession(this.providerSessionId, this.workingDir);
+            if (rebuilt) this.lastCanonicalCodexRebuildMtimeMs = transcriptMtime || Date.now();
           }
           if (!rebuilt) return false;
           const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
@@ -15986,8 +16589,17 @@ ${effect.notification.body || ""}`.trim();
       restorePersistedHistoryFromCurrentSession() {
         if (!this.providerSessionId) return;
         this.syncCanonicalSavedHistoryIfNeeded();
-        this.historyWriter.compactHistorySession(this.type, this.providerSessionId, this.provider.historyBehavior);
-        const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+        const restoredHistory = isNativeSourceCanonicalHistory(this.provider.canonicalHistory) ? readProviderChatHistory(this.type, {
+          canonicalHistory: this.provider.canonicalHistory,
+          historySessionId: this.providerSessionId,
+          workspace: this.workingDir,
+          offset: 0,
+          limit: Number.MAX_SAFE_INTEGER,
+          historyBehavior: this.provider.historyBehavior
+        }) : (() => {
+          this.historyWriter.compactHistorySession(this.type, this.providerSessionId, this.provider.historyBehavior);
+          return readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+        })();
         this.historyWriter.seedSessionHistory(
           this.type,
           restoredHistory.messages,
@@ -16314,10 +16926,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path36) {
-  if (!path36)
+function getElementAtPath(obj, path35) {
+  if (!path35)
     return obj;
-  return path36.reduce((acc, key) => acc?.[key], obj);
+  return path35.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -16629,11 +17241,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path36, issues) {
+function prefixIssues(path35, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path36);
+    iss.path.unshift(path35);
     return iss;
   });
 }
@@ -16876,7 +17488,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path36 = []) => {
+  const processError = (error49, path35 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -16886,7 +17498,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path36, ...issue2.path];
+        const fullpath = [...path35, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16918,8 +17530,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path36 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path36) {
+  const path35 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path35) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -29683,13 +30295,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path36 = ref.slice(1).split("/").filter(Boolean);
-  if (path36.length === 0) {
+  const path35 = ref.slice(1).split("/").filter(Boolean);
+  if (path35.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path36[0] === defsKey) {
-    const key = path36[1];
+  if (path35[0] === defsKey) {
+    const key = path35[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -34443,7 +35055,7 @@ var init_readdirp = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path36) => statMethod(path36, { bigint: true });
+          this._stat = (path35) => statMethod(path35, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -34468,8 +35080,8 @@ var init_readdirp = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path36, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path36));
+              const { path: path35, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path35));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -34509,21 +35121,21 @@ var init_readdirp = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path36, depth) {
+      async _exploreDir(path35, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path36, this._rdOptions);
+          files = await (0, import_promises.readdir)(path35, this._rdOptions);
         } catch (error48) {
           this._onError(error48);
         }
-        return { files, depth, path: path36 };
+        return { files, depth, path: path35 };
       }
-      async _formatEntry(dirent, path36) {
+      async _formatEntry(dirent, path35) {
         let entry;
-        const basename10 = this._isDirent ? dirent.name : dirent;
+        const basename11 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path36, basename10));
-          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename10 };
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path35, basename11));
+          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename11 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
           this._onError(err);
@@ -34579,16 +35191,16 @@ var init_readdirp = __esm({
 });
 
 // ../../oss/packages/daemon-core/node_modules/chokidar/handler.js
-function createFsWatchInstance(path36, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path35, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path36);
-    emitRaw(rawEvent, evPath, { watchedPath: path36 });
-    if (evPath && path36 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path36, evPath), KEY_LISTENERS, sp.join(path36, evPath));
+    listener(path35);
+    emitRaw(rawEvent, evPath, { watchedPath: path35 });
+    if (evPath && path35 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path35, evPath), KEY_LISTENERS, sp.join(path35, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path36, {
+    return (0, import_node_fs.watch)(path35, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -34937,12 +35549,12 @@ var init_handler2 = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path36, fullPath, options, handlers) => {
+    setFsWatchListener = (path35, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path36, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path35, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -34953,7 +35565,7 @@ var init_handler2 = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path36,
+          path35,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -34968,7 +35580,7 @@ var init_handler2 = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error48.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path36, "r");
+              const fd = await (0, import_promises2.open)(path35, "r");
               await fd.close();
               broadcastErr(error48);
             } catch (err) {
@@ -34999,7 +35611,7 @@ var init_handler2 = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path36, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path35, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -35021,7 +35633,7 @@ var init_handler2 = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path36, curr));
+              foreach(cont.listeners, (listener2) => listener2(path35, curr));
             }
           })
         };
@@ -35051,13 +35663,13 @@ var init_handler2 = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path36, listener) {
+      _watchWithNodeFs(path35, listener) {
         const opts = this.fsw.options;
-        const directory = sp.dirname(path36);
-        const basename10 = sp.basename(path36);
+        const directory = sp.dirname(path35);
+        const basename11 = sp.basename(path35);
         const parent = this.fsw._getWatchedDir(directory);
-        parent.add(basename10);
-        const absolutePath = sp.resolve(path36);
+        parent.add(basename11);
+        const absolutePath = sp.resolve(path35);
         const options = {
           persistent: opts.persistent
         };
@@ -35066,13 +35678,13 @@ var init_handler2 = __esm({
         let closer;
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
-          options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path36, absolutePath, options, {
+          options.interval = enableBin && isBinaryPath(basename11) ? opts.binaryInterval : opts.interval;
+          closer = setFsWatchFileListener(path35, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path36, absolutePath, options, {
+          closer = setFsWatchListener(path35, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -35089,12 +35701,12 @@ var init_handler2 = __esm({
           return;
         }
         const dirname11 = sp.dirname(file2);
-        const basename10 = sp.basename(file2);
+        const basename11 = sp.basename(file2);
         const parent = this.fsw._getWatchedDir(dirname11);
         let prevStats = stats;
-        if (parent.has(basename10))
+        if (parent.has(basename11))
           return;
-        const listener = async (path36, newStats) => {
+        const listener = async (path35, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -35108,18 +35720,18 @@ var init_handler2 = __esm({
                 this.fsw._emit(EV.CHANGE, file2, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path36);
+                this.fsw._closeFile(path35);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file2, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path36, closer2);
+                  this.fsw._addPathCloser(path35, closer2);
               } else {
                 prevStats = newStats2;
               }
             } catch (error48) {
-              this.fsw._remove(dirname11, basename10);
+              this.fsw._remove(dirname11, basename11);
             }
-          } else if (parent.has(basename10)) {
+          } else if (parent.has(basename11)) {
             const at = newStats.atimeMs;
             const mt = newStats.mtimeMs;
             if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -35144,7 +35756,7 @@ var init_handler2 = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path36, item) {
+      async _handleSymlink(entry, directory, path35, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -35154,7 +35766,7 @@ var init_handler2 = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path36);
+            linkPath = await (0, import_promises2.realpath)(path35);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -35164,12 +35776,12 @@ var init_handler2 = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path36, entry.stats);
+              this.fsw._emit(EV.CHANGE, path35, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path36, entry.stats);
+            this.fsw._emit(EV.ADD, path35, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -35199,9 +35811,9 @@ var init_handler2 = __esm({
             return;
           }
           const item = entry.path;
-          let path36 = sp.join(directory, item);
+          let path35 = sp.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path36, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path35, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -35210,8 +35822,8 @@ var init_handler2 = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path36 = sp.join(dir, sp.relative(dir, path36));
-            this._addToNodeFs(path36, initialAdd, wh, depth + 1);
+            path35 = sp.join(dir, sp.relative(dir, path35));
+            this._addToNodeFs(path35, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve18, reject) => {
@@ -35280,13 +35892,13 @@ var init_handler2 = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path36, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path35, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path36) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path35) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path36);
+        const wh = this.fsw._getWatchHelpers(path35);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -35302,8 +35914,8 @@ var init_handler2 = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sp.resolve(path36);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
+            const absPath = sp.resolve(path35);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path35) : path35;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -35313,29 +35925,29 @@ var init_handler2 = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path35) : path35;
             if (this.fsw.closed)
               return;
             const parent = sp.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path36, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path35, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sp.resolve(path36), targetPath);
+              this.fsw._symlinkPaths.set(sp.resolve(path35), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path36, closer);
+            this.fsw._addPathCloser(path35, closer);
           return false;
         } catch (error48) {
           if (this.fsw._handleError(error48)) {
             ready();
-            return path36;
+            return path35;
           }
         }
       }
@@ -35370,24 +35982,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path36) {
-  if (typeof path36 !== "string")
+function normalizePath(path35) {
+  if (typeof path35 !== "string")
     throw new Error("string expected");
-  path36 = sp2.normalize(path36);
-  path36 = path36.replace(/\\/g, "/");
+  path35 = sp2.normalize(path35);
+  path35 = path35.replace(/\\/g, "/");
   let prepend = false;
-  if (path36.startsWith("//"))
+  if (path35.startsWith("//"))
     prepend = true;
-  path36 = path36.replace(DOUBLE_SLASH_RE, "/");
+  path35 = path35.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path36 = "/" + path36;
-  return path36;
+    path35 = "/" + path35;
+  return path35;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path36 = normalizePath(testString);
+  const path35 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path36, stats)) {
+    if (pattern(path35, stats)) {
       return true;
     }
   }
@@ -35450,19 +36062,19 @@ var init_chokidar = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path36) => toUnix(sp2.normalize(toUnix(path36)));
-    normalizeIgnored = (cwd = "") => (path36) => {
-      if (typeof path36 === "string") {
-        return normalizePathToUnix(sp2.isAbsolute(path36) ? path36 : sp2.join(cwd, path36));
+    normalizePathToUnix = (path35) => toUnix(sp2.normalize(toUnix(path35)));
+    normalizeIgnored = (cwd = "") => (path35) => {
+      if (typeof path35 === "string") {
+        return normalizePathToUnix(sp2.isAbsolute(path35) ? path35 : sp2.join(cwd, path35));
       } else {
-        return path36;
+        return path35;
       }
     };
-    getAbsolutePath = (path36, cwd) => {
-      if (sp2.isAbsolute(path36)) {
-        return path36;
+    getAbsolutePath = (path35, cwd) => {
+      if (sp2.isAbsolute(path35)) {
+        return path35;
       }
-      return sp2.join(cwd, path36);
+      return sp2.join(cwd, path35);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -35527,10 +36139,10 @@ var init_chokidar = __esm({
       dirParts;
       followSymlinks;
       statMethod;
-      constructor(path36, follow, fsw) {
+      constructor(path35, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path36;
-        this.path = path36 = path36.replace(REPLACER_RE, "");
+        const watchPath = path35;
+        this.path = path35 = path35.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sp2.resolve(watchPath);
         this.dirParts = [];
@@ -35670,20 +36282,20 @@ var init_chokidar = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path36) => {
-            const absPath = getAbsolutePath(path36, cwd);
+          paths = paths.map((path35) => {
+            const absPath = getAbsolutePath(path35, cwd);
             return absPath;
           });
         }
-        paths.forEach((path36) => {
-          this._removeIgnoredPath(path36);
+        paths.forEach((path35) => {
+          this._removeIgnoredPath(path35);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path36) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path36, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path35) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path35, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -35705,17 +36317,17 @@ var init_chokidar = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path36) => {
-          if (!sp2.isAbsolute(path36) && !this._closers.has(path36)) {
+        paths.forEach((path35) => {
+          if (!sp2.isAbsolute(path35) && !this._closers.has(path35)) {
             if (cwd)
-              path36 = sp2.join(cwd, path36);
-            path36 = sp2.resolve(path36);
+              path35 = sp2.join(cwd, path35);
+            path35 = sp2.resolve(path35);
           }
-          this._closePath(path36);
-          this._addIgnoredPath(path36);
-          if (this._watched.has(path36)) {
+          this._closePath(path35);
+          this._addIgnoredPath(path35);
+          if (this._watched.has(path35)) {
             this._addIgnoredPath({
-              path: path36,
+              path: path35,
               recursive: true
             });
           }
@@ -35779,38 +36391,38 @@ var init_chokidar = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path36, stats) {
+      async _emit(event, path35, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path36 = sp2.normalize(path36);
+          path35 = sp2.normalize(path35);
         if (opts.cwd)
-          path36 = sp2.relative(opts.cwd, path36);
-        const args = [path36];
+          path35 = sp2.relative(opts.cwd, path35);
+        const args = [path35];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path36))) {
+        if (awf && (pw = this._pendingWrites.get(path35))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path36, [event, ...args]);
+            this._pendingUnlinks.set(path35, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path37) => {
+              this._pendingUnlinks.forEach((entry, path36) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path37);
+                this._pendingUnlinks.delete(path36);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path36)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path35)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path36);
+            this._pendingUnlinks.delete(path35);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -35828,16 +36440,16 @@ var init_chokidar = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path36, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path35, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path36, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path35, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sp2.join(opts.cwd, path36) : path36;
+          const fullPath = opts.cwd ? sp2.join(opts.cwd, path35) : path35;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -35868,23 +36480,23 @@ var init_chokidar = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path36, timeout) {
+      _throttle(actionType, path35, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path36);
+        const actionPath = action.get(path35);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path36);
+          const item = action.get(path35);
           const count = item ? item.count : 0;
-          action.delete(path36);
+          action.delete(path35);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -35892,7 +36504,7 @@ var init_chokidar = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path36, thr);
+        action.set(path35, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -35906,44 +36518,44 @@ var init_chokidar = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path36, threshold, event, awfEmit) {
+      _awaitWriteFinish(path35, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path36;
-        if (this.options.cwd && !sp2.isAbsolute(path36)) {
-          fullPath = sp2.join(this.options.cwd, path36);
+        let fullPath = path35;
+        if (this.options.cwd && !sp2.isAbsolute(path35)) {
+          fullPath = sp2.join(this.options.cwd, path35);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path36)) {
+            if (err || !writes.has(path35)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path36).lastChange = now2;
+              writes.get(path35).lastChange = now2;
             }
-            const pw = writes.get(path36);
+            const pw = writes.get(path35);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path36);
+              writes.delete(path35);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path36)) {
-          writes.set(path36, {
+        if (!writes.has(path35)) {
+          writes.set(path35, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path36);
+              writes.delete(path35);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -35954,8 +36566,8 @@ var init_chokidar = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path36, stats) {
-        if (this.options.atomic && DOT_RE.test(path36))
+      _isIgnored(path35, stats) {
+        if (this.options.atomic && DOT_RE.test(path35))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -35965,17 +36577,17 @@ var init_chokidar = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path36, stats);
+        return this._userIgnored(path35, stats);
       }
-      _isntIgnored(path36, stat4) {
-        return !this._isIgnored(path36, stat4);
+      _isntIgnored(path35, stat4) {
+        return !this._isIgnored(path35, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path36) {
-        return new WatchHelper(path36, this.options.followSymlinks, this);
+      _getWatchHelpers(path35) {
+        return new WatchHelper(path35, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -36007,63 +36619,63 @@ var init_chokidar = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path36 = sp2.join(directory, item);
-        const fullPath = sp2.resolve(path36);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path36) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path36, 100))
+        const path35 = sp2.join(directory, item);
+        const fullPath = sp2.resolve(path35);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path35) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path35, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path36);
+        const wp = this._getWatchedDir(path35);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path36, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path35, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path36;
+        let relPath = path35;
         if (this.options.cwd)
-          relPath = sp2.relative(this.options.cwd, path36);
+          relPath = sp2.relative(this.options.cwd, path35);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path36);
+        this._watched.delete(path35);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path36))
-          this._emit(eventName, path36);
-        this._closePath(path36);
+        if (wasTracked && !this._isIgnored(path35))
+          this._emit(eventName, path35);
+        this._closePath(path35);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path36) {
-        this._closeFile(path36);
-        const dir = sp2.dirname(path36);
-        this._getWatchedDir(dir).remove(sp2.basename(path36));
+      _closePath(path35) {
+        this._closeFile(path35);
+        const dir = sp2.dirname(path35);
+        this._getWatchedDir(dir).remove(sp2.basename(path35));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path36) {
-        const closers = this._closers.get(path36);
+      _closeFile(path35) {
+        const closers = this._closers.get(path35);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path36);
+        this._closers.delete(path35);
       }
-      _addPathCloser(path36, closer) {
+      _addPathCloser(path35, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path36);
+        let list = this._closers.get(path35);
         if (!list) {
           list = [];
-          this._closers.set(path36, list);
+          this._closers.set(path35, list);
         }
         list.push(closer);
       }
@@ -37812,6 +38424,43 @@ var init_provider_loader = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/launch/macos-app-process.ts
+function normalizeMacAppPath(appPath) {
+  const trimmed = String(appPath || "").trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/\/+$/, "");
+}
+function parsePsLine(line) {
+  const match = line.match(/^\s*(\d+)\s+(.+)$/);
+  if (!match) return null;
+  const pid = Number.parseInt(match[1], 10);
+  if (!Number.isFinite(pid)) return null;
+  return { pid, args: match[2] };
+}
+function isMacAppProcessArgs(args, appPath) {
+  const normalized = normalizeMacAppPath(appPath);
+  if (!normalized) return false;
+  return String(args || "").startsWith(`${normalized}/`);
+}
+function findMacAppProcessPids(psOutput, appPaths) {
+  const normalizedPaths = appPaths.map(normalizeMacAppPath).filter((value) => !!value);
+  if (normalizedPaths.length === 0) return [];
+  const pids = [];
+  for (const line of String(psOutput || "").split(/\r?\n/)) {
+    const parsed = parsePsLine(line);
+    if (!parsed) continue;
+    if (normalizedPaths.some((appPath) => isMacAppProcessArgs(parsed.args, appPath))) {
+      pids.push(parsed.pid);
+    }
+  }
+  return pids;
+}
+var init_macos_app_process = __esm({
+  "../../oss/packages/daemon-core/src/launch/macos-app-process.ts"() {
+    "use strict";
+  }
+});
+
 // ../../oss/packages/daemon-core/src/launch.ts
 function getProviderLoader() {
   if (!_providerLoader) {
@@ -37834,9 +38483,9 @@ function getWinProcessNames() {
 function getProviderMeta(ideId) {
   return getProviderLoader().getMeta(ideId);
 }
-function getPreferredLaunchMethod(ideId, platform13) {
+function getPreferredLaunchMethod(ideId, platform12) {
   const prefer = getProviderMeta(ideId)?.launch?.prefer;
-  const value = prefer?.[platform13];
+  const value = prefer?.[platform12];
   return value === "cli" || value === "app" || value === "auto" ? value : "auto";
 }
 function getCdpStartupTimeoutMs(ideId) {
@@ -37847,6 +38496,35 @@ function getCdpStartupTimeoutMs(ideId) {
 function escapeForAppleScript(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
+function getIdePathCandidates(ideId) {
+  return getProviderLoader().getIdePathCandidates(ideId);
+}
+function getMacAppProcessPids(ideId) {
+  const appPaths = getIdePathCandidates(ideId);
+  if (appPaths.length === 0) return [];
+  try {
+    const output = (0, import_child_process7.execSync)("ps axww -o pid=,args=", {
+      encoding: "utf-8",
+      timeout: 3e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return findMacAppProcessPids(output, appPaths);
+  } catch {
+    return [];
+  }
+}
+function killMacAppPathProcesses(ideId, signal) {
+  const pids = getMacAppProcessPids(ideId);
+  let signalled = false;
+  for (const pid of pids) {
+    try {
+      process.kill(pid, signal);
+      signalled = true;
+    } catch {
+    }
+  }
+  return signalled;
+}
 async function findFreePort(ports) {
   for (const port2 of ports) {
     const free = await checkPortFree(port2);
@@ -37908,6 +38586,7 @@ async function killIdeProcess(ideId) {
         } catch {
         }
       }
+      killMacAppPathProcesses(ideId, "SIGTERM");
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
@@ -37937,6 +38616,7 @@ async function killIdeProcess(ideId) {
         (0, import_child_process7.execSync)(`pkill -9 -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
       } catch {
       }
+      killMacAppPathProcesses(ideId, "SIGKILL");
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
@@ -37956,14 +38636,16 @@ function isIdeRunning(ideId) {
   try {
     if (plat === "darwin") {
       const appName = getMacAppIdentifiers()[ideId];
-      if (!appName) return false;
+      if (!appName) return getMacAppProcessPids(ideId).length > 0;
       try {
         const result = (0, import_child_process7.execSync)(`pgrep -x "${appName}" 2>/dev/null`, {
           encoding: "utf-8",
           timeout: 3e3
         });
-        return result.trim().length > 0;
+        if (result.trim().length > 0) return true;
       } catch {
+      }
+      try {
         const result = (0, import_child_process7.execSync)(
           `osascript -e 'tell application "System Events" to count (every process whose name is "${escapeForAppleScript(appName)}")'`,
           {
@@ -37972,8 +38654,10 @@ function isIdeRunning(ideId) {
             stdio: ["pipe", "pipe", "pipe"]
           }
         );
-        return Number.parseInt(result.trim() || "0", 10) > 0;
+        if (Number.parseInt(result.trim() || "0", 10) > 0) return true;
+      } catch {
       }
+      return getMacAppProcessPids(ideId).length > 0;
     } else if (plat === "win32") {
       const winProcesses = getWinProcessNames()[ideId];
       if (!winProcesses) return false;
@@ -38018,7 +38702,7 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs27 = require("fs");
+      const fs22 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -38027,8 +38711,8 @@ function detectCurrentWorkspace(ideId) {
           appName,
           "storage.json"
         );
-        if (fs27.existsSync(storagePath)) {
-          const data = JSON.parse(fs27.readFileSync(storagePath, "utf-8"));
+        if (fs22.existsSync(storagePath)) {
+          const data = JSON.parse(fs22.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -38045,7 +38729,7 @@ function detectCurrentWorkspace(ideId) {
   return void 0;
 }
 async function launchWithCdp(options = {}) {
-  const platform13 = os17.platform();
+  const platform12 = os17.platform();
   let targetIde;
   const ides = await detectIDEs(getProviderLoader());
   if (options.ideId) {
@@ -38114,9 +38798,9 @@ async function launchWithCdp(options = {}) {
   }
   const port = await findFreePort(portPair);
   try {
-    if (platform13 === "darwin") {
+    if (platform12 === "darwin") {
       await launchMacOS(targetIde, port, workspace, options.newWindow);
-    } else if (platform13 === "win32") {
+    } else if (platform12 === "win32") {
       await launchWindows(targetIde, port, workspace, options.newWindow);
     } else {
       await launchLinux(targetIde, port, workspace, options.newWindow);
@@ -38204,6 +38888,7 @@ var init_launch = __esm({
     path15 = __toESM(require("path"));
     init_ide_detector();
     init_provider_loader();
+    init_macos_app_process();
     _providerLoader = null;
   }
 });
@@ -39396,13 +40081,18 @@ var init_router = __esm({
             const wantsAll = args?.all === true;
             const offset = wantsAll ? 0 : Math.max(0, Number(args?.offset) || 0);
             const limit = wantsAll ? Number.MAX_SAFE_INTEGER : Math.max(1, Math.min(100, Number(args?.limit) || 30));
-            const { sessions: historySessions, hasMore } = listSavedHistorySessions(providerType, { offset, limit });
+            const providerMeta = this.deps.providerLoader.getMeta(providerType);
+            const { sessions: historySessions, hasMore, source } = listProviderHistorySessions(providerType, {
+              canonicalHistory: providerMeta?.canonicalHistory,
+              offset,
+              limit,
+              historyBehavior: providerMeta?.historyBehavior
+            });
             const state = loadState();
             const savedSessions = getSavedProviderSessions(state, { providerType, kind });
             const recentSessions = getRecentActivity(state, 200).filter((entry) => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
             const savedSessionById = new Map(savedSessions.map((entry) => [entry.providerSessionId, entry]));
             const recentSessionById = new Map(recentSessions.map((entry) => [entry.providerSessionId, entry]));
-            const providerMeta = this.deps.providerLoader.getMeta(providerType);
             const canResumeById = supportsExplicitSessionResume(providerMeta?.resume);
             return {
               success: true,
@@ -39425,7 +40115,8 @@ var init_router = __esm({
                   canResume: !!(saved?.workspace || recent?.workspace || session.workspace) && canResumeById
                 };
               }),
-              hasMore
+              hasMore,
+              source
             };
           }
           // ─── restart_session: IDE / CLI / ACP unified ───
@@ -45461,8 +46152,8 @@ var init_dev_server = __esm({
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path36 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path36}`;
+          const path35 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path35}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -47404,8 +48095,8 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs27 = await import("fs");
-        fs27.writeFileSync(vsixPath, buffer);
+        const fs22 = await import("fs");
+        fs22.writeFileSync(vsixPath, buffer);
         return new Promise((resolve18) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
           (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
@@ -48356,11 +49047,11 @@ var require_yoctocolors_cjs = __commonJS({
     "use strict";
     var tty3 = require("tty");
     var hasColors = tty3?.WriteStream?.prototype?.hasColors?.() ?? false;
-    var format = (open3, close) => {
+    var format = (open2, close) => {
       if (!hasColors) {
         return (input) => input;
       }
-      const openCode = `\x1B[${open3}m`;
+      const openCode = `\x1B[${open2}m`;
       const closeCode = `\x1B[${close}m`;
       return (input) => {
         const string4 = input + "";
@@ -51898,7 +52589,7 @@ var require_innerFrom = __commonJS({
     exports2.fromIterable = fromIterable;
     function fromAsyncIterable(asyncIterable) {
       return new Observable_1.Observable(function(subscriber) {
-        process19(asyncIterable, subscriber).catch(function(err) {
+        process13(asyncIterable, subscriber).catch(function(err) {
           return subscriber.error(err);
         });
       });
@@ -51908,7 +52599,7 @@ var require_innerFrom = __commonJS({
       return fromAsyncIterable(isReadableStreamLike_1.readableStreamLikeToAsyncGenerator(readableStream));
     }
     exports2.fromReadableStreamLike = fromReadableStreamLike;
-    function process19(asyncIterable, subscriber) {
+    function process13(asyncIterable, subscriber) {
       var asyncIterable_1, asyncIterable_1_1;
       var e_2, _a2;
       return __awaiter(this, void 0, void 0, function() {
@@ -59567,15 +60258,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path36 = [graph[toModel].parent, toModel];
+      const path35 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path36.unshift(graph[cur].parent);
+        path35.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path36;
+      fn.conversion = path35;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -59972,7 +60663,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os31 = require("os");
+    var os30 = require("os");
     var tty3 = require("tty");
     var hasFlag3 = require_has_flag();
     var { env: env3 } = process;
@@ -60020,7 +60711,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os31.release().split(".");
+        const osRelease = os30.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -60321,18 +61012,18 @@ var require_source = __commonJS({
         }
       }
     });
-    var createStyler3 = (open3, close, parent) => {
+    var createStyler3 = (open2, close, parent) => {
       let openAll;
       let closeAll;
       if (parent === void 0) {
-        openAll = open3;
+        openAll = open2;
         closeAll = close;
       } else {
-        openAll = parent.openAll + open3;
+        openAll = parent.openAll + open2;
         closeAll = close + parent.closeAll;
       }
       return {
-        open: open3,
+        open: open2,
         close,
         openAll,
         closeAll,
@@ -60496,11 +61187,11 @@ var require_signals = __commonJS({
 var require_signal_exit = __commonJS({
   "../../node_modules/inquirer/node_modules/signal-exit/index.js"(exports2, module2) {
     "use strict";
-    var process19 = global.process;
-    var processOk2 = function(process20) {
-      return process20 && typeof process20 === "object" && typeof process20.removeListener === "function" && typeof process20.emit === "function" && typeof process20.reallyExit === "function" && typeof process20.listeners === "function" && typeof process20.kill === "function" && typeof process20.pid === "number" && typeof process20.on === "function";
+    var process13 = global.process;
+    var processOk2 = function(process14) {
+      return process14 && typeof process14 === "object" && typeof process14.removeListener === "function" && typeof process14.emit === "function" && typeof process14.reallyExit === "function" && typeof process14.listeners === "function" && typeof process14.kill === "function" && typeof process14.pid === "number" && typeof process14.on === "function";
     };
-    if (!processOk2(process19)) {
+    if (!processOk2(process13)) {
       module2.exports = function() {
         return function() {
         };
@@ -60508,15 +61199,15 @@ var require_signal_exit = __commonJS({
     } else {
       assert3 = require("assert");
       signals2 = require_signals();
-      isWin = /^win/i.test(process19.platform);
+      isWin = /^win/i.test(process13.platform);
       EE = require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
       }
-      if (process19.__signal_exit_emitter__) {
-        emitter = process19.__signal_exit_emitter__;
+      if (process13.__signal_exit_emitter__) {
+        emitter = process13.__signal_exit_emitter__;
       } else {
-        emitter = process19.__signal_exit_emitter__ = new EE();
+        emitter = process13.__signal_exit_emitter__ = new EE();
         emitter.count = 0;
         emitter.emitted = {};
       }
@@ -60553,12 +61244,12 @@ var require_signal_exit = __commonJS({
         loaded = false;
         signals2.forEach(function(sig) {
           try {
-            process19.removeListener(sig, sigListeners[sig]);
+            process13.removeListener(sig, sigListeners[sig]);
           } catch (er) {
           }
         });
-        process19.emit = originalProcessEmit;
-        process19.reallyExit = originalProcessReallyExit;
+        process13.emit = originalProcessEmit;
+        process13.reallyExit = originalProcessReallyExit;
         emitter.count -= 1;
       };
       module2.exports.unload = unload2;
@@ -60575,7 +61266,7 @@ var require_signal_exit = __commonJS({
           if (!processOk2(global.process)) {
             return;
           }
-          var listeners = process19.listeners(sig);
+          var listeners = process13.listeners(sig);
           if (listeners.length === emitter.count) {
             unload2();
             emit("exit", null, sig);
@@ -60583,7 +61274,7 @@ var require_signal_exit = __commonJS({
             if (isWin && sig === "SIGHUP") {
               sig = "SIGINT";
             }
-            process19.kill(process19.pid, sig);
+            process13.kill(process13.pid, sig);
           }
         };
       });
@@ -60599,36 +61290,36 @@ var require_signal_exit = __commonJS({
         emitter.count += 1;
         signals2 = signals2.filter(function(sig) {
           try {
-            process19.on(sig, sigListeners[sig]);
+            process13.on(sig, sigListeners[sig]);
             return true;
           } catch (er) {
             return false;
           }
         });
-        process19.emit = processEmit;
-        process19.reallyExit = processReallyExit;
+        process13.emit = processEmit;
+        process13.reallyExit = processReallyExit;
       };
       module2.exports.load = load2;
-      originalProcessReallyExit = process19.reallyExit;
+      originalProcessReallyExit = process13.reallyExit;
       processReallyExit = function processReallyExit2(code) {
         if (!processOk2(global.process)) {
           return;
         }
-        process19.exitCode = code || /* istanbul ignore next */
+        process13.exitCode = code || /* istanbul ignore next */
         0;
-        emit("exit", process19.exitCode, null);
-        emit("afterexit", process19.exitCode, null);
-        originalProcessReallyExit.call(process19, process19.exitCode);
+        emit("exit", process13.exitCode, null);
+        emit("afterexit", process13.exitCode, null);
+        originalProcessReallyExit.call(process13, process13.exitCode);
       };
-      originalProcessEmit = process19.emit;
+      originalProcessEmit = process13.emit;
       processEmit = function processEmit2(ev, arg) {
         if (ev === "exit" && processOk2(global.process)) {
           if (arg !== void 0) {
-            process19.exitCode = arg;
+            process13.exitCode = arg;
           }
           var ret = originalProcessEmit.apply(this, arguments);
-          emit("exit", process19.exitCode, null);
-          emit("afterexit", process19.exitCode, null);
+          emit("exit", process13.exitCode, null);
+          emit("afterexit", process13.exitCode, null);
           return ret;
         } else {
           return originalProcessEmit.apply(this, arguments);
@@ -62818,12 +63509,12 @@ var require_buffer_list = __commonJS({
       return (hint === "string" ? String : Number)(input);
     }
     var _require = require("buffer");
-    var Buffer3 = _require.Buffer;
+    var Buffer2 = _require.Buffer;
     var _require2 = require("util");
     var inspect = _require2.inspect;
     var custom2 = inspect && inspect.custom || "inspect";
     function copyBuffer(src, target, offset) {
-      Buffer3.prototype.copy.call(src, target, offset);
+      Buffer2.prototype.copy.call(src, target, offset);
     }
     module2.exports = /* @__PURE__ */ (function() {
       function BufferList() {
@@ -62883,8 +63574,8 @@ var require_buffer_list = __commonJS({
       }, {
         key: "concat",
         value: function concat(n) {
-          if (this.length === 0) return Buffer3.alloc(0);
-          var ret = Buffer3.allocUnsafe(n >>> 0);
+          if (this.length === 0) return Buffer2.alloc(0);
+          var ret = Buffer2.allocUnsafe(n >>> 0);
           var p = this.head;
           var i = 0;
           while (p) {
@@ -62948,7 +63639,7 @@ var require_buffer_list = __commonJS({
       }, {
         key: "_getBuffer",
         value: function _getBuffer(n) {
-          var ret = Buffer3.allocUnsafe(n);
+          var ret = Buffer2.allocUnsafe(n);
           var p = this.head;
           var c = 1;
           p.data.copy(ret);
@@ -63280,14 +63971,14 @@ var require_stream_writable = __commonJS({
       deprecate: require_node()
     };
     var Stream = require_stream();
-    var Buffer3 = require("buffer").Buffer;
+    var Buffer2 = require("buffer").Buffer;
     var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
     };
     function _uint8ArrayToBuffer(chunk) {
-      return Buffer3.from(chunk);
+      return Buffer2.from(chunk);
     }
     function _isUint8Array(obj) {
-      return Buffer3.isBuffer(obj) || obj instanceof OurUint8Array;
+      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
     }
     var destroyImpl = require_destroy();
     var _require = require_state();
@@ -63415,7 +64106,7 @@ var require_stream_writable = __commonJS({
       var state = this._writableState;
       var ret = false;
       var isBuf = !state.objectMode && _isUint8Array(chunk);
-      if (isBuf && !Buffer3.isBuffer(chunk)) {
+      if (isBuf && !Buffer2.isBuffer(chunk)) {
         chunk = _uint8ArrayToBuffer(chunk);
       }
       if (typeof encoding === "function") {
@@ -63459,7 +64150,7 @@ var require_stream_writable = __commonJS({
     });
     function decodeChunk(state, chunk, encoding) {
       if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
-        chunk = Buffer3.from(chunk, encoding);
+        chunk = Buffer2.from(chunk, encoding);
       }
       return chunk;
     }
@@ -63830,34 +64521,34 @@ var require_safe_buffer = __commonJS({
   "../../node_modules/safe-buffer/index.js"(exports2, module2) {
     "use strict";
     var buffer = require("buffer");
-    var Buffer3 = buffer.Buffer;
+    var Buffer2 = buffer.Buffer;
     function copyProps(src, dst) {
       for (var key in src) {
         dst[key] = src[key];
       }
     }
-    if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
+    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
       module2.exports = buffer;
     } else {
       copyProps(buffer, exports2);
       exports2.Buffer = SafeBuffer;
     }
     function SafeBuffer(arg, encodingOrOffset, length) {
-      return Buffer3(arg, encodingOrOffset, length);
+      return Buffer2(arg, encodingOrOffset, length);
     }
-    SafeBuffer.prototype = Object.create(Buffer3.prototype);
-    copyProps(Buffer3, SafeBuffer);
+    SafeBuffer.prototype = Object.create(Buffer2.prototype);
+    copyProps(Buffer2, SafeBuffer);
     SafeBuffer.from = function(arg, encodingOrOffset, length) {
       if (typeof arg === "number") {
         throw new TypeError("Argument must not be a number");
       }
-      return Buffer3(arg, encodingOrOffset, length);
+      return Buffer2(arg, encodingOrOffset, length);
     };
     SafeBuffer.alloc = function(size, fill, encoding) {
       if (typeof size !== "number") {
         throw new TypeError("Argument must be a number");
       }
-      var buf = Buffer3(size);
+      var buf = Buffer2(size);
       if (fill !== void 0) {
         if (typeof encoding === "string") {
           buf.fill(fill, encoding);
@@ -63873,7 +64564,7 @@ var require_safe_buffer = __commonJS({
       if (typeof size !== "number") {
         throw new TypeError("Argument must be a number");
       }
-      return Buffer3(size);
+      return Buffer2(size);
     };
     SafeBuffer.allocUnsafeSlow = function(size) {
       if (typeof size !== "number") {
@@ -63888,8 +64579,8 @@ var require_safe_buffer = __commonJS({
 var require_string_decoder = __commonJS({
   "../../node_modules/string_decoder/lib/string_decoder.js"(exports2) {
     "use strict";
-    var Buffer3 = require_safe_buffer().Buffer;
-    var isEncoding = Buffer3.isEncoding || function(encoding) {
+    var Buffer2 = require_safe_buffer().Buffer;
+    var isEncoding = Buffer2.isEncoding || function(encoding) {
       encoding = "" + encoding;
       switch (encoding && encoding.toLowerCase()) {
         case "hex":
@@ -63937,7 +64628,7 @@ var require_string_decoder = __commonJS({
     }
     function normalizeEncoding(enc) {
       var nenc = _normalizeEncoding(enc);
-      if (typeof nenc !== "string" && (Buffer3.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+      if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
       return nenc || enc;
     }
     exports2.StringDecoder = StringDecoder;
@@ -63966,7 +64657,7 @@ var require_string_decoder = __commonJS({
       }
       this.lastNeed = 0;
       this.lastTotal = 0;
-      this.lastChar = Buffer3.allocUnsafe(nb);
+      this.lastChar = Buffer2.allocUnsafe(nb);
     }
     StringDecoder.prototype.write = function(buf) {
       if (buf.length === 0) return "";
@@ -64527,14 +65218,14 @@ var require_stream_readable = __commonJS({
       return emitter.listeners(type).length;
     };
     var Stream = require_stream();
-    var Buffer3 = require("buffer").Buffer;
+    var Buffer2 = require("buffer").Buffer;
     var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
     };
     function _uint8ArrayToBuffer(chunk) {
-      return Buffer3.from(chunk);
+      return Buffer2.from(chunk);
     }
     function _isUint8Array(obj) {
-      return Buffer3.isBuffer(obj) || obj instanceof OurUint8Array;
+      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
     }
     var debugUtil = require("util");
     var debug;
@@ -64642,7 +65333,7 @@ var require_stream_readable = __commonJS({
         if (typeof chunk === "string") {
           encoding = encoding || state.defaultEncoding;
           if (encoding !== state.encoding) {
-            chunk = Buffer3.from(chunk, encoding);
+            chunk = Buffer2.from(chunk, encoding);
             encoding = "";
           }
           skipChunkCheck = true;
@@ -64667,7 +65358,7 @@ var require_stream_readable = __commonJS({
         if (er) {
           errorOrDestroy(stream, er);
         } else if (state.objectMode || chunk && chunk.length > 0) {
-          if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer3.prototype) {
+          if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
             chunk = _uint8ArrayToBuffer(chunk);
           }
           if (addToFront) {
@@ -65478,7 +66169,7 @@ var require_readable = __commonJS({
 var require_BufferList = __commonJS({
   "../../node_modules/bl/BufferList.js"(exports2, module2) {
     "use strict";
-    var { Buffer: Buffer3 } = require("buffer");
+    var { Buffer: Buffer2 } = require("buffer");
     var symbol2 = /* @__PURE__ */ Symbol.for("BufferList");
     function BufferList(buf) {
       if (!(this instanceof BufferList)) {
@@ -65542,10 +66233,10 @@ var require_BufferList = __commonJS({
         srcEnd = this.length;
       }
       if (srcStart >= this.length) {
-        return dst || Buffer3.alloc(0);
+        return dst || Buffer2.alloc(0);
       }
       if (srcEnd <= 0) {
-        return dst || Buffer3.alloc(0);
+        return dst || Buffer2.alloc(0);
       }
       const copy2 = !!dst;
       const off = this._offset(srcStart);
@@ -65555,7 +66246,7 @@ var require_BufferList = __commonJS({
       let start = off[1];
       if (srcStart === 0 && srcEnd === this.length) {
         if (!copy2) {
-          return this._bufs.length === 1 ? this._bufs[0] : Buffer3.concat(this._bufs, this.length);
+          return this._bufs.length === 1 ? this._bufs[0] : Buffer2.concat(this._bufs, this.length);
         }
         for (let i = 0; i < this._bufs.length; i++) {
           this._bufs[i].copy(dst, bufoff);
@@ -65567,7 +66258,7 @@ var require_BufferList = __commonJS({
         return copy2 ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes) : this._bufs[off[0]].slice(start, start + bytes);
       }
       if (!copy2) {
-        dst = Buffer3.allocUnsafe(len);
+        dst = Buffer2.allocUnsafe(len);
       }
       for (let i = off[0]; i < this._bufs.length; i++) {
         const l = this._bufs[i].length - start;
@@ -65643,7 +66334,7 @@ var require_BufferList = __commonJS({
         return this;
       }
       if (buf.buffer) {
-        this._appendBuffer(Buffer3.from(buf.buffer, buf.byteOffset, buf.byteLength));
+        this._appendBuffer(Buffer2.from(buf.buffer, buf.byteOffset, buf.byteLength));
       } else if (Array.isArray(buf)) {
         for (let i = 0; i < buf.length; i++) {
           this.append(buf[i]);
@@ -65656,7 +66347,7 @@ var require_BufferList = __commonJS({
         if (typeof buf === "number") {
           buf = buf.toString();
         }
-        this._appendBuffer(Buffer3.from(buf));
+        this._appendBuffer(Buffer2.from(buf));
       }
       return this;
     };
@@ -65672,15 +66363,15 @@ var require_BufferList = __commonJS({
       if (typeof search === "function" || Array.isArray(search)) {
         throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.');
       } else if (typeof search === "number") {
-        search = Buffer3.from([search]);
+        search = Buffer2.from([search]);
       } else if (typeof search === "string") {
-        search = Buffer3.from(search, encoding);
+        search = Buffer2.from(search, encoding);
       } else if (this._isBufferList(search)) {
         search = search.slice();
       } else if (Array.isArray(search.buffer)) {
-        search = Buffer3.from(search.buffer, search.byteOffset, search.byteLength);
-      } else if (!Buffer3.isBuffer(search)) {
-        search = Buffer3.from(search);
+        search = Buffer2.from(search.buffer, search.byteOffset, search.byteLength);
+      } else if (!Buffer2.isBuffer(search)) {
+        search = Buffer2.from(search);
       }
       offset = Number(offset || 0);
       if (isNaN(offset)) {
@@ -72996,10 +73687,10 @@ var require_lib = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve18, reject) => {
       let fd;
-      const fs27 = (0, node_1.default)();
+      const fs22 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs27.closeSync(fd);
+          fs22.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -73011,9 +73702,9 @@ var require_lib = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs27.openSync(filepath, "r");
+        fd = fs22.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs27.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs22.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -73025,22 +73716,22 @@ var require_lib = __commonJS({
         });
         return;
       }
-      fs27.readFile(filepath, handler);
+      fs22.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs27 = (0, node_1.default)();
+      const fs22 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs27.openSync(filepath, "r");
+        const fd = fs22.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs27.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs22.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs27.closeSync(fd);
+        fs22.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs27.readFileSync(filepath));
+      return (0, exports2.detect)(fs22.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -73057,7 +73748,7 @@ var require_safer = __commonJS({
   "../../node_modules/safer-buffer/safer.js"(exports2, module2) {
     "use strict";
     var buffer = require("buffer");
-    var Buffer3 = buffer.Buffer;
+    var Buffer2 = buffer.Buffer;
     var safer = {};
     var key;
     for (key in buffer) {
@@ -73066,12 +73757,12 @@ var require_safer = __commonJS({
       safer[key] = buffer[key];
     }
     var Safer = safer.Buffer = {};
-    for (key in Buffer3) {
-      if (!Buffer3.hasOwnProperty(key)) continue;
+    for (key in Buffer2) {
+      if (!Buffer2.hasOwnProperty(key)) continue;
       if (key === "allocUnsafe" || key === "allocUnsafeSlow") continue;
-      Safer[key] = Buffer3[key];
+      Safer[key] = Buffer2[key];
     }
-    safer.Buffer.prototype = Buffer3.prototype;
+    safer.Buffer.prototype = Buffer2.prototype;
     if (!Safer.from || Safer.from === Uint8Array.from) {
       Safer.from = function(value, encodingOrOffset, length) {
         if (typeof value === "number") {
@@ -73080,7 +73771,7 @@ var require_safer = __commonJS({
         if (value && typeof value.length === "undefined") {
           throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
         }
-        return Buffer3(value, encodingOrOffset, length);
+        return Buffer2(value, encodingOrOffset, length);
       };
     }
     if (!Safer.alloc) {
@@ -73091,7 +73782,7 @@ var require_safer = __commonJS({
         if (size < 0 || size >= 2 * (1 << 30)) {
           throw new RangeError('The value "' + size + '" is invalid for option "size"');
         }
-        var buf = Buffer3(size);
+        var buf = Buffer2(size);
         if (!fill || fill.length === 0) {
           buf.fill(0);
         } else if (typeof encoding === "string") {
@@ -73186,7 +73877,7 @@ var require_merge_exports = __commonJS({
 var require_internal = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/encodings/internal.js"(exports2, module2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     module2.exports = {
       // Encodings
       utf8: { type: "_internal", bomAware: true },
@@ -73210,7 +73901,7 @@ var require_internal = __commonJS({
       } else if (this.enc === "cesu8") {
         this.enc = "utf8";
         this.encoder = InternalEncoderCesu8;
-        if (Buffer3.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") {
+        if (Buffer2.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") {
           this.decoder = InternalDecoderCesu8;
           this.defaultCharUnicode = iconv2.defaultCharUnicode;
         }
@@ -73223,8 +73914,8 @@ var require_internal = __commonJS({
       this.decoder = new StringDecoder(codec2.enc);
     }
     InternalDecoder.prototype.write = function(buf) {
-      if (!Buffer3.isBuffer(buf)) {
-        buf = Buffer3.from(buf);
+      if (!Buffer2.isBuffer(buf)) {
+        buf = Buffer2.from(buf);
       }
       return this.decoder.write(buf);
     };
@@ -73235,7 +73926,7 @@ var require_internal = __commonJS({
       this.enc = codec2.enc;
     }
     InternalEncoder.prototype.write = function(str) {
-      return Buffer3.from(str, this.enc);
+      return Buffer2.from(str, this.enc);
     };
     InternalEncoder.prototype.end = function() {
     };
@@ -73247,15 +73938,15 @@ var require_internal = __commonJS({
       var completeQuads = str.length - str.length % 4;
       this.prevStr = str.slice(completeQuads);
       str = str.slice(0, completeQuads);
-      return Buffer3.from(str, "base64");
+      return Buffer2.from(str, "base64");
     };
     InternalEncoderBase64.prototype.end = function() {
-      return Buffer3.from(this.prevStr, "base64");
+      return Buffer2.from(this.prevStr, "base64");
     };
     function InternalEncoderCesu8(options, codec2) {
     }
     InternalEncoderCesu8.prototype.write = function(str) {
-      var buf = Buffer3.alloc(str.length * 3);
+      var buf = Buffer2.alloc(str.length * 3);
       var bufIdx = 0;
       for (var i = 0; i < str.length; i++) {
         var charCode = str.charCodeAt(i);
@@ -73351,13 +74042,13 @@ var require_internal = __commonJS({
           str = str.slice(0, str.length - 1);
         }
       }
-      return Buffer3.from(str, this.enc);
+      return Buffer2.from(str, this.enc);
     };
     InternalEncoderUtf8.prototype.end = function() {
       if (this.highSurrogate) {
         var str = this.highSurrogate;
         this.highSurrogate = "";
-        return Buffer3.from(str, this.enc);
+        return Buffer2.from(str, this.enc);
       }
     };
   }
@@ -73367,7 +74058,7 @@ var require_internal = __commonJS({
 var require_utf32 = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/encodings/utf32.js"(exports2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     exports2._utf32 = Utf32Codec;
     function Utf32Codec(codecOptions, iconv2) {
       this.iconv = iconv2;
@@ -73385,8 +74076,8 @@ var require_utf32 = __commonJS({
       this.highSurrogate = 0;
     }
     Utf32Encoder.prototype.write = function(str) {
-      var src = Buffer3.from(str, "ucs2");
-      var dst = Buffer3.alloc(src.length * 2);
+      var src = Buffer2.from(str, "ucs2");
+      var dst = Buffer2.alloc(src.length * 2);
       var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
       var offset = 0;
       for (var i = 0; i < src.length; i += 2) {
@@ -73422,7 +74113,7 @@ var require_utf32 = __commonJS({
       if (!this.highSurrogate) {
         return;
       }
-      var buf = Buffer3.alloc(4);
+      var buf = Buffer2.alloc(4);
       if (this.isLE) {
         buf.writeUInt32LE(this.highSurrogate, 0);
       } else {
@@ -73442,7 +74133,7 @@ var require_utf32 = __commonJS({
       }
       var i = 0;
       var codepoint = 0;
-      var dst = Buffer3.alloc(src.length + 4);
+      var dst = Buffer2.alloc(src.length + 4);
       var offset = 0;
       var isLE = this.isLE;
       var overflow = this.overflow;
@@ -73598,7 +74289,7 @@ var require_utf32 = __commonJS({
 var require_utf16 = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/encodings/utf16.js"(exports2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     exports2.utf16be = Utf16BECodec;
     function Utf16BECodec() {
     }
@@ -73608,7 +74299,7 @@ var require_utf16 = __commonJS({
     function Utf16BEEncoder() {
     }
     Utf16BEEncoder.prototype.write = function(str) {
-      var buf = Buffer3.from(str, "ucs2");
+      var buf = Buffer2.from(str, "ucs2");
       for (var i = 0; i < buf.length; i += 2) {
         var tmp = buf[i];
         buf[i] = buf[i + 1];
@@ -73625,7 +74316,7 @@ var require_utf16 = __commonJS({
       if (buf.length == 0) {
         return "";
       }
-      var buf2 = Buffer3.alloc(buf.length + 1);
+      var buf2 = Buffer2.alloc(buf.length + 1);
       var i = 0;
       var j = 0;
       if (this.overflowByte !== -1) {
@@ -73741,7 +74432,7 @@ var require_utf16 = __commonJS({
 var require_utf7 = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/encodings/utf7.js"(exports2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     exports2.utf7 = Utf7Codec;
     exports2.unicode11utf7 = "utf7";
     function Utf7Codec(codecOptions, iconv2) {
@@ -73755,7 +74446,7 @@ var require_utf7 = __commonJS({
       this.iconv = codec2.iconv;
     }
     Utf7Encoder.prototype.write = function(str) {
-      return Buffer3.from(str.replace(nonDirectChars, function(chunk) {
+      return Buffer2.from(str.replace(nonDirectChars, function(chunk) {
         return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-";
       }.bind(this)));
     };
@@ -73793,7 +74484,7 @@ var require_utf7 = __commonJS({
               res += "+";
             } else {
               var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii");
-              res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
+              res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be");
             }
             if (buf[i2] != minusChar) {
               i2--;
@@ -73811,7 +74502,7 @@ var require_utf7 = __commonJS({
         var canBeDecoded = b64str.length - b64str.length % 8;
         base64Accum = b64str.slice(canBeDecoded);
         b64str = b64str.slice(0, canBeDecoded);
-        res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
+        res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be");
       }
       this.inBase64 = inBase64;
       this.base64Accum = base64Accum;
@@ -73820,7 +74511,7 @@ var require_utf7 = __commonJS({
     Utf7Decoder.prototype.end = function() {
       var res = "";
       if (this.inBase64 && this.base64Accum.length > 0) {
-        res = this.iconv.decode(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
+        res = this.iconv.decode(Buffer2.from(this.base64Accum, "base64"), "utf16-be");
       }
       this.inBase64 = false;
       this.base64Accum = "";
@@ -73836,14 +74527,14 @@ var require_utf7 = __commonJS({
     function Utf7IMAPEncoder(options, codec2) {
       this.iconv = codec2.iconv;
       this.inBase64 = false;
-      this.base64Accum = Buffer3.alloc(6);
+      this.base64Accum = Buffer2.alloc(6);
       this.base64AccumIdx = 0;
     }
     Utf7IMAPEncoder.prototype.write = function(str) {
       var inBase64 = this.inBase64;
       var base64Accum = this.base64Accum;
       var base64AccumIdx = this.base64AccumIdx;
-      var buf = Buffer3.alloc(str.length * 5 + 10);
+      var buf = Buffer2.alloc(str.length * 5 + 10);
       var bufIdx = 0;
       for (var i2 = 0; i2 < str.length; i2++) {
         var uChar = str.charCodeAt(i2);
@@ -73882,7 +74573,7 @@ var require_utf7 = __commonJS({
       return buf.slice(0, bufIdx);
     };
     Utf7IMAPEncoder.prototype.end = function() {
-      var buf = Buffer3.alloc(10);
+      var buf = Buffer2.alloc(10);
       var bufIdx = 0;
       if (this.inBase64) {
         if (this.base64AccumIdx > 0) {
@@ -73919,7 +74610,7 @@ var require_utf7 = __commonJS({
               res += "&";
             } else {
               var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii").replace(/,/g, "/");
-              res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
+              res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be");
             }
             if (buf[i2] != minusChar) {
               i2--;
@@ -73937,7 +74628,7 @@ var require_utf7 = __commonJS({
         var canBeDecoded = b64str.length - b64str.length % 8;
         base64Accum = b64str.slice(canBeDecoded);
         b64str = b64str.slice(0, canBeDecoded);
-        res += this.iconv.decode(Buffer3.from(b64str, "base64"), "utf16-be");
+        res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be");
       }
       this.inBase64 = inBase64;
       this.base64Accum = base64Accum;
@@ -73946,7 +74637,7 @@ var require_utf7 = __commonJS({
     Utf7IMAPDecoder.prototype.end = function() {
       var res = "";
       if (this.inBase64 && this.base64Accum.length > 0) {
-        res = this.iconv.decode(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
+        res = this.iconv.decode(Buffer2.from(this.base64Accum, "base64"), "utf16-be");
       }
       this.inBase64 = false;
       this.base64Accum = "";
@@ -73959,7 +74650,7 @@ var require_utf7 = __commonJS({
 var require_sbcs_codec = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/encodings/sbcs-codec.js"(exports2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     exports2._sbcs = SBCSCodec;
     function SBCSCodec(codecOptions, iconv2) {
       if (!codecOptions) {
@@ -73975,8 +74666,8 @@ var require_sbcs_codec = __commonJS({
         }
         codecOptions.chars = asciiString + codecOptions.chars;
       }
-      this.decodeBuf = Buffer3.from(codecOptions.chars, "ucs2");
-      var encodeBuf = Buffer3.alloc(65536, iconv2.defaultCharSingleByte.charCodeAt(0));
+      this.decodeBuf = Buffer2.from(codecOptions.chars, "ucs2");
+      var encodeBuf = Buffer2.alloc(65536, iconv2.defaultCharSingleByte.charCodeAt(0));
       for (var i = 0; i < codecOptions.chars.length; i++) {
         encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
       }
@@ -73988,7 +74679,7 @@ var require_sbcs_codec = __commonJS({
       this.encodeBuf = codec2.encodeBuf;
     }
     SBCSEncoder.prototype.write = function(str) {
-      var buf = Buffer3.alloc(str.length);
+      var buf = Buffer2.alloc(str.length);
       for (var i = 0; i < str.length; i++) {
         buf[i] = this.encodeBuf[str.charCodeAt(i)];
       }
@@ -74001,7 +74692,7 @@ var require_sbcs_codec = __commonJS({
     }
     SBCSDecoder.prototype.write = function(buf) {
       var decodeBuf = this.decodeBuf;
-      var newBuf = Buffer3.alloc(buf.length * 2);
+      var newBuf = Buffer2.alloc(buf.length * 2);
       var idx1 = 0;
       var idx2 = 0;
       for (var i = 0; i < buf.length; i++) {
@@ -74629,7 +75320,7 @@ var require_sbcs_data_generated = __commonJS({
 var require_dbcs_codec = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/encodings/dbcs-codec.js"(exports2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     exports2._dbcs = DBCSCodec;
     var UNASSIGNED = -1;
     var GB18030_CODE = -2;
@@ -74865,7 +75556,7 @@ var require_dbcs_codec = __commonJS({
       this.gb18030 = codec2.gb18030;
     }
     DBCSEncoder.prototype.write = function(str) {
-      var newBuf = Buffer3.alloc(str.length * (this.gb18030 ? 4 : 3));
+      var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3));
       var leadSurrogate = this.leadSurrogate;
       var seqObj = this.seqObj;
       var nextChar = -1;
@@ -74969,7 +75660,7 @@ var require_dbcs_codec = __commonJS({
       if (this.leadSurrogate === -1 && this.seqObj === void 0) {
         return;
       }
-      var newBuf = Buffer3.alloc(10);
+      var newBuf = Buffer2.alloc(10);
       var j = 0;
       if (this.seqObj) {
         var dbcsCode = this.seqObj[DEF_CHAR];
@@ -75000,7 +75691,7 @@ var require_dbcs_codec = __commonJS({
       this.gb18030 = codec2.gb18030;
     }
     DBCSDecoder.prototype.write = function(buf) {
-      var newBuf = Buffer3.alloc(buf.length * 2);
+      var newBuf = Buffer2.alloc(buf.length * 2);
       var nodeIdx = this.nodeIdx;
       var prevBytes = this.prevBytes;
       var prevOffset = this.prevBytes.length;
@@ -76609,7 +77300,7 @@ var require_encodings = __commonJS({
 var require_streams = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/lib/streams.js"(exports2, module2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     module2.exports = function(streamModule) {
       var Transform = streamModule.Transform;
       function IconvLiteEncoderStream(conv, options) {
@@ -76649,7 +77340,7 @@ var require_streams = __commonJS({
           chunks.push(chunk);
         });
         this.on("end", function() {
-          cb(null, Buffer3.concat(chunks));
+          cb(null, Buffer2.concat(chunks));
         });
         return this;
       };
@@ -76663,7 +77354,7 @@ var require_streams = __commonJS({
         constructor: { value: IconvLiteDecoderStream }
       });
       IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
-        if (!Buffer3.isBuffer(chunk) && !(chunk instanceof Uint8Array)) {
+        if (!Buffer2.isBuffer(chunk) && !(chunk instanceof Uint8Array)) {
           return done(new Error("Iconv decoding stream needs buffers as its input."));
         }
         try {
@@ -76706,7 +77397,7 @@ var require_streams = __commonJS({
 var require_lib2 = __commonJS({
   "../../node_modules/@inquirer/external-editor/node_modules/iconv-lite/lib/index.js"(exports2, module2) {
     "use strict";
-    var Buffer3 = require_safer().Buffer;
+    var Buffer2 = require_safer().Buffer;
     var bomHandling = require_bom_handling();
     var mergeModules = require_merge_exports();
     module2.exports.encodings = null;
@@ -76717,7 +77408,7 @@ var require_lib2 = __commonJS({
       var encoder = module2.exports.getEncoder(encoding, options);
       var res = encoder.write(str);
       var trail = encoder.end();
-      return trail && trail.length > 0 ? Buffer3.concat([res, trail]) : res;
+      return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res;
     };
     module2.exports.decode = function decode3(buf, encoding, options) {
       if (typeof buf === "string") {
@@ -76725,7 +77416,7 @@ var require_lib2 = __commonJS({
           console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
           module2.exports.skipDecodeWarning = true;
         }
-        buf = Buffer3.from("" + (buf || ""), "binary");
+        buf = Buffer2.from("" + (buf || ""), "binary");
       }
       var decoder = module2.exports.getDecoder(encoding, options);
       var res = decoder.write(buf);
@@ -77445,9 +78136,9 @@ var init_prompt = __esm({
     init_utils();
     init_baseUI();
     _ = {
-      set: (obj, path36 = "", value) => {
+      set: (obj, path35 = "", value) => {
         let pointer = obj;
-        path36.split(".").forEach((key, index, arr) => {
+        path35.split(".").forEach((key, index, arr) => {
           if (key === "__proto__" || key === "constructor") return;
           if (index === arr.length - 1) {
             pointer[key] = value;
@@ -77457,8 +78148,8 @@ var init_prompt = __esm({
           pointer = pointer[key];
         });
       },
-      get: (obj, path36 = "", defaultValue) => {
-        const travel = (regexp) => String.prototype.split.call(path36, regexp).filter(Boolean).reduce(
+      get: (obj, path35 = "", defaultValue) => {
+        const travel = (regexp) => String.prototype.split.call(path35, regexp).filter(Boolean).reduce(
           // @ts-expect-error implicit any on res[key]
           (res, key) => res !== null && res !== void 0 ? res[key] : res,
           obj
@@ -77774,7 +78465,7 @@ var init_mjs = __esm({
   "../../node_modules/signal-exit/dist/mjs/index.js"() {
     "use strict";
     init_signals();
-    processOk = (process19) => !!process19 && typeof process19 === "object" && typeof process19.removeListener === "function" && typeof process19.emit === "function" && typeof process19.reallyExit === "function" && typeof process19.listeners === "function" && typeof process19.kill === "function" && typeof process19.pid === "number" && typeof process19.on === "function";
+    processOk = (process13) => !!process13 && typeof process13 === "object" && typeof process13.removeListener === "function" && typeof process13.emit === "function" && typeof process13.reallyExit === "function" && typeof process13.listeners === "function" && typeof process13.kill === "function" && typeof process13.pid === "number" && typeof process13.on === "function";
     kExitEmitter = /* @__PURE__ */ Symbol.for("signal-exit emitter");
     global2 = globalThis;
     ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -77867,15 +78558,15 @@ var init_mjs = __esm({
       #originalProcessReallyExit;
       #sigListeners = {};
       #loaded = false;
-      constructor(process19) {
+      constructor(process13) {
         super();
-        this.#process = process19;
+        this.#process = process13;
         this.#sigListeners = {};
         for (const sig of signals) {
           this.#sigListeners[sig] = () => {
             const listeners = this.#process.listeners(sig);
             let { count } = this.#emitter;
-            const p = process19;
+            const p = process13;
             if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
               count += p.__signal_exit_emitter__.count;
             }
@@ -77884,12 +78575,12 @@ var init_mjs = __esm({
               const ret = this.#emitter.emit("exit", null, sig);
               const s = sig === "SIGHUP" ? this.#hupSig : sig;
               if (!ret)
-                process19.kill(process19.pid, s);
+                process13.kill(process13.pid, s);
             }
           };
         }
-        this.#originalProcessReallyExit = process19.reallyExit;
-        this.#originalProcessEmit = process19.emit;
+        this.#originalProcessReallyExit = process13.reallyExit;
+        this.#originalProcessEmit = process13.emit;
       }
       onExit(cb, opts) {
         if (!processOk(this.#process)) {
@@ -78734,585 +79425,6 @@ var init_ora = __esm({
   }
 });
 
-// ../../node_modules/is-docker/index.js
-function hasDockerEnv() {
-  try {
-    import_node_fs3.default.statSync("/.dockerenv");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hasDockerCGroup() {
-  try {
-    return import_node_fs3.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_fs3, isDockerCached;
-var init_is_docker = __esm({
-  "../../node_modules/is-docker/index.js"() {
-    "use strict";
-    import_node_fs3 = __toESM(require("fs"), 1);
-  }
-});
-
-// ../../node_modules/is-inside-container/index.js
-function isInsideContainer() {
-  if (cachedResult === void 0) {
-    cachedResult = hasContainerEnv() || isDocker();
-  }
-  return cachedResult;
-}
-var import_node_fs4, cachedResult, hasContainerEnv;
-var init_is_inside_container = __esm({
-  "../../node_modules/is-inside-container/index.js"() {
-    "use strict";
-    import_node_fs4 = __toESM(require("fs"), 1);
-    init_is_docker();
-    hasContainerEnv = () => {
-      try {
-        import_node_fs4.default.statSync("/run/.containerenv");
-        return true;
-      } catch {
-        return false;
-      }
-    };
-  }
-});
-
-// ../../node_modules/is-wsl/index.js
-var import_node_process10, import_node_os5, import_node_fs5, isWsl, is_wsl_default;
-var init_is_wsl = __esm({
-  "../../node_modules/is-wsl/index.js"() {
-    "use strict";
-    import_node_process10 = __toESM(require("process"), 1);
-    import_node_os5 = __toESM(require("os"), 1);
-    import_node_fs5 = __toESM(require("fs"), 1);
-    init_is_inside_container();
-    isWsl = () => {
-      if (import_node_process10.default.platform !== "linux") {
-        return false;
-      }
-      if (import_node_os5.default.release().toLowerCase().includes("microsoft")) {
-        if (isInsideContainer()) {
-          return false;
-        }
-        return true;
-      }
-      try {
-        if (import_node_fs5.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
-          return !isInsideContainer();
-        }
-      } catch {
-      }
-      if (import_node_fs5.default.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || import_node_fs5.default.existsSync("/run/WSL")) {
-        return !isInsideContainer();
-      }
-      return false;
-    };
-    is_wsl_default = import_node_process10.default.env.__IS_WSL_TEST__ ? isWsl : isWsl();
-  }
-});
-
-// ../../node_modules/wsl-utils/index.js
-var import_node_process11, import_promises4, wslDrivesMountPoint, powerShellPathFromWsl, powerShellPath;
-var init_wsl_utils = __esm({
-  "../../node_modules/wsl-utils/index.js"() {
-    "use strict";
-    import_node_process11 = __toESM(require("process"), 1);
-    import_promises4 = __toESM(require("fs/promises"), 1);
-    init_is_wsl();
-    init_is_wsl();
-    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_promises4.default.access(configFilePath, import_promises4.constants.F_OK);
-          isConfigFileExists = true;
-        } catch {
-        }
-        if (!isConfigFileExists) {
-          return defaultMountPoint;
-        }
-        const configContent = await import_promises4.default.readFile(configFilePath, { encoding: "utf8" });
-        const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
-        if (!configMountPoint) {
-          return defaultMountPoint;
-        }
-        mountPoint = configMountPoint.groups.mountPoint.trim();
-        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
-        return mountPoint;
-      };
-    })();
-    powerShellPathFromWsl = async () => {
-      const mountPoint = await wslDrivesMountPoint();
-      return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
-    };
-    powerShellPath = async () => {
-      if (is_wsl_default) {
-        return powerShellPathFromWsl();
-      }
-      return `${import_node_process11.default.env.SYSTEMROOT || import_node_process11.default.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
-    };
-  }
-});
-
-// ../../node_modules/define-lazy-prop/index.js
-function defineLazyProperty(object2, propertyName, valueGetter) {
-  const define = (value) => Object.defineProperty(object2, propertyName, { value, enumerable: true, writable: true });
-  Object.defineProperty(object2, propertyName, {
-    configurable: true,
-    enumerable: true,
-    get() {
-      const result = valueGetter();
-      define(result);
-      return result;
-    },
-    set(value) {
-      define(value);
-    }
-  });
-  return object2;
-}
-var init_define_lazy_prop = __esm({
-  "../../node_modules/define-lazy-prop/index.js"() {
-    "use strict";
-  }
-});
-
-// ../../node_modules/default-browser-id/index.js
-async function defaultBrowserId() {
-  if (import_node_process12.default.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const { stdout } = await execFileAsync("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_util, import_node_process12, import_node_child_process, execFileAsync;
-var init_default_browser_id = __esm({
-  "../../node_modules/default-browser-id/index.js"() {
-    "use strict";
-    import_node_util = require("util");
-    import_node_process12 = __toESM(require("process"), 1);
-    import_node_child_process = require("child_process");
-    execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
-  }
-});
-
-// ../../node_modules/run-applescript/index.js
-async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-  if (import_node_process13.default.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const outputArguments = humanReadableOutput ? [] : ["-ss"];
-  const execOptions = {};
-  if (signal) {
-    execOptions.signal = signal;
-  }
-  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
-  return stdout.trim();
-}
-var import_node_process13, import_node_util2, import_node_child_process2, execFileAsync2;
-var init_run_applescript = __esm({
-  "../../node_modules/run-applescript/index.js"() {
-    "use strict";
-    import_node_process13 = __toESM(require("process"), 1);
-    import_node_util2 = require("util");
-    import_node_child_process2 = require("child_process");
-    execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
-  }
-});
-
-// ../../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/bundle-name/index.js"() {
-    "use strict";
-    init_run_applescript();
-  }
-});
-
-// ../../node_modules/default-browser/windows.js
-async function defaultBrowser(_execFileAsync = execFileAsync3) {
-  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_util3, import_node_child_process3, execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
-var init_windows = __esm({
-  "../../node_modules/default-browser/windows.js"() {
-    "use strict";
-    import_node_util3 = require("util");
-    import_node_child_process3 = require("child_process");
-    execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.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/default-browser/index.js
-async function defaultBrowser2() {
-  if (import_node_process14.default.platform === "darwin") {
-    const id = await defaultBrowserId();
-    const name = await bundleName(id);
-    return { name, id };
-  }
-  if (import_node_process14.default.platform === "linux") {
-    const { stdout } = await execFileAsync4("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_process14.default.platform === "win32") {
-    return defaultBrowser();
-  }
-  throw new Error("Only macOS, Linux, and Windows are supported");
-}
-var import_node_util4, import_node_process14, import_node_child_process4, execFileAsync4, titleize;
-var init_default_browser = __esm({
-  "../../node_modules/default-browser/index.js"() {
-    "use strict";
-    import_node_util4 = require("util");
-    import_node_process14 = __toESM(require("process"), 1);
-    import_node_child_process4 = require("child_process");
-    init_default_browser_id();
-    init_bundle_name();
-    init_windows();
-    execFileAsync4 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
-    titleize = (string4) => string4.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
-  }
-});
-
-// ../../node_modules/open/index.js
-async function getWindowsDefaultBrowserFromWsl() {
-  const powershellPath = await powerShellPath();
-  const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-  const encodedCommand = import_node_buffer.Buffer.from(rawCommand, "utf16le").toString("base64");
-  const { stdout } = await execFile5(
-    powershellPath,
-    [
-      "-NoProfile",
-      "-NonInteractive",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-EncodedCommand",
-      encodedCommand
-    ],
-    { encoding: "utf8" }
-  );
-  const progId = stdout.trim();
-  const browserMap = {
-    ChromeHTML: "com.google.chrome",
-    BraveHTML: "com.brave.Browser",
-    MSEdgeHTM: "com.microsoft.edge",
-    FirefoxURL: "org.mozilla.firefox"
-  };
-  return browserMap[progId] ? { id: browserMap[progId] } : {};
-}
-function detectArchBinary(binary) {
-  if (typeof binary === "string" || Array.isArray(binary)) {
-    return binary;
-  }
-  const { [arch3]: archBinary } = binary;
-  if (!archBinary) {
-    throw new Error(`${arch3} is not supported`);
-  }
-  return archBinary;
-}
-function detectPlatformBinary({ [platform11]: platformBinary }, { wsl }) {
-  if (wsl && is_wsl_default) {
-    return detectArchBinary(wsl);
-  }
-  if (!platformBinary) {
-    throw new Error(`${platform11} is not supported`);
-  }
-  return detectArchBinary(platformBinary);
-}
-var import_node_process15, import_node_buffer, import_node_path3, import_node_url, import_node_util5, import_node_child_process5, import_promises5, import_meta, execFile5, __dirname2, localXdgOpenPath, platform11, arch3, pTryEach, baseOpen, open2, apps, open_default;
-var init_open = __esm({
-  "../../node_modules/open/index.js"() {
-    "use strict";
-    import_node_process15 = __toESM(require("process"), 1);
-    import_node_buffer = require("buffer");
-    import_node_path3 = __toESM(require("path"), 1);
-    import_node_url = require("url");
-    import_node_util5 = require("util");
-    import_node_child_process5 = __toESM(require("child_process"), 1);
-    import_promises5 = __toESM(require("fs/promises"), 1);
-    init_wsl_utils();
-    init_define_lazy_prop();
-    init_default_browser();
-    init_is_inside_container();
-    import_meta = {};
-    execFile5 = (0, import_node_util5.promisify)(import_node_child_process5.default.execFile);
-    __dirname2 = import_node_path3.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-    localXdgOpenPath = import_node_path3.default.join(__dirname2, "xdg-open");
-    ({ platform: platform11, arch: arch3 } = import_node_process15.default);
-    pTryEach = async (array2, mapper) => {
-      let latestError;
-      for (const item of array2) {
-        try {
-          return await mapper(item);
-        } catch (error48) {
-          latestError = error48;
-        }
-      }
-      throw latestError;
-    };
-    baseOpen = async (options) => {
-      options = {
-        wait: false,
-        background: false,
-        newInstance: false,
-        allowNonzeroExitCode: false,
-        ...options
-      };
-      if (Array.isArray(options.app)) {
-        return pTryEach(options.app, (singleApp) => baseOpen({
-          ...options,
-          app: singleApp
-        }));
-      }
-      let { name: app, arguments: appArguments = [] } = options.app ?? {};
-      appArguments = [...appArguments];
-      if (Array.isArray(app)) {
-        return pTryEach(app, (appName) => baseOpen({
-          ...options,
-          app: {
-            name: appName,
-            arguments: appArguments
-          }
-        }));
-      }
-      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"
-        };
-        const flags = {
-          chrome: "--incognito",
-          brave: "--incognito",
-          firefox: "--private-window",
-          edge: "--inPrivate"
-        };
-        const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser2();
-        if (browser.id in ids) {
-          const browserName = ids[browser.id];
-          if (app === "browserPrivate") {
-            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 = {};
-      if (platform11 === "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 (platform11 === "win32" || is_wsl_default && !isInsideContainer() && !app) {
-        command = await powerShellPath();
-        cliArguments.push(
-          "-NoProfile",
-          "-NonInteractive",
-          "-ExecutionPolicy",
-          "Bypass",
-          "-EncodedCommand"
-        );
-        if (!is_wsl_default) {
-          childProcessOptions.windowsVerbatimArguments = true;
-        }
-        const encodedArguments = ["Start"];
-        if (options.wait) {
-          encodedArguments.push("-Wait");
-        }
-        if (app) {
-          encodedArguments.push(`"\`"${app}\`""`);
-          if (options.target) {
-            appArguments.push(options.target);
-          }
-        } else if (options.target) {
-          encodedArguments.push(`"${options.target}"`);
-        }
-        if (appArguments.length > 0) {
-          appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
-          encodedArguments.push("-ArgumentList", appArguments.join(","));
-        }
-        options.target = import_node_buffer.Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
-      } else {
-        if (app) {
-          command = app;
-        } else {
-          const isBundled = !__dirname2 || __dirname2 === "/";
-          let exeLocalXdgOpen = false;
-          try {
-            await import_promises5.default.access(localXdgOpenPath, import_promises5.constants.X_OK);
-            exeLocalXdgOpen = true;
-          } catch {
-          }
-          const useSystemXdgOpen = import_node_process15.default.versions.electron ?? (platform11 === "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 (platform11 === "darwin" && appArguments.length > 0) {
-        cliArguments.push("--args", ...appArguments);
-      }
-      if (options.target) {
-        cliArguments.push(options.target);
-      }
-      const subprocess = import_node_child_process5.default.spawn(command, cliArguments, childProcessOptions);
-      if (options.wait) {
-        return new Promise((resolve18, reject) => {
-          subprocess.once("error", reject);
-          subprocess.once("close", (exitCode) => {
-            if (!options.allowNonzeroExitCode && exitCode > 0) {
-              reject(new Error(`Exited with code ${exitCode}`));
-              return;
-            }
-            resolve18(subprocess);
-          });
-        });
-      }
-      subprocess.unref();
-      return subprocess;
-    };
-    open2 = (target, options) => {
-      if (typeof target !== "string") {
-        throw new TypeError("Expected a `target`");
-      }
-      return baseOpen({
-        ...options,
-        target
-      });
-    };
-    apps = {};
-    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
-      darwin: "google chrome",
-      win32: "chrome",
-      linux: ["google-chrome", "google-chrome-stable", "chromium"]
-    }, {
-      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, "browser", () => "browser");
-    defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
-    open_default = open2;
-  }
-});
-
 // src/version.ts
 function resolvePackageVersion(options) {
   const injectedVersion = options?.injectedVersion || "unknown";
@@ -80540,12 +80652,12 @@ var init_peer_connection_manager = __esm({
 });
 
 // src/daemon-p2p/index.ts
-var fs20, path26, import_node_module2, esmRequire, DaemonP2PSender;
+var fs15, path25, import_node_module2, esmRequire, DaemonP2PSender;
 var init_daemon_p2p = __esm({
   "src/daemon-p2p/index.ts"() {
     "use strict";
-    fs20 = __toESM(require("fs"));
-    path26 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path25 = __toESM(require("path"));
     import_node_module2 = require("module");
     init_src();
     init_data_channel_router();
@@ -80619,22 +80731,22 @@ var init_daemon_p2p = __esm({
           log(`node-datachannel not found: ${e?.message}
 ${e?.stack || ""}`);
         }
-        const platform13 = process.platform;
-        const arch4 = process.arch;
-        const prebuildKey = `${platform13}-${arch4}`;
+        const platform12 = process.platform;
+        const arch3 = process.arch;
+        const prebuildKey = `${platform12}-${arch3}`;
         try {
           const candidates = [
-            path26.join(__dirname, "node_modules", "node-datachannel"),
-            path26.join(__dirname, "..", "node_modules", "node-datachannel"),
-            path26.join(__dirname, "..", "..", "node_modules", "node-datachannel")
+            path25.join(__dirname, "node_modules", "node-datachannel"),
+            path25.join(__dirname, "..", "node_modules", "node-datachannel"),
+            path25.join(__dirname, "..", "..", "node_modules", "node-datachannel")
           ];
           for (const candidate of candidates) {
-            const prebuildPath = path26.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
-            if (fs20.existsSync(prebuildPath)) {
-              const targetDir = path26.join(candidate, "build", "Release");
-              const targetPath = path26.join(targetDir, "node_datachannel.node");
-              fs20.mkdirSync(targetDir, { recursive: true });
-              fs20.copyFileSync(prebuildPath, targetPath);
+            const prebuildPath = path25.join(candidate, "prebuilds", prebuildKey, "node_datachannel.node");
+            if (fs15.existsSync(prebuildPath)) {
+              const targetDir = path25.join(candidate, "build", "Release");
+              const targetPath = path25.join(targetDir, "node_datachannel.node");
+              fs15.mkdirSync(targetDir, { recursive: true });
+              fs15.copyFileSync(prebuildPath, targetPath);
               try {
                 delete esmRequire.cache[esmRequire.resolve("node-datachannel")];
               } catch {
@@ -81001,27 +81113,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
     "use strict";
-    var fs27 = require("fs");
+    var fs22 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync20 = (path36) => {
-      const fd = fs27.openSync(path36, "r");
+    var readFileSync20 = (path35) => {
+      const fd = fs22.openSync(path35, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs27.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs27.close(fd, () => {
+      const bytesRead = fs22.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs22.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path36) => new Promise((resolve18, reject) => {
-      fs27.open(path36, "r", (err, fd) => {
+    var readFile = (path35) => new Promise((resolve18, reject) => {
+      fs22.open(path35, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs27.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
+          fs22.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
             resolve18(buffer.subarray(0, bytesRead));
-            fs27.close(fd, () => {
+            fs22.close(fd, () => {
             });
           });
         }
@@ -81077,7 +81189,7 @@ var require_elf = __commonJS({
 var require_detect_libc = __commonJS({
   "../../node_modules/detect-libc/lib/detect-libc.js"(exports2, module2) {
     "use strict";
-    var childProcess2 = require("child_process");
+    var childProcess = require("child_process");
     var { isLinux: isLinux2, getReport } = require_process();
     var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync20 } = require_filesystem();
     var { interpreterPath } = require_elf();
@@ -81089,7 +81201,7 @@ var require_detect_libc = __commonJS({
     var safeCommand = () => {
       if (!commandOut) {
         return new Promise((resolve18) => {
-          childProcess2.exec(command, (err, out) => {
+          childProcess.exec(command, (err, out) => {
             commandOut = err ? " " : out;
             resolve18(commandOut);
           });
@@ -81100,7 +81212,7 @@ var require_detect_libc = __commonJS({
     var safeCommandSync = () => {
       if (!commandOut) {
         try {
-          commandOut = childProcess2.execSync(command, { encoding: "utf8" });
+          commandOut = childProcess.execSync(command, { encoding: "utf8" });
         } catch (_err) {
           commandOut = " ";
         }
@@ -81133,11 +81245,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path36) => {
-      if (path36) {
-        if (path36.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path35) => {
+      if (path35) {
+        if (path35.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path36.includes("/ld-linux-")) {
+        } else if (path35.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -81184,8 +81296,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path36 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path36);
+        const path35 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path35);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -81197,8 +81309,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync20(SELF_PATH);
-        const path36 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path36);
+        const path35 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path35);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -82917,18 +83029,18 @@ var require_sharp = __commonJS({
       `@img/sharp-${runtimePlatform}/sharp.node`,
       "@img/sharp-wasm32/sharp.node"
     ];
-    var path36;
+    var path35;
     var sharp;
     var errors = [];
-    for (path36 of paths) {
+    for (path35 of paths) {
       try {
-        sharp = require(path36);
+        sharp = require(path35);
         break;
       } catch (err) {
         errors.push(err);
       }
     }
-    if (sharp && path36.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+    if (sharp && path35.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
       const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
       err.code = "Unsupported CPU";
       errors.push(err);
@@ -82937,7 +83049,7 @@ var require_sharp = __commonJS({
     if (sharp) {
       module2.exports = sharp;
     } else {
-      const [isLinux2, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os31) => runtimePlatform.startsWith(os31));
+      const [isLinux2, isMacOs, isWindows2] = ["linux", "darwin", "win32"].map((os30) => runtimePlatform.startsWith(os30));
       const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
       errors.forEach((err) => {
         if (err.code !== "MODULE_NOT_FOUND") {
@@ -82954,15 +83066,15 @@ var require_sharp = __commonJS({
           `    Requires ${expected}`
         );
       } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-        const [os31, cpu] = runtimePlatform.split("-");
-        const libc = os31.endsWith("musl") ? " --libc=musl" : "";
+        const [os30, cpu] = runtimePlatform.split("-");
+        const libc = os30.endsWith("musl") ? " --libc=musl" : "";
         help.push(
           "- Ensure optional dependencies can be installed:",
           "    npm install --include=optional sharp",
           "- Ensure your package manager supports multi-platform installation:",
           "    See https://sharp.pixelplumbing.com/install#cross-platform",
           "- Add platform-specific dependencies:",
-          `    npm install --os=${os31.replace("musl", "")}${libc} --cpu=${cpu} sharp`
+          `    npm install --os=${os30.replace("musl", "")}${libc} --cpu=${cpu} sharp`
         );
       } else {
         help.push(
@@ -85837,15 +85949,15 @@ var require_color = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path36 = [graph[toModel].parent, toModel];
+      const path35 = [graph[toModel].parent, toModel];
       let fn = conversions_default[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path36.unshift(graph[cur].parent);
+        path35.unshift(graph[cur].parent);
         fn = link(conversions_default[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path36;
+      fn.conversion = path35;
       return fn;
     }
     function route(fromModel) {
@@ -86462,7 +86574,7 @@ var require_channel = __commonJS({
 var require_output = __commonJS({
   "../../node_modules/sharp/lib/output.js"(exports2, module2) {
     "use strict";
-    var path36 = require("path");
+    var path35 = require("path");
     var is = require_is();
     var sharp = require_sharp();
     var formats = /* @__PURE__ */ new Map([
@@ -86493,9 +86605,9 @@ var require_output = __commonJS({
       let err;
       if (!is.string(fileOut)) {
         err = new Error("Missing output file path");
-      } else if (is.string(this.options.input.file) && path36.resolve(this.options.input.file) === path36.resolve(fileOut)) {
+      } else if (is.string(this.options.input.file) && path35.resolve(this.options.input.file) === path35.resolve(fileOut)) {
         err = new Error("Cannot use same file for input and output");
-      } else if (jp2Regex.test(path36.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+      } else if (jp2Regex.test(path35.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
         err = errJp2Save();
       }
       if (err) {
@@ -87769,21 +87881,21 @@ function quarantineLegacyStandaloneSessions(options) {
   if (shouldSkipForExplicitOverride(env3)) {
     return { movedCount: 0, skippedActiveCount: 0, backupDir: null };
   }
-  const homeDir = options.homeDir || os26.homedir();
+  const homeDir = options.homeDir || os25.homedir();
   const now = options.now || (() => /* @__PURE__ */ new Date());
   const isPidRunning = options.isPidRunning || defaultPidRunning;
-  const runtimesDir = path27.join(homeDir, ".adhdev", "session-host", options.appName, "runtimes");
-  if (!fs21.existsSync(runtimesDir)) {
+  const runtimesDir = path26.join(homeDir, ".adhdev", "session-host", options.appName, "runtimes");
+  if (!fs16.existsSync(runtimesDir)) {
     return { movedCount: 0, skippedActiveCount: 0, backupDir: null };
   }
-  const candidates = fs21.readdirSync(runtimesDir).filter((name) => name.endsWith(".json")).map((name) => path27.join(runtimesDir, name));
+  const candidates = fs16.readdirSync(runtimesDir).filter((name) => name.endsWith(".json")).map((name) => path26.join(runtimesDir, name));
   let movedCount = 0;
   let skippedActiveCount = 0;
   let backupDir = null;
   for (const sourcePath of candidates) {
     let parsed;
     try {
-      parsed = JSON.parse(fs21.readFileSync(sourcePath, "utf8"));
+      parsed = JSON.parse(fs16.readFileSync(sourcePath, "utf8"));
     } catch {
       continue;
     }
@@ -87794,26 +87906,26 @@ function quarantineLegacyStandaloneSessions(options) {
       continue;
     }
     if (!backupDir) {
-      backupDir = path27.join(
+      backupDir = path26.join(
         homeDir,
         ".adhdev",
         "session-host-backups",
         `legacy-standalone-${options.appName}-${formatTimestamp(now())}`
       );
-      fs21.mkdirSync(path27.join(backupDir, "runtimes"), { recursive: true });
+      fs16.mkdirSync(path26.join(backupDir, "runtimes"), { recursive: true });
     }
-    fs21.renameSync(sourcePath, path27.join(backupDir, "runtimes", path27.basename(sourcePath)));
+    fs16.renameSync(sourcePath, path26.join(backupDir, "runtimes", path26.basename(sourcePath)));
     movedCount += 1;
   }
   return { movedCount, skippedActiveCount, backupDir };
 }
-var fs21, os26, path27, LEGACY_STANDALONE_MANAGER_TAG;
+var fs16, os25, path26, LEGACY_STANDALONE_MANAGER_TAG;
 var init_session_host_hygiene = __esm({
   "src/session-host-hygiene.ts"() {
     "use strict";
-    fs21 = __toESM(require("fs"));
-    os26 = __toESM(require("os"));
-    path27 = __toESM(require("path"));
+    fs16 = __toESM(require("fs"));
+    os25 = __toESM(require("os"));
+    path26 = __toESM(require("path"));
     init_src();
     LEGACY_STANDALONE_MANAGER_TAG = "adhdev-standalone";
   }
@@ -87837,18 +87949,18 @@ function buildSessionHostEnv(baseEnv) {
 }
 function resolveSessionHostEntry() {
   const packagedCandidates = [
-    path28.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-    path28.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+    path27.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+    path27.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
   ];
   for (const candidate of packagedCandidates) {
-    if (fs22.existsSync(candidate)) {
+    if (fs17.existsSync(candidate)) {
       return candidate;
     }
   }
   return require.resolve("@adhdev/session-host-daemon");
 }
 function getSessionHostPidFile() {
-  return path28.join(os27.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
+  return path27.join(os26.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
 }
 function getSessionHostStatusPaths() {
   return {
@@ -87859,8 +87971,8 @@ function getSessionHostStatusPaths() {
 function getSessionHostPid() {
   try {
     const pidFile = getSessionHostPidFile();
-    if (!fs22.existsSync(pidFile)) return null;
-    const pid = Number.parseInt(fs22.readFileSync(pidFile, "utf8").trim(), 10);
+    if (!fs17.existsSync(pidFile)) return null;
+    const pid = Number.parseInt(fs17.readFileSync(pidFile, "utf8").trim(), 10);
     return Number.isFinite(pid) ? pid : null;
   } catch {
     return null;
@@ -87930,8 +88042,8 @@ function stopManagedSessionHostProcess() {
   let stopped = false;
   const pidFile = getSessionHostPidFile();
   try {
-    if (fs22.existsSync(pidFile)) {
-      const pid = Number.parseInt(fs22.readFileSync(pidFile, "utf8").trim(), 10);
+    if (fs17.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs17.readFileSync(pidFile, "utf8").trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid2(pid)) {
         stopped = killPid2(pid) || stopped;
       }
@@ -87939,7 +88051,7 @@ function stopManagedSessionHostProcess() {
   } catch {
   } finally {
     try {
-      fs22.unlinkSync(pidFile);
+      fs17.unlinkSync(pidFile);
     } catch {
     }
   }
@@ -87967,9 +88079,9 @@ async function ensureSessionHostReady2() {
   }
   const spawnHost = () => {
     const entry = resolveSessionHostEntry();
-    const logDir = path28.join(os27.homedir(), ".adhdev", "logs");
-    fs22.mkdirSync(logDir, { recursive: true });
-    const logFd = fs22.openSync(path28.join(logDir, "session-host.log"), "a");
+    const logDir = path27.join(os26.homedir(), ".adhdev", "logs");
+    fs17.mkdirSync(logDir, { recursive: true });
+    const logFd = fs17.openSync(path27.join(logDir, "session-host.log"), "a");
     const child = (0, import_child_process13.spawn)(process.execPath, [entry], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
@@ -87978,7 +88090,7 @@ async function ensureSessionHostReady2() {
     });
     child.unref();
     try {
-      fs22.closeSync(logFd);
+      fs17.closeSync(logFd);
     } catch {
     }
   };
@@ -88031,14 +88143,14 @@ async function probeSessionHostStatus() {
     };
   }
 }
-var import_child_process13, fs22, os27, path28, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
+var import_child_process13, fs17, os26, path27, SESSION_HOST_APP_NAME, SESSION_HOST_START_TIMEOUT_MS;
 var init_session_host = __esm({
   "src/session-host.ts"() {
     "use strict";
     import_child_process13 = require("child_process");
-    fs22 = __toESM(require("fs"));
-    os27 = __toESM(require("os"));
-    path28 = __toESM(require("path"));
+    fs17 = __toESM(require("fs"));
+    os26 = __toESM(require("os"));
+    path27 = __toESM(require("path"));
     init_src();
     init_dist();
     init_session_host_hygiene();
@@ -88266,29 +88378,29 @@ function resolveDaemonPort(ref = {}) {
   return Number.isFinite(ref.port) && Number(ref.port) > 0 ? Number(ref.port) : DEFAULT_DAEMON_PORT;
 }
 function getDaemonPidFile(ref = {}) {
-  const dir = path29.join(ref.homeDir || os28.homedir(), ".adhdev");
-  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
+  const dir = path28.join(ref.homeDir || os27.homedir(), ".adhdev");
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
   const port = resolveDaemonPort(ref);
-  return path29.join(dir, port === DEFAULT_DAEMON_PORT ? "daemon.pid" : `daemon-${port}.pid`);
+  return path28.join(dir, port === DEFAULT_DAEMON_PORT ? "daemon.pid" : `daemon-${port}.pid`);
 }
 function writeDaemonPid(pid, ref = {}) {
   const pidFile = getDaemonPidFile(ref);
   try {
-    fs23.writeFileSync(pidFile, String(pid), { encoding: "utf-8", flag: "wx" });
+    fs18.writeFileSync(pidFile, String(pid), { encoding: "utf-8", flag: "wx" });
   } catch {
-    fs23.writeFileSync(pidFile, String(pid), "utf-8");
+    fs18.writeFileSync(pidFile, String(pid), "utf-8");
   }
 }
 function removeDaemonPid(ref = {}) {
   try {
-    fs23.unlinkSync(getDaemonPidFile(ref));
+    fs18.unlinkSync(getDaemonPidFile(ref));
   } catch (e) {
   }
 }
 function isDaemonRunning(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync7 } = require("child_process");
+    const { execFileSync: execFileSync6 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -88298,7 +88410,7 @@ function isDaemonRunning(ref = {}) {
             req.on('error', () => process.stdout.write('0'));
             req.on('timeout', () => { req.destroy(); process.stdout.write('0'); });
         `;
-    const result = execFileSync7(process.execPath, ["-e", probe], {
+    const result = execFileSync6(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -88308,8 +88420,8 @@ function isDaemonRunning(ref = {}) {
   }
   const pidFile = getDaemonPidFile(ref);
   try {
-    if (!fs23.existsSync(pidFile)) return false;
-    const pid = parseInt(fs23.readFileSync(pidFile, "utf-8").trim());
+    if (!fs18.existsSync(pidFile)) return false;
+    const pid = parseInt(fs18.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, 0);
     if (!isAdhdevProcess(pid)) {
       removeDaemonPid(ref);
@@ -88324,9 +88436,9 @@ function isDaemonRunning(ref = {}) {
 function isAdhdevProcess(pid) {
   try {
     if (process.platform === "win32") {
-      const { execFileSync: execFileSync7 } = require("child_process");
+      const { execFileSync: execFileSync6 } = require("child_process");
       try {
-        const psOut = execFileSync7("powershell.exe", [
+        const psOut = execFileSync6("powershell.exe", [
           "-NoProfile",
           "-NonInteractive",
           "-ExecutionPolicy",
@@ -88339,8 +88451,8 @@ function isAdhdevProcess(pid) {
         return true;
       }
     } else {
-      const { execFileSync: execFileSync7 } = require("child_process");
-      const cmdline = execFileSync7("ps", ["-o", "command=", "-p", String(pid)], {
+      const { execFileSync: execFileSync6 } = require("child_process");
+      const cmdline = execFileSync6("ps", ["-o", "command=", "-p", String(pid)], {
         encoding: "utf-8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -88354,7 +88466,7 @@ function isAdhdevProcess(pid) {
 function getDaemonHealthPid(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync7 } = require("child_process");
+    const { execFileSync: execFileSync6 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -88372,7 +88484,7 @@ function getDaemonHealthPid(ref = {}) {
             req.on('error', () => {});
             req.on('timeout', () => { req.destroy(); });
         `;
-    const result = execFileSync7(process.execPath, ["-e", probe], {
+    const result = execFileSync6(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -88386,8 +88498,8 @@ function getDaemonHealthPid(ref = {}) {
 function getDaemonPid(ref = {}) {
   const pidFile = getDaemonPidFile(ref);
   try {
-    if (fs23.existsSync(pidFile)) {
-      const pid = parseInt(fs23.readFileSync(pidFile, "utf-8").trim(), 10);
+    if (fs18.existsSync(pidFile)) {
+      const pid = parseInt(fs18.readFileSync(pidFile, "utf-8").trim(), 10);
       if (Number.isFinite(pid)) return pid;
     }
   } catch {
@@ -88398,8 +88510,8 @@ function stopDaemon(ref = {}) {
   const pidFile = getDaemonPidFile(ref);
   let pid = null;
   try {
-    if (fs23.existsSync(pidFile)) {
-      const pidFromFile = parseInt(fs23.readFileSync(pidFile, "utf-8").trim(), 10);
+    if (fs18.existsSync(pidFile)) {
+      const pidFromFile = parseInt(fs18.readFileSync(pidFile, "utf-8").trim(), 10);
       if (Number.isFinite(pidFromFile)) pid = pidFromFile;
     }
   } catch {
@@ -88418,7 +88530,7 @@ function stopDaemon(ref = {}) {
     return false;
   }
 }
-var os28, fs23, path29, import_http, import_child_process14, import_ws3, pkgVersion, AdhdevDaemon;
+var os27, fs18, path28, import_http, import_child_process14, import_ws3, pkgVersion, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -88430,9 +88542,9 @@ var init_adhdev_daemon = __esm({
     init_startup_restore_policy();
     init_dist();
     init_session_host_controller();
-    os28 = __toESM(require("os"));
-    fs23 = __toESM(require("fs"));
-    path29 = __toESM(require("path"));
+    os27 = __toESM(require("os"));
+    fs18 = __toESM(require("fs"));
+    path28 = __toESM(require("path"));
     import_http = require("http");
     import_child_process14 = require("child_process");
     import_ws3 = require("ws");
@@ -88440,7 +88552,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.43" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.45" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -88964,8 +89076,8 @@ ${err?.stack || ""}`);
             cliInfo: {
               type: "adhdev-daemon",
               version: pkgVersion,
-              platform: os28.platform(),
-              hostname: os28.hostname(),
+              platform: os27.platform(),
+              hostname: os27.hostname(),
               machineId: config2.machineId,
               instanceId
             }
@@ -89564,6 +89676,10 @@ var wizard_exports = {};
 __export(wizard_exports, {
   runWizard: () => runWizard
 });
+async function openBrowser(url2) {
+  const mod = await import("open");
+  return mod.default(url2);
+}
 function hasCloudMachineAuth() {
   const config2 = loadConfig();
   return Boolean(config2.machineSecret && config2.machineSecret.trim());
@@ -89613,9 +89729,9 @@ async function runWizard(options = {}) {
 }
 async function checkForUpdate() {
   try {
-    const { execFileSync: execFileSync7 } = await import("child_process");
+    const { execFileSync: execFileSync6 } = await import("child_process");
     const currentVersion = resolvePackageVersion();
-    const latestVersion = readLatestPublishedCliVersion(execFileSync7);
+    const latestVersion = readLatestPublishedCliVersion(execFileSync6);
     if (!latestVersion) return;
     if (!currentVersion || !latestVersion || currentVersion === latestVersion) return;
     console.log(source_default.yellow(`  Update available: ${currentVersion} \u2192 ${latestVersion}`));
@@ -89632,7 +89748,7 @@ async function checkForUpdate() {
     const spinner = (await Promise.resolve().then(() => (init_ora(), ora_exports))).default("Updating adhdev CLI...").start();
     try {
       const installCommand = buildPinnedGlobalInstallCommand({ packageName: "adhdev", targetVersion: "latest" });
-      execFileSync7(installCommand.command, installCommand.args, {
+      execFileSync6(installCommand.command, installCommand.args, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -89716,15 +89832,15 @@ async function loginFlow() {
   let verificationUrl;
   try {
     const config2 = loadConfig();
-    const os31 = await import("os");
+    const os30 = await import("os");
     const res = await fetch(`${SERVER_URL}/auth/cli/init`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         clientMachineId: config2.machineId,
-        hostname: os31.hostname(),
-        platform: os31.platform(),
-        arch: os31.arch()
+        hostname: os30.hostname(),
+        platform: os30.platform(),
+        arch: os30.arch()
       })
     });
     if (!res.ok) {
@@ -89748,7 +89864,7 @@ async function loginFlow() {
   console.log(source_default.gray(`  Opening: ${verificationUrl}`));
   console.log();
   try {
-    await open_default(verificationUrl);
+    await openBrowser(verificationUrl);
     console.log(source_default.green("  \u2713 Browser opened \u2014 please sign in and approve"));
   } catch {
     console.log(source_default.yellow(`  \u26A0 Could not open browser. Visit: ${verificationUrl}`));
@@ -89829,10 +89945,10 @@ async function startDaemonFlow() {
     const { execSync: execSync8 } = await import("child_process");
     const { getCurrentDaemonLogPath: getCurrentDaemonLogPath2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const logPath = getCurrentDaemonLogPath2();
-    const os31 = await import("os");
-    const platform13 = os31.platform();
+    const os30 = await import("os");
+    const platform12 = os30.platform();
     try {
-      if (platform13 === "win32") {
+      if (platform12 === "win32") {
         execSync8("start /B adhdev daemon >NUL 2>&1", {
           timeout: 3e3,
           stdio: "ignore",
@@ -89945,7 +90061,6 @@ var init_wizard = __esm({
     init_source();
     init_lib();
     init_ora();
-    init_open();
     init_src();
     init_version();
     SERVER_URL = process.env.ADHDEV_SERVER_URL || "https://api.adhf.dev";
@@ -90978,7 +91093,7 @@ init_source();
 init_src();
 
 // src/cli/setup-commands.ts
-var import_node_path4 = __toESM(require("path"));
+var import_node_path3 = __toESM(require("path"));
 init_source();
 init_src();
 
@@ -91131,7 +91246,7 @@ function parsePositiveInteger(value, fallback2) {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback2;
 }
 function buildHistoryResumeLaunchPayload(cliType, session, overrideDir) {
-  const dir = typeof overrideDir === "string" && overrideDir.trim() ? import_node_path4.default.resolve(overrideDir.trim()) : typeof session.workspace === "string" && session.workspace.trim() ? import_node_path4.default.resolve(session.workspace.trim()) : "";
+  const dir = typeof overrideDir === "string" && overrideDir.trim() ? import_node_path3.default.resolve(overrideDir.trim()) : typeof session.workspace === "string" && session.workspace.trim() ? import_node_path3.default.resolve(session.workspace.trim()) : "";
   if (!dir) {
     throw new Error(`Saved history ${session.providerSessionId} is missing workspace metadata. Pass --dir to resume it explicitly.`);
   }
@@ -91251,7 +91366,7 @@ function registerSetupCommands(program2, getProviderLoader2) {
           console.log(source_default.gray("  Then run: adhdev launch " + targetArg));
           process.exit(1);
         }
-        const resolvedDir = import_node_path4.default.resolve(workingDir);
+        const resolvedDir = import_node_path3.default.resolve(workingDir);
         const result = await sendDaemonCommand("launch_cli", {
           cliType,
           dir: resolvedDir
@@ -91723,9 +91838,9 @@ function registerSetupCommands(program2, getProviderLoader2) {
   });
   program2.command("uninstall").description("Completely wipe all setting, configuration, stop daemon and uninstall service").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
     const inquirer2 = await Promise.resolve().then(() => (init_lib(), lib_exports));
-    const fs27 = await import("fs");
-    const path36 = await import("path");
-    const os31 = await import("os");
+    const fs22 = await import("fs");
+    const path35 = await import("path");
+    const os30 = await import("os");
     const { spawnSync: spawnSync3 } = await import("child_process");
     if (!options.force) {
       const { confirm } = await inquirer2.default.prompt([
@@ -91750,11 +91865,11 @@ function registerSetupCommands(program2, getProviderLoader2) {
     }
     console.log(source_default.gray("  Removing OS background service..."));
     spawnSync3(process.execPath, [process.argv[1], "service", "uninstall"], { stdio: "inherit" });
-    const adhdevDir = path36.join(os31.homedir(), ".adhdev");
-    if (fs27.existsSync(adhdevDir)) {
+    const adhdevDir = path35.join(os30.homedir(), ".adhdev");
+    if (fs22.existsSync(adhdevDir)) {
       console.log(source_default.gray(`  Deleting ${adhdevDir}...`));
       try {
-        fs27.rmSync(adhdevDir, { recursive: true, force: true });
+        fs22.rmSync(adhdevDir, { recursive: true, force: true });
         console.log(source_default.green("  \u2713 Data wiped."));
       } catch (e) {
         console.log(source_default.red(`  \u2717 Failed to delete ~/.adhdev: ${e.message}`));
@@ -91773,11 +91888,11 @@ init_source();
 init_src();
 
 // src/cli/runtime-tools.ts
-var fs24 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 function defaultPackageRoot() {
-  const currentCliPath = process.argv[1] ? fs24.realpathSync.native(process.argv[1]) : process.cwd();
-  return path31.resolve(path31.dirname(currentCliPath), "../..");
+  const currentCliPath = process.argv[1] ? fs19.realpathSync.native(process.argv[1]) : process.cwd();
+  return path30.resolve(path30.dirname(currentCliPath), "../..");
 }
 function normalizePath2(value) {
   return value.replace(/\\/g, "/").toLowerCase();
@@ -91786,19 +91901,19 @@ function shouldPreferSource(currentCliPath, packageRoot) {
   const normalizedCliPath = normalizePath2(currentCliPath || "");
   if (normalizedCliPath.includes("/src/cli/")) return true;
   if (normalizedCliPath.includes("/dist/cli/")) return false;
-  return fs24.existsSync(path31.join(packageRoot, "src", "cli", "index.ts"));
+  return fs19.existsSync(path30.join(packageRoot, "src", "cli", "index.ts"));
 }
 function getVendoredToolEntry(packageRoot, tool) {
   if (tool === "session-host-daemon") {
-    return path31.join(packageRoot, "vendor", "session-host-daemon", "index.js");
+    return path30.join(packageRoot, "vendor", "session-host-daemon", "index.js");
   }
-  return path31.join(packageRoot, "vendor", "terminal-mux-cli", "index.js");
+  return path30.join(packageRoot, "vendor", "terminal-mux-cli", "index.js");
 }
 function getSourceToolEntry(packageRoot, tool) {
   if (tool === "session-host-daemon") {
-    return path31.resolve(packageRoot, "../../oss/packages/session-host-daemon/src/index.ts");
+    return path30.resolve(packageRoot, "../../oss/packages/session-host-daemon/src/index.ts");
   }
-  return path31.resolve(packageRoot, "../../oss/packages/terminal-mux-cli/src/index.ts");
+  return path30.resolve(packageRoot, "../../oss/packages/terminal-mux-cli/src/index.ts");
 }
 function getGlobalToolCommand(tool) {
   return tool === "session-host-daemon" ? "adhdev-sessiond" : "adhmux";
@@ -91811,7 +91926,7 @@ function resolveRuntimeToolLaunch(tool, context = {}) {
   const vendoredEntry = getVendoredToolEntry(packageRoot, tool);
   const resolutionOrder = preferSource ? ["source", "vendored", "global"] : ["vendored", "source", "global"];
   for (const resolution of resolutionOrder) {
-    if (resolution === "source" && fs24.existsSync(sourceEntry)) {
+    if (resolution === "source" && fs19.existsSync(sourceEntry)) {
       return {
         tool,
         resolvedVia: "source",
@@ -91820,7 +91935,7 @@ function resolveRuntimeToolLaunch(tool, context = {}) {
         env: env3
       };
     }
-    if (resolution === "vendored" && fs24.existsSync(vendoredEntry)) {
+    if (resolution === "vendored" && fs19.existsSync(vendoredEntry)) {
       return {
         tool,
         resolvedVia: "vendored",
@@ -92951,9 +93066,9 @@ function registerDaemonCommands(program2, pkgVersion3) {
 // src/cli/doctor-commands.ts
 init_source();
 var import_child_process15 = require("child_process");
-var fs26 = __toESM(require("fs"));
-var os30 = __toESM(require("os"));
-var path34 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var os29 = __toESM(require("os"));
+var path33 = __toESM(require("path"));
 init_src();
 init_session_host();
 
@@ -93069,33 +93184,33 @@ function buildDoctorAdvice(input) {
 }
 
 // src/cli/service-commands.ts
-var import_node_fs6 = __toESM(require("fs"));
-var import_node_path5 = __toESM(require("path"));
-var import_node_os6 = __toESM(require("os"));
-var import_node_child_process6 = require("child_process");
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
+var import_node_os5 = __toESM(require("os"));
+var import_node_child_process = require("child_process");
 init_source();
 init_src();
 var DEFAULT_LOCAL_DAEMON_HEALTH_TIMEOUT_MS3 = 1500;
 var LAUNCHD_LABEL = "dev.adhf.daemon";
-var ADHDEV_DIR = import_node_path5.default.join(import_node_os6.default.homedir(), ".adhdev");
-var LOG_OUT = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.out");
-var LOG_ERR = import_node_path5.default.join(ADHDEV_DIR, "daemon-launchd.err");
+var ADHDEV_DIR = import_node_path4.default.join(import_node_os5.default.homedir(), ".adhdev");
+var LOG_OUT = import_node_path4.default.join(ADHDEV_DIR, "daemon-launchd.out");
+var LOG_ERR = import_node_path4.default.join(ADHDEV_DIR, "daemon-launchd.err");
 var MAX_LOG_SIZE2 = 10 * 1024 * 1024;
 function getDarwinPlistPath() {
-  return import_node_path5.default.join(import_node_os6.default.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  return import_node_path4.default.join(import_node_os5.default.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
 function getWindowsStartupDir() {
-  const appData = process.env.APPDATA || import_node_path5.default.join(import_node_os6.default.homedir(), "AppData", "Roaming");
-  return import_node_path5.default.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+  const appData = process.env.APPDATA || import_node_path4.default.join(import_node_os5.default.homedir(), "AppData", "Roaming");
+  return import_node_path4.default.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
 }
 function getWindowsVbsPath() {
-  return import_node_path5.default.join(getWindowsStartupDir(), "adhdev-daemon.vbs");
+  return import_node_path4.default.join(getWindowsStartupDir(), "adhdev-daemon.vbs");
 }
 function resolveCliPath() {
-  return import_node_fs6.default.realpathSync(process.argv[1]);
+  return import_node_fs3.default.realpathSync(process.argv[1]);
 }
 function ensureDir(dir) {
-  if (!import_node_fs6.default.existsSync(dir)) import_node_fs6.default.mkdirSync(dir, { recursive: true });
+  if (!import_node_fs3.default.existsSync(dir)) import_node_fs3.default.mkdirSync(dir, { recursive: true });
 }
 async function fetchHealth() {
   const controller = new AbortController();
@@ -93113,12 +93228,12 @@ async function fetchHealth() {
 function getProcessInfo(pid) {
   try {
     if (process.platform === "win32") {
-      const out = (0, import_node_child_process6.execSync)(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: "utf-8" });
+      const out = (0, import_node_child_process.execSync)(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: "utf-8" });
       const match = out.match(/"(\d[\d,]+)\sK"/);
       const memKB = match ? parseInt(match[1].replace(/,/g, ""), 10) : 0;
       return { uptime: "-", memMB: Math.round(memKB / 1024) };
     } else {
-      const out = (0, import_node_child_process6.execSync)(`ps -o etime=,rss= -p ${pid}`, { encoding: "utf-8" }).trim();
+      const out = (0, import_node_child_process.execSync)(`ps -o etime=,rss= -p ${pid}`, { encoding: "utf-8" }).trim();
       const parts = out.split(/\s+/);
       const etime = parts[0] || "-";
       const rssKB = parseInt(parts[1] || "0", 10);
@@ -93137,13 +93252,13 @@ function formatElapsed(etime) {
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (!import_node_fs6.default.existsSync(logPath)) return;
-    const stat4 = import_node_fs6.default.statSync(logPath);
+    if (!import_node_fs3.default.existsSync(logPath)) return;
+    const stat4 = import_node_fs3.default.statSync(logPath);
     if (stat4.size > MAX_LOG_SIZE2) {
       const rotated = logPath + ".old";
-      if (import_node_fs6.default.existsSync(rotated)) import_node_fs6.default.unlinkSync(rotated);
-      import_node_fs6.default.renameSync(logPath, rotated);
-      import_node_fs6.default.writeFileSync(logPath, `[log rotated at ${(/* @__PURE__ */ new Date()).toISOString()}]
+      if (import_node_fs3.default.existsSync(rotated)) import_node_fs3.default.unlinkSync(rotated);
+      import_node_fs3.default.renameSync(logPath, rotated);
+      import_node_fs3.default.writeFileSync(logPath, `[log rotated at ${(/* @__PURE__ */ new Date()).toISOString()}]
 `, "utf-8");
     }
   } catch {
@@ -93154,8 +93269,8 @@ function rotateLogs() {
   rotateLogIfNeeded(LOG_ERR);
 }
 function buildPlist(nodeExe, cliExe) {
-  const brewPrefix = import_node_fs6.default.existsSync("/opt/homebrew/bin") ? "/opt/homebrew/bin" : "/usr/local/bin";
-  const nodeDir = import_node_path5.default.dirname(nodeExe);
+  const brewPrefix = import_node_fs3.default.existsSync("/opt/homebrew/bin") ? "/opt/homebrew/bin" : "/usr/local/bin";
+  const nodeDir = import_node_path4.default.dirname(nodeExe);
   const pathEntries = /* @__PURE__ */ new Set([nodeDir, brewPrefix, "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]);
   const pathValue = Array.from(pathEntries).join(":");
   return `<?xml version="1.0" encoding="UTF-8"?>
@@ -93194,15 +93309,15 @@ function buildPlist(nodeExe, cliExe) {
 function installDarwin(nodeExe, cliExe) {
   const plistPath = getDarwinPlistPath();
   ensureDir(ADHDEV_DIR);
-  ensureDir(import_node_path5.default.dirname(plistPath));
-  import_node_fs6.default.writeFileSync(plistPath, buildPlist(nodeExe, cliExe), "utf-8");
+  ensureDir(import_node_path4.default.dirname(plistPath));
+  import_node_fs3.default.writeFileSync(plistPath, buildPlist(nodeExe, cliExe), "utf-8");
   console.log(source_default.gray(`  Plist: ${plistPath}`));
   try {
-    (0, import_node_child_process6.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+    (0, import_node_child_process.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
   } catch {
   }
   try {
-    (0, import_node_child_process6.execSync)(`launchctl load -w "${plistPath}"`, { stdio: "ignore" });
+    (0, import_node_child_process.execSync)(`launchctl load -w "${plistPath}"`, { stdio: "ignore" });
     console.log(source_default.green("\n  \u2713 Registered as LaunchAgent \u2014 daemon will start on login."));
     console.log(source_default.gray(`  Logs: ~/.adhdev/daemon-launchd.{out,err}`));
   } catch (e) {
@@ -93212,22 +93327,22 @@ function installDarwin(nodeExe, cliExe) {
 }
 function uninstallDarwin() {
   const plistPath = getDarwinPlistPath();
-  if (!import_node_fs6.default.existsSync(plistPath)) {
+  if (!import_node_fs3.default.existsSync(plistPath)) {
     console.log(source_default.yellow("\n  \u26A0 Service is not installed."));
     return;
   }
   try {
-    (0, import_node_child_process6.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+    (0, import_node_child_process.execSync)(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
   } catch {
   }
-  import_node_fs6.default.unlinkSync(plistPath);
+  import_node_fs3.default.unlinkSync(plistPath);
   console.log(source_default.green("\n  \u2713 Removed LaunchAgent. Daemon will no longer auto-start."));
 }
 function isInstalledDarwin() {
-  return import_node_fs6.default.existsSync(getDarwinPlistPath());
+  return import_node_fs3.default.existsSync(getDarwinPlistPath());
 }
 function buildVbs(nodeExe, cliExe) {
-  const logFile = import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log").replace(/\\/g, "\\\\");
+  const logFile = import_node_path4.default.join(ADHDEV_DIR, "daemon-service.log").replace(/\\/g, "\\\\");
   const escapedNodeExe = nodeExe.replace(/\\/g, "\\\\");
   const escapedCliExe = cliExe.replace(/\\/g, "\\\\");
   return `' ADHDev Daemon Auto-Start (generated by adhdev service install)
@@ -93238,39 +93353,39 @@ WshShell.Run "cmd.exe /c """"${escapedNodeExe}"""" """"${escapedCliExe}"""" daem
 function installWindows(nodeExe, cliExe) {
   const vbsPath = getWindowsVbsPath();
   ensureDir(ADHDEV_DIR);
-  ensureDir(import_node_path5.default.dirname(vbsPath));
-  import_node_fs6.default.writeFileSync(vbsPath, buildVbs(nodeExe, cliExe), "utf-8");
+  ensureDir(import_node_path4.default.dirname(vbsPath));
+  import_node_fs3.default.writeFileSync(vbsPath, buildVbs(nodeExe, cliExe), "utf-8");
   console.log(source_default.gray(`  Startup script: ${vbsPath}`));
   console.log(source_default.green("\n  \u2713 Registered in Startup folder \u2014 daemon will start on login (hidden)."));
-  console.log(source_default.gray(`  Logs: ${import_node_path5.default.join(ADHDEV_DIR, "daemon-service.log")}`));
+  console.log(source_default.gray(`  Logs: ${import_node_path4.default.join(ADHDEV_DIR, "daemon-service.log")}`));
   console.log(source_default.gray("  To start now without rebooting, run: adhdev daemon"));
 }
 function uninstallWindows() {
   const vbsPath = getWindowsVbsPath();
-  if (!import_node_fs6.default.existsSync(vbsPath)) {
+  if (!import_node_fs3.default.existsSync(vbsPath)) {
     console.log(source_default.yellow("\n  \u26A0 Service is not installed."));
     return;
   }
-  import_node_fs6.default.unlinkSync(vbsPath);
+  import_node_fs3.default.unlinkSync(vbsPath);
   console.log(source_default.green("\n  \u2713 Removed Startup script. Daemon will no longer auto-start."));
   console.log(source_default.gray("  Note: a currently running daemon is not affected. Stop with: adhdev daemon:stop"));
 }
 function isInstalledWindows() {
-  return import_node_fs6.default.existsSync(getWindowsVbsPath());
+  return import_node_fs3.default.existsSync(getWindowsVbsPath());
 }
 function registerServiceCommands(program2) {
   const svc = program2.command("service").description("\u{1F50C} Manage ADHDev as an OS background auto-start service");
   svc.command("install").description("Register ADHDev daemon to start automatically on login").action(async () => {
     console.log(source_default.bold("\n  \u{1F680} Installing ADHDev Background Service"));
-    const platform13 = import_node_os6.default.platform();
+    const platform12 = import_node_os5.default.platform();
     const nodeExe = process.execPath;
     const cliExe = resolveCliPath();
     console.log(source_default.gray(`  Node:     ${nodeExe}`));
     console.log(source_default.gray(`  CLI:      ${cliExe}`));
-    console.log(source_default.gray(`  Platform: ${platform13}`));
-    if (platform13 === "darwin") {
+    console.log(source_default.gray(`  Platform: ${platform12}`));
+    if (platform12 === "darwin") {
       installDarwin(nodeExe, cliExe);
-    } else if (platform13 === "win32") {
+    } else if (platform12 === "win32") {
       installWindows(nodeExe, cliExe);
     } else {
       console.log(source_default.yellow("\n  \u26A0 Auto-start service install is not supported on this platform."));
@@ -93281,10 +93396,10 @@ function registerServiceCommands(program2) {
   });
   svc.command("uninstall").description("Remove the OS background service").action(async () => {
     console.log(source_default.bold("\n  \u{1F5D1}\uFE0F  Removing ADHDev Background Service"));
-    const platform13 = import_node_os6.default.platform();
-    if (platform13 === "darwin") {
+    const platform12 = import_node_os5.default.platform();
+    if (platform12 === "darwin") {
       uninstallDarwin();
-    } else if (platform13 === "win32") {
+    } else if (platform12 === "win32") {
       uninstallWindows();
     } else {
       console.log(source_default.yellow("\n  \u26A0 Not supported on this platform."));
@@ -93292,11 +93407,11 @@ function registerServiceCommands(program2) {
     console.log();
   });
   svc.command("status").description("Show service installation state and live daemon health").action(async () => {
-    const platform13 = import_node_os6.default.platform();
-    const installed = platform13 === "darwin" ? isInstalledDarwin() : platform13 === "win32" ? isInstalledWindows() : false;
+    const platform12 = import_node_os5.default.platform();
+    const installed = platform12 === "darwin" ? isInstalledDarwin() : platform12 === "win32" ? isInstalledWindows() : false;
     if (installed) {
       console.log(source_default.green("\n  \u2713 Service is installed."));
-      if (platform13 === "darwin") console.log(source_default.gray(`  Plist:  ${getDarwinPlistPath()}`));
+      if (platform12 === "darwin") console.log(source_default.gray(`  Plist:  ${getDarwinPlistPath()}`));
       else console.log(source_default.gray(`  Script: ${getWindowsVbsPath()}`));
     } else {
       console.log(source_default.gray("\n  \u2717 Service is not installed. Run: adhdev service install"));
@@ -93312,8 +93427,8 @@ function registerServiceCommands(program2) {
     } else {
       console.log(source_default.yellow("  \u2717 Daemon is not running."));
     }
-    const outSize = import_node_fs6.default.existsSync(LOG_OUT) ? import_node_fs6.default.statSync(LOG_OUT).size : 0;
-    const errSize = import_node_fs6.default.existsSync(LOG_ERR) ? import_node_fs6.default.statSync(LOG_ERR).size : 0;
+    const outSize = import_node_fs3.default.existsSync(LOG_OUT) ? import_node_fs3.default.statSync(LOG_OUT).size : 0;
+    const errSize = import_node_fs3.default.existsSync(LOG_ERR) ? import_node_fs3.default.statSync(LOG_ERR).size : 0;
     if (outSize > 0 || errSize > 0) {
       console.log(source_default.gray(`  Logs:   stdout ${formatBytes(outSize)}, stderr ${formatBytes(errSize)}`));
     }
@@ -93322,13 +93437,13 @@ function registerServiceCommands(program2) {
   svc.command("logs").description("View daemon service logs").option("--err", "Show stderr log instead of stdout").option("--clear", "Truncate all log files").option("-n, --lines <count>", "Number of lines to show", "30").action(async (options) => {
     if (options.clear) {
       for (const f of [LOG_OUT, LOG_ERR]) {
-        if (import_node_fs6.default.existsSync(f)) import_node_fs6.default.writeFileSync(f, "", "utf-8");
+        if (import_node_fs3.default.existsSync(f)) import_node_fs3.default.writeFileSync(f, "", "utf-8");
       }
       console.log(source_default.green("\n  \u2713 Logs cleared.\n"));
       return;
     }
     const logFile = options.err ? LOG_ERR : LOG_OUT;
-    if (!import_node_fs6.default.existsSync(logFile)) {
+    if (!import_node_fs3.default.existsSync(logFile)) {
       console.log(source_default.gray(`
   No log file found: ${logFile}
 `));
@@ -93338,20 +93453,20 @@ function registerServiceCommands(program2) {
     console.log(source_default.gray(`
   \u2500\u2500 ${options.err ? "stderr" : "stdout"}: ${logFile} (last ${lines} lines) \u2500\u2500
 `));
-    const content = import_node_fs6.default.readFileSync(logFile, "utf-8");
+    const content = import_node_fs3.default.readFileSync(logFile, "utf-8");
     const allLines = content.split("\n");
     const lastLines = allLines.slice(-lines).join("\n");
     if (lastLines.trim()) console.log(lastLines);
     console.log(source_default.gray("\n  (watching for new output, Ctrl+C to stop)\n"));
     let offset = Buffer.byteLength(content, "utf-8");
-    const watcher = import_node_fs6.default.watchFile(logFile, { interval: 500 }, () => {
+    const watcher = import_node_fs3.default.watchFile(logFile, { interval: 500 }, () => {
       try {
-        const stat4 = import_node_fs6.default.statSync(logFile);
+        const stat4 = import_node_fs3.default.statSync(logFile);
         if (stat4.size > offset) {
-          const fd = import_node_fs6.default.openSync(logFile, "r");
+          const fd = import_node_fs3.default.openSync(logFile, "r");
           const buf = Buffer.alloc(stat4.size - offset);
-          import_node_fs6.default.readSync(fd, buf, 0, buf.length, offset);
-          import_node_fs6.default.closeSync(fd);
+          import_node_fs3.default.readSync(fd, buf, 0, buf.length, offset);
+          import_node_fs3.default.closeSync(fd);
           process.stdout.write(buf.toString("utf-8"));
           offset = stat4.size;
         } else if (stat4.size < offset) {
@@ -93361,15 +93476,15 @@ function registerServiceCommands(program2) {
       }
     });
     const cleanup = () => {
-      import_node_fs6.default.unwatchFile(logFile);
+      import_node_fs3.default.unwatchFile(logFile);
       process.exit(0);
     };
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
   });
   svc.command("restart").description("Restart the daemon process (service will auto-relaunch)").action(async () => {
-    const platform13 = import_node_os6.default.platform();
-    const installed = platform13 === "darwin" ? isInstalledDarwin() : platform13 === "win32" ? isInstalledWindows() : false;
+    const platform12 = import_node_os5.default.platform();
+    const installed = platform12 === "darwin" ? isInstalledDarwin() : platform12 === "win32" ? isInstalledWindows() : false;
     if (!installed) {
       console.log(source_default.yellow("\n  \u26A0 Service is not installed. Use `adhdev daemon:restart` for manual restart."));
       console.log(source_default.gray("  Or install the service first: adhdev service install\n"));
@@ -93379,10 +93494,10 @@ function registerServiceCommands(program2) {
     const health = await fetchHealth();
     if (!health?.pid) {
       console.log(source_default.yellow("\n  \u26A0 Daemon is not currently running."));
-      if (platform13 === "darwin") {
+      if (platform12 === "darwin") {
         console.log(source_default.gray("  Starting via launchctl..."));
         try {
-          (0, import_node_child_process6.execSync)(`launchctl start ${LAUNCHD_LABEL}`, { stdio: "ignore" });
+          (0, import_node_child_process.execSync)(`launchctl start ${LAUNCHD_LABEL}`, { stdio: "ignore" });
           console.log(source_default.green("  \u2713 Started.\n"));
         } catch {
           console.log(source_default.red("  \u2717 Failed to start. Check: adhdev service logs --err\n"));
@@ -93400,11 +93515,11 @@ function registerServiceCommands(program2) {
       console.log(source_default.yellow("  Could not send SIGTERM. Process may have already exited."));
     }
     await new Promise((r) => setTimeout(r, 2e3));
-    if (platform13 === "win32") {
+    if (platform12 === "win32") {
       const vbsPath = getWindowsVbsPath();
-      if (import_node_fs6.default.existsSync(vbsPath)) {
+      if (import_node_fs3.default.existsSync(vbsPath)) {
         try {
-          (0, import_node_child_process6.execSync)(`wscript.exe "${vbsPath}"`, { stdio: "ignore", windowsHide: true });
+          (0, import_node_child_process.execSync)(`wscript.exe "${vbsPath}"`, { stdio: "ignore", windowsHide: true });
         } catch {
         }
       }
@@ -93436,11 +93551,11 @@ function formatBytes(bytes) {
 
 // src/cli/doctor-commands.ts
 function resolvePackageRoot() {
-  return path34.resolve(__dirname, "..", "..");
+  return path33.resolve(__dirname, "..", "..");
 }
 function isLinkedInstall(packageRoot) {
-  const normalized = path34.normalize(packageRoot);
-  return !normalized.includes(`${path34.sep}node_modules${path34.sep}adhdev`);
+  const normalized = path33.normalize(packageRoot);
+  return !normalized.includes(`${path33.sep}node_modules${path33.sep}adhdev`);
 }
 function formatCheck(check2) {
   const icon = check2.ok ? source_default.green("\u2713") : source_default.red("\u2717");
@@ -93524,11 +93639,11 @@ function probeSharpRuntime(packageRoot, nativeSharpPackage) {
   }
 }
 function probeConfigAccess() {
-  const configDir = path34.join(os30.homedir(), ".adhdev");
-  const configPath = path34.join(configDir, "config.json");
+  const configDir = path33.join(os29.homedir(), ".adhdev");
+  const configPath = path33.join(configDir, "config.json");
   const checks = [];
   try {
-    fs26.mkdirSync(configDir, { recursive: true });
+    fs21.mkdirSync(configDir, { recursive: true });
     checks.push({
       label: "Config directory",
       ok: true,
@@ -93543,8 +93658,8 @@ function probeConfigAccess() {
     }];
   }
   try {
-    if (fs26.existsSync(configPath)) {
-      fs26.readFileSync(configPath, "utf-8");
+    if (fs21.existsSync(configPath)) {
+      fs21.readFileSync(configPath, "utf-8");
       checks.push({
         label: "Config file",
         ok: true,
@@ -93565,10 +93680,10 @@ function probeConfigAccess() {
       fatal: true
     });
   }
-  const probePath = path34.join(configDir, `.doctor-write-${process.pid}-${Date.now()}.tmp`);
+  const probePath = path33.join(configDir, `.doctor-write-${process.pid}-${Date.now()}.tmp`);
   try {
-    fs26.writeFileSync(probePath, "ok", "utf-8");
-    fs26.rmSync(probePath, { force: true });
+    fs21.writeFileSync(probePath, "ok", "utf-8");
+    fs21.rmSync(probePath, { force: true });
     checks.push({
       label: "Config write",
       ok: true,
@@ -93576,7 +93691,7 @@ function probeConfigAccess() {
     });
   } catch (error48) {
     try {
-      fs26.rmSync(probePath, { force: true });
+      fs21.rmSync(probePath, { force: true });
     } catch {
     }
     checks.push({
@@ -93632,9 +93747,9 @@ function probeCliBinary(commandPath, currentVersion) {
   return probe;
 }
 function readLogHints(logPath) {
-  if (!fs26.existsSync(logPath)) return [];
+  if (!fs21.existsSync(logPath)) return [];
   try {
-    const content = fs26.readFileSync(logPath, "utf-8");
+    const content = fs21.readFileSync(logPath, "utf-8");
     const lines = content.split(/\r?\n/);
     const recent = lines.slice(-400);
     const hits = recent.filter(
@@ -93648,11 +93763,11 @@ function readLogHints(logPath) {
 function buildBrowseProbeChecks() {
   const probes = process.platform === "win32" ? [
     process.env.SystemDrive ? `${process.env.SystemDrive.replace(/[\\/]+$/, "")}\\` : "C:\\",
-    os30.homedir()
-  ] : ["/", os30.homedir()];
+    os29.homedir()
+  ] : ["/", os29.homedir()];
   return probes.map((probePath, index) => {
     try {
-      const entries = fs26.readdirSync(probePath, { withFileTypes: true });
+      const entries = fs21.readdirSync(probePath, { withFileTypes: true });
       const directoryCount = entries.filter((entry) => entry.isDirectory()).length;
       return {
         label: index === 0 ? "Folder browse root" : "Folder browse home",
@@ -93672,7 +93787,7 @@ function buildBrowseProbeChecks() {
 function registerDoctorCommands(program2, pkgVersion3) {
   program2.command("doctor").description("Diagnose install, native dependencies, CLI resolution, and folder browse access").action(async () => {
     const packageRoot = resolvePackageRoot();
-    const cliPath = fs26.realpathSync(process.argv[1]);
+    const cliPath = fs21.realpathSync(process.argv[1]);
     const linked = isLinkedInstall(packageRoot);
     const logPath = getCurrentDaemonLogPath();
     const claudePaths = findCommandPaths("claude");
@@ -93754,12 +93869,12 @@ function registerDoctorCommands(program2, pkgVersion3) {
       });
     }
     if (process.platform === "darwin") {
-      serviceDefinitionPath = path34.join(os30.homedir(), "Library", "LaunchAgents", "dev.adhf.daemon.plist");
-      if (fs26.existsSync(serviceDefinitionPath)) {
+      serviceDefinitionPath = path33.join(os29.homedir(), "Library", "LaunchAgents", "dev.adhf.daemon.plist");
+      if (fs21.existsSync(serviceDefinitionPath)) {
         serviceDefinitionCheck = evaluateServiceDefinitionDrift({
           serviceKind: "launchd",
           servicePath: serviceDefinitionPath,
-          installedDefinition: fs26.readFileSync(serviceDefinitionPath, "utf8"),
+          installedDefinition: fs21.readFileSync(serviceDefinitionPath, "utf8"),
           expectedDefinition: buildPlist(process.execPath, cliPath)
         });
         checks.push({
@@ -93827,12 +93942,12 @@ function registerDoctorCommands(program2, pkgVersion3) {
       serviceCheck: serviceDefinitionCheck || void 0,
       sourceCliExample: "node --import tsx packages/daemon-cloud/src/cli/index.ts doctor"
     });
-    const sessionHostLogPath = path34.join(os30.homedir(), ".adhdev", "logs", "session-host.log");
+    const sessionHostLogPath = path33.join(os29.homedir(), ".adhdev", "logs", "session-host.log");
     console.log(source_default.bold("\n\u{1FA7A} ADHDev Doctor\n"));
     console.log(source_default.gray(`  Version:   ${pkgVersion3}`));
     console.log(source_default.gray(`  Platform:  ${process.platform} ${process.arch}`));
     console.log(source_default.gray(`  Node:      ${process.version}`));
-    console.log(source_default.gray(`  Home:      ${os30.homedir()}`));
+    console.log(source_default.gray(`  Home:      ${os29.homedir()}`));
     console.log(source_default.gray(`  Log file:  ${logPath}`));
     console.log(source_default.gray(`  SH log:    ${sessionHostLogPath}`));
     console.log();
@@ -93869,7 +93984,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
 
 // src/cli/provider-commands.ts
 init_source();
-var path35 = __toESM(require("path"));
+var path34 = __toESM(require("path"));
 init_cdp_utils();
 var DEV_SERVER_PORT3 = 19280;
 var IDE_AUTO_FIX_FUNCTIONS = [
@@ -93952,7 +94067,7 @@ function getProviderSourceCandidatePaths(options) {
   const results = [];
   for (const root of roots) {
     for (const name of relativeNames) {
-      results.push(path35.join(root, options.category, options.type, name));
+      results.push(path34.join(root, options.category, options.type, name));
     }
   }
   return results;
@@ -94087,35 +94202,35 @@ function registerProviderCommands(program2) {
       let osPaths = {};
       let processNames = {};
       if (category === "ide") {
-        const fs27 = await import("fs");
-        const path36 = await import("path");
-        const os31 = await import("os");
-        if (os31.platform() === "darwin") {
+        const fs22 = await import("fs");
+        const path35 = await import("path");
+        const os30 = await import("os");
+        if (os30.platform() === "darwin") {
           while (true) {
             const p = (await rl.question(`macOS Application Path (e.g. /Applications/${defaultName}.app): `)).trim() || `/Applications/${defaultName}.app`;
             if (p === "skip") break;
-            if (!fs27.existsSync(p)) {
+            if (!fs22.existsSync(p)) {
               console.log(source_default.red(`  \u2717 Path not found: ${p}`));
               console.log(source_default.gray(`    (Please provide the exact absolute path to the .app or binary, or type 'skip')`));
               continue;
             }
             console.log(source_default.green(`  \u2713 Path verified: ${p}`));
             osPaths["darwin"] = [p];
-            processNames["darwin"] = path36.basename(p, ".app");
+            processNames["darwin"] = path35.basename(p, ".app");
             break;
           }
-        } else if (os31.platform() === "win32") {
+        } else if (os30.platform() === "win32") {
           while (true) {
             const p = (await rl.question(`Windows Executable Path (e.g. C:\\Program Files\\${defaultName}\\${defaultName}.exe): `)).trim();
             if (!p || p === "skip") break;
-            if (!fs27.existsSync(p)) {
+            if (!fs22.existsSync(p)) {
               console.log(source_default.red(`  \u2717 Path not found: ${p}`));
               console.log(source_default.gray(`    (Please provide the exact absolute path, or type 'skip')`));
               continue;
             }
             console.log(source_default.green(`  \u2713 Path verified: ${p}`));
             osPaths["win32"] = [p];
-            processNames["win32"] = path36.basename(p, ".exe");
+            processNames["win32"] = path35.basename(p, ".exe");
             break;
           }
         }
@@ -94802,8 +94917,8 @@ function registerCdpCommands(program2) {
       }
       const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
       if (options.output) {
-        const fs27 = await import("fs");
-        fs27.writeFileSync(options.output, output, "utf-8");
+        const fs22 = await import("fs");
+        fs22.writeFileSync(options.output, output, "utf-8");
         console.log(source_default.green(`
   \u2713 Saved to ${options.output} (${output.length} chars)
 `));
@@ -94906,8 +95021,8 @@ function registerCdpCommands(program2) {
         ws.on("message", async (data) => {
           const msg = JSON.parse(data.toString());
           if (msg.id === 1 && msg.result?.data) {
-            const fs27 = await import("fs");
-            fs27.writeFileSync(options.output, Buffer.from(msg.result.data, "base64"));
+            const fs22 = await import("fs");
+            fs22.writeFileSync(options.output, Buffer.from(msg.result.data, "base64"));
             console.log(source_default.green(`
   \u2713 Screenshot saved to ${options.output}
 `));